1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Literal<'tree> {
3 BinaryIntegerLiteral(::std::boxed::Box<BinaryIntegerLiteral<'tree>>),
4 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
5 DecimalFloatingPointLiteral(::std::boxed::Box<DecimalFloatingPointLiteral<'tree>>),
6 DecimalIntegerLiteral(::std::boxed::Box<DecimalIntegerLiteral<'tree>>),
7 False(::std::boxed::Box<False<'tree>>),
8 HexFloatingPointLiteral(::std::boxed::Box<HexFloatingPointLiteral<'tree>>),
9 HexIntegerLiteral(::std::boxed::Box<HexIntegerLiteral<'tree>>),
10 NullLiteral(::std::boxed::Box<NullLiteral<'tree>>),
11 OctalIntegerLiteral(::std::boxed::Box<OctalIntegerLiteral<'tree>>),
12 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
13 True(::std::boxed::Box<True<'tree>>),
14}
15impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
16 #[allow(clippy::collapsible_else_if)]
17 fn from_node(
18 node: ::treesitter_types::tree_sitter::Node<'tree>,
19 src: &'tree [u8],
20 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
21 match node.kind() {
22 "binary_integer_literal" => Ok(Self::BinaryIntegerLiteral(::std::boxed::Box::new(
23 ::treesitter_types::runtime::maybe_grow_stack(|| {
24 <BinaryIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
25 })?,
26 ))),
27 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
28 ::treesitter_types::runtime::maybe_grow_stack(|| {
29 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
30 })?,
31 ))),
32 "decimal_floating_point_literal" => Ok(Self::DecimalFloatingPointLiteral(
33 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
34 <DecimalFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(
35 node, src,
36 )
37 })?),
38 )),
39 "decimal_integer_literal" => Ok(Self::DecimalIntegerLiteral(::std::boxed::Box::new(
40 ::treesitter_types::runtime::maybe_grow_stack(|| {
41 <DecimalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
42 })?,
43 ))),
44 "false" => Ok(Self::False(::std::boxed::Box::new(
45 ::treesitter_types::runtime::maybe_grow_stack(|| {
46 <False as ::treesitter_types::FromNode>::from_node(node, src)
47 })?,
48 ))),
49 "hex_floating_point_literal" => Ok(Self::HexFloatingPointLiteral(
50 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
51 <HexFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
52 })?),
53 )),
54 "hex_integer_literal" => Ok(Self::HexIntegerLiteral(::std::boxed::Box::new(
55 ::treesitter_types::runtime::maybe_grow_stack(|| {
56 <HexIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
57 })?,
58 ))),
59 "null_literal" => Ok(Self::NullLiteral(::std::boxed::Box::new(
60 ::treesitter_types::runtime::maybe_grow_stack(|| {
61 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
62 })?,
63 ))),
64 "octal_integer_literal" => Ok(Self::OctalIntegerLiteral(::std::boxed::Box::new(
65 ::treesitter_types::runtime::maybe_grow_stack(|| {
66 <OctalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
67 })?,
68 ))),
69 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
70 ::treesitter_types::runtime::maybe_grow_stack(|| {
71 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
72 })?,
73 ))),
74 "true" => Ok(Self::True(::std::boxed::Box::new(
75 ::treesitter_types::runtime::maybe_grow_stack(|| {
76 <True as ::treesitter_types::FromNode>::from_node(node, src)
77 })?,
78 ))),
79 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
80 }
81 }
82}
83impl ::treesitter_types::Spanned for Literal<'_> {
84 fn span(&self) -> ::treesitter_types::Span {
85 match self {
86 Self::BinaryIntegerLiteral(inner) => inner.span(),
87 Self::CharacterLiteral(inner) => inner.span(),
88 Self::DecimalFloatingPointLiteral(inner) => inner.span(),
89 Self::DecimalIntegerLiteral(inner) => inner.span(),
90 Self::False(inner) => inner.span(),
91 Self::HexFloatingPointLiteral(inner) => inner.span(),
92 Self::HexIntegerLiteral(inner) => inner.span(),
93 Self::NullLiteral(inner) => inner.span(),
94 Self::OctalIntegerLiteral(inner) => inner.span(),
95 Self::StringLiteral(inner) => inner.span(),
96 Self::True(inner) => inner.span(),
97 }
98 }
99}
100#[derive(Debug, Clone, PartialEq, Eq)]
101pub enum SimpleType<'tree> {
102 BooleanType(::std::boxed::Box<BooleanType<'tree>>),
103 FloatingPointType(::std::boxed::Box<FloatingPointType<'tree>>),
104 GenericType(::std::boxed::Box<GenericType<'tree>>),
105 IntegralType(::std::boxed::Box<IntegralType<'tree>>),
106 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
107 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
108 VoidType(::std::boxed::Box<VoidType<'tree>>),
109}
110impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleType<'tree> {
111 #[allow(clippy::collapsible_else_if)]
112 fn from_node(
113 node: ::treesitter_types::tree_sitter::Node<'tree>,
114 src: &'tree [u8],
115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
116 match node.kind() {
117 "boolean_type" => Ok(Self::BooleanType(::std::boxed::Box::new(
118 ::treesitter_types::runtime::maybe_grow_stack(|| {
119 <BooleanType as ::treesitter_types::FromNode>::from_node(node, src)
120 })?,
121 ))),
122 "floating_point_type" => Ok(Self::FloatingPointType(::std::boxed::Box::new(
123 ::treesitter_types::runtime::maybe_grow_stack(|| {
124 <FloatingPointType as ::treesitter_types::FromNode>::from_node(node, src)
125 })?,
126 ))),
127 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
128 ::treesitter_types::runtime::maybe_grow_stack(|| {
129 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
130 })?,
131 ))),
132 "integral_type" => Ok(Self::IntegralType(::std::boxed::Box::new(
133 ::treesitter_types::runtime::maybe_grow_stack(|| {
134 <IntegralType as ::treesitter_types::FromNode>::from_node(node, src)
135 })?,
136 ))),
137 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
138 ::treesitter_types::runtime::maybe_grow_stack(|| {
139 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
140 })?,
141 ))),
142 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
143 ::treesitter_types::runtime::maybe_grow_stack(|| {
144 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
145 })?,
146 ))),
147 "void_type" => Ok(Self::VoidType(::std::boxed::Box::new(
148 ::treesitter_types::runtime::maybe_grow_stack(|| {
149 <VoidType as ::treesitter_types::FromNode>::from_node(node, src)
150 })?,
151 ))),
152 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
153 }
154 }
155}
156impl ::treesitter_types::Spanned for SimpleType<'_> {
157 fn span(&self) -> ::treesitter_types::Span {
158 match self {
159 Self::BooleanType(inner) => inner.span(),
160 Self::FloatingPointType(inner) => inner.span(),
161 Self::GenericType(inner) => inner.span(),
162 Self::IntegralType(inner) => inner.span(),
163 Self::ScopedTypeIdentifier(inner) => inner.span(),
164 Self::TypeIdentifier(inner) => inner.span(),
165 Self::VoidType(inner) => inner.span(),
166 }
167 }
168}
169#[derive(Debug, Clone, PartialEq, Eq)]
170pub enum Type<'tree> {
171 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
172 AnnotatedType(::std::boxed::Box<AnnotatedType<'tree>>),
173}
174impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
175 #[allow(clippy::collapsible_else_if)]
176 fn from_node(
177 node: ::treesitter_types::tree_sitter::Node<'tree>,
178 src: &'tree [u8],
179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
180 match node.kind() {
181 "annotated_type" => Ok(Self::AnnotatedType(::std::boxed::Box::new(
182 ::treesitter_types::runtime::maybe_grow_stack(|| {
183 <AnnotatedType as ::treesitter_types::FromNode>::from_node(node, src)
184 })?,
185 ))),
186 _other => {
187 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
188 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
189 }) {
190 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
191 } else {
192 Err(::treesitter_types::ParseError::unexpected_kind(
193 _other, node,
194 ))
195 }
196 }
197 }
198 }
199}
200impl ::treesitter_types::Spanned for Type<'_> {
201 fn span(&self) -> ::treesitter_types::Span {
202 match self {
203 Self::UnannotatedType(inner) => inner.span(),
204 Self::AnnotatedType(inner) => inner.span(),
205 }
206 }
207}
208#[derive(Debug, Clone, PartialEq, Eq)]
209pub enum UnannotatedType<'tree> {
210 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
211 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
212}
213impl<'tree> ::treesitter_types::FromNode<'tree> for UnannotatedType<'tree> {
214 #[allow(clippy::collapsible_else_if)]
215 fn from_node(
216 node: ::treesitter_types::tree_sitter::Node<'tree>,
217 src: &'tree [u8],
218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
219 match node.kind() {
220 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
221 ::treesitter_types::runtime::maybe_grow_stack(|| {
222 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
223 })?,
224 ))),
225 _other => {
226 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
227 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
228 }) {
229 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
230 } else {
231 Err(::treesitter_types::ParseError::unexpected_kind(
232 _other, node,
233 ))
234 }
235 }
236 }
237 }
238}
239impl ::treesitter_types::Spanned for UnannotatedType<'_> {
240 fn span(&self) -> ::treesitter_types::Span {
241 match self {
242 Self::SimpleType(inner) => inner.span(),
243 Self::ArrayType(inner) => inner.span(),
244 }
245 }
246}
247#[derive(Debug, Clone, PartialEq, Eq)]
248pub enum Declaration<'tree> {
249 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
250 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
251 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
252 ImportDeclaration(::std::boxed::Box<ImportDeclaration<'tree>>),
253 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
254 ModuleDeclaration(::std::boxed::Box<ModuleDeclaration<'tree>>),
255 PackageDeclaration(::std::boxed::Box<PackageDeclaration<'tree>>),
256 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
257}
258impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
259 #[allow(clippy::collapsible_else_if)]
260 fn from_node(
261 node: ::treesitter_types::tree_sitter::Node<'tree>,
262 src: &'tree [u8],
263 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
264 match node.kind() {
265 "annotation_type_declaration" => Ok(Self::AnnotationTypeDeclaration(
266 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
267 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
268 node, src,
269 )
270 })?),
271 )),
272 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
273 ::treesitter_types::runtime::maybe_grow_stack(|| {
274 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
275 })?,
276 ))),
277 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
278 ::treesitter_types::runtime::maybe_grow_stack(|| {
279 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
280 })?,
281 ))),
282 "import_declaration" => Ok(Self::ImportDeclaration(::std::boxed::Box::new(
283 ::treesitter_types::runtime::maybe_grow_stack(|| {
284 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
285 })?,
286 ))),
287 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
288 ::treesitter_types::runtime::maybe_grow_stack(|| {
289 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
290 })?,
291 ))),
292 "module_declaration" => Ok(Self::ModuleDeclaration(::std::boxed::Box::new(
293 ::treesitter_types::runtime::maybe_grow_stack(|| {
294 <ModuleDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
295 })?,
296 ))),
297 "package_declaration" => Ok(Self::PackageDeclaration(::std::boxed::Box::new(
298 ::treesitter_types::runtime::maybe_grow_stack(|| {
299 <PackageDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
300 })?,
301 ))),
302 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
303 ::treesitter_types::runtime::maybe_grow_stack(|| {
304 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
305 })?,
306 ))),
307 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
308 }
309 }
310}
311impl ::treesitter_types::Spanned for Declaration<'_> {
312 fn span(&self) -> ::treesitter_types::Span {
313 match self {
314 Self::AnnotationTypeDeclaration(inner) => inner.span(),
315 Self::ClassDeclaration(inner) => inner.span(),
316 Self::EnumDeclaration(inner) => inner.span(),
317 Self::ImportDeclaration(inner) => inner.span(),
318 Self::InterfaceDeclaration(inner) => inner.span(),
319 Self::ModuleDeclaration(inner) => inner.span(),
320 Self::PackageDeclaration(inner) => inner.span(),
321 Self::RecordDeclaration(inner) => inner.span(),
322 }
323 }
324}
325#[derive(Debug, Clone, PartialEq, Eq)]
326pub enum Expression<'tree> {
327 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
328 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
329 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
330 InstanceofExpression(::std::boxed::Box<InstanceofExpression<'tree>>),
331 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
332 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
333 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
334 TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
335 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
336 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
337}
338impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
339 #[allow(clippy::collapsible_else_if)]
340 fn from_node(
341 node: ::treesitter_types::tree_sitter::Node<'tree>,
342 src: &'tree [u8],
343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
344 match node.kind() {
345 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
346 ::treesitter_types::runtime::maybe_grow_stack(|| {
347 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
348 })?,
349 ))),
350 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
351 ::treesitter_types::runtime::maybe_grow_stack(|| {
352 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
353 })?,
354 ))),
355 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
356 ::treesitter_types::runtime::maybe_grow_stack(|| {
357 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
358 })?,
359 ))),
360 "instanceof_expression" => Ok(Self::InstanceofExpression(::std::boxed::Box::new(
361 ::treesitter_types::runtime::maybe_grow_stack(|| {
362 <InstanceofExpression as ::treesitter_types::FromNode>::from_node(node, src)
363 })?,
364 ))),
365 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
366 ::treesitter_types::runtime::maybe_grow_stack(|| {
367 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
368 })?,
369 ))),
370 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
371 ::treesitter_types::runtime::maybe_grow_stack(|| {
372 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
373 })?,
374 ))),
375 "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
376 ::treesitter_types::runtime::maybe_grow_stack(|| {
377 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
378 })?,
379 ))),
380 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
381 ::treesitter_types::runtime::maybe_grow_stack(|| {
382 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
383 })?,
384 ))),
385 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
386 ::treesitter_types::runtime::maybe_grow_stack(|| {
387 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
388 })?,
389 ))),
390 _other => {
391 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
392 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
393 }) {
394 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
395 } else {
396 Err(::treesitter_types::ParseError::unexpected_kind(
397 _other, node,
398 ))
399 }
400 }
401 }
402 }
403}
404impl ::treesitter_types::Spanned for Expression<'_> {
405 fn span(&self) -> ::treesitter_types::Span {
406 match self {
407 Self::AssignmentExpression(inner) => inner.span(),
408 Self::BinaryExpression(inner) => inner.span(),
409 Self::CastExpression(inner) => inner.span(),
410 Self::InstanceofExpression(inner) => inner.span(),
411 Self::LambdaExpression(inner) => inner.span(),
412 Self::PrimaryExpression(inner) => inner.span(),
413 Self::SwitchExpression(inner) => inner.span(),
414 Self::TernaryExpression(inner) => inner.span(),
415 Self::UnaryExpression(inner) => inner.span(),
416 Self::UpdateExpression(inner) => inner.span(),
417 }
418 }
419}
420#[derive(Debug, Clone, PartialEq, Eq)]
421pub enum ModuleDirective<'tree> {
422 ExportsModuleDirective(::std::boxed::Box<ExportsModuleDirective<'tree>>),
423 OpensModuleDirective(::std::boxed::Box<OpensModuleDirective<'tree>>),
424 ProvidesModuleDirective(::std::boxed::Box<ProvidesModuleDirective<'tree>>),
425 RequiresModuleDirective(::std::boxed::Box<RequiresModuleDirective<'tree>>),
426 UsesModuleDirective(::std::boxed::Box<UsesModuleDirective<'tree>>),
427}
428impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDirective<'tree> {
429 #[allow(clippy::collapsible_else_if)]
430 fn from_node(
431 node: ::treesitter_types::tree_sitter::Node<'tree>,
432 src: &'tree [u8],
433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
434 match node.kind() {
435 "exports_module_directive" => Ok(Self::ExportsModuleDirective(::std::boxed::Box::new(
436 ::treesitter_types::runtime::maybe_grow_stack(|| {
437 <ExportsModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
438 })?,
439 ))),
440 "opens_module_directive" => Ok(Self::OpensModuleDirective(::std::boxed::Box::new(
441 ::treesitter_types::runtime::maybe_grow_stack(|| {
442 <OpensModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
443 })?,
444 ))),
445 "provides_module_directive" => Ok(Self::ProvidesModuleDirective(
446 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
447 <ProvidesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
448 })?),
449 )),
450 "requires_module_directive" => Ok(Self::RequiresModuleDirective(
451 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
452 <RequiresModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
453 })?),
454 )),
455 "uses_module_directive" => Ok(Self::UsesModuleDirective(::std::boxed::Box::new(
456 ::treesitter_types::runtime::maybe_grow_stack(|| {
457 <UsesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
458 })?,
459 ))),
460 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
461 }
462 }
463}
464impl ::treesitter_types::Spanned for ModuleDirective<'_> {
465 fn span(&self) -> ::treesitter_types::Span {
466 match self {
467 Self::ExportsModuleDirective(inner) => inner.span(),
468 Self::OpensModuleDirective(inner) => inner.span(),
469 Self::ProvidesModuleDirective(inner) => inner.span(),
470 Self::RequiresModuleDirective(inner) => inner.span(),
471 Self::UsesModuleDirective(inner) => inner.span(),
472 }
473 }
474}
475#[derive(Debug, Clone, PartialEq, Eq)]
476pub enum PrimaryExpression<'tree> {
477 Literal(::std::boxed::Box<Literal<'tree>>),
478 ArrayAccess(::std::boxed::Box<ArrayAccess<'tree>>),
479 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
480 ClassLiteral(::std::boxed::Box<ClassLiteral<'tree>>),
481 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
482 Identifier(::std::boxed::Box<Identifier<'tree>>),
483 MethodInvocation(::std::boxed::Box<MethodInvocation<'tree>>),
484 MethodReference(::std::boxed::Box<MethodReference<'tree>>),
485 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
486 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
487 TemplateExpression(::std::boxed::Box<TemplateExpression<'tree>>),
488 This(::std::boxed::Box<This<'tree>>),
489}
490impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
491 #[allow(clippy::collapsible_else_if)]
492 fn from_node(
493 node: ::treesitter_types::tree_sitter::Node<'tree>,
494 src: &'tree [u8],
495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
496 match node.kind() {
497 "array_access" => Ok(Self::ArrayAccess(::std::boxed::Box::new(
498 ::treesitter_types::runtime::maybe_grow_stack(|| {
499 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)
500 })?,
501 ))),
502 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
503 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
504 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
505 })?),
506 )),
507 "class_literal" => Ok(Self::ClassLiteral(::std::boxed::Box::new(
508 ::treesitter_types::runtime::maybe_grow_stack(|| {
509 <ClassLiteral as ::treesitter_types::FromNode>::from_node(node, src)
510 })?,
511 ))),
512 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
513 ::treesitter_types::runtime::maybe_grow_stack(|| {
514 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
515 })?,
516 ))),
517 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
518 ::treesitter_types::runtime::maybe_grow_stack(|| {
519 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
520 })?,
521 ))),
522 "method_invocation" => Ok(Self::MethodInvocation(::std::boxed::Box::new(
523 ::treesitter_types::runtime::maybe_grow_stack(|| {
524 <MethodInvocation as ::treesitter_types::FromNode>::from_node(node, src)
525 })?,
526 ))),
527 "method_reference" => Ok(Self::MethodReference(::std::boxed::Box::new(
528 ::treesitter_types::runtime::maybe_grow_stack(|| {
529 <MethodReference as ::treesitter_types::FromNode>::from_node(node, src)
530 })?,
531 ))),
532 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
533 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
534 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
535 })?),
536 )),
537 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
538 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
539 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
540 })?),
541 )),
542 "template_expression" => Ok(Self::TemplateExpression(::std::boxed::Box::new(
543 ::treesitter_types::runtime::maybe_grow_stack(|| {
544 <TemplateExpression as ::treesitter_types::FromNode>::from_node(node, src)
545 })?,
546 ))),
547 "this" => Ok(Self::This(::std::boxed::Box::new(
548 ::treesitter_types::runtime::maybe_grow_stack(|| {
549 <This as ::treesitter_types::FromNode>::from_node(node, src)
550 })?,
551 ))),
552 _other => {
553 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
554 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
555 }) {
556 Ok(Self::Literal(::std::boxed::Box::new(v)))
557 } else {
558 Err(::treesitter_types::ParseError::unexpected_kind(
559 _other, node,
560 ))
561 }
562 }
563 }
564 }
565}
566impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
567 fn span(&self) -> ::treesitter_types::Span {
568 match self {
569 Self::Literal(inner) => inner.span(),
570 Self::ArrayAccess(inner) => inner.span(),
571 Self::ArrayCreationExpression(inner) => inner.span(),
572 Self::ClassLiteral(inner) => inner.span(),
573 Self::FieldAccess(inner) => inner.span(),
574 Self::Identifier(inner) => inner.span(),
575 Self::MethodInvocation(inner) => inner.span(),
576 Self::MethodReference(inner) => inner.span(),
577 Self::ObjectCreationExpression(inner) => inner.span(),
578 Self::ParenthesizedExpression(inner) => inner.span(),
579 Self::TemplateExpression(inner) => inner.span(),
580 Self::This(inner) => inner.span(),
581 }
582 }
583}
584#[derive(Debug, Clone, PartialEq, Eq)]
585pub enum Statement<'tree> {
586 Semicolon(::treesitter_types::Span),
587 AssertStatement(::std::boxed::Box<AssertStatement<'tree>>),
588 Block(::std::boxed::Box<Block<'tree>>),
589 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
590 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
591 Declaration(::std::boxed::Box<Declaration<'tree>>),
592 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
593 EnhancedForStatement(::std::boxed::Box<EnhancedForStatement<'tree>>),
594 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
595 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
596 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
597 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
598 LocalVariableDeclaration(::std::boxed::Box<LocalVariableDeclaration<'tree>>),
599 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
600 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
601 SynchronizedStatement(::std::boxed::Box<SynchronizedStatement<'tree>>),
602 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
603 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
604 TryWithResourcesStatement(::std::boxed::Box<TryWithResourcesStatement<'tree>>),
605 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
606 YieldStatement(::std::boxed::Box<YieldStatement<'tree>>),
607}
608impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
609 #[allow(clippy::collapsible_else_if)]
610 fn from_node(
611 node: ::treesitter_types::tree_sitter::Node<'tree>,
612 src: &'tree [u8],
613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
614 match node.kind() {
615 ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
616 "assert_statement" => Ok(Self::AssertStatement(::std::boxed::Box::new(
617 ::treesitter_types::runtime::maybe_grow_stack(|| {
618 <AssertStatement as ::treesitter_types::FromNode>::from_node(node, src)
619 })?,
620 ))),
621 "block" => Ok(Self::Block(::std::boxed::Box::new(
622 ::treesitter_types::runtime::maybe_grow_stack(|| {
623 <Block as ::treesitter_types::FromNode>::from_node(node, src)
624 })?,
625 ))),
626 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
627 ::treesitter_types::runtime::maybe_grow_stack(|| {
628 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
629 })?,
630 ))),
631 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
632 ::treesitter_types::runtime::maybe_grow_stack(|| {
633 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
634 })?,
635 ))),
636 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
637 ::treesitter_types::runtime::maybe_grow_stack(|| {
638 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
639 })?,
640 ))),
641 "enhanced_for_statement" => Ok(Self::EnhancedForStatement(::std::boxed::Box::new(
642 ::treesitter_types::runtime::maybe_grow_stack(|| {
643 <EnhancedForStatement as ::treesitter_types::FromNode>::from_node(node, src)
644 })?,
645 ))),
646 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
647 ::treesitter_types::runtime::maybe_grow_stack(|| {
648 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
649 })?,
650 ))),
651 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
652 ::treesitter_types::runtime::maybe_grow_stack(|| {
653 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
654 })?,
655 ))),
656 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
657 ::treesitter_types::runtime::maybe_grow_stack(|| {
658 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
659 })?,
660 ))),
661 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
662 ::treesitter_types::runtime::maybe_grow_stack(|| {
663 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
664 })?,
665 ))),
666 "local_variable_declaration" => Ok(Self::LocalVariableDeclaration(
667 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
668 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
669 })?),
670 )),
671 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
672 ::treesitter_types::runtime::maybe_grow_stack(|| {
673 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
674 })?,
675 ))),
676 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
677 ::treesitter_types::runtime::maybe_grow_stack(|| {
678 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
679 })?,
680 ))),
681 "synchronized_statement" => Ok(Self::SynchronizedStatement(::std::boxed::Box::new(
682 ::treesitter_types::runtime::maybe_grow_stack(|| {
683 <SynchronizedStatement as ::treesitter_types::FromNode>::from_node(node, src)
684 })?,
685 ))),
686 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
687 ::treesitter_types::runtime::maybe_grow_stack(|| {
688 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
689 })?,
690 ))),
691 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
692 ::treesitter_types::runtime::maybe_grow_stack(|| {
693 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
694 })?,
695 ))),
696 "try_with_resources_statement" => Ok(Self::TryWithResourcesStatement(
697 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
698 <TryWithResourcesStatement as ::treesitter_types::FromNode>::from_node(
699 node, src,
700 )
701 })?),
702 )),
703 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
704 ::treesitter_types::runtime::maybe_grow_stack(|| {
705 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
706 })?,
707 ))),
708 "yield_statement" => Ok(Self::YieldStatement(::std::boxed::Box::new(
709 ::treesitter_types::runtime::maybe_grow_stack(|| {
710 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
711 })?,
712 ))),
713 _other => {
714 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
715 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
716 }) {
717 Ok(Self::Declaration(::std::boxed::Box::new(v)))
718 } else {
719 Err(::treesitter_types::ParseError::unexpected_kind(
720 _other, node,
721 ))
722 }
723 }
724 }
725 }
726}
727impl ::treesitter_types::Spanned for Statement<'_> {
728 fn span(&self) -> ::treesitter_types::Span {
729 match self {
730 Self::Semicolon(span) => *span,
731 Self::AssertStatement(inner) => inner.span(),
732 Self::Block(inner) => inner.span(),
733 Self::BreakStatement(inner) => inner.span(),
734 Self::ContinueStatement(inner) => inner.span(),
735 Self::Declaration(inner) => inner.span(),
736 Self::DoStatement(inner) => inner.span(),
737 Self::EnhancedForStatement(inner) => inner.span(),
738 Self::ExpressionStatement(inner) => inner.span(),
739 Self::ForStatement(inner) => inner.span(),
740 Self::IfStatement(inner) => inner.span(),
741 Self::LabeledStatement(inner) => inner.span(),
742 Self::LocalVariableDeclaration(inner) => inner.span(),
743 Self::ReturnStatement(inner) => inner.span(),
744 Self::SwitchExpression(inner) => inner.span(),
745 Self::SynchronizedStatement(inner) => inner.span(),
746 Self::ThrowStatement(inner) => inner.span(),
747 Self::TryStatement(inner) => inner.span(),
748 Self::TryWithResourcesStatement(inner) => inner.span(),
749 Self::WhileStatement(inner) => inner.span(),
750 Self::YieldStatement(inner) => inner.span(),
751 }
752 }
753}
754#[derive(Debug, Clone, PartialEq, Eq)]
755pub struct AnnotatedType<'tree> {
756 pub span: ::treesitter_types::Span,
757 pub children: ::std::vec::Vec<AnnotatedTypeChildren<'tree>>,
758}
759impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotatedType<'tree> {
760 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
761 fn from_node(
762 node: ::treesitter_types::tree_sitter::Node<'tree>,
763 src: &'tree [u8],
764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
765 debug_assert_eq!(node.kind(), "annotated_type");
766 Ok(Self {
767 span: ::treesitter_types::Span::from(node),
768 children: {
769 #[allow(clippy::suspicious_else_formatting)]
770 let non_field_children = {
771 let mut cursor = node.walk();
772 let mut result = ::std::vec::Vec::new();
773 if cursor.goto_first_child() {
774 loop {
775 if cursor.field_name().is_none()
776 && cursor.node().is_named()
777 && !cursor.node().is_extra()
778 {
779 result.push(cursor.node());
780 }
781 if !cursor.goto_next_sibling() {
782 break;
783 }
784 }
785 }
786 result
787 };
788 let mut items = ::std::vec::Vec::new();
789 for child in non_field_children {
790 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
791 <AnnotatedTypeChildren as ::treesitter_types::FromNode>::from_node(
792 child, src,
793 )
794 })?);
795 }
796 items
797 },
798 })
799 }
800}
801impl ::treesitter_types::Spanned for AnnotatedType<'_> {
802 fn span(&self) -> ::treesitter_types::Span {
803 self.span
804 }
805}
806#[derive(Debug, Clone, PartialEq, Eq)]
807pub struct Annotation<'tree> {
808 pub span: ::treesitter_types::Span,
809 pub arguments: AnnotationArgumentList<'tree>,
810 pub name: AnnotationName<'tree>,
811}
812impl<'tree> ::treesitter_types::FromNode<'tree> for Annotation<'tree> {
813 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
814 fn from_node(
815 node: ::treesitter_types::tree_sitter::Node<'tree>,
816 src: &'tree [u8],
817 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
818 debug_assert_eq!(node.kind(), "annotation");
819 Ok(Self {
820 span: ::treesitter_types::Span::from(node),
821 arguments: {
822 let child = node.child_by_field_name("arguments").ok_or_else(|| {
823 ::treesitter_types::ParseError::missing_field("arguments", node)
824 })?;
825 ::treesitter_types::runtime::maybe_grow_stack(|| {
826 <AnnotationArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
827 })?
828 },
829 name: {
830 let child = node
831 .child_by_field_name("name")
832 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
833 ::treesitter_types::runtime::maybe_grow_stack(|| {
834 <AnnotationName as ::treesitter_types::FromNode>::from_node(child, src)
835 })?
836 },
837 })
838 }
839}
840impl ::treesitter_types::Spanned for Annotation<'_> {
841 fn span(&self) -> ::treesitter_types::Span {
842 self.span
843 }
844}
845#[derive(Debug, Clone, PartialEq, Eq)]
846pub struct AnnotationArgumentList<'tree> {
847 pub span: ::treesitter_types::Span,
848 pub children: ::std::vec::Vec<AnnotationArgumentListChildren<'tree>>,
849}
850impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationArgumentList<'tree> {
851 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
852 fn from_node(
853 node: ::treesitter_types::tree_sitter::Node<'tree>,
854 src: &'tree [u8],
855 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
856 debug_assert_eq!(node.kind(), "annotation_argument_list");
857 Ok(Self {
858 span: ::treesitter_types::Span::from(node),
859 children: {
860 #[allow(clippy::suspicious_else_formatting)]
861 let non_field_children = {
862 let mut cursor = node.walk();
863 let mut result = ::std::vec::Vec::new();
864 if cursor.goto_first_child() {
865 loop {
866 if cursor.field_name().is_none()
867 && cursor.node().is_named()
868 && !cursor.node().is_extra()
869 {
870 result.push(cursor.node());
871 }
872 if !cursor.goto_next_sibling() {
873 break;
874 }
875 }
876 }
877 result
878 };
879 let mut items = ::std::vec::Vec::new();
880 for child in non_field_children {
881 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
882 <AnnotationArgumentListChildren as ::treesitter_types::FromNode>::from_node(
883 child, src,
884 )
885 })?);
886 }
887 items
888 },
889 })
890 }
891}
892impl ::treesitter_types::Spanned for AnnotationArgumentList<'_> {
893 fn span(&self) -> ::treesitter_types::Span {
894 self.span
895 }
896}
897#[derive(Debug, Clone, PartialEq, Eq)]
898pub struct AnnotationTypeBody<'tree> {
899 pub span: ::treesitter_types::Span,
900 pub children: ::std::vec::Vec<AnnotationTypeBodyChildren<'tree>>,
901}
902impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeBody<'tree> {
903 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
904 fn from_node(
905 node: ::treesitter_types::tree_sitter::Node<'tree>,
906 src: &'tree [u8],
907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
908 debug_assert_eq!(node.kind(), "annotation_type_body");
909 Ok(Self {
910 span: ::treesitter_types::Span::from(node),
911 children: {
912 #[allow(clippy::suspicious_else_formatting)]
913 let non_field_children = {
914 let mut cursor = node.walk();
915 let mut result = ::std::vec::Vec::new();
916 if cursor.goto_first_child() {
917 loop {
918 if cursor.field_name().is_none()
919 && cursor.node().is_named()
920 && !cursor.node().is_extra()
921 {
922 result.push(cursor.node());
923 }
924 if !cursor.goto_next_sibling() {
925 break;
926 }
927 }
928 }
929 result
930 };
931 let mut items = ::std::vec::Vec::new();
932 for child in non_field_children {
933 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
934 <AnnotationTypeBodyChildren as ::treesitter_types::FromNode>::from_node(
935 child, src,
936 )
937 })?);
938 }
939 items
940 },
941 })
942 }
943}
944impl ::treesitter_types::Spanned for AnnotationTypeBody<'_> {
945 fn span(&self) -> ::treesitter_types::Span {
946 self.span
947 }
948}
949#[derive(Debug, Clone, PartialEq, Eq)]
950pub struct AnnotationTypeDeclaration<'tree> {
951 pub span: ::treesitter_types::Span,
952 pub body: AnnotationTypeBody<'tree>,
953 pub name: Identifier<'tree>,
954 pub children: ::core::option::Option<Modifiers<'tree>>,
955}
956impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeDeclaration<'tree> {
957 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
958 fn from_node(
959 node: ::treesitter_types::tree_sitter::Node<'tree>,
960 src: &'tree [u8],
961 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
962 debug_assert_eq!(node.kind(), "annotation_type_declaration");
963 Ok(Self {
964 span: ::treesitter_types::Span::from(node),
965 body: {
966 let child = node
967 .child_by_field_name("body")
968 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
969 ::treesitter_types::runtime::maybe_grow_stack(|| {
970 <AnnotationTypeBody as ::treesitter_types::FromNode>::from_node(child, src)
971 })?
972 },
973 name: {
974 let child = node
975 .child_by_field_name("name")
976 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
977 ::treesitter_types::runtime::maybe_grow_stack(|| {
978 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
979 })?
980 },
981 children: {
982 #[allow(clippy::suspicious_else_formatting)]
983 let non_field_children = {
984 let mut cursor = node.walk();
985 let mut result = ::std::vec::Vec::new();
986 if cursor.goto_first_child() {
987 loop {
988 if cursor.field_name().is_none()
989 && cursor.node().is_named()
990 && !cursor.node().is_extra()
991 {
992 result.push(cursor.node());
993 }
994 if !cursor.goto_next_sibling() {
995 break;
996 }
997 }
998 }
999 result
1000 };
1001 match non_field_children.first() {
1002 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1003 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
1004 })?),
1005 None => None,
1006 }
1007 },
1008 })
1009 }
1010}
1011impl ::treesitter_types::Spanned for AnnotationTypeDeclaration<'_> {
1012 fn span(&self) -> ::treesitter_types::Span {
1013 self.span
1014 }
1015}
1016#[derive(Debug, Clone, PartialEq, Eq)]
1017pub struct AnnotationTypeElementDeclaration<'tree> {
1018 pub span: ::treesitter_types::Span,
1019 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
1020 pub name: Identifier<'tree>,
1021 pub r#type: UnannotatedType<'tree>,
1022 pub value: ::core::option::Option<AnnotationTypeElementDeclarationValue<'tree>>,
1023 pub children: ::core::option::Option<Modifiers<'tree>>,
1024}
1025impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeElementDeclaration<'tree> {
1026 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1027 fn from_node(
1028 node: ::treesitter_types::tree_sitter::Node<'tree>,
1029 src: &'tree [u8],
1030 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1031 debug_assert_eq!(node.kind(), "annotation_type_element_declaration");
1032 Ok(Self {
1033 span: ::treesitter_types::Span::from(node),
1034 dimensions: match node.child_by_field_name("dimensions") {
1035 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1036 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
1037 })?),
1038 None => None,
1039 },
1040 name: {
1041 let child = node
1042 .child_by_field_name("name")
1043 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1044 ::treesitter_types::runtime::maybe_grow_stack(|| {
1045 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1046 })?
1047 },
1048 r#type: {
1049 let child = node
1050 .child_by_field_name("type")
1051 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1052 ::treesitter_types::runtime::maybe_grow_stack(|| {
1053 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
1054 })?
1055 },
1056 value: match node.child_by_field_name("value") {
1057 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1058 <AnnotationTypeElementDeclarationValue as ::treesitter_types::FromNode>::from_node(
1059 child,
1060 src,
1061 )
1062 })?),
1063 None => None,
1064 },
1065 children: {
1066 #[allow(clippy::suspicious_else_formatting)]
1067 let non_field_children = {
1068 let mut cursor = node.walk();
1069 let mut result = ::std::vec::Vec::new();
1070 if cursor.goto_first_child() {
1071 loop {
1072 if cursor.field_name().is_none()
1073 && cursor.node().is_named()
1074 && !cursor.node().is_extra()
1075 {
1076 result.push(cursor.node());
1077 }
1078 if !cursor.goto_next_sibling() {
1079 break;
1080 }
1081 }
1082 }
1083 result
1084 };
1085 match non_field_children.first() {
1086 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1087 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
1088 })?),
1089 None => None,
1090 }
1091 },
1092 })
1093 }
1094}
1095impl ::treesitter_types::Spanned for AnnotationTypeElementDeclaration<'_> {
1096 fn span(&self) -> ::treesitter_types::Span {
1097 self.span
1098 }
1099}
1100#[derive(Debug, Clone, PartialEq, Eq)]
1101pub struct ArgumentList<'tree> {
1102 pub span: ::treesitter_types::Span,
1103 pub children: ::std::vec::Vec<Expression<'tree>>,
1104}
1105impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1106 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1107 fn from_node(
1108 node: ::treesitter_types::tree_sitter::Node<'tree>,
1109 src: &'tree [u8],
1110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1111 debug_assert_eq!(node.kind(), "argument_list");
1112 Ok(Self {
1113 span: ::treesitter_types::Span::from(node),
1114 children: {
1115 #[allow(clippy::suspicious_else_formatting)]
1116 let non_field_children = {
1117 let mut cursor = node.walk();
1118 let mut result = ::std::vec::Vec::new();
1119 if cursor.goto_first_child() {
1120 loop {
1121 if cursor.field_name().is_none()
1122 && cursor.node().is_named()
1123 && !cursor.node().is_extra()
1124 {
1125 result.push(cursor.node());
1126 }
1127 if !cursor.goto_next_sibling() {
1128 break;
1129 }
1130 }
1131 }
1132 result
1133 };
1134 let mut items = ::std::vec::Vec::new();
1135 for child in non_field_children {
1136 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1137 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1138 })?);
1139 }
1140 items
1141 },
1142 })
1143 }
1144}
1145impl ::treesitter_types::Spanned for ArgumentList<'_> {
1146 fn span(&self) -> ::treesitter_types::Span {
1147 self.span
1148 }
1149}
1150#[derive(Debug, Clone, PartialEq, Eq)]
1151pub struct ArrayAccess<'tree> {
1152 pub span: ::treesitter_types::Span,
1153 pub array: PrimaryExpression<'tree>,
1154 pub index: Expression<'tree>,
1155}
1156impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayAccess<'tree> {
1157 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1158 fn from_node(
1159 node: ::treesitter_types::tree_sitter::Node<'tree>,
1160 src: &'tree [u8],
1161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1162 debug_assert_eq!(node.kind(), "array_access");
1163 Ok(Self {
1164 span: ::treesitter_types::Span::from(node),
1165 array: {
1166 let child = node
1167 .child_by_field_name("array")
1168 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("array", node))?;
1169 ::treesitter_types::runtime::maybe_grow_stack(|| {
1170 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)
1171 })?
1172 },
1173 index: {
1174 let child = node
1175 .child_by_field_name("index")
1176 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
1177 ::treesitter_types::runtime::maybe_grow_stack(|| {
1178 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1179 })?
1180 },
1181 })
1182 }
1183}
1184impl ::treesitter_types::Spanned for ArrayAccess<'_> {
1185 fn span(&self) -> ::treesitter_types::Span {
1186 self.span
1187 }
1188}
1189#[derive(Debug, Clone, PartialEq, Eq)]
1190pub struct ArrayCreationExpression<'tree> {
1191 pub span: ::treesitter_types::Span,
1192 pub dimensions: ::std::vec::Vec<ArrayCreationExpressionDimensions<'tree>>,
1193 pub r#type: SimpleType<'tree>,
1194 pub value: ::core::option::Option<ArrayInitializer<'tree>>,
1195 pub children: ::std::vec::Vec<ArrayCreationExpressionChildren<'tree>>,
1196}
1197impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1198 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1199 fn from_node(
1200 node: ::treesitter_types::tree_sitter::Node<'tree>,
1201 src: &'tree [u8],
1202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1203 debug_assert_eq!(node.kind(), "array_creation_expression");
1204 Ok(Self {
1205 span: ::treesitter_types::Span::from(node),
1206 dimensions: {
1207 let mut cursor = node.walk();
1208 let mut items = ::std::vec::Vec::new();
1209 for child in node.children_by_field_name("dimensions", &mut cursor) {
1210 items
1211 .push(
1212 ::treesitter_types::runtime::maybe_grow_stack(|| <ArrayCreationExpressionDimensions as ::treesitter_types::FromNode>::from_node(
1213 child,
1214 src,
1215 ))?,
1216 );
1217 }
1218 items
1219 },
1220 r#type: {
1221 let child = node
1222 .child_by_field_name("type")
1223 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1224 ::treesitter_types::runtime::maybe_grow_stack(|| {
1225 <SimpleType as ::treesitter_types::FromNode>::from_node(child, src)
1226 })?
1227 },
1228 value: match node.child_by_field_name("value") {
1229 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1230 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(child, src)
1231 })?),
1232 None => None,
1233 },
1234 children: {
1235 #[allow(clippy::suspicious_else_formatting)]
1236 let non_field_children = {
1237 let mut cursor = node.walk();
1238 let mut result = ::std::vec::Vec::new();
1239 if cursor.goto_first_child() {
1240 loop {
1241 if cursor.field_name().is_none()
1242 && cursor.node().is_named()
1243 && !cursor.node().is_extra()
1244 {
1245 result.push(cursor.node());
1246 }
1247 if !cursor.goto_next_sibling() {
1248 break;
1249 }
1250 }
1251 }
1252 result
1253 };
1254 let mut items = ::std::vec::Vec::new();
1255 for child in non_field_children {
1256 items
1257 .push(
1258 ::treesitter_types::runtime::maybe_grow_stack(|| <ArrayCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
1259 child,
1260 src,
1261 ))?,
1262 );
1263 }
1264 items
1265 },
1266 })
1267 }
1268}
1269impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1270 fn span(&self) -> ::treesitter_types::Span {
1271 self.span
1272 }
1273}
1274#[derive(Debug, Clone, PartialEq, Eq)]
1275pub struct ArrayInitializer<'tree> {
1276 pub span: ::treesitter_types::Span,
1277 pub children: ::std::vec::Vec<ArrayInitializerChildren<'tree>>,
1278}
1279impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayInitializer<'tree> {
1280 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1281 fn from_node(
1282 node: ::treesitter_types::tree_sitter::Node<'tree>,
1283 src: &'tree [u8],
1284 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1285 debug_assert_eq!(node.kind(), "array_initializer");
1286 Ok(Self {
1287 span: ::treesitter_types::Span::from(node),
1288 children: {
1289 #[allow(clippy::suspicious_else_formatting)]
1290 let non_field_children = {
1291 let mut cursor = node.walk();
1292 let mut result = ::std::vec::Vec::new();
1293 if cursor.goto_first_child() {
1294 loop {
1295 if cursor.field_name().is_none()
1296 && cursor.node().is_named()
1297 && !cursor.node().is_extra()
1298 {
1299 result.push(cursor.node());
1300 }
1301 if !cursor.goto_next_sibling() {
1302 break;
1303 }
1304 }
1305 }
1306 result
1307 };
1308 let mut items = ::std::vec::Vec::new();
1309 for child in non_field_children {
1310 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1311 <ArrayInitializerChildren as ::treesitter_types::FromNode>::from_node(
1312 child, src,
1313 )
1314 })?);
1315 }
1316 items
1317 },
1318 })
1319 }
1320}
1321impl ::treesitter_types::Spanned for ArrayInitializer<'_> {
1322 fn span(&self) -> ::treesitter_types::Span {
1323 self.span
1324 }
1325}
1326#[derive(Debug, Clone, PartialEq, Eq)]
1327pub struct ArrayType<'tree> {
1328 pub span: ::treesitter_types::Span,
1329 pub dimensions: Dimensions<'tree>,
1330 pub element: UnannotatedType<'tree>,
1331}
1332impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1333 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1334 fn from_node(
1335 node: ::treesitter_types::tree_sitter::Node<'tree>,
1336 src: &'tree [u8],
1337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1338 debug_assert_eq!(node.kind(), "array_type");
1339 Ok(Self {
1340 span: ::treesitter_types::Span::from(node),
1341 dimensions: {
1342 let child = node.child_by_field_name("dimensions").ok_or_else(|| {
1343 ::treesitter_types::ParseError::missing_field("dimensions", node)
1344 })?;
1345 ::treesitter_types::runtime::maybe_grow_stack(|| {
1346 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
1347 })?
1348 },
1349 element: {
1350 let child = node.child_by_field_name("element").ok_or_else(|| {
1351 ::treesitter_types::ParseError::missing_field("element", node)
1352 })?;
1353 ::treesitter_types::runtime::maybe_grow_stack(|| {
1354 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
1355 })?
1356 },
1357 })
1358 }
1359}
1360impl ::treesitter_types::Spanned for ArrayType<'_> {
1361 fn span(&self) -> ::treesitter_types::Span {
1362 self.span
1363 }
1364}
1365#[derive(Debug, Clone, PartialEq, Eq)]
1366pub struct AssertStatement<'tree> {
1367 pub span: ::treesitter_types::Span,
1368 pub children: ::std::vec::Vec<Expression<'tree>>,
1369}
1370impl<'tree> ::treesitter_types::FromNode<'tree> for AssertStatement<'tree> {
1371 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1372 fn from_node(
1373 node: ::treesitter_types::tree_sitter::Node<'tree>,
1374 src: &'tree [u8],
1375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1376 debug_assert_eq!(node.kind(), "assert_statement");
1377 Ok(Self {
1378 span: ::treesitter_types::Span::from(node),
1379 children: {
1380 #[allow(clippy::suspicious_else_formatting)]
1381 let non_field_children = {
1382 let mut cursor = node.walk();
1383 let mut result = ::std::vec::Vec::new();
1384 if cursor.goto_first_child() {
1385 loop {
1386 if cursor.field_name().is_none()
1387 && cursor.node().is_named()
1388 && !cursor.node().is_extra()
1389 {
1390 result.push(cursor.node());
1391 }
1392 if !cursor.goto_next_sibling() {
1393 break;
1394 }
1395 }
1396 }
1397 result
1398 };
1399 let mut items = ::std::vec::Vec::new();
1400 for child in non_field_children {
1401 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1402 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1403 })?);
1404 }
1405 items
1406 },
1407 })
1408 }
1409}
1410impl ::treesitter_types::Spanned for AssertStatement<'_> {
1411 fn span(&self) -> ::treesitter_types::Span {
1412 self.span
1413 }
1414}
1415#[derive(Debug, Clone, PartialEq, Eq)]
1416pub struct AssignmentExpression<'tree> {
1417 pub span: ::treesitter_types::Span,
1418 pub left: AssignmentExpressionLeft<'tree>,
1419 pub operator: AssignmentExpressionOperator,
1420 pub right: Expression<'tree>,
1421}
1422impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1424 fn from_node(
1425 node: ::treesitter_types::tree_sitter::Node<'tree>,
1426 src: &'tree [u8],
1427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1428 debug_assert_eq!(node.kind(), "assignment_expression");
1429 Ok(Self {
1430 span: ::treesitter_types::Span::from(node),
1431 left: {
1432 let child = node
1433 .child_by_field_name("left")
1434 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1435 ::treesitter_types::runtime::maybe_grow_stack(|| {
1436 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1437 child, src,
1438 )
1439 })?
1440 },
1441 operator: {
1442 let child = node.child_by_field_name("operator").ok_or_else(|| {
1443 ::treesitter_types::ParseError::missing_field("operator", node)
1444 })?;
1445 ::treesitter_types::runtime::maybe_grow_stack(|| {
1446 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1447 child, src,
1448 )
1449 })?
1450 },
1451 right: {
1452 let child = node
1453 .child_by_field_name("right")
1454 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1455 ::treesitter_types::runtime::maybe_grow_stack(|| {
1456 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1457 })?
1458 },
1459 })
1460 }
1461}
1462impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1463 fn span(&self) -> ::treesitter_types::Span {
1464 self.span
1465 }
1466}
1467#[derive(Debug, Clone, PartialEq, Eq)]
1468pub struct Asterisk<'tree> {
1469 pub span: ::treesitter_types::Span,
1470 text: &'tree str,
1471}
1472impl<'tree> ::treesitter_types::FromNode<'tree> for Asterisk<'tree> {
1473 fn from_node(
1474 node: ::treesitter_types::tree_sitter::Node<'tree>,
1475 src: &'tree [u8],
1476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1477 debug_assert_eq!(node.kind(), "asterisk");
1478 Ok(Self {
1479 span: ::treesitter_types::Span::from(node),
1480 text: node.utf8_text(src)?,
1481 })
1482 }
1483}
1484impl<'tree> ::treesitter_types::LeafNode<'tree> for Asterisk<'tree> {
1485 fn text(&self) -> &'tree str {
1486 self.text
1487 }
1488}
1489impl ::treesitter_types::Spanned for Asterisk<'_> {
1490 fn span(&self) -> ::treesitter_types::Span {
1491 self.span
1492 }
1493}
1494#[derive(Debug, Clone, PartialEq, Eq)]
1495pub struct BinaryExpression<'tree> {
1496 pub span: ::treesitter_types::Span,
1497 pub left: Expression<'tree>,
1498 pub operator: BinaryExpressionOperator,
1499 pub right: Expression<'tree>,
1500}
1501impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1502 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1503 fn from_node(
1504 node: ::treesitter_types::tree_sitter::Node<'tree>,
1505 src: &'tree [u8],
1506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1507 debug_assert_eq!(node.kind(), "binary_expression");
1508 Ok(Self {
1509 span: ::treesitter_types::Span::from(node),
1510 left: {
1511 let child = node
1512 .child_by_field_name("left")
1513 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1514 ::treesitter_types::runtime::maybe_grow_stack(|| {
1515 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1516 })?
1517 },
1518 operator: {
1519 let child = node.child_by_field_name("operator").ok_or_else(|| {
1520 ::treesitter_types::ParseError::missing_field("operator", node)
1521 })?;
1522 ::treesitter_types::runtime::maybe_grow_stack(|| {
1523 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
1524 child, src,
1525 )
1526 })?
1527 },
1528 right: {
1529 let child = node
1530 .child_by_field_name("right")
1531 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1532 ::treesitter_types::runtime::maybe_grow_stack(|| {
1533 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1534 })?
1535 },
1536 })
1537 }
1538}
1539impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1540 fn span(&self) -> ::treesitter_types::Span {
1541 self.span
1542 }
1543}
1544#[derive(Debug, Clone, PartialEq, Eq)]
1545pub struct Block<'tree> {
1546 pub span: ::treesitter_types::Span,
1547 pub children: ::std::vec::Vec<Statement<'tree>>,
1548}
1549impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1550 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1551 fn from_node(
1552 node: ::treesitter_types::tree_sitter::Node<'tree>,
1553 src: &'tree [u8],
1554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1555 debug_assert_eq!(node.kind(), "block");
1556 Ok(Self {
1557 span: ::treesitter_types::Span::from(node),
1558 children: {
1559 #[allow(clippy::suspicious_else_formatting)]
1560 let non_field_children = {
1561 let mut cursor = node.walk();
1562 let mut result = ::std::vec::Vec::new();
1563 if cursor.goto_first_child() {
1564 loop {
1565 if cursor.field_name().is_none()
1566 && cursor.node().is_named()
1567 && !cursor.node().is_extra()
1568 {
1569 result.push(cursor.node());
1570 }
1571 if !cursor.goto_next_sibling() {
1572 break;
1573 }
1574 }
1575 }
1576 result
1577 };
1578 let mut items = ::std::vec::Vec::new();
1579 for child in non_field_children {
1580 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1581 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
1582 })?);
1583 }
1584 items
1585 },
1586 })
1587 }
1588}
1589impl ::treesitter_types::Spanned for Block<'_> {
1590 fn span(&self) -> ::treesitter_types::Span {
1591 self.span
1592 }
1593}
1594#[derive(Debug, Clone, PartialEq, Eq)]
1595pub struct BreakStatement<'tree> {
1596 pub span: ::treesitter_types::Span,
1597 pub children: ::core::option::Option<Identifier<'tree>>,
1598}
1599impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1600 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1601 fn from_node(
1602 node: ::treesitter_types::tree_sitter::Node<'tree>,
1603 src: &'tree [u8],
1604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1605 debug_assert_eq!(node.kind(), "break_statement");
1606 Ok(Self {
1607 span: ::treesitter_types::Span::from(node),
1608 children: {
1609 #[allow(clippy::suspicious_else_formatting)]
1610 let non_field_children = {
1611 let mut cursor = node.walk();
1612 let mut result = ::std::vec::Vec::new();
1613 if cursor.goto_first_child() {
1614 loop {
1615 if cursor.field_name().is_none()
1616 && cursor.node().is_named()
1617 && !cursor.node().is_extra()
1618 {
1619 result.push(cursor.node());
1620 }
1621 if !cursor.goto_next_sibling() {
1622 break;
1623 }
1624 }
1625 }
1626 result
1627 };
1628 match non_field_children.first() {
1629 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1630 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1631 })?),
1632 None => None,
1633 }
1634 },
1635 })
1636 }
1637}
1638impl ::treesitter_types::Spanned for BreakStatement<'_> {
1639 fn span(&self) -> ::treesitter_types::Span {
1640 self.span
1641 }
1642}
1643#[derive(Debug, Clone, PartialEq, Eq)]
1644pub struct CastExpression<'tree> {
1645 pub span: ::treesitter_types::Span,
1646 pub r#type: ::std::vec::Vec<Type<'tree>>,
1647 pub value: Expression<'tree>,
1648}
1649impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
1650 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1651 fn from_node(
1652 node: ::treesitter_types::tree_sitter::Node<'tree>,
1653 src: &'tree [u8],
1654 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1655 debug_assert_eq!(node.kind(), "cast_expression");
1656 Ok(Self {
1657 span: ::treesitter_types::Span::from(node),
1658 r#type: {
1659 let mut cursor = node.walk();
1660 let mut items = ::std::vec::Vec::new();
1661 for child in node.children_by_field_name("type", &mut cursor) {
1662 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1663 <Type as ::treesitter_types::FromNode>::from_node(child, src)
1664 })?);
1665 }
1666 items
1667 },
1668 value: {
1669 let child = node
1670 .child_by_field_name("value")
1671 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1672 ::treesitter_types::runtime::maybe_grow_stack(|| {
1673 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1674 })?
1675 },
1676 })
1677 }
1678}
1679impl ::treesitter_types::Spanned for CastExpression<'_> {
1680 fn span(&self) -> ::treesitter_types::Span {
1681 self.span
1682 }
1683}
1684#[derive(Debug, Clone, PartialEq, Eq)]
1685pub struct CatchClause<'tree> {
1686 pub span: ::treesitter_types::Span,
1687 pub body: Block<'tree>,
1688 pub children: CatchFormalParameter<'tree>,
1689}
1690impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1691 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1692 fn from_node(
1693 node: ::treesitter_types::tree_sitter::Node<'tree>,
1694 src: &'tree [u8],
1695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1696 debug_assert_eq!(node.kind(), "catch_clause");
1697 Ok(Self {
1698 span: ::treesitter_types::Span::from(node),
1699 body: {
1700 let child = node
1701 .child_by_field_name("body")
1702 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1703 ::treesitter_types::runtime::maybe_grow_stack(|| {
1704 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1705 })?
1706 },
1707 children: {
1708 #[allow(clippy::suspicious_else_formatting)]
1709 let non_field_children = {
1710 let mut cursor = node.walk();
1711 let mut result = ::std::vec::Vec::new();
1712 if cursor.goto_first_child() {
1713 loop {
1714 if cursor.field_name().is_none()
1715 && cursor.node().is_named()
1716 && !cursor.node().is_extra()
1717 {
1718 result.push(cursor.node());
1719 }
1720 if !cursor.goto_next_sibling() {
1721 break;
1722 }
1723 }
1724 }
1725 result
1726 };
1727 let child = if let Some(&c) = non_field_children.first() {
1728 c
1729 } else {
1730 let mut fallback_cursor = node.walk();
1731 let mut fallback_child = None;
1732 if fallback_cursor.goto_first_child() {
1733 loop {
1734 if fallback_cursor.field_name().is_none()
1735 && !fallback_cursor.node().is_extra()
1736 {
1737 let candidate = fallback_cursor.node();
1738 #[allow(clippy::needless_question_mark)]
1739 if (|| -> ::core::result::Result<
1740 _,
1741 ::treesitter_types::ParseError,
1742 > {
1743 let child = candidate;
1744 Ok(
1745 ::treesitter_types::runtime::maybe_grow_stack(|| <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(
1746 child,
1747 src,
1748 ))?,
1749 )
1750 })()
1751 .is_ok()
1752 {
1753 fallback_child = Some(candidate);
1754 break;
1755 }
1756 }
1757 if !fallback_cursor.goto_next_sibling() {
1758 break;
1759 }
1760 }
1761 }
1762 if fallback_child.is_none() {
1763 let mut cursor2 = node.walk();
1764 if cursor2.goto_first_child() {
1765 loop {
1766 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1767 let candidate = cursor2.node();
1768 #[allow(clippy::needless_question_mark)]
1769 if (|| -> ::core::result::Result<
1770 _,
1771 ::treesitter_types::ParseError,
1772 > {
1773 let child = candidate;
1774 Ok(
1775 ::treesitter_types::runtime::maybe_grow_stack(|| <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(
1776 child,
1777 src,
1778 ))?,
1779 )
1780 })()
1781 .is_ok()
1782 {
1783 fallback_child = Some(candidate);
1784 break;
1785 }
1786 }
1787 if !cursor2.goto_next_sibling() {
1788 break;
1789 }
1790 }
1791 }
1792 }
1793 fallback_child.ok_or_else(|| {
1794 ::treesitter_types::ParseError::missing_field("children", node)
1795 })?
1796 };
1797 ::treesitter_types::runtime::maybe_grow_stack(|| {
1798 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(child, src)
1799 })?
1800 },
1801 })
1802 }
1803}
1804impl ::treesitter_types::Spanned for CatchClause<'_> {
1805 fn span(&self) -> ::treesitter_types::Span {
1806 self.span
1807 }
1808}
1809#[derive(Debug, Clone, PartialEq, Eq)]
1810pub struct CatchFormalParameter<'tree> {
1811 pub span: ::treesitter_types::Span,
1812 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
1813 pub name: CatchFormalParameterName<'tree>,
1814 pub children: ::std::vec::Vec<CatchFormalParameterChildren<'tree>>,
1815}
1816impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameter<'tree> {
1817 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1818 fn from_node(
1819 node: ::treesitter_types::tree_sitter::Node<'tree>,
1820 src: &'tree [u8],
1821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1822 debug_assert_eq!(node.kind(), "catch_formal_parameter");
1823 Ok(Self {
1824 span: ::treesitter_types::Span::from(node),
1825 dimensions: match node.child_by_field_name("dimensions") {
1826 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1827 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
1828 })?),
1829 None => None,
1830 },
1831 name: {
1832 let child = node
1833 .child_by_field_name("name")
1834 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1835 ::treesitter_types::runtime::maybe_grow_stack(|| {
1836 <CatchFormalParameterName as ::treesitter_types::FromNode>::from_node(
1837 child, src,
1838 )
1839 })?
1840 },
1841 children: {
1842 #[allow(clippy::suspicious_else_formatting)]
1843 let non_field_children = {
1844 let mut cursor = node.walk();
1845 let mut result = ::std::vec::Vec::new();
1846 if cursor.goto_first_child() {
1847 loop {
1848 if cursor.field_name().is_none()
1849 && cursor.node().is_named()
1850 && !cursor.node().is_extra()
1851 {
1852 result.push(cursor.node());
1853 }
1854 if !cursor.goto_next_sibling() {
1855 break;
1856 }
1857 }
1858 }
1859 result
1860 };
1861 let mut items = ::std::vec::Vec::new();
1862 for child in non_field_children {
1863 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1864 <CatchFormalParameterChildren as ::treesitter_types::FromNode>::from_node(
1865 child, src,
1866 )
1867 })?);
1868 }
1869 items
1870 },
1871 })
1872 }
1873}
1874impl ::treesitter_types::Spanned for CatchFormalParameter<'_> {
1875 fn span(&self) -> ::treesitter_types::Span {
1876 self.span
1877 }
1878}
1879#[derive(Debug, Clone, PartialEq, Eq)]
1880pub struct CatchType<'tree> {
1881 pub span: ::treesitter_types::Span,
1882 pub children: ::std::vec::Vec<UnannotatedType<'tree>>,
1883}
1884impl<'tree> ::treesitter_types::FromNode<'tree> for CatchType<'tree> {
1885 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1886 fn from_node(
1887 node: ::treesitter_types::tree_sitter::Node<'tree>,
1888 src: &'tree [u8],
1889 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1890 debug_assert_eq!(node.kind(), "catch_type");
1891 Ok(Self {
1892 span: ::treesitter_types::Span::from(node),
1893 children: {
1894 #[allow(clippy::suspicious_else_formatting)]
1895 let non_field_children = {
1896 let mut cursor = node.walk();
1897 let mut result = ::std::vec::Vec::new();
1898 if cursor.goto_first_child() {
1899 loop {
1900 if cursor.field_name().is_none()
1901 && cursor.node().is_named()
1902 && !cursor.node().is_extra()
1903 {
1904 result.push(cursor.node());
1905 }
1906 if !cursor.goto_next_sibling() {
1907 break;
1908 }
1909 }
1910 }
1911 result
1912 };
1913 let mut items = ::std::vec::Vec::new();
1914 for child in non_field_children {
1915 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1916 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
1917 })?);
1918 }
1919 items
1920 },
1921 })
1922 }
1923}
1924impl ::treesitter_types::Spanned for CatchType<'_> {
1925 fn span(&self) -> ::treesitter_types::Span {
1926 self.span
1927 }
1928}
1929#[derive(Debug, Clone, PartialEq, Eq)]
1930pub struct ClassBody<'tree> {
1931 pub span: ::treesitter_types::Span,
1932 pub children: ::std::vec::Vec<ClassBodyChildren<'tree>>,
1933}
1934impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1935 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1936 fn from_node(
1937 node: ::treesitter_types::tree_sitter::Node<'tree>,
1938 src: &'tree [u8],
1939 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1940 debug_assert_eq!(node.kind(), "class_body");
1941 Ok(Self {
1942 span: ::treesitter_types::Span::from(node),
1943 children: {
1944 #[allow(clippy::suspicious_else_formatting)]
1945 let non_field_children = {
1946 let mut cursor = node.walk();
1947 let mut result = ::std::vec::Vec::new();
1948 if cursor.goto_first_child() {
1949 loop {
1950 if cursor.field_name().is_none()
1951 && cursor.node().is_named()
1952 && !cursor.node().is_extra()
1953 {
1954 result.push(cursor.node());
1955 }
1956 if !cursor.goto_next_sibling() {
1957 break;
1958 }
1959 }
1960 }
1961 result
1962 };
1963 let mut items = ::std::vec::Vec::new();
1964 for child in non_field_children {
1965 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1966 <ClassBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
1967 })?);
1968 }
1969 items
1970 },
1971 })
1972 }
1973}
1974impl ::treesitter_types::Spanned for ClassBody<'_> {
1975 fn span(&self) -> ::treesitter_types::Span {
1976 self.span
1977 }
1978}
1979#[derive(Debug, Clone, PartialEq, Eq)]
1980pub struct ClassDeclaration<'tree> {
1981 pub span: ::treesitter_types::Span,
1982 pub body: ClassBody<'tree>,
1983 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
1984 pub name: Identifier<'tree>,
1985 pub permits: ::core::option::Option<Permits<'tree>>,
1986 pub superclass: ::core::option::Option<Superclass<'tree>>,
1987 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1988 pub children: ::core::option::Option<Modifiers<'tree>>,
1989}
1990impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1992 fn from_node(
1993 node: ::treesitter_types::tree_sitter::Node<'tree>,
1994 src: &'tree [u8],
1995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1996 debug_assert_eq!(node.kind(), "class_declaration");
1997 Ok(Self {
1998 span: ::treesitter_types::Span::from(node),
1999 body: {
2000 let child = node
2001 .child_by_field_name("body")
2002 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2003 ::treesitter_types::runtime::maybe_grow_stack(|| {
2004 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)
2005 })?
2006 },
2007 interfaces: match node.child_by_field_name("interfaces") {
2008 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2009 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)
2010 })?),
2011 None => None,
2012 },
2013 name: {
2014 let child = node
2015 .child_by_field_name("name")
2016 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2017 ::treesitter_types::runtime::maybe_grow_stack(|| {
2018 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2019 })?
2020 },
2021 permits: match node.child_by_field_name("permits") {
2022 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2023 <Permits as ::treesitter_types::FromNode>::from_node(child, src)
2024 })?),
2025 None => None,
2026 },
2027 superclass: match node.child_by_field_name("superclass") {
2028 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2029 <Superclass as ::treesitter_types::FromNode>::from_node(child, src)
2030 })?),
2031 None => None,
2032 },
2033 type_parameters: match node.child_by_field_name("type_parameters") {
2034 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2035 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
2036 })?),
2037 None => None,
2038 },
2039 children: {
2040 #[allow(clippy::suspicious_else_formatting)]
2041 let non_field_children = {
2042 let mut cursor = node.walk();
2043 let mut result = ::std::vec::Vec::new();
2044 if cursor.goto_first_child() {
2045 loop {
2046 if cursor.field_name().is_none()
2047 && cursor.node().is_named()
2048 && !cursor.node().is_extra()
2049 {
2050 result.push(cursor.node());
2051 }
2052 if !cursor.goto_next_sibling() {
2053 break;
2054 }
2055 }
2056 }
2057 result
2058 };
2059 match non_field_children.first() {
2060 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2061 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
2062 })?),
2063 None => None,
2064 }
2065 },
2066 })
2067 }
2068}
2069impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
2070 fn span(&self) -> ::treesitter_types::Span {
2071 self.span
2072 }
2073}
2074#[derive(Debug, Clone, PartialEq, Eq)]
2075pub struct ClassLiteral<'tree> {
2076 pub span: ::treesitter_types::Span,
2077 pub children: UnannotatedType<'tree>,
2078}
2079impl<'tree> ::treesitter_types::FromNode<'tree> for ClassLiteral<'tree> {
2080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2081 fn from_node(
2082 node: ::treesitter_types::tree_sitter::Node<'tree>,
2083 src: &'tree [u8],
2084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2085 debug_assert_eq!(node.kind(), "class_literal");
2086 Ok(Self {
2087 span: ::treesitter_types::Span::from(node),
2088 children: {
2089 #[allow(clippy::suspicious_else_formatting)]
2090 let non_field_children = {
2091 let mut cursor = node.walk();
2092 let mut result = ::std::vec::Vec::new();
2093 if cursor.goto_first_child() {
2094 loop {
2095 if cursor.field_name().is_none()
2096 && cursor.node().is_named()
2097 && !cursor.node().is_extra()
2098 {
2099 result.push(cursor.node());
2100 }
2101 if !cursor.goto_next_sibling() {
2102 break;
2103 }
2104 }
2105 }
2106 result
2107 };
2108 let child = if let Some(&c) = non_field_children.first() {
2109 c
2110 } else {
2111 let mut fallback_cursor = node.walk();
2112 let mut fallback_child = None;
2113 if fallback_cursor.goto_first_child() {
2114 loop {
2115 if fallback_cursor.field_name().is_none()
2116 && !fallback_cursor.node().is_extra()
2117 {
2118 let candidate = fallback_cursor.node();
2119 #[allow(clippy::needless_question_mark)]
2120 if (|| -> ::core::result::Result<
2121 _,
2122 ::treesitter_types::ParseError,
2123 > {
2124 let child = candidate;
2125 Ok(
2126 ::treesitter_types::runtime::maybe_grow_stack(|| <UnannotatedType as ::treesitter_types::FromNode>::from_node(
2127 child,
2128 src,
2129 ))?,
2130 )
2131 })()
2132 .is_ok()
2133 {
2134 fallback_child = Some(candidate);
2135 break;
2136 }
2137 }
2138 if !fallback_cursor.goto_next_sibling() {
2139 break;
2140 }
2141 }
2142 }
2143 if fallback_child.is_none() {
2144 let mut cursor2 = node.walk();
2145 if cursor2.goto_first_child() {
2146 loop {
2147 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2148 let candidate = cursor2.node();
2149 #[allow(clippy::needless_question_mark)]
2150 if (|| -> ::core::result::Result<
2151 _,
2152 ::treesitter_types::ParseError,
2153 > {
2154 let child = candidate;
2155 Ok(
2156 ::treesitter_types::runtime::maybe_grow_stack(|| <UnannotatedType as ::treesitter_types::FromNode>::from_node(
2157 child,
2158 src,
2159 ))?,
2160 )
2161 })()
2162 .is_ok()
2163 {
2164 fallback_child = Some(candidate);
2165 break;
2166 }
2167 }
2168 if !cursor2.goto_next_sibling() {
2169 break;
2170 }
2171 }
2172 }
2173 }
2174 fallback_child.ok_or_else(|| {
2175 ::treesitter_types::ParseError::missing_field("children", node)
2176 })?
2177 };
2178 ::treesitter_types::runtime::maybe_grow_stack(|| {
2179 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
2180 })?
2181 },
2182 })
2183 }
2184}
2185impl ::treesitter_types::Spanned for ClassLiteral<'_> {
2186 fn span(&self) -> ::treesitter_types::Span {
2187 self.span
2188 }
2189}
2190#[derive(Debug, Clone, PartialEq, Eq)]
2191pub struct CompactConstructorDeclaration<'tree> {
2192 pub span: ::treesitter_types::Span,
2193 pub body: Block<'tree>,
2194 pub name: Identifier<'tree>,
2195 pub children: ::core::option::Option<Modifiers<'tree>>,
2196}
2197impl<'tree> ::treesitter_types::FromNode<'tree> for CompactConstructorDeclaration<'tree> {
2198 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2199 fn from_node(
2200 node: ::treesitter_types::tree_sitter::Node<'tree>,
2201 src: &'tree [u8],
2202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2203 debug_assert_eq!(node.kind(), "compact_constructor_declaration");
2204 Ok(Self {
2205 span: ::treesitter_types::Span::from(node),
2206 body: {
2207 let child = node
2208 .child_by_field_name("body")
2209 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2210 ::treesitter_types::runtime::maybe_grow_stack(|| {
2211 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2212 })?
2213 },
2214 name: {
2215 let child = node
2216 .child_by_field_name("name")
2217 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2218 ::treesitter_types::runtime::maybe_grow_stack(|| {
2219 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2220 })?
2221 },
2222 children: {
2223 #[allow(clippy::suspicious_else_formatting)]
2224 let non_field_children = {
2225 let mut cursor = node.walk();
2226 let mut result = ::std::vec::Vec::new();
2227 if cursor.goto_first_child() {
2228 loop {
2229 if cursor.field_name().is_none()
2230 && cursor.node().is_named()
2231 && !cursor.node().is_extra()
2232 {
2233 result.push(cursor.node());
2234 }
2235 if !cursor.goto_next_sibling() {
2236 break;
2237 }
2238 }
2239 }
2240 result
2241 };
2242 match non_field_children.first() {
2243 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2244 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
2245 })?),
2246 None => None,
2247 }
2248 },
2249 })
2250 }
2251}
2252impl ::treesitter_types::Spanned for CompactConstructorDeclaration<'_> {
2253 fn span(&self) -> ::treesitter_types::Span {
2254 self.span
2255 }
2256}
2257#[derive(Debug, Clone, PartialEq, Eq)]
2258pub struct ConstantDeclaration<'tree> {
2259 pub span: ::treesitter_types::Span,
2260 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
2261 pub r#type: UnannotatedType<'tree>,
2262 pub children: ::core::option::Option<Modifiers<'tree>>,
2263}
2264impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantDeclaration<'tree> {
2265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2266 fn from_node(
2267 node: ::treesitter_types::tree_sitter::Node<'tree>,
2268 src: &'tree [u8],
2269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2270 debug_assert_eq!(node.kind(), "constant_declaration");
2271 Ok(Self {
2272 span: ::treesitter_types::Span::from(node),
2273 declarator: {
2274 let mut cursor = node.walk();
2275 let mut items = ::std::vec::Vec::new();
2276 for child in node.children_by_field_name("declarator", &mut cursor) {
2277 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2278 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
2279 })?);
2280 }
2281 items
2282 },
2283 r#type: {
2284 let child = node
2285 .child_by_field_name("type")
2286 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2287 ::treesitter_types::runtime::maybe_grow_stack(|| {
2288 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
2289 })?
2290 },
2291 children: {
2292 #[allow(clippy::suspicious_else_formatting)]
2293 let non_field_children = {
2294 let mut cursor = node.walk();
2295 let mut result = ::std::vec::Vec::new();
2296 if cursor.goto_first_child() {
2297 loop {
2298 if cursor.field_name().is_none()
2299 && cursor.node().is_named()
2300 && !cursor.node().is_extra()
2301 {
2302 result.push(cursor.node());
2303 }
2304 if !cursor.goto_next_sibling() {
2305 break;
2306 }
2307 }
2308 }
2309 result
2310 };
2311 match non_field_children.first() {
2312 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2313 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
2314 })?),
2315 None => None,
2316 }
2317 },
2318 })
2319 }
2320}
2321impl ::treesitter_types::Spanned for ConstantDeclaration<'_> {
2322 fn span(&self) -> ::treesitter_types::Span {
2323 self.span
2324 }
2325}
2326#[derive(Debug, Clone, PartialEq, Eq)]
2327pub struct ConstructorBody<'tree> {
2328 pub span: ::treesitter_types::Span,
2329 pub children: ::std::vec::Vec<ConstructorBodyChildren<'tree>>,
2330}
2331impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBody<'tree> {
2332 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2333 fn from_node(
2334 node: ::treesitter_types::tree_sitter::Node<'tree>,
2335 src: &'tree [u8],
2336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2337 debug_assert_eq!(node.kind(), "constructor_body");
2338 Ok(Self {
2339 span: ::treesitter_types::Span::from(node),
2340 children: {
2341 #[allow(clippy::suspicious_else_formatting)]
2342 let non_field_children = {
2343 let mut cursor = node.walk();
2344 let mut result = ::std::vec::Vec::new();
2345 if cursor.goto_first_child() {
2346 loop {
2347 if cursor.field_name().is_none()
2348 && cursor.node().is_named()
2349 && !cursor.node().is_extra()
2350 {
2351 result.push(cursor.node());
2352 }
2353 if !cursor.goto_next_sibling() {
2354 break;
2355 }
2356 }
2357 }
2358 result
2359 };
2360 let mut items = ::std::vec::Vec::new();
2361 for child in non_field_children {
2362 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2363 <ConstructorBodyChildren as ::treesitter_types::FromNode>::from_node(
2364 child, src,
2365 )
2366 })?);
2367 }
2368 items
2369 },
2370 })
2371 }
2372}
2373impl ::treesitter_types::Spanned for ConstructorBody<'_> {
2374 fn span(&self) -> ::treesitter_types::Span {
2375 self.span
2376 }
2377}
2378#[derive(Debug, Clone, PartialEq, Eq)]
2379pub struct ConstructorDeclaration<'tree> {
2380 pub span: ::treesitter_types::Span,
2381 pub body: ConstructorBody<'tree>,
2382 pub name: Identifier<'tree>,
2383 pub parameters: FormalParameters<'tree>,
2384 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2385 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
2386}
2387impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
2388 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2389 fn from_node(
2390 node: ::treesitter_types::tree_sitter::Node<'tree>,
2391 src: &'tree [u8],
2392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2393 debug_assert_eq!(node.kind(), "constructor_declaration");
2394 Ok(Self {
2395 span: ::treesitter_types::Span::from(node),
2396 body: {
2397 let child = node
2398 .child_by_field_name("body")
2399 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2400 ::treesitter_types::runtime::maybe_grow_stack(|| {
2401 <ConstructorBody as ::treesitter_types::FromNode>::from_node(child, src)
2402 })?
2403 },
2404 name: {
2405 let child = node
2406 .child_by_field_name("name")
2407 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2408 ::treesitter_types::runtime::maybe_grow_stack(|| {
2409 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2410 })?
2411 },
2412 parameters: {
2413 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2414 ::treesitter_types::ParseError::missing_field("parameters", node)
2415 })?;
2416 ::treesitter_types::runtime::maybe_grow_stack(|| {
2417 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
2418 })?
2419 },
2420 type_parameters: match node.child_by_field_name("type_parameters") {
2421 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2422 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
2423 })?),
2424 None => None,
2425 },
2426 children: {
2427 #[allow(clippy::suspicious_else_formatting)]
2428 let non_field_children = {
2429 let mut cursor = node.walk();
2430 let mut result = ::std::vec::Vec::new();
2431 if cursor.goto_first_child() {
2432 loop {
2433 if cursor.field_name().is_none()
2434 && cursor.node().is_named()
2435 && !cursor.node().is_extra()
2436 {
2437 result.push(cursor.node());
2438 }
2439 if !cursor.goto_next_sibling() {
2440 break;
2441 }
2442 }
2443 }
2444 result
2445 };
2446 let mut items = ::std::vec::Vec::new();
2447 for child in non_field_children {
2448 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2449 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2450 child, src,
2451 )
2452 })?);
2453 }
2454 items
2455 },
2456 })
2457 }
2458}
2459impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
2460 fn span(&self) -> ::treesitter_types::Span {
2461 self.span
2462 }
2463}
2464#[derive(Debug, Clone, PartialEq, Eq)]
2465pub struct ContinueStatement<'tree> {
2466 pub span: ::treesitter_types::Span,
2467 pub children: ::core::option::Option<Identifier<'tree>>,
2468}
2469impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2470 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2471 fn from_node(
2472 node: ::treesitter_types::tree_sitter::Node<'tree>,
2473 src: &'tree [u8],
2474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2475 debug_assert_eq!(node.kind(), "continue_statement");
2476 Ok(Self {
2477 span: ::treesitter_types::Span::from(node),
2478 children: {
2479 #[allow(clippy::suspicious_else_formatting)]
2480 let non_field_children = {
2481 let mut cursor = node.walk();
2482 let mut result = ::std::vec::Vec::new();
2483 if cursor.goto_first_child() {
2484 loop {
2485 if cursor.field_name().is_none()
2486 && cursor.node().is_named()
2487 && !cursor.node().is_extra()
2488 {
2489 result.push(cursor.node());
2490 }
2491 if !cursor.goto_next_sibling() {
2492 break;
2493 }
2494 }
2495 }
2496 result
2497 };
2498 match non_field_children.first() {
2499 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2500 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2501 })?),
2502 None => None,
2503 }
2504 },
2505 })
2506 }
2507}
2508impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2509 fn span(&self) -> ::treesitter_types::Span {
2510 self.span
2511 }
2512}
2513#[derive(Debug, Clone, PartialEq, Eq)]
2514pub struct Dimensions<'tree> {
2515 pub span: ::treesitter_types::Span,
2516 pub children: ::std::vec::Vec<DimensionsChildren<'tree>>,
2517}
2518impl<'tree> ::treesitter_types::FromNode<'tree> for Dimensions<'tree> {
2519 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2520 fn from_node(
2521 node: ::treesitter_types::tree_sitter::Node<'tree>,
2522 src: &'tree [u8],
2523 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2524 debug_assert_eq!(node.kind(), "dimensions");
2525 Ok(Self {
2526 span: ::treesitter_types::Span::from(node),
2527 children: {
2528 #[allow(clippy::suspicious_else_formatting)]
2529 let non_field_children = {
2530 let mut cursor = node.walk();
2531 let mut result = ::std::vec::Vec::new();
2532 if cursor.goto_first_child() {
2533 loop {
2534 if cursor.field_name().is_none()
2535 && cursor.node().is_named()
2536 && !cursor.node().is_extra()
2537 {
2538 result.push(cursor.node());
2539 }
2540 if !cursor.goto_next_sibling() {
2541 break;
2542 }
2543 }
2544 }
2545 result
2546 };
2547 let mut items = ::std::vec::Vec::new();
2548 for child in non_field_children {
2549 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2550 <DimensionsChildren as ::treesitter_types::FromNode>::from_node(child, src)
2551 })?);
2552 }
2553 items
2554 },
2555 })
2556 }
2557}
2558impl ::treesitter_types::Spanned for Dimensions<'_> {
2559 fn span(&self) -> ::treesitter_types::Span {
2560 self.span
2561 }
2562}
2563#[derive(Debug, Clone, PartialEq, Eq)]
2564pub struct DimensionsExpr<'tree> {
2565 pub span: ::treesitter_types::Span,
2566 pub children: ::std::vec::Vec<DimensionsExprChildren<'tree>>,
2567}
2568impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExpr<'tree> {
2569 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2570 fn from_node(
2571 node: ::treesitter_types::tree_sitter::Node<'tree>,
2572 src: &'tree [u8],
2573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2574 debug_assert_eq!(node.kind(), "dimensions_expr");
2575 Ok(Self {
2576 span: ::treesitter_types::Span::from(node),
2577 children: {
2578 #[allow(clippy::suspicious_else_formatting)]
2579 let non_field_children = {
2580 let mut cursor = node.walk();
2581 let mut result = ::std::vec::Vec::new();
2582 if cursor.goto_first_child() {
2583 loop {
2584 if cursor.field_name().is_none()
2585 && cursor.node().is_named()
2586 && !cursor.node().is_extra()
2587 {
2588 result.push(cursor.node());
2589 }
2590 if !cursor.goto_next_sibling() {
2591 break;
2592 }
2593 }
2594 }
2595 result
2596 };
2597 let mut items = ::std::vec::Vec::new();
2598 for child in non_field_children {
2599 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2600 <DimensionsExprChildren as ::treesitter_types::FromNode>::from_node(
2601 child, src,
2602 )
2603 })?);
2604 }
2605 items
2606 },
2607 })
2608 }
2609}
2610impl ::treesitter_types::Spanned for DimensionsExpr<'_> {
2611 fn span(&self) -> ::treesitter_types::Span {
2612 self.span
2613 }
2614}
2615#[derive(Debug, Clone, PartialEq, Eq)]
2616pub struct DoStatement<'tree> {
2617 pub span: ::treesitter_types::Span,
2618 pub body: Statement<'tree>,
2619 pub condition: ParenthesizedExpression<'tree>,
2620}
2621impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2622 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2623 fn from_node(
2624 node: ::treesitter_types::tree_sitter::Node<'tree>,
2625 src: &'tree [u8],
2626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2627 debug_assert_eq!(node.kind(), "do_statement");
2628 Ok(Self {
2629 span: ::treesitter_types::Span::from(node),
2630 body: {
2631 let child = node
2632 .child_by_field_name("body")
2633 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2634 ::treesitter_types::runtime::maybe_grow_stack(|| {
2635 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2636 })?
2637 },
2638 condition: {
2639 let child = node.child_by_field_name("condition").ok_or_else(|| {
2640 ::treesitter_types::ParseError::missing_field("condition", node)
2641 })?;
2642 ::treesitter_types::runtime::maybe_grow_stack(|| {
2643 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
2644 })?
2645 },
2646 })
2647 }
2648}
2649impl ::treesitter_types::Spanned for DoStatement<'_> {
2650 fn span(&self) -> ::treesitter_types::Span {
2651 self.span
2652 }
2653}
2654#[derive(Debug, Clone, PartialEq, Eq)]
2655pub struct ElementValueArrayInitializer<'tree> {
2656 pub span: ::treesitter_types::Span,
2657 pub children: ::std::vec::Vec<ElementValueArrayInitializerChildren<'tree>>,
2658}
2659impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializer<'tree> {
2660 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2661 fn from_node(
2662 node: ::treesitter_types::tree_sitter::Node<'tree>,
2663 src: &'tree [u8],
2664 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2665 debug_assert_eq!(node.kind(), "element_value_array_initializer");
2666 Ok(Self {
2667 span: ::treesitter_types::Span::from(node),
2668 children: {
2669 #[allow(clippy::suspicious_else_formatting)]
2670 let non_field_children = {
2671 let mut cursor = node.walk();
2672 let mut result = ::std::vec::Vec::new();
2673 if cursor.goto_first_child() {
2674 loop {
2675 if cursor.field_name().is_none()
2676 && cursor.node().is_named()
2677 && !cursor.node().is_extra()
2678 {
2679 result.push(cursor.node());
2680 }
2681 if !cursor.goto_next_sibling() {
2682 break;
2683 }
2684 }
2685 }
2686 result
2687 };
2688 let mut items = ::std::vec::Vec::new();
2689 for child in non_field_children {
2690 items
2691 .push(
2692 ::treesitter_types::runtime::maybe_grow_stack(|| <ElementValueArrayInitializerChildren as ::treesitter_types::FromNode>::from_node(
2693 child,
2694 src,
2695 ))?,
2696 );
2697 }
2698 items
2699 },
2700 })
2701 }
2702}
2703impl ::treesitter_types::Spanned for ElementValueArrayInitializer<'_> {
2704 fn span(&self) -> ::treesitter_types::Span {
2705 self.span
2706 }
2707}
2708#[derive(Debug, Clone, PartialEq, Eq)]
2709pub struct ElementValuePair<'tree> {
2710 pub span: ::treesitter_types::Span,
2711 pub key: Identifier<'tree>,
2712 pub value: ElementValuePairValue<'tree>,
2713}
2714impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePair<'tree> {
2715 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2716 fn from_node(
2717 node: ::treesitter_types::tree_sitter::Node<'tree>,
2718 src: &'tree [u8],
2719 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2720 debug_assert_eq!(node.kind(), "element_value_pair");
2721 Ok(Self {
2722 span: ::treesitter_types::Span::from(node),
2723 key: {
2724 let child = node
2725 .child_by_field_name("key")
2726 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
2727 ::treesitter_types::runtime::maybe_grow_stack(|| {
2728 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2729 })?
2730 },
2731 value: {
2732 let child = node
2733 .child_by_field_name("value")
2734 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2735 ::treesitter_types::runtime::maybe_grow_stack(|| {
2736 <ElementValuePairValue as ::treesitter_types::FromNode>::from_node(child, src)
2737 })?
2738 },
2739 })
2740 }
2741}
2742impl ::treesitter_types::Spanned for ElementValuePair<'_> {
2743 fn span(&self) -> ::treesitter_types::Span {
2744 self.span
2745 }
2746}
2747#[derive(Debug, Clone, PartialEq, Eq)]
2748pub struct EnhancedForStatement<'tree> {
2749 pub span: ::treesitter_types::Span,
2750 pub body: Statement<'tree>,
2751 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
2752 pub name: EnhancedForStatementName<'tree>,
2753 pub r#type: UnannotatedType<'tree>,
2754 pub value: Expression<'tree>,
2755 pub children: ::core::option::Option<Modifiers<'tree>>,
2756}
2757impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatement<'tree> {
2758 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2759 fn from_node(
2760 node: ::treesitter_types::tree_sitter::Node<'tree>,
2761 src: &'tree [u8],
2762 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2763 debug_assert_eq!(node.kind(), "enhanced_for_statement");
2764 Ok(Self {
2765 span: ::treesitter_types::Span::from(node),
2766 body: {
2767 let child = node
2768 .child_by_field_name("body")
2769 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2770 ::treesitter_types::runtime::maybe_grow_stack(|| {
2771 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2772 })?
2773 },
2774 dimensions: match node.child_by_field_name("dimensions") {
2775 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2776 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
2777 })?),
2778 None => None,
2779 },
2780 name: {
2781 let child = node
2782 .child_by_field_name("name")
2783 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2784 ::treesitter_types::runtime::maybe_grow_stack(|| {
2785 <EnhancedForStatementName as ::treesitter_types::FromNode>::from_node(
2786 child, src,
2787 )
2788 })?
2789 },
2790 r#type: {
2791 let child = node
2792 .child_by_field_name("type")
2793 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2794 ::treesitter_types::runtime::maybe_grow_stack(|| {
2795 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
2796 })?
2797 },
2798 value: {
2799 let child = node
2800 .child_by_field_name("value")
2801 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2802 ::treesitter_types::runtime::maybe_grow_stack(|| {
2803 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2804 })?
2805 },
2806 children: {
2807 #[allow(clippy::suspicious_else_formatting)]
2808 let non_field_children = {
2809 let mut cursor = node.walk();
2810 let mut result = ::std::vec::Vec::new();
2811 if cursor.goto_first_child() {
2812 loop {
2813 if cursor.field_name().is_none()
2814 && cursor.node().is_named()
2815 && !cursor.node().is_extra()
2816 {
2817 result.push(cursor.node());
2818 }
2819 if !cursor.goto_next_sibling() {
2820 break;
2821 }
2822 }
2823 }
2824 result
2825 };
2826 match non_field_children.first() {
2827 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2828 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
2829 })?),
2830 None => None,
2831 }
2832 },
2833 })
2834 }
2835}
2836impl ::treesitter_types::Spanned for EnhancedForStatement<'_> {
2837 fn span(&self) -> ::treesitter_types::Span {
2838 self.span
2839 }
2840}
2841#[derive(Debug, Clone, PartialEq, Eq)]
2842pub struct EnumBody<'tree> {
2843 pub span: ::treesitter_types::Span,
2844 pub children: ::std::vec::Vec<EnumBodyChildren<'tree>>,
2845}
2846impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBody<'tree> {
2847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2848 fn from_node(
2849 node: ::treesitter_types::tree_sitter::Node<'tree>,
2850 src: &'tree [u8],
2851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2852 debug_assert_eq!(node.kind(), "enum_body");
2853 Ok(Self {
2854 span: ::treesitter_types::Span::from(node),
2855 children: {
2856 #[allow(clippy::suspicious_else_formatting)]
2857 let non_field_children = {
2858 let mut cursor = node.walk();
2859 let mut result = ::std::vec::Vec::new();
2860 if cursor.goto_first_child() {
2861 loop {
2862 if cursor.field_name().is_none()
2863 && cursor.node().is_named()
2864 && !cursor.node().is_extra()
2865 {
2866 result.push(cursor.node());
2867 }
2868 if !cursor.goto_next_sibling() {
2869 break;
2870 }
2871 }
2872 }
2873 result
2874 };
2875 let mut items = ::std::vec::Vec::new();
2876 for child in non_field_children {
2877 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2878 <EnumBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
2879 })?);
2880 }
2881 items
2882 },
2883 })
2884 }
2885}
2886impl ::treesitter_types::Spanned for EnumBody<'_> {
2887 fn span(&self) -> ::treesitter_types::Span {
2888 self.span
2889 }
2890}
2891#[derive(Debug, Clone, PartialEq, Eq)]
2892pub struct EnumBodyDeclarations<'tree> {
2893 pub span: ::treesitter_types::Span,
2894 pub children: ::std::vec::Vec<EnumBodyDeclarationsChildren<'tree>>,
2895}
2896impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarations<'tree> {
2897 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2898 fn from_node(
2899 node: ::treesitter_types::tree_sitter::Node<'tree>,
2900 src: &'tree [u8],
2901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2902 debug_assert_eq!(node.kind(), "enum_body_declarations");
2903 Ok(Self {
2904 span: ::treesitter_types::Span::from(node),
2905 children: {
2906 #[allow(clippy::suspicious_else_formatting)]
2907 let non_field_children = {
2908 let mut cursor = node.walk();
2909 let mut result = ::std::vec::Vec::new();
2910 if cursor.goto_first_child() {
2911 loop {
2912 if cursor.field_name().is_none()
2913 && cursor.node().is_named()
2914 && !cursor.node().is_extra()
2915 {
2916 result.push(cursor.node());
2917 }
2918 if !cursor.goto_next_sibling() {
2919 break;
2920 }
2921 }
2922 }
2923 result
2924 };
2925 let mut items = ::std::vec::Vec::new();
2926 for child in non_field_children {
2927 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2928 <EnumBodyDeclarationsChildren as ::treesitter_types::FromNode>::from_node(
2929 child, src,
2930 )
2931 })?);
2932 }
2933 items
2934 },
2935 })
2936 }
2937}
2938impl ::treesitter_types::Spanned for EnumBodyDeclarations<'_> {
2939 fn span(&self) -> ::treesitter_types::Span {
2940 self.span
2941 }
2942}
2943#[derive(Debug, Clone, PartialEq, Eq)]
2944pub struct EnumConstant<'tree> {
2945 pub span: ::treesitter_types::Span,
2946 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
2947 pub body: ::core::option::Option<ClassBody<'tree>>,
2948 pub name: Identifier<'tree>,
2949 pub children: ::core::option::Option<Modifiers<'tree>>,
2950}
2951impl<'tree> ::treesitter_types::FromNode<'tree> for EnumConstant<'tree> {
2952 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2953 fn from_node(
2954 node: ::treesitter_types::tree_sitter::Node<'tree>,
2955 src: &'tree [u8],
2956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2957 debug_assert_eq!(node.kind(), "enum_constant");
2958 Ok(Self {
2959 span: ::treesitter_types::Span::from(node),
2960 arguments: match node.child_by_field_name("arguments") {
2961 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2962 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
2963 })?),
2964 None => None,
2965 },
2966 body: match node.child_by_field_name("body") {
2967 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2968 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)
2969 })?),
2970 None => None,
2971 },
2972 name: {
2973 let child = node
2974 .child_by_field_name("name")
2975 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2976 ::treesitter_types::runtime::maybe_grow_stack(|| {
2977 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2978 })?
2979 },
2980 children: {
2981 #[allow(clippy::suspicious_else_formatting)]
2982 let non_field_children = {
2983 let mut cursor = node.walk();
2984 let mut result = ::std::vec::Vec::new();
2985 if cursor.goto_first_child() {
2986 loop {
2987 if cursor.field_name().is_none()
2988 && cursor.node().is_named()
2989 && !cursor.node().is_extra()
2990 {
2991 result.push(cursor.node());
2992 }
2993 if !cursor.goto_next_sibling() {
2994 break;
2995 }
2996 }
2997 }
2998 result
2999 };
3000 match non_field_children.first() {
3001 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3002 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
3003 })?),
3004 None => None,
3005 }
3006 },
3007 })
3008 }
3009}
3010impl ::treesitter_types::Spanned for EnumConstant<'_> {
3011 fn span(&self) -> ::treesitter_types::Span {
3012 self.span
3013 }
3014}
3015#[derive(Debug, Clone, PartialEq, Eq)]
3016pub struct EnumDeclaration<'tree> {
3017 pub span: ::treesitter_types::Span,
3018 pub body: EnumBody<'tree>,
3019 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
3020 pub name: Identifier<'tree>,
3021 pub children: ::core::option::Option<Modifiers<'tree>>,
3022}
3023impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
3024 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3025 fn from_node(
3026 node: ::treesitter_types::tree_sitter::Node<'tree>,
3027 src: &'tree [u8],
3028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3029 debug_assert_eq!(node.kind(), "enum_declaration");
3030 Ok(Self {
3031 span: ::treesitter_types::Span::from(node),
3032 body: {
3033 let child = node
3034 .child_by_field_name("body")
3035 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3036 ::treesitter_types::runtime::maybe_grow_stack(|| {
3037 <EnumBody as ::treesitter_types::FromNode>::from_node(child, src)
3038 })?
3039 },
3040 interfaces: match node.child_by_field_name("interfaces") {
3041 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3042 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)
3043 })?),
3044 None => None,
3045 },
3046 name: {
3047 let child = node
3048 .child_by_field_name("name")
3049 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3050 ::treesitter_types::runtime::maybe_grow_stack(|| {
3051 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3052 })?
3053 },
3054 children: {
3055 #[allow(clippy::suspicious_else_formatting)]
3056 let non_field_children = {
3057 let mut cursor = node.walk();
3058 let mut result = ::std::vec::Vec::new();
3059 if cursor.goto_first_child() {
3060 loop {
3061 if cursor.field_name().is_none()
3062 && cursor.node().is_named()
3063 && !cursor.node().is_extra()
3064 {
3065 result.push(cursor.node());
3066 }
3067 if !cursor.goto_next_sibling() {
3068 break;
3069 }
3070 }
3071 }
3072 result
3073 };
3074 match non_field_children.first() {
3075 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3076 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
3077 })?),
3078 None => None,
3079 }
3080 },
3081 })
3082 }
3083}
3084impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
3085 fn span(&self) -> ::treesitter_types::Span {
3086 self.span
3087 }
3088}
3089#[derive(Debug, Clone, PartialEq, Eq)]
3090pub struct ExplicitConstructorInvocation<'tree> {
3091 pub span: ::treesitter_types::Span,
3092 pub arguments: ArgumentList<'tree>,
3093 pub constructor: ExplicitConstructorInvocationConstructor<'tree>,
3094 pub object: ::core::option::Option<PrimaryExpression<'tree>>,
3095 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
3096}
3097impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitConstructorInvocation<'tree> {
3098 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3099 fn from_node(
3100 node: ::treesitter_types::tree_sitter::Node<'tree>,
3101 src: &'tree [u8],
3102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3103 debug_assert_eq!(node.kind(), "explicit_constructor_invocation");
3104 Ok(Self {
3105 span: ::treesitter_types::Span::from(node),
3106 arguments: {
3107 let child = node.child_by_field_name("arguments").ok_or_else(|| {
3108 ::treesitter_types::ParseError::missing_field("arguments", node)
3109 })?;
3110 ::treesitter_types::runtime::maybe_grow_stack(|| {
3111 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
3112 })?
3113 },
3114 constructor: {
3115 let child = node.child_by_field_name("constructor").ok_or_else(|| {
3116 ::treesitter_types::ParseError::missing_field("constructor", node)
3117 })?;
3118 ::treesitter_types::runtime::maybe_grow_stack(|| {
3119 <ExplicitConstructorInvocationConstructor as ::treesitter_types::FromNode>::from_node(
3120 child,
3121 src,
3122 )
3123 })?
3124 },
3125 object: match node.child_by_field_name("object") {
3126 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3127 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)
3128 })?),
3129 None => None,
3130 },
3131 type_arguments: match node.child_by_field_name("type_arguments") {
3132 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3133 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
3134 })?),
3135 None => None,
3136 },
3137 })
3138 }
3139}
3140impl ::treesitter_types::Spanned for ExplicitConstructorInvocation<'_> {
3141 fn span(&self) -> ::treesitter_types::Span {
3142 self.span
3143 }
3144}
3145#[derive(Debug, Clone, PartialEq, Eq)]
3146pub struct ExportsModuleDirective<'tree> {
3147 pub span: ::treesitter_types::Span,
3148 pub modules: ::std::vec::Vec<ExportsModuleDirectiveModules<'tree>>,
3149 pub package: ExportsModuleDirectivePackage<'tree>,
3150}
3151impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirective<'tree> {
3152 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3153 fn from_node(
3154 node: ::treesitter_types::tree_sitter::Node<'tree>,
3155 src: &'tree [u8],
3156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3157 debug_assert_eq!(node.kind(), "exports_module_directive");
3158 Ok(Self {
3159 span: ::treesitter_types::Span::from(node),
3160 modules: {
3161 let mut cursor = node.walk();
3162 let mut items = ::std::vec::Vec::new();
3163 for child in node.children_by_field_name("modules", &mut cursor) {
3164 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3165 <ExportsModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
3166 child, src,
3167 )
3168 })?);
3169 }
3170 items
3171 },
3172 package: {
3173 let child = node.child_by_field_name("package").ok_or_else(|| {
3174 ::treesitter_types::ParseError::missing_field("package", node)
3175 })?;
3176 ::treesitter_types::runtime::maybe_grow_stack(|| {
3177 <ExportsModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
3178 child, src,
3179 )
3180 })?
3181 },
3182 })
3183 }
3184}
3185impl ::treesitter_types::Spanned for ExportsModuleDirective<'_> {
3186 fn span(&self) -> ::treesitter_types::Span {
3187 self.span
3188 }
3189}
3190#[derive(Debug, Clone, PartialEq, Eq)]
3191pub struct ExpressionStatement<'tree> {
3192 pub span: ::treesitter_types::Span,
3193 pub children: Expression<'tree>,
3194}
3195impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3197 fn from_node(
3198 node: ::treesitter_types::tree_sitter::Node<'tree>,
3199 src: &'tree [u8],
3200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3201 debug_assert_eq!(node.kind(), "expression_statement");
3202 Ok(Self {
3203 span: ::treesitter_types::Span::from(node),
3204 children: {
3205 #[allow(clippy::suspicious_else_formatting)]
3206 let non_field_children = {
3207 let mut cursor = node.walk();
3208 let mut result = ::std::vec::Vec::new();
3209 if cursor.goto_first_child() {
3210 loop {
3211 if cursor.field_name().is_none()
3212 && cursor.node().is_named()
3213 && !cursor.node().is_extra()
3214 {
3215 result.push(cursor.node());
3216 }
3217 if !cursor.goto_next_sibling() {
3218 break;
3219 }
3220 }
3221 }
3222 result
3223 };
3224 let child = if let Some(&c) = non_field_children.first() {
3225 c
3226 } else {
3227 let mut fallback_cursor = node.walk();
3228 let mut fallback_child = None;
3229 if fallback_cursor.goto_first_child() {
3230 loop {
3231 if fallback_cursor.field_name().is_none()
3232 && !fallback_cursor.node().is_extra()
3233 {
3234 let candidate = fallback_cursor.node();
3235 #[allow(clippy::needless_question_mark)]
3236 if (|| -> ::core::result::Result<
3237 _,
3238 ::treesitter_types::ParseError,
3239 > {
3240 let child = candidate;
3241 Ok(
3242 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3243 child,
3244 src,
3245 ))?,
3246 )
3247 })()
3248 .is_ok()
3249 {
3250 fallback_child = Some(candidate);
3251 break;
3252 }
3253 }
3254 if !fallback_cursor.goto_next_sibling() {
3255 break;
3256 }
3257 }
3258 }
3259 if fallback_child.is_none() {
3260 let mut cursor2 = node.walk();
3261 if cursor2.goto_first_child() {
3262 loop {
3263 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3264 let candidate = cursor2.node();
3265 #[allow(clippy::needless_question_mark)]
3266 if (|| -> ::core::result::Result<
3267 _,
3268 ::treesitter_types::ParseError,
3269 > {
3270 let child = candidate;
3271 Ok(
3272 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3273 child,
3274 src,
3275 ))?,
3276 )
3277 })()
3278 .is_ok()
3279 {
3280 fallback_child = Some(candidate);
3281 break;
3282 }
3283 }
3284 if !cursor2.goto_next_sibling() {
3285 break;
3286 }
3287 }
3288 }
3289 }
3290 fallback_child.ok_or_else(|| {
3291 ::treesitter_types::ParseError::missing_field("children", node)
3292 })?
3293 };
3294 ::treesitter_types::runtime::maybe_grow_stack(|| {
3295 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3296 })?
3297 },
3298 })
3299 }
3300}
3301impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3302 fn span(&self) -> ::treesitter_types::Span {
3303 self.span
3304 }
3305}
3306#[derive(Debug, Clone, PartialEq, Eq)]
3307pub struct ExtendsInterfaces<'tree> {
3308 pub span: ::treesitter_types::Span,
3309 pub children: TypeList<'tree>,
3310}
3311impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsInterfaces<'tree> {
3312 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3313 fn from_node(
3314 node: ::treesitter_types::tree_sitter::Node<'tree>,
3315 src: &'tree [u8],
3316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3317 debug_assert_eq!(node.kind(), "extends_interfaces");
3318 Ok(Self {
3319 span: ::treesitter_types::Span::from(node),
3320 children: {
3321 #[allow(clippy::suspicious_else_formatting)]
3322 let non_field_children = {
3323 let mut cursor = node.walk();
3324 let mut result = ::std::vec::Vec::new();
3325 if cursor.goto_first_child() {
3326 loop {
3327 if cursor.field_name().is_none()
3328 && cursor.node().is_named()
3329 && !cursor.node().is_extra()
3330 {
3331 result.push(cursor.node());
3332 }
3333 if !cursor.goto_next_sibling() {
3334 break;
3335 }
3336 }
3337 }
3338 result
3339 };
3340 let child = if let Some(&c) = non_field_children.first() {
3341 c
3342 } else {
3343 let mut fallback_cursor = node.walk();
3344 let mut fallback_child = None;
3345 if fallback_cursor.goto_first_child() {
3346 loop {
3347 if fallback_cursor.field_name().is_none()
3348 && !fallback_cursor.node().is_extra()
3349 {
3350 let candidate = fallback_cursor.node();
3351 #[allow(clippy::needless_question_mark)]
3352 if (|| -> ::core::result::Result<
3353 _,
3354 ::treesitter_types::ParseError,
3355 > {
3356 let child = candidate;
3357 Ok(
3358 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
3359 child,
3360 src,
3361 ))?,
3362 )
3363 })()
3364 .is_ok()
3365 {
3366 fallback_child = Some(candidate);
3367 break;
3368 }
3369 }
3370 if !fallback_cursor.goto_next_sibling() {
3371 break;
3372 }
3373 }
3374 }
3375 if fallback_child.is_none() {
3376 let mut cursor2 = node.walk();
3377 if cursor2.goto_first_child() {
3378 loop {
3379 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3380 let candidate = cursor2.node();
3381 #[allow(clippy::needless_question_mark)]
3382 if (|| -> ::core::result::Result<
3383 _,
3384 ::treesitter_types::ParseError,
3385 > {
3386 let child = candidate;
3387 Ok(
3388 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
3389 child,
3390 src,
3391 ))?,
3392 )
3393 })()
3394 .is_ok()
3395 {
3396 fallback_child = Some(candidate);
3397 break;
3398 }
3399 }
3400 if !cursor2.goto_next_sibling() {
3401 break;
3402 }
3403 }
3404 }
3405 }
3406 fallback_child.ok_or_else(|| {
3407 ::treesitter_types::ParseError::missing_field("children", node)
3408 })?
3409 };
3410 ::treesitter_types::runtime::maybe_grow_stack(|| {
3411 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)
3412 })?
3413 },
3414 })
3415 }
3416}
3417impl ::treesitter_types::Spanned for ExtendsInterfaces<'_> {
3418 fn span(&self) -> ::treesitter_types::Span {
3419 self.span
3420 }
3421}
3422#[derive(Debug, Clone, PartialEq, Eq)]
3423pub struct FieldAccess<'tree> {
3424 pub span: ::treesitter_types::Span,
3425 pub field: FieldAccessField<'tree>,
3426 pub object: FieldAccessObject<'tree>,
3427 pub children: ::core::option::Option<Super<'tree>>,
3428}
3429impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccess<'tree> {
3430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3431 fn from_node(
3432 node: ::treesitter_types::tree_sitter::Node<'tree>,
3433 src: &'tree [u8],
3434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3435 debug_assert_eq!(node.kind(), "field_access");
3436 Ok(Self {
3437 span: ::treesitter_types::Span::from(node),
3438 field: {
3439 let child = node
3440 .child_by_field_name("field")
3441 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3442 ::treesitter_types::runtime::maybe_grow_stack(|| {
3443 <FieldAccessField as ::treesitter_types::FromNode>::from_node(child, src)
3444 })?
3445 },
3446 object: {
3447 let child = node
3448 .child_by_field_name("object")
3449 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
3450 ::treesitter_types::runtime::maybe_grow_stack(|| {
3451 <FieldAccessObject as ::treesitter_types::FromNode>::from_node(child, src)
3452 })?
3453 },
3454 children: {
3455 #[allow(clippy::suspicious_else_formatting)]
3456 let non_field_children = {
3457 let mut cursor = node.walk();
3458 let mut result = ::std::vec::Vec::new();
3459 if cursor.goto_first_child() {
3460 loop {
3461 if cursor.field_name().is_none()
3462 && cursor.node().is_named()
3463 && !cursor.node().is_extra()
3464 {
3465 result.push(cursor.node());
3466 }
3467 if !cursor.goto_next_sibling() {
3468 break;
3469 }
3470 }
3471 }
3472 result
3473 };
3474 match non_field_children.first() {
3475 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3476 <Super as ::treesitter_types::FromNode>::from_node(child, src)
3477 })?),
3478 None => None,
3479 }
3480 },
3481 })
3482 }
3483}
3484impl ::treesitter_types::Spanned for FieldAccess<'_> {
3485 fn span(&self) -> ::treesitter_types::Span {
3486 self.span
3487 }
3488}
3489#[derive(Debug, Clone, PartialEq, Eq)]
3490pub struct FieldDeclaration<'tree> {
3491 pub span: ::treesitter_types::Span,
3492 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
3493 pub r#type: UnannotatedType<'tree>,
3494 pub children: ::core::option::Option<Modifiers<'tree>>,
3495}
3496impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
3497 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3498 fn from_node(
3499 node: ::treesitter_types::tree_sitter::Node<'tree>,
3500 src: &'tree [u8],
3501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3502 debug_assert_eq!(node.kind(), "field_declaration");
3503 Ok(Self {
3504 span: ::treesitter_types::Span::from(node),
3505 declarator: {
3506 let mut cursor = node.walk();
3507 let mut items = ::std::vec::Vec::new();
3508 for child in node.children_by_field_name("declarator", &mut cursor) {
3509 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3510 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
3511 })?);
3512 }
3513 items
3514 },
3515 r#type: {
3516 let child = node
3517 .child_by_field_name("type")
3518 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3519 ::treesitter_types::runtime::maybe_grow_stack(|| {
3520 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
3521 })?
3522 },
3523 children: {
3524 #[allow(clippy::suspicious_else_formatting)]
3525 let non_field_children = {
3526 let mut cursor = node.walk();
3527 let mut result = ::std::vec::Vec::new();
3528 if cursor.goto_first_child() {
3529 loop {
3530 if cursor.field_name().is_none()
3531 && cursor.node().is_named()
3532 && !cursor.node().is_extra()
3533 {
3534 result.push(cursor.node());
3535 }
3536 if !cursor.goto_next_sibling() {
3537 break;
3538 }
3539 }
3540 }
3541 result
3542 };
3543 match non_field_children.first() {
3544 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3545 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
3546 })?),
3547 None => None,
3548 }
3549 },
3550 })
3551 }
3552}
3553impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
3554 fn span(&self) -> ::treesitter_types::Span {
3555 self.span
3556 }
3557}
3558#[derive(Debug, Clone, PartialEq, Eq)]
3559pub struct FinallyClause<'tree> {
3560 pub span: ::treesitter_types::Span,
3561 pub children: Block<'tree>,
3562}
3563impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3564 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3565 fn from_node(
3566 node: ::treesitter_types::tree_sitter::Node<'tree>,
3567 src: &'tree [u8],
3568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3569 debug_assert_eq!(node.kind(), "finally_clause");
3570 Ok(Self {
3571 span: ::treesitter_types::Span::from(node),
3572 children: {
3573 #[allow(clippy::suspicious_else_formatting)]
3574 let non_field_children = {
3575 let mut cursor = node.walk();
3576 let mut result = ::std::vec::Vec::new();
3577 if cursor.goto_first_child() {
3578 loop {
3579 if cursor.field_name().is_none()
3580 && cursor.node().is_named()
3581 && !cursor.node().is_extra()
3582 {
3583 result.push(cursor.node());
3584 }
3585 if !cursor.goto_next_sibling() {
3586 break;
3587 }
3588 }
3589 }
3590 result
3591 };
3592 let child = if let Some(&c) = non_field_children.first() {
3593 c
3594 } else {
3595 let mut fallback_cursor = node.walk();
3596 let mut fallback_child = None;
3597 if fallback_cursor.goto_first_child() {
3598 loop {
3599 if fallback_cursor.field_name().is_none()
3600 && !fallback_cursor.node().is_extra()
3601 {
3602 let candidate = fallback_cursor.node();
3603 #[allow(clippy::needless_question_mark)]
3604 if (|| -> ::core::result::Result<
3605 _,
3606 ::treesitter_types::ParseError,
3607 > {
3608 let child = candidate;
3609 Ok(
3610 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3611 child,
3612 src,
3613 ))?,
3614 )
3615 })()
3616 .is_ok()
3617 {
3618 fallback_child = Some(candidate);
3619 break;
3620 }
3621 }
3622 if !fallback_cursor.goto_next_sibling() {
3623 break;
3624 }
3625 }
3626 }
3627 if fallback_child.is_none() {
3628 let mut cursor2 = node.walk();
3629 if cursor2.goto_first_child() {
3630 loop {
3631 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3632 let candidate = cursor2.node();
3633 #[allow(clippy::needless_question_mark)]
3634 if (|| -> ::core::result::Result<
3635 _,
3636 ::treesitter_types::ParseError,
3637 > {
3638 let child = candidate;
3639 Ok(
3640 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3641 child,
3642 src,
3643 ))?,
3644 )
3645 })()
3646 .is_ok()
3647 {
3648 fallback_child = Some(candidate);
3649 break;
3650 }
3651 }
3652 if !cursor2.goto_next_sibling() {
3653 break;
3654 }
3655 }
3656 }
3657 }
3658 fallback_child.ok_or_else(|| {
3659 ::treesitter_types::ParseError::missing_field("children", node)
3660 })?
3661 };
3662 ::treesitter_types::runtime::maybe_grow_stack(|| {
3663 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3664 })?
3665 },
3666 })
3667 }
3668}
3669impl ::treesitter_types::Spanned for FinallyClause<'_> {
3670 fn span(&self) -> ::treesitter_types::Span {
3671 self.span
3672 }
3673}
3674#[derive(Debug, Clone, PartialEq, Eq)]
3675pub struct FloatingPointType<'tree> {
3676 pub span: ::treesitter_types::Span,
3677 text: &'tree str,
3678}
3679impl<'tree> ::treesitter_types::FromNode<'tree> for FloatingPointType<'tree> {
3680 fn from_node(
3681 node: ::treesitter_types::tree_sitter::Node<'tree>,
3682 src: &'tree [u8],
3683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3684 debug_assert_eq!(node.kind(), "floating_point_type");
3685 Ok(Self {
3686 span: ::treesitter_types::Span::from(node),
3687 text: node.utf8_text(src)?,
3688 })
3689 }
3690}
3691impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatingPointType<'tree> {
3692 fn text(&self) -> &'tree str {
3693 self.text
3694 }
3695}
3696impl ::treesitter_types::Spanned for FloatingPointType<'_> {
3697 fn span(&self) -> ::treesitter_types::Span {
3698 self.span
3699 }
3700}
3701#[derive(Debug, Clone, PartialEq, Eq)]
3702pub struct ForStatement<'tree> {
3703 pub span: ::treesitter_types::Span,
3704 pub body: Statement<'tree>,
3705 pub condition: ::core::option::Option<Expression<'tree>>,
3706 pub init: ::std::vec::Vec<ForStatementInit<'tree>>,
3707 pub update: ::std::vec::Vec<Expression<'tree>>,
3708}
3709impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3710 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3711 fn from_node(
3712 node: ::treesitter_types::tree_sitter::Node<'tree>,
3713 src: &'tree [u8],
3714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3715 debug_assert_eq!(node.kind(), "for_statement");
3716 Ok(Self {
3717 span: ::treesitter_types::Span::from(node),
3718 body: {
3719 let child = node
3720 .child_by_field_name("body")
3721 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3722 ::treesitter_types::runtime::maybe_grow_stack(|| {
3723 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3724 })?
3725 },
3726 condition: match node.child_by_field_name("condition") {
3727 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3728 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3729 })?),
3730 None => None,
3731 },
3732 init: {
3733 let mut cursor = node.walk();
3734 let mut items = ::std::vec::Vec::new();
3735 for child in node.children_by_field_name("init", &mut cursor) {
3736 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3737 <ForStatementInit as ::treesitter_types::FromNode>::from_node(child, src)
3738 })?);
3739 }
3740 items
3741 },
3742 update: {
3743 let mut cursor = node.walk();
3744 let mut items = ::std::vec::Vec::new();
3745 for child in node.children_by_field_name("update", &mut cursor) {
3746 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3747 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3748 })?);
3749 }
3750 items
3751 },
3752 })
3753 }
3754}
3755impl ::treesitter_types::Spanned for ForStatement<'_> {
3756 fn span(&self) -> ::treesitter_types::Span {
3757 self.span
3758 }
3759}
3760#[derive(Debug, Clone, PartialEq, Eq)]
3761pub struct FormalParameter<'tree> {
3762 pub span: ::treesitter_types::Span,
3763 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
3764 pub name: FormalParameterName<'tree>,
3765 pub r#type: UnannotatedType<'tree>,
3766 pub children: ::core::option::Option<Modifiers<'tree>>,
3767}
3768impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameter<'tree> {
3769 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3770 fn from_node(
3771 node: ::treesitter_types::tree_sitter::Node<'tree>,
3772 src: &'tree [u8],
3773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3774 debug_assert_eq!(node.kind(), "formal_parameter");
3775 Ok(Self {
3776 span: ::treesitter_types::Span::from(node),
3777 dimensions: match node.child_by_field_name("dimensions") {
3778 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3779 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
3780 })?),
3781 None => None,
3782 },
3783 name: {
3784 let child = node
3785 .child_by_field_name("name")
3786 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3787 ::treesitter_types::runtime::maybe_grow_stack(|| {
3788 <FormalParameterName as ::treesitter_types::FromNode>::from_node(child, src)
3789 })?
3790 },
3791 r#type: {
3792 let child = node
3793 .child_by_field_name("type")
3794 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3795 ::treesitter_types::runtime::maybe_grow_stack(|| {
3796 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
3797 })?
3798 },
3799 children: {
3800 #[allow(clippy::suspicious_else_formatting)]
3801 let non_field_children = {
3802 let mut cursor = node.walk();
3803 let mut result = ::std::vec::Vec::new();
3804 if cursor.goto_first_child() {
3805 loop {
3806 if cursor.field_name().is_none()
3807 && cursor.node().is_named()
3808 && !cursor.node().is_extra()
3809 {
3810 result.push(cursor.node());
3811 }
3812 if !cursor.goto_next_sibling() {
3813 break;
3814 }
3815 }
3816 }
3817 result
3818 };
3819 match non_field_children.first() {
3820 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3821 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
3822 })?),
3823 None => None,
3824 }
3825 },
3826 })
3827 }
3828}
3829impl ::treesitter_types::Spanned for FormalParameter<'_> {
3830 fn span(&self) -> ::treesitter_types::Span {
3831 self.span
3832 }
3833}
3834#[derive(Debug, Clone, PartialEq, Eq)]
3835pub struct FormalParameters<'tree> {
3836 pub span: ::treesitter_types::Span,
3837 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
3838}
3839impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
3840 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3841 fn from_node(
3842 node: ::treesitter_types::tree_sitter::Node<'tree>,
3843 src: &'tree [u8],
3844 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3845 debug_assert_eq!(node.kind(), "formal_parameters");
3846 Ok(Self {
3847 span: ::treesitter_types::Span::from(node),
3848 children: {
3849 #[allow(clippy::suspicious_else_formatting)]
3850 let non_field_children = {
3851 let mut cursor = node.walk();
3852 let mut result = ::std::vec::Vec::new();
3853 if cursor.goto_first_child() {
3854 loop {
3855 if cursor.field_name().is_none()
3856 && cursor.node().is_named()
3857 && !cursor.node().is_extra()
3858 {
3859 result.push(cursor.node());
3860 }
3861 if !cursor.goto_next_sibling() {
3862 break;
3863 }
3864 }
3865 }
3866 result
3867 };
3868 let mut items = ::std::vec::Vec::new();
3869 for child in non_field_children {
3870 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3871 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
3872 child, src,
3873 )
3874 })?);
3875 }
3876 items
3877 },
3878 })
3879 }
3880}
3881impl ::treesitter_types::Spanned for FormalParameters<'_> {
3882 fn span(&self) -> ::treesitter_types::Span {
3883 self.span
3884 }
3885}
3886#[derive(Debug, Clone, PartialEq, Eq)]
3887pub struct GenericType<'tree> {
3888 pub span: ::treesitter_types::Span,
3889 pub children: ::std::vec::Vec<GenericTypeChildren<'tree>>,
3890}
3891impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
3892 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3893 fn from_node(
3894 node: ::treesitter_types::tree_sitter::Node<'tree>,
3895 src: &'tree [u8],
3896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3897 debug_assert_eq!(node.kind(), "generic_type");
3898 Ok(Self {
3899 span: ::treesitter_types::Span::from(node),
3900 children: {
3901 #[allow(clippy::suspicious_else_formatting)]
3902 let non_field_children = {
3903 let mut cursor = node.walk();
3904 let mut result = ::std::vec::Vec::new();
3905 if cursor.goto_first_child() {
3906 loop {
3907 if cursor.field_name().is_none()
3908 && cursor.node().is_named()
3909 && !cursor.node().is_extra()
3910 {
3911 result.push(cursor.node());
3912 }
3913 if !cursor.goto_next_sibling() {
3914 break;
3915 }
3916 }
3917 }
3918 result
3919 };
3920 let mut items = ::std::vec::Vec::new();
3921 for child in non_field_children {
3922 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3923 <GenericTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
3924 })?);
3925 }
3926 items
3927 },
3928 })
3929 }
3930}
3931impl ::treesitter_types::Spanned for GenericType<'_> {
3932 fn span(&self) -> ::treesitter_types::Span {
3933 self.span
3934 }
3935}
3936#[derive(Debug, Clone, PartialEq, Eq)]
3937pub struct Guard<'tree> {
3938 pub span: ::treesitter_types::Span,
3939 pub children: Expression<'tree>,
3940}
3941impl<'tree> ::treesitter_types::FromNode<'tree> for Guard<'tree> {
3942 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3943 fn from_node(
3944 node: ::treesitter_types::tree_sitter::Node<'tree>,
3945 src: &'tree [u8],
3946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3947 debug_assert_eq!(node.kind(), "guard");
3948 Ok(Self {
3949 span: ::treesitter_types::Span::from(node),
3950 children: {
3951 #[allow(clippy::suspicious_else_formatting)]
3952 let non_field_children = {
3953 let mut cursor = node.walk();
3954 let mut result = ::std::vec::Vec::new();
3955 if cursor.goto_first_child() {
3956 loop {
3957 if cursor.field_name().is_none()
3958 && cursor.node().is_named()
3959 && !cursor.node().is_extra()
3960 {
3961 result.push(cursor.node());
3962 }
3963 if !cursor.goto_next_sibling() {
3964 break;
3965 }
3966 }
3967 }
3968 result
3969 };
3970 let child = if let Some(&c) = non_field_children.first() {
3971 c
3972 } else {
3973 let mut fallback_cursor = node.walk();
3974 let mut fallback_child = None;
3975 if fallback_cursor.goto_first_child() {
3976 loop {
3977 if fallback_cursor.field_name().is_none()
3978 && !fallback_cursor.node().is_extra()
3979 {
3980 let candidate = fallback_cursor.node();
3981 #[allow(clippy::needless_question_mark)]
3982 if (|| -> ::core::result::Result<
3983 _,
3984 ::treesitter_types::ParseError,
3985 > {
3986 let child = candidate;
3987 Ok(
3988 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3989 child,
3990 src,
3991 ))?,
3992 )
3993 })()
3994 .is_ok()
3995 {
3996 fallback_child = Some(candidate);
3997 break;
3998 }
3999 }
4000 if !fallback_cursor.goto_next_sibling() {
4001 break;
4002 }
4003 }
4004 }
4005 if fallback_child.is_none() {
4006 let mut cursor2 = node.walk();
4007 if cursor2.goto_first_child() {
4008 loop {
4009 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4010 let candidate = cursor2.node();
4011 #[allow(clippy::needless_question_mark)]
4012 if (|| -> ::core::result::Result<
4013 _,
4014 ::treesitter_types::ParseError,
4015 > {
4016 let child = candidate;
4017 Ok(
4018 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4019 child,
4020 src,
4021 ))?,
4022 )
4023 })()
4024 .is_ok()
4025 {
4026 fallback_child = Some(candidate);
4027 break;
4028 }
4029 }
4030 if !cursor2.goto_next_sibling() {
4031 break;
4032 }
4033 }
4034 }
4035 }
4036 fallback_child.ok_or_else(|| {
4037 ::treesitter_types::ParseError::missing_field("children", node)
4038 })?
4039 };
4040 ::treesitter_types::runtime::maybe_grow_stack(|| {
4041 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4042 })?
4043 },
4044 })
4045 }
4046}
4047impl ::treesitter_types::Spanned for Guard<'_> {
4048 fn span(&self) -> ::treesitter_types::Span {
4049 self.span
4050 }
4051}
4052#[derive(Debug, Clone, PartialEq, Eq)]
4053pub struct IfStatement<'tree> {
4054 pub span: ::treesitter_types::Span,
4055 pub alternative: ::core::option::Option<Statement<'tree>>,
4056 pub condition: ParenthesizedExpression<'tree>,
4057 pub consequence: Statement<'tree>,
4058}
4059impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
4060 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4061 fn from_node(
4062 node: ::treesitter_types::tree_sitter::Node<'tree>,
4063 src: &'tree [u8],
4064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4065 debug_assert_eq!(node.kind(), "if_statement");
4066 Ok(Self {
4067 span: ::treesitter_types::Span::from(node),
4068 alternative: match node.child_by_field_name("alternative") {
4069 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4070 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4071 })?),
4072 None => None,
4073 },
4074 condition: {
4075 let child = node.child_by_field_name("condition").ok_or_else(|| {
4076 ::treesitter_types::ParseError::missing_field("condition", node)
4077 })?;
4078 ::treesitter_types::runtime::maybe_grow_stack(|| {
4079 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
4080 })?
4081 },
4082 consequence: {
4083 let child = node.child_by_field_name("consequence").ok_or_else(|| {
4084 ::treesitter_types::ParseError::missing_field("consequence", node)
4085 })?;
4086 ::treesitter_types::runtime::maybe_grow_stack(|| {
4087 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4088 })?
4089 },
4090 })
4091 }
4092}
4093impl ::treesitter_types::Spanned for IfStatement<'_> {
4094 fn span(&self) -> ::treesitter_types::Span {
4095 self.span
4096 }
4097}
4098#[derive(Debug, Clone, PartialEq, Eq)]
4099pub struct ImportDeclaration<'tree> {
4100 pub span: ::treesitter_types::Span,
4101 pub children: ::std::vec::Vec<ImportDeclarationChildren<'tree>>,
4102}
4103impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclaration<'tree> {
4104 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4105 fn from_node(
4106 node: ::treesitter_types::tree_sitter::Node<'tree>,
4107 src: &'tree [u8],
4108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4109 debug_assert_eq!(node.kind(), "import_declaration");
4110 Ok(Self {
4111 span: ::treesitter_types::Span::from(node),
4112 children: {
4113 #[allow(clippy::suspicious_else_formatting)]
4114 let non_field_children = {
4115 let mut cursor = node.walk();
4116 let mut result = ::std::vec::Vec::new();
4117 if cursor.goto_first_child() {
4118 loop {
4119 if cursor.field_name().is_none()
4120 && cursor.node().is_named()
4121 && !cursor.node().is_extra()
4122 {
4123 result.push(cursor.node());
4124 }
4125 if !cursor.goto_next_sibling() {
4126 break;
4127 }
4128 }
4129 }
4130 result
4131 };
4132 let mut items = ::std::vec::Vec::new();
4133 for child in non_field_children {
4134 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4135 <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4136 child, src,
4137 )
4138 })?);
4139 }
4140 items
4141 },
4142 })
4143 }
4144}
4145impl ::treesitter_types::Spanned for ImportDeclaration<'_> {
4146 fn span(&self) -> ::treesitter_types::Span {
4147 self.span
4148 }
4149}
4150#[derive(Debug, Clone, PartialEq, Eq)]
4151pub struct InferredParameters<'tree> {
4152 pub span: ::treesitter_types::Span,
4153 pub children: ::std::vec::Vec<Identifier<'tree>>,
4154}
4155impl<'tree> ::treesitter_types::FromNode<'tree> for InferredParameters<'tree> {
4156 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4157 fn from_node(
4158 node: ::treesitter_types::tree_sitter::Node<'tree>,
4159 src: &'tree [u8],
4160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4161 debug_assert_eq!(node.kind(), "inferred_parameters");
4162 Ok(Self {
4163 span: ::treesitter_types::Span::from(node),
4164 children: {
4165 #[allow(clippy::suspicious_else_formatting)]
4166 let non_field_children = {
4167 let mut cursor = node.walk();
4168 let mut result = ::std::vec::Vec::new();
4169 if cursor.goto_first_child() {
4170 loop {
4171 if cursor.field_name().is_none()
4172 && cursor.node().is_named()
4173 && !cursor.node().is_extra()
4174 {
4175 result.push(cursor.node());
4176 }
4177 if !cursor.goto_next_sibling() {
4178 break;
4179 }
4180 }
4181 }
4182 result
4183 };
4184 let mut items = ::std::vec::Vec::new();
4185 for child in non_field_children {
4186 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4187 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4188 })?);
4189 }
4190 items
4191 },
4192 })
4193 }
4194}
4195impl ::treesitter_types::Spanned for InferredParameters<'_> {
4196 fn span(&self) -> ::treesitter_types::Span {
4197 self.span
4198 }
4199}
4200#[derive(Debug, Clone, PartialEq, Eq)]
4201pub struct InstanceofExpression<'tree> {
4202 pub span: ::treesitter_types::Span,
4203 pub left: Expression<'tree>,
4204 pub name: ::core::option::Option<Identifier<'tree>>,
4205 pub pattern: ::core::option::Option<RecordPattern<'tree>>,
4206 pub right: ::core::option::Option<Type<'tree>>,
4207}
4208impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceofExpression<'tree> {
4209 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4210 fn from_node(
4211 node: ::treesitter_types::tree_sitter::Node<'tree>,
4212 src: &'tree [u8],
4213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4214 debug_assert_eq!(node.kind(), "instanceof_expression");
4215 Ok(Self {
4216 span: ::treesitter_types::Span::from(node),
4217 left: {
4218 let child = node
4219 .child_by_field_name("left")
4220 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4221 ::treesitter_types::runtime::maybe_grow_stack(|| {
4222 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4223 })?
4224 },
4225 name: match node.child_by_field_name("name") {
4226 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4227 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4228 })?),
4229 None => None,
4230 },
4231 pattern: match node.child_by_field_name("pattern") {
4232 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4233 <RecordPattern as ::treesitter_types::FromNode>::from_node(child, src)
4234 })?),
4235 None => None,
4236 },
4237 right: match node.child_by_field_name("right") {
4238 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4239 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4240 })?),
4241 None => None,
4242 },
4243 })
4244 }
4245}
4246impl ::treesitter_types::Spanned for InstanceofExpression<'_> {
4247 fn span(&self) -> ::treesitter_types::Span {
4248 self.span
4249 }
4250}
4251#[derive(Debug, Clone, PartialEq, Eq)]
4252pub struct IntegralType<'tree> {
4253 pub span: ::treesitter_types::Span,
4254 text: &'tree str,
4255}
4256impl<'tree> ::treesitter_types::FromNode<'tree> for IntegralType<'tree> {
4257 fn from_node(
4258 node: ::treesitter_types::tree_sitter::Node<'tree>,
4259 src: &'tree [u8],
4260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4261 debug_assert_eq!(node.kind(), "integral_type");
4262 Ok(Self {
4263 span: ::treesitter_types::Span::from(node),
4264 text: node.utf8_text(src)?,
4265 })
4266 }
4267}
4268impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegralType<'tree> {
4269 fn text(&self) -> &'tree str {
4270 self.text
4271 }
4272}
4273impl ::treesitter_types::Spanned for IntegralType<'_> {
4274 fn span(&self) -> ::treesitter_types::Span {
4275 self.span
4276 }
4277}
4278#[derive(Debug, Clone, PartialEq, Eq)]
4279pub struct InterfaceBody<'tree> {
4280 pub span: ::treesitter_types::Span,
4281 pub children: ::std::vec::Vec<InterfaceBodyChildren<'tree>>,
4282}
4283impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBody<'tree> {
4284 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4285 fn from_node(
4286 node: ::treesitter_types::tree_sitter::Node<'tree>,
4287 src: &'tree [u8],
4288 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4289 debug_assert_eq!(node.kind(), "interface_body");
4290 Ok(Self {
4291 span: ::treesitter_types::Span::from(node),
4292 children: {
4293 #[allow(clippy::suspicious_else_formatting)]
4294 let non_field_children = {
4295 let mut cursor = node.walk();
4296 let mut result = ::std::vec::Vec::new();
4297 if cursor.goto_first_child() {
4298 loop {
4299 if cursor.field_name().is_none()
4300 && cursor.node().is_named()
4301 && !cursor.node().is_extra()
4302 {
4303 result.push(cursor.node());
4304 }
4305 if !cursor.goto_next_sibling() {
4306 break;
4307 }
4308 }
4309 }
4310 result
4311 };
4312 let mut items = ::std::vec::Vec::new();
4313 for child in non_field_children {
4314 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4315 <InterfaceBodyChildren as ::treesitter_types::FromNode>::from_node(
4316 child, src,
4317 )
4318 })?);
4319 }
4320 items
4321 },
4322 })
4323 }
4324}
4325impl ::treesitter_types::Spanned for InterfaceBody<'_> {
4326 fn span(&self) -> ::treesitter_types::Span {
4327 self.span
4328 }
4329}
4330#[derive(Debug, Clone, PartialEq, Eq)]
4331pub struct InterfaceDeclaration<'tree> {
4332 pub span: ::treesitter_types::Span,
4333 pub body: InterfaceBody<'tree>,
4334 pub name: Identifier<'tree>,
4335 pub permits: ::core::option::Option<Permits<'tree>>,
4336 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4337 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
4338}
4339impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
4340 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4341 fn from_node(
4342 node: ::treesitter_types::tree_sitter::Node<'tree>,
4343 src: &'tree [u8],
4344 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4345 debug_assert_eq!(node.kind(), "interface_declaration");
4346 Ok(Self {
4347 span: ::treesitter_types::Span::from(node),
4348 body: {
4349 let child = node
4350 .child_by_field_name("body")
4351 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4352 ::treesitter_types::runtime::maybe_grow_stack(|| {
4353 <InterfaceBody as ::treesitter_types::FromNode>::from_node(child, src)
4354 })?
4355 },
4356 name: {
4357 let child = node
4358 .child_by_field_name("name")
4359 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4360 ::treesitter_types::runtime::maybe_grow_stack(|| {
4361 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4362 })?
4363 },
4364 permits: match node.child_by_field_name("permits") {
4365 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4366 <Permits as ::treesitter_types::FromNode>::from_node(child, src)
4367 })?),
4368 None => None,
4369 },
4370 type_parameters: match node.child_by_field_name("type_parameters") {
4371 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4372 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
4373 })?),
4374 None => None,
4375 },
4376 children: {
4377 #[allow(clippy::suspicious_else_formatting)]
4378 let non_field_children = {
4379 let mut cursor = node.walk();
4380 let mut result = ::std::vec::Vec::new();
4381 if cursor.goto_first_child() {
4382 loop {
4383 if cursor.field_name().is_none()
4384 && cursor.node().is_named()
4385 && !cursor.node().is_extra()
4386 {
4387 result.push(cursor.node());
4388 }
4389 if !cursor.goto_next_sibling() {
4390 break;
4391 }
4392 }
4393 }
4394 result
4395 };
4396 let mut items = ::std::vec::Vec::new();
4397 for child in non_field_children {
4398 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4399 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4400 child, src,
4401 )
4402 })?);
4403 }
4404 items
4405 },
4406 })
4407 }
4408}
4409impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
4410 fn span(&self) -> ::treesitter_types::Span {
4411 self.span
4412 }
4413}
4414#[derive(Debug, Clone, PartialEq, Eq)]
4415pub struct LabeledStatement<'tree> {
4416 pub span: ::treesitter_types::Span,
4417 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
4418}
4419impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
4420 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4421 fn from_node(
4422 node: ::treesitter_types::tree_sitter::Node<'tree>,
4423 src: &'tree [u8],
4424 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4425 debug_assert_eq!(node.kind(), "labeled_statement");
4426 Ok(Self {
4427 span: ::treesitter_types::Span::from(node),
4428 children: {
4429 #[allow(clippy::suspicious_else_formatting)]
4430 let non_field_children = {
4431 let mut cursor = node.walk();
4432 let mut result = ::std::vec::Vec::new();
4433 if cursor.goto_first_child() {
4434 loop {
4435 if cursor.field_name().is_none()
4436 && cursor.node().is_named()
4437 && !cursor.node().is_extra()
4438 {
4439 result.push(cursor.node());
4440 }
4441 if !cursor.goto_next_sibling() {
4442 break;
4443 }
4444 }
4445 }
4446 result
4447 };
4448 let mut items = ::std::vec::Vec::new();
4449 for child in non_field_children {
4450 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4451 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
4452 child, src,
4453 )
4454 })?);
4455 }
4456 items
4457 },
4458 })
4459 }
4460}
4461impl ::treesitter_types::Spanned for LabeledStatement<'_> {
4462 fn span(&self) -> ::treesitter_types::Span {
4463 self.span
4464 }
4465}
4466#[derive(Debug, Clone, PartialEq, Eq)]
4467pub struct LambdaExpression<'tree> {
4468 pub span: ::treesitter_types::Span,
4469 pub body: LambdaExpressionBody<'tree>,
4470 pub parameters: LambdaExpressionParameters<'tree>,
4471}
4472impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
4473 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4474 fn from_node(
4475 node: ::treesitter_types::tree_sitter::Node<'tree>,
4476 src: &'tree [u8],
4477 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4478 debug_assert_eq!(node.kind(), "lambda_expression");
4479 Ok(Self {
4480 span: ::treesitter_types::Span::from(node),
4481 body: {
4482 let child = node
4483 .child_by_field_name("body")
4484 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4485 ::treesitter_types::runtime::maybe_grow_stack(|| {
4486 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)
4487 })?
4488 },
4489 parameters: {
4490 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4491 ::treesitter_types::ParseError::missing_field("parameters", node)
4492 })?;
4493 ::treesitter_types::runtime::maybe_grow_stack(|| {
4494 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(
4495 child, src,
4496 )
4497 })?
4498 },
4499 })
4500 }
4501}
4502impl ::treesitter_types::Spanned for LambdaExpression<'_> {
4503 fn span(&self) -> ::treesitter_types::Span {
4504 self.span
4505 }
4506}
4507#[derive(Debug, Clone, PartialEq, Eq)]
4508pub struct LocalVariableDeclaration<'tree> {
4509 pub span: ::treesitter_types::Span,
4510 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
4511 pub r#type: UnannotatedType<'tree>,
4512 pub children: ::core::option::Option<Modifiers<'tree>>,
4513}
4514impl<'tree> ::treesitter_types::FromNode<'tree> for LocalVariableDeclaration<'tree> {
4515 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4516 fn from_node(
4517 node: ::treesitter_types::tree_sitter::Node<'tree>,
4518 src: &'tree [u8],
4519 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4520 debug_assert_eq!(node.kind(), "local_variable_declaration");
4521 Ok(Self {
4522 span: ::treesitter_types::Span::from(node),
4523 declarator: {
4524 let mut cursor = node.walk();
4525 let mut items = ::std::vec::Vec::new();
4526 for child in node.children_by_field_name("declarator", &mut cursor) {
4527 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4528 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
4529 })?);
4530 }
4531 items
4532 },
4533 r#type: {
4534 let child = node
4535 .child_by_field_name("type")
4536 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4537 ::treesitter_types::runtime::maybe_grow_stack(|| {
4538 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
4539 })?
4540 },
4541 children: {
4542 #[allow(clippy::suspicious_else_formatting)]
4543 let non_field_children = {
4544 let mut cursor = node.walk();
4545 let mut result = ::std::vec::Vec::new();
4546 if cursor.goto_first_child() {
4547 loop {
4548 if cursor.field_name().is_none()
4549 && cursor.node().is_named()
4550 && !cursor.node().is_extra()
4551 {
4552 result.push(cursor.node());
4553 }
4554 if !cursor.goto_next_sibling() {
4555 break;
4556 }
4557 }
4558 }
4559 result
4560 };
4561 match non_field_children.first() {
4562 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4563 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
4564 })?),
4565 None => None,
4566 }
4567 },
4568 })
4569 }
4570}
4571impl ::treesitter_types::Spanned for LocalVariableDeclaration<'_> {
4572 fn span(&self) -> ::treesitter_types::Span {
4573 self.span
4574 }
4575}
4576#[derive(Debug, Clone, PartialEq, Eq)]
4577pub struct MarkerAnnotation<'tree> {
4578 pub span: ::treesitter_types::Span,
4579 pub name: MarkerAnnotationName<'tree>,
4580}
4581impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotation<'tree> {
4582 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4583 fn from_node(
4584 node: ::treesitter_types::tree_sitter::Node<'tree>,
4585 src: &'tree [u8],
4586 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4587 debug_assert_eq!(node.kind(), "marker_annotation");
4588 Ok(Self {
4589 span: ::treesitter_types::Span::from(node),
4590 name: {
4591 let child = node
4592 .child_by_field_name("name")
4593 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4594 ::treesitter_types::runtime::maybe_grow_stack(|| {
4595 <MarkerAnnotationName as ::treesitter_types::FromNode>::from_node(child, src)
4596 })?
4597 },
4598 })
4599 }
4600}
4601impl ::treesitter_types::Spanned for MarkerAnnotation<'_> {
4602 fn span(&self) -> ::treesitter_types::Span {
4603 self.span
4604 }
4605}
4606#[derive(Debug, Clone, PartialEq, Eq)]
4607pub struct MethodDeclaration<'tree> {
4608 pub span: ::treesitter_types::Span,
4609 pub body: ::core::option::Option<Block<'tree>>,
4610 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
4611 pub name: Identifier<'tree>,
4612 pub parameters: FormalParameters<'tree>,
4613 pub r#type: UnannotatedType<'tree>,
4614 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4615 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
4616}
4617impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
4618 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4619 fn from_node(
4620 node: ::treesitter_types::tree_sitter::Node<'tree>,
4621 src: &'tree [u8],
4622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4623 debug_assert_eq!(node.kind(), "method_declaration");
4624 Ok(Self {
4625 span: ::treesitter_types::Span::from(node),
4626 body: match node.child_by_field_name("body") {
4627 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4628 <Block as ::treesitter_types::FromNode>::from_node(child, src)
4629 })?),
4630 None => None,
4631 },
4632 dimensions: match node.child_by_field_name("dimensions") {
4633 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4634 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
4635 })?),
4636 None => None,
4637 },
4638 name: {
4639 let child = node
4640 .child_by_field_name("name")
4641 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4642 ::treesitter_types::runtime::maybe_grow_stack(|| {
4643 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4644 })?
4645 },
4646 parameters: {
4647 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4648 ::treesitter_types::ParseError::missing_field("parameters", node)
4649 })?;
4650 ::treesitter_types::runtime::maybe_grow_stack(|| {
4651 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
4652 })?
4653 },
4654 r#type: {
4655 let child = node
4656 .child_by_field_name("type")
4657 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4658 ::treesitter_types::runtime::maybe_grow_stack(|| {
4659 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
4660 })?
4661 },
4662 type_parameters: match node.child_by_field_name("type_parameters") {
4663 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4664 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
4665 })?),
4666 None => None,
4667 },
4668 children: {
4669 #[allow(clippy::suspicious_else_formatting)]
4670 let non_field_children = {
4671 let mut cursor = node.walk();
4672 let mut result = ::std::vec::Vec::new();
4673 if cursor.goto_first_child() {
4674 loop {
4675 if cursor.field_name().is_none()
4676 && cursor.node().is_named()
4677 && !cursor.node().is_extra()
4678 {
4679 result.push(cursor.node());
4680 }
4681 if !cursor.goto_next_sibling() {
4682 break;
4683 }
4684 }
4685 }
4686 result
4687 };
4688 let mut items = ::std::vec::Vec::new();
4689 for child in non_field_children {
4690 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4691 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4692 child, src,
4693 )
4694 })?);
4695 }
4696 items
4697 },
4698 })
4699 }
4700}
4701impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
4702 fn span(&self) -> ::treesitter_types::Span {
4703 self.span
4704 }
4705}
4706#[derive(Debug, Clone, PartialEq, Eq)]
4707pub struct MethodInvocation<'tree> {
4708 pub span: ::treesitter_types::Span,
4709 pub arguments: ArgumentList<'tree>,
4710 pub name: Identifier<'tree>,
4711 pub object: ::core::option::Option<MethodInvocationObject<'tree>>,
4712 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
4713 pub children: ::core::option::Option<Super<'tree>>,
4714}
4715impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocation<'tree> {
4716 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4717 fn from_node(
4718 node: ::treesitter_types::tree_sitter::Node<'tree>,
4719 src: &'tree [u8],
4720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4721 debug_assert_eq!(node.kind(), "method_invocation");
4722 Ok(Self {
4723 span: ::treesitter_types::Span::from(node),
4724 arguments: {
4725 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4726 ::treesitter_types::ParseError::missing_field("arguments", node)
4727 })?;
4728 ::treesitter_types::runtime::maybe_grow_stack(|| {
4729 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4730 })?
4731 },
4732 name: {
4733 let child = node
4734 .child_by_field_name("name")
4735 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4736 ::treesitter_types::runtime::maybe_grow_stack(|| {
4737 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4738 })?
4739 },
4740 object: match node.child_by_field_name("object") {
4741 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4742 <MethodInvocationObject as ::treesitter_types::FromNode>::from_node(child, src)
4743 })?),
4744 None => None,
4745 },
4746 type_arguments: match node.child_by_field_name("type_arguments") {
4747 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4748 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
4749 })?),
4750 None => None,
4751 },
4752 children: {
4753 #[allow(clippy::suspicious_else_formatting)]
4754 let non_field_children = {
4755 let mut cursor = node.walk();
4756 let mut result = ::std::vec::Vec::new();
4757 if cursor.goto_first_child() {
4758 loop {
4759 if cursor.field_name().is_none()
4760 && cursor.node().is_named()
4761 && !cursor.node().is_extra()
4762 {
4763 result.push(cursor.node());
4764 }
4765 if !cursor.goto_next_sibling() {
4766 break;
4767 }
4768 }
4769 }
4770 result
4771 };
4772 match non_field_children.first() {
4773 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4774 <Super as ::treesitter_types::FromNode>::from_node(child, src)
4775 })?),
4776 None => None,
4777 }
4778 },
4779 })
4780 }
4781}
4782impl ::treesitter_types::Spanned for MethodInvocation<'_> {
4783 fn span(&self) -> ::treesitter_types::Span {
4784 self.span
4785 }
4786}
4787#[derive(Debug, Clone, PartialEq, Eq)]
4788pub struct MethodReference<'tree> {
4789 pub span: ::treesitter_types::Span,
4790 pub children: ::std::vec::Vec<MethodReferenceChildren<'tree>>,
4791}
4792impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReference<'tree> {
4793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4794 fn from_node(
4795 node: ::treesitter_types::tree_sitter::Node<'tree>,
4796 src: &'tree [u8],
4797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4798 debug_assert_eq!(node.kind(), "method_reference");
4799 Ok(Self {
4800 span: ::treesitter_types::Span::from(node),
4801 children: {
4802 #[allow(clippy::suspicious_else_formatting)]
4803 let non_field_children = {
4804 let mut cursor = node.walk();
4805 let mut result = ::std::vec::Vec::new();
4806 if cursor.goto_first_child() {
4807 loop {
4808 if cursor.field_name().is_none()
4809 && cursor.node().is_named()
4810 && !cursor.node().is_extra()
4811 {
4812 result.push(cursor.node());
4813 }
4814 if !cursor.goto_next_sibling() {
4815 break;
4816 }
4817 }
4818 }
4819 result
4820 };
4821 let mut items = ::std::vec::Vec::new();
4822 for child in non_field_children {
4823 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4824 <MethodReferenceChildren as ::treesitter_types::FromNode>::from_node(
4825 child, src,
4826 )
4827 })?);
4828 }
4829 items
4830 },
4831 })
4832 }
4833}
4834impl ::treesitter_types::Spanned for MethodReference<'_> {
4835 fn span(&self) -> ::treesitter_types::Span {
4836 self.span
4837 }
4838}
4839#[derive(Debug, Clone, PartialEq, Eq)]
4840pub struct Modifiers<'tree> {
4841 pub span: ::treesitter_types::Span,
4842 pub children: ::std::vec::Vec<ModifiersChildren<'tree>>,
4843}
4844impl<'tree> ::treesitter_types::FromNode<'tree> for Modifiers<'tree> {
4845 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4846 fn from_node(
4847 node: ::treesitter_types::tree_sitter::Node<'tree>,
4848 src: &'tree [u8],
4849 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4850 debug_assert_eq!(node.kind(), "modifiers");
4851 Ok(Self {
4852 span: ::treesitter_types::Span::from(node),
4853 children: {
4854 #[allow(clippy::suspicious_else_formatting)]
4855 let non_field_children = {
4856 let mut cursor = node.walk();
4857 let mut result = ::std::vec::Vec::new();
4858 if cursor.goto_first_child() {
4859 loop {
4860 if cursor.field_name().is_none()
4861 && cursor.node().is_named()
4862 && !cursor.node().is_extra()
4863 {
4864 result.push(cursor.node());
4865 }
4866 if !cursor.goto_next_sibling() {
4867 break;
4868 }
4869 }
4870 }
4871 result
4872 };
4873 let mut items = ::std::vec::Vec::new();
4874 for child in non_field_children {
4875 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4876 <ModifiersChildren as ::treesitter_types::FromNode>::from_node(child, src)
4877 })?);
4878 }
4879 items
4880 },
4881 })
4882 }
4883}
4884impl ::treesitter_types::Spanned for Modifiers<'_> {
4885 fn span(&self) -> ::treesitter_types::Span {
4886 self.span
4887 }
4888}
4889#[derive(Debug, Clone, PartialEq, Eq)]
4890pub struct ModuleBody<'tree> {
4891 pub span: ::treesitter_types::Span,
4892 pub children: ::std::vec::Vec<ModuleDirective<'tree>>,
4893}
4894impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleBody<'tree> {
4895 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4896 fn from_node(
4897 node: ::treesitter_types::tree_sitter::Node<'tree>,
4898 src: &'tree [u8],
4899 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4900 debug_assert_eq!(node.kind(), "module_body");
4901 Ok(Self {
4902 span: ::treesitter_types::Span::from(node),
4903 children: {
4904 #[allow(clippy::suspicious_else_formatting)]
4905 let non_field_children = {
4906 let mut cursor = node.walk();
4907 let mut result = ::std::vec::Vec::new();
4908 if cursor.goto_first_child() {
4909 loop {
4910 if cursor.field_name().is_none()
4911 && cursor.node().is_named()
4912 && !cursor.node().is_extra()
4913 {
4914 result.push(cursor.node());
4915 }
4916 if !cursor.goto_next_sibling() {
4917 break;
4918 }
4919 }
4920 }
4921 result
4922 };
4923 let mut items = ::std::vec::Vec::new();
4924 for child in non_field_children {
4925 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4926 <ModuleDirective as ::treesitter_types::FromNode>::from_node(child, src)
4927 })?);
4928 }
4929 items
4930 },
4931 })
4932 }
4933}
4934impl ::treesitter_types::Spanned for ModuleBody<'_> {
4935 fn span(&self) -> ::treesitter_types::Span {
4936 self.span
4937 }
4938}
4939#[derive(Debug, Clone, PartialEq, Eq)]
4940pub struct ModuleDeclaration<'tree> {
4941 pub span: ::treesitter_types::Span,
4942 pub body: ModuleBody<'tree>,
4943 pub name: ModuleDeclarationName<'tree>,
4944 pub children: ::std::vec::Vec<ModuleDeclarationChildren<'tree>>,
4945}
4946impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclaration<'tree> {
4947 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4948 fn from_node(
4949 node: ::treesitter_types::tree_sitter::Node<'tree>,
4950 src: &'tree [u8],
4951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4952 debug_assert_eq!(node.kind(), "module_declaration");
4953 Ok(Self {
4954 span: ::treesitter_types::Span::from(node),
4955 body: {
4956 let child = node
4957 .child_by_field_name("body")
4958 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4959 ::treesitter_types::runtime::maybe_grow_stack(|| {
4960 <ModuleBody as ::treesitter_types::FromNode>::from_node(child, src)
4961 })?
4962 },
4963 name: {
4964 let child = node
4965 .child_by_field_name("name")
4966 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4967 ::treesitter_types::runtime::maybe_grow_stack(|| {
4968 <ModuleDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)
4969 })?
4970 },
4971 children: {
4972 #[allow(clippy::suspicious_else_formatting)]
4973 let non_field_children = {
4974 let mut cursor = node.walk();
4975 let mut result = ::std::vec::Vec::new();
4976 if cursor.goto_first_child() {
4977 loop {
4978 if cursor.field_name().is_none()
4979 && cursor.node().is_named()
4980 && !cursor.node().is_extra()
4981 {
4982 result.push(cursor.node());
4983 }
4984 if !cursor.goto_next_sibling() {
4985 break;
4986 }
4987 }
4988 }
4989 result
4990 };
4991 let mut items = ::std::vec::Vec::new();
4992 for child in non_field_children {
4993 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4994 <ModuleDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4995 child, src,
4996 )
4997 })?);
4998 }
4999 items
5000 },
5001 })
5002 }
5003}
5004impl ::treesitter_types::Spanned for ModuleDeclaration<'_> {
5005 fn span(&self) -> ::treesitter_types::Span {
5006 self.span
5007 }
5008}
5009#[derive(Debug, Clone, PartialEq, Eq)]
5010pub struct MultilineStringFragment<'tree> {
5011 pub span: ::treesitter_types::Span,
5012 text: &'tree str,
5013}
5014impl<'tree> ::treesitter_types::FromNode<'tree> for MultilineStringFragment<'tree> {
5015 fn from_node(
5016 node: ::treesitter_types::tree_sitter::Node<'tree>,
5017 src: &'tree [u8],
5018 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5019 debug_assert_eq!(node.kind(), "multiline_string_fragment");
5020 Ok(Self {
5021 span: ::treesitter_types::Span::from(node),
5022 text: node.utf8_text(src)?,
5023 })
5024 }
5025}
5026impl<'tree> ::treesitter_types::LeafNode<'tree> for MultilineStringFragment<'tree> {
5027 fn text(&self) -> &'tree str {
5028 self.text
5029 }
5030}
5031impl ::treesitter_types::Spanned for MultilineStringFragment<'_> {
5032 fn span(&self) -> ::treesitter_types::Span {
5033 self.span
5034 }
5035}
5036#[derive(Debug, Clone, PartialEq, Eq)]
5037pub struct ObjectCreationExpression<'tree> {
5038 pub span: ::treesitter_types::Span,
5039 pub arguments: ArgumentList<'tree>,
5040 pub r#type: SimpleType<'tree>,
5041 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
5042 pub children: ::std::vec::Vec<ObjectCreationExpressionChildren<'tree>>,
5043}
5044impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
5045 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5046 fn from_node(
5047 node: ::treesitter_types::tree_sitter::Node<'tree>,
5048 src: &'tree [u8],
5049 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5050 debug_assert_eq!(node.kind(), "object_creation_expression");
5051 Ok(Self {
5052 span: ::treesitter_types::Span::from(node),
5053 arguments: {
5054 let child = node.child_by_field_name("arguments").ok_or_else(|| {
5055 ::treesitter_types::ParseError::missing_field("arguments", node)
5056 })?;
5057 ::treesitter_types::runtime::maybe_grow_stack(|| {
5058 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
5059 })?
5060 },
5061 r#type: {
5062 let child = node
5063 .child_by_field_name("type")
5064 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5065 ::treesitter_types::runtime::maybe_grow_stack(|| {
5066 <SimpleType as ::treesitter_types::FromNode>::from_node(child, src)
5067 })?
5068 },
5069 type_arguments: match node.child_by_field_name("type_arguments") {
5070 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5071 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
5072 })?),
5073 None => None,
5074 },
5075 children: {
5076 #[allow(clippy::suspicious_else_formatting)]
5077 let non_field_children = {
5078 let mut cursor = node.walk();
5079 let mut result = ::std::vec::Vec::new();
5080 if cursor.goto_first_child() {
5081 loop {
5082 if cursor.field_name().is_none()
5083 && cursor.node().is_named()
5084 && !cursor.node().is_extra()
5085 {
5086 result.push(cursor.node());
5087 }
5088 if !cursor.goto_next_sibling() {
5089 break;
5090 }
5091 }
5092 }
5093 result
5094 };
5095 let mut items = ::std::vec::Vec::new();
5096 for child in non_field_children {
5097 items
5098 .push(
5099 ::treesitter_types::runtime::maybe_grow_stack(|| <ObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
5100 child,
5101 src,
5102 ))?,
5103 );
5104 }
5105 items
5106 },
5107 })
5108 }
5109}
5110impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
5111 fn span(&self) -> ::treesitter_types::Span {
5112 self.span
5113 }
5114}
5115#[derive(Debug, Clone, PartialEq, Eq)]
5116pub struct OpensModuleDirective<'tree> {
5117 pub span: ::treesitter_types::Span,
5118 pub modules: ::std::vec::Vec<OpensModuleDirectiveModules<'tree>>,
5119 pub package: OpensModuleDirectivePackage<'tree>,
5120}
5121impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirective<'tree> {
5122 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5123 fn from_node(
5124 node: ::treesitter_types::tree_sitter::Node<'tree>,
5125 src: &'tree [u8],
5126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5127 debug_assert_eq!(node.kind(), "opens_module_directive");
5128 Ok(Self {
5129 span: ::treesitter_types::Span::from(node),
5130 modules: {
5131 let mut cursor = node.walk();
5132 let mut items = ::std::vec::Vec::new();
5133 for child in node.children_by_field_name("modules", &mut cursor) {
5134 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5135 <OpensModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
5136 child, src,
5137 )
5138 })?);
5139 }
5140 items
5141 },
5142 package: {
5143 let child = node.child_by_field_name("package").ok_or_else(|| {
5144 ::treesitter_types::ParseError::missing_field("package", node)
5145 })?;
5146 ::treesitter_types::runtime::maybe_grow_stack(|| {
5147 <OpensModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
5148 child, src,
5149 )
5150 })?
5151 },
5152 })
5153 }
5154}
5155impl ::treesitter_types::Spanned for OpensModuleDirective<'_> {
5156 fn span(&self) -> ::treesitter_types::Span {
5157 self.span
5158 }
5159}
5160#[derive(Debug, Clone, PartialEq, Eq)]
5161pub struct PackageDeclaration<'tree> {
5162 pub span: ::treesitter_types::Span,
5163 pub children: ::std::vec::Vec<PackageDeclarationChildren<'tree>>,
5164}
5165impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclaration<'tree> {
5166 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5167 fn from_node(
5168 node: ::treesitter_types::tree_sitter::Node<'tree>,
5169 src: &'tree [u8],
5170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5171 debug_assert_eq!(node.kind(), "package_declaration");
5172 Ok(Self {
5173 span: ::treesitter_types::Span::from(node),
5174 children: {
5175 #[allow(clippy::suspicious_else_formatting)]
5176 let non_field_children = {
5177 let mut cursor = node.walk();
5178 let mut result = ::std::vec::Vec::new();
5179 if cursor.goto_first_child() {
5180 loop {
5181 if cursor.field_name().is_none()
5182 && cursor.node().is_named()
5183 && !cursor.node().is_extra()
5184 {
5185 result.push(cursor.node());
5186 }
5187 if !cursor.goto_next_sibling() {
5188 break;
5189 }
5190 }
5191 }
5192 result
5193 };
5194 let mut items = ::std::vec::Vec::new();
5195 for child in non_field_children {
5196 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5197 <PackageDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5198 child, src,
5199 )
5200 })?);
5201 }
5202 items
5203 },
5204 })
5205 }
5206}
5207impl ::treesitter_types::Spanned for PackageDeclaration<'_> {
5208 fn span(&self) -> ::treesitter_types::Span {
5209 self.span
5210 }
5211}
5212#[derive(Debug, Clone, PartialEq, Eq)]
5213pub struct ParenthesizedExpression<'tree> {
5214 pub span: ::treesitter_types::Span,
5215 pub children: Expression<'tree>,
5216}
5217impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
5218 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5219 fn from_node(
5220 node: ::treesitter_types::tree_sitter::Node<'tree>,
5221 src: &'tree [u8],
5222 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5223 debug_assert_eq!(node.kind(), "parenthesized_expression");
5224 Ok(Self {
5225 span: ::treesitter_types::Span::from(node),
5226 children: {
5227 #[allow(clippy::suspicious_else_formatting)]
5228 let non_field_children = {
5229 let mut cursor = node.walk();
5230 let mut result = ::std::vec::Vec::new();
5231 if cursor.goto_first_child() {
5232 loop {
5233 if cursor.field_name().is_none()
5234 && cursor.node().is_named()
5235 && !cursor.node().is_extra()
5236 {
5237 result.push(cursor.node());
5238 }
5239 if !cursor.goto_next_sibling() {
5240 break;
5241 }
5242 }
5243 }
5244 result
5245 };
5246 let child = if let Some(&c) = non_field_children.first() {
5247 c
5248 } else {
5249 let mut fallback_cursor = node.walk();
5250 let mut fallback_child = None;
5251 if fallback_cursor.goto_first_child() {
5252 loop {
5253 if fallback_cursor.field_name().is_none()
5254 && !fallback_cursor.node().is_extra()
5255 {
5256 let candidate = fallback_cursor.node();
5257 #[allow(clippy::needless_question_mark)]
5258 if (|| -> ::core::result::Result<
5259 _,
5260 ::treesitter_types::ParseError,
5261 > {
5262 let child = candidate;
5263 Ok(
5264 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5265 child,
5266 src,
5267 ))?,
5268 )
5269 })()
5270 .is_ok()
5271 {
5272 fallback_child = Some(candidate);
5273 break;
5274 }
5275 }
5276 if !fallback_cursor.goto_next_sibling() {
5277 break;
5278 }
5279 }
5280 }
5281 if fallback_child.is_none() {
5282 let mut cursor2 = node.walk();
5283 if cursor2.goto_first_child() {
5284 loop {
5285 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5286 let candidate = cursor2.node();
5287 #[allow(clippy::needless_question_mark)]
5288 if (|| -> ::core::result::Result<
5289 _,
5290 ::treesitter_types::ParseError,
5291 > {
5292 let child = candidate;
5293 Ok(
5294 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5295 child,
5296 src,
5297 ))?,
5298 )
5299 })()
5300 .is_ok()
5301 {
5302 fallback_child = Some(candidate);
5303 break;
5304 }
5305 }
5306 if !cursor2.goto_next_sibling() {
5307 break;
5308 }
5309 }
5310 }
5311 }
5312 fallback_child.ok_or_else(|| {
5313 ::treesitter_types::ParseError::missing_field("children", node)
5314 })?
5315 };
5316 ::treesitter_types::runtime::maybe_grow_stack(|| {
5317 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5318 })?
5319 },
5320 })
5321 }
5322}
5323impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
5324 fn span(&self) -> ::treesitter_types::Span {
5325 self.span
5326 }
5327}
5328#[derive(Debug, Clone, PartialEq, Eq)]
5329pub struct Pattern<'tree> {
5330 pub span: ::treesitter_types::Span,
5331 pub children: PatternChildren<'tree>,
5332}
5333impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
5334 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5335 fn from_node(
5336 node: ::treesitter_types::tree_sitter::Node<'tree>,
5337 src: &'tree [u8],
5338 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5339 debug_assert_eq!(node.kind(), "pattern");
5340 Ok(Self {
5341 span: ::treesitter_types::Span::from(node),
5342 children: {
5343 #[allow(clippy::suspicious_else_formatting)]
5344 let non_field_children = {
5345 let mut cursor = node.walk();
5346 let mut result = ::std::vec::Vec::new();
5347 if cursor.goto_first_child() {
5348 loop {
5349 if cursor.field_name().is_none()
5350 && cursor.node().is_named()
5351 && !cursor.node().is_extra()
5352 {
5353 result.push(cursor.node());
5354 }
5355 if !cursor.goto_next_sibling() {
5356 break;
5357 }
5358 }
5359 }
5360 result
5361 };
5362 let child = if let Some(&c) = non_field_children.first() {
5363 c
5364 } else {
5365 let mut fallback_cursor = node.walk();
5366 let mut fallback_child = None;
5367 if fallback_cursor.goto_first_child() {
5368 loop {
5369 if fallback_cursor.field_name().is_none()
5370 && !fallback_cursor.node().is_extra()
5371 {
5372 let candidate = fallback_cursor.node();
5373 #[allow(clippy::needless_question_mark)]
5374 if (|| -> ::core::result::Result<
5375 _,
5376 ::treesitter_types::ParseError,
5377 > {
5378 let child = candidate;
5379 Ok(
5380 ::treesitter_types::runtime::maybe_grow_stack(|| <PatternChildren as ::treesitter_types::FromNode>::from_node(
5381 child,
5382 src,
5383 ))?,
5384 )
5385 })()
5386 .is_ok()
5387 {
5388 fallback_child = Some(candidate);
5389 break;
5390 }
5391 }
5392 if !fallback_cursor.goto_next_sibling() {
5393 break;
5394 }
5395 }
5396 }
5397 if fallback_child.is_none() {
5398 let mut cursor2 = node.walk();
5399 if cursor2.goto_first_child() {
5400 loop {
5401 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5402 let candidate = cursor2.node();
5403 #[allow(clippy::needless_question_mark)]
5404 if (|| -> ::core::result::Result<
5405 _,
5406 ::treesitter_types::ParseError,
5407 > {
5408 let child = candidate;
5409 Ok(
5410 ::treesitter_types::runtime::maybe_grow_stack(|| <PatternChildren as ::treesitter_types::FromNode>::from_node(
5411 child,
5412 src,
5413 ))?,
5414 )
5415 })()
5416 .is_ok()
5417 {
5418 fallback_child = Some(candidate);
5419 break;
5420 }
5421 }
5422 if !cursor2.goto_next_sibling() {
5423 break;
5424 }
5425 }
5426 }
5427 }
5428 fallback_child.ok_or_else(|| {
5429 ::treesitter_types::ParseError::missing_field("children", node)
5430 })?
5431 };
5432 ::treesitter_types::runtime::maybe_grow_stack(|| {
5433 <PatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
5434 })?
5435 },
5436 })
5437 }
5438}
5439impl ::treesitter_types::Spanned for Pattern<'_> {
5440 fn span(&self) -> ::treesitter_types::Span {
5441 self.span
5442 }
5443}
5444#[derive(Debug, Clone, PartialEq, Eq)]
5445pub struct Permits<'tree> {
5446 pub span: ::treesitter_types::Span,
5447 pub children: TypeList<'tree>,
5448}
5449impl<'tree> ::treesitter_types::FromNode<'tree> for Permits<'tree> {
5450 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5451 fn from_node(
5452 node: ::treesitter_types::tree_sitter::Node<'tree>,
5453 src: &'tree [u8],
5454 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5455 debug_assert_eq!(node.kind(), "permits");
5456 Ok(Self {
5457 span: ::treesitter_types::Span::from(node),
5458 children: {
5459 #[allow(clippy::suspicious_else_formatting)]
5460 let non_field_children = {
5461 let mut cursor = node.walk();
5462 let mut result = ::std::vec::Vec::new();
5463 if cursor.goto_first_child() {
5464 loop {
5465 if cursor.field_name().is_none()
5466 && cursor.node().is_named()
5467 && !cursor.node().is_extra()
5468 {
5469 result.push(cursor.node());
5470 }
5471 if !cursor.goto_next_sibling() {
5472 break;
5473 }
5474 }
5475 }
5476 result
5477 };
5478 let child = if let Some(&c) = non_field_children.first() {
5479 c
5480 } else {
5481 let mut fallback_cursor = node.walk();
5482 let mut fallback_child = None;
5483 if fallback_cursor.goto_first_child() {
5484 loop {
5485 if fallback_cursor.field_name().is_none()
5486 && !fallback_cursor.node().is_extra()
5487 {
5488 let candidate = fallback_cursor.node();
5489 #[allow(clippy::needless_question_mark)]
5490 if (|| -> ::core::result::Result<
5491 _,
5492 ::treesitter_types::ParseError,
5493 > {
5494 let child = candidate;
5495 Ok(
5496 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
5497 child,
5498 src,
5499 ))?,
5500 )
5501 })()
5502 .is_ok()
5503 {
5504 fallback_child = Some(candidate);
5505 break;
5506 }
5507 }
5508 if !fallback_cursor.goto_next_sibling() {
5509 break;
5510 }
5511 }
5512 }
5513 if fallback_child.is_none() {
5514 let mut cursor2 = node.walk();
5515 if cursor2.goto_first_child() {
5516 loop {
5517 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5518 let candidate = cursor2.node();
5519 #[allow(clippy::needless_question_mark)]
5520 if (|| -> ::core::result::Result<
5521 _,
5522 ::treesitter_types::ParseError,
5523 > {
5524 let child = candidate;
5525 Ok(
5526 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
5527 child,
5528 src,
5529 ))?,
5530 )
5531 })()
5532 .is_ok()
5533 {
5534 fallback_child = Some(candidate);
5535 break;
5536 }
5537 }
5538 if !cursor2.goto_next_sibling() {
5539 break;
5540 }
5541 }
5542 }
5543 }
5544 fallback_child.ok_or_else(|| {
5545 ::treesitter_types::ParseError::missing_field("children", node)
5546 })?
5547 };
5548 ::treesitter_types::runtime::maybe_grow_stack(|| {
5549 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)
5550 })?
5551 },
5552 })
5553 }
5554}
5555impl ::treesitter_types::Spanned for Permits<'_> {
5556 fn span(&self) -> ::treesitter_types::Span {
5557 self.span
5558 }
5559}
5560#[derive(Debug, Clone, PartialEq, Eq)]
5561pub struct Program<'tree> {
5562 pub span: ::treesitter_types::Span,
5563 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
5564}
5565impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
5566 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5567 fn from_node(
5568 node: ::treesitter_types::tree_sitter::Node<'tree>,
5569 src: &'tree [u8],
5570 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5571 debug_assert_eq!(node.kind(), "program");
5572 Ok(Self {
5573 span: ::treesitter_types::Span::from(node),
5574 children: {
5575 #[allow(clippy::suspicious_else_formatting)]
5576 let non_field_children = {
5577 let mut cursor = node.walk();
5578 let mut result = ::std::vec::Vec::new();
5579 if cursor.goto_first_child() {
5580 loop {
5581 if cursor.field_name().is_none()
5582 && cursor.node().is_named()
5583 && !cursor.node().is_extra()
5584 {
5585 result.push(cursor.node());
5586 }
5587 if !cursor.goto_next_sibling() {
5588 break;
5589 }
5590 }
5591 }
5592 result
5593 };
5594 let mut items = ::std::vec::Vec::new();
5595 for child in non_field_children {
5596 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5597 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)
5598 })?);
5599 }
5600 items
5601 },
5602 })
5603 }
5604}
5605impl ::treesitter_types::Spanned for Program<'_> {
5606 fn span(&self) -> ::treesitter_types::Span {
5607 self.span
5608 }
5609}
5610#[derive(Debug, Clone, PartialEq, Eq)]
5611pub struct ProvidesModuleDirective<'tree> {
5612 pub span: ::treesitter_types::Span,
5613 pub provided: ProvidesModuleDirectiveProvided<'tree>,
5614 pub provider: ::std::vec::Vec<ProvidesModuleDirectiveProvider<'tree>>,
5615 pub children: ProvidesModuleDirectiveChildren<'tree>,
5616}
5617impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirective<'tree> {
5618 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5619 fn from_node(
5620 node: ::treesitter_types::tree_sitter::Node<'tree>,
5621 src: &'tree [u8],
5622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5623 debug_assert_eq!(node.kind(), "provides_module_directive");
5624 Ok(Self {
5625 span: ::treesitter_types::Span::from(node),
5626 provided: {
5627 let child = node.child_by_field_name("provided").ok_or_else(|| {
5628 ::treesitter_types::ParseError::missing_field("provided", node)
5629 })?;
5630 ::treesitter_types::runtime::maybe_grow_stack(|| {
5631 <ProvidesModuleDirectiveProvided as ::treesitter_types::FromNode>::from_node(
5632 child, src,
5633 )
5634 })?
5635 },
5636 provider: {
5637 let mut cursor = node.walk();
5638 let mut items = ::std::vec::Vec::new();
5639 for child in node.children_by_field_name("provider", &mut cursor) {
5640 items
5641 .push(
5642 ::treesitter_types::runtime::maybe_grow_stack(|| <ProvidesModuleDirectiveProvider as ::treesitter_types::FromNode>::from_node(
5643 child,
5644 src,
5645 ))?,
5646 );
5647 }
5648 items
5649 },
5650 children: {
5651 #[allow(clippy::suspicious_else_formatting)]
5652 let non_field_children = {
5653 let mut cursor = node.walk();
5654 let mut result = ::std::vec::Vec::new();
5655 if cursor.goto_first_child() {
5656 loop {
5657 if cursor.field_name().is_none()
5658 && cursor.node().is_named()
5659 && !cursor.node().is_extra()
5660 {
5661 result.push(cursor.node());
5662 }
5663 if !cursor.goto_next_sibling() {
5664 break;
5665 }
5666 }
5667 }
5668 result
5669 };
5670 let child = if let Some(&c) = non_field_children.first() {
5671 c
5672 } else {
5673 let mut fallback_cursor = node.walk();
5674 let mut fallback_child = None;
5675 if fallback_cursor.goto_first_child() {
5676 loop {
5677 if fallback_cursor.field_name().is_none()
5678 && !fallback_cursor.node().is_extra()
5679 {
5680 let candidate = fallback_cursor.node();
5681 #[allow(clippy::needless_question_mark)]
5682 if (|| -> ::core::result::Result<
5683 _,
5684 ::treesitter_types::ParseError,
5685 > {
5686 let child = candidate;
5687 Ok(
5688 ::treesitter_types::runtime::maybe_grow_stack(|| <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5689 child,
5690 src,
5691 ))?,
5692 )
5693 })()
5694 .is_ok()
5695 {
5696 fallback_child = Some(candidate);
5697 break;
5698 }
5699 }
5700 if !fallback_cursor.goto_next_sibling() {
5701 break;
5702 }
5703 }
5704 }
5705 if fallback_child.is_none() {
5706 let mut cursor2 = node.walk();
5707 if cursor2.goto_first_child() {
5708 loop {
5709 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5710 let candidate = cursor2.node();
5711 #[allow(clippy::needless_question_mark)]
5712 if (|| -> ::core::result::Result<
5713 _,
5714 ::treesitter_types::ParseError,
5715 > {
5716 let child = candidate;
5717 Ok(
5718 ::treesitter_types::runtime::maybe_grow_stack(|| <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5719 child,
5720 src,
5721 ))?,
5722 )
5723 })()
5724 .is_ok()
5725 {
5726 fallback_child = Some(candidate);
5727 break;
5728 }
5729 }
5730 if !cursor2.goto_next_sibling() {
5731 break;
5732 }
5733 }
5734 }
5735 }
5736 fallback_child.ok_or_else(|| {
5737 ::treesitter_types::ParseError::missing_field("children", node)
5738 })?
5739 };
5740 ::treesitter_types::runtime::maybe_grow_stack(|| {
5741 <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5742 child, src,
5743 )
5744 })?
5745 },
5746 })
5747 }
5748}
5749impl ::treesitter_types::Spanned for ProvidesModuleDirective<'_> {
5750 fn span(&self) -> ::treesitter_types::Span {
5751 self.span
5752 }
5753}
5754#[derive(Debug, Clone, PartialEq, Eq)]
5755pub struct ReceiverParameter<'tree> {
5756 pub span: ::treesitter_types::Span,
5757 pub children: ::std::vec::Vec<ReceiverParameterChildren<'tree>>,
5758}
5759impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameter<'tree> {
5760 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5761 fn from_node(
5762 node: ::treesitter_types::tree_sitter::Node<'tree>,
5763 src: &'tree [u8],
5764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5765 debug_assert_eq!(node.kind(), "receiver_parameter");
5766 Ok(Self {
5767 span: ::treesitter_types::Span::from(node),
5768 children: {
5769 #[allow(clippy::suspicious_else_formatting)]
5770 let non_field_children = {
5771 let mut cursor = node.walk();
5772 let mut result = ::std::vec::Vec::new();
5773 if cursor.goto_first_child() {
5774 loop {
5775 if cursor.field_name().is_none()
5776 && cursor.node().is_named()
5777 && !cursor.node().is_extra()
5778 {
5779 result.push(cursor.node());
5780 }
5781 if !cursor.goto_next_sibling() {
5782 break;
5783 }
5784 }
5785 }
5786 result
5787 };
5788 let mut items = ::std::vec::Vec::new();
5789 for child in non_field_children {
5790 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5791 <ReceiverParameterChildren as ::treesitter_types::FromNode>::from_node(
5792 child, src,
5793 )
5794 })?);
5795 }
5796 items
5797 },
5798 })
5799 }
5800}
5801impl ::treesitter_types::Spanned for ReceiverParameter<'_> {
5802 fn span(&self) -> ::treesitter_types::Span {
5803 self.span
5804 }
5805}
5806#[derive(Debug, Clone, PartialEq, Eq)]
5807pub struct RecordDeclaration<'tree> {
5808 pub span: ::treesitter_types::Span,
5809 pub body: ClassBody<'tree>,
5810 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
5811 pub name: Identifier<'tree>,
5812 pub parameters: FormalParameters<'tree>,
5813 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
5814 pub children: ::core::option::Option<Modifiers<'tree>>,
5815}
5816impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
5817 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5818 fn from_node(
5819 node: ::treesitter_types::tree_sitter::Node<'tree>,
5820 src: &'tree [u8],
5821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5822 debug_assert_eq!(node.kind(), "record_declaration");
5823 Ok(Self {
5824 span: ::treesitter_types::Span::from(node),
5825 body: {
5826 let child = node
5827 .child_by_field_name("body")
5828 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5829 ::treesitter_types::runtime::maybe_grow_stack(|| {
5830 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)
5831 })?
5832 },
5833 interfaces: match node.child_by_field_name("interfaces") {
5834 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5835 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)
5836 })?),
5837 None => None,
5838 },
5839 name: {
5840 let child = node
5841 .child_by_field_name("name")
5842 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5843 ::treesitter_types::runtime::maybe_grow_stack(|| {
5844 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5845 })?
5846 },
5847 parameters: {
5848 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5849 ::treesitter_types::ParseError::missing_field("parameters", node)
5850 })?;
5851 ::treesitter_types::runtime::maybe_grow_stack(|| {
5852 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
5853 })?
5854 },
5855 type_parameters: match node.child_by_field_name("type_parameters") {
5856 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5857 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
5858 })?),
5859 None => None,
5860 },
5861 children: {
5862 #[allow(clippy::suspicious_else_formatting)]
5863 let non_field_children = {
5864 let mut cursor = node.walk();
5865 let mut result = ::std::vec::Vec::new();
5866 if cursor.goto_first_child() {
5867 loop {
5868 if cursor.field_name().is_none()
5869 && cursor.node().is_named()
5870 && !cursor.node().is_extra()
5871 {
5872 result.push(cursor.node());
5873 }
5874 if !cursor.goto_next_sibling() {
5875 break;
5876 }
5877 }
5878 }
5879 result
5880 };
5881 match non_field_children.first() {
5882 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5883 <Modifiers as ::treesitter_types::FromNode>::from_node(child, src)
5884 })?),
5885 None => None,
5886 }
5887 },
5888 })
5889 }
5890}
5891impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
5892 fn span(&self) -> ::treesitter_types::Span {
5893 self.span
5894 }
5895}
5896#[derive(Debug, Clone, PartialEq, Eq)]
5897pub struct RecordPattern<'tree> {
5898 pub span: ::treesitter_types::Span,
5899 pub children: ::std::vec::Vec<RecordPatternChildren<'tree>>,
5900}
5901impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPattern<'tree> {
5902 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5903 fn from_node(
5904 node: ::treesitter_types::tree_sitter::Node<'tree>,
5905 src: &'tree [u8],
5906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5907 debug_assert_eq!(node.kind(), "record_pattern");
5908 Ok(Self {
5909 span: ::treesitter_types::Span::from(node),
5910 children: {
5911 #[allow(clippy::suspicious_else_formatting)]
5912 let non_field_children = {
5913 let mut cursor = node.walk();
5914 let mut result = ::std::vec::Vec::new();
5915 if cursor.goto_first_child() {
5916 loop {
5917 if cursor.field_name().is_none()
5918 && cursor.node().is_named()
5919 && !cursor.node().is_extra()
5920 {
5921 result.push(cursor.node());
5922 }
5923 if !cursor.goto_next_sibling() {
5924 break;
5925 }
5926 }
5927 }
5928 result
5929 };
5930 let mut items = ::std::vec::Vec::new();
5931 for child in non_field_children {
5932 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5933 <RecordPatternChildren as ::treesitter_types::FromNode>::from_node(
5934 child, src,
5935 )
5936 })?);
5937 }
5938 items
5939 },
5940 })
5941 }
5942}
5943impl ::treesitter_types::Spanned for RecordPattern<'_> {
5944 fn span(&self) -> ::treesitter_types::Span {
5945 self.span
5946 }
5947}
5948#[derive(Debug, Clone, PartialEq, Eq)]
5949pub struct RecordPatternBody<'tree> {
5950 pub span: ::treesitter_types::Span,
5951 pub children: ::std::vec::Vec<RecordPatternBodyChildren<'tree>>,
5952}
5953impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBody<'tree> {
5954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5955 fn from_node(
5956 node: ::treesitter_types::tree_sitter::Node<'tree>,
5957 src: &'tree [u8],
5958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5959 debug_assert_eq!(node.kind(), "record_pattern_body");
5960 Ok(Self {
5961 span: ::treesitter_types::Span::from(node),
5962 children: {
5963 #[allow(clippy::suspicious_else_formatting)]
5964 let non_field_children = {
5965 let mut cursor = node.walk();
5966 let mut result = ::std::vec::Vec::new();
5967 if cursor.goto_first_child() {
5968 loop {
5969 if cursor.field_name().is_none()
5970 && cursor.node().is_named()
5971 && !cursor.node().is_extra()
5972 {
5973 result.push(cursor.node());
5974 }
5975 if !cursor.goto_next_sibling() {
5976 break;
5977 }
5978 }
5979 }
5980 result
5981 };
5982 let mut items = ::std::vec::Vec::new();
5983 for child in non_field_children {
5984 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5985 <RecordPatternBodyChildren as ::treesitter_types::FromNode>::from_node(
5986 child, src,
5987 )
5988 })?);
5989 }
5990 items
5991 },
5992 })
5993 }
5994}
5995impl ::treesitter_types::Spanned for RecordPatternBody<'_> {
5996 fn span(&self) -> ::treesitter_types::Span {
5997 self.span
5998 }
5999}
6000#[derive(Debug, Clone, PartialEq, Eq)]
6001pub struct RecordPatternComponent<'tree> {
6002 pub span: ::treesitter_types::Span,
6003 pub children: ::std::vec::Vec<RecordPatternComponentChildren<'tree>>,
6004}
6005impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponent<'tree> {
6006 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6007 fn from_node(
6008 node: ::treesitter_types::tree_sitter::Node<'tree>,
6009 src: &'tree [u8],
6010 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6011 debug_assert_eq!(node.kind(), "record_pattern_component");
6012 Ok(Self {
6013 span: ::treesitter_types::Span::from(node),
6014 children: {
6015 #[allow(clippy::suspicious_else_formatting)]
6016 let non_field_children = {
6017 let mut cursor = node.walk();
6018 let mut result = ::std::vec::Vec::new();
6019 if cursor.goto_first_child() {
6020 loop {
6021 if cursor.field_name().is_none()
6022 && cursor.node().is_named()
6023 && !cursor.node().is_extra()
6024 {
6025 result.push(cursor.node());
6026 }
6027 if !cursor.goto_next_sibling() {
6028 break;
6029 }
6030 }
6031 }
6032 result
6033 };
6034 let mut items = ::std::vec::Vec::new();
6035 for child in non_field_children {
6036 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6037 <RecordPatternComponentChildren as ::treesitter_types::FromNode>::from_node(
6038 child, src,
6039 )
6040 })?);
6041 }
6042 items
6043 },
6044 })
6045 }
6046}
6047impl ::treesitter_types::Spanned for RecordPatternComponent<'_> {
6048 fn span(&self) -> ::treesitter_types::Span {
6049 self.span
6050 }
6051}
6052#[derive(Debug, Clone, PartialEq, Eq)]
6053pub struct RequiresModifier<'tree> {
6054 pub span: ::treesitter_types::Span,
6055 text: &'tree str,
6056}
6057impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModifier<'tree> {
6058 fn from_node(
6059 node: ::treesitter_types::tree_sitter::Node<'tree>,
6060 src: &'tree [u8],
6061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6062 debug_assert_eq!(node.kind(), "requires_modifier");
6063 Ok(Self {
6064 span: ::treesitter_types::Span::from(node),
6065 text: node.utf8_text(src)?,
6066 })
6067 }
6068}
6069impl<'tree> ::treesitter_types::LeafNode<'tree> for RequiresModifier<'tree> {
6070 fn text(&self) -> &'tree str {
6071 self.text
6072 }
6073}
6074impl ::treesitter_types::Spanned for RequiresModifier<'_> {
6075 fn span(&self) -> ::treesitter_types::Span {
6076 self.span
6077 }
6078}
6079#[derive(Debug, Clone, PartialEq, Eq)]
6080pub struct RequiresModuleDirective<'tree> {
6081 pub span: ::treesitter_types::Span,
6082 pub modifiers: ::std::vec::Vec<RequiresModifier<'tree>>,
6083 pub module: RequiresModuleDirectiveModule<'tree>,
6084}
6085impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirective<'tree> {
6086 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6087 fn from_node(
6088 node: ::treesitter_types::tree_sitter::Node<'tree>,
6089 src: &'tree [u8],
6090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6091 debug_assert_eq!(node.kind(), "requires_module_directive");
6092 Ok(Self {
6093 span: ::treesitter_types::Span::from(node),
6094 modifiers: {
6095 let mut cursor = node.walk();
6096 let mut items = ::std::vec::Vec::new();
6097 for child in node.children_by_field_name("modifiers", &mut cursor) {
6098 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6099 <RequiresModifier as ::treesitter_types::FromNode>::from_node(child, src)
6100 })?);
6101 }
6102 items
6103 },
6104 module: {
6105 let child = node
6106 .child_by_field_name("module")
6107 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
6108 ::treesitter_types::runtime::maybe_grow_stack(|| {
6109 <RequiresModuleDirectiveModule as ::treesitter_types::FromNode>::from_node(
6110 child, src,
6111 )
6112 })?
6113 },
6114 })
6115 }
6116}
6117impl ::treesitter_types::Spanned for RequiresModuleDirective<'_> {
6118 fn span(&self) -> ::treesitter_types::Span {
6119 self.span
6120 }
6121}
6122#[derive(Debug, Clone, PartialEq, Eq)]
6123pub struct Resource<'tree> {
6124 pub span: ::treesitter_types::Span,
6125 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
6126 pub name: ::core::option::Option<ResourceName<'tree>>,
6127 pub r#type: ::core::option::Option<UnannotatedType<'tree>>,
6128 pub value: ::core::option::Option<Expression<'tree>>,
6129 pub children: ::core::option::Option<ResourceChildren<'tree>>,
6130}
6131impl<'tree> ::treesitter_types::FromNode<'tree> for Resource<'tree> {
6132 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6133 fn from_node(
6134 node: ::treesitter_types::tree_sitter::Node<'tree>,
6135 src: &'tree [u8],
6136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6137 debug_assert_eq!(node.kind(), "resource");
6138 Ok(Self {
6139 span: ::treesitter_types::Span::from(node),
6140 dimensions: match node.child_by_field_name("dimensions") {
6141 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6142 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
6143 })?),
6144 None => None,
6145 },
6146 name: match node.child_by_field_name("name") {
6147 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6148 <ResourceName as ::treesitter_types::FromNode>::from_node(child, src)
6149 })?),
6150 None => None,
6151 },
6152 r#type: match node.child_by_field_name("type") {
6153 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6154 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)
6155 })?),
6156 None => None,
6157 },
6158 value: match node.child_by_field_name("value") {
6159 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6160 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6161 })?),
6162 None => None,
6163 },
6164 children: {
6165 #[allow(clippy::suspicious_else_formatting)]
6166 let non_field_children = {
6167 let mut cursor = node.walk();
6168 let mut result = ::std::vec::Vec::new();
6169 if cursor.goto_first_child() {
6170 loop {
6171 if cursor.field_name().is_none()
6172 && cursor.node().is_named()
6173 && !cursor.node().is_extra()
6174 {
6175 result.push(cursor.node());
6176 }
6177 if !cursor.goto_next_sibling() {
6178 break;
6179 }
6180 }
6181 }
6182 result
6183 };
6184 match non_field_children.first() {
6185 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6186 <ResourceChildren as ::treesitter_types::FromNode>::from_node(child, src)
6187 })?),
6188 None => None,
6189 }
6190 },
6191 })
6192 }
6193}
6194impl ::treesitter_types::Spanned for Resource<'_> {
6195 fn span(&self) -> ::treesitter_types::Span {
6196 self.span
6197 }
6198}
6199#[derive(Debug, Clone, PartialEq, Eq)]
6200pub struct ResourceSpecification<'tree> {
6201 pub span: ::treesitter_types::Span,
6202 pub children: ::std::vec::Vec<Resource<'tree>>,
6203}
6204impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceSpecification<'tree> {
6205 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6206 fn from_node(
6207 node: ::treesitter_types::tree_sitter::Node<'tree>,
6208 src: &'tree [u8],
6209 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6210 debug_assert_eq!(node.kind(), "resource_specification");
6211 Ok(Self {
6212 span: ::treesitter_types::Span::from(node),
6213 children: {
6214 #[allow(clippy::suspicious_else_formatting)]
6215 let non_field_children = {
6216 let mut cursor = node.walk();
6217 let mut result = ::std::vec::Vec::new();
6218 if cursor.goto_first_child() {
6219 loop {
6220 if cursor.field_name().is_none()
6221 && cursor.node().is_named()
6222 && !cursor.node().is_extra()
6223 {
6224 result.push(cursor.node());
6225 }
6226 if !cursor.goto_next_sibling() {
6227 break;
6228 }
6229 }
6230 }
6231 result
6232 };
6233 let mut items = ::std::vec::Vec::new();
6234 for child in non_field_children {
6235 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6236 <Resource as ::treesitter_types::FromNode>::from_node(child, src)
6237 })?);
6238 }
6239 items
6240 },
6241 })
6242 }
6243}
6244impl ::treesitter_types::Spanned for ResourceSpecification<'_> {
6245 fn span(&self) -> ::treesitter_types::Span {
6246 self.span
6247 }
6248}
6249#[derive(Debug, Clone, PartialEq, Eq)]
6250pub struct ReturnStatement<'tree> {
6251 pub span: ::treesitter_types::Span,
6252 pub children: ::core::option::Option<Expression<'tree>>,
6253}
6254impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
6255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6256 fn from_node(
6257 node: ::treesitter_types::tree_sitter::Node<'tree>,
6258 src: &'tree [u8],
6259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6260 debug_assert_eq!(node.kind(), "return_statement");
6261 Ok(Self {
6262 span: ::treesitter_types::Span::from(node),
6263 children: {
6264 #[allow(clippy::suspicious_else_formatting)]
6265 let non_field_children = {
6266 let mut cursor = node.walk();
6267 let mut result = ::std::vec::Vec::new();
6268 if cursor.goto_first_child() {
6269 loop {
6270 if cursor.field_name().is_none()
6271 && cursor.node().is_named()
6272 && !cursor.node().is_extra()
6273 {
6274 result.push(cursor.node());
6275 }
6276 if !cursor.goto_next_sibling() {
6277 break;
6278 }
6279 }
6280 }
6281 result
6282 };
6283 match non_field_children.first() {
6284 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6285 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6286 })?),
6287 None => None,
6288 }
6289 },
6290 })
6291 }
6292}
6293impl ::treesitter_types::Spanned for ReturnStatement<'_> {
6294 fn span(&self) -> ::treesitter_types::Span {
6295 self.span
6296 }
6297}
6298#[derive(Debug, Clone, PartialEq, Eq)]
6299pub struct ScopedIdentifier<'tree> {
6300 pub span: ::treesitter_types::Span,
6301 pub name: Identifier<'tree>,
6302 pub scope: ScopedIdentifierScope<'tree>,
6303}
6304impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
6305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6306 fn from_node(
6307 node: ::treesitter_types::tree_sitter::Node<'tree>,
6308 src: &'tree [u8],
6309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6310 debug_assert_eq!(node.kind(), "scoped_identifier");
6311 Ok(Self {
6312 span: ::treesitter_types::Span::from(node),
6313 name: {
6314 let child = node
6315 .child_by_field_name("name")
6316 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6317 ::treesitter_types::runtime::maybe_grow_stack(|| {
6318 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
6319 })?
6320 },
6321 scope: {
6322 let child = node
6323 .child_by_field_name("scope")
6324 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
6325 ::treesitter_types::runtime::maybe_grow_stack(|| {
6326 <ScopedIdentifierScope as ::treesitter_types::FromNode>::from_node(child, src)
6327 })?
6328 },
6329 })
6330 }
6331}
6332impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
6333 fn span(&self) -> ::treesitter_types::Span {
6334 self.span
6335 }
6336}
6337#[derive(Debug, Clone, PartialEq, Eq)]
6338pub struct ScopedTypeIdentifier<'tree> {
6339 pub span: ::treesitter_types::Span,
6340 pub children: ::std::vec::Vec<ScopedTypeIdentifierChildren<'tree>>,
6341}
6342impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
6343 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6344 fn from_node(
6345 node: ::treesitter_types::tree_sitter::Node<'tree>,
6346 src: &'tree [u8],
6347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6348 debug_assert_eq!(node.kind(), "scoped_type_identifier");
6349 Ok(Self {
6350 span: ::treesitter_types::Span::from(node),
6351 children: {
6352 #[allow(clippy::suspicious_else_formatting)]
6353 let non_field_children = {
6354 let mut cursor = node.walk();
6355 let mut result = ::std::vec::Vec::new();
6356 if cursor.goto_first_child() {
6357 loop {
6358 if cursor.field_name().is_none()
6359 && cursor.node().is_named()
6360 && !cursor.node().is_extra()
6361 {
6362 result.push(cursor.node());
6363 }
6364 if !cursor.goto_next_sibling() {
6365 break;
6366 }
6367 }
6368 }
6369 result
6370 };
6371 let mut items = ::std::vec::Vec::new();
6372 for child in non_field_children {
6373 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6374 <ScopedTypeIdentifierChildren as ::treesitter_types::FromNode>::from_node(
6375 child, src,
6376 )
6377 })?);
6378 }
6379 items
6380 },
6381 })
6382 }
6383}
6384impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
6385 fn span(&self) -> ::treesitter_types::Span {
6386 self.span
6387 }
6388}
6389#[derive(Debug, Clone, PartialEq, Eq)]
6390pub struct SpreadParameter<'tree> {
6391 pub span: ::treesitter_types::Span,
6392 pub children: ::std::vec::Vec<SpreadParameterChildren<'tree>>,
6393}
6394impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameter<'tree> {
6395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6396 fn from_node(
6397 node: ::treesitter_types::tree_sitter::Node<'tree>,
6398 src: &'tree [u8],
6399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6400 debug_assert_eq!(node.kind(), "spread_parameter");
6401 Ok(Self {
6402 span: ::treesitter_types::Span::from(node),
6403 children: {
6404 #[allow(clippy::suspicious_else_formatting)]
6405 let non_field_children = {
6406 let mut cursor = node.walk();
6407 let mut result = ::std::vec::Vec::new();
6408 if cursor.goto_first_child() {
6409 loop {
6410 if cursor.field_name().is_none()
6411 && cursor.node().is_named()
6412 && !cursor.node().is_extra()
6413 {
6414 result.push(cursor.node());
6415 }
6416 if !cursor.goto_next_sibling() {
6417 break;
6418 }
6419 }
6420 }
6421 result
6422 };
6423 let mut items = ::std::vec::Vec::new();
6424 for child in non_field_children {
6425 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6426 <SpreadParameterChildren as ::treesitter_types::FromNode>::from_node(
6427 child, src,
6428 )
6429 })?);
6430 }
6431 items
6432 },
6433 })
6434 }
6435}
6436impl ::treesitter_types::Spanned for SpreadParameter<'_> {
6437 fn span(&self) -> ::treesitter_types::Span {
6438 self.span
6439 }
6440}
6441#[derive(Debug, Clone, PartialEq, Eq)]
6442pub struct StaticInitializer<'tree> {
6443 pub span: ::treesitter_types::Span,
6444 pub children: Block<'tree>,
6445}
6446impl<'tree> ::treesitter_types::FromNode<'tree> for StaticInitializer<'tree> {
6447 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6448 fn from_node(
6449 node: ::treesitter_types::tree_sitter::Node<'tree>,
6450 src: &'tree [u8],
6451 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6452 debug_assert_eq!(node.kind(), "static_initializer");
6453 Ok(Self {
6454 span: ::treesitter_types::Span::from(node),
6455 children: {
6456 #[allow(clippy::suspicious_else_formatting)]
6457 let non_field_children = {
6458 let mut cursor = node.walk();
6459 let mut result = ::std::vec::Vec::new();
6460 if cursor.goto_first_child() {
6461 loop {
6462 if cursor.field_name().is_none()
6463 && cursor.node().is_named()
6464 && !cursor.node().is_extra()
6465 {
6466 result.push(cursor.node());
6467 }
6468 if !cursor.goto_next_sibling() {
6469 break;
6470 }
6471 }
6472 }
6473 result
6474 };
6475 let child = if let Some(&c) = non_field_children.first() {
6476 c
6477 } else {
6478 let mut fallback_cursor = node.walk();
6479 let mut fallback_child = None;
6480 if fallback_cursor.goto_first_child() {
6481 loop {
6482 if fallback_cursor.field_name().is_none()
6483 && !fallback_cursor.node().is_extra()
6484 {
6485 let candidate = fallback_cursor.node();
6486 #[allow(clippy::needless_question_mark)]
6487 if (|| -> ::core::result::Result<
6488 _,
6489 ::treesitter_types::ParseError,
6490 > {
6491 let child = candidate;
6492 Ok(
6493 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
6494 child,
6495 src,
6496 ))?,
6497 )
6498 })()
6499 .is_ok()
6500 {
6501 fallback_child = Some(candidate);
6502 break;
6503 }
6504 }
6505 if !fallback_cursor.goto_next_sibling() {
6506 break;
6507 }
6508 }
6509 }
6510 if fallback_child.is_none() {
6511 let mut cursor2 = node.walk();
6512 if cursor2.goto_first_child() {
6513 loop {
6514 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6515 let candidate = cursor2.node();
6516 #[allow(clippy::needless_question_mark)]
6517 if (|| -> ::core::result::Result<
6518 _,
6519 ::treesitter_types::ParseError,
6520 > {
6521 let child = candidate;
6522 Ok(
6523 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
6524 child,
6525 src,
6526 ))?,
6527 )
6528 })()
6529 .is_ok()
6530 {
6531 fallback_child = Some(candidate);
6532 break;
6533 }
6534 }
6535 if !cursor2.goto_next_sibling() {
6536 break;
6537 }
6538 }
6539 }
6540 }
6541 fallback_child.ok_or_else(|| {
6542 ::treesitter_types::ParseError::missing_field("children", node)
6543 })?
6544 };
6545 ::treesitter_types::runtime::maybe_grow_stack(|| {
6546 <Block as ::treesitter_types::FromNode>::from_node(child, src)
6547 })?
6548 },
6549 })
6550 }
6551}
6552impl ::treesitter_types::Spanned for StaticInitializer<'_> {
6553 fn span(&self) -> ::treesitter_types::Span {
6554 self.span
6555 }
6556}
6557#[derive(Debug, Clone, PartialEq, Eq)]
6558pub struct StringInterpolation<'tree> {
6559 pub span: ::treesitter_types::Span,
6560 pub children: Expression<'tree>,
6561}
6562impl<'tree> ::treesitter_types::FromNode<'tree> for StringInterpolation<'tree> {
6563 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6564 fn from_node(
6565 node: ::treesitter_types::tree_sitter::Node<'tree>,
6566 src: &'tree [u8],
6567 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6568 debug_assert_eq!(node.kind(), "string_interpolation");
6569 Ok(Self {
6570 span: ::treesitter_types::Span::from(node),
6571 children: {
6572 #[allow(clippy::suspicious_else_formatting)]
6573 let non_field_children = {
6574 let mut cursor = node.walk();
6575 let mut result = ::std::vec::Vec::new();
6576 if cursor.goto_first_child() {
6577 loop {
6578 if cursor.field_name().is_none()
6579 && cursor.node().is_named()
6580 && !cursor.node().is_extra()
6581 {
6582 result.push(cursor.node());
6583 }
6584 if !cursor.goto_next_sibling() {
6585 break;
6586 }
6587 }
6588 }
6589 result
6590 };
6591 let child = if let Some(&c) = non_field_children.first() {
6592 c
6593 } else {
6594 let mut fallback_cursor = node.walk();
6595 let mut fallback_child = None;
6596 if fallback_cursor.goto_first_child() {
6597 loop {
6598 if fallback_cursor.field_name().is_none()
6599 && !fallback_cursor.node().is_extra()
6600 {
6601 let candidate = fallback_cursor.node();
6602 #[allow(clippy::needless_question_mark)]
6603 if (|| -> ::core::result::Result<
6604 _,
6605 ::treesitter_types::ParseError,
6606 > {
6607 let child = candidate;
6608 Ok(
6609 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6610 child,
6611 src,
6612 ))?,
6613 )
6614 })()
6615 .is_ok()
6616 {
6617 fallback_child = Some(candidate);
6618 break;
6619 }
6620 }
6621 if !fallback_cursor.goto_next_sibling() {
6622 break;
6623 }
6624 }
6625 }
6626 if fallback_child.is_none() {
6627 let mut cursor2 = node.walk();
6628 if cursor2.goto_first_child() {
6629 loop {
6630 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6631 let candidate = cursor2.node();
6632 #[allow(clippy::needless_question_mark)]
6633 if (|| -> ::core::result::Result<
6634 _,
6635 ::treesitter_types::ParseError,
6636 > {
6637 let child = candidate;
6638 Ok(
6639 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6640 child,
6641 src,
6642 ))?,
6643 )
6644 })()
6645 .is_ok()
6646 {
6647 fallback_child = Some(candidate);
6648 break;
6649 }
6650 }
6651 if !cursor2.goto_next_sibling() {
6652 break;
6653 }
6654 }
6655 }
6656 }
6657 fallback_child.ok_or_else(|| {
6658 ::treesitter_types::ParseError::missing_field("children", node)
6659 })?
6660 };
6661 ::treesitter_types::runtime::maybe_grow_stack(|| {
6662 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6663 })?
6664 },
6665 })
6666 }
6667}
6668impl ::treesitter_types::Spanned for StringInterpolation<'_> {
6669 fn span(&self) -> ::treesitter_types::Span {
6670 self.span
6671 }
6672}
6673#[derive(Debug, Clone, PartialEq, Eq)]
6674pub struct StringLiteral<'tree> {
6675 pub span: ::treesitter_types::Span,
6676 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
6677}
6678impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
6679 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6680 fn from_node(
6681 node: ::treesitter_types::tree_sitter::Node<'tree>,
6682 src: &'tree [u8],
6683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6684 debug_assert_eq!(node.kind(), "string_literal");
6685 Ok(Self {
6686 span: ::treesitter_types::Span::from(node),
6687 children: {
6688 #[allow(clippy::suspicious_else_formatting)]
6689 let non_field_children = {
6690 let mut cursor = node.walk();
6691 let mut result = ::std::vec::Vec::new();
6692 if cursor.goto_first_child() {
6693 loop {
6694 if cursor.field_name().is_none()
6695 && cursor.node().is_named()
6696 && !cursor.node().is_extra()
6697 {
6698 result.push(cursor.node());
6699 }
6700 if !cursor.goto_next_sibling() {
6701 break;
6702 }
6703 }
6704 }
6705 result
6706 };
6707 let mut items = ::std::vec::Vec::new();
6708 for child in non_field_children {
6709 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6710 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
6711 child, src,
6712 )
6713 })?);
6714 }
6715 items
6716 },
6717 })
6718 }
6719}
6720impl ::treesitter_types::Spanned for StringLiteral<'_> {
6721 fn span(&self) -> ::treesitter_types::Span {
6722 self.span
6723 }
6724}
6725#[derive(Debug, Clone, PartialEq, Eq)]
6726pub struct SuperInterfaces<'tree> {
6727 pub span: ::treesitter_types::Span,
6728 pub children: TypeList<'tree>,
6729}
6730impl<'tree> ::treesitter_types::FromNode<'tree> for SuperInterfaces<'tree> {
6731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6732 fn from_node(
6733 node: ::treesitter_types::tree_sitter::Node<'tree>,
6734 src: &'tree [u8],
6735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6736 debug_assert_eq!(node.kind(), "super_interfaces");
6737 Ok(Self {
6738 span: ::treesitter_types::Span::from(node),
6739 children: {
6740 #[allow(clippy::suspicious_else_formatting)]
6741 let non_field_children = {
6742 let mut cursor = node.walk();
6743 let mut result = ::std::vec::Vec::new();
6744 if cursor.goto_first_child() {
6745 loop {
6746 if cursor.field_name().is_none()
6747 && cursor.node().is_named()
6748 && !cursor.node().is_extra()
6749 {
6750 result.push(cursor.node());
6751 }
6752 if !cursor.goto_next_sibling() {
6753 break;
6754 }
6755 }
6756 }
6757 result
6758 };
6759 let child = if let Some(&c) = non_field_children.first() {
6760 c
6761 } else {
6762 let mut fallback_cursor = node.walk();
6763 let mut fallback_child = None;
6764 if fallback_cursor.goto_first_child() {
6765 loop {
6766 if fallback_cursor.field_name().is_none()
6767 && !fallback_cursor.node().is_extra()
6768 {
6769 let candidate = fallback_cursor.node();
6770 #[allow(clippy::needless_question_mark)]
6771 if (|| -> ::core::result::Result<
6772 _,
6773 ::treesitter_types::ParseError,
6774 > {
6775 let child = candidate;
6776 Ok(
6777 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
6778 child,
6779 src,
6780 ))?,
6781 )
6782 })()
6783 .is_ok()
6784 {
6785 fallback_child = Some(candidate);
6786 break;
6787 }
6788 }
6789 if !fallback_cursor.goto_next_sibling() {
6790 break;
6791 }
6792 }
6793 }
6794 if fallback_child.is_none() {
6795 let mut cursor2 = node.walk();
6796 if cursor2.goto_first_child() {
6797 loop {
6798 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6799 let candidate = cursor2.node();
6800 #[allow(clippy::needless_question_mark)]
6801 if (|| -> ::core::result::Result<
6802 _,
6803 ::treesitter_types::ParseError,
6804 > {
6805 let child = candidate;
6806 Ok(
6807 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeList as ::treesitter_types::FromNode>::from_node(
6808 child,
6809 src,
6810 ))?,
6811 )
6812 })()
6813 .is_ok()
6814 {
6815 fallback_child = Some(candidate);
6816 break;
6817 }
6818 }
6819 if !cursor2.goto_next_sibling() {
6820 break;
6821 }
6822 }
6823 }
6824 }
6825 fallback_child.ok_or_else(|| {
6826 ::treesitter_types::ParseError::missing_field("children", node)
6827 })?
6828 };
6829 ::treesitter_types::runtime::maybe_grow_stack(|| {
6830 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)
6831 })?
6832 },
6833 })
6834 }
6835}
6836impl ::treesitter_types::Spanned for SuperInterfaces<'_> {
6837 fn span(&self) -> ::treesitter_types::Span {
6838 self.span
6839 }
6840}
6841#[derive(Debug, Clone, PartialEq, Eq)]
6842pub struct Superclass<'tree> {
6843 pub span: ::treesitter_types::Span,
6844 pub children: Type<'tree>,
6845}
6846impl<'tree> ::treesitter_types::FromNode<'tree> for Superclass<'tree> {
6847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6848 fn from_node(
6849 node: ::treesitter_types::tree_sitter::Node<'tree>,
6850 src: &'tree [u8],
6851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6852 debug_assert_eq!(node.kind(), "superclass");
6853 Ok(Self {
6854 span: ::treesitter_types::Span::from(node),
6855 children: {
6856 #[allow(clippy::suspicious_else_formatting)]
6857 let non_field_children = {
6858 let mut cursor = node.walk();
6859 let mut result = ::std::vec::Vec::new();
6860 if cursor.goto_first_child() {
6861 loop {
6862 if cursor.field_name().is_none()
6863 && cursor.node().is_named()
6864 && !cursor.node().is_extra()
6865 {
6866 result.push(cursor.node());
6867 }
6868 if !cursor.goto_next_sibling() {
6869 break;
6870 }
6871 }
6872 }
6873 result
6874 };
6875 let child = if let Some(&c) = non_field_children.first() {
6876 c
6877 } else {
6878 let mut fallback_cursor = node.walk();
6879 let mut fallback_child = None;
6880 if fallback_cursor.goto_first_child() {
6881 loop {
6882 if fallback_cursor.field_name().is_none()
6883 && !fallback_cursor.node().is_extra()
6884 {
6885 let candidate = fallback_cursor.node();
6886 #[allow(clippy::needless_question_mark)]
6887 if (|| -> ::core::result::Result<
6888 _,
6889 ::treesitter_types::ParseError,
6890 > {
6891 let child = candidate;
6892 Ok(
6893 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
6894 child,
6895 src,
6896 ))?,
6897 )
6898 })()
6899 .is_ok()
6900 {
6901 fallback_child = Some(candidate);
6902 break;
6903 }
6904 }
6905 if !fallback_cursor.goto_next_sibling() {
6906 break;
6907 }
6908 }
6909 }
6910 if fallback_child.is_none() {
6911 let mut cursor2 = node.walk();
6912 if cursor2.goto_first_child() {
6913 loop {
6914 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6915 let candidate = cursor2.node();
6916 #[allow(clippy::needless_question_mark)]
6917 if (|| -> ::core::result::Result<
6918 _,
6919 ::treesitter_types::ParseError,
6920 > {
6921 let child = candidate;
6922 Ok(
6923 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
6924 child,
6925 src,
6926 ))?,
6927 )
6928 })()
6929 .is_ok()
6930 {
6931 fallback_child = Some(candidate);
6932 break;
6933 }
6934 }
6935 if !cursor2.goto_next_sibling() {
6936 break;
6937 }
6938 }
6939 }
6940 }
6941 fallback_child.ok_or_else(|| {
6942 ::treesitter_types::ParseError::missing_field("children", node)
6943 })?
6944 };
6945 ::treesitter_types::runtime::maybe_grow_stack(|| {
6946 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6947 })?
6948 },
6949 })
6950 }
6951}
6952impl ::treesitter_types::Spanned for Superclass<'_> {
6953 fn span(&self) -> ::treesitter_types::Span {
6954 self.span
6955 }
6956}
6957#[derive(Debug, Clone, PartialEq, Eq)]
6958pub struct SwitchBlock<'tree> {
6959 pub span: ::treesitter_types::Span,
6960 pub children: ::std::vec::Vec<SwitchBlockChildren<'tree>>,
6961}
6962impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlock<'tree> {
6963 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6964 fn from_node(
6965 node: ::treesitter_types::tree_sitter::Node<'tree>,
6966 src: &'tree [u8],
6967 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6968 debug_assert_eq!(node.kind(), "switch_block");
6969 Ok(Self {
6970 span: ::treesitter_types::Span::from(node),
6971 children: {
6972 #[allow(clippy::suspicious_else_formatting)]
6973 let non_field_children = {
6974 let mut cursor = node.walk();
6975 let mut result = ::std::vec::Vec::new();
6976 if cursor.goto_first_child() {
6977 loop {
6978 if cursor.field_name().is_none()
6979 && cursor.node().is_named()
6980 && !cursor.node().is_extra()
6981 {
6982 result.push(cursor.node());
6983 }
6984 if !cursor.goto_next_sibling() {
6985 break;
6986 }
6987 }
6988 }
6989 result
6990 };
6991 let mut items = ::std::vec::Vec::new();
6992 for child in non_field_children {
6993 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6994 <SwitchBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
6995 })?);
6996 }
6997 items
6998 },
6999 })
7000 }
7001}
7002impl ::treesitter_types::Spanned for SwitchBlock<'_> {
7003 fn span(&self) -> ::treesitter_types::Span {
7004 self.span
7005 }
7006}
7007#[derive(Debug, Clone, PartialEq, Eq)]
7008pub struct SwitchBlockStatementGroup<'tree> {
7009 pub span: ::treesitter_types::Span,
7010 pub children: ::std::vec::Vec<SwitchBlockStatementGroupChildren<'tree>>,
7011}
7012impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroup<'tree> {
7013 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7014 fn from_node(
7015 node: ::treesitter_types::tree_sitter::Node<'tree>,
7016 src: &'tree [u8],
7017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7018 debug_assert_eq!(node.kind(), "switch_block_statement_group");
7019 Ok(Self {
7020 span: ::treesitter_types::Span::from(node),
7021 children: {
7022 #[allow(clippy::suspicious_else_formatting)]
7023 let non_field_children = {
7024 let mut cursor = node.walk();
7025 let mut result = ::std::vec::Vec::new();
7026 if cursor.goto_first_child() {
7027 loop {
7028 if cursor.field_name().is_none()
7029 && cursor.node().is_named()
7030 && !cursor.node().is_extra()
7031 {
7032 result.push(cursor.node());
7033 }
7034 if !cursor.goto_next_sibling() {
7035 break;
7036 }
7037 }
7038 }
7039 result
7040 };
7041 let mut items = ::std::vec::Vec::new();
7042 for child in non_field_children {
7043 items
7044 .push(
7045 ::treesitter_types::runtime::maybe_grow_stack(|| <SwitchBlockStatementGroupChildren as ::treesitter_types::FromNode>::from_node(
7046 child,
7047 src,
7048 ))?,
7049 );
7050 }
7051 items
7052 },
7053 })
7054 }
7055}
7056impl ::treesitter_types::Spanned for SwitchBlockStatementGroup<'_> {
7057 fn span(&self) -> ::treesitter_types::Span {
7058 self.span
7059 }
7060}
7061#[derive(Debug, Clone, PartialEq, Eq)]
7062pub struct SwitchExpression<'tree> {
7063 pub span: ::treesitter_types::Span,
7064 pub body: SwitchBlock<'tree>,
7065 pub condition: ParenthesizedExpression<'tree>,
7066}
7067impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
7068 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7069 fn from_node(
7070 node: ::treesitter_types::tree_sitter::Node<'tree>,
7071 src: &'tree [u8],
7072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7073 debug_assert_eq!(node.kind(), "switch_expression");
7074 Ok(Self {
7075 span: ::treesitter_types::Span::from(node),
7076 body: {
7077 let child = node
7078 .child_by_field_name("body")
7079 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7080 ::treesitter_types::runtime::maybe_grow_stack(|| {
7081 <SwitchBlock as ::treesitter_types::FromNode>::from_node(child, src)
7082 })?
7083 },
7084 condition: {
7085 let child = node.child_by_field_name("condition").ok_or_else(|| {
7086 ::treesitter_types::ParseError::missing_field("condition", node)
7087 })?;
7088 ::treesitter_types::runtime::maybe_grow_stack(|| {
7089 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
7090 })?
7091 },
7092 })
7093 }
7094}
7095impl ::treesitter_types::Spanned for SwitchExpression<'_> {
7096 fn span(&self) -> ::treesitter_types::Span {
7097 self.span
7098 }
7099}
7100#[derive(Debug, Clone, PartialEq, Eq)]
7101pub struct SwitchLabel<'tree> {
7102 pub span: ::treesitter_types::Span,
7103 pub children: ::std::vec::Vec<SwitchLabelChildren<'tree>>,
7104}
7105impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabel<'tree> {
7106 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7107 fn from_node(
7108 node: ::treesitter_types::tree_sitter::Node<'tree>,
7109 src: &'tree [u8],
7110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7111 debug_assert_eq!(node.kind(), "switch_label");
7112 Ok(Self {
7113 span: ::treesitter_types::Span::from(node),
7114 children: {
7115 #[allow(clippy::suspicious_else_formatting)]
7116 let non_field_children = {
7117 let mut cursor = node.walk();
7118 let mut result = ::std::vec::Vec::new();
7119 if cursor.goto_first_child() {
7120 loop {
7121 if cursor.field_name().is_none()
7122 && cursor.node().is_named()
7123 && !cursor.node().is_extra()
7124 {
7125 result.push(cursor.node());
7126 }
7127 if !cursor.goto_next_sibling() {
7128 break;
7129 }
7130 }
7131 }
7132 result
7133 };
7134 let mut items = ::std::vec::Vec::new();
7135 for child in non_field_children {
7136 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7137 <SwitchLabelChildren as ::treesitter_types::FromNode>::from_node(child, src)
7138 })?);
7139 }
7140 items
7141 },
7142 })
7143 }
7144}
7145impl ::treesitter_types::Spanned for SwitchLabel<'_> {
7146 fn span(&self) -> ::treesitter_types::Span {
7147 self.span
7148 }
7149}
7150#[derive(Debug, Clone, PartialEq, Eq)]
7151pub struct SwitchRule<'tree> {
7152 pub span: ::treesitter_types::Span,
7153 pub children: ::std::vec::Vec<SwitchRuleChildren<'tree>>,
7154}
7155impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRule<'tree> {
7156 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7157 fn from_node(
7158 node: ::treesitter_types::tree_sitter::Node<'tree>,
7159 src: &'tree [u8],
7160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7161 debug_assert_eq!(node.kind(), "switch_rule");
7162 Ok(Self {
7163 span: ::treesitter_types::Span::from(node),
7164 children: {
7165 #[allow(clippy::suspicious_else_formatting)]
7166 let non_field_children = {
7167 let mut cursor = node.walk();
7168 let mut result = ::std::vec::Vec::new();
7169 if cursor.goto_first_child() {
7170 loop {
7171 if cursor.field_name().is_none()
7172 && cursor.node().is_named()
7173 && !cursor.node().is_extra()
7174 {
7175 result.push(cursor.node());
7176 }
7177 if !cursor.goto_next_sibling() {
7178 break;
7179 }
7180 }
7181 }
7182 result
7183 };
7184 let mut items = ::std::vec::Vec::new();
7185 for child in non_field_children {
7186 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7187 <SwitchRuleChildren as ::treesitter_types::FromNode>::from_node(child, src)
7188 })?);
7189 }
7190 items
7191 },
7192 })
7193 }
7194}
7195impl ::treesitter_types::Spanned for SwitchRule<'_> {
7196 fn span(&self) -> ::treesitter_types::Span {
7197 self.span
7198 }
7199}
7200#[derive(Debug, Clone, PartialEq, Eq)]
7201pub struct SynchronizedStatement<'tree> {
7202 pub span: ::treesitter_types::Span,
7203 pub body: Block<'tree>,
7204 pub children: ParenthesizedExpression<'tree>,
7205}
7206impl<'tree> ::treesitter_types::FromNode<'tree> for SynchronizedStatement<'tree> {
7207 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7208 fn from_node(
7209 node: ::treesitter_types::tree_sitter::Node<'tree>,
7210 src: &'tree [u8],
7211 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7212 debug_assert_eq!(node.kind(), "synchronized_statement");
7213 Ok(Self {
7214 span: ::treesitter_types::Span::from(node),
7215 body: {
7216 let child = node
7217 .child_by_field_name("body")
7218 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7219 ::treesitter_types::runtime::maybe_grow_stack(|| {
7220 <Block as ::treesitter_types::FromNode>::from_node(child, src)
7221 })?
7222 },
7223 children: {
7224 #[allow(clippy::suspicious_else_formatting)]
7225 let non_field_children = {
7226 let mut cursor = node.walk();
7227 let mut result = ::std::vec::Vec::new();
7228 if cursor.goto_first_child() {
7229 loop {
7230 if cursor.field_name().is_none()
7231 && cursor.node().is_named()
7232 && !cursor.node().is_extra()
7233 {
7234 result.push(cursor.node());
7235 }
7236 if !cursor.goto_next_sibling() {
7237 break;
7238 }
7239 }
7240 }
7241 result
7242 };
7243 let child = if let Some(&c) = non_field_children.first() {
7244 c
7245 } else {
7246 let mut fallback_cursor = node.walk();
7247 let mut fallback_child = None;
7248 if fallback_cursor.goto_first_child() {
7249 loop {
7250 if fallback_cursor.field_name().is_none()
7251 && !fallback_cursor.node().is_extra()
7252 {
7253 let candidate = fallback_cursor.node();
7254 #[allow(clippy::needless_question_mark)]
7255 if (|| -> ::core::result::Result<
7256 _,
7257 ::treesitter_types::ParseError,
7258 > {
7259 let child = candidate;
7260 Ok(
7261 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
7262 child,
7263 src,
7264 ))?,
7265 )
7266 })()
7267 .is_ok()
7268 {
7269 fallback_child = Some(candidate);
7270 break;
7271 }
7272 }
7273 if !fallback_cursor.goto_next_sibling() {
7274 break;
7275 }
7276 }
7277 }
7278 if fallback_child.is_none() {
7279 let mut cursor2 = node.walk();
7280 if cursor2.goto_first_child() {
7281 loop {
7282 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7283 let candidate = cursor2.node();
7284 #[allow(clippy::needless_question_mark)]
7285 if (|| -> ::core::result::Result<
7286 _,
7287 ::treesitter_types::ParseError,
7288 > {
7289 let child = candidate;
7290 Ok(
7291 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
7292 child,
7293 src,
7294 ))?,
7295 )
7296 })()
7297 .is_ok()
7298 {
7299 fallback_child = Some(candidate);
7300 break;
7301 }
7302 }
7303 if !cursor2.goto_next_sibling() {
7304 break;
7305 }
7306 }
7307 }
7308 }
7309 fallback_child.ok_or_else(|| {
7310 ::treesitter_types::ParseError::missing_field("children", node)
7311 })?
7312 };
7313 ::treesitter_types::runtime::maybe_grow_stack(|| {
7314 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
7315 })?
7316 },
7317 })
7318 }
7319}
7320impl ::treesitter_types::Spanned for SynchronizedStatement<'_> {
7321 fn span(&self) -> ::treesitter_types::Span {
7322 self.span
7323 }
7324}
7325#[derive(Debug, Clone, PartialEq, Eq)]
7326pub struct TemplateExpression<'tree> {
7327 pub span: ::treesitter_types::Span,
7328 pub template_argument: StringLiteral<'tree>,
7329 pub template_processor: PrimaryExpression<'tree>,
7330}
7331impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateExpression<'tree> {
7332 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7333 fn from_node(
7334 node: ::treesitter_types::tree_sitter::Node<'tree>,
7335 src: &'tree [u8],
7336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7337 debug_assert_eq!(node.kind(), "template_expression");
7338 Ok(Self {
7339 span: ::treesitter_types::Span::from(node),
7340 template_argument: {
7341 let child = node
7342 .child_by_field_name("template_argument")
7343 .ok_or_else(|| {
7344 ::treesitter_types::ParseError::missing_field("template_argument", node)
7345 })?;
7346 ::treesitter_types::runtime::maybe_grow_stack(|| {
7347 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
7348 })?
7349 },
7350 template_processor: {
7351 let child = node
7352 .child_by_field_name("template_processor")
7353 .ok_or_else(|| {
7354 ::treesitter_types::ParseError::missing_field("template_processor", node)
7355 })?;
7356 ::treesitter_types::runtime::maybe_grow_stack(|| {
7357 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)
7358 })?
7359 },
7360 })
7361 }
7362}
7363impl ::treesitter_types::Spanned for TemplateExpression<'_> {
7364 fn span(&self) -> ::treesitter_types::Span {
7365 self.span
7366 }
7367}
7368#[derive(Debug, Clone, PartialEq, Eq)]
7369pub struct TernaryExpression<'tree> {
7370 pub span: ::treesitter_types::Span,
7371 pub alternative: Expression<'tree>,
7372 pub condition: Expression<'tree>,
7373 pub consequence: Expression<'tree>,
7374}
7375impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
7376 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7377 fn from_node(
7378 node: ::treesitter_types::tree_sitter::Node<'tree>,
7379 src: &'tree [u8],
7380 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7381 debug_assert_eq!(node.kind(), "ternary_expression");
7382 Ok(Self {
7383 span: ::treesitter_types::Span::from(node),
7384 alternative: {
7385 let child = node.child_by_field_name("alternative").ok_or_else(|| {
7386 ::treesitter_types::ParseError::missing_field("alternative", node)
7387 })?;
7388 ::treesitter_types::runtime::maybe_grow_stack(|| {
7389 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7390 })?
7391 },
7392 condition: {
7393 let child = node.child_by_field_name("condition").ok_or_else(|| {
7394 ::treesitter_types::ParseError::missing_field("condition", node)
7395 })?;
7396 ::treesitter_types::runtime::maybe_grow_stack(|| {
7397 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7398 })?
7399 },
7400 consequence: {
7401 let child = node.child_by_field_name("consequence").ok_or_else(|| {
7402 ::treesitter_types::ParseError::missing_field("consequence", node)
7403 })?;
7404 ::treesitter_types::runtime::maybe_grow_stack(|| {
7405 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7406 })?
7407 },
7408 })
7409 }
7410}
7411impl ::treesitter_types::Spanned for TernaryExpression<'_> {
7412 fn span(&self) -> ::treesitter_types::Span {
7413 self.span
7414 }
7415}
7416#[derive(Debug, Clone, PartialEq, Eq)]
7417pub struct ThrowStatement<'tree> {
7418 pub span: ::treesitter_types::Span,
7419 pub children: Expression<'tree>,
7420}
7421impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
7422 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7423 fn from_node(
7424 node: ::treesitter_types::tree_sitter::Node<'tree>,
7425 src: &'tree [u8],
7426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7427 debug_assert_eq!(node.kind(), "throw_statement");
7428 Ok(Self {
7429 span: ::treesitter_types::Span::from(node),
7430 children: {
7431 #[allow(clippy::suspicious_else_formatting)]
7432 let non_field_children = {
7433 let mut cursor = node.walk();
7434 let mut result = ::std::vec::Vec::new();
7435 if cursor.goto_first_child() {
7436 loop {
7437 if cursor.field_name().is_none()
7438 && cursor.node().is_named()
7439 && !cursor.node().is_extra()
7440 {
7441 result.push(cursor.node());
7442 }
7443 if !cursor.goto_next_sibling() {
7444 break;
7445 }
7446 }
7447 }
7448 result
7449 };
7450 let child = if let Some(&c) = non_field_children.first() {
7451 c
7452 } else {
7453 let mut fallback_cursor = node.walk();
7454 let mut fallback_child = None;
7455 if fallback_cursor.goto_first_child() {
7456 loop {
7457 if fallback_cursor.field_name().is_none()
7458 && !fallback_cursor.node().is_extra()
7459 {
7460 let candidate = fallback_cursor.node();
7461 #[allow(clippy::needless_question_mark)]
7462 if (|| -> ::core::result::Result<
7463 _,
7464 ::treesitter_types::ParseError,
7465 > {
7466 let child = candidate;
7467 Ok(
7468 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7469 child,
7470 src,
7471 ))?,
7472 )
7473 })()
7474 .is_ok()
7475 {
7476 fallback_child = Some(candidate);
7477 break;
7478 }
7479 }
7480 if !fallback_cursor.goto_next_sibling() {
7481 break;
7482 }
7483 }
7484 }
7485 if fallback_child.is_none() {
7486 let mut cursor2 = node.walk();
7487 if cursor2.goto_first_child() {
7488 loop {
7489 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7490 let candidate = cursor2.node();
7491 #[allow(clippy::needless_question_mark)]
7492 if (|| -> ::core::result::Result<
7493 _,
7494 ::treesitter_types::ParseError,
7495 > {
7496 let child = candidate;
7497 Ok(
7498 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7499 child,
7500 src,
7501 ))?,
7502 )
7503 })()
7504 .is_ok()
7505 {
7506 fallback_child = Some(candidate);
7507 break;
7508 }
7509 }
7510 if !cursor2.goto_next_sibling() {
7511 break;
7512 }
7513 }
7514 }
7515 }
7516 fallback_child.ok_or_else(|| {
7517 ::treesitter_types::ParseError::missing_field("children", node)
7518 })?
7519 };
7520 ::treesitter_types::runtime::maybe_grow_stack(|| {
7521 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7522 })?
7523 },
7524 })
7525 }
7526}
7527impl ::treesitter_types::Spanned for ThrowStatement<'_> {
7528 fn span(&self) -> ::treesitter_types::Span {
7529 self.span
7530 }
7531}
7532#[derive(Debug, Clone, PartialEq, Eq)]
7533pub struct Throws<'tree> {
7534 pub span: ::treesitter_types::Span,
7535 pub children: ::std::vec::Vec<Type<'tree>>,
7536}
7537impl<'tree> ::treesitter_types::FromNode<'tree> for Throws<'tree> {
7538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7539 fn from_node(
7540 node: ::treesitter_types::tree_sitter::Node<'tree>,
7541 src: &'tree [u8],
7542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7543 debug_assert_eq!(node.kind(), "throws");
7544 Ok(Self {
7545 span: ::treesitter_types::Span::from(node),
7546 children: {
7547 #[allow(clippy::suspicious_else_formatting)]
7548 let non_field_children = {
7549 let mut cursor = node.walk();
7550 let mut result = ::std::vec::Vec::new();
7551 if cursor.goto_first_child() {
7552 loop {
7553 if cursor.field_name().is_none()
7554 && cursor.node().is_named()
7555 && !cursor.node().is_extra()
7556 {
7557 result.push(cursor.node());
7558 }
7559 if !cursor.goto_next_sibling() {
7560 break;
7561 }
7562 }
7563 }
7564 result
7565 };
7566 let mut items = ::std::vec::Vec::new();
7567 for child in non_field_children {
7568 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7569 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7570 })?);
7571 }
7572 items
7573 },
7574 })
7575 }
7576}
7577impl ::treesitter_types::Spanned for Throws<'_> {
7578 fn span(&self) -> ::treesitter_types::Span {
7579 self.span
7580 }
7581}
7582#[derive(Debug, Clone, PartialEq, Eq)]
7583pub struct TryStatement<'tree> {
7584 pub span: ::treesitter_types::Span,
7585 pub body: Block<'tree>,
7586 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
7587}
7588impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
7589 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7590 fn from_node(
7591 node: ::treesitter_types::tree_sitter::Node<'tree>,
7592 src: &'tree [u8],
7593 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7594 debug_assert_eq!(node.kind(), "try_statement");
7595 Ok(Self {
7596 span: ::treesitter_types::Span::from(node),
7597 body: {
7598 let child = node
7599 .child_by_field_name("body")
7600 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7601 ::treesitter_types::runtime::maybe_grow_stack(|| {
7602 <Block as ::treesitter_types::FromNode>::from_node(child, src)
7603 })?
7604 },
7605 children: {
7606 #[allow(clippy::suspicious_else_formatting)]
7607 let non_field_children = {
7608 let mut cursor = node.walk();
7609 let mut result = ::std::vec::Vec::new();
7610 if cursor.goto_first_child() {
7611 loop {
7612 if cursor.field_name().is_none()
7613 && cursor.node().is_named()
7614 && !cursor.node().is_extra()
7615 {
7616 result.push(cursor.node());
7617 }
7618 if !cursor.goto_next_sibling() {
7619 break;
7620 }
7621 }
7622 }
7623 result
7624 };
7625 let mut items = ::std::vec::Vec::new();
7626 for child in non_field_children {
7627 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7628 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
7629 child, src,
7630 )
7631 })?);
7632 }
7633 items
7634 },
7635 })
7636 }
7637}
7638impl ::treesitter_types::Spanned for TryStatement<'_> {
7639 fn span(&self) -> ::treesitter_types::Span {
7640 self.span
7641 }
7642}
7643#[derive(Debug, Clone, PartialEq, Eq)]
7644pub struct TryWithResourcesStatement<'tree> {
7645 pub span: ::treesitter_types::Span,
7646 pub body: Block<'tree>,
7647 pub resources: ResourceSpecification<'tree>,
7648 pub children: ::std::vec::Vec<TryWithResourcesStatementChildren<'tree>>,
7649}
7650impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatement<'tree> {
7651 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7652 fn from_node(
7653 node: ::treesitter_types::tree_sitter::Node<'tree>,
7654 src: &'tree [u8],
7655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7656 debug_assert_eq!(node.kind(), "try_with_resources_statement");
7657 Ok(Self {
7658 span: ::treesitter_types::Span::from(node),
7659 body: {
7660 let child = node
7661 .child_by_field_name("body")
7662 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7663 ::treesitter_types::runtime::maybe_grow_stack(|| {
7664 <Block as ::treesitter_types::FromNode>::from_node(child, src)
7665 })?
7666 },
7667 resources: {
7668 let child = node.child_by_field_name("resources").ok_or_else(|| {
7669 ::treesitter_types::ParseError::missing_field("resources", node)
7670 })?;
7671 ::treesitter_types::runtime::maybe_grow_stack(|| {
7672 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(child, src)
7673 })?
7674 },
7675 children: {
7676 #[allow(clippy::suspicious_else_formatting)]
7677 let non_field_children = {
7678 let mut cursor = node.walk();
7679 let mut result = ::std::vec::Vec::new();
7680 if cursor.goto_first_child() {
7681 loop {
7682 if cursor.field_name().is_none()
7683 && cursor.node().is_named()
7684 && !cursor.node().is_extra()
7685 {
7686 result.push(cursor.node());
7687 }
7688 if !cursor.goto_next_sibling() {
7689 break;
7690 }
7691 }
7692 }
7693 result
7694 };
7695 let mut items = ::std::vec::Vec::new();
7696 for child in non_field_children {
7697 items
7698 .push(
7699 ::treesitter_types::runtime::maybe_grow_stack(|| <TryWithResourcesStatementChildren as ::treesitter_types::FromNode>::from_node(
7700 child,
7701 src,
7702 ))?,
7703 );
7704 }
7705 items
7706 },
7707 })
7708 }
7709}
7710impl ::treesitter_types::Spanned for TryWithResourcesStatement<'_> {
7711 fn span(&self) -> ::treesitter_types::Span {
7712 self.span
7713 }
7714}
7715#[derive(Debug, Clone, PartialEq, Eq)]
7716pub struct TypeArguments<'tree> {
7717 pub span: ::treesitter_types::Span,
7718 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
7719}
7720impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
7721 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7722 fn from_node(
7723 node: ::treesitter_types::tree_sitter::Node<'tree>,
7724 src: &'tree [u8],
7725 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7726 debug_assert_eq!(node.kind(), "type_arguments");
7727 Ok(Self {
7728 span: ::treesitter_types::Span::from(node),
7729 children: {
7730 #[allow(clippy::suspicious_else_formatting)]
7731 let non_field_children = {
7732 let mut cursor = node.walk();
7733 let mut result = ::std::vec::Vec::new();
7734 if cursor.goto_first_child() {
7735 loop {
7736 if cursor.field_name().is_none()
7737 && cursor.node().is_named()
7738 && !cursor.node().is_extra()
7739 {
7740 result.push(cursor.node());
7741 }
7742 if !cursor.goto_next_sibling() {
7743 break;
7744 }
7745 }
7746 }
7747 result
7748 };
7749 let mut items = ::std::vec::Vec::new();
7750 for child in non_field_children {
7751 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7752 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
7753 child, src,
7754 )
7755 })?);
7756 }
7757 items
7758 },
7759 })
7760 }
7761}
7762impl ::treesitter_types::Spanned for TypeArguments<'_> {
7763 fn span(&self) -> ::treesitter_types::Span {
7764 self.span
7765 }
7766}
7767#[derive(Debug, Clone, PartialEq, Eq)]
7768pub struct TypeBound<'tree> {
7769 pub span: ::treesitter_types::Span,
7770 pub children: ::std::vec::Vec<Type<'tree>>,
7771}
7772impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBound<'tree> {
7773 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7774 fn from_node(
7775 node: ::treesitter_types::tree_sitter::Node<'tree>,
7776 src: &'tree [u8],
7777 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7778 debug_assert_eq!(node.kind(), "type_bound");
7779 Ok(Self {
7780 span: ::treesitter_types::Span::from(node),
7781 children: {
7782 #[allow(clippy::suspicious_else_formatting)]
7783 let non_field_children = {
7784 let mut cursor = node.walk();
7785 let mut result = ::std::vec::Vec::new();
7786 if cursor.goto_first_child() {
7787 loop {
7788 if cursor.field_name().is_none()
7789 && cursor.node().is_named()
7790 && !cursor.node().is_extra()
7791 {
7792 result.push(cursor.node());
7793 }
7794 if !cursor.goto_next_sibling() {
7795 break;
7796 }
7797 }
7798 }
7799 result
7800 };
7801 let mut items = ::std::vec::Vec::new();
7802 for child in non_field_children {
7803 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7804 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7805 })?);
7806 }
7807 items
7808 },
7809 })
7810 }
7811}
7812impl ::treesitter_types::Spanned for TypeBound<'_> {
7813 fn span(&self) -> ::treesitter_types::Span {
7814 self.span
7815 }
7816}
7817#[derive(Debug, Clone, PartialEq, Eq)]
7818pub struct TypeList<'tree> {
7819 pub span: ::treesitter_types::Span,
7820 pub children: ::std::vec::Vec<Type<'tree>>,
7821}
7822impl<'tree> ::treesitter_types::FromNode<'tree> for TypeList<'tree> {
7823 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7824 fn from_node(
7825 node: ::treesitter_types::tree_sitter::Node<'tree>,
7826 src: &'tree [u8],
7827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7828 debug_assert_eq!(node.kind(), "type_list");
7829 Ok(Self {
7830 span: ::treesitter_types::Span::from(node),
7831 children: {
7832 #[allow(clippy::suspicious_else_formatting)]
7833 let non_field_children = {
7834 let mut cursor = node.walk();
7835 let mut result = ::std::vec::Vec::new();
7836 if cursor.goto_first_child() {
7837 loop {
7838 if cursor.field_name().is_none()
7839 && cursor.node().is_named()
7840 && !cursor.node().is_extra()
7841 {
7842 result.push(cursor.node());
7843 }
7844 if !cursor.goto_next_sibling() {
7845 break;
7846 }
7847 }
7848 }
7849 result
7850 };
7851 let mut items = ::std::vec::Vec::new();
7852 for child in non_field_children {
7853 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7854 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7855 })?);
7856 }
7857 items
7858 },
7859 })
7860 }
7861}
7862impl ::treesitter_types::Spanned for TypeList<'_> {
7863 fn span(&self) -> ::treesitter_types::Span {
7864 self.span
7865 }
7866}
7867#[derive(Debug, Clone, PartialEq, Eq)]
7868pub struct TypeParameter<'tree> {
7869 pub span: ::treesitter_types::Span,
7870 pub children: ::std::vec::Vec<TypeParameterChildren<'tree>>,
7871}
7872impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
7873 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7874 fn from_node(
7875 node: ::treesitter_types::tree_sitter::Node<'tree>,
7876 src: &'tree [u8],
7877 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7878 debug_assert_eq!(node.kind(), "type_parameter");
7879 Ok(Self {
7880 span: ::treesitter_types::Span::from(node),
7881 children: {
7882 #[allow(clippy::suspicious_else_formatting)]
7883 let non_field_children = {
7884 let mut cursor = node.walk();
7885 let mut result = ::std::vec::Vec::new();
7886 if cursor.goto_first_child() {
7887 loop {
7888 if cursor.field_name().is_none()
7889 && cursor.node().is_named()
7890 && !cursor.node().is_extra()
7891 {
7892 result.push(cursor.node());
7893 }
7894 if !cursor.goto_next_sibling() {
7895 break;
7896 }
7897 }
7898 }
7899 result
7900 };
7901 let mut items = ::std::vec::Vec::new();
7902 for child in non_field_children {
7903 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7904 <TypeParameterChildren as ::treesitter_types::FromNode>::from_node(
7905 child, src,
7906 )
7907 })?);
7908 }
7909 items
7910 },
7911 })
7912 }
7913}
7914impl ::treesitter_types::Spanned for TypeParameter<'_> {
7915 fn span(&self) -> ::treesitter_types::Span {
7916 self.span
7917 }
7918}
7919#[derive(Debug, Clone, PartialEq, Eq)]
7920pub struct TypeParameters<'tree> {
7921 pub span: ::treesitter_types::Span,
7922 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
7923}
7924impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
7925 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7926 fn from_node(
7927 node: ::treesitter_types::tree_sitter::Node<'tree>,
7928 src: &'tree [u8],
7929 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7930 debug_assert_eq!(node.kind(), "type_parameters");
7931 Ok(Self {
7932 span: ::treesitter_types::Span::from(node),
7933 children: {
7934 #[allow(clippy::suspicious_else_formatting)]
7935 let non_field_children = {
7936 let mut cursor = node.walk();
7937 let mut result = ::std::vec::Vec::new();
7938 if cursor.goto_first_child() {
7939 loop {
7940 if cursor.field_name().is_none()
7941 && cursor.node().is_named()
7942 && !cursor.node().is_extra()
7943 {
7944 result.push(cursor.node());
7945 }
7946 if !cursor.goto_next_sibling() {
7947 break;
7948 }
7949 }
7950 }
7951 result
7952 };
7953 let mut items = ::std::vec::Vec::new();
7954 for child in non_field_children {
7955 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7956 <TypeParameter as ::treesitter_types::FromNode>::from_node(child, src)
7957 })?);
7958 }
7959 items
7960 },
7961 })
7962 }
7963}
7964impl ::treesitter_types::Spanned for TypeParameters<'_> {
7965 fn span(&self) -> ::treesitter_types::Span {
7966 self.span
7967 }
7968}
7969#[derive(Debug, Clone, PartialEq, Eq)]
7970pub struct TypePattern<'tree> {
7971 pub span: ::treesitter_types::Span,
7972 pub children: ::std::vec::Vec<TypePatternChildren<'tree>>,
7973}
7974impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
7975 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7976 fn from_node(
7977 node: ::treesitter_types::tree_sitter::Node<'tree>,
7978 src: &'tree [u8],
7979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7980 debug_assert_eq!(node.kind(), "type_pattern");
7981 Ok(Self {
7982 span: ::treesitter_types::Span::from(node),
7983 children: {
7984 #[allow(clippy::suspicious_else_formatting)]
7985 let non_field_children = {
7986 let mut cursor = node.walk();
7987 let mut result = ::std::vec::Vec::new();
7988 if cursor.goto_first_child() {
7989 loop {
7990 if cursor.field_name().is_none()
7991 && cursor.node().is_named()
7992 && !cursor.node().is_extra()
7993 {
7994 result.push(cursor.node());
7995 }
7996 if !cursor.goto_next_sibling() {
7997 break;
7998 }
7999 }
8000 }
8001 result
8002 };
8003 let mut items = ::std::vec::Vec::new();
8004 for child in non_field_children {
8005 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8006 <TypePatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
8007 })?);
8008 }
8009 items
8010 },
8011 })
8012 }
8013}
8014impl ::treesitter_types::Spanned for TypePattern<'_> {
8015 fn span(&self) -> ::treesitter_types::Span {
8016 self.span
8017 }
8018}
8019#[derive(Debug, Clone, PartialEq, Eq)]
8020pub struct UnaryExpression<'tree> {
8021 pub span: ::treesitter_types::Span,
8022 pub operand: Expression<'tree>,
8023 pub operator: UnaryExpressionOperator,
8024}
8025impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
8026 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8027 fn from_node(
8028 node: ::treesitter_types::tree_sitter::Node<'tree>,
8029 src: &'tree [u8],
8030 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8031 debug_assert_eq!(node.kind(), "unary_expression");
8032 Ok(Self {
8033 span: ::treesitter_types::Span::from(node),
8034 operand: {
8035 let child = node.child_by_field_name("operand").ok_or_else(|| {
8036 ::treesitter_types::ParseError::missing_field("operand", node)
8037 })?;
8038 ::treesitter_types::runtime::maybe_grow_stack(|| {
8039 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8040 })?
8041 },
8042 operator: {
8043 let child = node.child_by_field_name("operator").ok_or_else(|| {
8044 ::treesitter_types::ParseError::missing_field("operator", node)
8045 })?;
8046 ::treesitter_types::runtime::maybe_grow_stack(|| {
8047 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
8048 })?
8049 },
8050 })
8051 }
8052}
8053impl ::treesitter_types::Spanned for UnaryExpression<'_> {
8054 fn span(&self) -> ::treesitter_types::Span {
8055 self.span
8056 }
8057}
8058#[derive(Debug, Clone, PartialEq, Eq)]
8059pub struct UpdateExpression<'tree> {
8060 pub span: ::treesitter_types::Span,
8061 pub children: Expression<'tree>,
8062}
8063impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
8064 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8065 fn from_node(
8066 node: ::treesitter_types::tree_sitter::Node<'tree>,
8067 src: &'tree [u8],
8068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8069 debug_assert_eq!(node.kind(), "update_expression");
8070 Ok(Self {
8071 span: ::treesitter_types::Span::from(node),
8072 children: {
8073 #[allow(clippy::suspicious_else_formatting)]
8074 let non_field_children = {
8075 let mut cursor = node.walk();
8076 let mut result = ::std::vec::Vec::new();
8077 if cursor.goto_first_child() {
8078 loop {
8079 if cursor.field_name().is_none()
8080 && cursor.node().is_named()
8081 && !cursor.node().is_extra()
8082 {
8083 result.push(cursor.node());
8084 }
8085 if !cursor.goto_next_sibling() {
8086 break;
8087 }
8088 }
8089 }
8090 result
8091 };
8092 let child = if let Some(&c) = non_field_children.first() {
8093 c
8094 } else {
8095 let mut fallback_cursor = node.walk();
8096 let mut fallback_child = None;
8097 if fallback_cursor.goto_first_child() {
8098 loop {
8099 if fallback_cursor.field_name().is_none()
8100 && !fallback_cursor.node().is_extra()
8101 {
8102 let candidate = fallback_cursor.node();
8103 #[allow(clippy::needless_question_mark)]
8104 if (|| -> ::core::result::Result<
8105 _,
8106 ::treesitter_types::ParseError,
8107 > {
8108 let child = candidate;
8109 Ok(
8110 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8111 child,
8112 src,
8113 ))?,
8114 )
8115 })()
8116 .is_ok()
8117 {
8118 fallback_child = Some(candidate);
8119 break;
8120 }
8121 }
8122 if !fallback_cursor.goto_next_sibling() {
8123 break;
8124 }
8125 }
8126 }
8127 if fallback_child.is_none() {
8128 let mut cursor2 = node.walk();
8129 if cursor2.goto_first_child() {
8130 loop {
8131 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8132 let candidate = cursor2.node();
8133 #[allow(clippy::needless_question_mark)]
8134 if (|| -> ::core::result::Result<
8135 _,
8136 ::treesitter_types::ParseError,
8137 > {
8138 let child = candidate;
8139 Ok(
8140 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8141 child,
8142 src,
8143 ))?,
8144 )
8145 })()
8146 .is_ok()
8147 {
8148 fallback_child = Some(candidate);
8149 break;
8150 }
8151 }
8152 if !cursor2.goto_next_sibling() {
8153 break;
8154 }
8155 }
8156 }
8157 }
8158 fallback_child.ok_or_else(|| {
8159 ::treesitter_types::ParseError::missing_field("children", node)
8160 })?
8161 };
8162 ::treesitter_types::runtime::maybe_grow_stack(|| {
8163 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8164 })?
8165 },
8166 })
8167 }
8168}
8169impl ::treesitter_types::Spanned for UpdateExpression<'_> {
8170 fn span(&self) -> ::treesitter_types::Span {
8171 self.span
8172 }
8173}
8174#[derive(Debug, Clone, PartialEq, Eq)]
8175pub struct UsesModuleDirective<'tree> {
8176 pub span: ::treesitter_types::Span,
8177 pub r#type: UsesModuleDirectiveType<'tree>,
8178}
8179impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirective<'tree> {
8180 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8181 fn from_node(
8182 node: ::treesitter_types::tree_sitter::Node<'tree>,
8183 src: &'tree [u8],
8184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8185 debug_assert_eq!(node.kind(), "uses_module_directive");
8186 Ok(Self {
8187 span: ::treesitter_types::Span::from(node),
8188 r#type: {
8189 let child = node
8190 .child_by_field_name("type")
8191 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8192 ::treesitter_types::runtime::maybe_grow_stack(|| {
8193 <UsesModuleDirectiveType as ::treesitter_types::FromNode>::from_node(child, src)
8194 })?
8195 },
8196 })
8197 }
8198}
8199impl ::treesitter_types::Spanned for UsesModuleDirective<'_> {
8200 fn span(&self) -> ::treesitter_types::Span {
8201 self.span
8202 }
8203}
8204#[derive(Debug, Clone, PartialEq, Eq)]
8205pub struct VariableDeclarator<'tree> {
8206 pub span: ::treesitter_types::Span,
8207 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
8208 pub name: VariableDeclaratorName<'tree>,
8209 pub value: ::core::option::Option<VariableDeclaratorValue<'tree>>,
8210}
8211impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
8212 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8213 fn from_node(
8214 node: ::treesitter_types::tree_sitter::Node<'tree>,
8215 src: &'tree [u8],
8216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8217 debug_assert_eq!(node.kind(), "variable_declarator");
8218 Ok(Self {
8219 span: ::treesitter_types::Span::from(node),
8220 dimensions: match node.child_by_field_name("dimensions") {
8221 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8222 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)
8223 })?),
8224 None => None,
8225 },
8226 name: {
8227 let child = node
8228 .child_by_field_name("name")
8229 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8230 ::treesitter_types::runtime::maybe_grow_stack(|| {
8231 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)
8232 })?
8233 },
8234 value: match node.child_by_field_name("value") {
8235 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8236 <VariableDeclaratorValue as ::treesitter_types::FromNode>::from_node(child, src)
8237 })?),
8238 None => None,
8239 },
8240 })
8241 }
8242}
8243impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
8244 fn span(&self) -> ::treesitter_types::Span {
8245 self.span
8246 }
8247}
8248#[derive(Debug, Clone, PartialEq, Eq)]
8249pub struct WhileStatement<'tree> {
8250 pub span: ::treesitter_types::Span,
8251 pub body: Statement<'tree>,
8252 pub condition: ParenthesizedExpression<'tree>,
8253}
8254impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
8255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8256 fn from_node(
8257 node: ::treesitter_types::tree_sitter::Node<'tree>,
8258 src: &'tree [u8],
8259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8260 debug_assert_eq!(node.kind(), "while_statement");
8261 Ok(Self {
8262 span: ::treesitter_types::Span::from(node),
8263 body: {
8264 let child = node
8265 .child_by_field_name("body")
8266 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8267 ::treesitter_types::runtime::maybe_grow_stack(|| {
8268 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
8269 })?
8270 },
8271 condition: {
8272 let child = node.child_by_field_name("condition").ok_or_else(|| {
8273 ::treesitter_types::ParseError::missing_field("condition", node)
8274 })?;
8275 ::treesitter_types::runtime::maybe_grow_stack(|| {
8276 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
8277 })?
8278 },
8279 })
8280 }
8281}
8282impl ::treesitter_types::Spanned for WhileStatement<'_> {
8283 fn span(&self) -> ::treesitter_types::Span {
8284 self.span
8285 }
8286}
8287#[derive(Debug, Clone, PartialEq, Eq)]
8288pub struct Wildcard<'tree> {
8289 pub span: ::treesitter_types::Span,
8290 pub children: ::std::vec::Vec<WildcardChildren<'tree>>,
8291}
8292impl<'tree> ::treesitter_types::FromNode<'tree> for Wildcard<'tree> {
8293 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8294 fn from_node(
8295 node: ::treesitter_types::tree_sitter::Node<'tree>,
8296 src: &'tree [u8],
8297 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8298 debug_assert_eq!(node.kind(), "wildcard");
8299 Ok(Self {
8300 span: ::treesitter_types::Span::from(node),
8301 children: {
8302 #[allow(clippy::suspicious_else_formatting)]
8303 let non_field_children = {
8304 let mut cursor = node.walk();
8305 let mut result = ::std::vec::Vec::new();
8306 if cursor.goto_first_child() {
8307 loop {
8308 if cursor.field_name().is_none()
8309 && cursor.node().is_named()
8310 && !cursor.node().is_extra()
8311 {
8312 result.push(cursor.node());
8313 }
8314 if !cursor.goto_next_sibling() {
8315 break;
8316 }
8317 }
8318 }
8319 result
8320 };
8321 let mut items = ::std::vec::Vec::new();
8322 for child in non_field_children {
8323 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8324 <WildcardChildren as ::treesitter_types::FromNode>::from_node(child, src)
8325 })?);
8326 }
8327 items
8328 },
8329 })
8330 }
8331}
8332impl ::treesitter_types::Spanned for Wildcard<'_> {
8333 fn span(&self) -> ::treesitter_types::Span {
8334 self.span
8335 }
8336}
8337#[derive(Debug, Clone, PartialEq, Eq)]
8338pub struct YieldStatement<'tree> {
8339 pub span: ::treesitter_types::Span,
8340 pub children: Expression<'tree>,
8341}
8342impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
8343 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8344 fn from_node(
8345 node: ::treesitter_types::tree_sitter::Node<'tree>,
8346 src: &'tree [u8],
8347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8348 debug_assert_eq!(node.kind(), "yield_statement");
8349 Ok(Self {
8350 span: ::treesitter_types::Span::from(node),
8351 children: {
8352 #[allow(clippy::suspicious_else_formatting)]
8353 let non_field_children = {
8354 let mut cursor = node.walk();
8355 let mut result = ::std::vec::Vec::new();
8356 if cursor.goto_first_child() {
8357 loop {
8358 if cursor.field_name().is_none()
8359 && cursor.node().is_named()
8360 && !cursor.node().is_extra()
8361 {
8362 result.push(cursor.node());
8363 }
8364 if !cursor.goto_next_sibling() {
8365 break;
8366 }
8367 }
8368 }
8369 result
8370 };
8371 let child = if let Some(&c) = non_field_children.first() {
8372 c
8373 } else {
8374 let mut fallback_cursor = node.walk();
8375 let mut fallback_child = None;
8376 if fallback_cursor.goto_first_child() {
8377 loop {
8378 if fallback_cursor.field_name().is_none()
8379 && !fallback_cursor.node().is_extra()
8380 {
8381 let candidate = fallback_cursor.node();
8382 #[allow(clippy::needless_question_mark)]
8383 if (|| -> ::core::result::Result<
8384 _,
8385 ::treesitter_types::ParseError,
8386 > {
8387 let child = candidate;
8388 Ok(
8389 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8390 child,
8391 src,
8392 ))?,
8393 )
8394 })()
8395 .is_ok()
8396 {
8397 fallback_child = Some(candidate);
8398 break;
8399 }
8400 }
8401 if !fallback_cursor.goto_next_sibling() {
8402 break;
8403 }
8404 }
8405 }
8406 if fallback_child.is_none() {
8407 let mut cursor2 = node.walk();
8408 if cursor2.goto_first_child() {
8409 loop {
8410 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8411 let candidate = cursor2.node();
8412 #[allow(clippy::needless_question_mark)]
8413 if (|| -> ::core::result::Result<
8414 _,
8415 ::treesitter_types::ParseError,
8416 > {
8417 let child = candidate;
8418 Ok(
8419 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8420 child,
8421 src,
8422 ))?,
8423 )
8424 })()
8425 .is_ok()
8426 {
8427 fallback_child = Some(candidate);
8428 break;
8429 }
8430 }
8431 if !cursor2.goto_next_sibling() {
8432 break;
8433 }
8434 }
8435 }
8436 }
8437 fallback_child.ok_or_else(|| {
8438 ::treesitter_types::ParseError::missing_field("children", node)
8439 })?
8440 };
8441 ::treesitter_types::runtime::maybe_grow_stack(|| {
8442 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8443 })?
8444 },
8445 })
8446 }
8447}
8448impl ::treesitter_types::Spanned for YieldStatement<'_> {
8449 fn span(&self) -> ::treesitter_types::Span {
8450 self.span
8451 }
8452}
8453#[derive(Debug, Clone, PartialEq, Eq)]
8454pub struct BinaryIntegerLiteral<'tree> {
8455 pub span: ::treesitter_types::Span,
8456 text: &'tree str,
8457}
8458impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryIntegerLiteral<'tree> {
8459 fn from_node(
8460 node: ::treesitter_types::tree_sitter::Node<'tree>,
8461 src: &'tree [u8],
8462 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8463 debug_assert_eq!(node.kind(), "binary_integer_literal");
8464 Ok(Self {
8465 span: ::treesitter_types::Span::from(node),
8466 text: node.utf8_text(src)?,
8467 })
8468 }
8469}
8470impl<'tree> ::treesitter_types::LeafNode<'tree> for BinaryIntegerLiteral<'tree> {
8471 fn text(&self) -> &'tree str {
8472 self.text
8473 }
8474}
8475impl ::treesitter_types::Spanned for BinaryIntegerLiteral<'_> {
8476 fn span(&self) -> ::treesitter_types::Span {
8477 self.span
8478 }
8479}
8480#[derive(Debug, Clone, PartialEq, Eq)]
8481pub struct BlockComment<'tree> {
8482 pub span: ::treesitter_types::Span,
8483 text: &'tree str,
8484}
8485impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
8486 fn from_node(
8487 node: ::treesitter_types::tree_sitter::Node<'tree>,
8488 src: &'tree [u8],
8489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8490 debug_assert_eq!(node.kind(), "block_comment");
8491 Ok(Self {
8492 span: ::treesitter_types::Span::from(node),
8493 text: node.utf8_text(src)?,
8494 })
8495 }
8496}
8497impl<'tree> ::treesitter_types::LeafNode<'tree> for BlockComment<'tree> {
8498 fn text(&self) -> &'tree str {
8499 self.text
8500 }
8501}
8502impl ::treesitter_types::Spanned for BlockComment<'_> {
8503 fn span(&self) -> ::treesitter_types::Span {
8504 self.span
8505 }
8506}
8507#[derive(Debug, Clone, PartialEq, Eq)]
8508pub struct BooleanType<'tree> {
8509 pub span: ::treesitter_types::Span,
8510 text: &'tree str,
8511}
8512impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanType<'tree> {
8513 fn from_node(
8514 node: ::treesitter_types::tree_sitter::Node<'tree>,
8515 src: &'tree [u8],
8516 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8517 debug_assert_eq!(node.kind(), "boolean_type");
8518 Ok(Self {
8519 span: ::treesitter_types::Span::from(node),
8520 text: node.utf8_text(src)?,
8521 })
8522 }
8523}
8524impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanType<'tree> {
8525 fn text(&self) -> &'tree str {
8526 self.text
8527 }
8528}
8529impl ::treesitter_types::Spanned for BooleanType<'_> {
8530 fn span(&self) -> ::treesitter_types::Span {
8531 self.span
8532 }
8533}
8534#[derive(Debug, Clone, PartialEq, Eq)]
8535pub struct CharacterLiteral<'tree> {
8536 pub span: ::treesitter_types::Span,
8537 text: &'tree str,
8538}
8539impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
8540 fn from_node(
8541 node: ::treesitter_types::tree_sitter::Node<'tree>,
8542 src: &'tree [u8],
8543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8544 debug_assert_eq!(node.kind(), "character_literal");
8545 Ok(Self {
8546 span: ::treesitter_types::Span::from(node),
8547 text: node.utf8_text(src)?,
8548 })
8549 }
8550}
8551impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteral<'tree> {
8552 fn text(&self) -> &'tree str {
8553 self.text
8554 }
8555}
8556impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
8557 fn span(&self) -> ::treesitter_types::Span {
8558 self.span
8559 }
8560}
8561#[derive(Debug, Clone, PartialEq, Eq)]
8562pub struct DecimalFloatingPointLiteral<'tree> {
8563 pub span: ::treesitter_types::Span,
8564 text: &'tree str,
8565}
8566impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalFloatingPointLiteral<'tree> {
8567 fn from_node(
8568 node: ::treesitter_types::tree_sitter::Node<'tree>,
8569 src: &'tree [u8],
8570 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8571 debug_assert_eq!(node.kind(), "decimal_floating_point_literal");
8572 Ok(Self {
8573 span: ::treesitter_types::Span::from(node),
8574 text: node.utf8_text(src)?,
8575 })
8576 }
8577}
8578impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalFloatingPointLiteral<'tree> {
8579 fn text(&self) -> &'tree str {
8580 self.text
8581 }
8582}
8583impl ::treesitter_types::Spanned for DecimalFloatingPointLiteral<'_> {
8584 fn span(&self) -> ::treesitter_types::Span {
8585 self.span
8586 }
8587}
8588#[derive(Debug, Clone, PartialEq, Eq)]
8589pub struct DecimalIntegerLiteral<'tree> {
8590 pub span: ::treesitter_types::Span,
8591 text: &'tree str,
8592}
8593impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalIntegerLiteral<'tree> {
8594 fn from_node(
8595 node: ::treesitter_types::tree_sitter::Node<'tree>,
8596 src: &'tree [u8],
8597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8598 debug_assert_eq!(node.kind(), "decimal_integer_literal");
8599 Ok(Self {
8600 span: ::treesitter_types::Span::from(node),
8601 text: node.utf8_text(src)?,
8602 })
8603 }
8604}
8605impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalIntegerLiteral<'tree> {
8606 fn text(&self) -> &'tree str {
8607 self.text
8608 }
8609}
8610impl ::treesitter_types::Spanned for DecimalIntegerLiteral<'_> {
8611 fn span(&self) -> ::treesitter_types::Span {
8612 self.span
8613 }
8614}
8615#[derive(Debug, Clone, PartialEq, Eq)]
8616pub struct EscapeSequence<'tree> {
8617 pub span: ::treesitter_types::Span,
8618 text: &'tree str,
8619}
8620impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
8621 fn from_node(
8622 node: ::treesitter_types::tree_sitter::Node<'tree>,
8623 src: &'tree [u8],
8624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8625 debug_assert_eq!(node.kind(), "escape_sequence");
8626 Ok(Self {
8627 span: ::treesitter_types::Span::from(node),
8628 text: node.utf8_text(src)?,
8629 })
8630 }
8631}
8632impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
8633 fn text(&self) -> &'tree str {
8634 self.text
8635 }
8636}
8637impl ::treesitter_types::Spanned for EscapeSequence<'_> {
8638 fn span(&self) -> ::treesitter_types::Span {
8639 self.span
8640 }
8641}
8642#[derive(Debug, Clone, PartialEq, Eq)]
8643pub struct False<'tree> {
8644 pub span: ::treesitter_types::Span,
8645 text: &'tree str,
8646}
8647impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
8648 fn from_node(
8649 node: ::treesitter_types::tree_sitter::Node<'tree>,
8650 src: &'tree [u8],
8651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8652 debug_assert_eq!(node.kind(), "false");
8653 Ok(Self {
8654 span: ::treesitter_types::Span::from(node),
8655 text: node.utf8_text(src)?,
8656 })
8657 }
8658}
8659impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
8660 fn text(&self) -> &'tree str {
8661 self.text
8662 }
8663}
8664impl ::treesitter_types::Spanned for False<'_> {
8665 fn span(&self) -> ::treesitter_types::Span {
8666 self.span
8667 }
8668}
8669#[derive(Debug, Clone, PartialEq, Eq)]
8670pub struct HexFloatingPointLiteral<'tree> {
8671 pub span: ::treesitter_types::Span,
8672 text: &'tree str,
8673}
8674impl<'tree> ::treesitter_types::FromNode<'tree> for HexFloatingPointLiteral<'tree> {
8675 fn from_node(
8676 node: ::treesitter_types::tree_sitter::Node<'tree>,
8677 src: &'tree [u8],
8678 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8679 debug_assert_eq!(node.kind(), "hex_floating_point_literal");
8680 Ok(Self {
8681 span: ::treesitter_types::Span::from(node),
8682 text: node.utf8_text(src)?,
8683 })
8684 }
8685}
8686impl<'tree> ::treesitter_types::LeafNode<'tree> for HexFloatingPointLiteral<'tree> {
8687 fn text(&self) -> &'tree str {
8688 self.text
8689 }
8690}
8691impl ::treesitter_types::Spanned for HexFloatingPointLiteral<'_> {
8692 fn span(&self) -> ::treesitter_types::Span {
8693 self.span
8694 }
8695}
8696#[derive(Debug, Clone, PartialEq, Eq)]
8697pub struct HexIntegerLiteral<'tree> {
8698 pub span: ::treesitter_types::Span,
8699 text: &'tree str,
8700}
8701impl<'tree> ::treesitter_types::FromNode<'tree> for HexIntegerLiteral<'tree> {
8702 fn from_node(
8703 node: ::treesitter_types::tree_sitter::Node<'tree>,
8704 src: &'tree [u8],
8705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8706 debug_assert_eq!(node.kind(), "hex_integer_literal");
8707 Ok(Self {
8708 span: ::treesitter_types::Span::from(node),
8709 text: node.utf8_text(src)?,
8710 })
8711 }
8712}
8713impl<'tree> ::treesitter_types::LeafNode<'tree> for HexIntegerLiteral<'tree> {
8714 fn text(&self) -> &'tree str {
8715 self.text
8716 }
8717}
8718impl ::treesitter_types::Spanned for HexIntegerLiteral<'_> {
8719 fn span(&self) -> ::treesitter_types::Span {
8720 self.span
8721 }
8722}
8723#[derive(Debug, Clone, PartialEq, Eq)]
8724pub struct Identifier<'tree> {
8725 pub span: ::treesitter_types::Span,
8726 text: &'tree str,
8727}
8728impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
8729 fn from_node(
8730 node: ::treesitter_types::tree_sitter::Node<'tree>,
8731 src: &'tree [u8],
8732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8733 debug_assert_eq!(node.kind(), "identifier");
8734 Ok(Self {
8735 span: ::treesitter_types::Span::from(node),
8736 text: node.utf8_text(src)?,
8737 })
8738 }
8739}
8740impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
8741 fn text(&self) -> &'tree str {
8742 self.text
8743 }
8744}
8745impl ::treesitter_types::Spanned for Identifier<'_> {
8746 fn span(&self) -> ::treesitter_types::Span {
8747 self.span
8748 }
8749}
8750#[derive(Debug, Clone, PartialEq, Eq)]
8751pub struct LineComment<'tree> {
8752 pub span: ::treesitter_types::Span,
8753 text: &'tree str,
8754}
8755impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
8756 fn from_node(
8757 node: ::treesitter_types::tree_sitter::Node<'tree>,
8758 src: &'tree [u8],
8759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8760 debug_assert_eq!(node.kind(), "line_comment");
8761 Ok(Self {
8762 span: ::treesitter_types::Span::from(node),
8763 text: node.utf8_text(src)?,
8764 })
8765 }
8766}
8767impl<'tree> ::treesitter_types::LeafNode<'tree> for LineComment<'tree> {
8768 fn text(&self) -> &'tree str {
8769 self.text
8770 }
8771}
8772impl ::treesitter_types::Spanned for LineComment<'_> {
8773 fn span(&self) -> ::treesitter_types::Span {
8774 self.span
8775 }
8776}
8777#[derive(Debug, Clone, PartialEq, Eq)]
8778pub struct NullLiteral<'tree> {
8779 pub span: ::treesitter_types::Span,
8780 text: &'tree str,
8781}
8782impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
8783 fn from_node(
8784 node: ::treesitter_types::tree_sitter::Node<'tree>,
8785 src: &'tree [u8],
8786 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8787 debug_assert_eq!(node.kind(), "null_literal");
8788 Ok(Self {
8789 span: ::treesitter_types::Span::from(node),
8790 text: node.utf8_text(src)?,
8791 })
8792 }
8793}
8794impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
8795 fn text(&self) -> &'tree str {
8796 self.text
8797 }
8798}
8799impl ::treesitter_types::Spanned for NullLiteral<'_> {
8800 fn span(&self) -> ::treesitter_types::Span {
8801 self.span
8802 }
8803}
8804#[derive(Debug, Clone, PartialEq, Eq)]
8805pub struct OctalIntegerLiteral<'tree> {
8806 pub span: ::treesitter_types::Span,
8807 text: &'tree str,
8808}
8809impl<'tree> ::treesitter_types::FromNode<'tree> for OctalIntegerLiteral<'tree> {
8810 fn from_node(
8811 node: ::treesitter_types::tree_sitter::Node<'tree>,
8812 src: &'tree [u8],
8813 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8814 debug_assert_eq!(node.kind(), "octal_integer_literal");
8815 Ok(Self {
8816 span: ::treesitter_types::Span::from(node),
8817 text: node.utf8_text(src)?,
8818 })
8819 }
8820}
8821impl<'tree> ::treesitter_types::LeafNode<'tree> for OctalIntegerLiteral<'tree> {
8822 fn text(&self) -> &'tree str {
8823 self.text
8824 }
8825}
8826impl ::treesitter_types::Spanned for OctalIntegerLiteral<'_> {
8827 fn span(&self) -> ::treesitter_types::Span {
8828 self.span
8829 }
8830}
8831#[derive(Debug, Clone, PartialEq, Eq)]
8832pub struct StringFragment<'tree> {
8833 pub span: ::treesitter_types::Span,
8834 text: &'tree str,
8835}
8836impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
8837 fn from_node(
8838 node: ::treesitter_types::tree_sitter::Node<'tree>,
8839 src: &'tree [u8],
8840 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8841 debug_assert_eq!(node.kind(), "string_fragment");
8842 Ok(Self {
8843 span: ::treesitter_types::Span::from(node),
8844 text: node.utf8_text(src)?,
8845 })
8846 }
8847}
8848impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
8849 fn text(&self) -> &'tree str {
8850 self.text
8851 }
8852}
8853impl ::treesitter_types::Spanned for StringFragment<'_> {
8854 fn span(&self) -> ::treesitter_types::Span {
8855 self.span
8856 }
8857}
8858#[derive(Debug, Clone, PartialEq, Eq)]
8859pub struct Super<'tree> {
8860 pub span: ::treesitter_types::Span,
8861 text: &'tree str,
8862}
8863impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
8864 fn from_node(
8865 node: ::treesitter_types::tree_sitter::Node<'tree>,
8866 src: &'tree [u8],
8867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8868 debug_assert_eq!(node.kind(), "super");
8869 Ok(Self {
8870 span: ::treesitter_types::Span::from(node),
8871 text: node.utf8_text(src)?,
8872 })
8873 }
8874}
8875impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
8876 fn text(&self) -> &'tree str {
8877 self.text
8878 }
8879}
8880impl ::treesitter_types::Spanned for Super<'_> {
8881 fn span(&self) -> ::treesitter_types::Span {
8882 self.span
8883 }
8884}
8885#[derive(Debug, Clone, PartialEq, Eq)]
8886pub struct This<'tree> {
8887 pub span: ::treesitter_types::Span,
8888 text: &'tree str,
8889}
8890impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
8891 fn from_node(
8892 node: ::treesitter_types::tree_sitter::Node<'tree>,
8893 src: &'tree [u8],
8894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8895 debug_assert_eq!(node.kind(), "this");
8896 Ok(Self {
8897 span: ::treesitter_types::Span::from(node),
8898 text: node.utf8_text(src)?,
8899 })
8900 }
8901}
8902impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
8903 fn text(&self) -> &'tree str {
8904 self.text
8905 }
8906}
8907impl ::treesitter_types::Spanned for This<'_> {
8908 fn span(&self) -> ::treesitter_types::Span {
8909 self.span
8910 }
8911}
8912#[derive(Debug, Clone, PartialEq, Eq)]
8913pub struct True<'tree> {
8914 pub span: ::treesitter_types::Span,
8915 text: &'tree str,
8916}
8917impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
8918 fn from_node(
8919 node: ::treesitter_types::tree_sitter::Node<'tree>,
8920 src: &'tree [u8],
8921 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8922 debug_assert_eq!(node.kind(), "true");
8923 Ok(Self {
8924 span: ::treesitter_types::Span::from(node),
8925 text: node.utf8_text(src)?,
8926 })
8927 }
8928}
8929impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
8930 fn text(&self) -> &'tree str {
8931 self.text
8932 }
8933}
8934impl ::treesitter_types::Spanned for True<'_> {
8935 fn span(&self) -> ::treesitter_types::Span {
8936 self.span
8937 }
8938}
8939#[derive(Debug, Clone, PartialEq, Eq)]
8940pub struct TypeIdentifier<'tree> {
8941 pub span: ::treesitter_types::Span,
8942 text: &'tree str,
8943}
8944impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
8945 fn from_node(
8946 node: ::treesitter_types::tree_sitter::Node<'tree>,
8947 src: &'tree [u8],
8948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8949 debug_assert_eq!(node.kind(), "type_identifier");
8950 Ok(Self {
8951 span: ::treesitter_types::Span::from(node),
8952 text: node.utf8_text(src)?,
8953 })
8954 }
8955}
8956impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
8957 fn text(&self) -> &'tree str {
8958 self.text
8959 }
8960}
8961impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
8962 fn span(&self) -> ::treesitter_types::Span {
8963 self.span
8964 }
8965}
8966#[derive(Debug, Clone, PartialEq, Eq)]
8967pub struct UnderscorePattern<'tree> {
8968 pub span: ::treesitter_types::Span,
8969 text: &'tree str,
8970}
8971impl<'tree> ::treesitter_types::FromNode<'tree> for UnderscorePattern<'tree> {
8972 fn from_node(
8973 node: ::treesitter_types::tree_sitter::Node<'tree>,
8974 src: &'tree [u8],
8975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8976 debug_assert_eq!(node.kind(), "underscore_pattern");
8977 Ok(Self {
8978 span: ::treesitter_types::Span::from(node),
8979 text: node.utf8_text(src)?,
8980 })
8981 }
8982}
8983impl<'tree> ::treesitter_types::LeafNode<'tree> for UnderscorePattern<'tree> {
8984 fn text(&self) -> &'tree str {
8985 self.text
8986 }
8987}
8988impl ::treesitter_types::Spanned for UnderscorePattern<'_> {
8989 fn span(&self) -> ::treesitter_types::Span {
8990 self.span
8991 }
8992}
8993#[derive(Debug, Clone, PartialEq, Eq)]
8994pub struct VoidType<'tree> {
8995 pub span: ::treesitter_types::Span,
8996 text: &'tree str,
8997}
8998impl<'tree> ::treesitter_types::FromNode<'tree> for VoidType<'tree> {
8999 fn from_node(
9000 node: ::treesitter_types::tree_sitter::Node<'tree>,
9001 src: &'tree [u8],
9002 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9003 debug_assert_eq!(node.kind(), "void_type");
9004 Ok(Self {
9005 span: ::treesitter_types::Span::from(node),
9006 text: node.utf8_text(src)?,
9007 })
9008 }
9009}
9010impl<'tree> ::treesitter_types::LeafNode<'tree> for VoidType<'tree> {
9011 fn text(&self) -> &'tree str {
9012 self.text
9013 }
9014}
9015impl ::treesitter_types::Spanned for VoidType<'_> {
9016 fn span(&self) -> ::treesitter_types::Span {
9017 self.span
9018 }
9019}
9020#[derive(Debug, Clone, PartialEq, Eq)]
9021pub enum AnnotatedTypeChildren<'tree> {
9022 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
9023 Annotation(::std::boxed::Box<Annotation<'tree>>),
9024 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9025}
9026impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotatedTypeChildren<'tree> {
9027 #[allow(clippy::collapsible_else_if)]
9028 fn from_node(
9029 node: ::treesitter_types::tree_sitter::Node<'tree>,
9030 src: &'tree [u8],
9031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9032 match node.kind() {
9033 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9034 ::treesitter_types::runtime::maybe_grow_stack(|| {
9035 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9036 })?,
9037 ))),
9038 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9039 ::treesitter_types::runtime::maybe_grow_stack(|| {
9040 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9041 })?,
9042 ))),
9043 _other => {
9044 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9045 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
9046 }) {
9047 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
9048 } else {
9049 Err(::treesitter_types::ParseError::unexpected_kind(
9050 _other, node,
9051 ))
9052 }
9053 }
9054 }
9055 }
9056}
9057impl ::treesitter_types::Spanned for AnnotatedTypeChildren<'_> {
9058 fn span(&self) -> ::treesitter_types::Span {
9059 match self {
9060 Self::UnannotatedType(inner) => inner.span(),
9061 Self::Annotation(inner) => inner.span(),
9062 Self::MarkerAnnotation(inner) => inner.span(),
9063 }
9064 }
9065}
9066#[derive(Debug, Clone, PartialEq, Eq)]
9067pub enum AnnotationName<'tree> {
9068 Identifier(::std::boxed::Box<Identifier<'tree>>),
9069 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9070}
9071impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationName<'tree> {
9072 #[allow(clippy::collapsible_else_if)]
9073 fn from_node(
9074 node: ::treesitter_types::tree_sitter::Node<'tree>,
9075 src: &'tree [u8],
9076 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9077 match node.kind() {
9078 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9079 ::treesitter_types::runtime::maybe_grow_stack(|| {
9080 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9081 })?,
9082 ))),
9083 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9084 ::treesitter_types::runtime::maybe_grow_stack(|| {
9085 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9086 })?,
9087 ))),
9088 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9089 }
9090 }
9091}
9092impl ::treesitter_types::Spanned for AnnotationName<'_> {
9093 fn span(&self) -> ::treesitter_types::Span {
9094 match self {
9095 Self::Identifier(inner) => inner.span(),
9096 Self::ScopedIdentifier(inner) => inner.span(),
9097 }
9098 }
9099}
9100#[derive(Debug, Clone, PartialEq, Eq)]
9101pub enum AnnotationArgumentListChildren<'tree> {
9102 Annotation(::std::boxed::Box<Annotation<'tree>>),
9103 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9104 ElementValuePair(::std::boxed::Box<ElementValuePair<'tree>>),
9105 Expression(::std::boxed::Box<Expression<'tree>>),
9106 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9107}
9108impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationArgumentListChildren<'tree> {
9109 #[allow(clippy::collapsible_else_if)]
9110 fn from_node(
9111 node: ::treesitter_types::tree_sitter::Node<'tree>,
9112 src: &'tree [u8],
9113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9114 match node.kind() {
9115 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9116 ::treesitter_types::runtime::maybe_grow_stack(|| {
9117 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9118 })?,
9119 ))),
9120 "element_value_array_initializer" => Ok(Self::ElementValueArrayInitializer(
9121 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9122 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9123 node, src,
9124 )
9125 })?),
9126 )),
9127 "element_value_pair" => Ok(Self::ElementValuePair(::std::boxed::Box::new(
9128 ::treesitter_types::runtime::maybe_grow_stack(|| {
9129 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)
9130 })?,
9131 ))),
9132 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9133 ::treesitter_types::runtime::maybe_grow_stack(|| {
9134 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9135 })?,
9136 ))),
9137 _other => {
9138 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9139 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9140 }) {
9141 Ok(Self::Expression(::std::boxed::Box::new(v)))
9142 } else {
9143 Err(::treesitter_types::ParseError::unexpected_kind(
9144 _other, node,
9145 ))
9146 }
9147 }
9148 }
9149 }
9150}
9151impl ::treesitter_types::Spanned for AnnotationArgumentListChildren<'_> {
9152 fn span(&self) -> ::treesitter_types::Span {
9153 match self {
9154 Self::Annotation(inner) => inner.span(),
9155 Self::ElementValueArrayInitializer(inner) => inner.span(),
9156 Self::ElementValuePair(inner) => inner.span(),
9157 Self::Expression(inner) => inner.span(),
9158 Self::MarkerAnnotation(inner) => inner.span(),
9159 }
9160 }
9161}
9162#[derive(Debug, Clone, PartialEq, Eq)]
9163pub enum AnnotationTypeBodyChildren<'tree> {
9164 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
9165 AnnotationTypeElementDeclaration(::std::boxed::Box<AnnotationTypeElementDeclaration<'tree>>),
9166 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
9167 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
9168 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9169 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
9170}
9171impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeBodyChildren<'tree> {
9172 #[allow(clippy::collapsible_else_if)]
9173 fn from_node(
9174 node: ::treesitter_types::tree_sitter::Node<'tree>,
9175 src: &'tree [u8],
9176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9177 match node.kind() {
9178 "annotation_type_declaration" => Ok(Self::AnnotationTypeDeclaration(
9179 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9180 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
9181 node, src,
9182 )
9183 })?),
9184 )),
9185 "annotation_type_element_declaration" => Ok(Self::AnnotationTypeElementDeclaration(
9186 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9187 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
9188 node, src,
9189 )
9190 })?),
9191 )),
9192 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
9193 ::treesitter_types::runtime::maybe_grow_stack(|| {
9194 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9195 })?,
9196 ))),
9197 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
9198 ::treesitter_types::runtime::maybe_grow_stack(|| {
9199 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9200 })?,
9201 ))),
9202 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
9203 ::treesitter_types::runtime::maybe_grow_stack(|| {
9204 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9205 })?,
9206 ))),
9207 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
9208 ::treesitter_types::runtime::maybe_grow_stack(|| {
9209 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9210 })?,
9211 ))),
9212 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9213 }
9214 }
9215}
9216impl ::treesitter_types::Spanned for AnnotationTypeBodyChildren<'_> {
9217 fn span(&self) -> ::treesitter_types::Span {
9218 match self {
9219 Self::AnnotationTypeDeclaration(inner) => inner.span(),
9220 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
9221 Self::ClassDeclaration(inner) => inner.span(),
9222 Self::ConstantDeclaration(inner) => inner.span(),
9223 Self::EnumDeclaration(inner) => inner.span(),
9224 Self::InterfaceDeclaration(inner) => inner.span(),
9225 }
9226 }
9227}
9228#[derive(Debug, Clone, PartialEq, Eq)]
9229pub enum AnnotationTypeElementDeclarationValue<'tree> {
9230 Annotation(::std::boxed::Box<Annotation<'tree>>),
9231 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9232 Expression(::std::boxed::Box<Expression<'tree>>),
9233 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9234}
9235impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeElementDeclarationValue<'tree> {
9236 #[allow(clippy::collapsible_else_if)]
9237 fn from_node(
9238 node: ::treesitter_types::tree_sitter::Node<'tree>,
9239 src: &'tree [u8],
9240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9241 match node.kind() {
9242 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9243 ::treesitter_types::runtime::maybe_grow_stack(|| {
9244 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9245 })?,
9246 ))),
9247 "element_value_array_initializer" => Ok(Self::ElementValueArrayInitializer(
9248 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9249 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9250 node, src,
9251 )
9252 })?),
9253 )),
9254 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9255 ::treesitter_types::runtime::maybe_grow_stack(|| {
9256 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9257 })?,
9258 ))),
9259 _other => {
9260 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9261 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9262 }) {
9263 Ok(Self::Expression(::std::boxed::Box::new(v)))
9264 } else {
9265 Err(::treesitter_types::ParseError::unexpected_kind(
9266 _other, node,
9267 ))
9268 }
9269 }
9270 }
9271 }
9272}
9273impl ::treesitter_types::Spanned for AnnotationTypeElementDeclarationValue<'_> {
9274 fn span(&self) -> ::treesitter_types::Span {
9275 match self {
9276 Self::Annotation(inner) => inner.span(),
9277 Self::ElementValueArrayInitializer(inner) => inner.span(),
9278 Self::Expression(inner) => inner.span(),
9279 Self::MarkerAnnotation(inner) => inner.span(),
9280 }
9281 }
9282}
9283#[derive(Debug, Clone, PartialEq, Eq)]
9284pub enum ArrayCreationExpressionDimensions<'tree> {
9285 Dimensions(::std::boxed::Box<Dimensions<'tree>>),
9286 DimensionsExpr(::std::boxed::Box<DimensionsExpr<'tree>>),
9287}
9288impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionDimensions<'tree> {
9289 #[allow(clippy::collapsible_else_if)]
9290 fn from_node(
9291 node: ::treesitter_types::tree_sitter::Node<'tree>,
9292 src: &'tree [u8],
9293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9294 match node.kind() {
9295 "dimensions" => Ok(Self::Dimensions(::std::boxed::Box::new(
9296 ::treesitter_types::runtime::maybe_grow_stack(|| {
9297 <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)
9298 })?,
9299 ))),
9300 "dimensions_expr" => Ok(Self::DimensionsExpr(::std::boxed::Box::new(
9301 ::treesitter_types::runtime::maybe_grow_stack(|| {
9302 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)
9303 })?,
9304 ))),
9305 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9306 }
9307 }
9308}
9309impl ::treesitter_types::Spanned for ArrayCreationExpressionDimensions<'_> {
9310 fn span(&self) -> ::treesitter_types::Span {
9311 match self {
9312 Self::Dimensions(inner) => inner.span(),
9313 Self::DimensionsExpr(inner) => inner.span(),
9314 }
9315 }
9316}
9317#[derive(Debug, Clone, PartialEq, Eq)]
9318pub enum ArrayCreationExpressionChildren<'tree> {
9319 Annotation(::std::boxed::Box<Annotation<'tree>>),
9320 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9321}
9322impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionChildren<'tree> {
9323 #[allow(clippy::collapsible_else_if)]
9324 fn from_node(
9325 node: ::treesitter_types::tree_sitter::Node<'tree>,
9326 src: &'tree [u8],
9327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9328 match node.kind() {
9329 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9330 ::treesitter_types::runtime::maybe_grow_stack(|| {
9331 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9332 })?,
9333 ))),
9334 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9335 ::treesitter_types::runtime::maybe_grow_stack(|| {
9336 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9337 })?,
9338 ))),
9339 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9340 }
9341 }
9342}
9343impl ::treesitter_types::Spanned for ArrayCreationExpressionChildren<'_> {
9344 fn span(&self) -> ::treesitter_types::Span {
9345 match self {
9346 Self::Annotation(inner) => inner.span(),
9347 Self::MarkerAnnotation(inner) => inner.span(),
9348 }
9349 }
9350}
9351#[derive(Debug, Clone, PartialEq, Eq)]
9352pub enum ArrayInitializerChildren<'tree> {
9353 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
9354 Expression(::std::boxed::Box<Expression<'tree>>),
9355}
9356impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayInitializerChildren<'tree> {
9357 #[allow(clippy::collapsible_else_if)]
9358 fn from_node(
9359 node: ::treesitter_types::tree_sitter::Node<'tree>,
9360 src: &'tree [u8],
9361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9362 match node.kind() {
9363 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
9364 ::treesitter_types::runtime::maybe_grow_stack(|| {
9365 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
9366 })?,
9367 ))),
9368 _other => {
9369 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9370 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9371 }) {
9372 Ok(Self::Expression(::std::boxed::Box::new(v)))
9373 } else {
9374 Err(::treesitter_types::ParseError::unexpected_kind(
9375 _other, node,
9376 ))
9377 }
9378 }
9379 }
9380 }
9381}
9382impl ::treesitter_types::Spanned for ArrayInitializerChildren<'_> {
9383 fn span(&self) -> ::treesitter_types::Span {
9384 match self {
9385 Self::ArrayInitializer(inner) => inner.span(),
9386 Self::Expression(inner) => inner.span(),
9387 }
9388 }
9389}
9390#[derive(Debug, Clone, PartialEq, Eq)]
9391pub enum AssignmentExpressionLeft<'tree> {
9392 ArrayAccess(::std::boxed::Box<ArrayAccess<'tree>>),
9393 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
9394 Identifier(::std::boxed::Box<Identifier<'tree>>),
9395}
9396impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
9397 #[allow(clippy::collapsible_else_if)]
9398 fn from_node(
9399 node: ::treesitter_types::tree_sitter::Node<'tree>,
9400 src: &'tree [u8],
9401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9402 match node.kind() {
9403 "array_access" => Ok(Self::ArrayAccess(::std::boxed::Box::new(
9404 ::treesitter_types::runtime::maybe_grow_stack(|| {
9405 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)
9406 })?,
9407 ))),
9408 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
9409 ::treesitter_types::runtime::maybe_grow_stack(|| {
9410 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
9411 })?,
9412 ))),
9413 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9414 ::treesitter_types::runtime::maybe_grow_stack(|| {
9415 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9416 })?,
9417 ))),
9418 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9419 }
9420 }
9421}
9422impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
9423 fn span(&self) -> ::treesitter_types::Span {
9424 match self {
9425 Self::ArrayAccess(inner) => inner.span(),
9426 Self::FieldAccess(inner) => inner.span(),
9427 Self::Identifier(inner) => inner.span(),
9428 }
9429 }
9430}
9431#[derive(Debug, Clone, PartialEq, Eq)]
9432pub enum AssignmentExpressionOperator {
9433 PercentEq(::treesitter_types::Span),
9434 AmpEq(::treesitter_types::Span),
9435 StarEq(::treesitter_types::Span),
9436 PlusEq(::treesitter_types::Span),
9437 MinusEq(::treesitter_types::Span),
9438 SlashEq(::treesitter_types::Span),
9439 ShlEq(::treesitter_types::Span),
9440 Eq(::treesitter_types::Span),
9441 ShrEq(::treesitter_types::Span),
9442 GtGtGtEq(::treesitter_types::Span),
9443 CaretEq(::treesitter_types::Span),
9444 PipeEq(::treesitter_types::Span),
9445}
9446impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
9447 #[allow(clippy::collapsible_else_if)]
9448 fn from_node(
9449 node: ::treesitter_types::tree_sitter::Node<'tree>,
9450 _src: &'tree [u8],
9451 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9452 match node.kind() {
9453 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
9454 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
9455 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
9456 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
9457 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
9458 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
9459 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
9460 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
9461 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
9462 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
9463 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
9464 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
9465 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9466 }
9467 }
9468}
9469impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
9470 fn span(&self) -> ::treesitter_types::Span {
9471 match self {
9472 Self::PercentEq(span) => *span,
9473 Self::AmpEq(span) => *span,
9474 Self::StarEq(span) => *span,
9475 Self::PlusEq(span) => *span,
9476 Self::MinusEq(span) => *span,
9477 Self::SlashEq(span) => *span,
9478 Self::ShlEq(span) => *span,
9479 Self::Eq(span) => *span,
9480 Self::ShrEq(span) => *span,
9481 Self::GtGtGtEq(span) => *span,
9482 Self::CaretEq(span) => *span,
9483 Self::PipeEq(span) => *span,
9484 }
9485 }
9486}
9487#[derive(Debug, Clone, PartialEq, Eq)]
9488pub enum BinaryExpressionOperator {
9489 NotEq(::treesitter_types::Span),
9490 Percent(::treesitter_types::Span),
9491 Amp(::treesitter_types::Span),
9492 AmpAmp(::treesitter_types::Span),
9493 Star(::treesitter_types::Span),
9494 Plus(::treesitter_types::Span),
9495 Minus(::treesitter_types::Span),
9496 Slash(::treesitter_types::Span),
9497 Lt(::treesitter_types::Span),
9498 Shl(::treesitter_types::Span),
9499 LtEq(::treesitter_types::Span),
9500 EqEq(::treesitter_types::Span),
9501 Gt(::treesitter_types::Span),
9502 GtEq(::treesitter_types::Span),
9503 Shr(::treesitter_types::Span),
9504 GtGtGt(::treesitter_types::Span),
9505 Caret(::treesitter_types::Span),
9506 Pipe(::treesitter_types::Span),
9507 PipePipe(::treesitter_types::Span),
9508}
9509impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
9510 #[allow(clippy::collapsible_else_if)]
9511 fn from_node(
9512 node: ::treesitter_types::tree_sitter::Node<'tree>,
9513 _src: &'tree [u8],
9514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9515 match node.kind() {
9516 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
9517 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
9518 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
9519 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
9520 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
9521 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9522 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9523 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
9524 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
9525 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
9526 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
9527 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
9528 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
9529 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
9530 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
9531 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
9532 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
9533 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
9534 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
9535 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9536 }
9537 }
9538}
9539impl ::treesitter_types::Spanned for BinaryExpressionOperator {
9540 fn span(&self) -> ::treesitter_types::Span {
9541 match self {
9542 Self::NotEq(span) => *span,
9543 Self::Percent(span) => *span,
9544 Self::Amp(span) => *span,
9545 Self::AmpAmp(span) => *span,
9546 Self::Star(span) => *span,
9547 Self::Plus(span) => *span,
9548 Self::Minus(span) => *span,
9549 Self::Slash(span) => *span,
9550 Self::Lt(span) => *span,
9551 Self::Shl(span) => *span,
9552 Self::LtEq(span) => *span,
9553 Self::EqEq(span) => *span,
9554 Self::Gt(span) => *span,
9555 Self::GtEq(span) => *span,
9556 Self::Shr(span) => *span,
9557 Self::GtGtGt(span) => *span,
9558 Self::Caret(span) => *span,
9559 Self::Pipe(span) => *span,
9560 Self::PipePipe(span) => *span,
9561 }
9562 }
9563}
9564#[derive(Debug, Clone, PartialEq, Eq)]
9565pub enum CatchFormalParameterName<'tree> {
9566 Identifier(::std::boxed::Box<Identifier<'tree>>),
9567 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
9568}
9569impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterName<'tree> {
9570 #[allow(clippy::collapsible_else_if)]
9571 fn from_node(
9572 node: ::treesitter_types::tree_sitter::Node<'tree>,
9573 src: &'tree [u8],
9574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9575 match node.kind() {
9576 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9577 ::treesitter_types::runtime::maybe_grow_stack(|| {
9578 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9579 })?,
9580 ))),
9581 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
9582 ::treesitter_types::runtime::maybe_grow_stack(|| {
9583 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
9584 })?,
9585 ))),
9586 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9587 }
9588 }
9589}
9590impl ::treesitter_types::Spanned for CatchFormalParameterName<'_> {
9591 fn span(&self) -> ::treesitter_types::Span {
9592 match self {
9593 Self::Identifier(inner) => inner.span(),
9594 Self::UnderscorePattern(inner) => inner.span(),
9595 }
9596 }
9597}
9598#[derive(Debug, Clone, PartialEq, Eq)]
9599pub enum CatchFormalParameterChildren<'tree> {
9600 CatchType(::std::boxed::Box<CatchType<'tree>>),
9601 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9602}
9603impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterChildren<'tree> {
9604 #[allow(clippy::collapsible_else_if)]
9605 fn from_node(
9606 node: ::treesitter_types::tree_sitter::Node<'tree>,
9607 src: &'tree [u8],
9608 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9609 match node.kind() {
9610 "catch_type" => Ok(Self::CatchType(::std::boxed::Box::new(
9611 ::treesitter_types::runtime::maybe_grow_stack(|| {
9612 <CatchType as ::treesitter_types::FromNode>::from_node(node, src)
9613 })?,
9614 ))),
9615 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9616 ::treesitter_types::runtime::maybe_grow_stack(|| {
9617 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
9618 })?,
9619 ))),
9620 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9621 }
9622 }
9623}
9624impl ::treesitter_types::Spanned for CatchFormalParameterChildren<'_> {
9625 fn span(&self) -> ::treesitter_types::Span {
9626 match self {
9627 Self::CatchType(inner) => inner.span(),
9628 Self::Modifiers(inner) => inner.span(),
9629 }
9630 }
9631}
9632#[derive(Debug, Clone, PartialEq, Eq)]
9633pub enum ClassBodyChildren<'tree> {
9634 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
9635 Block(::std::boxed::Box<Block<'tree>>),
9636 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
9637 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
9638 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
9639 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9640 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
9641 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
9642 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
9643 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
9644 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
9645}
9646impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyChildren<'tree> {
9647 #[allow(clippy::collapsible_else_if)]
9648 fn from_node(
9649 node: ::treesitter_types::tree_sitter::Node<'tree>,
9650 src: &'tree [u8],
9651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9652 match node.kind() {
9653 "annotation_type_declaration" => Ok(Self::AnnotationTypeDeclaration(
9654 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9655 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
9656 node, src,
9657 )
9658 })?),
9659 )),
9660 "block" => Ok(Self::Block(::std::boxed::Box::new(
9661 ::treesitter_types::runtime::maybe_grow_stack(|| {
9662 <Block as ::treesitter_types::FromNode>::from_node(node, src)
9663 })?,
9664 ))),
9665 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
9666 ::treesitter_types::runtime::maybe_grow_stack(|| {
9667 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9668 })?,
9669 ))),
9670 "compact_constructor_declaration" => Ok(Self::CompactConstructorDeclaration(
9671 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9672 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
9673 node, src,
9674 )
9675 })?),
9676 )),
9677 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
9678 ::treesitter_types::runtime::maybe_grow_stack(|| {
9679 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9680 })?,
9681 ))),
9682 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
9683 ::treesitter_types::runtime::maybe_grow_stack(|| {
9684 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9685 })?,
9686 ))),
9687 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
9688 ::treesitter_types::runtime::maybe_grow_stack(|| {
9689 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9690 })?,
9691 ))),
9692 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
9693 ::treesitter_types::runtime::maybe_grow_stack(|| {
9694 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9695 })?,
9696 ))),
9697 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
9698 ::treesitter_types::runtime::maybe_grow_stack(|| {
9699 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9700 })?,
9701 ))),
9702 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
9703 ::treesitter_types::runtime::maybe_grow_stack(|| {
9704 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9705 })?,
9706 ))),
9707 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
9708 ::treesitter_types::runtime::maybe_grow_stack(|| {
9709 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)
9710 })?,
9711 ))),
9712 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9713 }
9714 }
9715}
9716impl ::treesitter_types::Spanned for ClassBodyChildren<'_> {
9717 fn span(&self) -> ::treesitter_types::Span {
9718 match self {
9719 Self::AnnotationTypeDeclaration(inner) => inner.span(),
9720 Self::Block(inner) => inner.span(),
9721 Self::ClassDeclaration(inner) => inner.span(),
9722 Self::CompactConstructorDeclaration(inner) => inner.span(),
9723 Self::ConstructorDeclaration(inner) => inner.span(),
9724 Self::EnumDeclaration(inner) => inner.span(),
9725 Self::FieldDeclaration(inner) => inner.span(),
9726 Self::InterfaceDeclaration(inner) => inner.span(),
9727 Self::MethodDeclaration(inner) => inner.span(),
9728 Self::RecordDeclaration(inner) => inner.span(),
9729 Self::StaticInitializer(inner) => inner.span(),
9730 }
9731 }
9732}
9733#[derive(Debug, Clone, PartialEq, Eq)]
9734pub enum ConstructorBodyChildren<'tree> {
9735 ExplicitConstructorInvocation(::std::boxed::Box<ExplicitConstructorInvocation<'tree>>),
9736 Statement(::std::boxed::Box<Statement<'tree>>),
9737}
9738impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBodyChildren<'tree> {
9739 #[allow(clippy::collapsible_else_if)]
9740 fn from_node(
9741 node: ::treesitter_types::tree_sitter::Node<'tree>,
9742 src: &'tree [u8],
9743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9744 match node.kind() {
9745 "explicit_constructor_invocation" => Ok(Self::ExplicitConstructorInvocation(
9746 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9747 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
9748 node, src,
9749 )
9750 })?),
9751 )),
9752 _other => {
9753 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9754 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9755 }) {
9756 Ok(Self::Statement(::std::boxed::Box::new(v)))
9757 } else {
9758 Err(::treesitter_types::ParseError::unexpected_kind(
9759 _other, node,
9760 ))
9761 }
9762 }
9763 }
9764 }
9765}
9766impl ::treesitter_types::Spanned for ConstructorBodyChildren<'_> {
9767 fn span(&self) -> ::treesitter_types::Span {
9768 match self {
9769 Self::ExplicitConstructorInvocation(inner) => inner.span(),
9770 Self::Statement(inner) => inner.span(),
9771 }
9772 }
9773}
9774#[derive(Debug, Clone, PartialEq, Eq)]
9775pub enum ConstructorDeclarationChildren<'tree> {
9776 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9777 Throws(::std::boxed::Box<Throws<'tree>>),
9778}
9779impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
9780 #[allow(clippy::collapsible_else_if)]
9781 fn from_node(
9782 node: ::treesitter_types::tree_sitter::Node<'tree>,
9783 src: &'tree [u8],
9784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9785 match node.kind() {
9786 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9787 ::treesitter_types::runtime::maybe_grow_stack(|| {
9788 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
9789 })?,
9790 ))),
9791 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
9792 ::treesitter_types::runtime::maybe_grow_stack(|| {
9793 <Throws as ::treesitter_types::FromNode>::from_node(node, src)
9794 })?,
9795 ))),
9796 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9797 }
9798 }
9799}
9800impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
9801 fn span(&self) -> ::treesitter_types::Span {
9802 match self {
9803 Self::Modifiers(inner) => inner.span(),
9804 Self::Throws(inner) => inner.span(),
9805 }
9806 }
9807}
9808#[derive(Debug, Clone, PartialEq, Eq)]
9809pub enum DimensionsChildren<'tree> {
9810 Annotation(::std::boxed::Box<Annotation<'tree>>),
9811 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9812}
9813impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsChildren<'tree> {
9814 #[allow(clippy::collapsible_else_if)]
9815 fn from_node(
9816 node: ::treesitter_types::tree_sitter::Node<'tree>,
9817 src: &'tree [u8],
9818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9819 match node.kind() {
9820 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9821 ::treesitter_types::runtime::maybe_grow_stack(|| {
9822 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9823 })?,
9824 ))),
9825 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9826 ::treesitter_types::runtime::maybe_grow_stack(|| {
9827 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9828 })?,
9829 ))),
9830 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9831 }
9832 }
9833}
9834impl ::treesitter_types::Spanned for DimensionsChildren<'_> {
9835 fn span(&self) -> ::treesitter_types::Span {
9836 match self {
9837 Self::Annotation(inner) => inner.span(),
9838 Self::MarkerAnnotation(inner) => inner.span(),
9839 }
9840 }
9841}
9842#[derive(Debug, Clone, PartialEq, Eq)]
9843pub enum DimensionsExprChildren<'tree> {
9844 Annotation(::std::boxed::Box<Annotation<'tree>>),
9845 Expression(::std::boxed::Box<Expression<'tree>>),
9846 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9847}
9848impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExprChildren<'tree> {
9849 #[allow(clippy::collapsible_else_if)]
9850 fn from_node(
9851 node: ::treesitter_types::tree_sitter::Node<'tree>,
9852 src: &'tree [u8],
9853 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9854 match node.kind() {
9855 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9856 ::treesitter_types::runtime::maybe_grow_stack(|| {
9857 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9858 })?,
9859 ))),
9860 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9861 ::treesitter_types::runtime::maybe_grow_stack(|| {
9862 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9863 })?,
9864 ))),
9865 _other => {
9866 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9867 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9868 }) {
9869 Ok(Self::Expression(::std::boxed::Box::new(v)))
9870 } else {
9871 Err(::treesitter_types::ParseError::unexpected_kind(
9872 _other, node,
9873 ))
9874 }
9875 }
9876 }
9877 }
9878}
9879impl ::treesitter_types::Spanned for DimensionsExprChildren<'_> {
9880 fn span(&self) -> ::treesitter_types::Span {
9881 match self {
9882 Self::Annotation(inner) => inner.span(),
9883 Self::Expression(inner) => inner.span(),
9884 Self::MarkerAnnotation(inner) => inner.span(),
9885 }
9886 }
9887}
9888#[derive(Debug, Clone, PartialEq, Eq)]
9889pub enum ElementValueArrayInitializerChildren<'tree> {
9890 Annotation(::std::boxed::Box<Annotation<'tree>>),
9891 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9892 Expression(::std::boxed::Box<Expression<'tree>>),
9893 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9894}
9895impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializerChildren<'tree> {
9896 #[allow(clippy::collapsible_else_if)]
9897 fn from_node(
9898 node: ::treesitter_types::tree_sitter::Node<'tree>,
9899 src: &'tree [u8],
9900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9901 match node.kind() {
9902 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9903 ::treesitter_types::runtime::maybe_grow_stack(|| {
9904 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9905 })?,
9906 ))),
9907 "element_value_array_initializer" => Ok(Self::ElementValueArrayInitializer(
9908 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9909 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9910 node, src,
9911 )
9912 })?),
9913 )),
9914 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9915 ::treesitter_types::runtime::maybe_grow_stack(|| {
9916 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9917 })?,
9918 ))),
9919 _other => {
9920 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9921 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9922 }) {
9923 Ok(Self::Expression(::std::boxed::Box::new(v)))
9924 } else {
9925 Err(::treesitter_types::ParseError::unexpected_kind(
9926 _other, node,
9927 ))
9928 }
9929 }
9930 }
9931 }
9932}
9933impl ::treesitter_types::Spanned for ElementValueArrayInitializerChildren<'_> {
9934 fn span(&self) -> ::treesitter_types::Span {
9935 match self {
9936 Self::Annotation(inner) => inner.span(),
9937 Self::ElementValueArrayInitializer(inner) => inner.span(),
9938 Self::Expression(inner) => inner.span(),
9939 Self::MarkerAnnotation(inner) => inner.span(),
9940 }
9941 }
9942}
9943#[derive(Debug, Clone, PartialEq, Eq)]
9944pub enum ElementValuePairValue<'tree> {
9945 Annotation(::std::boxed::Box<Annotation<'tree>>),
9946 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9947 Expression(::std::boxed::Box<Expression<'tree>>),
9948 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9949}
9950impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePairValue<'tree> {
9951 #[allow(clippy::collapsible_else_if)]
9952 fn from_node(
9953 node: ::treesitter_types::tree_sitter::Node<'tree>,
9954 src: &'tree [u8],
9955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9956 match node.kind() {
9957 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9958 ::treesitter_types::runtime::maybe_grow_stack(|| {
9959 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
9960 })?,
9961 ))),
9962 "element_value_array_initializer" => Ok(Self::ElementValueArrayInitializer(
9963 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9964 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9965 node, src,
9966 )
9967 })?),
9968 )),
9969 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9970 ::treesitter_types::runtime::maybe_grow_stack(|| {
9971 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
9972 })?,
9973 ))),
9974 _other => {
9975 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9976 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9977 }) {
9978 Ok(Self::Expression(::std::boxed::Box::new(v)))
9979 } else {
9980 Err(::treesitter_types::ParseError::unexpected_kind(
9981 _other, node,
9982 ))
9983 }
9984 }
9985 }
9986 }
9987}
9988impl ::treesitter_types::Spanned for ElementValuePairValue<'_> {
9989 fn span(&self) -> ::treesitter_types::Span {
9990 match self {
9991 Self::Annotation(inner) => inner.span(),
9992 Self::ElementValueArrayInitializer(inner) => inner.span(),
9993 Self::Expression(inner) => inner.span(),
9994 Self::MarkerAnnotation(inner) => inner.span(),
9995 }
9996 }
9997}
9998#[derive(Debug, Clone, PartialEq, Eq)]
9999pub enum EnhancedForStatementName<'tree> {
10000 Identifier(::std::boxed::Box<Identifier<'tree>>),
10001 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10002}
10003impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatementName<'tree> {
10004 #[allow(clippy::collapsible_else_if)]
10005 fn from_node(
10006 node: ::treesitter_types::tree_sitter::Node<'tree>,
10007 src: &'tree [u8],
10008 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10009 match node.kind() {
10010 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10011 ::treesitter_types::runtime::maybe_grow_stack(|| {
10012 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10013 })?,
10014 ))),
10015 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10016 ::treesitter_types::runtime::maybe_grow_stack(|| {
10017 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
10018 })?,
10019 ))),
10020 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10021 }
10022 }
10023}
10024impl ::treesitter_types::Spanned for EnhancedForStatementName<'_> {
10025 fn span(&self) -> ::treesitter_types::Span {
10026 match self {
10027 Self::Identifier(inner) => inner.span(),
10028 Self::UnderscorePattern(inner) => inner.span(),
10029 }
10030 }
10031}
10032#[derive(Debug, Clone, PartialEq, Eq)]
10033pub enum EnumBodyChildren<'tree> {
10034 EnumBodyDeclarations(::std::boxed::Box<EnumBodyDeclarations<'tree>>),
10035 EnumConstant(::std::boxed::Box<EnumConstant<'tree>>),
10036}
10037impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyChildren<'tree> {
10038 #[allow(clippy::collapsible_else_if)]
10039 fn from_node(
10040 node: ::treesitter_types::tree_sitter::Node<'tree>,
10041 src: &'tree [u8],
10042 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10043 match node.kind() {
10044 "enum_body_declarations" => Ok(Self::EnumBodyDeclarations(::std::boxed::Box::new(
10045 ::treesitter_types::runtime::maybe_grow_stack(|| {
10046 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
10047 })?,
10048 ))),
10049 "enum_constant" => Ok(Self::EnumConstant(::std::boxed::Box::new(
10050 ::treesitter_types::runtime::maybe_grow_stack(|| {
10051 <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)
10052 })?,
10053 ))),
10054 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10055 }
10056 }
10057}
10058impl ::treesitter_types::Spanned for EnumBodyChildren<'_> {
10059 fn span(&self) -> ::treesitter_types::Span {
10060 match self {
10061 Self::EnumBodyDeclarations(inner) => inner.span(),
10062 Self::EnumConstant(inner) => inner.span(),
10063 }
10064 }
10065}
10066#[derive(Debug, Clone, PartialEq, Eq)]
10067pub enum EnumBodyDeclarationsChildren<'tree> {
10068 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
10069 Block(::std::boxed::Box<Block<'tree>>),
10070 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
10071 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
10072 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
10073 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
10074 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
10075 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
10076 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
10077 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
10078 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
10079}
10080impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarationsChildren<'tree> {
10081 #[allow(clippy::collapsible_else_if)]
10082 fn from_node(
10083 node: ::treesitter_types::tree_sitter::Node<'tree>,
10084 src: &'tree [u8],
10085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10086 match node.kind() {
10087 "annotation_type_declaration" => Ok(Self::AnnotationTypeDeclaration(
10088 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10089 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
10090 node, src,
10091 )
10092 })?),
10093 )),
10094 "block" => Ok(Self::Block(::std::boxed::Box::new(
10095 ::treesitter_types::runtime::maybe_grow_stack(|| {
10096 <Block as ::treesitter_types::FromNode>::from_node(node, src)
10097 })?,
10098 ))),
10099 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
10100 ::treesitter_types::runtime::maybe_grow_stack(|| {
10101 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10102 })?,
10103 ))),
10104 "compact_constructor_declaration" => Ok(Self::CompactConstructorDeclaration(
10105 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10106 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
10107 node, src,
10108 )
10109 })?),
10110 )),
10111 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
10112 ::treesitter_types::runtime::maybe_grow_stack(|| {
10113 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10114 })?,
10115 ))),
10116 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
10117 ::treesitter_types::runtime::maybe_grow_stack(|| {
10118 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10119 })?,
10120 ))),
10121 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
10122 ::treesitter_types::runtime::maybe_grow_stack(|| {
10123 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10124 })?,
10125 ))),
10126 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
10127 ::treesitter_types::runtime::maybe_grow_stack(|| {
10128 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10129 })?,
10130 ))),
10131 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
10132 ::treesitter_types::runtime::maybe_grow_stack(|| {
10133 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10134 })?,
10135 ))),
10136 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
10137 ::treesitter_types::runtime::maybe_grow_stack(|| {
10138 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10139 })?,
10140 ))),
10141 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
10142 ::treesitter_types::runtime::maybe_grow_stack(|| {
10143 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)
10144 })?,
10145 ))),
10146 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10147 }
10148 }
10149}
10150impl ::treesitter_types::Spanned for EnumBodyDeclarationsChildren<'_> {
10151 fn span(&self) -> ::treesitter_types::Span {
10152 match self {
10153 Self::AnnotationTypeDeclaration(inner) => inner.span(),
10154 Self::Block(inner) => inner.span(),
10155 Self::ClassDeclaration(inner) => inner.span(),
10156 Self::CompactConstructorDeclaration(inner) => inner.span(),
10157 Self::ConstructorDeclaration(inner) => inner.span(),
10158 Self::EnumDeclaration(inner) => inner.span(),
10159 Self::FieldDeclaration(inner) => inner.span(),
10160 Self::InterfaceDeclaration(inner) => inner.span(),
10161 Self::MethodDeclaration(inner) => inner.span(),
10162 Self::RecordDeclaration(inner) => inner.span(),
10163 Self::StaticInitializer(inner) => inner.span(),
10164 }
10165 }
10166}
10167#[derive(Debug, Clone, PartialEq, Eq)]
10168pub enum ExplicitConstructorInvocationConstructor<'tree> {
10169 Super(::std::boxed::Box<Super<'tree>>),
10170 This(::std::boxed::Box<This<'tree>>),
10171}
10172impl<'tree> ::treesitter_types::FromNode<'tree>
10173 for ExplicitConstructorInvocationConstructor<'tree>
10174{
10175 #[allow(clippy::collapsible_else_if)]
10176 fn from_node(
10177 node: ::treesitter_types::tree_sitter::Node<'tree>,
10178 src: &'tree [u8],
10179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10180 match node.kind() {
10181 "super" => Ok(Self::Super(::std::boxed::Box::new(
10182 ::treesitter_types::runtime::maybe_grow_stack(|| {
10183 <Super as ::treesitter_types::FromNode>::from_node(node, src)
10184 })?,
10185 ))),
10186 "this" => Ok(Self::This(::std::boxed::Box::new(
10187 ::treesitter_types::runtime::maybe_grow_stack(|| {
10188 <This as ::treesitter_types::FromNode>::from_node(node, src)
10189 })?,
10190 ))),
10191 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10192 }
10193 }
10194}
10195impl ::treesitter_types::Spanned for ExplicitConstructorInvocationConstructor<'_> {
10196 fn span(&self) -> ::treesitter_types::Span {
10197 match self {
10198 Self::Super(inner) => inner.span(),
10199 Self::This(inner) => inner.span(),
10200 }
10201 }
10202}
10203#[derive(Debug, Clone, PartialEq, Eq)]
10204pub enum ExportsModuleDirectiveModules<'tree> {
10205 Identifier(::std::boxed::Box<Identifier<'tree>>),
10206 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10207}
10208impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectiveModules<'tree> {
10209 #[allow(clippy::collapsible_else_if)]
10210 fn from_node(
10211 node: ::treesitter_types::tree_sitter::Node<'tree>,
10212 src: &'tree [u8],
10213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10214 match node.kind() {
10215 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10216 ::treesitter_types::runtime::maybe_grow_stack(|| {
10217 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10218 })?,
10219 ))),
10220 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10221 ::treesitter_types::runtime::maybe_grow_stack(|| {
10222 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10223 })?,
10224 ))),
10225 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10226 }
10227 }
10228}
10229impl ::treesitter_types::Spanned for ExportsModuleDirectiveModules<'_> {
10230 fn span(&self) -> ::treesitter_types::Span {
10231 match self {
10232 Self::Identifier(inner) => inner.span(),
10233 Self::ScopedIdentifier(inner) => inner.span(),
10234 }
10235 }
10236}
10237#[derive(Debug, Clone, PartialEq, Eq)]
10238pub enum ExportsModuleDirectivePackage<'tree> {
10239 Identifier(::std::boxed::Box<Identifier<'tree>>),
10240 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10241}
10242impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectivePackage<'tree> {
10243 #[allow(clippy::collapsible_else_if)]
10244 fn from_node(
10245 node: ::treesitter_types::tree_sitter::Node<'tree>,
10246 src: &'tree [u8],
10247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10248 match node.kind() {
10249 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10250 ::treesitter_types::runtime::maybe_grow_stack(|| {
10251 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10252 })?,
10253 ))),
10254 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10255 ::treesitter_types::runtime::maybe_grow_stack(|| {
10256 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10257 })?,
10258 ))),
10259 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10260 }
10261 }
10262}
10263impl ::treesitter_types::Spanned for ExportsModuleDirectivePackage<'_> {
10264 fn span(&self) -> ::treesitter_types::Span {
10265 match self {
10266 Self::Identifier(inner) => inner.span(),
10267 Self::ScopedIdentifier(inner) => inner.span(),
10268 }
10269 }
10270}
10271#[derive(Debug, Clone, PartialEq, Eq)]
10272pub enum FieldAccessField<'tree> {
10273 Identifier(::std::boxed::Box<Identifier<'tree>>),
10274 This(::std::boxed::Box<This<'tree>>),
10275}
10276impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessField<'tree> {
10277 #[allow(clippy::collapsible_else_if)]
10278 fn from_node(
10279 node: ::treesitter_types::tree_sitter::Node<'tree>,
10280 src: &'tree [u8],
10281 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10282 match node.kind() {
10283 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10284 ::treesitter_types::runtime::maybe_grow_stack(|| {
10285 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10286 })?,
10287 ))),
10288 "this" => Ok(Self::This(::std::boxed::Box::new(
10289 ::treesitter_types::runtime::maybe_grow_stack(|| {
10290 <This as ::treesitter_types::FromNode>::from_node(node, src)
10291 })?,
10292 ))),
10293 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10294 }
10295 }
10296}
10297impl ::treesitter_types::Spanned for FieldAccessField<'_> {
10298 fn span(&self) -> ::treesitter_types::Span {
10299 match self {
10300 Self::Identifier(inner) => inner.span(),
10301 Self::This(inner) => inner.span(),
10302 }
10303 }
10304}
10305#[derive(Debug, Clone, PartialEq, Eq)]
10306pub enum FieldAccessObject<'tree> {
10307 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10308 Super(::std::boxed::Box<Super<'tree>>),
10309}
10310impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessObject<'tree> {
10311 #[allow(clippy::collapsible_else_if)]
10312 fn from_node(
10313 node: ::treesitter_types::tree_sitter::Node<'tree>,
10314 src: &'tree [u8],
10315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10316 match node.kind() {
10317 "super" => Ok(Self::Super(::std::boxed::Box::new(
10318 ::treesitter_types::runtime::maybe_grow_stack(|| {
10319 <Super as ::treesitter_types::FromNode>::from_node(node, src)
10320 })?,
10321 ))),
10322 _other => {
10323 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10324 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10325 }) {
10326 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10327 } else {
10328 Err(::treesitter_types::ParseError::unexpected_kind(
10329 _other, node,
10330 ))
10331 }
10332 }
10333 }
10334 }
10335}
10336impl ::treesitter_types::Spanned for FieldAccessObject<'_> {
10337 fn span(&self) -> ::treesitter_types::Span {
10338 match self {
10339 Self::PrimaryExpression(inner) => inner.span(),
10340 Self::Super(inner) => inner.span(),
10341 }
10342 }
10343}
10344#[derive(Debug, Clone, PartialEq, Eq)]
10345pub enum ForStatementInit<'tree> {
10346 Expression(::std::boxed::Box<Expression<'tree>>),
10347 LocalVariableDeclaration(::std::boxed::Box<LocalVariableDeclaration<'tree>>),
10348}
10349impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInit<'tree> {
10350 #[allow(clippy::collapsible_else_if)]
10351 fn from_node(
10352 node: ::treesitter_types::tree_sitter::Node<'tree>,
10353 src: &'tree [u8],
10354 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10355 match node.kind() {
10356 "local_variable_declaration" => Ok(Self::LocalVariableDeclaration(
10357 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10358 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10359 })?),
10360 )),
10361 _other => {
10362 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10363 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10364 }) {
10365 Ok(Self::Expression(::std::boxed::Box::new(v)))
10366 } else {
10367 Err(::treesitter_types::ParseError::unexpected_kind(
10368 _other, node,
10369 ))
10370 }
10371 }
10372 }
10373 }
10374}
10375impl ::treesitter_types::Spanned for ForStatementInit<'_> {
10376 fn span(&self) -> ::treesitter_types::Span {
10377 match self {
10378 Self::Expression(inner) => inner.span(),
10379 Self::LocalVariableDeclaration(inner) => inner.span(),
10380 }
10381 }
10382}
10383#[derive(Debug, Clone, PartialEq, Eq)]
10384pub enum FormalParameterName<'tree> {
10385 Identifier(::std::boxed::Box<Identifier<'tree>>),
10386 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10387}
10388impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameterName<'tree> {
10389 #[allow(clippy::collapsible_else_if)]
10390 fn from_node(
10391 node: ::treesitter_types::tree_sitter::Node<'tree>,
10392 src: &'tree [u8],
10393 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10394 match node.kind() {
10395 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10396 ::treesitter_types::runtime::maybe_grow_stack(|| {
10397 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10398 })?,
10399 ))),
10400 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10401 ::treesitter_types::runtime::maybe_grow_stack(|| {
10402 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
10403 })?,
10404 ))),
10405 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10406 }
10407 }
10408}
10409impl ::treesitter_types::Spanned for FormalParameterName<'_> {
10410 fn span(&self) -> ::treesitter_types::Span {
10411 match self {
10412 Self::Identifier(inner) => inner.span(),
10413 Self::UnderscorePattern(inner) => inner.span(),
10414 }
10415 }
10416}
10417#[derive(Debug, Clone, PartialEq, Eq)]
10418pub enum FormalParametersChildren<'tree> {
10419 FormalParameter(::std::boxed::Box<FormalParameter<'tree>>),
10420 ReceiverParameter(::std::boxed::Box<ReceiverParameter<'tree>>),
10421 SpreadParameter(::std::boxed::Box<SpreadParameter<'tree>>),
10422}
10423impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
10424 #[allow(clippy::collapsible_else_if)]
10425 fn from_node(
10426 node: ::treesitter_types::tree_sitter::Node<'tree>,
10427 src: &'tree [u8],
10428 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10429 match node.kind() {
10430 "formal_parameter" => Ok(Self::FormalParameter(::std::boxed::Box::new(
10431 ::treesitter_types::runtime::maybe_grow_stack(|| {
10432 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
10433 })?,
10434 ))),
10435 "receiver_parameter" => Ok(Self::ReceiverParameter(::std::boxed::Box::new(
10436 ::treesitter_types::runtime::maybe_grow_stack(|| {
10437 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)
10438 })?,
10439 ))),
10440 "spread_parameter" => Ok(Self::SpreadParameter(::std::boxed::Box::new(
10441 ::treesitter_types::runtime::maybe_grow_stack(|| {
10442 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)
10443 })?,
10444 ))),
10445 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10446 }
10447 }
10448}
10449impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
10450 fn span(&self) -> ::treesitter_types::Span {
10451 match self {
10452 Self::FormalParameter(inner) => inner.span(),
10453 Self::ReceiverParameter(inner) => inner.span(),
10454 Self::SpreadParameter(inner) => inner.span(),
10455 }
10456 }
10457}
10458#[derive(Debug, Clone, PartialEq, Eq)]
10459pub enum GenericTypeChildren<'tree> {
10460 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10461 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
10462 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10463}
10464impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeChildren<'tree> {
10465 #[allow(clippy::collapsible_else_if)]
10466 fn from_node(
10467 node: ::treesitter_types::tree_sitter::Node<'tree>,
10468 src: &'tree [u8],
10469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10470 match node.kind() {
10471 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10472 ::treesitter_types::runtime::maybe_grow_stack(|| {
10473 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10474 })?,
10475 ))),
10476 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
10477 ::treesitter_types::runtime::maybe_grow_stack(|| {
10478 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
10479 })?,
10480 ))),
10481 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10482 ::treesitter_types::runtime::maybe_grow_stack(|| {
10483 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10484 })?,
10485 ))),
10486 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10487 }
10488 }
10489}
10490impl ::treesitter_types::Spanned for GenericTypeChildren<'_> {
10491 fn span(&self) -> ::treesitter_types::Span {
10492 match self {
10493 Self::ScopedTypeIdentifier(inner) => inner.span(),
10494 Self::TypeArguments(inner) => inner.span(),
10495 Self::TypeIdentifier(inner) => inner.span(),
10496 }
10497 }
10498}
10499#[derive(Debug, Clone, PartialEq, Eq)]
10500pub enum ImportDeclarationChildren<'tree> {
10501 Asterisk(::std::boxed::Box<Asterisk<'tree>>),
10502 Identifier(::std::boxed::Box<Identifier<'tree>>),
10503 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10504}
10505impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclarationChildren<'tree> {
10506 #[allow(clippy::collapsible_else_if)]
10507 fn from_node(
10508 node: ::treesitter_types::tree_sitter::Node<'tree>,
10509 src: &'tree [u8],
10510 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10511 match node.kind() {
10512 "asterisk" => Ok(Self::Asterisk(::std::boxed::Box::new(
10513 ::treesitter_types::runtime::maybe_grow_stack(|| {
10514 <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)
10515 })?,
10516 ))),
10517 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10518 ::treesitter_types::runtime::maybe_grow_stack(|| {
10519 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10520 })?,
10521 ))),
10522 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10523 ::treesitter_types::runtime::maybe_grow_stack(|| {
10524 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10525 })?,
10526 ))),
10527 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10528 }
10529 }
10530}
10531impl ::treesitter_types::Spanned for ImportDeclarationChildren<'_> {
10532 fn span(&self) -> ::treesitter_types::Span {
10533 match self {
10534 Self::Asterisk(inner) => inner.span(),
10535 Self::Identifier(inner) => inner.span(),
10536 Self::ScopedIdentifier(inner) => inner.span(),
10537 }
10538 }
10539}
10540#[derive(Debug, Clone, PartialEq, Eq)]
10541pub enum InterfaceBodyChildren<'tree> {
10542 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
10543 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
10544 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
10545 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
10546 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
10547 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
10548 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
10549}
10550impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBodyChildren<'tree> {
10551 #[allow(clippy::collapsible_else_if)]
10552 fn from_node(
10553 node: ::treesitter_types::tree_sitter::Node<'tree>,
10554 src: &'tree [u8],
10555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10556 match node.kind() {
10557 "annotation_type_declaration" => Ok(Self::AnnotationTypeDeclaration(
10558 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10559 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
10560 node, src,
10561 )
10562 })?),
10563 )),
10564 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
10565 ::treesitter_types::runtime::maybe_grow_stack(|| {
10566 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10567 })?,
10568 ))),
10569 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
10570 ::treesitter_types::runtime::maybe_grow_stack(|| {
10571 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10572 })?,
10573 ))),
10574 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
10575 ::treesitter_types::runtime::maybe_grow_stack(|| {
10576 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10577 })?,
10578 ))),
10579 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
10580 ::treesitter_types::runtime::maybe_grow_stack(|| {
10581 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10582 })?,
10583 ))),
10584 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
10585 ::treesitter_types::runtime::maybe_grow_stack(|| {
10586 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10587 })?,
10588 ))),
10589 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
10590 ::treesitter_types::runtime::maybe_grow_stack(|| {
10591 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10592 })?,
10593 ))),
10594 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10595 }
10596 }
10597}
10598impl ::treesitter_types::Spanned for InterfaceBodyChildren<'_> {
10599 fn span(&self) -> ::treesitter_types::Span {
10600 match self {
10601 Self::AnnotationTypeDeclaration(inner) => inner.span(),
10602 Self::ClassDeclaration(inner) => inner.span(),
10603 Self::ConstantDeclaration(inner) => inner.span(),
10604 Self::EnumDeclaration(inner) => inner.span(),
10605 Self::InterfaceDeclaration(inner) => inner.span(),
10606 Self::MethodDeclaration(inner) => inner.span(),
10607 Self::RecordDeclaration(inner) => inner.span(),
10608 }
10609 }
10610}
10611#[derive(Debug, Clone, PartialEq, Eq)]
10612pub enum InterfaceDeclarationChildren<'tree> {
10613 ExtendsInterfaces(::std::boxed::Box<ExtendsInterfaces<'tree>>),
10614 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10615}
10616impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
10617 #[allow(clippy::collapsible_else_if)]
10618 fn from_node(
10619 node: ::treesitter_types::tree_sitter::Node<'tree>,
10620 src: &'tree [u8],
10621 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10622 match node.kind() {
10623 "extends_interfaces" => Ok(Self::ExtendsInterfaces(::std::boxed::Box::new(
10624 ::treesitter_types::runtime::maybe_grow_stack(|| {
10625 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
10626 })?,
10627 ))),
10628 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10629 ::treesitter_types::runtime::maybe_grow_stack(|| {
10630 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
10631 })?,
10632 ))),
10633 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10634 }
10635 }
10636}
10637impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
10638 fn span(&self) -> ::treesitter_types::Span {
10639 match self {
10640 Self::ExtendsInterfaces(inner) => inner.span(),
10641 Self::Modifiers(inner) => inner.span(),
10642 }
10643 }
10644}
10645#[derive(Debug, Clone, PartialEq, Eq)]
10646pub enum LabeledStatementChildren<'tree> {
10647 Identifier(::std::boxed::Box<Identifier<'tree>>),
10648 Statement(::std::boxed::Box<Statement<'tree>>),
10649}
10650impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
10651 #[allow(clippy::collapsible_else_if)]
10652 fn from_node(
10653 node: ::treesitter_types::tree_sitter::Node<'tree>,
10654 src: &'tree [u8],
10655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10656 match node.kind() {
10657 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10658 ::treesitter_types::runtime::maybe_grow_stack(|| {
10659 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10660 })?,
10661 ))),
10662 _other => {
10663 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10664 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10665 }) {
10666 Ok(Self::Statement(::std::boxed::Box::new(v)))
10667 } else {
10668 Err(::treesitter_types::ParseError::unexpected_kind(
10669 _other, node,
10670 ))
10671 }
10672 }
10673 }
10674 }
10675}
10676impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
10677 fn span(&self) -> ::treesitter_types::Span {
10678 match self {
10679 Self::Identifier(inner) => inner.span(),
10680 Self::Statement(inner) => inner.span(),
10681 }
10682 }
10683}
10684#[derive(Debug, Clone, PartialEq, Eq)]
10685pub enum LambdaExpressionBody<'tree> {
10686 Block(::std::boxed::Box<Block<'tree>>),
10687 Expression(::std::boxed::Box<Expression<'tree>>),
10688}
10689impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
10690 #[allow(clippy::collapsible_else_if)]
10691 fn from_node(
10692 node: ::treesitter_types::tree_sitter::Node<'tree>,
10693 src: &'tree [u8],
10694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10695 match node.kind() {
10696 "block" => Ok(Self::Block(::std::boxed::Box::new(
10697 ::treesitter_types::runtime::maybe_grow_stack(|| {
10698 <Block as ::treesitter_types::FromNode>::from_node(node, src)
10699 })?,
10700 ))),
10701 _other => {
10702 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10703 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10704 }) {
10705 Ok(Self::Expression(::std::boxed::Box::new(v)))
10706 } else {
10707 Err(::treesitter_types::ParseError::unexpected_kind(
10708 _other, node,
10709 ))
10710 }
10711 }
10712 }
10713 }
10714}
10715impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
10716 fn span(&self) -> ::treesitter_types::Span {
10717 match self {
10718 Self::Block(inner) => inner.span(),
10719 Self::Expression(inner) => inner.span(),
10720 }
10721 }
10722}
10723#[derive(Debug, Clone, PartialEq, Eq)]
10724pub enum LambdaExpressionParameters<'tree> {
10725 FormalParameters(::std::boxed::Box<FormalParameters<'tree>>),
10726 Identifier(::std::boxed::Box<Identifier<'tree>>),
10727 InferredParameters(::std::boxed::Box<InferredParameters<'tree>>),
10728}
10729impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
10730 #[allow(clippy::collapsible_else_if)]
10731 fn from_node(
10732 node: ::treesitter_types::tree_sitter::Node<'tree>,
10733 src: &'tree [u8],
10734 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10735 match node.kind() {
10736 "formal_parameters" => Ok(Self::FormalParameters(::std::boxed::Box::new(
10737 ::treesitter_types::runtime::maybe_grow_stack(|| {
10738 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
10739 })?,
10740 ))),
10741 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10742 ::treesitter_types::runtime::maybe_grow_stack(|| {
10743 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10744 })?,
10745 ))),
10746 "inferred_parameters" => Ok(Self::InferredParameters(::std::boxed::Box::new(
10747 ::treesitter_types::runtime::maybe_grow_stack(|| {
10748 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)
10749 })?,
10750 ))),
10751 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10752 }
10753 }
10754}
10755impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
10756 fn span(&self) -> ::treesitter_types::Span {
10757 match self {
10758 Self::FormalParameters(inner) => inner.span(),
10759 Self::Identifier(inner) => inner.span(),
10760 Self::InferredParameters(inner) => inner.span(),
10761 }
10762 }
10763}
10764#[derive(Debug, Clone, PartialEq, Eq)]
10765pub enum MarkerAnnotationName<'tree> {
10766 Identifier(::std::boxed::Box<Identifier<'tree>>),
10767 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10768}
10769impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotationName<'tree> {
10770 #[allow(clippy::collapsible_else_if)]
10771 fn from_node(
10772 node: ::treesitter_types::tree_sitter::Node<'tree>,
10773 src: &'tree [u8],
10774 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10775 match node.kind() {
10776 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10777 ::treesitter_types::runtime::maybe_grow_stack(|| {
10778 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10779 })?,
10780 ))),
10781 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10782 ::treesitter_types::runtime::maybe_grow_stack(|| {
10783 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10784 })?,
10785 ))),
10786 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10787 }
10788 }
10789}
10790impl ::treesitter_types::Spanned for MarkerAnnotationName<'_> {
10791 fn span(&self) -> ::treesitter_types::Span {
10792 match self {
10793 Self::Identifier(inner) => inner.span(),
10794 Self::ScopedIdentifier(inner) => inner.span(),
10795 }
10796 }
10797}
10798#[derive(Debug, Clone, PartialEq, Eq)]
10799pub enum MethodDeclarationChildren<'tree> {
10800 Annotation(::std::boxed::Box<Annotation<'tree>>),
10801 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10802 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10803 Throws(::std::boxed::Box<Throws<'tree>>),
10804}
10805impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
10806 #[allow(clippy::collapsible_else_if)]
10807 fn from_node(
10808 node: ::treesitter_types::tree_sitter::Node<'tree>,
10809 src: &'tree [u8],
10810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10811 match node.kind() {
10812 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10813 ::treesitter_types::runtime::maybe_grow_stack(|| {
10814 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
10815 })?,
10816 ))),
10817 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10818 ::treesitter_types::runtime::maybe_grow_stack(|| {
10819 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
10820 })?,
10821 ))),
10822 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10823 ::treesitter_types::runtime::maybe_grow_stack(|| {
10824 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
10825 })?,
10826 ))),
10827 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
10828 ::treesitter_types::runtime::maybe_grow_stack(|| {
10829 <Throws as ::treesitter_types::FromNode>::from_node(node, src)
10830 })?,
10831 ))),
10832 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10833 }
10834 }
10835}
10836impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
10837 fn span(&self) -> ::treesitter_types::Span {
10838 match self {
10839 Self::Annotation(inner) => inner.span(),
10840 Self::MarkerAnnotation(inner) => inner.span(),
10841 Self::Modifiers(inner) => inner.span(),
10842 Self::Throws(inner) => inner.span(),
10843 }
10844 }
10845}
10846#[derive(Debug, Clone, PartialEq, Eq)]
10847pub enum MethodInvocationObject<'tree> {
10848 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10849 Super(::std::boxed::Box<Super<'tree>>),
10850}
10851impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocationObject<'tree> {
10852 #[allow(clippy::collapsible_else_if)]
10853 fn from_node(
10854 node: ::treesitter_types::tree_sitter::Node<'tree>,
10855 src: &'tree [u8],
10856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10857 match node.kind() {
10858 "super" => Ok(Self::Super(::std::boxed::Box::new(
10859 ::treesitter_types::runtime::maybe_grow_stack(|| {
10860 <Super as ::treesitter_types::FromNode>::from_node(node, src)
10861 })?,
10862 ))),
10863 _other => {
10864 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10865 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10866 }) {
10867 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10868 } else {
10869 Err(::treesitter_types::ParseError::unexpected_kind(
10870 _other, node,
10871 ))
10872 }
10873 }
10874 }
10875 }
10876}
10877impl ::treesitter_types::Spanned for MethodInvocationObject<'_> {
10878 fn span(&self) -> ::treesitter_types::Span {
10879 match self {
10880 Self::PrimaryExpression(inner) => inner.span(),
10881 Self::Super(inner) => inner.span(),
10882 }
10883 }
10884}
10885#[derive(Debug, Clone, PartialEq, Eq)]
10886pub enum MethodReferenceChildren<'tree> {
10887 Type(::std::boxed::Box<Type<'tree>>),
10888 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10889 Super(::std::boxed::Box<Super<'tree>>),
10890 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
10891}
10892impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReferenceChildren<'tree> {
10893 #[allow(clippy::collapsible_else_if)]
10894 fn from_node(
10895 node: ::treesitter_types::tree_sitter::Node<'tree>,
10896 src: &'tree [u8],
10897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10898 match node.kind() {
10899 "super" => Ok(Self::Super(::std::boxed::Box::new(
10900 ::treesitter_types::runtime::maybe_grow_stack(|| {
10901 <Super as ::treesitter_types::FromNode>::from_node(node, src)
10902 })?,
10903 ))),
10904 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
10905 ::treesitter_types::runtime::maybe_grow_stack(|| {
10906 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
10907 })?,
10908 ))),
10909 _other => {
10910 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10911 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10912 }) {
10913 Ok(Self::Type(::std::boxed::Box::new(v)))
10914 } else {
10915 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10916 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10917 }) {
10918 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10919 } else {
10920 Err(::treesitter_types::ParseError::unexpected_kind(
10921 _other, node,
10922 ))
10923 }
10924 }
10925 }
10926 }
10927 }
10928}
10929impl ::treesitter_types::Spanned for MethodReferenceChildren<'_> {
10930 fn span(&self) -> ::treesitter_types::Span {
10931 match self {
10932 Self::Type(inner) => inner.span(),
10933 Self::PrimaryExpression(inner) => inner.span(),
10934 Self::Super(inner) => inner.span(),
10935 Self::TypeArguments(inner) => inner.span(),
10936 }
10937 }
10938}
10939#[derive(Debug, Clone, PartialEq, Eq)]
10940pub enum ModifiersChildren<'tree> {
10941 Annotation(::std::boxed::Box<Annotation<'tree>>),
10942 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10943}
10944impl<'tree> ::treesitter_types::FromNode<'tree> for ModifiersChildren<'tree> {
10945 #[allow(clippy::collapsible_else_if)]
10946 fn from_node(
10947 node: ::treesitter_types::tree_sitter::Node<'tree>,
10948 src: &'tree [u8],
10949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10950 match node.kind() {
10951 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10952 ::treesitter_types::runtime::maybe_grow_stack(|| {
10953 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
10954 })?,
10955 ))),
10956 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10957 ::treesitter_types::runtime::maybe_grow_stack(|| {
10958 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
10959 })?,
10960 ))),
10961 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10962 }
10963 }
10964}
10965impl ::treesitter_types::Spanned for ModifiersChildren<'_> {
10966 fn span(&self) -> ::treesitter_types::Span {
10967 match self {
10968 Self::Annotation(inner) => inner.span(),
10969 Self::MarkerAnnotation(inner) => inner.span(),
10970 }
10971 }
10972}
10973#[derive(Debug, Clone, PartialEq, Eq)]
10974pub enum ModuleDeclarationName<'tree> {
10975 Identifier(::std::boxed::Box<Identifier<'tree>>),
10976 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10977}
10978impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationName<'tree> {
10979 #[allow(clippy::collapsible_else_if)]
10980 fn from_node(
10981 node: ::treesitter_types::tree_sitter::Node<'tree>,
10982 src: &'tree [u8],
10983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10984 match node.kind() {
10985 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10986 ::treesitter_types::runtime::maybe_grow_stack(|| {
10987 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10988 })?,
10989 ))),
10990 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10991 ::treesitter_types::runtime::maybe_grow_stack(|| {
10992 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10993 })?,
10994 ))),
10995 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10996 }
10997 }
10998}
10999impl ::treesitter_types::Spanned for ModuleDeclarationName<'_> {
11000 fn span(&self) -> ::treesitter_types::Span {
11001 match self {
11002 Self::Identifier(inner) => inner.span(),
11003 Self::ScopedIdentifier(inner) => inner.span(),
11004 }
11005 }
11006}
11007#[derive(Debug, Clone, PartialEq, Eq)]
11008pub enum ModuleDeclarationChildren<'tree> {
11009 Annotation(::std::boxed::Box<Annotation<'tree>>),
11010 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11011}
11012impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationChildren<'tree> {
11013 #[allow(clippy::collapsible_else_if)]
11014 fn from_node(
11015 node: ::treesitter_types::tree_sitter::Node<'tree>,
11016 src: &'tree [u8],
11017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11018 match node.kind() {
11019 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11020 ::treesitter_types::runtime::maybe_grow_stack(|| {
11021 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11022 })?,
11023 ))),
11024 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11025 ::treesitter_types::runtime::maybe_grow_stack(|| {
11026 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11027 })?,
11028 ))),
11029 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11030 }
11031 }
11032}
11033impl ::treesitter_types::Spanned for ModuleDeclarationChildren<'_> {
11034 fn span(&self) -> ::treesitter_types::Span {
11035 match self {
11036 Self::Annotation(inner) => inner.span(),
11037 Self::MarkerAnnotation(inner) => inner.span(),
11038 }
11039 }
11040}
11041#[derive(Debug, Clone, PartialEq, Eq)]
11042pub enum ObjectCreationExpressionChildren<'tree> {
11043 Annotation(::std::boxed::Box<Annotation<'tree>>),
11044 ClassBody(::std::boxed::Box<ClassBody<'tree>>),
11045 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11046 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
11047}
11048impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpressionChildren<'tree> {
11049 #[allow(clippy::collapsible_else_if)]
11050 fn from_node(
11051 node: ::treesitter_types::tree_sitter::Node<'tree>,
11052 src: &'tree [u8],
11053 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11054 match node.kind() {
11055 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11056 ::treesitter_types::runtime::maybe_grow_stack(|| {
11057 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11058 })?,
11059 ))),
11060 "class_body" => Ok(Self::ClassBody(::std::boxed::Box::new(
11061 ::treesitter_types::runtime::maybe_grow_stack(|| {
11062 <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
11063 })?,
11064 ))),
11065 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11066 ::treesitter_types::runtime::maybe_grow_stack(|| {
11067 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11068 })?,
11069 ))),
11070 _other => {
11071 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11072 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11073 }) {
11074 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
11075 } else {
11076 Err(::treesitter_types::ParseError::unexpected_kind(
11077 _other, node,
11078 ))
11079 }
11080 }
11081 }
11082 }
11083}
11084impl ::treesitter_types::Spanned for ObjectCreationExpressionChildren<'_> {
11085 fn span(&self) -> ::treesitter_types::Span {
11086 match self {
11087 Self::Annotation(inner) => inner.span(),
11088 Self::ClassBody(inner) => inner.span(),
11089 Self::MarkerAnnotation(inner) => inner.span(),
11090 Self::PrimaryExpression(inner) => inner.span(),
11091 }
11092 }
11093}
11094#[derive(Debug, Clone, PartialEq, Eq)]
11095pub enum OpensModuleDirectiveModules<'tree> {
11096 Identifier(::std::boxed::Box<Identifier<'tree>>),
11097 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11098}
11099impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectiveModules<'tree> {
11100 #[allow(clippy::collapsible_else_if)]
11101 fn from_node(
11102 node: ::treesitter_types::tree_sitter::Node<'tree>,
11103 src: &'tree [u8],
11104 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11105 match node.kind() {
11106 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11107 ::treesitter_types::runtime::maybe_grow_stack(|| {
11108 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11109 })?,
11110 ))),
11111 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11112 ::treesitter_types::runtime::maybe_grow_stack(|| {
11113 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11114 })?,
11115 ))),
11116 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11117 }
11118 }
11119}
11120impl ::treesitter_types::Spanned for OpensModuleDirectiveModules<'_> {
11121 fn span(&self) -> ::treesitter_types::Span {
11122 match self {
11123 Self::Identifier(inner) => inner.span(),
11124 Self::ScopedIdentifier(inner) => inner.span(),
11125 }
11126 }
11127}
11128#[derive(Debug, Clone, PartialEq, Eq)]
11129pub enum OpensModuleDirectivePackage<'tree> {
11130 Identifier(::std::boxed::Box<Identifier<'tree>>),
11131 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11132}
11133impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectivePackage<'tree> {
11134 #[allow(clippy::collapsible_else_if)]
11135 fn from_node(
11136 node: ::treesitter_types::tree_sitter::Node<'tree>,
11137 src: &'tree [u8],
11138 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11139 match node.kind() {
11140 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11141 ::treesitter_types::runtime::maybe_grow_stack(|| {
11142 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11143 })?,
11144 ))),
11145 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11146 ::treesitter_types::runtime::maybe_grow_stack(|| {
11147 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11148 })?,
11149 ))),
11150 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11151 }
11152 }
11153}
11154impl ::treesitter_types::Spanned for OpensModuleDirectivePackage<'_> {
11155 fn span(&self) -> ::treesitter_types::Span {
11156 match self {
11157 Self::Identifier(inner) => inner.span(),
11158 Self::ScopedIdentifier(inner) => inner.span(),
11159 }
11160 }
11161}
11162#[derive(Debug, Clone, PartialEq, Eq)]
11163pub enum PackageDeclarationChildren<'tree> {
11164 Annotation(::std::boxed::Box<Annotation<'tree>>),
11165 Identifier(::std::boxed::Box<Identifier<'tree>>),
11166 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11167 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11168}
11169impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclarationChildren<'tree> {
11170 #[allow(clippy::collapsible_else_if)]
11171 fn from_node(
11172 node: ::treesitter_types::tree_sitter::Node<'tree>,
11173 src: &'tree [u8],
11174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11175 match node.kind() {
11176 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11177 ::treesitter_types::runtime::maybe_grow_stack(|| {
11178 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11179 })?,
11180 ))),
11181 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11182 ::treesitter_types::runtime::maybe_grow_stack(|| {
11183 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11184 })?,
11185 ))),
11186 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11187 ::treesitter_types::runtime::maybe_grow_stack(|| {
11188 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11189 })?,
11190 ))),
11191 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11192 ::treesitter_types::runtime::maybe_grow_stack(|| {
11193 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11194 })?,
11195 ))),
11196 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11197 }
11198 }
11199}
11200impl ::treesitter_types::Spanned for PackageDeclarationChildren<'_> {
11201 fn span(&self) -> ::treesitter_types::Span {
11202 match self {
11203 Self::Annotation(inner) => inner.span(),
11204 Self::Identifier(inner) => inner.span(),
11205 Self::MarkerAnnotation(inner) => inner.span(),
11206 Self::ScopedIdentifier(inner) => inner.span(),
11207 }
11208 }
11209}
11210#[derive(Debug, Clone, PartialEq, Eq)]
11211pub enum PatternChildren<'tree> {
11212 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
11213 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
11214}
11215impl<'tree> ::treesitter_types::FromNode<'tree> for PatternChildren<'tree> {
11216 #[allow(clippy::collapsible_else_if)]
11217 fn from_node(
11218 node: ::treesitter_types::tree_sitter::Node<'tree>,
11219 src: &'tree [u8],
11220 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11221 match node.kind() {
11222 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
11223 ::treesitter_types::runtime::maybe_grow_stack(|| {
11224 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)
11225 })?,
11226 ))),
11227 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
11228 ::treesitter_types::runtime::maybe_grow_stack(|| {
11229 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
11230 })?,
11231 ))),
11232 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11233 }
11234 }
11235}
11236impl ::treesitter_types::Spanned for PatternChildren<'_> {
11237 fn span(&self) -> ::treesitter_types::Span {
11238 match self {
11239 Self::RecordPattern(inner) => inner.span(),
11240 Self::TypePattern(inner) => inner.span(),
11241 }
11242 }
11243}
11244#[derive(Debug, Clone, PartialEq, Eq)]
11245pub enum ProgramChildren<'tree> {
11246 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
11247 Statement(::std::boxed::Box<Statement<'tree>>),
11248}
11249impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
11250 #[allow(clippy::collapsible_else_if)]
11251 fn from_node(
11252 node: ::treesitter_types::tree_sitter::Node<'tree>,
11253 src: &'tree [u8],
11254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11255 match node.kind() {
11256 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
11257 ::treesitter_types::runtime::maybe_grow_stack(|| {
11258 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11259 })?,
11260 ))),
11261 _other => {
11262 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11263 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11264 }) {
11265 Ok(Self::Statement(::std::boxed::Box::new(v)))
11266 } else {
11267 Err(::treesitter_types::ParseError::unexpected_kind(
11268 _other, node,
11269 ))
11270 }
11271 }
11272 }
11273 }
11274}
11275impl ::treesitter_types::Spanned for ProgramChildren<'_> {
11276 fn span(&self) -> ::treesitter_types::Span {
11277 match self {
11278 Self::MethodDeclaration(inner) => inner.span(),
11279 Self::Statement(inner) => inner.span(),
11280 }
11281 }
11282}
11283#[derive(Debug, Clone, PartialEq, Eq)]
11284pub enum ProvidesModuleDirectiveProvided<'tree> {
11285 Identifier(::std::boxed::Box<Identifier<'tree>>),
11286 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11287}
11288impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvided<'tree> {
11289 #[allow(clippy::collapsible_else_if)]
11290 fn from_node(
11291 node: ::treesitter_types::tree_sitter::Node<'tree>,
11292 src: &'tree [u8],
11293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11294 match node.kind() {
11295 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11296 ::treesitter_types::runtime::maybe_grow_stack(|| {
11297 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11298 })?,
11299 ))),
11300 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11301 ::treesitter_types::runtime::maybe_grow_stack(|| {
11302 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11303 })?,
11304 ))),
11305 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11306 }
11307 }
11308}
11309impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvided<'_> {
11310 fn span(&self) -> ::treesitter_types::Span {
11311 match self {
11312 Self::Identifier(inner) => inner.span(),
11313 Self::ScopedIdentifier(inner) => inner.span(),
11314 }
11315 }
11316}
11317#[derive(Debug, Clone, PartialEq, Eq)]
11318pub enum ProvidesModuleDirectiveProvider<'tree> {
11319 Identifier(::std::boxed::Box<Identifier<'tree>>),
11320 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11321}
11322impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvider<'tree> {
11323 #[allow(clippy::collapsible_else_if)]
11324 fn from_node(
11325 node: ::treesitter_types::tree_sitter::Node<'tree>,
11326 src: &'tree [u8],
11327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11328 match node.kind() {
11329 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11330 ::treesitter_types::runtime::maybe_grow_stack(|| {
11331 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11332 })?,
11333 ))),
11334 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11335 ::treesitter_types::runtime::maybe_grow_stack(|| {
11336 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11337 })?,
11338 ))),
11339 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11340 }
11341 }
11342}
11343impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvider<'_> {
11344 fn span(&self) -> ::treesitter_types::Span {
11345 match self {
11346 Self::Identifier(inner) => inner.span(),
11347 Self::ScopedIdentifier(inner) => inner.span(),
11348 }
11349 }
11350}
11351#[derive(Debug, Clone, PartialEq, Eq)]
11352pub enum ProvidesModuleDirectiveChildren<'tree> {
11353 Identifier(::std::boxed::Box<Identifier<'tree>>),
11354 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11355}
11356impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveChildren<'tree> {
11357 #[allow(clippy::collapsible_else_if)]
11358 fn from_node(
11359 node: ::treesitter_types::tree_sitter::Node<'tree>,
11360 src: &'tree [u8],
11361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11362 match node.kind() {
11363 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11364 ::treesitter_types::runtime::maybe_grow_stack(|| {
11365 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11366 })?,
11367 ))),
11368 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11369 ::treesitter_types::runtime::maybe_grow_stack(|| {
11370 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11371 })?,
11372 ))),
11373 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11374 }
11375 }
11376}
11377impl ::treesitter_types::Spanned for ProvidesModuleDirectiveChildren<'_> {
11378 fn span(&self) -> ::treesitter_types::Span {
11379 match self {
11380 Self::Identifier(inner) => inner.span(),
11381 Self::ScopedIdentifier(inner) => inner.span(),
11382 }
11383 }
11384}
11385#[derive(Debug, Clone, PartialEq, Eq)]
11386pub enum ReceiverParameterChildren<'tree> {
11387 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
11388 Annotation(::std::boxed::Box<Annotation<'tree>>),
11389 Identifier(::std::boxed::Box<Identifier<'tree>>),
11390 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11391 This(::std::boxed::Box<This<'tree>>),
11392}
11393impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameterChildren<'tree> {
11394 #[allow(clippy::collapsible_else_if)]
11395 fn from_node(
11396 node: ::treesitter_types::tree_sitter::Node<'tree>,
11397 src: &'tree [u8],
11398 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11399 match node.kind() {
11400 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11401 ::treesitter_types::runtime::maybe_grow_stack(|| {
11402 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11403 })?,
11404 ))),
11405 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11406 ::treesitter_types::runtime::maybe_grow_stack(|| {
11407 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11408 })?,
11409 ))),
11410 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11411 ::treesitter_types::runtime::maybe_grow_stack(|| {
11412 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11413 })?,
11414 ))),
11415 "this" => Ok(Self::This(::std::boxed::Box::new(
11416 ::treesitter_types::runtime::maybe_grow_stack(|| {
11417 <This as ::treesitter_types::FromNode>::from_node(node, src)
11418 })?,
11419 ))),
11420 _other => {
11421 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11422 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11423 }) {
11424 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
11425 } else {
11426 Err(::treesitter_types::ParseError::unexpected_kind(
11427 _other, node,
11428 ))
11429 }
11430 }
11431 }
11432 }
11433}
11434impl ::treesitter_types::Spanned for ReceiverParameterChildren<'_> {
11435 fn span(&self) -> ::treesitter_types::Span {
11436 match self {
11437 Self::UnannotatedType(inner) => inner.span(),
11438 Self::Annotation(inner) => inner.span(),
11439 Self::Identifier(inner) => inner.span(),
11440 Self::MarkerAnnotation(inner) => inner.span(),
11441 Self::This(inner) => inner.span(),
11442 }
11443 }
11444}
11445#[derive(Debug, Clone, PartialEq, Eq)]
11446pub enum RecordPatternChildren<'tree> {
11447 GenericType(::std::boxed::Box<GenericType<'tree>>),
11448 Identifier(::std::boxed::Box<Identifier<'tree>>),
11449 RecordPatternBody(::std::boxed::Box<RecordPatternBody<'tree>>),
11450}
11451impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternChildren<'tree> {
11452 #[allow(clippy::collapsible_else_if)]
11453 fn from_node(
11454 node: ::treesitter_types::tree_sitter::Node<'tree>,
11455 src: &'tree [u8],
11456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11457 match node.kind() {
11458 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11459 ::treesitter_types::runtime::maybe_grow_stack(|| {
11460 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
11461 })?,
11462 ))),
11463 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11464 ::treesitter_types::runtime::maybe_grow_stack(|| {
11465 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11466 })?,
11467 ))),
11468 "record_pattern_body" => Ok(Self::RecordPatternBody(::std::boxed::Box::new(
11469 ::treesitter_types::runtime::maybe_grow_stack(|| {
11470 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)
11471 })?,
11472 ))),
11473 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11474 }
11475 }
11476}
11477impl ::treesitter_types::Spanned for RecordPatternChildren<'_> {
11478 fn span(&self) -> ::treesitter_types::Span {
11479 match self {
11480 Self::GenericType(inner) => inner.span(),
11481 Self::Identifier(inner) => inner.span(),
11482 Self::RecordPatternBody(inner) => inner.span(),
11483 }
11484 }
11485}
11486#[derive(Debug, Clone, PartialEq, Eq)]
11487pub enum RecordPatternBodyChildren<'tree> {
11488 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
11489 RecordPatternComponent(::std::boxed::Box<RecordPatternComponent<'tree>>),
11490}
11491impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBodyChildren<'tree> {
11492 #[allow(clippy::collapsible_else_if)]
11493 fn from_node(
11494 node: ::treesitter_types::tree_sitter::Node<'tree>,
11495 src: &'tree [u8],
11496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11497 match node.kind() {
11498 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
11499 ::treesitter_types::runtime::maybe_grow_stack(|| {
11500 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)
11501 })?,
11502 ))),
11503 "record_pattern_component" => Ok(Self::RecordPatternComponent(::std::boxed::Box::new(
11504 ::treesitter_types::runtime::maybe_grow_stack(|| {
11505 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)
11506 })?,
11507 ))),
11508 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11509 }
11510 }
11511}
11512impl ::treesitter_types::Spanned for RecordPatternBodyChildren<'_> {
11513 fn span(&self) -> ::treesitter_types::Span {
11514 match self {
11515 Self::RecordPattern(inner) => inner.span(),
11516 Self::RecordPatternComponent(inner) => inner.span(),
11517 }
11518 }
11519}
11520#[derive(Debug, Clone, PartialEq, Eq)]
11521pub enum RecordPatternComponentChildren<'tree> {
11522 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
11523 Identifier(::std::boxed::Box<Identifier<'tree>>),
11524 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
11525}
11526impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponentChildren<'tree> {
11527 #[allow(clippy::collapsible_else_if)]
11528 fn from_node(
11529 node: ::treesitter_types::tree_sitter::Node<'tree>,
11530 src: &'tree [u8],
11531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11532 match node.kind() {
11533 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11534 ::treesitter_types::runtime::maybe_grow_stack(|| {
11535 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11536 })?,
11537 ))),
11538 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
11539 ::treesitter_types::runtime::maybe_grow_stack(|| {
11540 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
11541 })?,
11542 ))),
11543 _other => {
11544 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11545 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11546 }) {
11547 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
11548 } else {
11549 Err(::treesitter_types::ParseError::unexpected_kind(
11550 _other, node,
11551 ))
11552 }
11553 }
11554 }
11555 }
11556}
11557impl ::treesitter_types::Spanned for RecordPatternComponentChildren<'_> {
11558 fn span(&self) -> ::treesitter_types::Span {
11559 match self {
11560 Self::UnannotatedType(inner) => inner.span(),
11561 Self::Identifier(inner) => inner.span(),
11562 Self::UnderscorePattern(inner) => inner.span(),
11563 }
11564 }
11565}
11566#[derive(Debug, Clone, PartialEq, Eq)]
11567pub enum RequiresModuleDirectiveModule<'tree> {
11568 Identifier(::std::boxed::Box<Identifier<'tree>>),
11569 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11570}
11571impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirectiveModule<'tree> {
11572 #[allow(clippy::collapsible_else_if)]
11573 fn from_node(
11574 node: ::treesitter_types::tree_sitter::Node<'tree>,
11575 src: &'tree [u8],
11576 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11577 match node.kind() {
11578 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11579 ::treesitter_types::runtime::maybe_grow_stack(|| {
11580 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11581 })?,
11582 ))),
11583 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11584 ::treesitter_types::runtime::maybe_grow_stack(|| {
11585 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11586 })?,
11587 ))),
11588 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11589 }
11590 }
11591}
11592impl ::treesitter_types::Spanned for RequiresModuleDirectiveModule<'_> {
11593 fn span(&self) -> ::treesitter_types::Span {
11594 match self {
11595 Self::Identifier(inner) => inner.span(),
11596 Self::ScopedIdentifier(inner) => inner.span(),
11597 }
11598 }
11599}
11600#[derive(Debug, Clone, PartialEq, Eq)]
11601pub enum ResourceName<'tree> {
11602 Identifier(::std::boxed::Box<Identifier<'tree>>),
11603 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
11604}
11605impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceName<'tree> {
11606 #[allow(clippy::collapsible_else_if)]
11607 fn from_node(
11608 node: ::treesitter_types::tree_sitter::Node<'tree>,
11609 src: &'tree [u8],
11610 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11611 match node.kind() {
11612 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11613 ::treesitter_types::runtime::maybe_grow_stack(|| {
11614 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11615 })?,
11616 ))),
11617 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
11618 ::treesitter_types::runtime::maybe_grow_stack(|| {
11619 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
11620 })?,
11621 ))),
11622 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11623 }
11624 }
11625}
11626impl ::treesitter_types::Spanned for ResourceName<'_> {
11627 fn span(&self) -> ::treesitter_types::Span {
11628 match self {
11629 Self::Identifier(inner) => inner.span(),
11630 Self::UnderscorePattern(inner) => inner.span(),
11631 }
11632 }
11633}
11634#[derive(Debug, Clone, PartialEq, Eq)]
11635pub enum ResourceChildren<'tree> {
11636 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
11637 Identifier(::std::boxed::Box<Identifier<'tree>>),
11638 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
11639}
11640impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceChildren<'tree> {
11641 #[allow(clippy::collapsible_else_if)]
11642 fn from_node(
11643 node: ::treesitter_types::tree_sitter::Node<'tree>,
11644 src: &'tree [u8],
11645 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11646 match node.kind() {
11647 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
11648 ::treesitter_types::runtime::maybe_grow_stack(|| {
11649 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
11650 })?,
11651 ))),
11652 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11653 ::treesitter_types::runtime::maybe_grow_stack(|| {
11654 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11655 })?,
11656 ))),
11657 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
11658 ::treesitter_types::runtime::maybe_grow_stack(|| {
11659 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
11660 })?,
11661 ))),
11662 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11663 }
11664 }
11665}
11666impl ::treesitter_types::Spanned for ResourceChildren<'_> {
11667 fn span(&self) -> ::treesitter_types::Span {
11668 match self {
11669 Self::FieldAccess(inner) => inner.span(),
11670 Self::Identifier(inner) => inner.span(),
11671 Self::Modifiers(inner) => inner.span(),
11672 }
11673 }
11674}
11675#[derive(Debug, Clone, PartialEq, Eq)]
11676pub enum ScopedIdentifierScope<'tree> {
11677 Identifier(::std::boxed::Box<Identifier<'tree>>),
11678 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11679}
11680impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierScope<'tree> {
11681 #[allow(clippy::collapsible_else_if)]
11682 fn from_node(
11683 node: ::treesitter_types::tree_sitter::Node<'tree>,
11684 src: &'tree [u8],
11685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11686 match node.kind() {
11687 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11688 ::treesitter_types::runtime::maybe_grow_stack(|| {
11689 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11690 })?,
11691 ))),
11692 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11693 ::treesitter_types::runtime::maybe_grow_stack(|| {
11694 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11695 })?,
11696 ))),
11697 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11698 }
11699 }
11700}
11701impl ::treesitter_types::Spanned for ScopedIdentifierScope<'_> {
11702 fn span(&self) -> ::treesitter_types::Span {
11703 match self {
11704 Self::Identifier(inner) => inner.span(),
11705 Self::ScopedIdentifier(inner) => inner.span(),
11706 }
11707 }
11708}
11709#[derive(Debug, Clone, PartialEq, Eq)]
11710pub enum ScopedTypeIdentifierChildren<'tree> {
11711 Annotation(::std::boxed::Box<Annotation<'tree>>),
11712 GenericType(::std::boxed::Box<GenericType<'tree>>),
11713 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11714 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11715 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11716}
11717impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierChildren<'tree> {
11718 #[allow(clippy::collapsible_else_if)]
11719 fn from_node(
11720 node: ::treesitter_types::tree_sitter::Node<'tree>,
11721 src: &'tree [u8],
11722 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11723 match node.kind() {
11724 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11725 ::treesitter_types::runtime::maybe_grow_stack(|| {
11726 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11727 })?,
11728 ))),
11729 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11730 ::treesitter_types::runtime::maybe_grow_stack(|| {
11731 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
11732 })?,
11733 ))),
11734 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11735 ::treesitter_types::runtime::maybe_grow_stack(|| {
11736 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11737 })?,
11738 ))),
11739 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11740 ::treesitter_types::runtime::maybe_grow_stack(|| {
11741 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11742 })?,
11743 ))),
11744 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11745 ::treesitter_types::runtime::maybe_grow_stack(|| {
11746 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11747 })?,
11748 ))),
11749 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11750 }
11751 }
11752}
11753impl ::treesitter_types::Spanned for ScopedTypeIdentifierChildren<'_> {
11754 fn span(&self) -> ::treesitter_types::Span {
11755 match self {
11756 Self::Annotation(inner) => inner.span(),
11757 Self::GenericType(inner) => inner.span(),
11758 Self::MarkerAnnotation(inner) => inner.span(),
11759 Self::ScopedTypeIdentifier(inner) => inner.span(),
11760 Self::TypeIdentifier(inner) => inner.span(),
11761 }
11762 }
11763}
11764#[derive(Debug, Clone, PartialEq, Eq)]
11765pub enum SpreadParameterChildren<'tree> {
11766 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
11767 Annotation(::std::boxed::Box<Annotation<'tree>>),
11768 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11769 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
11770 VariableDeclarator(::std::boxed::Box<VariableDeclarator<'tree>>),
11771}
11772impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameterChildren<'tree> {
11773 #[allow(clippy::collapsible_else_if)]
11774 fn from_node(
11775 node: ::treesitter_types::tree_sitter::Node<'tree>,
11776 src: &'tree [u8],
11777 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11778 match node.kind() {
11779 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11780 ::treesitter_types::runtime::maybe_grow_stack(|| {
11781 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11782 })?,
11783 ))),
11784 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11785 ::treesitter_types::runtime::maybe_grow_stack(|| {
11786 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11787 })?,
11788 ))),
11789 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
11790 ::treesitter_types::runtime::maybe_grow_stack(|| {
11791 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
11792 })?,
11793 ))),
11794 "variable_declarator" => Ok(Self::VariableDeclarator(::std::boxed::Box::new(
11795 ::treesitter_types::runtime::maybe_grow_stack(|| {
11796 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11797 })?,
11798 ))),
11799 _other => {
11800 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11801 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11802 }) {
11803 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
11804 } else {
11805 Err(::treesitter_types::ParseError::unexpected_kind(
11806 _other, node,
11807 ))
11808 }
11809 }
11810 }
11811 }
11812}
11813impl ::treesitter_types::Spanned for SpreadParameterChildren<'_> {
11814 fn span(&self) -> ::treesitter_types::Span {
11815 match self {
11816 Self::UnannotatedType(inner) => inner.span(),
11817 Self::Annotation(inner) => inner.span(),
11818 Self::MarkerAnnotation(inner) => inner.span(),
11819 Self::Modifiers(inner) => inner.span(),
11820 Self::VariableDeclarator(inner) => inner.span(),
11821 }
11822 }
11823}
11824#[derive(Debug, Clone, PartialEq, Eq)]
11825pub enum StringLiteralChildren<'tree> {
11826 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11827 MultilineStringFragment(::std::boxed::Box<MultilineStringFragment<'tree>>),
11828 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
11829 StringInterpolation(::std::boxed::Box<StringInterpolation<'tree>>),
11830}
11831impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
11832 #[allow(clippy::collapsible_else_if)]
11833 fn from_node(
11834 node: ::treesitter_types::tree_sitter::Node<'tree>,
11835 src: &'tree [u8],
11836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11837 match node.kind() {
11838 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11839 ::treesitter_types::runtime::maybe_grow_stack(|| {
11840 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
11841 })?,
11842 ))),
11843 "multiline_string_fragment" => Ok(Self::MultilineStringFragment(
11844 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11845 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(node, src)
11846 })?),
11847 )),
11848 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
11849 ::treesitter_types::runtime::maybe_grow_stack(|| {
11850 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
11851 })?,
11852 ))),
11853 "string_interpolation" => Ok(Self::StringInterpolation(::std::boxed::Box::new(
11854 ::treesitter_types::runtime::maybe_grow_stack(|| {
11855 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
11856 })?,
11857 ))),
11858 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11859 }
11860 }
11861}
11862impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
11863 fn span(&self) -> ::treesitter_types::Span {
11864 match self {
11865 Self::EscapeSequence(inner) => inner.span(),
11866 Self::MultilineStringFragment(inner) => inner.span(),
11867 Self::StringFragment(inner) => inner.span(),
11868 Self::StringInterpolation(inner) => inner.span(),
11869 }
11870 }
11871}
11872#[derive(Debug, Clone, PartialEq, Eq)]
11873pub enum SwitchBlockChildren<'tree> {
11874 SwitchBlockStatementGroup(::std::boxed::Box<SwitchBlockStatementGroup<'tree>>),
11875 SwitchRule(::std::boxed::Box<SwitchRule<'tree>>),
11876}
11877impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockChildren<'tree> {
11878 #[allow(clippy::collapsible_else_if)]
11879 fn from_node(
11880 node: ::treesitter_types::tree_sitter::Node<'tree>,
11881 src: &'tree [u8],
11882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11883 match node.kind() {
11884 "switch_block_statement_group" => Ok(Self::SwitchBlockStatementGroup(
11885 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11886 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(
11887 node, src,
11888 )
11889 })?),
11890 )),
11891 "switch_rule" => Ok(Self::SwitchRule(::std::boxed::Box::new(
11892 ::treesitter_types::runtime::maybe_grow_stack(|| {
11893 <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)
11894 })?,
11895 ))),
11896 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11897 }
11898 }
11899}
11900impl ::treesitter_types::Spanned for SwitchBlockChildren<'_> {
11901 fn span(&self) -> ::treesitter_types::Span {
11902 match self {
11903 Self::SwitchBlockStatementGroup(inner) => inner.span(),
11904 Self::SwitchRule(inner) => inner.span(),
11905 }
11906 }
11907}
11908#[derive(Debug, Clone, PartialEq, Eq)]
11909pub enum SwitchBlockStatementGroupChildren<'tree> {
11910 Statement(::std::boxed::Box<Statement<'tree>>),
11911 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
11912}
11913impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroupChildren<'tree> {
11914 #[allow(clippy::collapsible_else_if)]
11915 fn from_node(
11916 node: ::treesitter_types::tree_sitter::Node<'tree>,
11917 src: &'tree [u8],
11918 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11919 match node.kind() {
11920 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
11921 ::treesitter_types::runtime::maybe_grow_stack(|| {
11922 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)
11923 })?,
11924 ))),
11925 _other => {
11926 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11927 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11928 }) {
11929 Ok(Self::Statement(::std::boxed::Box::new(v)))
11930 } else {
11931 Err(::treesitter_types::ParseError::unexpected_kind(
11932 _other, node,
11933 ))
11934 }
11935 }
11936 }
11937 }
11938}
11939impl ::treesitter_types::Spanned for SwitchBlockStatementGroupChildren<'_> {
11940 fn span(&self) -> ::treesitter_types::Span {
11941 match self {
11942 Self::Statement(inner) => inner.span(),
11943 Self::SwitchLabel(inner) => inner.span(),
11944 }
11945 }
11946}
11947#[derive(Debug, Clone, PartialEq, Eq)]
11948pub enum SwitchLabelChildren<'tree> {
11949 Expression(::std::boxed::Box<Expression<'tree>>),
11950 Guard(::std::boxed::Box<Guard<'tree>>),
11951 Pattern(::std::boxed::Box<Pattern<'tree>>),
11952}
11953impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabelChildren<'tree> {
11954 #[allow(clippy::collapsible_else_if)]
11955 fn from_node(
11956 node: ::treesitter_types::tree_sitter::Node<'tree>,
11957 src: &'tree [u8],
11958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11959 match node.kind() {
11960 "guard" => Ok(Self::Guard(::std::boxed::Box::new(
11961 ::treesitter_types::runtime::maybe_grow_stack(|| {
11962 <Guard as ::treesitter_types::FromNode>::from_node(node, src)
11963 })?,
11964 ))),
11965 "pattern" => Ok(Self::Pattern(::std::boxed::Box::new(
11966 ::treesitter_types::runtime::maybe_grow_stack(|| {
11967 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
11968 })?,
11969 ))),
11970 _other => {
11971 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11972 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11973 }) {
11974 Ok(Self::Expression(::std::boxed::Box::new(v)))
11975 } else {
11976 Err(::treesitter_types::ParseError::unexpected_kind(
11977 _other, node,
11978 ))
11979 }
11980 }
11981 }
11982 }
11983}
11984impl ::treesitter_types::Spanned for SwitchLabelChildren<'_> {
11985 fn span(&self) -> ::treesitter_types::Span {
11986 match self {
11987 Self::Expression(inner) => inner.span(),
11988 Self::Guard(inner) => inner.span(),
11989 Self::Pattern(inner) => inner.span(),
11990 }
11991 }
11992}
11993#[derive(Debug, Clone, PartialEq, Eq)]
11994pub enum SwitchRuleChildren<'tree> {
11995 Block(::std::boxed::Box<Block<'tree>>),
11996 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
11997 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
11998 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
11999}
12000impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRuleChildren<'tree> {
12001 #[allow(clippy::collapsible_else_if)]
12002 fn from_node(
12003 node: ::treesitter_types::tree_sitter::Node<'tree>,
12004 src: &'tree [u8],
12005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12006 match node.kind() {
12007 "block" => Ok(Self::Block(::std::boxed::Box::new(
12008 ::treesitter_types::runtime::maybe_grow_stack(|| {
12009 <Block as ::treesitter_types::FromNode>::from_node(node, src)
12010 })?,
12011 ))),
12012 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
12013 ::treesitter_types::runtime::maybe_grow_stack(|| {
12014 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
12015 })?,
12016 ))),
12017 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
12018 ::treesitter_types::runtime::maybe_grow_stack(|| {
12019 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)
12020 })?,
12021 ))),
12022 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
12023 ::treesitter_types::runtime::maybe_grow_stack(|| {
12024 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
12025 })?,
12026 ))),
12027 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12028 }
12029 }
12030}
12031impl ::treesitter_types::Spanned for SwitchRuleChildren<'_> {
12032 fn span(&self) -> ::treesitter_types::Span {
12033 match self {
12034 Self::Block(inner) => inner.span(),
12035 Self::ExpressionStatement(inner) => inner.span(),
12036 Self::SwitchLabel(inner) => inner.span(),
12037 Self::ThrowStatement(inner) => inner.span(),
12038 }
12039 }
12040}
12041#[derive(Debug, Clone, PartialEq, Eq)]
12042pub enum TryStatementChildren<'tree> {
12043 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
12044 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
12045}
12046impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
12047 #[allow(clippy::collapsible_else_if)]
12048 fn from_node(
12049 node: ::treesitter_types::tree_sitter::Node<'tree>,
12050 src: &'tree [u8],
12051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12052 match node.kind() {
12053 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
12054 ::treesitter_types::runtime::maybe_grow_stack(|| {
12055 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
12056 })?,
12057 ))),
12058 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
12059 ::treesitter_types::runtime::maybe_grow_stack(|| {
12060 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
12061 })?,
12062 ))),
12063 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12064 }
12065 }
12066}
12067impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
12068 fn span(&self) -> ::treesitter_types::Span {
12069 match self {
12070 Self::CatchClause(inner) => inner.span(),
12071 Self::FinallyClause(inner) => inner.span(),
12072 }
12073 }
12074}
12075#[derive(Debug, Clone, PartialEq, Eq)]
12076pub enum TryWithResourcesStatementChildren<'tree> {
12077 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
12078 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
12079}
12080impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatementChildren<'tree> {
12081 #[allow(clippy::collapsible_else_if)]
12082 fn from_node(
12083 node: ::treesitter_types::tree_sitter::Node<'tree>,
12084 src: &'tree [u8],
12085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12086 match node.kind() {
12087 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
12088 ::treesitter_types::runtime::maybe_grow_stack(|| {
12089 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
12090 })?,
12091 ))),
12092 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
12093 ::treesitter_types::runtime::maybe_grow_stack(|| {
12094 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
12095 })?,
12096 ))),
12097 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12098 }
12099 }
12100}
12101impl ::treesitter_types::Spanned for TryWithResourcesStatementChildren<'_> {
12102 fn span(&self) -> ::treesitter_types::Span {
12103 match self {
12104 Self::CatchClause(inner) => inner.span(),
12105 Self::FinallyClause(inner) => inner.span(),
12106 }
12107 }
12108}
12109#[derive(Debug, Clone, PartialEq, Eq)]
12110pub enum TypeArgumentsChildren<'tree> {
12111 Type(::std::boxed::Box<Type<'tree>>),
12112 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
12113}
12114impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
12115 #[allow(clippy::collapsible_else_if)]
12116 fn from_node(
12117 node: ::treesitter_types::tree_sitter::Node<'tree>,
12118 src: &'tree [u8],
12119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12120 match node.kind() {
12121 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
12122 ::treesitter_types::runtime::maybe_grow_stack(|| {
12123 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
12124 })?,
12125 ))),
12126 _other => {
12127 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12128 <Type as ::treesitter_types::FromNode>::from_node(node, src)
12129 }) {
12130 Ok(Self::Type(::std::boxed::Box::new(v)))
12131 } else {
12132 Err(::treesitter_types::ParseError::unexpected_kind(
12133 _other, node,
12134 ))
12135 }
12136 }
12137 }
12138 }
12139}
12140impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
12141 fn span(&self) -> ::treesitter_types::Span {
12142 match self {
12143 Self::Type(inner) => inner.span(),
12144 Self::Wildcard(inner) => inner.span(),
12145 }
12146 }
12147}
12148#[derive(Debug, Clone, PartialEq, Eq)]
12149pub enum TypeParameterChildren<'tree> {
12150 Annotation(::std::boxed::Box<Annotation<'tree>>),
12151 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
12152 TypeBound(::std::boxed::Box<TypeBound<'tree>>),
12153 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12154}
12155impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterChildren<'tree> {
12156 #[allow(clippy::collapsible_else_if)]
12157 fn from_node(
12158 node: ::treesitter_types::tree_sitter::Node<'tree>,
12159 src: &'tree [u8],
12160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12161 match node.kind() {
12162 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
12163 ::treesitter_types::runtime::maybe_grow_stack(|| {
12164 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
12165 })?,
12166 ))),
12167 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
12168 ::treesitter_types::runtime::maybe_grow_stack(|| {
12169 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
12170 })?,
12171 ))),
12172 "type_bound" => Ok(Self::TypeBound(::std::boxed::Box::new(
12173 ::treesitter_types::runtime::maybe_grow_stack(|| {
12174 <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)
12175 })?,
12176 ))),
12177 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12178 ::treesitter_types::runtime::maybe_grow_stack(|| {
12179 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12180 })?,
12181 ))),
12182 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12183 }
12184 }
12185}
12186impl ::treesitter_types::Spanned for TypeParameterChildren<'_> {
12187 fn span(&self) -> ::treesitter_types::Span {
12188 match self {
12189 Self::Annotation(inner) => inner.span(),
12190 Self::MarkerAnnotation(inner) => inner.span(),
12191 Self::TypeBound(inner) => inner.span(),
12192 Self::TypeIdentifier(inner) => inner.span(),
12193 }
12194 }
12195}
12196#[derive(Debug, Clone, PartialEq, Eq)]
12197pub enum TypePatternChildren<'tree> {
12198 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
12199 Identifier(::std::boxed::Box<Identifier<'tree>>),
12200}
12201impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatternChildren<'tree> {
12202 #[allow(clippy::collapsible_else_if)]
12203 fn from_node(
12204 node: ::treesitter_types::tree_sitter::Node<'tree>,
12205 src: &'tree [u8],
12206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12207 match node.kind() {
12208 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12209 ::treesitter_types::runtime::maybe_grow_stack(|| {
12210 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12211 })?,
12212 ))),
12213 _other => {
12214 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12215 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
12216 }) {
12217 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
12218 } else {
12219 Err(::treesitter_types::ParseError::unexpected_kind(
12220 _other, node,
12221 ))
12222 }
12223 }
12224 }
12225 }
12226}
12227impl ::treesitter_types::Spanned for TypePatternChildren<'_> {
12228 fn span(&self) -> ::treesitter_types::Span {
12229 match self {
12230 Self::UnannotatedType(inner) => inner.span(),
12231 Self::Identifier(inner) => inner.span(),
12232 }
12233 }
12234}
12235#[derive(Debug, Clone, PartialEq, Eq)]
12236pub enum UnaryExpressionOperator {
12237 Bang(::treesitter_types::Span),
12238 Plus(::treesitter_types::Span),
12239 Minus(::treesitter_types::Span),
12240 Tilde(::treesitter_types::Span),
12241}
12242impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
12243 #[allow(clippy::collapsible_else_if)]
12244 fn from_node(
12245 node: ::treesitter_types::tree_sitter::Node<'tree>,
12246 _src: &'tree [u8],
12247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12248 match node.kind() {
12249 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
12250 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
12251 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
12252 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
12253 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12254 }
12255 }
12256}
12257impl ::treesitter_types::Spanned for UnaryExpressionOperator {
12258 fn span(&self) -> ::treesitter_types::Span {
12259 match self {
12260 Self::Bang(span) => *span,
12261 Self::Plus(span) => *span,
12262 Self::Minus(span) => *span,
12263 Self::Tilde(span) => *span,
12264 }
12265 }
12266}
12267#[derive(Debug, Clone, PartialEq, Eq)]
12268pub enum UsesModuleDirectiveType<'tree> {
12269 Identifier(::std::boxed::Box<Identifier<'tree>>),
12270 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12271}
12272impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirectiveType<'tree> {
12273 #[allow(clippy::collapsible_else_if)]
12274 fn from_node(
12275 node: ::treesitter_types::tree_sitter::Node<'tree>,
12276 src: &'tree [u8],
12277 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12278 match node.kind() {
12279 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12280 ::treesitter_types::runtime::maybe_grow_stack(|| {
12281 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12282 })?,
12283 ))),
12284 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12285 ::treesitter_types::runtime::maybe_grow_stack(|| {
12286 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12287 })?,
12288 ))),
12289 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12290 }
12291 }
12292}
12293impl ::treesitter_types::Spanned for UsesModuleDirectiveType<'_> {
12294 fn span(&self) -> ::treesitter_types::Span {
12295 match self {
12296 Self::Identifier(inner) => inner.span(),
12297 Self::ScopedIdentifier(inner) => inner.span(),
12298 }
12299 }
12300}
12301#[derive(Debug, Clone, PartialEq, Eq)]
12302pub enum VariableDeclaratorName<'tree> {
12303 Identifier(::std::boxed::Box<Identifier<'tree>>),
12304 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
12305}
12306impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
12307 #[allow(clippy::collapsible_else_if)]
12308 fn from_node(
12309 node: ::treesitter_types::tree_sitter::Node<'tree>,
12310 src: &'tree [u8],
12311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12312 match node.kind() {
12313 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12314 ::treesitter_types::runtime::maybe_grow_stack(|| {
12315 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12316 })?,
12317 ))),
12318 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
12319 ::treesitter_types::runtime::maybe_grow_stack(|| {
12320 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
12321 })?,
12322 ))),
12323 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12324 }
12325 }
12326}
12327impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
12328 fn span(&self) -> ::treesitter_types::Span {
12329 match self {
12330 Self::Identifier(inner) => inner.span(),
12331 Self::UnderscorePattern(inner) => inner.span(),
12332 }
12333 }
12334}
12335#[derive(Debug, Clone, PartialEq, Eq)]
12336pub enum VariableDeclaratorValue<'tree> {
12337 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
12338 Expression(::std::boxed::Box<Expression<'tree>>),
12339}
12340impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorValue<'tree> {
12341 #[allow(clippy::collapsible_else_if)]
12342 fn from_node(
12343 node: ::treesitter_types::tree_sitter::Node<'tree>,
12344 src: &'tree [u8],
12345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12346 match node.kind() {
12347 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
12348 ::treesitter_types::runtime::maybe_grow_stack(|| {
12349 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12350 })?,
12351 ))),
12352 _other => {
12353 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12354 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12355 }) {
12356 Ok(Self::Expression(::std::boxed::Box::new(v)))
12357 } else {
12358 Err(::treesitter_types::ParseError::unexpected_kind(
12359 _other, node,
12360 ))
12361 }
12362 }
12363 }
12364 }
12365}
12366impl ::treesitter_types::Spanned for VariableDeclaratorValue<'_> {
12367 fn span(&self) -> ::treesitter_types::Span {
12368 match self {
12369 Self::ArrayInitializer(inner) => inner.span(),
12370 Self::Expression(inner) => inner.span(),
12371 }
12372 }
12373}
12374#[derive(Debug, Clone, PartialEq, Eq)]
12375pub enum WildcardChildren<'tree> {
12376 Type(::std::boxed::Box<Type<'tree>>),
12377 Annotation(::std::boxed::Box<Annotation<'tree>>),
12378 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
12379 Super(::std::boxed::Box<Super<'tree>>),
12380}
12381impl<'tree> ::treesitter_types::FromNode<'tree> for WildcardChildren<'tree> {
12382 #[allow(clippy::collapsible_else_if)]
12383 fn from_node(
12384 node: ::treesitter_types::tree_sitter::Node<'tree>,
12385 src: &'tree [u8],
12386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12387 match node.kind() {
12388 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
12389 ::treesitter_types::runtime::maybe_grow_stack(|| {
12390 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
12391 })?,
12392 ))),
12393 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
12394 ::treesitter_types::runtime::maybe_grow_stack(|| {
12395 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
12396 })?,
12397 ))),
12398 "super" => Ok(Self::Super(::std::boxed::Box::new(
12399 ::treesitter_types::runtime::maybe_grow_stack(|| {
12400 <Super as ::treesitter_types::FromNode>::from_node(node, src)
12401 })?,
12402 ))),
12403 _other => {
12404 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12405 <Type as ::treesitter_types::FromNode>::from_node(node, src)
12406 }) {
12407 Ok(Self::Type(::std::boxed::Box::new(v)))
12408 } else {
12409 Err(::treesitter_types::ParseError::unexpected_kind(
12410 _other, node,
12411 ))
12412 }
12413 }
12414 }
12415 }
12416}
12417impl ::treesitter_types::Spanned for WildcardChildren<'_> {
12418 fn span(&self) -> ::treesitter_types::Span {
12419 match self {
12420 Self::Type(inner) => inner.span(),
12421 Self::Annotation(inner) => inner.span(),
12422 Self::MarkerAnnotation(inner) => inner.span(),
12423 Self::Super(inner) => inner.span(),
12424 }
12425 }
12426}
12427#[derive(Debug, Clone, PartialEq, Eq)]
12428pub enum AnyNode<'tree> {
12429 Literal(Literal<'tree>),
12430 SimpleType(SimpleType<'tree>),
12431 Type(Type<'tree>),
12432 UnannotatedType(UnannotatedType<'tree>),
12433 Declaration(Declaration<'tree>),
12434 Expression(Expression<'tree>),
12435 ModuleDirective(ModuleDirective<'tree>),
12436 PrimaryExpression(PrimaryExpression<'tree>),
12437 Statement(Statement<'tree>),
12438 AnnotatedType(AnnotatedType<'tree>),
12439 Annotation(Annotation<'tree>),
12440 AnnotationArgumentList(AnnotationArgumentList<'tree>),
12441 AnnotationTypeBody(AnnotationTypeBody<'tree>),
12442 AnnotationTypeDeclaration(AnnotationTypeDeclaration<'tree>),
12443 AnnotationTypeElementDeclaration(AnnotationTypeElementDeclaration<'tree>),
12444 ArgumentList(ArgumentList<'tree>),
12445 ArrayAccess(ArrayAccess<'tree>),
12446 ArrayCreationExpression(ArrayCreationExpression<'tree>),
12447 ArrayInitializer(ArrayInitializer<'tree>),
12448 ArrayType(ArrayType<'tree>),
12449 AssertStatement(AssertStatement<'tree>),
12450 AssignmentExpression(AssignmentExpression<'tree>),
12451 Asterisk(Asterisk<'tree>),
12452 BinaryExpression(BinaryExpression<'tree>),
12453 Block(Block<'tree>),
12454 BreakStatement(BreakStatement<'tree>),
12455 CastExpression(CastExpression<'tree>),
12456 CatchClause(CatchClause<'tree>),
12457 CatchFormalParameter(CatchFormalParameter<'tree>),
12458 CatchType(CatchType<'tree>),
12459 ClassBody(ClassBody<'tree>),
12460 ClassDeclaration(ClassDeclaration<'tree>),
12461 ClassLiteral(ClassLiteral<'tree>),
12462 CompactConstructorDeclaration(CompactConstructorDeclaration<'tree>),
12463 ConstantDeclaration(ConstantDeclaration<'tree>),
12464 ConstructorBody(ConstructorBody<'tree>),
12465 ConstructorDeclaration(ConstructorDeclaration<'tree>),
12466 ContinueStatement(ContinueStatement<'tree>),
12467 Dimensions(Dimensions<'tree>),
12468 DimensionsExpr(DimensionsExpr<'tree>),
12469 DoStatement(DoStatement<'tree>),
12470 ElementValueArrayInitializer(ElementValueArrayInitializer<'tree>),
12471 ElementValuePair(ElementValuePair<'tree>),
12472 EnhancedForStatement(EnhancedForStatement<'tree>),
12473 EnumBody(EnumBody<'tree>),
12474 EnumBodyDeclarations(EnumBodyDeclarations<'tree>),
12475 EnumConstant(EnumConstant<'tree>),
12476 EnumDeclaration(EnumDeclaration<'tree>),
12477 ExplicitConstructorInvocation(ExplicitConstructorInvocation<'tree>),
12478 ExportsModuleDirective(ExportsModuleDirective<'tree>),
12479 ExpressionStatement(ExpressionStatement<'tree>),
12480 ExtendsInterfaces(ExtendsInterfaces<'tree>),
12481 FieldAccess(FieldAccess<'tree>),
12482 FieldDeclaration(FieldDeclaration<'tree>),
12483 FinallyClause(FinallyClause<'tree>),
12484 FloatingPointType(FloatingPointType<'tree>),
12485 ForStatement(ForStatement<'tree>),
12486 FormalParameter(FormalParameter<'tree>),
12487 FormalParameters(FormalParameters<'tree>),
12488 GenericType(GenericType<'tree>),
12489 Guard(Guard<'tree>),
12490 IfStatement(IfStatement<'tree>),
12491 ImportDeclaration(ImportDeclaration<'tree>),
12492 InferredParameters(InferredParameters<'tree>),
12493 InstanceofExpression(InstanceofExpression<'tree>),
12494 IntegralType(IntegralType<'tree>),
12495 InterfaceBody(InterfaceBody<'tree>),
12496 InterfaceDeclaration(InterfaceDeclaration<'tree>),
12497 LabeledStatement(LabeledStatement<'tree>),
12498 LambdaExpression(LambdaExpression<'tree>),
12499 LocalVariableDeclaration(LocalVariableDeclaration<'tree>),
12500 MarkerAnnotation(MarkerAnnotation<'tree>),
12501 MethodDeclaration(MethodDeclaration<'tree>),
12502 MethodInvocation(MethodInvocation<'tree>),
12503 MethodReference(MethodReference<'tree>),
12504 Modifiers(Modifiers<'tree>),
12505 ModuleBody(ModuleBody<'tree>),
12506 ModuleDeclaration(ModuleDeclaration<'tree>),
12507 MultilineStringFragment(MultilineStringFragment<'tree>),
12508 ObjectCreationExpression(ObjectCreationExpression<'tree>),
12509 OpensModuleDirective(OpensModuleDirective<'tree>),
12510 PackageDeclaration(PackageDeclaration<'tree>),
12511 ParenthesizedExpression(ParenthesizedExpression<'tree>),
12512 Pattern(Pattern<'tree>),
12513 Permits(Permits<'tree>),
12514 Program(Program<'tree>),
12515 ProvidesModuleDirective(ProvidesModuleDirective<'tree>),
12516 ReceiverParameter(ReceiverParameter<'tree>),
12517 RecordDeclaration(RecordDeclaration<'tree>),
12518 RecordPattern(RecordPattern<'tree>),
12519 RecordPatternBody(RecordPatternBody<'tree>),
12520 RecordPatternComponent(RecordPatternComponent<'tree>),
12521 RequiresModifier(RequiresModifier<'tree>),
12522 RequiresModuleDirective(RequiresModuleDirective<'tree>),
12523 Resource(Resource<'tree>),
12524 ResourceSpecification(ResourceSpecification<'tree>),
12525 ReturnStatement(ReturnStatement<'tree>),
12526 ScopedIdentifier(ScopedIdentifier<'tree>),
12527 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
12528 SpreadParameter(SpreadParameter<'tree>),
12529 StaticInitializer(StaticInitializer<'tree>),
12530 StringInterpolation(StringInterpolation<'tree>),
12531 StringLiteral(StringLiteral<'tree>),
12532 SuperInterfaces(SuperInterfaces<'tree>),
12533 Superclass(Superclass<'tree>),
12534 SwitchBlock(SwitchBlock<'tree>),
12535 SwitchBlockStatementGroup(SwitchBlockStatementGroup<'tree>),
12536 SwitchExpression(SwitchExpression<'tree>),
12537 SwitchLabel(SwitchLabel<'tree>),
12538 SwitchRule(SwitchRule<'tree>),
12539 SynchronizedStatement(SynchronizedStatement<'tree>),
12540 TemplateExpression(TemplateExpression<'tree>),
12541 TernaryExpression(TernaryExpression<'tree>),
12542 ThrowStatement(ThrowStatement<'tree>),
12543 Throws(Throws<'tree>),
12544 TryStatement(TryStatement<'tree>),
12545 TryWithResourcesStatement(TryWithResourcesStatement<'tree>),
12546 TypeArguments(TypeArguments<'tree>),
12547 TypeBound(TypeBound<'tree>),
12548 TypeList(TypeList<'tree>),
12549 TypeParameter(TypeParameter<'tree>),
12550 TypeParameters(TypeParameters<'tree>),
12551 TypePattern(TypePattern<'tree>),
12552 UnaryExpression(UnaryExpression<'tree>),
12553 UpdateExpression(UpdateExpression<'tree>),
12554 UsesModuleDirective(UsesModuleDirective<'tree>),
12555 VariableDeclarator(VariableDeclarator<'tree>),
12556 WhileStatement(WhileStatement<'tree>),
12557 Wildcard(Wildcard<'tree>),
12558 YieldStatement(YieldStatement<'tree>),
12559 BinaryIntegerLiteral(BinaryIntegerLiteral<'tree>),
12560 BlockComment(BlockComment<'tree>),
12561 BooleanType(BooleanType<'tree>),
12562 CharacterLiteral(CharacterLiteral<'tree>),
12563 DecimalFloatingPointLiteral(DecimalFloatingPointLiteral<'tree>),
12564 DecimalIntegerLiteral(DecimalIntegerLiteral<'tree>),
12565 EscapeSequence(EscapeSequence<'tree>),
12566 False(False<'tree>),
12567 HexFloatingPointLiteral(HexFloatingPointLiteral<'tree>),
12568 HexIntegerLiteral(HexIntegerLiteral<'tree>),
12569 Identifier(Identifier<'tree>),
12570 LineComment(LineComment<'tree>),
12571 NullLiteral(NullLiteral<'tree>),
12572 OctalIntegerLiteral(OctalIntegerLiteral<'tree>),
12573 StringFragment(StringFragment<'tree>),
12574 Super(Super<'tree>),
12575 This(This<'tree>),
12576 True(True<'tree>),
12577 TypeIdentifier(TypeIdentifier<'tree>),
12578 UnderscorePattern(UnderscorePattern<'tree>),
12579 VoidType(VoidType<'tree>),
12580 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
12581}
12582impl<'tree> AnyNode<'tree> {
12583 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
12584 match node.kind() {
12585 "_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12586 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
12587 })
12588 .map(Self::Literal)
12589 .unwrap_or(Self::Unknown(node)),
12590 "_simple_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12591 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
12592 })
12593 .map(Self::SimpleType)
12594 .unwrap_or(Self::Unknown(node)),
12595 "_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12596 <Type as ::treesitter_types::FromNode>::from_node(node, src)
12597 })
12598 .map(Self::Type)
12599 .unwrap_or(Self::Unknown(node)),
12600 "_unannotated_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12601 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
12602 })
12603 .map(Self::UnannotatedType)
12604 .unwrap_or(Self::Unknown(node)),
12605 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12606 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
12607 })
12608 .map(Self::Declaration)
12609 .unwrap_or(Self::Unknown(node)),
12610 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12611 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12612 })
12613 .map(Self::Expression)
12614 .unwrap_or(Self::Unknown(node)),
12615 "module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12616 <ModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12617 })
12618 .map(Self::ModuleDirective)
12619 .unwrap_or(Self::Unknown(node)),
12620 "primary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12621 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12622 })
12623 .map(Self::PrimaryExpression)
12624 .unwrap_or(Self::Unknown(node)),
12625 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12626 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
12627 })
12628 .map(Self::Statement)
12629 .unwrap_or(Self::Unknown(node)),
12630 "annotated_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12631 <AnnotatedType as ::treesitter_types::FromNode>::from_node(node, src)
12632 })
12633 .map(Self::AnnotatedType)
12634 .unwrap_or(Self::Unknown(node)),
12635 "annotation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12636 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
12637 })
12638 .map(Self::Annotation)
12639 .unwrap_or(Self::Unknown(node)),
12640 "annotation_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12641 <AnnotationArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
12642 })
12643 .map(Self::AnnotationArgumentList)
12644 .unwrap_or(Self::Unknown(node)),
12645 "annotation_type_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12646 <AnnotationTypeBody as ::treesitter_types::FromNode>::from_node(node, src)
12647 })
12648 .map(Self::AnnotationTypeBody)
12649 .unwrap_or(Self::Unknown(node)),
12650 "annotation_type_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12651 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12652 })
12653 .map(Self::AnnotationTypeDeclaration)
12654 .unwrap_or(Self::Unknown(node)),
12655 "annotation_type_element_declaration" => {
12656 ::treesitter_types::runtime::maybe_grow_stack(|| {
12657 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
12658 node, src,
12659 )
12660 })
12661 .map(Self::AnnotationTypeElementDeclaration)
12662 .unwrap_or(Self::Unknown(node))
12663 }
12664 "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12665 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
12666 })
12667 .map(Self::ArgumentList)
12668 .unwrap_or(Self::Unknown(node)),
12669 "array_access" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12670 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)
12671 })
12672 .map(Self::ArrayAccess)
12673 .unwrap_or(Self::Unknown(node)),
12674 "array_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12675 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12676 })
12677 .map(Self::ArrayCreationExpression)
12678 .unwrap_or(Self::Unknown(node)),
12679 "array_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12680 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12681 })
12682 .map(Self::ArrayInitializer)
12683 .unwrap_or(Self::Unknown(node)),
12684 "array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12685 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
12686 })
12687 .map(Self::ArrayType)
12688 .unwrap_or(Self::Unknown(node)),
12689 "assert_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12690 <AssertStatement as ::treesitter_types::FromNode>::from_node(node, src)
12691 })
12692 .map(Self::AssertStatement)
12693 .unwrap_or(Self::Unknown(node)),
12694 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12695 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
12696 })
12697 .map(Self::AssignmentExpression)
12698 .unwrap_or(Self::Unknown(node)),
12699 "asterisk" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12700 <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)
12701 })
12702 .map(Self::Asterisk)
12703 .unwrap_or(Self::Unknown(node)),
12704 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12705 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12706 })
12707 .map(Self::BinaryExpression)
12708 .unwrap_or(Self::Unknown(node)),
12709 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12710 <Block as ::treesitter_types::FromNode>::from_node(node, src)
12711 })
12712 .map(Self::Block)
12713 .unwrap_or(Self::Unknown(node)),
12714 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12715 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
12716 })
12717 .map(Self::BreakStatement)
12718 .unwrap_or(Self::Unknown(node)),
12719 "cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12720 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
12721 })
12722 .map(Self::CastExpression)
12723 .unwrap_or(Self::Unknown(node)),
12724 "catch_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12725 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
12726 })
12727 .map(Self::CatchClause)
12728 .unwrap_or(Self::Unknown(node)),
12729 "catch_formal_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12730 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
12731 })
12732 .map(Self::CatchFormalParameter)
12733 .unwrap_or(Self::Unknown(node)),
12734 "catch_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12735 <CatchType as ::treesitter_types::FromNode>::from_node(node, src)
12736 })
12737 .map(Self::CatchType)
12738 .unwrap_or(Self::Unknown(node)),
12739 "class_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12740 <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
12741 })
12742 .map(Self::ClassBody)
12743 .unwrap_or(Self::Unknown(node)),
12744 "class_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12745 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12746 })
12747 .map(Self::ClassDeclaration)
12748 .unwrap_or(Self::Unknown(node)),
12749 "class_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12750 <ClassLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12751 })
12752 .map(Self::ClassLiteral)
12753 .unwrap_or(Self::Unknown(node)),
12754 "compact_constructor_declaration" => {
12755 ::treesitter_types::runtime::maybe_grow_stack(|| {
12756 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
12757 node, src,
12758 )
12759 })
12760 .map(Self::CompactConstructorDeclaration)
12761 .unwrap_or(Self::Unknown(node))
12762 }
12763 "constant_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12764 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12765 })
12766 .map(Self::ConstantDeclaration)
12767 .unwrap_or(Self::Unknown(node)),
12768 "constructor_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12769 <ConstructorBody as ::treesitter_types::FromNode>::from_node(node, src)
12770 })
12771 .map(Self::ConstructorBody)
12772 .unwrap_or(Self::Unknown(node)),
12773 "constructor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12774 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12775 })
12776 .map(Self::ConstructorDeclaration)
12777 .unwrap_or(Self::Unknown(node)),
12778 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12779 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
12780 })
12781 .map(Self::ContinueStatement)
12782 .unwrap_or(Self::Unknown(node)),
12783 "dimensions" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12784 <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)
12785 })
12786 .map(Self::Dimensions)
12787 .unwrap_or(Self::Unknown(node)),
12788 "dimensions_expr" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12789 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)
12790 })
12791 .map(Self::DimensionsExpr)
12792 .unwrap_or(Self::Unknown(node)),
12793 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12794 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
12795 })
12796 .map(Self::DoStatement)
12797 .unwrap_or(Self::Unknown(node)),
12798 "element_value_array_initializer" => {
12799 ::treesitter_types::runtime::maybe_grow_stack(|| {
12800 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
12801 node, src,
12802 )
12803 })
12804 .map(Self::ElementValueArrayInitializer)
12805 .unwrap_or(Self::Unknown(node))
12806 }
12807 "element_value_pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12808 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)
12809 })
12810 .map(Self::ElementValuePair)
12811 .unwrap_or(Self::Unknown(node)),
12812 "enhanced_for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12813 <EnhancedForStatement as ::treesitter_types::FromNode>::from_node(node, src)
12814 })
12815 .map(Self::EnhancedForStatement)
12816 .unwrap_or(Self::Unknown(node)),
12817 "enum_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12818 <EnumBody as ::treesitter_types::FromNode>::from_node(node, src)
12819 })
12820 .map(Self::EnumBody)
12821 .unwrap_or(Self::Unknown(node)),
12822 "enum_body_declarations" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12823 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
12824 })
12825 .map(Self::EnumBodyDeclarations)
12826 .unwrap_or(Self::Unknown(node)),
12827 "enum_constant" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12828 <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)
12829 })
12830 .map(Self::EnumConstant)
12831 .unwrap_or(Self::Unknown(node)),
12832 "enum_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12833 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12834 })
12835 .map(Self::EnumDeclaration)
12836 .unwrap_or(Self::Unknown(node)),
12837 "explicit_constructor_invocation" => {
12838 ::treesitter_types::runtime::maybe_grow_stack(|| {
12839 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
12840 node, src,
12841 )
12842 })
12843 .map(Self::ExplicitConstructorInvocation)
12844 .unwrap_or(Self::Unknown(node))
12845 }
12846 "exports_module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12847 <ExportsModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12848 })
12849 .map(Self::ExportsModuleDirective)
12850 .unwrap_or(Self::Unknown(node)),
12851 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12852 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
12853 })
12854 .map(Self::ExpressionStatement)
12855 .unwrap_or(Self::Unknown(node)),
12856 "extends_interfaces" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12857 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
12858 })
12859 .map(Self::ExtendsInterfaces)
12860 .unwrap_or(Self::Unknown(node)),
12861 "field_access" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12862 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
12863 })
12864 .map(Self::FieldAccess)
12865 .unwrap_or(Self::Unknown(node)),
12866 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12867 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12868 })
12869 .map(Self::FieldDeclaration)
12870 .unwrap_or(Self::Unknown(node)),
12871 "finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12872 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
12873 })
12874 .map(Self::FinallyClause)
12875 .unwrap_or(Self::Unknown(node)),
12876 "floating_point_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12877 <FloatingPointType as ::treesitter_types::FromNode>::from_node(node, src)
12878 })
12879 .map(Self::FloatingPointType)
12880 .unwrap_or(Self::Unknown(node)),
12881 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12882 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
12883 })
12884 .map(Self::ForStatement)
12885 .unwrap_or(Self::Unknown(node)),
12886 "formal_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12887 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
12888 })
12889 .map(Self::FormalParameter)
12890 .unwrap_or(Self::Unknown(node)),
12891 "formal_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12892 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
12893 })
12894 .map(Self::FormalParameters)
12895 .unwrap_or(Self::Unknown(node)),
12896 "generic_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12897 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
12898 })
12899 .map(Self::GenericType)
12900 .unwrap_or(Self::Unknown(node)),
12901 "guard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12902 <Guard as ::treesitter_types::FromNode>::from_node(node, src)
12903 })
12904 .map(Self::Guard)
12905 .unwrap_or(Self::Unknown(node)),
12906 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12907 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
12908 })
12909 .map(Self::IfStatement)
12910 .unwrap_or(Self::Unknown(node)),
12911 "import_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12912 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12913 })
12914 .map(Self::ImportDeclaration)
12915 .unwrap_or(Self::Unknown(node)),
12916 "inferred_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12917 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)
12918 })
12919 .map(Self::InferredParameters)
12920 .unwrap_or(Self::Unknown(node)),
12921 "instanceof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12922 <InstanceofExpression as ::treesitter_types::FromNode>::from_node(node, src)
12923 })
12924 .map(Self::InstanceofExpression)
12925 .unwrap_or(Self::Unknown(node)),
12926 "integral_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12927 <IntegralType as ::treesitter_types::FromNode>::from_node(node, src)
12928 })
12929 .map(Self::IntegralType)
12930 .unwrap_or(Self::Unknown(node)),
12931 "interface_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12932 <InterfaceBody as ::treesitter_types::FromNode>::from_node(node, src)
12933 })
12934 .map(Self::InterfaceBody)
12935 .unwrap_or(Self::Unknown(node)),
12936 "interface_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12937 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12938 })
12939 .map(Self::InterfaceDeclaration)
12940 .unwrap_or(Self::Unknown(node)),
12941 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12942 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
12943 })
12944 .map(Self::LabeledStatement)
12945 .unwrap_or(Self::Unknown(node)),
12946 "lambda_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12947 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
12948 })
12949 .map(Self::LambdaExpression)
12950 .unwrap_or(Self::Unknown(node)),
12951 "local_variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12952 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12953 })
12954 .map(Self::LocalVariableDeclaration)
12955 .unwrap_or(Self::Unknown(node)),
12956 "marker_annotation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12957 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
12958 })
12959 .map(Self::MarkerAnnotation)
12960 .unwrap_or(Self::Unknown(node)),
12961 "method_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12962 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12963 })
12964 .map(Self::MethodDeclaration)
12965 .unwrap_or(Self::Unknown(node)),
12966 "method_invocation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12967 <MethodInvocation as ::treesitter_types::FromNode>::from_node(node, src)
12968 })
12969 .map(Self::MethodInvocation)
12970 .unwrap_or(Self::Unknown(node)),
12971 "method_reference" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12972 <MethodReference as ::treesitter_types::FromNode>::from_node(node, src)
12973 })
12974 .map(Self::MethodReference)
12975 .unwrap_or(Self::Unknown(node)),
12976 "modifiers" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12977 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
12978 })
12979 .map(Self::Modifiers)
12980 .unwrap_or(Self::Unknown(node)),
12981 "module_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12982 <ModuleBody as ::treesitter_types::FromNode>::from_node(node, src)
12983 })
12984 .map(Self::ModuleBody)
12985 .unwrap_or(Self::Unknown(node)),
12986 "module_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12987 <ModuleDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12988 })
12989 .map(Self::ModuleDeclaration)
12990 .unwrap_or(Self::Unknown(node)),
12991 "multiline_string_fragment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12992 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(node, src)
12993 })
12994 .map(Self::MultilineStringFragment)
12995 .unwrap_or(Self::Unknown(node)),
12996 "object_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12997 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12998 })
12999 .map(Self::ObjectCreationExpression)
13000 .unwrap_or(Self::Unknown(node)),
13001 "opens_module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13002 <OpensModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
13003 })
13004 .map(Self::OpensModuleDirective)
13005 .unwrap_or(Self::Unknown(node)),
13006 "package_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13007 <PackageDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13008 })
13009 .map(Self::PackageDeclaration)
13010 .unwrap_or(Self::Unknown(node)),
13011 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13012 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13013 })
13014 .map(Self::ParenthesizedExpression)
13015 .unwrap_or(Self::Unknown(node)),
13016 "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13017 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13018 })
13019 .map(Self::Pattern)
13020 .unwrap_or(Self::Unknown(node)),
13021 "permits" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13022 <Permits as ::treesitter_types::FromNode>::from_node(node, src)
13023 })
13024 .map(Self::Permits)
13025 .unwrap_or(Self::Unknown(node)),
13026 "program" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13027 <Program as ::treesitter_types::FromNode>::from_node(node, src)
13028 })
13029 .map(Self::Program)
13030 .unwrap_or(Self::Unknown(node)),
13031 "provides_module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13032 <ProvidesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
13033 })
13034 .map(Self::ProvidesModuleDirective)
13035 .unwrap_or(Self::Unknown(node)),
13036 "receiver_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13037 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)
13038 })
13039 .map(Self::ReceiverParameter)
13040 .unwrap_or(Self::Unknown(node)),
13041 "record_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13042 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13043 })
13044 .map(Self::RecordDeclaration)
13045 .unwrap_or(Self::Unknown(node)),
13046 "record_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13047 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)
13048 })
13049 .map(Self::RecordPattern)
13050 .unwrap_or(Self::Unknown(node)),
13051 "record_pattern_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13052 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)
13053 })
13054 .map(Self::RecordPatternBody)
13055 .unwrap_or(Self::Unknown(node)),
13056 "record_pattern_component" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13057 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)
13058 })
13059 .map(Self::RecordPatternComponent)
13060 .unwrap_or(Self::Unknown(node)),
13061 "requires_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13062 <RequiresModifier as ::treesitter_types::FromNode>::from_node(node, src)
13063 })
13064 .map(Self::RequiresModifier)
13065 .unwrap_or(Self::Unknown(node)),
13066 "requires_module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13067 <RequiresModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
13068 })
13069 .map(Self::RequiresModuleDirective)
13070 .unwrap_or(Self::Unknown(node)),
13071 "resource" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13072 <Resource as ::treesitter_types::FromNode>::from_node(node, src)
13073 })
13074 .map(Self::Resource)
13075 .unwrap_or(Self::Unknown(node)),
13076 "resource_specification" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13077 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(node, src)
13078 })
13079 .map(Self::ResourceSpecification)
13080 .unwrap_or(Self::Unknown(node)),
13081 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13082 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
13083 })
13084 .map(Self::ReturnStatement)
13085 .unwrap_or(Self::Unknown(node)),
13086 "scoped_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13087 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13088 })
13089 .map(Self::ScopedIdentifier)
13090 .unwrap_or(Self::Unknown(node)),
13091 "scoped_type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13092 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13093 })
13094 .map(Self::ScopedTypeIdentifier)
13095 .unwrap_or(Self::Unknown(node)),
13096 "spread_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13097 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)
13098 })
13099 .map(Self::SpreadParameter)
13100 .unwrap_or(Self::Unknown(node)),
13101 "static_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13102 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)
13103 })
13104 .map(Self::StaticInitializer)
13105 .unwrap_or(Self::Unknown(node)),
13106 "string_interpolation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13107 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
13108 })
13109 .map(Self::StringInterpolation)
13110 .unwrap_or(Self::Unknown(node)),
13111 "string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13112 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13113 })
13114 .map(Self::StringLiteral)
13115 .unwrap_or(Self::Unknown(node)),
13116 "super_interfaces" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13117 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
13118 })
13119 .map(Self::SuperInterfaces)
13120 .unwrap_or(Self::Unknown(node)),
13121 "superclass" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13122 <Superclass as ::treesitter_types::FromNode>::from_node(node, src)
13123 })
13124 .map(Self::Superclass)
13125 .unwrap_or(Self::Unknown(node)),
13126 "switch_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13127 <SwitchBlock as ::treesitter_types::FromNode>::from_node(node, src)
13128 })
13129 .map(Self::SwitchBlock)
13130 .unwrap_or(Self::Unknown(node)),
13131 "switch_block_statement_group" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13132 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(node, src)
13133 })
13134 .map(Self::SwitchBlockStatementGroup)
13135 .unwrap_or(Self::Unknown(node)),
13136 "switch_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13137 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
13138 })
13139 .map(Self::SwitchExpression)
13140 .unwrap_or(Self::Unknown(node)),
13141 "switch_label" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13142 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)
13143 })
13144 .map(Self::SwitchLabel)
13145 .unwrap_or(Self::Unknown(node)),
13146 "switch_rule" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13147 <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)
13148 })
13149 .map(Self::SwitchRule)
13150 .unwrap_or(Self::Unknown(node)),
13151 "synchronized_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13152 <SynchronizedStatement as ::treesitter_types::FromNode>::from_node(node, src)
13153 })
13154 .map(Self::SynchronizedStatement)
13155 .unwrap_or(Self::Unknown(node)),
13156 "template_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13157 <TemplateExpression as ::treesitter_types::FromNode>::from_node(node, src)
13158 })
13159 .map(Self::TemplateExpression)
13160 .unwrap_or(Self::Unknown(node)),
13161 "ternary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13162 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13163 })
13164 .map(Self::TernaryExpression)
13165 .unwrap_or(Self::Unknown(node)),
13166 "throw_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13167 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
13168 })
13169 .map(Self::ThrowStatement)
13170 .unwrap_or(Self::Unknown(node)),
13171 "throws" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13172 <Throws as ::treesitter_types::FromNode>::from_node(node, src)
13173 })
13174 .map(Self::Throws)
13175 .unwrap_or(Self::Unknown(node)),
13176 "try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13177 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
13178 })
13179 .map(Self::TryStatement)
13180 .unwrap_or(Self::Unknown(node)),
13181 "try_with_resources_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13182 <TryWithResourcesStatement as ::treesitter_types::FromNode>::from_node(node, src)
13183 })
13184 .map(Self::TryWithResourcesStatement)
13185 .unwrap_or(Self::Unknown(node)),
13186 "type_arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13187 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
13188 })
13189 .map(Self::TypeArguments)
13190 .unwrap_or(Self::Unknown(node)),
13191 "type_bound" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13192 <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)
13193 })
13194 .map(Self::TypeBound)
13195 .unwrap_or(Self::Unknown(node)),
13196 "type_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13197 <TypeList as ::treesitter_types::FromNode>::from_node(node, src)
13198 })
13199 .map(Self::TypeList)
13200 .unwrap_or(Self::Unknown(node)),
13201 "type_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13202 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
13203 })
13204 .map(Self::TypeParameter)
13205 .unwrap_or(Self::Unknown(node)),
13206 "type_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13207 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
13208 })
13209 .map(Self::TypeParameters)
13210 .unwrap_or(Self::Unknown(node)),
13211 "type_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13212 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
13213 })
13214 .map(Self::TypePattern)
13215 .unwrap_or(Self::Unknown(node)),
13216 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13217 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13218 })
13219 .map(Self::UnaryExpression)
13220 .unwrap_or(Self::Unknown(node)),
13221 "update_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13222 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
13223 })
13224 .map(Self::UpdateExpression)
13225 .unwrap_or(Self::Unknown(node)),
13226 "uses_module_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13227 <UsesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
13228 })
13229 .map(Self::UsesModuleDirective)
13230 .unwrap_or(Self::Unknown(node)),
13231 "variable_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13232 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
13233 })
13234 .map(Self::VariableDeclarator)
13235 .unwrap_or(Self::Unknown(node)),
13236 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13237 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
13238 })
13239 .map(Self::WhileStatement)
13240 .unwrap_or(Self::Unknown(node)),
13241 "wildcard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13242 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
13243 })
13244 .map(Self::Wildcard)
13245 .unwrap_or(Self::Unknown(node)),
13246 "yield_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13247 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
13248 })
13249 .map(Self::YieldStatement)
13250 .unwrap_or(Self::Unknown(node)),
13251 "binary_integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13252 <BinaryIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13253 })
13254 .map(Self::BinaryIntegerLiteral)
13255 .unwrap_or(Self::Unknown(node)),
13256 "block_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13257 <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
13258 })
13259 .map(Self::BlockComment)
13260 .unwrap_or(Self::Unknown(node)),
13261 "boolean_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13262 <BooleanType as ::treesitter_types::FromNode>::from_node(node, src)
13263 })
13264 .map(Self::BooleanType)
13265 .unwrap_or(Self::Unknown(node)),
13266 "character_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13267 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13268 })
13269 .map(Self::CharacterLiteral)
13270 .unwrap_or(Self::Unknown(node)),
13271 "decimal_floating_point_literal" => {
13272 ::treesitter_types::runtime::maybe_grow_stack(|| {
13273 <DecimalFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(
13274 node, src,
13275 )
13276 })
13277 .map(Self::DecimalFloatingPointLiteral)
13278 .unwrap_or(Self::Unknown(node))
13279 }
13280 "decimal_integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13281 <DecimalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13282 })
13283 .map(Self::DecimalIntegerLiteral)
13284 .unwrap_or(Self::Unknown(node)),
13285 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13286 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
13287 })
13288 .map(Self::EscapeSequence)
13289 .unwrap_or(Self::Unknown(node)),
13290 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13291 <False as ::treesitter_types::FromNode>::from_node(node, src)
13292 })
13293 .map(Self::False)
13294 .unwrap_or(Self::Unknown(node)),
13295 "hex_floating_point_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13296 <HexFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13297 })
13298 .map(Self::HexFloatingPointLiteral)
13299 .unwrap_or(Self::Unknown(node)),
13300 "hex_integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13301 <HexIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13302 })
13303 .map(Self::HexIntegerLiteral)
13304 .unwrap_or(Self::Unknown(node)),
13305 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13306 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13307 })
13308 .map(Self::Identifier)
13309 .unwrap_or(Self::Unknown(node)),
13310 "line_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13311 <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
13312 })
13313 .map(Self::LineComment)
13314 .unwrap_or(Self::Unknown(node)),
13315 "null_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13316 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13317 })
13318 .map(Self::NullLiteral)
13319 .unwrap_or(Self::Unknown(node)),
13320 "octal_integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13321 <OctalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13322 })
13323 .map(Self::OctalIntegerLiteral)
13324 .unwrap_or(Self::Unknown(node)),
13325 "string_fragment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13326 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
13327 })
13328 .map(Self::StringFragment)
13329 .unwrap_or(Self::Unknown(node)),
13330 "super" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13331 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13332 })
13333 .map(Self::Super)
13334 .unwrap_or(Self::Unknown(node)),
13335 "this" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13336 <This as ::treesitter_types::FromNode>::from_node(node, src)
13337 })
13338 .map(Self::This)
13339 .unwrap_or(Self::Unknown(node)),
13340 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13341 <True as ::treesitter_types::FromNode>::from_node(node, src)
13342 })
13343 .map(Self::True)
13344 .unwrap_or(Self::Unknown(node)),
13345 "type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13346 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13347 })
13348 .map(Self::TypeIdentifier)
13349 .unwrap_or(Self::Unknown(node)),
13350 "underscore_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13351 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
13352 })
13353 .map(Self::UnderscorePattern)
13354 .unwrap_or(Self::Unknown(node)),
13355 "void_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
13356 <VoidType as ::treesitter_types::FromNode>::from_node(node, src)
13357 })
13358 .map(Self::VoidType)
13359 .unwrap_or(Self::Unknown(node)),
13360 _ => Self::Unknown(node),
13361 }
13362 }
13363}
13364impl ::treesitter_types::Spanned for AnyNode<'_> {
13365 fn span(&self) -> ::treesitter_types::Span {
13366 match self {
13367 Self::Literal(inner) => inner.span(),
13368 Self::SimpleType(inner) => inner.span(),
13369 Self::Type(inner) => inner.span(),
13370 Self::UnannotatedType(inner) => inner.span(),
13371 Self::Declaration(inner) => inner.span(),
13372 Self::Expression(inner) => inner.span(),
13373 Self::ModuleDirective(inner) => inner.span(),
13374 Self::PrimaryExpression(inner) => inner.span(),
13375 Self::Statement(inner) => inner.span(),
13376 Self::AnnotatedType(inner) => inner.span(),
13377 Self::Annotation(inner) => inner.span(),
13378 Self::AnnotationArgumentList(inner) => inner.span(),
13379 Self::AnnotationTypeBody(inner) => inner.span(),
13380 Self::AnnotationTypeDeclaration(inner) => inner.span(),
13381 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
13382 Self::ArgumentList(inner) => inner.span(),
13383 Self::ArrayAccess(inner) => inner.span(),
13384 Self::ArrayCreationExpression(inner) => inner.span(),
13385 Self::ArrayInitializer(inner) => inner.span(),
13386 Self::ArrayType(inner) => inner.span(),
13387 Self::AssertStatement(inner) => inner.span(),
13388 Self::AssignmentExpression(inner) => inner.span(),
13389 Self::Asterisk(inner) => inner.span(),
13390 Self::BinaryExpression(inner) => inner.span(),
13391 Self::Block(inner) => inner.span(),
13392 Self::BreakStatement(inner) => inner.span(),
13393 Self::CastExpression(inner) => inner.span(),
13394 Self::CatchClause(inner) => inner.span(),
13395 Self::CatchFormalParameter(inner) => inner.span(),
13396 Self::CatchType(inner) => inner.span(),
13397 Self::ClassBody(inner) => inner.span(),
13398 Self::ClassDeclaration(inner) => inner.span(),
13399 Self::ClassLiteral(inner) => inner.span(),
13400 Self::CompactConstructorDeclaration(inner) => inner.span(),
13401 Self::ConstantDeclaration(inner) => inner.span(),
13402 Self::ConstructorBody(inner) => inner.span(),
13403 Self::ConstructorDeclaration(inner) => inner.span(),
13404 Self::ContinueStatement(inner) => inner.span(),
13405 Self::Dimensions(inner) => inner.span(),
13406 Self::DimensionsExpr(inner) => inner.span(),
13407 Self::DoStatement(inner) => inner.span(),
13408 Self::ElementValueArrayInitializer(inner) => inner.span(),
13409 Self::ElementValuePair(inner) => inner.span(),
13410 Self::EnhancedForStatement(inner) => inner.span(),
13411 Self::EnumBody(inner) => inner.span(),
13412 Self::EnumBodyDeclarations(inner) => inner.span(),
13413 Self::EnumConstant(inner) => inner.span(),
13414 Self::EnumDeclaration(inner) => inner.span(),
13415 Self::ExplicitConstructorInvocation(inner) => inner.span(),
13416 Self::ExportsModuleDirective(inner) => inner.span(),
13417 Self::ExpressionStatement(inner) => inner.span(),
13418 Self::ExtendsInterfaces(inner) => inner.span(),
13419 Self::FieldAccess(inner) => inner.span(),
13420 Self::FieldDeclaration(inner) => inner.span(),
13421 Self::FinallyClause(inner) => inner.span(),
13422 Self::FloatingPointType(inner) => inner.span(),
13423 Self::ForStatement(inner) => inner.span(),
13424 Self::FormalParameter(inner) => inner.span(),
13425 Self::FormalParameters(inner) => inner.span(),
13426 Self::GenericType(inner) => inner.span(),
13427 Self::Guard(inner) => inner.span(),
13428 Self::IfStatement(inner) => inner.span(),
13429 Self::ImportDeclaration(inner) => inner.span(),
13430 Self::InferredParameters(inner) => inner.span(),
13431 Self::InstanceofExpression(inner) => inner.span(),
13432 Self::IntegralType(inner) => inner.span(),
13433 Self::InterfaceBody(inner) => inner.span(),
13434 Self::InterfaceDeclaration(inner) => inner.span(),
13435 Self::LabeledStatement(inner) => inner.span(),
13436 Self::LambdaExpression(inner) => inner.span(),
13437 Self::LocalVariableDeclaration(inner) => inner.span(),
13438 Self::MarkerAnnotation(inner) => inner.span(),
13439 Self::MethodDeclaration(inner) => inner.span(),
13440 Self::MethodInvocation(inner) => inner.span(),
13441 Self::MethodReference(inner) => inner.span(),
13442 Self::Modifiers(inner) => inner.span(),
13443 Self::ModuleBody(inner) => inner.span(),
13444 Self::ModuleDeclaration(inner) => inner.span(),
13445 Self::MultilineStringFragment(inner) => inner.span(),
13446 Self::ObjectCreationExpression(inner) => inner.span(),
13447 Self::OpensModuleDirective(inner) => inner.span(),
13448 Self::PackageDeclaration(inner) => inner.span(),
13449 Self::ParenthesizedExpression(inner) => inner.span(),
13450 Self::Pattern(inner) => inner.span(),
13451 Self::Permits(inner) => inner.span(),
13452 Self::Program(inner) => inner.span(),
13453 Self::ProvidesModuleDirective(inner) => inner.span(),
13454 Self::ReceiverParameter(inner) => inner.span(),
13455 Self::RecordDeclaration(inner) => inner.span(),
13456 Self::RecordPattern(inner) => inner.span(),
13457 Self::RecordPatternBody(inner) => inner.span(),
13458 Self::RecordPatternComponent(inner) => inner.span(),
13459 Self::RequiresModifier(inner) => inner.span(),
13460 Self::RequiresModuleDirective(inner) => inner.span(),
13461 Self::Resource(inner) => inner.span(),
13462 Self::ResourceSpecification(inner) => inner.span(),
13463 Self::ReturnStatement(inner) => inner.span(),
13464 Self::ScopedIdentifier(inner) => inner.span(),
13465 Self::ScopedTypeIdentifier(inner) => inner.span(),
13466 Self::SpreadParameter(inner) => inner.span(),
13467 Self::StaticInitializer(inner) => inner.span(),
13468 Self::StringInterpolation(inner) => inner.span(),
13469 Self::StringLiteral(inner) => inner.span(),
13470 Self::SuperInterfaces(inner) => inner.span(),
13471 Self::Superclass(inner) => inner.span(),
13472 Self::SwitchBlock(inner) => inner.span(),
13473 Self::SwitchBlockStatementGroup(inner) => inner.span(),
13474 Self::SwitchExpression(inner) => inner.span(),
13475 Self::SwitchLabel(inner) => inner.span(),
13476 Self::SwitchRule(inner) => inner.span(),
13477 Self::SynchronizedStatement(inner) => inner.span(),
13478 Self::TemplateExpression(inner) => inner.span(),
13479 Self::TernaryExpression(inner) => inner.span(),
13480 Self::ThrowStatement(inner) => inner.span(),
13481 Self::Throws(inner) => inner.span(),
13482 Self::TryStatement(inner) => inner.span(),
13483 Self::TryWithResourcesStatement(inner) => inner.span(),
13484 Self::TypeArguments(inner) => inner.span(),
13485 Self::TypeBound(inner) => inner.span(),
13486 Self::TypeList(inner) => inner.span(),
13487 Self::TypeParameter(inner) => inner.span(),
13488 Self::TypeParameters(inner) => inner.span(),
13489 Self::TypePattern(inner) => inner.span(),
13490 Self::UnaryExpression(inner) => inner.span(),
13491 Self::UpdateExpression(inner) => inner.span(),
13492 Self::UsesModuleDirective(inner) => inner.span(),
13493 Self::VariableDeclarator(inner) => inner.span(),
13494 Self::WhileStatement(inner) => inner.span(),
13495 Self::Wildcard(inner) => inner.span(),
13496 Self::YieldStatement(inner) => inner.span(),
13497 Self::BinaryIntegerLiteral(inner) => inner.span(),
13498 Self::BlockComment(inner) => inner.span(),
13499 Self::BooleanType(inner) => inner.span(),
13500 Self::CharacterLiteral(inner) => inner.span(),
13501 Self::DecimalFloatingPointLiteral(inner) => inner.span(),
13502 Self::DecimalIntegerLiteral(inner) => inner.span(),
13503 Self::EscapeSequence(inner) => inner.span(),
13504 Self::False(inner) => inner.span(),
13505 Self::HexFloatingPointLiteral(inner) => inner.span(),
13506 Self::HexIntegerLiteral(inner) => inner.span(),
13507 Self::Identifier(inner) => inner.span(),
13508 Self::LineComment(inner) => inner.span(),
13509 Self::NullLiteral(inner) => inner.span(),
13510 Self::OctalIntegerLiteral(inner) => inner.span(),
13511 Self::StringFragment(inner) => inner.span(),
13512 Self::Super(inner) => inner.span(),
13513 Self::This(inner) => inner.span(),
13514 Self::True(inner) => inner.span(),
13515 Self::TypeIdentifier(inner) => inner.span(),
13516 Self::UnderscorePattern(inner) => inner.span(),
13517 Self::VoidType(inner) => inner.span(),
13518 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
13519 }
13520 }
13521}