1#[derive(Debug, Clone)]
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: ::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 <BinaryIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
24 ))),
25 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
26 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
27 ))),
28 "decimal_floating_point_literal" => {
29 Ok(Self::DecimalFloatingPointLiteral(::std::boxed::Box::new(
30 <DecimalFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(
31 node, src,
32 )?,
33 )))
34 }
35 "decimal_integer_literal" => Ok(Self::DecimalIntegerLiteral(::std::boxed::Box::new(
36 <DecimalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
37 ))),
38 "false" => Ok(Self::False(::std::boxed::Box::new(
39 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
40 ))),
41 "hex_floating_point_literal" => {
42 Ok(Self::HexFloatingPointLiteral(::std::boxed::Box::new(
43 <HexFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(
44 node, src,
45 )?,
46 )))
47 }
48 "hex_integer_literal" => Ok(Self::HexIntegerLiteral(::std::boxed::Box::new(
49 <HexIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
50 ))),
51 "null_literal" => Ok(Self::NullLiteral(::std::boxed::Box::new(
52 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
53 ))),
54 "octal_integer_literal" => Ok(Self::OctalIntegerLiteral(::std::boxed::Box::new(
55 <OctalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
56 ))),
57 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
58 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
59 ))),
60 "true" => Ok(Self::True(::std::boxed::Box::new(
61 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
62 ))),
63 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
64 }
65 }
66}
67impl ::treesitter_types::Spanned for Literal<'_> {
68 fn span(&self) -> ::treesitter_types::Span {
69 match self {
70 Self::BinaryIntegerLiteral(inner) => inner.span(),
71 Self::CharacterLiteral(inner) => inner.span(),
72 Self::DecimalFloatingPointLiteral(inner) => inner.span(),
73 Self::DecimalIntegerLiteral(inner) => inner.span(),
74 Self::False(inner) => inner.span(),
75 Self::HexFloatingPointLiteral(inner) => inner.span(),
76 Self::HexIntegerLiteral(inner) => inner.span(),
77 Self::NullLiteral(inner) => inner.span(),
78 Self::OctalIntegerLiteral(inner) => inner.span(),
79 Self::StringLiteral(inner) => inner.span(),
80 Self::True(inner) => inner.span(),
81 }
82 }
83}
84#[derive(Debug, Clone)]
85pub enum SimpleType<'tree> {
86 BooleanType(::std::boxed::Box<BooleanType<'tree>>),
87 FloatingPointType(::std::boxed::Box<FloatingPointType<'tree>>),
88 GenericType(::std::boxed::Box<GenericType<'tree>>),
89 IntegralType(::std::boxed::Box<IntegralType<'tree>>),
90 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
91 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
92 VoidType(::std::boxed::Box<VoidType<'tree>>),
93}
94impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleType<'tree> {
95 #[allow(clippy::collapsible_else_if)]
96 fn from_node(
97 node: ::tree_sitter::Node<'tree>,
98 src: &'tree [u8],
99 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
100 match node.kind() {
101 "boolean_type" => Ok(Self::BooleanType(::std::boxed::Box::new(
102 <BooleanType as ::treesitter_types::FromNode>::from_node(node, src)?,
103 ))),
104 "floating_point_type" => Ok(Self::FloatingPointType(::std::boxed::Box::new(
105 <FloatingPointType as ::treesitter_types::FromNode>::from_node(node, src)?,
106 ))),
107 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
108 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
109 ))),
110 "integral_type" => Ok(Self::IntegralType(::std::boxed::Box::new(
111 <IntegralType as ::treesitter_types::FromNode>::from_node(node, src)?,
112 ))),
113 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
114 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
115 ))),
116 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
117 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
118 ))),
119 "void_type" => Ok(Self::VoidType(::std::boxed::Box::new(
120 <VoidType as ::treesitter_types::FromNode>::from_node(node, src)?,
121 ))),
122 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
123 }
124 }
125}
126impl ::treesitter_types::Spanned for SimpleType<'_> {
127 fn span(&self) -> ::treesitter_types::Span {
128 match self {
129 Self::BooleanType(inner) => inner.span(),
130 Self::FloatingPointType(inner) => inner.span(),
131 Self::GenericType(inner) => inner.span(),
132 Self::IntegralType(inner) => inner.span(),
133 Self::ScopedTypeIdentifier(inner) => inner.span(),
134 Self::TypeIdentifier(inner) => inner.span(),
135 Self::VoidType(inner) => inner.span(),
136 }
137 }
138}
139#[derive(Debug, Clone)]
140pub enum Type<'tree> {
141 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
142 AnnotatedType(::std::boxed::Box<AnnotatedType<'tree>>),
143}
144impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
145 #[allow(clippy::collapsible_else_if)]
146 fn from_node(
147 node: ::tree_sitter::Node<'tree>,
148 src: &'tree [u8],
149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
150 match node.kind() {
151 "annotated_type" => Ok(Self::AnnotatedType(::std::boxed::Box::new(
152 <AnnotatedType as ::treesitter_types::FromNode>::from_node(node, src)?,
153 ))),
154 _other => {
155 if let Ok(v) =
156 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
157 {
158 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
159 } else {
160 Err(::treesitter_types::ParseError::unexpected_kind(
161 _other, node,
162 ))
163 }
164 }
165 }
166 }
167}
168impl ::treesitter_types::Spanned for Type<'_> {
169 fn span(&self) -> ::treesitter_types::Span {
170 match self {
171 Self::UnannotatedType(inner) => inner.span(),
172 Self::AnnotatedType(inner) => inner.span(),
173 }
174 }
175}
176#[derive(Debug, Clone)]
177pub enum UnannotatedType<'tree> {
178 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
179 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
180}
181impl<'tree> ::treesitter_types::FromNode<'tree> for UnannotatedType<'tree> {
182 #[allow(clippy::collapsible_else_if)]
183 fn from_node(
184 node: ::tree_sitter::Node<'tree>,
185 src: &'tree [u8],
186 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
187 match node.kind() {
188 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
189 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
190 ))),
191 _other => {
192 if let Ok(v) = <SimpleType as ::treesitter_types::FromNode>::from_node(node, src) {
193 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
194 } else {
195 Err(::treesitter_types::ParseError::unexpected_kind(
196 _other, node,
197 ))
198 }
199 }
200 }
201 }
202}
203impl ::treesitter_types::Spanned for UnannotatedType<'_> {
204 fn span(&self) -> ::treesitter_types::Span {
205 match self {
206 Self::SimpleType(inner) => inner.span(),
207 Self::ArrayType(inner) => inner.span(),
208 }
209 }
210}
211#[derive(Debug, Clone)]
212pub enum Declaration<'tree> {
213 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
214 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
215 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
216 ImportDeclaration(::std::boxed::Box<ImportDeclaration<'tree>>),
217 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
218 ModuleDeclaration(::std::boxed::Box<ModuleDeclaration<'tree>>),
219 PackageDeclaration(::std::boxed::Box<PackageDeclaration<'tree>>),
220 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
221}
222impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
223 #[allow(clippy::collapsible_else_if)]
224 fn from_node(
225 node: ::tree_sitter::Node<'tree>,
226 src: &'tree [u8],
227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
228 match node.kind() {
229 "annotation_type_declaration" => {
230 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
231 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
232 node, src,
233 )?,
234 )))
235 }
236 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
237 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
238 ))),
239 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
240 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
241 ))),
242 "import_declaration" => Ok(Self::ImportDeclaration(::std::boxed::Box::new(
243 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
244 ))),
245 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
246 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
247 ))),
248 "module_declaration" => Ok(Self::ModuleDeclaration(::std::boxed::Box::new(
249 <ModuleDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
250 ))),
251 "package_declaration" => Ok(Self::PackageDeclaration(::std::boxed::Box::new(
252 <PackageDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
253 ))),
254 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
255 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
256 ))),
257 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
258 }
259 }
260}
261impl ::treesitter_types::Spanned for Declaration<'_> {
262 fn span(&self) -> ::treesitter_types::Span {
263 match self {
264 Self::AnnotationTypeDeclaration(inner) => inner.span(),
265 Self::ClassDeclaration(inner) => inner.span(),
266 Self::EnumDeclaration(inner) => inner.span(),
267 Self::ImportDeclaration(inner) => inner.span(),
268 Self::InterfaceDeclaration(inner) => inner.span(),
269 Self::ModuleDeclaration(inner) => inner.span(),
270 Self::PackageDeclaration(inner) => inner.span(),
271 Self::RecordDeclaration(inner) => inner.span(),
272 }
273 }
274}
275#[derive(Debug, Clone)]
276pub enum Expression<'tree> {
277 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
278 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
279 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
280 InstanceofExpression(::std::boxed::Box<InstanceofExpression<'tree>>),
281 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
282 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
283 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
284 TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
285 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
286 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
287}
288impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
289 #[allow(clippy::collapsible_else_if)]
290 fn from_node(
291 node: ::tree_sitter::Node<'tree>,
292 src: &'tree [u8],
293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
294 match node.kind() {
295 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
296 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
297 ))),
298 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
299 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
300 ))),
301 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
302 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
303 ))),
304 "instanceof_expression" => Ok(Self::InstanceofExpression(::std::boxed::Box::new(
305 <InstanceofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
306 ))),
307 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
308 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
309 ))),
310 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
311 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
312 ))),
313 "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
314 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
315 ))),
316 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
317 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
318 ))),
319 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
320 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
321 ))),
322 _other => {
323 if let Ok(v) =
324 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
325 {
326 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
327 } else {
328 Err(::treesitter_types::ParseError::unexpected_kind(
329 _other, node,
330 ))
331 }
332 }
333 }
334 }
335}
336impl ::treesitter_types::Spanned for Expression<'_> {
337 fn span(&self) -> ::treesitter_types::Span {
338 match self {
339 Self::AssignmentExpression(inner) => inner.span(),
340 Self::BinaryExpression(inner) => inner.span(),
341 Self::CastExpression(inner) => inner.span(),
342 Self::InstanceofExpression(inner) => inner.span(),
343 Self::LambdaExpression(inner) => inner.span(),
344 Self::PrimaryExpression(inner) => inner.span(),
345 Self::SwitchExpression(inner) => inner.span(),
346 Self::TernaryExpression(inner) => inner.span(),
347 Self::UnaryExpression(inner) => inner.span(),
348 Self::UpdateExpression(inner) => inner.span(),
349 }
350 }
351}
352#[derive(Debug, Clone)]
353pub enum ModuleDirective<'tree> {
354 ExportsModuleDirective(::std::boxed::Box<ExportsModuleDirective<'tree>>),
355 OpensModuleDirective(::std::boxed::Box<OpensModuleDirective<'tree>>),
356 ProvidesModuleDirective(::std::boxed::Box<ProvidesModuleDirective<'tree>>),
357 RequiresModuleDirective(::std::boxed::Box<RequiresModuleDirective<'tree>>),
358 UsesModuleDirective(::std::boxed::Box<UsesModuleDirective<'tree>>),
359}
360impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDirective<'tree> {
361 #[allow(clippy::collapsible_else_if)]
362 fn from_node(
363 node: ::tree_sitter::Node<'tree>,
364 src: &'tree [u8],
365 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
366 match node.kind() {
367 "exports_module_directive" => Ok(Self::ExportsModuleDirective(::std::boxed::Box::new(
368 <ExportsModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
369 ))),
370 "opens_module_directive" => Ok(Self::OpensModuleDirective(::std::boxed::Box::new(
371 <OpensModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
372 ))),
373 "provides_module_directive" => {
374 Ok(Self::ProvidesModuleDirective(::std::boxed::Box::new(
375 <ProvidesModuleDirective as ::treesitter_types::FromNode>::from_node(
376 node, src,
377 )?,
378 )))
379 }
380 "requires_module_directive" => {
381 Ok(Self::RequiresModuleDirective(::std::boxed::Box::new(
382 <RequiresModuleDirective as ::treesitter_types::FromNode>::from_node(
383 node, src,
384 )?,
385 )))
386 }
387 "uses_module_directive" => Ok(Self::UsesModuleDirective(::std::boxed::Box::new(
388 <UsesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
389 ))),
390 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
391 }
392 }
393}
394impl ::treesitter_types::Spanned for ModuleDirective<'_> {
395 fn span(&self) -> ::treesitter_types::Span {
396 match self {
397 Self::ExportsModuleDirective(inner) => inner.span(),
398 Self::OpensModuleDirective(inner) => inner.span(),
399 Self::ProvidesModuleDirective(inner) => inner.span(),
400 Self::RequiresModuleDirective(inner) => inner.span(),
401 Self::UsesModuleDirective(inner) => inner.span(),
402 }
403 }
404}
405#[derive(Debug, Clone)]
406pub enum PrimaryExpression<'tree> {
407 Literal(::std::boxed::Box<Literal<'tree>>),
408 ArrayAccess(::std::boxed::Box<ArrayAccess<'tree>>),
409 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
410 ClassLiteral(::std::boxed::Box<ClassLiteral<'tree>>),
411 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
412 Identifier(::std::boxed::Box<Identifier<'tree>>),
413 MethodInvocation(::std::boxed::Box<MethodInvocation<'tree>>),
414 MethodReference(::std::boxed::Box<MethodReference<'tree>>),
415 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
416 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
417 TemplateExpression(::std::boxed::Box<TemplateExpression<'tree>>),
418 This(::std::boxed::Box<This<'tree>>),
419}
420impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
421 #[allow(clippy::collapsible_else_if)]
422 fn from_node(
423 node: ::tree_sitter::Node<'tree>,
424 src: &'tree [u8],
425 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
426 match node.kind() {
427 "array_access" => Ok(Self::ArrayAccess(::std::boxed::Box::new(
428 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
429 ))),
430 "array_creation_expression" => {
431 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
432 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
433 node, src,
434 )?,
435 )))
436 }
437 "class_literal" => Ok(Self::ClassLiteral(::std::boxed::Box::new(
438 <ClassLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
439 ))),
440 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
441 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
442 ))),
443 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
444 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
445 ))),
446 "method_invocation" => Ok(Self::MethodInvocation(::std::boxed::Box::new(
447 <MethodInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
448 ))),
449 "method_reference" => Ok(Self::MethodReference(::std::boxed::Box::new(
450 <MethodReference as ::treesitter_types::FromNode>::from_node(node, src)?,
451 ))),
452 "object_creation_expression" => {
453 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
454 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
455 node, src,
456 )?,
457 )))
458 }
459 "parenthesized_expression" => {
460 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
461 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
462 node, src,
463 )?,
464 )))
465 }
466 "template_expression" => Ok(Self::TemplateExpression(::std::boxed::Box::new(
467 <TemplateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
468 ))),
469 "this" => Ok(Self::This(::std::boxed::Box::new(
470 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
471 ))),
472 _other => {
473 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
474 Ok(Self::Literal(::std::boxed::Box::new(v)))
475 } else {
476 Err(::treesitter_types::ParseError::unexpected_kind(
477 _other, node,
478 ))
479 }
480 }
481 }
482 }
483}
484impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
485 fn span(&self) -> ::treesitter_types::Span {
486 match self {
487 Self::Literal(inner) => inner.span(),
488 Self::ArrayAccess(inner) => inner.span(),
489 Self::ArrayCreationExpression(inner) => inner.span(),
490 Self::ClassLiteral(inner) => inner.span(),
491 Self::FieldAccess(inner) => inner.span(),
492 Self::Identifier(inner) => inner.span(),
493 Self::MethodInvocation(inner) => inner.span(),
494 Self::MethodReference(inner) => inner.span(),
495 Self::ObjectCreationExpression(inner) => inner.span(),
496 Self::ParenthesizedExpression(inner) => inner.span(),
497 Self::TemplateExpression(inner) => inner.span(),
498 Self::This(inner) => inner.span(),
499 }
500 }
501}
502#[derive(Debug, Clone)]
503pub enum Statement<'tree> {
504 Semicolon(::treesitter_types::Span),
505 AssertStatement(::std::boxed::Box<AssertStatement<'tree>>),
506 Block(::std::boxed::Box<Block<'tree>>),
507 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
508 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
509 Declaration(::std::boxed::Box<Declaration<'tree>>),
510 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
511 EnhancedForStatement(::std::boxed::Box<EnhancedForStatement<'tree>>),
512 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
513 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
514 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
515 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
516 LocalVariableDeclaration(::std::boxed::Box<LocalVariableDeclaration<'tree>>),
517 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
518 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
519 SynchronizedStatement(::std::boxed::Box<SynchronizedStatement<'tree>>),
520 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
521 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
522 TryWithResourcesStatement(::std::boxed::Box<TryWithResourcesStatement<'tree>>),
523 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
524 YieldStatement(::std::boxed::Box<YieldStatement<'tree>>),
525}
526impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
527 #[allow(clippy::collapsible_else_if)]
528 fn from_node(
529 node: ::tree_sitter::Node<'tree>,
530 src: &'tree [u8],
531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
532 match node.kind() {
533 ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
534 "assert_statement" => Ok(Self::AssertStatement(::std::boxed::Box::new(
535 <AssertStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
536 ))),
537 "block" => Ok(Self::Block(::std::boxed::Box::new(
538 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
539 ))),
540 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
541 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
542 ))),
543 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
544 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
545 ))),
546 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
547 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
548 ))),
549 "enhanced_for_statement" => Ok(Self::EnhancedForStatement(::std::boxed::Box::new(
550 <EnhancedForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
551 ))),
552 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
553 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
554 ))),
555 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
556 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
557 ))),
558 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
559 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
560 ))),
561 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
562 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
563 ))),
564 "local_variable_declaration" => {
565 Ok(Self::LocalVariableDeclaration(::std::boxed::Box::new(
566 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(
567 node, src,
568 )?,
569 )))
570 }
571 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
572 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
573 ))),
574 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
575 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
576 ))),
577 "synchronized_statement" => Ok(Self::SynchronizedStatement(::std::boxed::Box::new(
578 <SynchronizedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
579 ))),
580 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
581 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
582 ))),
583 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
584 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
585 ))),
586 "try_with_resources_statement" => {
587 Ok(Self::TryWithResourcesStatement(::std::boxed::Box::new(
588 <TryWithResourcesStatement as ::treesitter_types::FromNode>::from_node(
589 node, src,
590 )?,
591 )))
592 }
593 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
594 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
595 ))),
596 "yield_statement" => Ok(Self::YieldStatement(::std::boxed::Box::new(
597 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
598 ))),
599 _other => {
600 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
601 Ok(Self::Declaration(::std::boxed::Box::new(v)))
602 } else {
603 Err(::treesitter_types::ParseError::unexpected_kind(
604 _other, node,
605 ))
606 }
607 }
608 }
609 }
610}
611impl ::treesitter_types::Spanned for Statement<'_> {
612 fn span(&self) -> ::treesitter_types::Span {
613 match self {
614 Self::Semicolon(span) => *span,
615 Self::AssertStatement(inner) => inner.span(),
616 Self::Block(inner) => inner.span(),
617 Self::BreakStatement(inner) => inner.span(),
618 Self::ContinueStatement(inner) => inner.span(),
619 Self::Declaration(inner) => inner.span(),
620 Self::DoStatement(inner) => inner.span(),
621 Self::EnhancedForStatement(inner) => inner.span(),
622 Self::ExpressionStatement(inner) => inner.span(),
623 Self::ForStatement(inner) => inner.span(),
624 Self::IfStatement(inner) => inner.span(),
625 Self::LabeledStatement(inner) => inner.span(),
626 Self::LocalVariableDeclaration(inner) => inner.span(),
627 Self::ReturnStatement(inner) => inner.span(),
628 Self::SwitchExpression(inner) => inner.span(),
629 Self::SynchronizedStatement(inner) => inner.span(),
630 Self::ThrowStatement(inner) => inner.span(),
631 Self::TryStatement(inner) => inner.span(),
632 Self::TryWithResourcesStatement(inner) => inner.span(),
633 Self::WhileStatement(inner) => inner.span(),
634 Self::YieldStatement(inner) => inner.span(),
635 }
636 }
637}
638#[derive(Debug, Clone)]
639pub struct AnnotatedType<'tree> {
640 pub span: ::treesitter_types::Span,
641 pub children: ::std::vec::Vec<AnnotatedTypeChildren<'tree>>,
642}
643impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotatedType<'tree> {
644 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
645 fn from_node(
646 node: ::tree_sitter::Node<'tree>,
647 src: &'tree [u8],
648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
649 debug_assert_eq!(node.kind(), "annotated_type");
650 Ok(Self {
651 span: ::treesitter_types::Span::from(node),
652 children: {
653 #[allow(clippy::suspicious_else_formatting)]
654 let non_field_children = {
655 let mut cursor = node.walk();
656 let mut result = ::std::vec::Vec::new();
657 if cursor.goto_first_child() {
658 loop {
659 if cursor.field_name().is_none()
660 && cursor.node().is_named()
661 && !cursor.node().is_extra()
662 {
663 result.push(cursor.node());
664 }
665 if !cursor.goto_next_sibling() {
666 break;
667 }
668 }
669 }
670 result
671 };
672 let mut items = ::std::vec::Vec::new();
673 for child in non_field_children {
674 items.push(
675 <AnnotatedTypeChildren as ::treesitter_types::FromNode>::from_node(
676 child, src,
677 )?,
678 );
679 }
680 items
681 },
682 })
683 }
684}
685impl ::treesitter_types::Spanned for AnnotatedType<'_> {
686 fn span(&self) -> ::treesitter_types::Span {
687 self.span
688 }
689}
690#[derive(Debug, Clone)]
691pub struct Annotation<'tree> {
692 pub span: ::treesitter_types::Span,
693 pub arguments: AnnotationArgumentList<'tree>,
694 pub name: AnnotationName<'tree>,
695}
696impl<'tree> ::treesitter_types::FromNode<'tree> for Annotation<'tree> {
697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
698 fn from_node(
699 node: ::tree_sitter::Node<'tree>,
700 src: &'tree [u8],
701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
702 debug_assert_eq!(node.kind(), "annotation");
703 Ok(Self {
704 span: ::treesitter_types::Span::from(node),
705 arguments: {
706 let child = node.child_by_field_name("arguments").ok_or_else(|| {
707 ::treesitter_types::ParseError::missing_field("arguments", node)
708 })?;
709 <AnnotationArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
710 },
711 name: {
712 let child = node
713 .child_by_field_name("name")
714 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
715 <AnnotationName as ::treesitter_types::FromNode>::from_node(child, src)?
716 },
717 })
718 }
719}
720impl ::treesitter_types::Spanned for Annotation<'_> {
721 fn span(&self) -> ::treesitter_types::Span {
722 self.span
723 }
724}
725#[derive(Debug, Clone)]
726pub struct AnnotationArgumentList<'tree> {
727 pub span: ::treesitter_types::Span,
728 pub children: ::std::vec::Vec<AnnotationArgumentListChildren<'tree>>,
729}
730impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationArgumentList<'tree> {
731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
732 fn from_node(
733 node: ::tree_sitter::Node<'tree>,
734 src: &'tree [u8],
735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
736 debug_assert_eq!(node.kind(), "annotation_argument_list");
737 Ok(Self {
738 span: ::treesitter_types::Span::from(node),
739 children: {
740 #[allow(clippy::suspicious_else_formatting)]
741 let non_field_children = {
742 let mut cursor = node.walk();
743 let mut result = ::std::vec::Vec::new();
744 if cursor.goto_first_child() {
745 loop {
746 if cursor.field_name().is_none()
747 && cursor.node().is_named()
748 && !cursor.node().is_extra()
749 {
750 result.push(cursor.node());
751 }
752 if !cursor.goto_next_sibling() {
753 break;
754 }
755 }
756 }
757 result
758 };
759 let mut items = ::std::vec::Vec::new();
760 for child in non_field_children {
761 items
762 .push(
763 <AnnotationArgumentListChildren as ::treesitter_types::FromNode>::from_node(
764 child,
765 src,
766 )?,
767 );
768 }
769 items
770 },
771 })
772 }
773}
774impl ::treesitter_types::Spanned for AnnotationArgumentList<'_> {
775 fn span(&self) -> ::treesitter_types::Span {
776 self.span
777 }
778}
779#[derive(Debug, Clone)]
780pub struct AnnotationTypeBody<'tree> {
781 pub span: ::treesitter_types::Span,
782 pub children: ::std::vec::Vec<AnnotationTypeBodyChildren<'tree>>,
783}
784impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeBody<'tree> {
785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
786 fn from_node(
787 node: ::tree_sitter::Node<'tree>,
788 src: &'tree [u8],
789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
790 debug_assert_eq!(node.kind(), "annotation_type_body");
791 Ok(Self {
792 span: ::treesitter_types::Span::from(node),
793 children: {
794 #[allow(clippy::suspicious_else_formatting)]
795 let non_field_children = {
796 let mut cursor = node.walk();
797 let mut result = ::std::vec::Vec::new();
798 if cursor.goto_first_child() {
799 loop {
800 if cursor.field_name().is_none()
801 && cursor.node().is_named()
802 && !cursor.node().is_extra()
803 {
804 result.push(cursor.node());
805 }
806 if !cursor.goto_next_sibling() {
807 break;
808 }
809 }
810 }
811 result
812 };
813 let mut items = ::std::vec::Vec::new();
814 for child in non_field_children {
815 items.push(
816 <AnnotationTypeBodyChildren as ::treesitter_types::FromNode>::from_node(
817 child, src,
818 )?,
819 );
820 }
821 items
822 },
823 })
824 }
825}
826impl ::treesitter_types::Spanned for AnnotationTypeBody<'_> {
827 fn span(&self) -> ::treesitter_types::Span {
828 self.span
829 }
830}
831#[derive(Debug, Clone)]
832pub struct AnnotationTypeDeclaration<'tree> {
833 pub span: ::treesitter_types::Span,
834 pub body: AnnotationTypeBody<'tree>,
835 pub name: Identifier<'tree>,
836 pub children: ::core::option::Option<Modifiers<'tree>>,
837}
838impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeDeclaration<'tree> {
839 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
840 fn from_node(
841 node: ::tree_sitter::Node<'tree>,
842 src: &'tree [u8],
843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
844 debug_assert_eq!(node.kind(), "annotation_type_declaration");
845 Ok(Self {
846 span: ::treesitter_types::Span::from(node),
847 body: {
848 let child = node
849 .child_by_field_name("body")
850 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
851 <AnnotationTypeBody as ::treesitter_types::FromNode>::from_node(child, src)?
852 },
853 name: {
854 let child = node
855 .child_by_field_name("name")
856 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
857 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
858 },
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 match non_field_children.first() {
880 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
881 child, src,
882 )?),
883 None => None,
884 }
885 },
886 })
887 }
888}
889impl ::treesitter_types::Spanned for AnnotationTypeDeclaration<'_> {
890 fn span(&self) -> ::treesitter_types::Span {
891 self.span
892 }
893}
894#[derive(Debug, Clone)]
895pub struct AnnotationTypeElementDeclaration<'tree> {
896 pub span: ::treesitter_types::Span,
897 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
898 pub name: Identifier<'tree>,
899 pub r#type: UnannotatedType<'tree>,
900 pub value: ::core::option::Option<AnnotationTypeElementDeclarationValue<'tree>>,
901 pub children: ::core::option::Option<Modifiers<'tree>>,
902}
903impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeElementDeclaration<'tree> {
904 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
905 fn from_node(
906 node: ::tree_sitter::Node<'tree>,
907 src: &'tree [u8],
908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
909 debug_assert_eq!(node.kind(), "annotation_type_element_declaration");
910 Ok(Self {
911 span: ::treesitter_types::Span::from(node),
912 dimensions: match node.child_by_field_name("dimensions") {
913 Some(child) => {
914 Some(
915 <Dimensions as ::treesitter_types::FromNode>::from_node(
916 child,
917 src,
918 )?,
919 )
920 }
921 None => None,
922 },
923 name: {
924 let child = node
925 .child_by_field_name("name")
926 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
927 "name",
928 node,
929 ))?;
930 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
931 },
932 r#type: {
933 let child = node
934 .child_by_field_name("type")
935 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
936 "type",
937 node,
938 ))?;
939 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
940 },
941 value: match node.child_by_field_name("value") {
942 Some(child) => {
943 Some(
944 <AnnotationTypeElementDeclarationValue as ::treesitter_types::FromNode>::from_node(
945 child,
946 src,
947 )?,
948 )
949 }
950 None => None,
951 },
952 children: {
953 #[allow(clippy::suspicious_else_formatting)]
954 let non_field_children = {
955 let mut cursor = node.walk();
956 let mut result = ::std::vec::Vec::new();
957 if cursor.goto_first_child() {
958 loop {
959 if cursor.field_name().is_none() && cursor.node().is_named()
960 && !cursor.node().is_extra()
961 {
962 result.push(cursor.node());
963 }
964 if !cursor.goto_next_sibling() {
965 break;
966 }
967 }
968 }
969 result
970 };
971 match non_field_children.first() {
972 Some(&child) => {
973 Some(
974 <Modifiers as ::treesitter_types::FromNode>::from_node(
975 child,
976 src,
977 )?,
978 )
979 }
980 None => None,
981 }
982 },
983 })
984 }
985}
986impl ::treesitter_types::Spanned for AnnotationTypeElementDeclaration<'_> {
987 fn span(&self) -> ::treesitter_types::Span {
988 self.span
989 }
990}
991#[derive(Debug, Clone)]
992pub struct ArgumentList<'tree> {
993 pub span: ::treesitter_types::Span,
994 pub children: ::std::vec::Vec<Expression<'tree>>,
995}
996impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
997 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
998 fn from_node(
999 node: ::tree_sitter::Node<'tree>,
1000 src: &'tree [u8],
1001 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1002 debug_assert_eq!(node.kind(), "argument_list");
1003 Ok(Self {
1004 span: ::treesitter_types::Span::from(node),
1005 children: {
1006 #[allow(clippy::suspicious_else_formatting)]
1007 let non_field_children = {
1008 let mut cursor = node.walk();
1009 let mut result = ::std::vec::Vec::new();
1010 if cursor.goto_first_child() {
1011 loop {
1012 if cursor.field_name().is_none()
1013 && cursor.node().is_named()
1014 && !cursor.node().is_extra()
1015 {
1016 result.push(cursor.node());
1017 }
1018 if !cursor.goto_next_sibling() {
1019 break;
1020 }
1021 }
1022 }
1023 result
1024 };
1025 let mut items = ::std::vec::Vec::new();
1026 for child in non_field_children {
1027 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
1028 child, src,
1029 )?);
1030 }
1031 items
1032 },
1033 })
1034 }
1035}
1036impl ::treesitter_types::Spanned for ArgumentList<'_> {
1037 fn span(&self) -> ::treesitter_types::Span {
1038 self.span
1039 }
1040}
1041#[derive(Debug, Clone)]
1042pub struct ArrayAccess<'tree> {
1043 pub span: ::treesitter_types::Span,
1044 pub array: PrimaryExpression<'tree>,
1045 pub index: Expression<'tree>,
1046}
1047impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayAccess<'tree> {
1048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1049 fn from_node(
1050 node: ::tree_sitter::Node<'tree>,
1051 src: &'tree [u8],
1052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1053 debug_assert_eq!(node.kind(), "array_access");
1054 Ok(Self {
1055 span: ::treesitter_types::Span::from(node),
1056 array: {
1057 let child = node
1058 .child_by_field_name("array")
1059 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("array", node))?;
1060 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
1061 },
1062 index: {
1063 let child = node
1064 .child_by_field_name("index")
1065 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
1066 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1067 },
1068 })
1069 }
1070}
1071impl ::treesitter_types::Spanned for ArrayAccess<'_> {
1072 fn span(&self) -> ::treesitter_types::Span {
1073 self.span
1074 }
1075}
1076#[derive(Debug, Clone)]
1077pub struct ArrayCreationExpression<'tree> {
1078 pub span: ::treesitter_types::Span,
1079 pub dimensions: ::std::vec::Vec<ArrayCreationExpressionDimensions<'tree>>,
1080 pub r#type: SimpleType<'tree>,
1081 pub value: ::core::option::Option<ArrayInitializer<'tree>>,
1082 pub children: ::std::vec::Vec<ArrayCreationExpressionChildren<'tree>>,
1083}
1084impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1085 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1086 fn from_node(
1087 node: ::tree_sitter::Node<'tree>,
1088 src: &'tree [u8],
1089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1090 debug_assert_eq!(node.kind(), "array_creation_expression");
1091 Ok(Self {
1092 span: ::treesitter_types::Span::from(node),
1093 dimensions: {
1094 let mut cursor = node.walk();
1095 let mut items = ::std::vec::Vec::new();
1096 for child in node.children_by_field_name("dimensions", &mut cursor) {
1097 items
1098 .push(
1099 <ArrayCreationExpressionDimensions as ::treesitter_types::FromNode>::from_node(
1100 child,
1101 src,
1102 )?,
1103 );
1104 }
1105 items
1106 },
1107 r#type: {
1108 let child = node
1109 .child_by_field_name("type")
1110 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1111 <SimpleType as ::treesitter_types::FromNode>::from_node(child, src)?
1112 },
1113 value: match node.child_by_field_name("value") {
1114 Some(child) => {
1115 Some(<ArrayInitializer as ::treesitter_types::FromNode>::from_node(child, src)?)
1116 }
1117 None => None,
1118 },
1119 children: {
1120 #[allow(clippy::suspicious_else_formatting)]
1121 let non_field_children = {
1122 let mut cursor = node.walk();
1123 let mut result = ::std::vec::Vec::new();
1124 if cursor.goto_first_child() {
1125 loop {
1126 if cursor.field_name().is_none()
1127 && cursor.node().is_named()
1128 && !cursor.node().is_extra()
1129 {
1130 result.push(cursor.node());
1131 }
1132 if !cursor.goto_next_sibling() {
1133 break;
1134 }
1135 }
1136 }
1137 result
1138 };
1139 let mut items = ::std::vec::Vec::new();
1140 for child in non_field_children {
1141 items
1142 .push(
1143 <ArrayCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
1144 child,
1145 src,
1146 )?,
1147 );
1148 }
1149 items
1150 },
1151 })
1152 }
1153}
1154impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1155 fn span(&self) -> ::treesitter_types::Span {
1156 self.span
1157 }
1158}
1159#[derive(Debug, Clone)]
1160pub struct ArrayInitializer<'tree> {
1161 pub span: ::treesitter_types::Span,
1162 pub children: ::std::vec::Vec<ArrayInitializerChildren<'tree>>,
1163}
1164impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayInitializer<'tree> {
1165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1166 fn from_node(
1167 node: ::tree_sitter::Node<'tree>,
1168 src: &'tree [u8],
1169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1170 debug_assert_eq!(node.kind(), "array_initializer");
1171 Ok(Self {
1172 span: ::treesitter_types::Span::from(node),
1173 children: {
1174 #[allow(clippy::suspicious_else_formatting)]
1175 let non_field_children = {
1176 let mut cursor = node.walk();
1177 let mut result = ::std::vec::Vec::new();
1178 if cursor.goto_first_child() {
1179 loop {
1180 if cursor.field_name().is_none()
1181 && cursor.node().is_named()
1182 && !cursor.node().is_extra()
1183 {
1184 result.push(cursor.node());
1185 }
1186 if !cursor.goto_next_sibling() {
1187 break;
1188 }
1189 }
1190 }
1191 result
1192 };
1193 let mut items = ::std::vec::Vec::new();
1194 for child in non_field_children {
1195 items.push(
1196 <ArrayInitializerChildren as ::treesitter_types::FromNode>::from_node(
1197 child, src,
1198 )?,
1199 );
1200 }
1201 items
1202 },
1203 })
1204 }
1205}
1206impl ::treesitter_types::Spanned for ArrayInitializer<'_> {
1207 fn span(&self) -> ::treesitter_types::Span {
1208 self.span
1209 }
1210}
1211#[derive(Debug, Clone)]
1212pub struct ArrayType<'tree> {
1213 pub span: ::treesitter_types::Span,
1214 pub dimensions: Dimensions<'tree>,
1215 pub element: UnannotatedType<'tree>,
1216}
1217impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1218 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1219 fn from_node(
1220 node: ::tree_sitter::Node<'tree>,
1221 src: &'tree [u8],
1222 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1223 debug_assert_eq!(node.kind(), "array_type");
1224 Ok(Self {
1225 span: ::treesitter_types::Span::from(node),
1226 dimensions: {
1227 let child = node.child_by_field_name("dimensions").ok_or_else(|| {
1228 ::treesitter_types::ParseError::missing_field("dimensions", node)
1229 })?;
1230 <Dimensions as ::treesitter_types::FromNode>::from_node(child, src)?
1231 },
1232 element: {
1233 let child = node.child_by_field_name("element").ok_or_else(|| {
1234 ::treesitter_types::ParseError::missing_field("element", node)
1235 })?;
1236 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
1237 },
1238 })
1239 }
1240}
1241impl ::treesitter_types::Spanned for ArrayType<'_> {
1242 fn span(&self) -> ::treesitter_types::Span {
1243 self.span
1244 }
1245}
1246#[derive(Debug, Clone)]
1247pub struct AssertStatement<'tree> {
1248 pub span: ::treesitter_types::Span,
1249 pub children: ::std::vec::Vec<Expression<'tree>>,
1250}
1251impl<'tree> ::treesitter_types::FromNode<'tree> for AssertStatement<'tree> {
1252 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1253 fn from_node(
1254 node: ::tree_sitter::Node<'tree>,
1255 src: &'tree [u8],
1256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1257 debug_assert_eq!(node.kind(), "assert_statement");
1258 Ok(Self {
1259 span: ::treesitter_types::Span::from(node),
1260 children: {
1261 #[allow(clippy::suspicious_else_formatting)]
1262 let non_field_children = {
1263 let mut cursor = node.walk();
1264 let mut result = ::std::vec::Vec::new();
1265 if cursor.goto_first_child() {
1266 loop {
1267 if cursor.field_name().is_none()
1268 && cursor.node().is_named()
1269 && !cursor.node().is_extra()
1270 {
1271 result.push(cursor.node());
1272 }
1273 if !cursor.goto_next_sibling() {
1274 break;
1275 }
1276 }
1277 }
1278 result
1279 };
1280 let mut items = ::std::vec::Vec::new();
1281 for child in non_field_children {
1282 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
1283 child, src,
1284 )?);
1285 }
1286 items
1287 },
1288 })
1289 }
1290}
1291impl ::treesitter_types::Spanned for AssertStatement<'_> {
1292 fn span(&self) -> ::treesitter_types::Span {
1293 self.span
1294 }
1295}
1296#[derive(Debug, Clone)]
1297pub struct AssignmentExpression<'tree> {
1298 pub span: ::treesitter_types::Span,
1299 pub left: AssignmentExpressionLeft<'tree>,
1300 pub operator: AssignmentExpressionOperator,
1301 pub right: Expression<'tree>,
1302}
1303impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1304 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1305 fn from_node(
1306 node: ::tree_sitter::Node<'tree>,
1307 src: &'tree [u8],
1308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1309 debug_assert_eq!(node.kind(), "assignment_expression");
1310 Ok(Self {
1311 span: ::treesitter_types::Span::from(node),
1312 left: {
1313 let child = node
1314 .child_by_field_name("left")
1315 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1316 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1317 },
1318 operator: {
1319 let child = node.child_by_field_name("operator").ok_or_else(|| {
1320 ::treesitter_types::ParseError::missing_field("operator", node)
1321 })?;
1322 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1323 child, src,
1324 )?
1325 },
1326 right: {
1327 let child = node
1328 .child_by_field_name("right")
1329 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1330 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1331 },
1332 })
1333 }
1334}
1335impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1336 fn span(&self) -> ::treesitter_types::Span {
1337 self.span
1338 }
1339}
1340#[derive(Debug, Clone)]
1341pub struct Asterisk<'tree> {
1342 pub span: ::treesitter_types::Span,
1343 text: &'tree str,
1344}
1345impl<'tree> ::treesitter_types::FromNode<'tree> for Asterisk<'tree> {
1346 fn from_node(
1347 node: ::tree_sitter::Node<'tree>,
1348 src: &'tree [u8],
1349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1350 debug_assert_eq!(node.kind(), "asterisk");
1351 Ok(Self {
1352 span: ::treesitter_types::Span::from(node),
1353 text: node.utf8_text(src)?,
1354 })
1355 }
1356}
1357impl<'tree> ::treesitter_types::LeafNode<'tree> for Asterisk<'tree> {
1358 fn text(&self) -> &'tree str {
1359 self.text
1360 }
1361}
1362impl ::treesitter_types::Spanned for Asterisk<'_> {
1363 fn span(&self) -> ::treesitter_types::Span {
1364 self.span
1365 }
1366}
1367#[derive(Debug, Clone)]
1368pub struct BinaryExpression<'tree> {
1369 pub span: ::treesitter_types::Span,
1370 pub left: Expression<'tree>,
1371 pub operator: BinaryExpressionOperator,
1372 pub right: Expression<'tree>,
1373}
1374impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1375 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1376 fn from_node(
1377 node: ::tree_sitter::Node<'tree>,
1378 src: &'tree [u8],
1379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1380 debug_assert_eq!(node.kind(), "binary_expression");
1381 Ok(Self {
1382 span: ::treesitter_types::Span::from(node),
1383 left: {
1384 let child = node
1385 .child_by_field_name("left")
1386 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1387 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1388 },
1389 operator: {
1390 let child = node.child_by_field_name("operator").ok_or_else(|| {
1391 ::treesitter_types::ParseError::missing_field("operator", node)
1392 })?;
1393 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1394 },
1395 right: {
1396 let child = node
1397 .child_by_field_name("right")
1398 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1399 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1400 },
1401 })
1402 }
1403}
1404impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1405 fn span(&self) -> ::treesitter_types::Span {
1406 self.span
1407 }
1408}
1409#[derive(Debug, Clone)]
1410pub struct Block<'tree> {
1411 pub span: ::treesitter_types::Span,
1412 pub children: ::std::vec::Vec<Statement<'tree>>,
1413}
1414impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1415 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1416 fn from_node(
1417 node: ::tree_sitter::Node<'tree>,
1418 src: &'tree [u8],
1419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1420 debug_assert_eq!(node.kind(), "block");
1421 Ok(Self {
1422 span: ::treesitter_types::Span::from(node),
1423 children: {
1424 #[allow(clippy::suspicious_else_formatting)]
1425 let non_field_children = {
1426 let mut cursor = node.walk();
1427 let mut result = ::std::vec::Vec::new();
1428 if cursor.goto_first_child() {
1429 loop {
1430 if cursor.field_name().is_none()
1431 && cursor.node().is_named()
1432 && !cursor.node().is_extra()
1433 {
1434 result.push(cursor.node());
1435 }
1436 if !cursor.goto_next_sibling() {
1437 break;
1438 }
1439 }
1440 }
1441 result
1442 };
1443 let mut items = ::std::vec::Vec::new();
1444 for child in non_field_children {
1445 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
1446 child, src,
1447 )?);
1448 }
1449 items
1450 },
1451 })
1452 }
1453}
1454impl ::treesitter_types::Spanned for Block<'_> {
1455 fn span(&self) -> ::treesitter_types::Span {
1456 self.span
1457 }
1458}
1459#[derive(Debug, Clone)]
1460pub struct BreakStatement<'tree> {
1461 pub span: ::treesitter_types::Span,
1462 pub children: ::core::option::Option<Identifier<'tree>>,
1463}
1464impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1465 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1466 fn from_node(
1467 node: ::tree_sitter::Node<'tree>,
1468 src: &'tree [u8],
1469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1470 debug_assert_eq!(node.kind(), "break_statement");
1471 Ok(Self {
1472 span: ::treesitter_types::Span::from(node),
1473 children: {
1474 #[allow(clippy::suspicious_else_formatting)]
1475 let non_field_children = {
1476 let mut cursor = node.walk();
1477 let mut result = ::std::vec::Vec::new();
1478 if cursor.goto_first_child() {
1479 loop {
1480 if cursor.field_name().is_none()
1481 && cursor.node().is_named()
1482 && !cursor.node().is_extra()
1483 {
1484 result.push(cursor.node());
1485 }
1486 if !cursor.goto_next_sibling() {
1487 break;
1488 }
1489 }
1490 }
1491 result
1492 };
1493 match non_field_children.first() {
1494 Some(&child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1495 child, src,
1496 )?),
1497 None => None,
1498 }
1499 },
1500 })
1501 }
1502}
1503impl ::treesitter_types::Spanned for BreakStatement<'_> {
1504 fn span(&self) -> ::treesitter_types::Span {
1505 self.span
1506 }
1507}
1508#[derive(Debug, Clone)]
1509pub struct CastExpression<'tree> {
1510 pub span: ::treesitter_types::Span,
1511 pub r#type: ::std::vec::Vec<Type<'tree>>,
1512 pub value: Expression<'tree>,
1513}
1514impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
1515 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1516 fn from_node(
1517 node: ::tree_sitter::Node<'tree>,
1518 src: &'tree [u8],
1519 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1520 debug_assert_eq!(node.kind(), "cast_expression");
1521 Ok(Self {
1522 span: ::treesitter_types::Span::from(node),
1523 r#type: {
1524 let mut cursor = node.walk();
1525 let mut items = ::std::vec::Vec::new();
1526 for child in node.children_by_field_name("type", &mut cursor) {
1527 items.push(<Type as ::treesitter_types::FromNode>::from_node(
1528 child, src,
1529 )?);
1530 }
1531 items
1532 },
1533 value: {
1534 let child = node
1535 .child_by_field_name("value")
1536 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1537 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1538 },
1539 })
1540 }
1541}
1542impl ::treesitter_types::Spanned for CastExpression<'_> {
1543 fn span(&self) -> ::treesitter_types::Span {
1544 self.span
1545 }
1546}
1547#[derive(Debug, Clone)]
1548pub struct CatchClause<'tree> {
1549 pub span: ::treesitter_types::Span,
1550 pub body: Block<'tree>,
1551 pub children: CatchFormalParameter<'tree>,
1552}
1553impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1554 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1555 fn from_node(
1556 node: ::tree_sitter::Node<'tree>,
1557 src: &'tree [u8],
1558 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1559 debug_assert_eq!(node.kind(), "catch_clause");
1560 Ok(Self {
1561 span: ::treesitter_types::Span::from(node),
1562 body: {
1563 let child = node
1564 .child_by_field_name("body")
1565 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1566 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
1567 },
1568 children: {
1569 #[allow(clippy::suspicious_else_formatting)]
1570 let non_field_children = {
1571 let mut cursor = node.walk();
1572 let mut result = ::std::vec::Vec::new();
1573 if cursor.goto_first_child() {
1574 loop {
1575 if cursor.field_name().is_none()
1576 && cursor.node().is_named()
1577 && !cursor.node().is_extra()
1578 {
1579 result.push(cursor.node());
1580 }
1581 if !cursor.goto_next_sibling() {
1582 break;
1583 }
1584 }
1585 }
1586 result
1587 };
1588 let child = if let Some(&c) = non_field_children.first() {
1589 c
1590 } else {
1591 let mut fallback_cursor = node.walk();
1592 let mut fallback_child = None;
1593 if fallback_cursor.goto_first_child() {
1594 loop {
1595 if fallback_cursor.field_name().is_none()
1596 && !fallback_cursor.node().is_extra()
1597 {
1598 fallback_child = Some(fallback_cursor.node());
1599 break;
1600 }
1601 if !fallback_cursor.goto_next_sibling() {
1602 break;
1603 }
1604 }
1605 }
1606 fallback_child.ok_or_else(|| {
1607 ::treesitter_types::ParseError::missing_field("children", node)
1608 })?
1609 };
1610 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(child, src)?
1611 },
1612 })
1613 }
1614}
1615impl ::treesitter_types::Spanned for CatchClause<'_> {
1616 fn span(&self) -> ::treesitter_types::Span {
1617 self.span
1618 }
1619}
1620#[derive(Debug, Clone)]
1621pub struct CatchFormalParameter<'tree> {
1622 pub span: ::treesitter_types::Span,
1623 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
1624 pub name: CatchFormalParameterName<'tree>,
1625 pub children: ::std::vec::Vec<CatchFormalParameterChildren<'tree>>,
1626}
1627impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameter<'tree> {
1628 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1629 fn from_node(
1630 node: ::tree_sitter::Node<'tree>,
1631 src: &'tree [u8],
1632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1633 debug_assert_eq!(node.kind(), "catch_formal_parameter");
1634 Ok(Self {
1635 span: ::treesitter_types::Span::from(node),
1636 dimensions: match node.child_by_field_name("dimensions") {
1637 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
1638 child, src,
1639 )?),
1640 None => None,
1641 },
1642 name: {
1643 let child = node
1644 .child_by_field_name("name")
1645 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1646 <CatchFormalParameterName as ::treesitter_types::FromNode>::from_node(child, src)?
1647 },
1648 children: {
1649 #[allow(clippy::suspicious_else_formatting)]
1650 let non_field_children = {
1651 let mut cursor = node.walk();
1652 let mut result = ::std::vec::Vec::new();
1653 if cursor.goto_first_child() {
1654 loop {
1655 if cursor.field_name().is_none()
1656 && cursor.node().is_named()
1657 && !cursor.node().is_extra()
1658 {
1659 result.push(cursor.node());
1660 }
1661 if !cursor.goto_next_sibling() {
1662 break;
1663 }
1664 }
1665 }
1666 result
1667 };
1668 let mut items = ::std::vec::Vec::new();
1669 for child in non_field_children {
1670 items.push(
1671 <CatchFormalParameterChildren as ::treesitter_types::FromNode>::from_node(
1672 child, src,
1673 )?,
1674 );
1675 }
1676 items
1677 },
1678 })
1679 }
1680}
1681impl ::treesitter_types::Spanned for CatchFormalParameter<'_> {
1682 fn span(&self) -> ::treesitter_types::Span {
1683 self.span
1684 }
1685}
1686#[derive(Debug, Clone)]
1687pub struct CatchType<'tree> {
1688 pub span: ::treesitter_types::Span,
1689 pub children: ::std::vec::Vec<UnannotatedType<'tree>>,
1690}
1691impl<'tree> ::treesitter_types::FromNode<'tree> for CatchType<'tree> {
1692 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1693 fn from_node(
1694 node: ::tree_sitter::Node<'tree>,
1695 src: &'tree [u8],
1696 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1697 debug_assert_eq!(node.kind(), "catch_type");
1698 Ok(Self {
1699 span: ::treesitter_types::Span::from(node),
1700 children: {
1701 #[allow(clippy::suspicious_else_formatting)]
1702 let non_field_children = {
1703 let mut cursor = node.walk();
1704 let mut result = ::std::vec::Vec::new();
1705 if cursor.goto_first_child() {
1706 loop {
1707 if cursor.field_name().is_none()
1708 && cursor.node().is_named()
1709 && !cursor.node().is_extra()
1710 {
1711 result.push(cursor.node());
1712 }
1713 if !cursor.goto_next_sibling() {
1714 break;
1715 }
1716 }
1717 }
1718 result
1719 };
1720 let mut items = ::std::vec::Vec::new();
1721 for child in non_field_children {
1722 items.push(
1723 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?,
1724 );
1725 }
1726 items
1727 },
1728 })
1729 }
1730}
1731impl ::treesitter_types::Spanned for CatchType<'_> {
1732 fn span(&self) -> ::treesitter_types::Span {
1733 self.span
1734 }
1735}
1736#[derive(Debug, Clone)]
1737pub struct ClassBody<'tree> {
1738 pub span: ::treesitter_types::Span,
1739 pub children: ::std::vec::Vec<ClassBodyChildren<'tree>>,
1740}
1741impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1742 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1743 fn from_node(
1744 node: ::tree_sitter::Node<'tree>,
1745 src: &'tree [u8],
1746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1747 debug_assert_eq!(node.kind(), "class_body");
1748 Ok(Self {
1749 span: ::treesitter_types::Span::from(node),
1750 children: {
1751 #[allow(clippy::suspicious_else_formatting)]
1752 let non_field_children = {
1753 let mut cursor = node.walk();
1754 let mut result = ::std::vec::Vec::new();
1755 if cursor.goto_first_child() {
1756 loop {
1757 if cursor.field_name().is_none()
1758 && cursor.node().is_named()
1759 && !cursor.node().is_extra()
1760 {
1761 result.push(cursor.node());
1762 }
1763 if !cursor.goto_next_sibling() {
1764 break;
1765 }
1766 }
1767 }
1768 result
1769 };
1770 let mut items = ::std::vec::Vec::new();
1771 for child in non_field_children {
1772 items.push(
1773 <ClassBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1774 );
1775 }
1776 items
1777 },
1778 })
1779 }
1780}
1781impl ::treesitter_types::Spanned for ClassBody<'_> {
1782 fn span(&self) -> ::treesitter_types::Span {
1783 self.span
1784 }
1785}
1786#[derive(Debug, Clone)]
1787pub struct ClassDeclaration<'tree> {
1788 pub span: ::treesitter_types::Span,
1789 pub body: ClassBody<'tree>,
1790 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
1791 pub name: Identifier<'tree>,
1792 pub permits: ::core::option::Option<Permits<'tree>>,
1793 pub superclass: ::core::option::Option<Superclass<'tree>>,
1794 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1795 pub children: ::core::option::Option<Modifiers<'tree>>,
1796}
1797impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1798 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1799 fn from_node(
1800 node: ::tree_sitter::Node<'tree>,
1801 src: &'tree [u8],
1802 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1803 debug_assert_eq!(node.kind(), "class_declaration");
1804 Ok(Self {
1805 span: ::treesitter_types::Span::from(node),
1806 body: {
1807 let child = node
1808 .child_by_field_name("body")
1809 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1810 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
1811 },
1812 interfaces: match node.child_by_field_name("interfaces") {
1813 Some(child) => {
1814 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
1815 }
1816 None => None,
1817 },
1818 name: {
1819 let child = node
1820 .child_by_field_name("name")
1821 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1822 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1823 },
1824 permits: match node.child_by_field_name("permits") {
1825 Some(child) => Some(<Permits as ::treesitter_types::FromNode>::from_node(
1826 child, src,
1827 )?),
1828 None => None,
1829 },
1830 superclass: match node.child_by_field_name("superclass") {
1831 Some(child) => Some(<Superclass as ::treesitter_types::FromNode>::from_node(
1832 child, src,
1833 )?),
1834 None => None,
1835 },
1836 type_parameters: match node.child_by_field_name("type_parameters") {
1837 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
1838 child, src,
1839 )?),
1840 None => None,
1841 },
1842 children: {
1843 #[allow(clippy::suspicious_else_formatting)]
1844 let non_field_children = {
1845 let mut cursor = node.walk();
1846 let mut result = ::std::vec::Vec::new();
1847 if cursor.goto_first_child() {
1848 loop {
1849 if cursor.field_name().is_none()
1850 && cursor.node().is_named()
1851 && !cursor.node().is_extra()
1852 {
1853 result.push(cursor.node());
1854 }
1855 if !cursor.goto_next_sibling() {
1856 break;
1857 }
1858 }
1859 }
1860 result
1861 };
1862 match non_field_children.first() {
1863 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
1864 child, src,
1865 )?),
1866 None => None,
1867 }
1868 },
1869 })
1870 }
1871}
1872impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
1873 fn span(&self) -> ::treesitter_types::Span {
1874 self.span
1875 }
1876}
1877#[derive(Debug, Clone)]
1878pub struct ClassLiteral<'tree> {
1879 pub span: ::treesitter_types::Span,
1880 pub children: UnannotatedType<'tree>,
1881}
1882impl<'tree> ::treesitter_types::FromNode<'tree> for ClassLiteral<'tree> {
1883 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1884 fn from_node(
1885 node: ::tree_sitter::Node<'tree>,
1886 src: &'tree [u8],
1887 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1888 debug_assert_eq!(node.kind(), "class_literal");
1889 Ok(Self {
1890 span: ::treesitter_types::Span::from(node),
1891 children: {
1892 #[allow(clippy::suspicious_else_formatting)]
1893 let non_field_children = {
1894 let mut cursor = node.walk();
1895 let mut result = ::std::vec::Vec::new();
1896 if cursor.goto_first_child() {
1897 loop {
1898 if cursor.field_name().is_none()
1899 && cursor.node().is_named()
1900 && !cursor.node().is_extra()
1901 {
1902 result.push(cursor.node());
1903 }
1904 if !cursor.goto_next_sibling() {
1905 break;
1906 }
1907 }
1908 }
1909 result
1910 };
1911 let child = if let Some(&c) = non_field_children.first() {
1912 c
1913 } else {
1914 let mut fallback_cursor = node.walk();
1915 let mut fallback_child = None;
1916 if fallback_cursor.goto_first_child() {
1917 loop {
1918 if fallback_cursor.field_name().is_none()
1919 && !fallback_cursor.node().is_extra()
1920 {
1921 fallback_child = Some(fallback_cursor.node());
1922 break;
1923 }
1924 if !fallback_cursor.goto_next_sibling() {
1925 break;
1926 }
1927 }
1928 }
1929 fallback_child.ok_or_else(|| {
1930 ::treesitter_types::ParseError::missing_field("children", node)
1931 })?
1932 };
1933 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
1934 },
1935 })
1936 }
1937}
1938impl ::treesitter_types::Spanned for ClassLiteral<'_> {
1939 fn span(&self) -> ::treesitter_types::Span {
1940 self.span
1941 }
1942}
1943#[derive(Debug, Clone)]
1944pub struct CompactConstructorDeclaration<'tree> {
1945 pub span: ::treesitter_types::Span,
1946 pub body: Block<'tree>,
1947 pub name: Identifier<'tree>,
1948 pub children: ::core::option::Option<Modifiers<'tree>>,
1949}
1950impl<'tree> ::treesitter_types::FromNode<'tree> for CompactConstructorDeclaration<'tree> {
1951 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1952 fn from_node(
1953 node: ::tree_sitter::Node<'tree>,
1954 src: &'tree [u8],
1955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1956 debug_assert_eq!(node.kind(), "compact_constructor_declaration");
1957 Ok(Self {
1958 span: ::treesitter_types::Span::from(node),
1959 body: {
1960 let child = node
1961 .child_by_field_name("body")
1962 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1963 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
1964 },
1965 name: {
1966 let child = node
1967 .child_by_field_name("name")
1968 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1969 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1970 },
1971 children: {
1972 #[allow(clippy::suspicious_else_formatting)]
1973 let non_field_children = {
1974 let mut cursor = node.walk();
1975 let mut result = ::std::vec::Vec::new();
1976 if cursor.goto_first_child() {
1977 loop {
1978 if cursor.field_name().is_none()
1979 && cursor.node().is_named()
1980 && !cursor.node().is_extra()
1981 {
1982 result.push(cursor.node());
1983 }
1984 if !cursor.goto_next_sibling() {
1985 break;
1986 }
1987 }
1988 }
1989 result
1990 };
1991 match non_field_children.first() {
1992 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
1993 child, src,
1994 )?),
1995 None => None,
1996 }
1997 },
1998 })
1999 }
2000}
2001impl ::treesitter_types::Spanned for CompactConstructorDeclaration<'_> {
2002 fn span(&self) -> ::treesitter_types::Span {
2003 self.span
2004 }
2005}
2006#[derive(Debug, Clone)]
2007pub struct ConstantDeclaration<'tree> {
2008 pub span: ::treesitter_types::Span,
2009 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
2010 pub r#type: UnannotatedType<'tree>,
2011 pub children: ::core::option::Option<Modifiers<'tree>>,
2012}
2013impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantDeclaration<'tree> {
2014 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2015 fn from_node(
2016 node: ::tree_sitter::Node<'tree>,
2017 src: &'tree [u8],
2018 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2019 debug_assert_eq!(node.kind(), "constant_declaration");
2020 Ok(Self {
2021 span: ::treesitter_types::Span::from(node),
2022 declarator: {
2023 let mut cursor = node.walk();
2024 let mut items = ::std::vec::Vec::new();
2025 for child in node.children_by_field_name("declarator", &mut cursor) {
2026 items.push(
2027 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
2028 child, src,
2029 )?,
2030 );
2031 }
2032 items
2033 },
2034 r#type: {
2035 let child = node
2036 .child_by_field_name("type")
2037 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2038 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
2039 },
2040 children: {
2041 #[allow(clippy::suspicious_else_formatting)]
2042 let non_field_children = {
2043 let mut cursor = node.walk();
2044 let mut result = ::std::vec::Vec::new();
2045 if cursor.goto_first_child() {
2046 loop {
2047 if cursor.field_name().is_none()
2048 && cursor.node().is_named()
2049 && !cursor.node().is_extra()
2050 {
2051 result.push(cursor.node());
2052 }
2053 if !cursor.goto_next_sibling() {
2054 break;
2055 }
2056 }
2057 }
2058 result
2059 };
2060 match non_field_children.first() {
2061 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2062 child, src,
2063 )?),
2064 None => None,
2065 }
2066 },
2067 })
2068 }
2069}
2070impl ::treesitter_types::Spanned for ConstantDeclaration<'_> {
2071 fn span(&self) -> ::treesitter_types::Span {
2072 self.span
2073 }
2074}
2075#[derive(Debug, Clone)]
2076pub struct ConstructorBody<'tree> {
2077 pub span: ::treesitter_types::Span,
2078 pub children: ::std::vec::Vec<ConstructorBodyChildren<'tree>>,
2079}
2080impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBody<'tree> {
2081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2082 fn from_node(
2083 node: ::tree_sitter::Node<'tree>,
2084 src: &'tree [u8],
2085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2086 debug_assert_eq!(node.kind(), "constructor_body");
2087 Ok(Self {
2088 span: ::treesitter_types::Span::from(node),
2089 children: {
2090 #[allow(clippy::suspicious_else_formatting)]
2091 let non_field_children = {
2092 let mut cursor = node.walk();
2093 let mut result = ::std::vec::Vec::new();
2094 if cursor.goto_first_child() {
2095 loop {
2096 if cursor.field_name().is_none()
2097 && cursor.node().is_named()
2098 && !cursor.node().is_extra()
2099 {
2100 result.push(cursor.node());
2101 }
2102 if !cursor.goto_next_sibling() {
2103 break;
2104 }
2105 }
2106 }
2107 result
2108 };
2109 let mut items = ::std::vec::Vec::new();
2110 for child in non_field_children {
2111 items.push(
2112 <ConstructorBodyChildren as ::treesitter_types::FromNode>::from_node(
2113 child, src,
2114 )?,
2115 );
2116 }
2117 items
2118 },
2119 })
2120 }
2121}
2122impl ::treesitter_types::Spanned for ConstructorBody<'_> {
2123 fn span(&self) -> ::treesitter_types::Span {
2124 self.span
2125 }
2126}
2127#[derive(Debug, Clone)]
2128pub struct ConstructorDeclaration<'tree> {
2129 pub span: ::treesitter_types::Span,
2130 pub body: ConstructorBody<'tree>,
2131 pub name: Identifier<'tree>,
2132 pub parameters: FormalParameters<'tree>,
2133 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2134 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
2135}
2136impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
2137 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2138 fn from_node(
2139 node: ::tree_sitter::Node<'tree>,
2140 src: &'tree [u8],
2141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2142 debug_assert_eq!(node.kind(), "constructor_declaration");
2143 Ok(Self {
2144 span: ::treesitter_types::Span::from(node),
2145 body: {
2146 let child = node
2147 .child_by_field_name("body")
2148 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2149 <ConstructorBody as ::treesitter_types::FromNode>::from_node(child, src)?
2150 },
2151 name: {
2152 let child = node
2153 .child_by_field_name("name")
2154 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2155 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2156 },
2157 parameters: {
2158 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2159 ::treesitter_types::ParseError::missing_field("parameters", node)
2160 })?;
2161 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2162 },
2163 type_parameters: match node.child_by_field_name("type_parameters") {
2164 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2165 child, src,
2166 )?),
2167 None => None,
2168 },
2169 children: {
2170 #[allow(clippy::suspicious_else_formatting)]
2171 let non_field_children = {
2172 let mut cursor = node.walk();
2173 let mut result = ::std::vec::Vec::new();
2174 if cursor.goto_first_child() {
2175 loop {
2176 if cursor.field_name().is_none()
2177 && cursor.node().is_named()
2178 && !cursor.node().is_extra()
2179 {
2180 result.push(cursor.node());
2181 }
2182 if !cursor.goto_next_sibling() {
2183 break;
2184 }
2185 }
2186 }
2187 result
2188 };
2189 let mut items = ::std::vec::Vec::new();
2190 for child in non_field_children {
2191 items
2192 .push(
2193 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2194 child,
2195 src,
2196 )?,
2197 );
2198 }
2199 items
2200 },
2201 })
2202 }
2203}
2204impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
2205 fn span(&self) -> ::treesitter_types::Span {
2206 self.span
2207 }
2208}
2209#[derive(Debug, Clone)]
2210pub struct ContinueStatement<'tree> {
2211 pub span: ::treesitter_types::Span,
2212 pub children: ::core::option::Option<Identifier<'tree>>,
2213}
2214impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2215 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2216 fn from_node(
2217 node: ::tree_sitter::Node<'tree>,
2218 src: &'tree [u8],
2219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2220 debug_assert_eq!(node.kind(), "continue_statement");
2221 Ok(Self {
2222 span: ::treesitter_types::Span::from(node),
2223 children: {
2224 #[allow(clippy::suspicious_else_formatting)]
2225 let non_field_children = {
2226 let mut cursor = node.walk();
2227 let mut result = ::std::vec::Vec::new();
2228 if cursor.goto_first_child() {
2229 loop {
2230 if cursor.field_name().is_none()
2231 && cursor.node().is_named()
2232 && !cursor.node().is_extra()
2233 {
2234 result.push(cursor.node());
2235 }
2236 if !cursor.goto_next_sibling() {
2237 break;
2238 }
2239 }
2240 }
2241 result
2242 };
2243 match non_field_children.first() {
2244 Some(&child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2245 child, src,
2246 )?),
2247 None => None,
2248 }
2249 },
2250 })
2251 }
2252}
2253impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2254 fn span(&self) -> ::treesitter_types::Span {
2255 self.span
2256 }
2257}
2258#[derive(Debug, Clone)]
2259pub struct Dimensions<'tree> {
2260 pub span: ::treesitter_types::Span,
2261 pub children: ::std::vec::Vec<DimensionsChildren<'tree>>,
2262}
2263impl<'tree> ::treesitter_types::FromNode<'tree> for Dimensions<'tree> {
2264 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2265 fn from_node(
2266 node: ::tree_sitter::Node<'tree>,
2267 src: &'tree [u8],
2268 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2269 debug_assert_eq!(node.kind(), "dimensions");
2270 Ok(Self {
2271 span: ::treesitter_types::Span::from(node),
2272 children: {
2273 #[allow(clippy::suspicious_else_formatting)]
2274 let non_field_children = {
2275 let mut cursor = node.walk();
2276 let mut result = ::std::vec::Vec::new();
2277 if cursor.goto_first_child() {
2278 loop {
2279 if cursor.field_name().is_none()
2280 && cursor.node().is_named()
2281 && !cursor.node().is_extra()
2282 {
2283 result.push(cursor.node());
2284 }
2285 if !cursor.goto_next_sibling() {
2286 break;
2287 }
2288 }
2289 }
2290 result
2291 };
2292 let mut items = ::std::vec::Vec::new();
2293 for child in non_field_children {
2294 items.push(
2295 <DimensionsChildren as ::treesitter_types::FromNode>::from_node(
2296 child, src,
2297 )?,
2298 );
2299 }
2300 items
2301 },
2302 })
2303 }
2304}
2305impl ::treesitter_types::Spanned for Dimensions<'_> {
2306 fn span(&self) -> ::treesitter_types::Span {
2307 self.span
2308 }
2309}
2310#[derive(Debug, Clone)]
2311pub struct DimensionsExpr<'tree> {
2312 pub span: ::treesitter_types::Span,
2313 pub children: ::std::vec::Vec<DimensionsExprChildren<'tree>>,
2314}
2315impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExpr<'tree> {
2316 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2317 fn from_node(
2318 node: ::tree_sitter::Node<'tree>,
2319 src: &'tree [u8],
2320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2321 debug_assert_eq!(node.kind(), "dimensions_expr");
2322 Ok(Self {
2323 span: ::treesitter_types::Span::from(node),
2324 children: {
2325 #[allow(clippy::suspicious_else_formatting)]
2326 let non_field_children = {
2327 let mut cursor = node.walk();
2328 let mut result = ::std::vec::Vec::new();
2329 if cursor.goto_first_child() {
2330 loop {
2331 if cursor.field_name().is_none()
2332 && cursor.node().is_named()
2333 && !cursor.node().is_extra()
2334 {
2335 result.push(cursor.node());
2336 }
2337 if !cursor.goto_next_sibling() {
2338 break;
2339 }
2340 }
2341 }
2342 result
2343 };
2344 let mut items = ::std::vec::Vec::new();
2345 for child in non_field_children {
2346 items.push(
2347 <DimensionsExprChildren as ::treesitter_types::FromNode>::from_node(
2348 child, src,
2349 )?,
2350 );
2351 }
2352 items
2353 },
2354 })
2355 }
2356}
2357impl ::treesitter_types::Spanned for DimensionsExpr<'_> {
2358 fn span(&self) -> ::treesitter_types::Span {
2359 self.span
2360 }
2361}
2362#[derive(Debug, Clone)]
2363pub struct DoStatement<'tree> {
2364 pub span: ::treesitter_types::Span,
2365 pub body: Statement<'tree>,
2366 pub condition: ParenthesizedExpression<'tree>,
2367}
2368impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2370 fn from_node(
2371 node: ::tree_sitter::Node<'tree>,
2372 src: &'tree [u8],
2373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2374 debug_assert_eq!(node.kind(), "do_statement");
2375 Ok(Self {
2376 span: ::treesitter_types::Span::from(node),
2377 body: {
2378 let child = node
2379 .child_by_field_name("body")
2380 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2381 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2382 },
2383 condition: {
2384 let child = node.child_by_field_name("condition").ok_or_else(|| {
2385 ::treesitter_types::ParseError::missing_field("condition", node)
2386 })?;
2387 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2388 },
2389 })
2390 }
2391}
2392impl ::treesitter_types::Spanned for DoStatement<'_> {
2393 fn span(&self) -> ::treesitter_types::Span {
2394 self.span
2395 }
2396}
2397#[derive(Debug, Clone)]
2398pub struct ElementValueArrayInitializer<'tree> {
2399 pub span: ::treesitter_types::Span,
2400 pub children: ::std::vec::Vec<ElementValueArrayInitializerChildren<'tree>>,
2401}
2402impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializer<'tree> {
2403 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2404 fn from_node(
2405 node: ::tree_sitter::Node<'tree>,
2406 src: &'tree [u8],
2407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2408 debug_assert_eq!(node.kind(), "element_value_array_initializer");
2409 Ok(Self {
2410 span: ::treesitter_types::Span::from(node),
2411 children: {
2412 #[allow(clippy::suspicious_else_formatting)]
2413 let non_field_children = {
2414 let mut cursor = node.walk();
2415 let mut result = ::std::vec::Vec::new();
2416 if cursor.goto_first_child() {
2417 loop {
2418 if cursor.field_name().is_none()
2419 && cursor.node().is_named()
2420 && !cursor.node().is_extra()
2421 {
2422 result.push(cursor.node());
2423 }
2424 if !cursor.goto_next_sibling() {
2425 break;
2426 }
2427 }
2428 }
2429 result
2430 };
2431 let mut items = ::std::vec::Vec::new();
2432 for child in non_field_children {
2433 items
2434 .push(
2435 <ElementValueArrayInitializerChildren as ::treesitter_types::FromNode>::from_node(
2436 child,
2437 src,
2438 )?,
2439 );
2440 }
2441 items
2442 },
2443 })
2444 }
2445}
2446impl ::treesitter_types::Spanned for ElementValueArrayInitializer<'_> {
2447 fn span(&self) -> ::treesitter_types::Span {
2448 self.span
2449 }
2450}
2451#[derive(Debug, Clone)]
2452pub struct ElementValuePair<'tree> {
2453 pub span: ::treesitter_types::Span,
2454 pub key: Identifier<'tree>,
2455 pub value: ElementValuePairValue<'tree>,
2456}
2457impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePair<'tree> {
2458 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2459 fn from_node(
2460 node: ::tree_sitter::Node<'tree>,
2461 src: &'tree [u8],
2462 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2463 debug_assert_eq!(node.kind(), "element_value_pair");
2464 Ok(Self {
2465 span: ::treesitter_types::Span::from(node),
2466 key: {
2467 let child = node
2468 .child_by_field_name("key")
2469 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
2470 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2471 },
2472 value: {
2473 let child = node
2474 .child_by_field_name("value")
2475 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2476 <ElementValuePairValue as ::treesitter_types::FromNode>::from_node(child, src)?
2477 },
2478 })
2479 }
2480}
2481impl ::treesitter_types::Spanned for ElementValuePair<'_> {
2482 fn span(&self) -> ::treesitter_types::Span {
2483 self.span
2484 }
2485}
2486#[derive(Debug, Clone)]
2487pub struct EnhancedForStatement<'tree> {
2488 pub span: ::treesitter_types::Span,
2489 pub body: Statement<'tree>,
2490 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
2491 pub name: EnhancedForStatementName<'tree>,
2492 pub r#type: UnannotatedType<'tree>,
2493 pub value: Expression<'tree>,
2494 pub children: ::core::option::Option<Modifiers<'tree>>,
2495}
2496impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatement<'tree> {
2497 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2498 fn from_node(
2499 node: ::tree_sitter::Node<'tree>,
2500 src: &'tree [u8],
2501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2502 debug_assert_eq!(node.kind(), "enhanced_for_statement");
2503 Ok(Self {
2504 span: ::treesitter_types::Span::from(node),
2505 body: {
2506 let child = node
2507 .child_by_field_name("body")
2508 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2509 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2510 },
2511 dimensions: match node.child_by_field_name("dimensions") {
2512 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
2513 child, src,
2514 )?),
2515 None => None,
2516 },
2517 name: {
2518 let child = node
2519 .child_by_field_name("name")
2520 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2521 <EnhancedForStatementName as ::treesitter_types::FromNode>::from_node(child, src)?
2522 },
2523 r#type: {
2524 let child = node
2525 .child_by_field_name("type")
2526 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2527 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
2528 },
2529 value: {
2530 let child = node
2531 .child_by_field_name("value")
2532 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2533 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2534 },
2535 children: {
2536 #[allow(clippy::suspicious_else_formatting)]
2537 let non_field_children = {
2538 let mut cursor = node.walk();
2539 let mut result = ::std::vec::Vec::new();
2540 if cursor.goto_first_child() {
2541 loop {
2542 if cursor.field_name().is_none()
2543 && cursor.node().is_named()
2544 && !cursor.node().is_extra()
2545 {
2546 result.push(cursor.node());
2547 }
2548 if !cursor.goto_next_sibling() {
2549 break;
2550 }
2551 }
2552 }
2553 result
2554 };
2555 match non_field_children.first() {
2556 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2557 child, src,
2558 )?),
2559 None => None,
2560 }
2561 },
2562 })
2563 }
2564}
2565impl ::treesitter_types::Spanned for EnhancedForStatement<'_> {
2566 fn span(&self) -> ::treesitter_types::Span {
2567 self.span
2568 }
2569}
2570#[derive(Debug, Clone)]
2571pub struct EnumBody<'tree> {
2572 pub span: ::treesitter_types::Span,
2573 pub children: ::std::vec::Vec<EnumBodyChildren<'tree>>,
2574}
2575impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBody<'tree> {
2576 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2577 fn from_node(
2578 node: ::tree_sitter::Node<'tree>,
2579 src: &'tree [u8],
2580 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2581 debug_assert_eq!(node.kind(), "enum_body");
2582 Ok(Self {
2583 span: ::treesitter_types::Span::from(node),
2584 children: {
2585 #[allow(clippy::suspicious_else_formatting)]
2586 let non_field_children = {
2587 let mut cursor = node.walk();
2588 let mut result = ::std::vec::Vec::new();
2589 if cursor.goto_first_child() {
2590 loop {
2591 if cursor.field_name().is_none()
2592 && cursor.node().is_named()
2593 && !cursor.node().is_extra()
2594 {
2595 result.push(cursor.node());
2596 }
2597 if !cursor.goto_next_sibling() {
2598 break;
2599 }
2600 }
2601 }
2602 result
2603 };
2604 let mut items = ::std::vec::Vec::new();
2605 for child in non_field_children {
2606 items.push(
2607 <EnumBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2608 );
2609 }
2610 items
2611 },
2612 })
2613 }
2614}
2615impl ::treesitter_types::Spanned for EnumBody<'_> {
2616 fn span(&self) -> ::treesitter_types::Span {
2617 self.span
2618 }
2619}
2620#[derive(Debug, Clone)]
2621pub struct EnumBodyDeclarations<'tree> {
2622 pub span: ::treesitter_types::Span,
2623 pub children: ::std::vec::Vec<EnumBodyDeclarationsChildren<'tree>>,
2624}
2625impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarations<'tree> {
2626 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2627 fn from_node(
2628 node: ::tree_sitter::Node<'tree>,
2629 src: &'tree [u8],
2630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2631 debug_assert_eq!(node.kind(), "enum_body_declarations");
2632 Ok(Self {
2633 span: ::treesitter_types::Span::from(node),
2634 children: {
2635 #[allow(clippy::suspicious_else_formatting)]
2636 let non_field_children = {
2637 let mut cursor = node.walk();
2638 let mut result = ::std::vec::Vec::new();
2639 if cursor.goto_first_child() {
2640 loop {
2641 if cursor.field_name().is_none()
2642 && cursor.node().is_named()
2643 && !cursor.node().is_extra()
2644 {
2645 result.push(cursor.node());
2646 }
2647 if !cursor.goto_next_sibling() {
2648 break;
2649 }
2650 }
2651 }
2652 result
2653 };
2654 let mut items = ::std::vec::Vec::new();
2655 for child in non_field_children {
2656 items.push(
2657 <EnumBodyDeclarationsChildren as ::treesitter_types::FromNode>::from_node(
2658 child, src,
2659 )?,
2660 );
2661 }
2662 items
2663 },
2664 })
2665 }
2666}
2667impl ::treesitter_types::Spanned for EnumBodyDeclarations<'_> {
2668 fn span(&self) -> ::treesitter_types::Span {
2669 self.span
2670 }
2671}
2672#[derive(Debug, Clone)]
2673pub struct EnumConstant<'tree> {
2674 pub span: ::treesitter_types::Span,
2675 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
2676 pub body: ::core::option::Option<ClassBody<'tree>>,
2677 pub name: Identifier<'tree>,
2678 pub children: ::core::option::Option<Modifiers<'tree>>,
2679}
2680impl<'tree> ::treesitter_types::FromNode<'tree> for EnumConstant<'tree> {
2681 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2682 fn from_node(
2683 node: ::tree_sitter::Node<'tree>,
2684 src: &'tree [u8],
2685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2686 debug_assert_eq!(node.kind(), "enum_constant");
2687 Ok(Self {
2688 span: ::treesitter_types::Span::from(node),
2689 arguments: match node.child_by_field_name("arguments") {
2690 Some(child) => Some(<ArgumentList as ::treesitter_types::FromNode>::from_node(
2691 child, src,
2692 )?),
2693 None => None,
2694 },
2695 body: match node.child_by_field_name("body") {
2696 Some(child) => Some(<ClassBody as ::treesitter_types::FromNode>::from_node(
2697 child, src,
2698 )?),
2699 None => None,
2700 },
2701 name: {
2702 let child = node
2703 .child_by_field_name("name")
2704 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2705 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2706 },
2707 children: {
2708 #[allow(clippy::suspicious_else_formatting)]
2709 let non_field_children = {
2710 let mut cursor = node.walk();
2711 let mut result = ::std::vec::Vec::new();
2712 if cursor.goto_first_child() {
2713 loop {
2714 if cursor.field_name().is_none()
2715 && cursor.node().is_named()
2716 && !cursor.node().is_extra()
2717 {
2718 result.push(cursor.node());
2719 }
2720 if !cursor.goto_next_sibling() {
2721 break;
2722 }
2723 }
2724 }
2725 result
2726 };
2727 match non_field_children.first() {
2728 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2729 child, src,
2730 )?),
2731 None => None,
2732 }
2733 },
2734 })
2735 }
2736}
2737impl ::treesitter_types::Spanned for EnumConstant<'_> {
2738 fn span(&self) -> ::treesitter_types::Span {
2739 self.span
2740 }
2741}
2742#[derive(Debug, Clone)]
2743pub struct EnumDeclaration<'tree> {
2744 pub span: ::treesitter_types::Span,
2745 pub body: EnumBody<'tree>,
2746 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
2747 pub name: Identifier<'tree>,
2748 pub children: ::core::option::Option<Modifiers<'tree>>,
2749}
2750impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
2751 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2752 fn from_node(
2753 node: ::tree_sitter::Node<'tree>,
2754 src: &'tree [u8],
2755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2756 debug_assert_eq!(node.kind(), "enum_declaration");
2757 Ok(Self {
2758 span: ::treesitter_types::Span::from(node),
2759 body: {
2760 let child = node
2761 .child_by_field_name("body")
2762 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2763 <EnumBody as ::treesitter_types::FromNode>::from_node(child, src)?
2764 },
2765 interfaces: match node.child_by_field_name("interfaces") {
2766 Some(child) => {
2767 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
2768 }
2769 None => None,
2770 },
2771 name: {
2772 let child = node
2773 .child_by_field_name("name")
2774 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2775 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2776 },
2777 children: {
2778 #[allow(clippy::suspicious_else_formatting)]
2779 let non_field_children = {
2780 let mut cursor = node.walk();
2781 let mut result = ::std::vec::Vec::new();
2782 if cursor.goto_first_child() {
2783 loop {
2784 if cursor.field_name().is_none()
2785 && cursor.node().is_named()
2786 && !cursor.node().is_extra()
2787 {
2788 result.push(cursor.node());
2789 }
2790 if !cursor.goto_next_sibling() {
2791 break;
2792 }
2793 }
2794 }
2795 result
2796 };
2797 match non_field_children.first() {
2798 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2799 child, src,
2800 )?),
2801 None => None,
2802 }
2803 },
2804 })
2805 }
2806}
2807impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
2808 fn span(&self) -> ::treesitter_types::Span {
2809 self.span
2810 }
2811}
2812#[derive(Debug, Clone)]
2813pub struct ExplicitConstructorInvocation<'tree> {
2814 pub span: ::treesitter_types::Span,
2815 pub arguments: ArgumentList<'tree>,
2816 pub constructor: ExplicitConstructorInvocationConstructor<'tree>,
2817 pub object: ::core::option::Option<PrimaryExpression<'tree>>,
2818 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
2819}
2820impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitConstructorInvocation<'tree> {
2821 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2822 fn from_node(
2823 node: ::tree_sitter::Node<'tree>,
2824 src: &'tree [u8],
2825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2826 debug_assert_eq!(node.kind(), "explicit_constructor_invocation");
2827 Ok(Self {
2828 span: ::treesitter_types::Span::from(node),
2829 arguments: {
2830 let child = node.child_by_field_name("arguments").ok_or_else(|| {
2831 ::treesitter_types::ParseError::missing_field("arguments", node)
2832 })?;
2833 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
2834 },
2835 constructor: {
2836 let child = node.child_by_field_name("constructor").ok_or_else(|| {
2837 ::treesitter_types::ParseError::missing_field("constructor", node)
2838 })?;
2839 <ExplicitConstructorInvocationConstructor as ::treesitter_types::FromNode>::from_node(
2840 child,
2841 src,
2842 )?
2843 },
2844 object: match node.child_by_field_name("object") {
2845 Some(child) => Some(
2846 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?,
2847 ),
2848 None => None,
2849 },
2850 type_arguments: match node.child_by_field_name("type_arguments") {
2851 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
2852 child, src,
2853 )?),
2854 None => None,
2855 },
2856 })
2857 }
2858}
2859impl ::treesitter_types::Spanned for ExplicitConstructorInvocation<'_> {
2860 fn span(&self) -> ::treesitter_types::Span {
2861 self.span
2862 }
2863}
2864#[derive(Debug, Clone)]
2865pub struct ExportsModuleDirective<'tree> {
2866 pub span: ::treesitter_types::Span,
2867 pub modules: ::std::vec::Vec<ExportsModuleDirectiveModules<'tree>>,
2868 pub package: ExportsModuleDirectivePackage<'tree>,
2869}
2870impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirective<'tree> {
2871 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2872 fn from_node(
2873 node: ::tree_sitter::Node<'tree>,
2874 src: &'tree [u8],
2875 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2876 debug_assert_eq!(node.kind(), "exports_module_directive");
2877 Ok(Self {
2878 span: ::treesitter_types::Span::from(node),
2879 modules: {
2880 let mut cursor = node.walk();
2881 let mut items = ::std::vec::Vec::new();
2882 for child in node.children_by_field_name("modules", &mut cursor) {
2883 items.push(
2884 <ExportsModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
2885 child, src,
2886 )?,
2887 );
2888 }
2889 items
2890 },
2891 package: {
2892 let child = node.child_by_field_name("package").ok_or_else(|| {
2893 ::treesitter_types::ParseError::missing_field("package", node)
2894 })?;
2895 <ExportsModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
2896 child, src,
2897 )?
2898 },
2899 })
2900 }
2901}
2902impl ::treesitter_types::Spanned for ExportsModuleDirective<'_> {
2903 fn span(&self) -> ::treesitter_types::Span {
2904 self.span
2905 }
2906}
2907#[derive(Debug, Clone)]
2908pub struct ExpressionStatement<'tree> {
2909 pub span: ::treesitter_types::Span,
2910 pub children: Expression<'tree>,
2911}
2912impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
2913 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2914 fn from_node(
2915 node: ::tree_sitter::Node<'tree>,
2916 src: &'tree [u8],
2917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2918 debug_assert_eq!(node.kind(), "expression_statement");
2919 Ok(Self {
2920 span: ::treesitter_types::Span::from(node),
2921 children: {
2922 #[allow(clippy::suspicious_else_formatting)]
2923 let non_field_children = {
2924 let mut cursor = node.walk();
2925 let mut result = ::std::vec::Vec::new();
2926 if cursor.goto_first_child() {
2927 loop {
2928 if cursor.field_name().is_none()
2929 && cursor.node().is_named()
2930 && !cursor.node().is_extra()
2931 {
2932 result.push(cursor.node());
2933 }
2934 if !cursor.goto_next_sibling() {
2935 break;
2936 }
2937 }
2938 }
2939 result
2940 };
2941 let child = if let Some(&c) = non_field_children.first() {
2942 c
2943 } else {
2944 let mut fallback_cursor = node.walk();
2945 let mut fallback_child = None;
2946 if fallback_cursor.goto_first_child() {
2947 loop {
2948 if fallback_cursor.field_name().is_none()
2949 && !fallback_cursor.node().is_extra()
2950 {
2951 fallback_child = Some(fallback_cursor.node());
2952 break;
2953 }
2954 if !fallback_cursor.goto_next_sibling() {
2955 break;
2956 }
2957 }
2958 }
2959 fallback_child.ok_or_else(|| {
2960 ::treesitter_types::ParseError::missing_field("children", node)
2961 })?
2962 };
2963 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2964 },
2965 })
2966 }
2967}
2968impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2969 fn span(&self) -> ::treesitter_types::Span {
2970 self.span
2971 }
2972}
2973#[derive(Debug, Clone)]
2974pub struct ExtendsInterfaces<'tree> {
2975 pub span: ::treesitter_types::Span,
2976 pub children: TypeList<'tree>,
2977}
2978impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsInterfaces<'tree> {
2979 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2980 fn from_node(
2981 node: ::tree_sitter::Node<'tree>,
2982 src: &'tree [u8],
2983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2984 debug_assert_eq!(node.kind(), "extends_interfaces");
2985 Ok(Self {
2986 span: ::treesitter_types::Span::from(node),
2987 children: {
2988 #[allow(clippy::suspicious_else_formatting)]
2989 let non_field_children = {
2990 let mut cursor = node.walk();
2991 let mut result = ::std::vec::Vec::new();
2992 if cursor.goto_first_child() {
2993 loop {
2994 if cursor.field_name().is_none()
2995 && cursor.node().is_named()
2996 && !cursor.node().is_extra()
2997 {
2998 result.push(cursor.node());
2999 }
3000 if !cursor.goto_next_sibling() {
3001 break;
3002 }
3003 }
3004 }
3005 result
3006 };
3007 let child = if let Some(&c) = non_field_children.first() {
3008 c
3009 } else {
3010 let mut fallback_cursor = node.walk();
3011 let mut fallback_child = None;
3012 if fallback_cursor.goto_first_child() {
3013 loop {
3014 if fallback_cursor.field_name().is_none()
3015 && !fallback_cursor.node().is_extra()
3016 {
3017 fallback_child = Some(fallback_cursor.node());
3018 break;
3019 }
3020 if !fallback_cursor.goto_next_sibling() {
3021 break;
3022 }
3023 }
3024 }
3025 fallback_child.ok_or_else(|| {
3026 ::treesitter_types::ParseError::missing_field("children", node)
3027 })?
3028 };
3029 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
3030 },
3031 })
3032 }
3033}
3034impl ::treesitter_types::Spanned for ExtendsInterfaces<'_> {
3035 fn span(&self) -> ::treesitter_types::Span {
3036 self.span
3037 }
3038}
3039#[derive(Debug, Clone)]
3040pub struct FieldAccess<'tree> {
3041 pub span: ::treesitter_types::Span,
3042 pub field: FieldAccessField<'tree>,
3043 pub object: FieldAccessObject<'tree>,
3044 pub children: ::core::option::Option<Super<'tree>>,
3045}
3046impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccess<'tree> {
3047 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3048 fn from_node(
3049 node: ::tree_sitter::Node<'tree>,
3050 src: &'tree [u8],
3051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3052 debug_assert_eq!(node.kind(), "field_access");
3053 Ok(Self {
3054 span: ::treesitter_types::Span::from(node),
3055 field: {
3056 let child = node
3057 .child_by_field_name("field")
3058 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3059 <FieldAccessField as ::treesitter_types::FromNode>::from_node(child, src)?
3060 },
3061 object: {
3062 let child = node
3063 .child_by_field_name("object")
3064 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
3065 <FieldAccessObject as ::treesitter_types::FromNode>::from_node(child, src)?
3066 },
3067 children: {
3068 #[allow(clippy::suspicious_else_formatting)]
3069 let non_field_children = {
3070 let mut cursor = node.walk();
3071 let mut result = ::std::vec::Vec::new();
3072 if cursor.goto_first_child() {
3073 loop {
3074 if cursor.field_name().is_none()
3075 && cursor.node().is_named()
3076 && !cursor.node().is_extra()
3077 {
3078 result.push(cursor.node());
3079 }
3080 if !cursor.goto_next_sibling() {
3081 break;
3082 }
3083 }
3084 }
3085 result
3086 };
3087 match non_field_children.first() {
3088 Some(&child) => Some(<Super as ::treesitter_types::FromNode>::from_node(
3089 child, src,
3090 )?),
3091 None => None,
3092 }
3093 },
3094 })
3095 }
3096}
3097impl ::treesitter_types::Spanned for FieldAccess<'_> {
3098 fn span(&self) -> ::treesitter_types::Span {
3099 self.span
3100 }
3101}
3102#[derive(Debug, Clone)]
3103pub struct FieldDeclaration<'tree> {
3104 pub span: ::treesitter_types::Span,
3105 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
3106 pub r#type: UnannotatedType<'tree>,
3107 pub children: ::core::option::Option<Modifiers<'tree>>,
3108}
3109impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
3110 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3111 fn from_node(
3112 node: ::tree_sitter::Node<'tree>,
3113 src: &'tree [u8],
3114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3115 debug_assert_eq!(node.kind(), "field_declaration");
3116 Ok(Self {
3117 span: ::treesitter_types::Span::from(node),
3118 declarator: {
3119 let mut cursor = node.walk();
3120 let mut items = ::std::vec::Vec::new();
3121 for child in node.children_by_field_name("declarator", &mut cursor) {
3122 items.push(
3123 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
3124 child, src,
3125 )?,
3126 );
3127 }
3128 items
3129 },
3130 r#type: {
3131 let child = node
3132 .child_by_field_name("type")
3133 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3134 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
3135 },
3136 children: {
3137 #[allow(clippy::suspicious_else_formatting)]
3138 let non_field_children = {
3139 let mut cursor = node.walk();
3140 let mut result = ::std::vec::Vec::new();
3141 if cursor.goto_first_child() {
3142 loop {
3143 if cursor.field_name().is_none()
3144 && cursor.node().is_named()
3145 && !cursor.node().is_extra()
3146 {
3147 result.push(cursor.node());
3148 }
3149 if !cursor.goto_next_sibling() {
3150 break;
3151 }
3152 }
3153 }
3154 result
3155 };
3156 match non_field_children.first() {
3157 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
3158 child, src,
3159 )?),
3160 None => None,
3161 }
3162 },
3163 })
3164 }
3165}
3166impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
3167 fn span(&self) -> ::treesitter_types::Span {
3168 self.span
3169 }
3170}
3171#[derive(Debug, Clone)]
3172pub struct FinallyClause<'tree> {
3173 pub span: ::treesitter_types::Span,
3174 pub children: Block<'tree>,
3175}
3176impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3177 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3178 fn from_node(
3179 node: ::tree_sitter::Node<'tree>,
3180 src: &'tree [u8],
3181 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3182 debug_assert_eq!(node.kind(), "finally_clause");
3183 Ok(Self {
3184 span: ::treesitter_types::Span::from(node),
3185 children: {
3186 #[allow(clippy::suspicious_else_formatting)]
3187 let non_field_children = {
3188 let mut cursor = node.walk();
3189 let mut result = ::std::vec::Vec::new();
3190 if cursor.goto_first_child() {
3191 loop {
3192 if cursor.field_name().is_none()
3193 && cursor.node().is_named()
3194 && !cursor.node().is_extra()
3195 {
3196 result.push(cursor.node());
3197 }
3198 if !cursor.goto_next_sibling() {
3199 break;
3200 }
3201 }
3202 }
3203 result
3204 };
3205 let child = if let Some(&c) = non_field_children.first() {
3206 c
3207 } else {
3208 let mut fallback_cursor = node.walk();
3209 let mut fallback_child = None;
3210 if fallback_cursor.goto_first_child() {
3211 loop {
3212 if fallback_cursor.field_name().is_none()
3213 && !fallback_cursor.node().is_extra()
3214 {
3215 fallback_child = Some(fallback_cursor.node());
3216 break;
3217 }
3218 if !fallback_cursor.goto_next_sibling() {
3219 break;
3220 }
3221 }
3222 }
3223 fallback_child.ok_or_else(|| {
3224 ::treesitter_types::ParseError::missing_field("children", node)
3225 })?
3226 };
3227 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3228 },
3229 })
3230 }
3231}
3232impl ::treesitter_types::Spanned for FinallyClause<'_> {
3233 fn span(&self) -> ::treesitter_types::Span {
3234 self.span
3235 }
3236}
3237#[derive(Debug, Clone)]
3238pub struct FloatingPointType<'tree> {
3239 pub span: ::treesitter_types::Span,
3240 text: &'tree str,
3241}
3242impl<'tree> ::treesitter_types::FromNode<'tree> for FloatingPointType<'tree> {
3243 fn from_node(
3244 node: ::tree_sitter::Node<'tree>,
3245 src: &'tree [u8],
3246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3247 debug_assert_eq!(node.kind(), "floating_point_type");
3248 Ok(Self {
3249 span: ::treesitter_types::Span::from(node),
3250 text: node.utf8_text(src)?,
3251 })
3252 }
3253}
3254impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatingPointType<'tree> {
3255 fn text(&self) -> &'tree str {
3256 self.text
3257 }
3258}
3259impl ::treesitter_types::Spanned for FloatingPointType<'_> {
3260 fn span(&self) -> ::treesitter_types::Span {
3261 self.span
3262 }
3263}
3264#[derive(Debug, Clone)]
3265pub struct ForStatement<'tree> {
3266 pub span: ::treesitter_types::Span,
3267 pub body: Statement<'tree>,
3268 pub condition: ::core::option::Option<Expression<'tree>>,
3269 pub init: ::std::vec::Vec<ForStatementInit<'tree>>,
3270 pub update: ::std::vec::Vec<Expression<'tree>>,
3271}
3272impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3273 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3274 fn from_node(
3275 node: ::tree_sitter::Node<'tree>,
3276 src: &'tree [u8],
3277 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3278 debug_assert_eq!(node.kind(), "for_statement");
3279 Ok(Self {
3280 span: ::treesitter_types::Span::from(node),
3281 body: {
3282 let child = node
3283 .child_by_field_name("body")
3284 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3285 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3286 },
3287 condition: match node.child_by_field_name("condition") {
3288 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3289 child, src,
3290 )?),
3291 None => None,
3292 },
3293 init: {
3294 let mut cursor = node.walk();
3295 let mut items = ::std::vec::Vec::new();
3296 for child in node.children_by_field_name("init", &mut cursor) {
3297 items.push(
3298 <ForStatementInit as ::treesitter_types::FromNode>::from_node(child, src)?,
3299 );
3300 }
3301 items
3302 },
3303 update: {
3304 let mut cursor = node.walk();
3305 let mut items = ::std::vec::Vec::new();
3306 for child in node.children_by_field_name("update", &mut cursor) {
3307 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
3308 child, src,
3309 )?);
3310 }
3311 items
3312 },
3313 })
3314 }
3315}
3316impl ::treesitter_types::Spanned for ForStatement<'_> {
3317 fn span(&self) -> ::treesitter_types::Span {
3318 self.span
3319 }
3320}
3321#[derive(Debug, Clone)]
3322pub struct FormalParameter<'tree> {
3323 pub span: ::treesitter_types::Span,
3324 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
3325 pub name: FormalParameterName<'tree>,
3326 pub r#type: UnannotatedType<'tree>,
3327 pub children: ::core::option::Option<Modifiers<'tree>>,
3328}
3329impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameter<'tree> {
3330 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3331 fn from_node(
3332 node: ::tree_sitter::Node<'tree>,
3333 src: &'tree [u8],
3334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3335 debug_assert_eq!(node.kind(), "formal_parameter");
3336 Ok(Self {
3337 span: ::treesitter_types::Span::from(node),
3338 dimensions: match node.child_by_field_name("dimensions") {
3339 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
3340 child, src,
3341 )?),
3342 None => None,
3343 },
3344 name: {
3345 let child = node
3346 .child_by_field_name("name")
3347 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3348 <FormalParameterName as ::treesitter_types::FromNode>::from_node(child, src)?
3349 },
3350 r#type: {
3351 let child = node
3352 .child_by_field_name("type")
3353 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3354 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
3355 },
3356 children: {
3357 #[allow(clippy::suspicious_else_formatting)]
3358 let non_field_children = {
3359 let mut cursor = node.walk();
3360 let mut result = ::std::vec::Vec::new();
3361 if cursor.goto_first_child() {
3362 loop {
3363 if cursor.field_name().is_none()
3364 && cursor.node().is_named()
3365 && !cursor.node().is_extra()
3366 {
3367 result.push(cursor.node());
3368 }
3369 if !cursor.goto_next_sibling() {
3370 break;
3371 }
3372 }
3373 }
3374 result
3375 };
3376 match non_field_children.first() {
3377 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
3378 child, src,
3379 )?),
3380 None => None,
3381 }
3382 },
3383 })
3384 }
3385}
3386impl ::treesitter_types::Spanned for FormalParameter<'_> {
3387 fn span(&self) -> ::treesitter_types::Span {
3388 self.span
3389 }
3390}
3391#[derive(Debug, Clone)]
3392pub struct FormalParameters<'tree> {
3393 pub span: ::treesitter_types::Span,
3394 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
3395}
3396impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
3397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3398 fn from_node(
3399 node: ::tree_sitter::Node<'tree>,
3400 src: &'tree [u8],
3401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3402 debug_assert_eq!(node.kind(), "formal_parameters");
3403 Ok(Self {
3404 span: ::treesitter_types::Span::from(node),
3405 children: {
3406 #[allow(clippy::suspicious_else_formatting)]
3407 let non_field_children = {
3408 let mut cursor = node.walk();
3409 let mut result = ::std::vec::Vec::new();
3410 if cursor.goto_first_child() {
3411 loop {
3412 if cursor.field_name().is_none()
3413 && cursor.node().is_named()
3414 && !cursor.node().is_extra()
3415 {
3416 result.push(cursor.node());
3417 }
3418 if !cursor.goto_next_sibling() {
3419 break;
3420 }
3421 }
3422 }
3423 result
3424 };
3425 let mut items = ::std::vec::Vec::new();
3426 for child in non_field_children {
3427 items.push(
3428 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
3429 child, src,
3430 )?,
3431 );
3432 }
3433 items
3434 },
3435 })
3436 }
3437}
3438impl ::treesitter_types::Spanned for FormalParameters<'_> {
3439 fn span(&self) -> ::treesitter_types::Span {
3440 self.span
3441 }
3442}
3443#[derive(Debug, Clone)]
3444pub struct GenericType<'tree> {
3445 pub span: ::treesitter_types::Span,
3446 pub children: ::std::vec::Vec<GenericTypeChildren<'tree>>,
3447}
3448impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
3449 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3450 fn from_node(
3451 node: ::tree_sitter::Node<'tree>,
3452 src: &'tree [u8],
3453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3454 debug_assert_eq!(node.kind(), "generic_type");
3455 Ok(Self {
3456 span: ::treesitter_types::Span::from(node),
3457 children: {
3458 #[allow(clippy::suspicious_else_formatting)]
3459 let non_field_children = {
3460 let mut cursor = node.walk();
3461 let mut result = ::std::vec::Vec::new();
3462 if cursor.goto_first_child() {
3463 loop {
3464 if cursor.field_name().is_none()
3465 && cursor.node().is_named()
3466 && !cursor.node().is_extra()
3467 {
3468 result.push(cursor.node());
3469 }
3470 if !cursor.goto_next_sibling() {
3471 break;
3472 }
3473 }
3474 }
3475 result
3476 };
3477 let mut items = ::std::vec::Vec::new();
3478 for child in non_field_children {
3479 items.push(
3480 <GenericTypeChildren as ::treesitter_types::FromNode>::from_node(
3481 child, src,
3482 )?,
3483 );
3484 }
3485 items
3486 },
3487 })
3488 }
3489}
3490impl ::treesitter_types::Spanned for GenericType<'_> {
3491 fn span(&self) -> ::treesitter_types::Span {
3492 self.span
3493 }
3494}
3495#[derive(Debug, Clone)]
3496pub struct Guard<'tree> {
3497 pub span: ::treesitter_types::Span,
3498 pub children: Expression<'tree>,
3499}
3500impl<'tree> ::treesitter_types::FromNode<'tree> for Guard<'tree> {
3501 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3502 fn from_node(
3503 node: ::tree_sitter::Node<'tree>,
3504 src: &'tree [u8],
3505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3506 debug_assert_eq!(node.kind(), "guard");
3507 Ok(Self {
3508 span: ::treesitter_types::Span::from(node),
3509 children: {
3510 #[allow(clippy::suspicious_else_formatting)]
3511 let non_field_children = {
3512 let mut cursor = node.walk();
3513 let mut result = ::std::vec::Vec::new();
3514 if cursor.goto_first_child() {
3515 loop {
3516 if cursor.field_name().is_none()
3517 && cursor.node().is_named()
3518 && !cursor.node().is_extra()
3519 {
3520 result.push(cursor.node());
3521 }
3522 if !cursor.goto_next_sibling() {
3523 break;
3524 }
3525 }
3526 }
3527 result
3528 };
3529 let child = if let Some(&c) = non_field_children.first() {
3530 c
3531 } else {
3532 let mut fallback_cursor = node.walk();
3533 let mut fallback_child = None;
3534 if fallback_cursor.goto_first_child() {
3535 loop {
3536 if fallback_cursor.field_name().is_none()
3537 && !fallback_cursor.node().is_extra()
3538 {
3539 fallback_child = Some(fallback_cursor.node());
3540 break;
3541 }
3542 if !fallback_cursor.goto_next_sibling() {
3543 break;
3544 }
3545 }
3546 }
3547 fallback_child.ok_or_else(|| {
3548 ::treesitter_types::ParseError::missing_field("children", node)
3549 })?
3550 };
3551 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3552 },
3553 })
3554 }
3555}
3556impl ::treesitter_types::Spanned for Guard<'_> {
3557 fn span(&self) -> ::treesitter_types::Span {
3558 self.span
3559 }
3560}
3561#[derive(Debug, Clone)]
3562pub struct IfStatement<'tree> {
3563 pub span: ::treesitter_types::Span,
3564 pub alternative: ::core::option::Option<Statement<'tree>>,
3565 pub condition: ParenthesizedExpression<'tree>,
3566 pub consequence: Statement<'tree>,
3567}
3568impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
3569 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3570 fn from_node(
3571 node: ::tree_sitter::Node<'tree>,
3572 src: &'tree [u8],
3573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3574 debug_assert_eq!(node.kind(), "if_statement");
3575 Ok(Self {
3576 span: ::treesitter_types::Span::from(node),
3577 alternative: match node.child_by_field_name("alternative") {
3578 Some(child) => Some(<Statement as ::treesitter_types::FromNode>::from_node(
3579 child, src,
3580 )?),
3581 None => None,
3582 },
3583 condition: {
3584 let child = node.child_by_field_name("condition").ok_or_else(|| {
3585 ::treesitter_types::ParseError::missing_field("condition", node)
3586 })?;
3587 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
3588 },
3589 consequence: {
3590 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3591 ::treesitter_types::ParseError::missing_field("consequence", node)
3592 })?;
3593 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3594 },
3595 })
3596 }
3597}
3598impl ::treesitter_types::Spanned for IfStatement<'_> {
3599 fn span(&self) -> ::treesitter_types::Span {
3600 self.span
3601 }
3602}
3603#[derive(Debug, Clone)]
3604pub struct ImportDeclaration<'tree> {
3605 pub span: ::treesitter_types::Span,
3606 pub children: ::std::vec::Vec<ImportDeclarationChildren<'tree>>,
3607}
3608impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclaration<'tree> {
3609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3610 fn from_node(
3611 node: ::tree_sitter::Node<'tree>,
3612 src: &'tree [u8],
3613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3614 debug_assert_eq!(node.kind(), "import_declaration");
3615 Ok(Self {
3616 span: ::treesitter_types::Span::from(node),
3617 children: {
3618 #[allow(clippy::suspicious_else_formatting)]
3619 let non_field_children = {
3620 let mut cursor = node.walk();
3621 let mut result = ::std::vec::Vec::new();
3622 if cursor.goto_first_child() {
3623 loop {
3624 if cursor.field_name().is_none()
3625 && cursor.node().is_named()
3626 && !cursor.node().is_extra()
3627 {
3628 result.push(cursor.node());
3629 }
3630 if !cursor.goto_next_sibling() {
3631 break;
3632 }
3633 }
3634 }
3635 result
3636 };
3637 let mut items = ::std::vec::Vec::new();
3638 for child in non_field_children {
3639 items.push(
3640 <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3641 child, src,
3642 )?,
3643 );
3644 }
3645 items
3646 },
3647 })
3648 }
3649}
3650impl ::treesitter_types::Spanned for ImportDeclaration<'_> {
3651 fn span(&self) -> ::treesitter_types::Span {
3652 self.span
3653 }
3654}
3655#[derive(Debug, Clone)]
3656pub struct InferredParameters<'tree> {
3657 pub span: ::treesitter_types::Span,
3658 pub children: ::std::vec::Vec<Identifier<'tree>>,
3659}
3660impl<'tree> ::treesitter_types::FromNode<'tree> for InferredParameters<'tree> {
3661 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3662 fn from_node(
3663 node: ::tree_sitter::Node<'tree>,
3664 src: &'tree [u8],
3665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3666 debug_assert_eq!(node.kind(), "inferred_parameters");
3667 Ok(Self {
3668 span: ::treesitter_types::Span::from(node),
3669 children: {
3670 #[allow(clippy::suspicious_else_formatting)]
3671 let non_field_children = {
3672 let mut cursor = node.walk();
3673 let mut result = ::std::vec::Vec::new();
3674 if cursor.goto_first_child() {
3675 loop {
3676 if cursor.field_name().is_none()
3677 && cursor.node().is_named()
3678 && !cursor.node().is_extra()
3679 {
3680 result.push(cursor.node());
3681 }
3682 if !cursor.goto_next_sibling() {
3683 break;
3684 }
3685 }
3686 }
3687 result
3688 };
3689 let mut items = ::std::vec::Vec::new();
3690 for child in non_field_children {
3691 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
3692 child, src,
3693 )?);
3694 }
3695 items
3696 },
3697 })
3698 }
3699}
3700impl ::treesitter_types::Spanned for InferredParameters<'_> {
3701 fn span(&self) -> ::treesitter_types::Span {
3702 self.span
3703 }
3704}
3705#[derive(Debug, Clone)]
3706pub struct InstanceofExpression<'tree> {
3707 pub span: ::treesitter_types::Span,
3708 pub left: Expression<'tree>,
3709 pub name: ::core::option::Option<Identifier<'tree>>,
3710 pub pattern: ::core::option::Option<RecordPattern<'tree>>,
3711 pub right: ::core::option::Option<Type<'tree>>,
3712}
3713impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceofExpression<'tree> {
3714 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3715 fn from_node(
3716 node: ::tree_sitter::Node<'tree>,
3717 src: &'tree [u8],
3718 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3719 debug_assert_eq!(node.kind(), "instanceof_expression");
3720 Ok(Self {
3721 span: ::treesitter_types::Span::from(node),
3722 left: {
3723 let child = node
3724 .child_by_field_name("left")
3725 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
3726 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3727 },
3728 name: match node.child_by_field_name("name") {
3729 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
3730 child, src,
3731 )?),
3732 None => None,
3733 },
3734 pattern: match node.child_by_field_name("pattern") {
3735 Some(child) => Some(<RecordPattern as ::treesitter_types::FromNode>::from_node(
3736 child, src,
3737 )?),
3738 None => None,
3739 },
3740 right: match node.child_by_field_name("right") {
3741 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3742 child, src,
3743 )?),
3744 None => None,
3745 },
3746 })
3747 }
3748}
3749impl ::treesitter_types::Spanned for InstanceofExpression<'_> {
3750 fn span(&self) -> ::treesitter_types::Span {
3751 self.span
3752 }
3753}
3754#[derive(Debug, Clone)]
3755pub struct IntegralType<'tree> {
3756 pub span: ::treesitter_types::Span,
3757 text: &'tree str,
3758}
3759impl<'tree> ::treesitter_types::FromNode<'tree> for IntegralType<'tree> {
3760 fn from_node(
3761 node: ::tree_sitter::Node<'tree>,
3762 src: &'tree [u8],
3763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3764 debug_assert_eq!(node.kind(), "integral_type");
3765 Ok(Self {
3766 span: ::treesitter_types::Span::from(node),
3767 text: node.utf8_text(src)?,
3768 })
3769 }
3770}
3771impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegralType<'tree> {
3772 fn text(&self) -> &'tree str {
3773 self.text
3774 }
3775}
3776impl ::treesitter_types::Spanned for IntegralType<'_> {
3777 fn span(&self) -> ::treesitter_types::Span {
3778 self.span
3779 }
3780}
3781#[derive(Debug, Clone)]
3782pub struct InterfaceBody<'tree> {
3783 pub span: ::treesitter_types::Span,
3784 pub children: ::std::vec::Vec<InterfaceBodyChildren<'tree>>,
3785}
3786impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBody<'tree> {
3787 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3788 fn from_node(
3789 node: ::tree_sitter::Node<'tree>,
3790 src: &'tree [u8],
3791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3792 debug_assert_eq!(node.kind(), "interface_body");
3793 Ok(Self {
3794 span: ::treesitter_types::Span::from(node),
3795 children: {
3796 #[allow(clippy::suspicious_else_formatting)]
3797 let non_field_children = {
3798 let mut cursor = node.walk();
3799 let mut result = ::std::vec::Vec::new();
3800 if cursor.goto_first_child() {
3801 loop {
3802 if cursor.field_name().is_none()
3803 && cursor.node().is_named()
3804 && !cursor.node().is_extra()
3805 {
3806 result.push(cursor.node());
3807 }
3808 if !cursor.goto_next_sibling() {
3809 break;
3810 }
3811 }
3812 }
3813 result
3814 };
3815 let mut items = ::std::vec::Vec::new();
3816 for child in non_field_children {
3817 items.push(
3818 <InterfaceBodyChildren as ::treesitter_types::FromNode>::from_node(
3819 child, src,
3820 )?,
3821 );
3822 }
3823 items
3824 },
3825 })
3826 }
3827}
3828impl ::treesitter_types::Spanned for InterfaceBody<'_> {
3829 fn span(&self) -> ::treesitter_types::Span {
3830 self.span
3831 }
3832}
3833#[derive(Debug, Clone)]
3834pub struct InterfaceDeclaration<'tree> {
3835 pub span: ::treesitter_types::Span,
3836 pub body: InterfaceBody<'tree>,
3837 pub name: Identifier<'tree>,
3838 pub permits: ::core::option::Option<Permits<'tree>>,
3839 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3840 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
3841}
3842impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
3843 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3844 fn from_node(
3845 node: ::tree_sitter::Node<'tree>,
3846 src: &'tree [u8],
3847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3848 debug_assert_eq!(node.kind(), "interface_declaration");
3849 Ok(Self {
3850 span: ::treesitter_types::Span::from(node),
3851 body: {
3852 let child = node
3853 .child_by_field_name("body")
3854 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3855 <InterfaceBody as ::treesitter_types::FromNode>::from_node(child, src)?
3856 },
3857 name: {
3858 let child = node
3859 .child_by_field_name("name")
3860 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3861 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3862 },
3863 permits: match node.child_by_field_name("permits") {
3864 Some(child) => Some(<Permits as ::treesitter_types::FromNode>::from_node(
3865 child, src,
3866 )?),
3867 None => None,
3868 },
3869 type_parameters: match node.child_by_field_name("type_parameters") {
3870 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3871 child, src,
3872 )?),
3873 None => None,
3874 },
3875 children: {
3876 #[allow(clippy::suspicious_else_formatting)]
3877 let non_field_children = {
3878 let mut cursor = node.walk();
3879 let mut result = ::std::vec::Vec::new();
3880 if cursor.goto_first_child() {
3881 loop {
3882 if cursor.field_name().is_none()
3883 && cursor.node().is_named()
3884 && !cursor.node().is_extra()
3885 {
3886 result.push(cursor.node());
3887 }
3888 if !cursor.goto_next_sibling() {
3889 break;
3890 }
3891 }
3892 }
3893 result
3894 };
3895 let mut items = ::std::vec::Vec::new();
3896 for child in non_field_children {
3897 items.push(
3898 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3899 child, src,
3900 )?,
3901 );
3902 }
3903 items
3904 },
3905 })
3906 }
3907}
3908impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
3909 fn span(&self) -> ::treesitter_types::Span {
3910 self.span
3911 }
3912}
3913#[derive(Debug, Clone)]
3914pub struct LabeledStatement<'tree> {
3915 pub span: ::treesitter_types::Span,
3916 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
3917}
3918impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
3919 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3920 fn from_node(
3921 node: ::tree_sitter::Node<'tree>,
3922 src: &'tree [u8],
3923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3924 debug_assert_eq!(node.kind(), "labeled_statement");
3925 Ok(Self {
3926 span: ::treesitter_types::Span::from(node),
3927 children: {
3928 #[allow(clippy::suspicious_else_formatting)]
3929 let non_field_children = {
3930 let mut cursor = node.walk();
3931 let mut result = ::std::vec::Vec::new();
3932 if cursor.goto_first_child() {
3933 loop {
3934 if cursor.field_name().is_none()
3935 && cursor.node().is_named()
3936 && !cursor.node().is_extra()
3937 {
3938 result.push(cursor.node());
3939 }
3940 if !cursor.goto_next_sibling() {
3941 break;
3942 }
3943 }
3944 }
3945 result
3946 };
3947 let mut items = ::std::vec::Vec::new();
3948 for child in non_field_children {
3949 items.push(
3950 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
3951 child, src,
3952 )?,
3953 );
3954 }
3955 items
3956 },
3957 })
3958 }
3959}
3960impl ::treesitter_types::Spanned for LabeledStatement<'_> {
3961 fn span(&self) -> ::treesitter_types::Span {
3962 self.span
3963 }
3964}
3965#[derive(Debug, Clone)]
3966pub struct LambdaExpression<'tree> {
3967 pub span: ::treesitter_types::Span,
3968 pub body: LambdaExpressionBody<'tree>,
3969 pub parameters: LambdaExpressionParameters<'tree>,
3970}
3971impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
3972 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3973 fn from_node(
3974 node: ::tree_sitter::Node<'tree>,
3975 src: &'tree [u8],
3976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3977 debug_assert_eq!(node.kind(), "lambda_expression");
3978 Ok(Self {
3979 span: ::treesitter_types::Span::from(node),
3980 body: {
3981 let child = node
3982 .child_by_field_name("body")
3983 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3984 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)?
3985 },
3986 parameters: {
3987 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3988 ::treesitter_types::ParseError::missing_field("parameters", node)
3989 })?;
3990 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3991 },
3992 })
3993 }
3994}
3995impl ::treesitter_types::Spanned for LambdaExpression<'_> {
3996 fn span(&self) -> ::treesitter_types::Span {
3997 self.span
3998 }
3999}
4000#[derive(Debug, Clone)]
4001pub struct LocalVariableDeclaration<'tree> {
4002 pub span: ::treesitter_types::Span,
4003 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
4004 pub r#type: UnannotatedType<'tree>,
4005 pub children: ::core::option::Option<Modifiers<'tree>>,
4006}
4007impl<'tree> ::treesitter_types::FromNode<'tree> for LocalVariableDeclaration<'tree> {
4008 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4009 fn from_node(
4010 node: ::tree_sitter::Node<'tree>,
4011 src: &'tree [u8],
4012 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4013 debug_assert_eq!(node.kind(), "local_variable_declaration");
4014 Ok(Self {
4015 span: ::treesitter_types::Span::from(node),
4016 declarator: {
4017 let mut cursor = node.walk();
4018 let mut items = ::std::vec::Vec::new();
4019 for child in node.children_by_field_name("declarator", &mut cursor) {
4020 items.push(
4021 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
4022 child, src,
4023 )?,
4024 );
4025 }
4026 items
4027 },
4028 r#type: {
4029 let child = node
4030 .child_by_field_name("type")
4031 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4032 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
4033 },
4034 children: {
4035 #[allow(clippy::suspicious_else_formatting)]
4036 let non_field_children = {
4037 let mut cursor = node.walk();
4038 let mut result = ::std::vec::Vec::new();
4039 if cursor.goto_first_child() {
4040 loop {
4041 if cursor.field_name().is_none()
4042 && cursor.node().is_named()
4043 && !cursor.node().is_extra()
4044 {
4045 result.push(cursor.node());
4046 }
4047 if !cursor.goto_next_sibling() {
4048 break;
4049 }
4050 }
4051 }
4052 result
4053 };
4054 match non_field_children.first() {
4055 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
4056 child, src,
4057 )?),
4058 None => None,
4059 }
4060 },
4061 })
4062 }
4063}
4064impl ::treesitter_types::Spanned for LocalVariableDeclaration<'_> {
4065 fn span(&self) -> ::treesitter_types::Span {
4066 self.span
4067 }
4068}
4069#[derive(Debug, Clone)]
4070pub struct MarkerAnnotation<'tree> {
4071 pub span: ::treesitter_types::Span,
4072 pub name: MarkerAnnotationName<'tree>,
4073}
4074impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotation<'tree> {
4075 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4076 fn from_node(
4077 node: ::tree_sitter::Node<'tree>,
4078 src: &'tree [u8],
4079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4080 debug_assert_eq!(node.kind(), "marker_annotation");
4081 Ok(Self {
4082 span: ::treesitter_types::Span::from(node),
4083 name: {
4084 let child = node
4085 .child_by_field_name("name")
4086 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4087 <MarkerAnnotationName as ::treesitter_types::FromNode>::from_node(child, src)?
4088 },
4089 })
4090 }
4091}
4092impl ::treesitter_types::Spanned for MarkerAnnotation<'_> {
4093 fn span(&self) -> ::treesitter_types::Span {
4094 self.span
4095 }
4096}
4097#[derive(Debug, Clone)]
4098pub struct MethodDeclaration<'tree> {
4099 pub span: ::treesitter_types::Span,
4100 pub body: ::core::option::Option<Block<'tree>>,
4101 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
4102 pub name: Identifier<'tree>,
4103 pub parameters: FormalParameters<'tree>,
4104 pub r#type: UnannotatedType<'tree>,
4105 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4106 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
4107}
4108impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
4109 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4110 fn from_node(
4111 node: ::tree_sitter::Node<'tree>,
4112 src: &'tree [u8],
4113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4114 debug_assert_eq!(node.kind(), "method_declaration");
4115 Ok(Self {
4116 span: ::treesitter_types::Span::from(node),
4117 body: match node.child_by_field_name("body") {
4118 Some(child) => Some(<Block as ::treesitter_types::FromNode>::from_node(
4119 child, src,
4120 )?),
4121 None => None,
4122 },
4123 dimensions: match node.child_by_field_name("dimensions") {
4124 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
4125 child, src,
4126 )?),
4127 None => None,
4128 },
4129 name: {
4130 let child = node
4131 .child_by_field_name("name")
4132 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4133 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4134 },
4135 parameters: {
4136 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4137 ::treesitter_types::ParseError::missing_field("parameters", node)
4138 })?;
4139 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
4140 },
4141 r#type: {
4142 let child = node
4143 .child_by_field_name("type")
4144 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4145 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
4146 },
4147 type_parameters: match node.child_by_field_name("type_parameters") {
4148 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
4149 child, src,
4150 )?),
4151 None => None,
4152 },
4153 children: {
4154 #[allow(clippy::suspicious_else_formatting)]
4155 let non_field_children = {
4156 let mut cursor = node.walk();
4157 let mut result = ::std::vec::Vec::new();
4158 if cursor.goto_first_child() {
4159 loop {
4160 if cursor.field_name().is_none()
4161 && cursor.node().is_named()
4162 && !cursor.node().is_extra()
4163 {
4164 result.push(cursor.node());
4165 }
4166 if !cursor.goto_next_sibling() {
4167 break;
4168 }
4169 }
4170 }
4171 result
4172 };
4173 let mut items = ::std::vec::Vec::new();
4174 for child in non_field_children {
4175 items.push(
4176 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4177 child, src,
4178 )?,
4179 );
4180 }
4181 items
4182 },
4183 })
4184 }
4185}
4186impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
4187 fn span(&self) -> ::treesitter_types::Span {
4188 self.span
4189 }
4190}
4191#[derive(Debug, Clone)]
4192pub struct MethodInvocation<'tree> {
4193 pub span: ::treesitter_types::Span,
4194 pub arguments: ArgumentList<'tree>,
4195 pub name: Identifier<'tree>,
4196 pub object: ::core::option::Option<MethodInvocationObject<'tree>>,
4197 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
4198 pub children: ::core::option::Option<Super<'tree>>,
4199}
4200impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocation<'tree> {
4201 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4202 fn from_node(
4203 node: ::tree_sitter::Node<'tree>,
4204 src: &'tree [u8],
4205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4206 debug_assert_eq!(node.kind(), "method_invocation");
4207 Ok(Self {
4208 span: ::treesitter_types::Span::from(node),
4209 arguments: {
4210 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4211 ::treesitter_types::ParseError::missing_field("arguments", node)
4212 })?;
4213 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
4214 },
4215 name: {
4216 let child = node
4217 .child_by_field_name("name")
4218 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4219 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4220 },
4221 object: match node.child_by_field_name("object") {
4222 Some(child) => Some(
4223 <MethodInvocationObject as ::treesitter_types::FromNode>::from_node(
4224 child, src,
4225 )?,
4226 ),
4227 None => None,
4228 },
4229 type_arguments: match node.child_by_field_name("type_arguments") {
4230 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
4231 child, src,
4232 )?),
4233 None => None,
4234 },
4235 children: {
4236 #[allow(clippy::suspicious_else_formatting)]
4237 let non_field_children = {
4238 let mut cursor = node.walk();
4239 let mut result = ::std::vec::Vec::new();
4240 if cursor.goto_first_child() {
4241 loop {
4242 if cursor.field_name().is_none()
4243 && cursor.node().is_named()
4244 && !cursor.node().is_extra()
4245 {
4246 result.push(cursor.node());
4247 }
4248 if !cursor.goto_next_sibling() {
4249 break;
4250 }
4251 }
4252 }
4253 result
4254 };
4255 match non_field_children.first() {
4256 Some(&child) => Some(<Super as ::treesitter_types::FromNode>::from_node(
4257 child, src,
4258 )?),
4259 None => None,
4260 }
4261 },
4262 })
4263 }
4264}
4265impl ::treesitter_types::Spanned for MethodInvocation<'_> {
4266 fn span(&self) -> ::treesitter_types::Span {
4267 self.span
4268 }
4269}
4270#[derive(Debug, Clone)]
4271pub struct MethodReference<'tree> {
4272 pub span: ::treesitter_types::Span,
4273 pub children: ::std::vec::Vec<MethodReferenceChildren<'tree>>,
4274}
4275impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReference<'tree> {
4276 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4277 fn from_node(
4278 node: ::tree_sitter::Node<'tree>,
4279 src: &'tree [u8],
4280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4281 debug_assert_eq!(node.kind(), "method_reference");
4282 Ok(Self {
4283 span: ::treesitter_types::Span::from(node),
4284 children: {
4285 #[allow(clippy::suspicious_else_formatting)]
4286 let non_field_children = {
4287 let mut cursor = node.walk();
4288 let mut result = ::std::vec::Vec::new();
4289 if cursor.goto_first_child() {
4290 loop {
4291 if cursor.field_name().is_none()
4292 && cursor.node().is_named()
4293 && !cursor.node().is_extra()
4294 {
4295 result.push(cursor.node());
4296 }
4297 if !cursor.goto_next_sibling() {
4298 break;
4299 }
4300 }
4301 }
4302 result
4303 };
4304 let mut items = ::std::vec::Vec::new();
4305 for child in non_field_children {
4306 items.push(
4307 <MethodReferenceChildren as ::treesitter_types::FromNode>::from_node(
4308 child, src,
4309 )?,
4310 );
4311 }
4312 items
4313 },
4314 })
4315 }
4316}
4317impl ::treesitter_types::Spanned for MethodReference<'_> {
4318 fn span(&self) -> ::treesitter_types::Span {
4319 self.span
4320 }
4321}
4322#[derive(Debug, Clone)]
4323pub struct Modifiers<'tree> {
4324 pub span: ::treesitter_types::Span,
4325 pub children: ::std::vec::Vec<ModifiersChildren<'tree>>,
4326}
4327impl<'tree> ::treesitter_types::FromNode<'tree> for Modifiers<'tree> {
4328 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4329 fn from_node(
4330 node: ::tree_sitter::Node<'tree>,
4331 src: &'tree [u8],
4332 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4333 debug_assert_eq!(node.kind(), "modifiers");
4334 Ok(Self {
4335 span: ::treesitter_types::Span::from(node),
4336 children: {
4337 #[allow(clippy::suspicious_else_formatting)]
4338 let non_field_children = {
4339 let mut cursor = node.walk();
4340 let mut result = ::std::vec::Vec::new();
4341 if cursor.goto_first_child() {
4342 loop {
4343 if cursor.field_name().is_none()
4344 && cursor.node().is_named()
4345 && !cursor.node().is_extra()
4346 {
4347 result.push(cursor.node());
4348 }
4349 if !cursor.goto_next_sibling() {
4350 break;
4351 }
4352 }
4353 }
4354 result
4355 };
4356 let mut items = ::std::vec::Vec::new();
4357 for child in non_field_children {
4358 items.push(
4359 <ModifiersChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4360 );
4361 }
4362 items
4363 },
4364 })
4365 }
4366}
4367impl ::treesitter_types::Spanned for Modifiers<'_> {
4368 fn span(&self) -> ::treesitter_types::Span {
4369 self.span
4370 }
4371}
4372#[derive(Debug, Clone)]
4373pub struct ModuleBody<'tree> {
4374 pub span: ::treesitter_types::Span,
4375 pub children: ::std::vec::Vec<ModuleDirective<'tree>>,
4376}
4377impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleBody<'tree> {
4378 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4379 fn from_node(
4380 node: ::tree_sitter::Node<'tree>,
4381 src: &'tree [u8],
4382 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4383 debug_assert_eq!(node.kind(), "module_body");
4384 Ok(Self {
4385 span: ::treesitter_types::Span::from(node),
4386 children: {
4387 #[allow(clippy::suspicious_else_formatting)]
4388 let non_field_children = {
4389 let mut cursor = node.walk();
4390 let mut result = ::std::vec::Vec::new();
4391 if cursor.goto_first_child() {
4392 loop {
4393 if cursor.field_name().is_none()
4394 && cursor.node().is_named()
4395 && !cursor.node().is_extra()
4396 {
4397 result.push(cursor.node());
4398 }
4399 if !cursor.goto_next_sibling() {
4400 break;
4401 }
4402 }
4403 }
4404 result
4405 };
4406 let mut items = ::std::vec::Vec::new();
4407 for child in non_field_children {
4408 items.push(
4409 <ModuleDirective as ::treesitter_types::FromNode>::from_node(child, src)?,
4410 );
4411 }
4412 items
4413 },
4414 })
4415 }
4416}
4417impl ::treesitter_types::Spanned for ModuleBody<'_> {
4418 fn span(&self) -> ::treesitter_types::Span {
4419 self.span
4420 }
4421}
4422#[derive(Debug, Clone)]
4423pub struct ModuleDeclaration<'tree> {
4424 pub span: ::treesitter_types::Span,
4425 pub body: ModuleBody<'tree>,
4426 pub name: ModuleDeclarationName<'tree>,
4427 pub children: ::std::vec::Vec<ModuleDeclarationChildren<'tree>>,
4428}
4429impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclaration<'tree> {
4430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4431 fn from_node(
4432 node: ::tree_sitter::Node<'tree>,
4433 src: &'tree [u8],
4434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4435 debug_assert_eq!(node.kind(), "module_declaration");
4436 Ok(Self {
4437 span: ::treesitter_types::Span::from(node),
4438 body: {
4439 let child = node
4440 .child_by_field_name("body")
4441 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4442 <ModuleBody as ::treesitter_types::FromNode>::from_node(child, src)?
4443 },
4444 name: {
4445 let child = node
4446 .child_by_field_name("name")
4447 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4448 <ModuleDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)?
4449 },
4450 children: {
4451 #[allow(clippy::suspicious_else_formatting)]
4452 let non_field_children = {
4453 let mut cursor = node.walk();
4454 let mut result = ::std::vec::Vec::new();
4455 if cursor.goto_first_child() {
4456 loop {
4457 if cursor.field_name().is_none()
4458 && cursor.node().is_named()
4459 && !cursor.node().is_extra()
4460 {
4461 result.push(cursor.node());
4462 }
4463 if !cursor.goto_next_sibling() {
4464 break;
4465 }
4466 }
4467 }
4468 result
4469 };
4470 let mut items = ::std::vec::Vec::new();
4471 for child in non_field_children {
4472 items.push(
4473 <ModuleDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4474 child, src,
4475 )?,
4476 );
4477 }
4478 items
4479 },
4480 })
4481 }
4482}
4483impl ::treesitter_types::Spanned for ModuleDeclaration<'_> {
4484 fn span(&self) -> ::treesitter_types::Span {
4485 self.span
4486 }
4487}
4488#[derive(Debug, Clone)]
4489pub struct MultilineStringFragment<'tree> {
4490 pub span: ::treesitter_types::Span,
4491 text: &'tree str,
4492}
4493impl<'tree> ::treesitter_types::FromNode<'tree> for MultilineStringFragment<'tree> {
4494 fn from_node(
4495 node: ::tree_sitter::Node<'tree>,
4496 src: &'tree [u8],
4497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4498 debug_assert_eq!(node.kind(), "multiline_string_fragment");
4499 Ok(Self {
4500 span: ::treesitter_types::Span::from(node),
4501 text: node.utf8_text(src)?,
4502 })
4503 }
4504}
4505impl<'tree> ::treesitter_types::LeafNode<'tree> for MultilineStringFragment<'tree> {
4506 fn text(&self) -> &'tree str {
4507 self.text
4508 }
4509}
4510impl ::treesitter_types::Spanned for MultilineStringFragment<'_> {
4511 fn span(&self) -> ::treesitter_types::Span {
4512 self.span
4513 }
4514}
4515#[derive(Debug, Clone)]
4516pub struct ObjectCreationExpression<'tree> {
4517 pub span: ::treesitter_types::Span,
4518 pub arguments: ArgumentList<'tree>,
4519 pub r#type: SimpleType<'tree>,
4520 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
4521 pub children: ::std::vec::Vec<ObjectCreationExpressionChildren<'tree>>,
4522}
4523impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
4524 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4525 fn from_node(
4526 node: ::tree_sitter::Node<'tree>,
4527 src: &'tree [u8],
4528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4529 debug_assert_eq!(node.kind(), "object_creation_expression");
4530 Ok(Self {
4531 span: ::treesitter_types::Span::from(node),
4532 arguments: {
4533 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4534 ::treesitter_types::ParseError::missing_field("arguments", node)
4535 })?;
4536 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
4537 },
4538 r#type: {
4539 let child = node
4540 .child_by_field_name("type")
4541 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4542 <SimpleType as ::treesitter_types::FromNode>::from_node(child, src)?
4543 },
4544 type_arguments: match node.child_by_field_name("type_arguments") {
4545 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
4546 child, src,
4547 )?),
4548 None => None,
4549 },
4550 children: {
4551 #[allow(clippy::suspicious_else_formatting)]
4552 let non_field_children = {
4553 let mut cursor = node.walk();
4554 let mut result = ::std::vec::Vec::new();
4555 if cursor.goto_first_child() {
4556 loop {
4557 if cursor.field_name().is_none()
4558 && cursor.node().is_named()
4559 && !cursor.node().is_extra()
4560 {
4561 result.push(cursor.node());
4562 }
4563 if !cursor.goto_next_sibling() {
4564 break;
4565 }
4566 }
4567 }
4568 result
4569 };
4570 let mut items = ::std::vec::Vec::new();
4571 for child in non_field_children {
4572 items
4573 .push(
4574 <ObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
4575 child,
4576 src,
4577 )?,
4578 );
4579 }
4580 items
4581 },
4582 })
4583 }
4584}
4585impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
4586 fn span(&self) -> ::treesitter_types::Span {
4587 self.span
4588 }
4589}
4590#[derive(Debug, Clone)]
4591pub struct OpensModuleDirective<'tree> {
4592 pub span: ::treesitter_types::Span,
4593 pub modules: ::std::vec::Vec<OpensModuleDirectiveModules<'tree>>,
4594 pub package: OpensModuleDirectivePackage<'tree>,
4595}
4596impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirective<'tree> {
4597 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4598 fn from_node(
4599 node: ::tree_sitter::Node<'tree>,
4600 src: &'tree [u8],
4601 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4602 debug_assert_eq!(node.kind(), "opens_module_directive");
4603 Ok(Self {
4604 span: ::treesitter_types::Span::from(node),
4605 modules: {
4606 let mut cursor = node.walk();
4607 let mut items = ::std::vec::Vec::new();
4608 for child in node.children_by_field_name("modules", &mut cursor) {
4609 items.push(
4610 <OpensModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
4611 child, src,
4612 )?,
4613 );
4614 }
4615 items
4616 },
4617 package: {
4618 let child = node.child_by_field_name("package").ok_or_else(|| {
4619 ::treesitter_types::ParseError::missing_field("package", node)
4620 })?;
4621 <OpensModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
4622 child, src,
4623 )?
4624 },
4625 })
4626 }
4627}
4628impl ::treesitter_types::Spanned for OpensModuleDirective<'_> {
4629 fn span(&self) -> ::treesitter_types::Span {
4630 self.span
4631 }
4632}
4633#[derive(Debug, Clone)]
4634pub struct PackageDeclaration<'tree> {
4635 pub span: ::treesitter_types::Span,
4636 pub children: ::std::vec::Vec<PackageDeclarationChildren<'tree>>,
4637}
4638impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclaration<'tree> {
4639 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4640 fn from_node(
4641 node: ::tree_sitter::Node<'tree>,
4642 src: &'tree [u8],
4643 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4644 debug_assert_eq!(node.kind(), "package_declaration");
4645 Ok(Self {
4646 span: ::treesitter_types::Span::from(node),
4647 children: {
4648 #[allow(clippy::suspicious_else_formatting)]
4649 let non_field_children = {
4650 let mut cursor = node.walk();
4651 let mut result = ::std::vec::Vec::new();
4652 if cursor.goto_first_child() {
4653 loop {
4654 if cursor.field_name().is_none()
4655 && cursor.node().is_named()
4656 && !cursor.node().is_extra()
4657 {
4658 result.push(cursor.node());
4659 }
4660 if !cursor.goto_next_sibling() {
4661 break;
4662 }
4663 }
4664 }
4665 result
4666 };
4667 let mut items = ::std::vec::Vec::new();
4668 for child in non_field_children {
4669 items.push(
4670 <PackageDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4671 child, src,
4672 )?,
4673 );
4674 }
4675 items
4676 },
4677 })
4678 }
4679}
4680impl ::treesitter_types::Spanned for PackageDeclaration<'_> {
4681 fn span(&self) -> ::treesitter_types::Span {
4682 self.span
4683 }
4684}
4685#[derive(Debug, Clone)]
4686pub struct ParenthesizedExpression<'tree> {
4687 pub span: ::treesitter_types::Span,
4688 pub children: Expression<'tree>,
4689}
4690impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
4691 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4692 fn from_node(
4693 node: ::tree_sitter::Node<'tree>,
4694 src: &'tree [u8],
4695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4696 debug_assert_eq!(node.kind(), "parenthesized_expression");
4697 Ok(Self {
4698 span: ::treesitter_types::Span::from(node),
4699 children: {
4700 #[allow(clippy::suspicious_else_formatting)]
4701 let non_field_children = {
4702 let mut cursor = node.walk();
4703 let mut result = ::std::vec::Vec::new();
4704 if cursor.goto_first_child() {
4705 loop {
4706 if cursor.field_name().is_none()
4707 && cursor.node().is_named()
4708 && !cursor.node().is_extra()
4709 {
4710 result.push(cursor.node());
4711 }
4712 if !cursor.goto_next_sibling() {
4713 break;
4714 }
4715 }
4716 }
4717 result
4718 };
4719 let child = if let Some(&c) = non_field_children.first() {
4720 c
4721 } else {
4722 let mut fallback_cursor = node.walk();
4723 let mut fallback_child = None;
4724 if fallback_cursor.goto_first_child() {
4725 loop {
4726 if fallback_cursor.field_name().is_none()
4727 && !fallback_cursor.node().is_extra()
4728 {
4729 fallback_child = Some(fallback_cursor.node());
4730 break;
4731 }
4732 if !fallback_cursor.goto_next_sibling() {
4733 break;
4734 }
4735 }
4736 }
4737 fallback_child.ok_or_else(|| {
4738 ::treesitter_types::ParseError::missing_field("children", node)
4739 })?
4740 };
4741 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4742 },
4743 })
4744 }
4745}
4746impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
4747 fn span(&self) -> ::treesitter_types::Span {
4748 self.span
4749 }
4750}
4751#[derive(Debug, Clone)]
4752pub struct Pattern<'tree> {
4753 pub span: ::treesitter_types::Span,
4754 pub children: PatternChildren<'tree>,
4755}
4756impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
4757 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4758 fn from_node(
4759 node: ::tree_sitter::Node<'tree>,
4760 src: &'tree [u8],
4761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4762 debug_assert_eq!(node.kind(), "pattern");
4763 Ok(Self {
4764 span: ::treesitter_types::Span::from(node),
4765 children: {
4766 #[allow(clippy::suspicious_else_formatting)]
4767 let non_field_children = {
4768 let mut cursor = node.walk();
4769 let mut result = ::std::vec::Vec::new();
4770 if cursor.goto_first_child() {
4771 loop {
4772 if cursor.field_name().is_none()
4773 && cursor.node().is_named()
4774 && !cursor.node().is_extra()
4775 {
4776 result.push(cursor.node());
4777 }
4778 if !cursor.goto_next_sibling() {
4779 break;
4780 }
4781 }
4782 }
4783 result
4784 };
4785 let child = if let Some(&c) = non_field_children.first() {
4786 c
4787 } else {
4788 let mut fallback_cursor = node.walk();
4789 let mut fallback_child = None;
4790 if fallback_cursor.goto_first_child() {
4791 loop {
4792 if fallback_cursor.field_name().is_none()
4793 && !fallback_cursor.node().is_extra()
4794 {
4795 fallback_child = Some(fallback_cursor.node());
4796 break;
4797 }
4798 if !fallback_cursor.goto_next_sibling() {
4799 break;
4800 }
4801 }
4802 }
4803 fallback_child.ok_or_else(|| {
4804 ::treesitter_types::ParseError::missing_field("children", node)
4805 })?
4806 };
4807 <PatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4808 },
4809 })
4810 }
4811}
4812impl ::treesitter_types::Spanned for Pattern<'_> {
4813 fn span(&self) -> ::treesitter_types::Span {
4814 self.span
4815 }
4816}
4817#[derive(Debug, Clone)]
4818pub struct Permits<'tree> {
4819 pub span: ::treesitter_types::Span,
4820 pub children: TypeList<'tree>,
4821}
4822impl<'tree> ::treesitter_types::FromNode<'tree> for Permits<'tree> {
4823 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4824 fn from_node(
4825 node: ::tree_sitter::Node<'tree>,
4826 src: &'tree [u8],
4827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4828 debug_assert_eq!(node.kind(), "permits");
4829 Ok(Self {
4830 span: ::treesitter_types::Span::from(node),
4831 children: {
4832 #[allow(clippy::suspicious_else_formatting)]
4833 let non_field_children = {
4834 let mut cursor = node.walk();
4835 let mut result = ::std::vec::Vec::new();
4836 if cursor.goto_first_child() {
4837 loop {
4838 if cursor.field_name().is_none()
4839 && cursor.node().is_named()
4840 && !cursor.node().is_extra()
4841 {
4842 result.push(cursor.node());
4843 }
4844 if !cursor.goto_next_sibling() {
4845 break;
4846 }
4847 }
4848 }
4849 result
4850 };
4851 let child = if let Some(&c) = non_field_children.first() {
4852 c
4853 } else {
4854 let mut fallback_cursor = node.walk();
4855 let mut fallback_child = None;
4856 if fallback_cursor.goto_first_child() {
4857 loop {
4858 if fallback_cursor.field_name().is_none()
4859 && !fallback_cursor.node().is_extra()
4860 {
4861 fallback_child = Some(fallback_cursor.node());
4862 break;
4863 }
4864 if !fallback_cursor.goto_next_sibling() {
4865 break;
4866 }
4867 }
4868 }
4869 fallback_child.ok_or_else(|| {
4870 ::treesitter_types::ParseError::missing_field("children", node)
4871 })?
4872 };
4873 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
4874 },
4875 })
4876 }
4877}
4878impl ::treesitter_types::Spanned for Permits<'_> {
4879 fn span(&self) -> ::treesitter_types::Span {
4880 self.span
4881 }
4882}
4883#[derive(Debug, Clone)]
4884pub struct Program<'tree> {
4885 pub span: ::treesitter_types::Span,
4886 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
4887}
4888impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
4889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4890 fn from_node(
4891 node: ::tree_sitter::Node<'tree>,
4892 src: &'tree [u8],
4893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4894 debug_assert_eq!(node.kind(), "program");
4895 Ok(Self {
4896 span: ::treesitter_types::Span::from(node),
4897 children: {
4898 #[allow(clippy::suspicious_else_formatting)]
4899 let non_field_children = {
4900 let mut cursor = node.walk();
4901 let mut result = ::std::vec::Vec::new();
4902 if cursor.goto_first_child() {
4903 loop {
4904 if cursor.field_name().is_none()
4905 && cursor.node().is_named()
4906 && !cursor.node().is_extra()
4907 {
4908 result.push(cursor.node());
4909 }
4910 if !cursor.goto_next_sibling() {
4911 break;
4912 }
4913 }
4914 }
4915 result
4916 };
4917 let mut items = ::std::vec::Vec::new();
4918 for child in non_field_children {
4919 items.push(
4920 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4921 );
4922 }
4923 items
4924 },
4925 })
4926 }
4927}
4928impl ::treesitter_types::Spanned for Program<'_> {
4929 fn span(&self) -> ::treesitter_types::Span {
4930 self.span
4931 }
4932}
4933#[derive(Debug, Clone)]
4934pub struct ProvidesModuleDirective<'tree> {
4935 pub span: ::treesitter_types::Span,
4936 pub provided: ProvidesModuleDirectiveProvided<'tree>,
4937 pub provider: ::std::vec::Vec<ProvidesModuleDirectiveProvider<'tree>>,
4938 pub children: ProvidesModuleDirectiveChildren<'tree>,
4939}
4940impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirective<'tree> {
4941 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4942 fn from_node(
4943 node: ::tree_sitter::Node<'tree>,
4944 src: &'tree [u8],
4945 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4946 debug_assert_eq!(node.kind(), "provides_module_directive");
4947 Ok(Self {
4948 span: ::treesitter_types::Span::from(node),
4949 provided: {
4950 let child = node.child_by_field_name("provided").ok_or_else(|| {
4951 ::treesitter_types::ParseError::missing_field("provided", node)
4952 })?;
4953 <ProvidesModuleDirectiveProvided as ::treesitter_types::FromNode>::from_node(
4954 child, src,
4955 )?
4956 },
4957 provider: {
4958 let mut cursor = node.walk();
4959 let mut items = ::std::vec::Vec::new();
4960 for child in node.children_by_field_name("provider", &mut cursor) {
4961 items
4962 .push(
4963 <ProvidesModuleDirectiveProvider as ::treesitter_types::FromNode>::from_node(
4964 child,
4965 src,
4966 )?,
4967 );
4968 }
4969 items
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 child = if let Some(&c) = non_field_children.first() {
4992 c
4993 } else {
4994 let mut fallback_cursor = node.walk();
4995 let mut fallback_child = None;
4996 if fallback_cursor.goto_first_child() {
4997 loop {
4998 if fallback_cursor.field_name().is_none()
4999 && !fallback_cursor.node().is_extra()
5000 {
5001 fallback_child = Some(fallback_cursor.node());
5002 break;
5003 }
5004 if !fallback_cursor.goto_next_sibling() {
5005 break;
5006 }
5007 }
5008 }
5009 fallback_child.ok_or_else(|| {
5010 ::treesitter_types::ParseError::missing_field("children", node)
5011 })?
5012 };
5013 <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5014 child, src,
5015 )?
5016 },
5017 })
5018 }
5019}
5020impl ::treesitter_types::Spanned for ProvidesModuleDirective<'_> {
5021 fn span(&self) -> ::treesitter_types::Span {
5022 self.span
5023 }
5024}
5025#[derive(Debug, Clone)]
5026pub struct ReceiverParameter<'tree> {
5027 pub span: ::treesitter_types::Span,
5028 pub children: ::std::vec::Vec<ReceiverParameterChildren<'tree>>,
5029}
5030impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameter<'tree> {
5031 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5032 fn from_node(
5033 node: ::tree_sitter::Node<'tree>,
5034 src: &'tree [u8],
5035 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5036 debug_assert_eq!(node.kind(), "receiver_parameter");
5037 Ok(Self {
5038 span: ::treesitter_types::Span::from(node),
5039 children: {
5040 #[allow(clippy::suspicious_else_formatting)]
5041 let non_field_children = {
5042 let mut cursor = node.walk();
5043 let mut result = ::std::vec::Vec::new();
5044 if cursor.goto_first_child() {
5045 loop {
5046 if cursor.field_name().is_none()
5047 && cursor.node().is_named()
5048 && !cursor.node().is_extra()
5049 {
5050 result.push(cursor.node());
5051 }
5052 if !cursor.goto_next_sibling() {
5053 break;
5054 }
5055 }
5056 }
5057 result
5058 };
5059 let mut items = ::std::vec::Vec::new();
5060 for child in non_field_children {
5061 items.push(
5062 <ReceiverParameterChildren as ::treesitter_types::FromNode>::from_node(
5063 child, src,
5064 )?,
5065 );
5066 }
5067 items
5068 },
5069 })
5070 }
5071}
5072impl ::treesitter_types::Spanned for ReceiverParameter<'_> {
5073 fn span(&self) -> ::treesitter_types::Span {
5074 self.span
5075 }
5076}
5077#[derive(Debug, Clone)]
5078pub struct RecordDeclaration<'tree> {
5079 pub span: ::treesitter_types::Span,
5080 pub body: ClassBody<'tree>,
5081 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
5082 pub name: Identifier<'tree>,
5083 pub parameters: FormalParameters<'tree>,
5084 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
5085 pub children: ::core::option::Option<Modifiers<'tree>>,
5086}
5087impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
5088 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5089 fn from_node(
5090 node: ::tree_sitter::Node<'tree>,
5091 src: &'tree [u8],
5092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5093 debug_assert_eq!(node.kind(), "record_declaration");
5094 Ok(Self {
5095 span: ::treesitter_types::Span::from(node),
5096 body: {
5097 let child = node
5098 .child_by_field_name("body")
5099 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5100 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
5101 },
5102 interfaces: match node.child_by_field_name("interfaces") {
5103 Some(child) => {
5104 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
5105 }
5106 None => None,
5107 },
5108 name: {
5109 let child = node
5110 .child_by_field_name("name")
5111 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5112 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5113 },
5114 parameters: {
5115 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5116 ::treesitter_types::ParseError::missing_field("parameters", node)
5117 })?;
5118 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
5119 },
5120 type_parameters: match node.child_by_field_name("type_parameters") {
5121 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
5122 child, src,
5123 )?),
5124 None => None,
5125 },
5126 children: {
5127 #[allow(clippy::suspicious_else_formatting)]
5128 let non_field_children = {
5129 let mut cursor = node.walk();
5130 let mut result = ::std::vec::Vec::new();
5131 if cursor.goto_first_child() {
5132 loop {
5133 if cursor.field_name().is_none()
5134 && cursor.node().is_named()
5135 && !cursor.node().is_extra()
5136 {
5137 result.push(cursor.node());
5138 }
5139 if !cursor.goto_next_sibling() {
5140 break;
5141 }
5142 }
5143 }
5144 result
5145 };
5146 match non_field_children.first() {
5147 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
5148 child, src,
5149 )?),
5150 None => None,
5151 }
5152 },
5153 })
5154 }
5155}
5156impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
5157 fn span(&self) -> ::treesitter_types::Span {
5158 self.span
5159 }
5160}
5161#[derive(Debug, Clone)]
5162pub struct RecordPattern<'tree> {
5163 pub span: ::treesitter_types::Span,
5164 pub children: ::std::vec::Vec<RecordPatternChildren<'tree>>,
5165}
5166impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPattern<'tree> {
5167 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5168 fn from_node(
5169 node: ::tree_sitter::Node<'tree>,
5170 src: &'tree [u8],
5171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5172 debug_assert_eq!(node.kind(), "record_pattern");
5173 Ok(Self {
5174 span: ::treesitter_types::Span::from(node),
5175 children: {
5176 #[allow(clippy::suspicious_else_formatting)]
5177 let non_field_children = {
5178 let mut cursor = node.walk();
5179 let mut result = ::std::vec::Vec::new();
5180 if cursor.goto_first_child() {
5181 loop {
5182 if cursor.field_name().is_none()
5183 && cursor.node().is_named()
5184 && !cursor.node().is_extra()
5185 {
5186 result.push(cursor.node());
5187 }
5188 if !cursor.goto_next_sibling() {
5189 break;
5190 }
5191 }
5192 }
5193 result
5194 };
5195 let mut items = ::std::vec::Vec::new();
5196 for child in non_field_children {
5197 items.push(
5198 <RecordPatternChildren as ::treesitter_types::FromNode>::from_node(
5199 child, src,
5200 )?,
5201 );
5202 }
5203 items
5204 },
5205 })
5206 }
5207}
5208impl ::treesitter_types::Spanned for RecordPattern<'_> {
5209 fn span(&self) -> ::treesitter_types::Span {
5210 self.span
5211 }
5212}
5213#[derive(Debug, Clone)]
5214pub struct RecordPatternBody<'tree> {
5215 pub span: ::treesitter_types::Span,
5216 pub children: ::std::vec::Vec<RecordPatternBodyChildren<'tree>>,
5217}
5218impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBody<'tree> {
5219 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5220 fn from_node(
5221 node: ::tree_sitter::Node<'tree>,
5222 src: &'tree [u8],
5223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5224 debug_assert_eq!(node.kind(), "record_pattern_body");
5225 Ok(Self {
5226 span: ::treesitter_types::Span::from(node),
5227 children: {
5228 #[allow(clippy::suspicious_else_formatting)]
5229 let non_field_children = {
5230 let mut cursor = node.walk();
5231 let mut result = ::std::vec::Vec::new();
5232 if cursor.goto_first_child() {
5233 loop {
5234 if cursor.field_name().is_none()
5235 && cursor.node().is_named()
5236 && !cursor.node().is_extra()
5237 {
5238 result.push(cursor.node());
5239 }
5240 if !cursor.goto_next_sibling() {
5241 break;
5242 }
5243 }
5244 }
5245 result
5246 };
5247 let mut items = ::std::vec::Vec::new();
5248 for child in non_field_children {
5249 items.push(
5250 <RecordPatternBodyChildren as ::treesitter_types::FromNode>::from_node(
5251 child, src,
5252 )?,
5253 );
5254 }
5255 items
5256 },
5257 })
5258 }
5259}
5260impl ::treesitter_types::Spanned for RecordPatternBody<'_> {
5261 fn span(&self) -> ::treesitter_types::Span {
5262 self.span
5263 }
5264}
5265#[derive(Debug, Clone)]
5266pub struct RecordPatternComponent<'tree> {
5267 pub span: ::treesitter_types::Span,
5268 pub children: ::std::vec::Vec<RecordPatternComponentChildren<'tree>>,
5269}
5270impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponent<'tree> {
5271 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5272 fn from_node(
5273 node: ::tree_sitter::Node<'tree>,
5274 src: &'tree [u8],
5275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5276 debug_assert_eq!(node.kind(), "record_pattern_component");
5277 Ok(Self {
5278 span: ::treesitter_types::Span::from(node),
5279 children: {
5280 #[allow(clippy::suspicious_else_formatting)]
5281 let non_field_children = {
5282 let mut cursor = node.walk();
5283 let mut result = ::std::vec::Vec::new();
5284 if cursor.goto_first_child() {
5285 loop {
5286 if cursor.field_name().is_none()
5287 && cursor.node().is_named()
5288 && !cursor.node().is_extra()
5289 {
5290 result.push(cursor.node());
5291 }
5292 if !cursor.goto_next_sibling() {
5293 break;
5294 }
5295 }
5296 }
5297 result
5298 };
5299 let mut items = ::std::vec::Vec::new();
5300 for child in non_field_children {
5301 items
5302 .push(
5303 <RecordPatternComponentChildren as ::treesitter_types::FromNode>::from_node(
5304 child,
5305 src,
5306 )?,
5307 );
5308 }
5309 items
5310 },
5311 })
5312 }
5313}
5314impl ::treesitter_types::Spanned for RecordPatternComponent<'_> {
5315 fn span(&self) -> ::treesitter_types::Span {
5316 self.span
5317 }
5318}
5319#[derive(Debug, Clone)]
5320pub struct RequiresModifier<'tree> {
5321 pub span: ::treesitter_types::Span,
5322 text: &'tree str,
5323}
5324impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModifier<'tree> {
5325 fn from_node(
5326 node: ::tree_sitter::Node<'tree>,
5327 src: &'tree [u8],
5328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5329 debug_assert_eq!(node.kind(), "requires_modifier");
5330 Ok(Self {
5331 span: ::treesitter_types::Span::from(node),
5332 text: node.utf8_text(src)?,
5333 })
5334 }
5335}
5336impl<'tree> ::treesitter_types::LeafNode<'tree> for RequiresModifier<'tree> {
5337 fn text(&self) -> &'tree str {
5338 self.text
5339 }
5340}
5341impl ::treesitter_types::Spanned for RequiresModifier<'_> {
5342 fn span(&self) -> ::treesitter_types::Span {
5343 self.span
5344 }
5345}
5346#[derive(Debug, Clone)]
5347pub struct RequiresModuleDirective<'tree> {
5348 pub span: ::treesitter_types::Span,
5349 pub modifiers: ::std::vec::Vec<RequiresModifier<'tree>>,
5350 pub module: RequiresModuleDirectiveModule<'tree>,
5351}
5352impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirective<'tree> {
5353 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5354 fn from_node(
5355 node: ::tree_sitter::Node<'tree>,
5356 src: &'tree [u8],
5357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5358 debug_assert_eq!(node.kind(), "requires_module_directive");
5359 Ok(Self {
5360 span: ::treesitter_types::Span::from(node),
5361 modifiers: {
5362 let mut cursor = node.walk();
5363 let mut items = ::std::vec::Vec::new();
5364 for child in node.children_by_field_name("modifiers", &mut cursor) {
5365 items.push(
5366 <RequiresModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5367 );
5368 }
5369 items
5370 },
5371 module: {
5372 let child = node
5373 .child_by_field_name("module")
5374 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
5375 <RequiresModuleDirectiveModule as ::treesitter_types::FromNode>::from_node(
5376 child, src,
5377 )?
5378 },
5379 })
5380 }
5381}
5382impl ::treesitter_types::Spanned for RequiresModuleDirective<'_> {
5383 fn span(&self) -> ::treesitter_types::Span {
5384 self.span
5385 }
5386}
5387#[derive(Debug, Clone)]
5388pub struct Resource<'tree> {
5389 pub span: ::treesitter_types::Span,
5390 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
5391 pub name: ::core::option::Option<ResourceName<'tree>>,
5392 pub r#type: ::core::option::Option<UnannotatedType<'tree>>,
5393 pub value: ::core::option::Option<Expression<'tree>>,
5394 pub children: ::core::option::Option<ResourceChildren<'tree>>,
5395}
5396impl<'tree> ::treesitter_types::FromNode<'tree> for Resource<'tree> {
5397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5398 fn from_node(
5399 node: ::tree_sitter::Node<'tree>,
5400 src: &'tree [u8],
5401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5402 debug_assert_eq!(node.kind(), "resource");
5403 Ok(Self {
5404 span: ::treesitter_types::Span::from(node),
5405 dimensions: match node.child_by_field_name("dimensions") {
5406 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
5407 child, src,
5408 )?),
5409 None => None,
5410 },
5411 name: match node.child_by_field_name("name") {
5412 Some(child) => Some(<ResourceName as ::treesitter_types::FromNode>::from_node(
5413 child, src,
5414 )?),
5415 None => None,
5416 },
5417 r#type: match node.child_by_field_name("type") {
5418 Some(child) => {
5419 Some(<UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?)
5420 }
5421 None => None,
5422 },
5423 value: match node.child_by_field_name("value") {
5424 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5425 child, src,
5426 )?),
5427 None => None,
5428 },
5429 children: {
5430 #[allow(clippy::suspicious_else_formatting)]
5431 let non_field_children = {
5432 let mut cursor = node.walk();
5433 let mut result = ::std::vec::Vec::new();
5434 if cursor.goto_first_child() {
5435 loop {
5436 if cursor.field_name().is_none()
5437 && cursor.node().is_named()
5438 && !cursor.node().is_extra()
5439 {
5440 result.push(cursor.node());
5441 }
5442 if !cursor.goto_next_sibling() {
5443 break;
5444 }
5445 }
5446 }
5447 result
5448 };
5449 match non_field_children.first() {
5450 Some(&child) => Some(
5451 <ResourceChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5452 ),
5453 None => None,
5454 }
5455 },
5456 })
5457 }
5458}
5459impl ::treesitter_types::Spanned for Resource<'_> {
5460 fn span(&self) -> ::treesitter_types::Span {
5461 self.span
5462 }
5463}
5464#[derive(Debug, Clone)]
5465pub struct ResourceSpecification<'tree> {
5466 pub span: ::treesitter_types::Span,
5467 pub children: ::std::vec::Vec<Resource<'tree>>,
5468}
5469impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceSpecification<'tree> {
5470 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5471 fn from_node(
5472 node: ::tree_sitter::Node<'tree>,
5473 src: &'tree [u8],
5474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5475 debug_assert_eq!(node.kind(), "resource_specification");
5476 Ok(Self {
5477 span: ::treesitter_types::Span::from(node),
5478 children: {
5479 #[allow(clippy::suspicious_else_formatting)]
5480 let non_field_children = {
5481 let mut cursor = node.walk();
5482 let mut result = ::std::vec::Vec::new();
5483 if cursor.goto_first_child() {
5484 loop {
5485 if cursor.field_name().is_none()
5486 && cursor.node().is_named()
5487 && !cursor.node().is_extra()
5488 {
5489 result.push(cursor.node());
5490 }
5491 if !cursor.goto_next_sibling() {
5492 break;
5493 }
5494 }
5495 }
5496 result
5497 };
5498 let mut items = ::std::vec::Vec::new();
5499 for child in non_field_children {
5500 items.push(<Resource as ::treesitter_types::FromNode>::from_node(
5501 child, src,
5502 )?);
5503 }
5504 items
5505 },
5506 })
5507 }
5508}
5509impl ::treesitter_types::Spanned for ResourceSpecification<'_> {
5510 fn span(&self) -> ::treesitter_types::Span {
5511 self.span
5512 }
5513}
5514#[derive(Debug, Clone)]
5515pub struct ReturnStatement<'tree> {
5516 pub span: ::treesitter_types::Span,
5517 pub children: ::core::option::Option<Expression<'tree>>,
5518}
5519impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
5520 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5521 fn from_node(
5522 node: ::tree_sitter::Node<'tree>,
5523 src: &'tree [u8],
5524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5525 debug_assert_eq!(node.kind(), "return_statement");
5526 Ok(Self {
5527 span: ::treesitter_types::Span::from(node),
5528 children: {
5529 #[allow(clippy::suspicious_else_formatting)]
5530 let non_field_children = {
5531 let mut cursor = node.walk();
5532 let mut result = ::std::vec::Vec::new();
5533 if cursor.goto_first_child() {
5534 loop {
5535 if cursor.field_name().is_none()
5536 && cursor.node().is_named()
5537 && !cursor.node().is_extra()
5538 {
5539 result.push(cursor.node());
5540 }
5541 if !cursor.goto_next_sibling() {
5542 break;
5543 }
5544 }
5545 }
5546 result
5547 };
5548 match non_field_children.first() {
5549 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5550 child, src,
5551 )?),
5552 None => None,
5553 }
5554 },
5555 })
5556 }
5557}
5558impl ::treesitter_types::Spanned for ReturnStatement<'_> {
5559 fn span(&self) -> ::treesitter_types::Span {
5560 self.span
5561 }
5562}
5563#[derive(Debug, Clone)]
5564pub struct ScopedIdentifier<'tree> {
5565 pub span: ::treesitter_types::Span,
5566 pub name: Identifier<'tree>,
5567 pub scope: ScopedIdentifierScope<'tree>,
5568}
5569impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
5570 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5571 fn from_node(
5572 node: ::tree_sitter::Node<'tree>,
5573 src: &'tree [u8],
5574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5575 debug_assert_eq!(node.kind(), "scoped_identifier");
5576 Ok(Self {
5577 span: ::treesitter_types::Span::from(node),
5578 name: {
5579 let child = node
5580 .child_by_field_name("name")
5581 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5582 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5583 },
5584 scope: {
5585 let child = node
5586 .child_by_field_name("scope")
5587 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
5588 <ScopedIdentifierScope as ::treesitter_types::FromNode>::from_node(child, src)?
5589 },
5590 })
5591 }
5592}
5593impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
5594 fn span(&self) -> ::treesitter_types::Span {
5595 self.span
5596 }
5597}
5598#[derive(Debug, Clone)]
5599pub struct ScopedTypeIdentifier<'tree> {
5600 pub span: ::treesitter_types::Span,
5601 pub children: ::std::vec::Vec<ScopedTypeIdentifierChildren<'tree>>,
5602}
5603impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
5604 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5605 fn from_node(
5606 node: ::tree_sitter::Node<'tree>,
5607 src: &'tree [u8],
5608 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5609 debug_assert_eq!(node.kind(), "scoped_type_identifier");
5610 Ok(Self {
5611 span: ::treesitter_types::Span::from(node),
5612 children: {
5613 #[allow(clippy::suspicious_else_formatting)]
5614 let non_field_children = {
5615 let mut cursor = node.walk();
5616 let mut result = ::std::vec::Vec::new();
5617 if cursor.goto_first_child() {
5618 loop {
5619 if cursor.field_name().is_none()
5620 && cursor.node().is_named()
5621 && !cursor.node().is_extra()
5622 {
5623 result.push(cursor.node());
5624 }
5625 if !cursor.goto_next_sibling() {
5626 break;
5627 }
5628 }
5629 }
5630 result
5631 };
5632 let mut items = ::std::vec::Vec::new();
5633 for child in non_field_children {
5634 items.push(
5635 <ScopedTypeIdentifierChildren as ::treesitter_types::FromNode>::from_node(
5636 child, src,
5637 )?,
5638 );
5639 }
5640 items
5641 },
5642 })
5643 }
5644}
5645impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
5646 fn span(&self) -> ::treesitter_types::Span {
5647 self.span
5648 }
5649}
5650#[derive(Debug, Clone)]
5651pub struct SpreadParameter<'tree> {
5652 pub span: ::treesitter_types::Span,
5653 pub children: ::std::vec::Vec<SpreadParameterChildren<'tree>>,
5654}
5655impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameter<'tree> {
5656 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5657 fn from_node(
5658 node: ::tree_sitter::Node<'tree>,
5659 src: &'tree [u8],
5660 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5661 debug_assert_eq!(node.kind(), "spread_parameter");
5662 Ok(Self {
5663 span: ::treesitter_types::Span::from(node),
5664 children: {
5665 #[allow(clippy::suspicious_else_formatting)]
5666 let non_field_children = {
5667 let mut cursor = node.walk();
5668 let mut result = ::std::vec::Vec::new();
5669 if cursor.goto_first_child() {
5670 loop {
5671 if cursor.field_name().is_none()
5672 && cursor.node().is_named()
5673 && !cursor.node().is_extra()
5674 {
5675 result.push(cursor.node());
5676 }
5677 if !cursor.goto_next_sibling() {
5678 break;
5679 }
5680 }
5681 }
5682 result
5683 };
5684 let mut items = ::std::vec::Vec::new();
5685 for child in non_field_children {
5686 items.push(
5687 <SpreadParameterChildren as ::treesitter_types::FromNode>::from_node(
5688 child, src,
5689 )?,
5690 );
5691 }
5692 items
5693 },
5694 })
5695 }
5696}
5697impl ::treesitter_types::Spanned for SpreadParameter<'_> {
5698 fn span(&self) -> ::treesitter_types::Span {
5699 self.span
5700 }
5701}
5702#[derive(Debug, Clone)]
5703pub struct StaticInitializer<'tree> {
5704 pub span: ::treesitter_types::Span,
5705 pub children: Block<'tree>,
5706}
5707impl<'tree> ::treesitter_types::FromNode<'tree> for StaticInitializer<'tree> {
5708 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5709 fn from_node(
5710 node: ::tree_sitter::Node<'tree>,
5711 src: &'tree [u8],
5712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5713 debug_assert_eq!(node.kind(), "static_initializer");
5714 Ok(Self {
5715 span: ::treesitter_types::Span::from(node),
5716 children: {
5717 #[allow(clippy::suspicious_else_formatting)]
5718 let non_field_children = {
5719 let mut cursor = node.walk();
5720 let mut result = ::std::vec::Vec::new();
5721 if cursor.goto_first_child() {
5722 loop {
5723 if cursor.field_name().is_none()
5724 && cursor.node().is_named()
5725 && !cursor.node().is_extra()
5726 {
5727 result.push(cursor.node());
5728 }
5729 if !cursor.goto_next_sibling() {
5730 break;
5731 }
5732 }
5733 }
5734 result
5735 };
5736 let child = if let Some(&c) = non_field_children.first() {
5737 c
5738 } else {
5739 let mut fallback_cursor = node.walk();
5740 let mut fallback_child = None;
5741 if fallback_cursor.goto_first_child() {
5742 loop {
5743 if fallback_cursor.field_name().is_none()
5744 && !fallback_cursor.node().is_extra()
5745 {
5746 fallback_child = Some(fallback_cursor.node());
5747 break;
5748 }
5749 if !fallback_cursor.goto_next_sibling() {
5750 break;
5751 }
5752 }
5753 }
5754 fallback_child.ok_or_else(|| {
5755 ::treesitter_types::ParseError::missing_field("children", node)
5756 })?
5757 };
5758 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
5759 },
5760 })
5761 }
5762}
5763impl ::treesitter_types::Spanned for StaticInitializer<'_> {
5764 fn span(&self) -> ::treesitter_types::Span {
5765 self.span
5766 }
5767}
5768#[derive(Debug, Clone)]
5769pub struct StringInterpolation<'tree> {
5770 pub span: ::treesitter_types::Span,
5771 pub children: Expression<'tree>,
5772}
5773impl<'tree> ::treesitter_types::FromNode<'tree> for StringInterpolation<'tree> {
5774 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5775 fn from_node(
5776 node: ::tree_sitter::Node<'tree>,
5777 src: &'tree [u8],
5778 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5779 debug_assert_eq!(node.kind(), "string_interpolation");
5780 Ok(Self {
5781 span: ::treesitter_types::Span::from(node),
5782 children: {
5783 #[allow(clippy::suspicious_else_formatting)]
5784 let non_field_children = {
5785 let mut cursor = node.walk();
5786 let mut result = ::std::vec::Vec::new();
5787 if cursor.goto_first_child() {
5788 loop {
5789 if cursor.field_name().is_none()
5790 && cursor.node().is_named()
5791 && !cursor.node().is_extra()
5792 {
5793 result.push(cursor.node());
5794 }
5795 if !cursor.goto_next_sibling() {
5796 break;
5797 }
5798 }
5799 }
5800 result
5801 };
5802 let child = if let Some(&c) = non_field_children.first() {
5803 c
5804 } else {
5805 let mut fallback_cursor = node.walk();
5806 let mut fallback_child = None;
5807 if fallback_cursor.goto_first_child() {
5808 loop {
5809 if fallback_cursor.field_name().is_none()
5810 && !fallback_cursor.node().is_extra()
5811 {
5812 fallback_child = Some(fallback_cursor.node());
5813 break;
5814 }
5815 if !fallback_cursor.goto_next_sibling() {
5816 break;
5817 }
5818 }
5819 }
5820 fallback_child.ok_or_else(|| {
5821 ::treesitter_types::ParseError::missing_field("children", node)
5822 })?
5823 };
5824 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5825 },
5826 })
5827 }
5828}
5829impl ::treesitter_types::Spanned for StringInterpolation<'_> {
5830 fn span(&self) -> ::treesitter_types::Span {
5831 self.span
5832 }
5833}
5834#[derive(Debug, Clone)]
5835pub struct StringLiteral<'tree> {
5836 pub span: ::treesitter_types::Span,
5837 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
5838}
5839impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
5840 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5841 fn from_node(
5842 node: ::tree_sitter::Node<'tree>,
5843 src: &'tree [u8],
5844 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5845 debug_assert_eq!(node.kind(), "string_literal");
5846 Ok(Self {
5847 span: ::treesitter_types::Span::from(node),
5848 children: {
5849 #[allow(clippy::suspicious_else_formatting)]
5850 let non_field_children = {
5851 let mut cursor = node.walk();
5852 let mut result = ::std::vec::Vec::new();
5853 if cursor.goto_first_child() {
5854 loop {
5855 if cursor.field_name().is_none()
5856 && cursor.node().is_named()
5857 && !cursor.node().is_extra()
5858 {
5859 result.push(cursor.node());
5860 }
5861 if !cursor.goto_next_sibling() {
5862 break;
5863 }
5864 }
5865 }
5866 result
5867 };
5868 let mut items = ::std::vec::Vec::new();
5869 for child in non_field_children {
5870 items.push(
5871 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
5872 child, src,
5873 )?,
5874 );
5875 }
5876 items
5877 },
5878 })
5879 }
5880}
5881impl ::treesitter_types::Spanned for StringLiteral<'_> {
5882 fn span(&self) -> ::treesitter_types::Span {
5883 self.span
5884 }
5885}
5886#[derive(Debug, Clone)]
5887pub struct SuperInterfaces<'tree> {
5888 pub span: ::treesitter_types::Span,
5889 pub children: TypeList<'tree>,
5890}
5891impl<'tree> ::treesitter_types::FromNode<'tree> for SuperInterfaces<'tree> {
5892 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5893 fn from_node(
5894 node: ::tree_sitter::Node<'tree>,
5895 src: &'tree [u8],
5896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5897 debug_assert_eq!(node.kind(), "super_interfaces");
5898 Ok(Self {
5899 span: ::treesitter_types::Span::from(node),
5900 children: {
5901 #[allow(clippy::suspicious_else_formatting)]
5902 let non_field_children = {
5903 let mut cursor = node.walk();
5904 let mut result = ::std::vec::Vec::new();
5905 if cursor.goto_first_child() {
5906 loop {
5907 if cursor.field_name().is_none()
5908 && cursor.node().is_named()
5909 && !cursor.node().is_extra()
5910 {
5911 result.push(cursor.node());
5912 }
5913 if !cursor.goto_next_sibling() {
5914 break;
5915 }
5916 }
5917 }
5918 result
5919 };
5920 let child = if let Some(&c) = non_field_children.first() {
5921 c
5922 } else {
5923 let mut fallback_cursor = node.walk();
5924 let mut fallback_child = None;
5925 if fallback_cursor.goto_first_child() {
5926 loop {
5927 if fallback_cursor.field_name().is_none()
5928 && !fallback_cursor.node().is_extra()
5929 {
5930 fallback_child = Some(fallback_cursor.node());
5931 break;
5932 }
5933 if !fallback_cursor.goto_next_sibling() {
5934 break;
5935 }
5936 }
5937 }
5938 fallback_child.ok_or_else(|| {
5939 ::treesitter_types::ParseError::missing_field("children", node)
5940 })?
5941 };
5942 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
5943 },
5944 })
5945 }
5946}
5947impl ::treesitter_types::Spanned for SuperInterfaces<'_> {
5948 fn span(&self) -> ::treesitter_types::Span {
5949 self.span
5950 }
5951}
5952#[derive(Debug, Clone)]
5953pub struct Superclass<'tree> {
5954 pub span: ::treesitter_types::Span,
5955 pub children: Type<'tree>,
5956}
5957impl<'tree> ::treesitter_types::FromNode<'tree> for Superclass<'tree> {
5958 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5959 fn from_node(
5960 node: ::tree_sitter::Node<'tree>,
5961 src: &'tree [u8],
5962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5963 debug_assert_eq!(node.kind(), "superclass");
5964 Ok(Self {
5965 span: ::treesitter_types::Span::from(node),
5966 children: {
5967 #[allow(clippy::suspicious_else_formatting)]
5968 let non_field_children = {
5969 let mut cursor = node.walk();
5970 let mut result = ::std::vec::Vec::new();
5971 if cursor.goto_first_child() {
5972 loop {
5973 if cursor.field_name().is_none()
5974 && cursor.node().is_named()
5975 && !cursor.node().is_extra()
5976 {
5977 result.push(cursor.node());
5978 }
5979 if !cursor.goto_next_sibling() {
5980 break;
5981 }
5982 }
5983 }
5984 result
5985 };
5986 let child = if let Some(&c) = non_field_children.first() {
5987 c
5988 } else {
5989 let mut fallback_cursor = node.walk();
5990 let mut fallback_child = None;
5991 if fallback_cursor.goto_first_child() {
5992 loop {
5993 if fallback_cursor.field_name().is_none()
5994 && !fallback_cursor.node().is_extra()
5995 {
5996 fallback_child = Some(fallback_cursor.node());
5997 break;
5998 }
5999 if !fallback_cursor.goto_next_sibling() {
6000 break;
6001 }
6002 }
6003 }
6004 fallback_child.ok_or_else(|| {
6005 ::treesitter_types::ParseError::missing_field("children", node)
6006 })?
6007 };
6008 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6009 },
6010 })
6011 }
6012}
6013impl ::treesitter_types::Spanned for Superclass<'_> {
6014 fn span(&self) -> ::treesitter_types::Span {
6015 self.span
6016 }
6017}
6018#[derive(Debug, Clone)]
6019pub struct SwitchBlock<'tree> {
6020 pub span: ::treesitter_types::Span,
6021 pub children: ::std::vec::Vec<SwitchBlockChildren<'tree>>,
6022}
6023impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlock<'tree> {
6024 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6025 fn from_node(
6026 node: ::tree_sitter::Node<'tree>,
6027 src: &'tree [u8],
6028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6029 debug_assert_eq!(node.kind(), "switch_block");
6030 Ok(Self {
6031 span: ::treesitter_types::Span::from(node),
6032 children: {
6033 #[allow(clippy::suspicious_else_formatting)]
6034 let non_field_children = {
6035 let mut cursor = node.walk();
6036 let mut result = ::std::vec::Vec::new();
6037 if cursor.goto_first_child() {
6038 loop {
6039 if cursor.field_name().is_none()
6040 && cursor.node().is_named()
6041 && !cursor.node().is_extra()
6042 {
6043 result.push(cursor.node());
6044 }
6045 if !cursor.goto_next_sibling() {
6046 break;
6047 }
6048 }
6049 }
6050 result
6051 };
6052 let mut items = ::std::vec::Vec::new();
6053 for child in non_field_children {
6054 items.push(
6055 <SwitchBlockChildren as ::treesitter_types::FromNode>::from_node(
6056 child, src,
6057 )?,
6058 );
6059 }
6060 items
6061 },
6062 })
6063 }
6064}
6065impl ::treesitter_types::Spanned for SwitchBlock<'_> {
6066 fn span(&self) -> ::treesitter_types::Span {
6067 self.span
6068 }
6069}
6070#[derive(Debug, Clone)]
6071pub struct SwitchBlockStatementGroup<'tree> {
6072 pub span: ::treesitter_types::Span,
6073 pub children: ::std::vec::Vec<SwitchBlockStatementGroupChildren<'tree>>,
6074}
6075impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroup<'tree> {
6076 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6077 fn from_node(
6078 node: ::tree_sitter::Node<'tree>,
6079 src: &'tree [u8],
6080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6081 debug_assert_eq!(node.kind(), "switch_block_statement_group");
6082 Ok(Self {
6083 span: ::treesitter_types::Span::from(node),
6084 children: {
6085 #[allow(clippy::suspicious_else_formatting)]
6086 let non_field_children = {
6087 let mut cursor = node.walk();
6088 let mut result = ::std::vec::Vec::new();
6089 if cursor.goto_first_child() {
6090 loop {
6091 if cursor.field_name().is_none()
6092 && cursor.node().is_named()
6093 && !cursor.node().is_extra()
6094 {
6095 result.push(cursor.node());
6096 }
6097 if !cursor.goto_next_sibling() {
6098 break;
6099 }
6100 }
6101 }
6102 result
6103 };
6104 let mut items = ::std::vec::Vec::new();
6105 for child in non_field_children {
6106 items
6107 .push(
6108 <SwitchBlockStatementGroupChildren as ::treesitter_types::FromNode>::from_node(
6109 child,
6110 src,
6111 )?,
6112 );
6113 }
6114 items
6115 },
6116 })
6117 }
6118}
6119impl ::treesitter_types::Spanned for SwitchBlockStatementGroup<'_> {
6120 fn span(&self) -> ::treesitter_types::Span {
6121 self.span
6122 }
6123}
6124#[derive(Debug, Clone)]
6125pub struct SwitchExpression<'tree> {
6126 pub span: ::treesitter_types::Span,
6127 pub body: SwitchBlock<'tree>,
6128 pub condition: ParenthesizedExpression<'tree>,
6129}
6130impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
6131 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6132 fn from_node(
6133 node: ::tree_sitter::Node<'tree>,
6134 src: &'tree [u8],
6135 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6136 debug_assert_eq!(node.kind(), "switch_expression");
6137 Ok(Self {
6138 span: ::treesitter_types::Span::from(node),
6139 body: {
6140 let child = node
6141 .child_by_field_name("body")
6142 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6143 <SwitchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
6144 },
6145 condition: {
6146 let child = node.child_by_field_name("condition").ok_or_else(|| {
6147 ::treesitter_types::ParseError::missing_field("condition", node)
6148 })?;
6149 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6150 },
6151 })
6152 }
6153}
6154impl ::treesitter_types::Spanned for SwitchExpression<'_> {
6155 fn span(&self) -> ::treesitter_types::Span {
6156 self.span
6157 }
6158}
6159#[derive(Debug, Clone)]
6160pub struct SwitchLabel<'tree> {
6161 pub span: ::treesitter_types::Span,
6162 pub children: ::std::vec::Vec<SwitchLabelChildren<'tree>>,
6163}
6164impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabel<'tree> {
6165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6166 fn from_node(
6167 node: ::tree_sitter::Node<'tree>,
6168 src: &'tree [u8],
6169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6170 debug_assert_eq!(node.kind(), "switch_label");
6171 Ok(Self {
6172 span: ::treesitter_types::Span::from(node),
6173 children: {
6174 #[allow(clippy::suspicious_else_formatting)]
6175 let non_field_children = {
6176 let mut cursor = node.walk();
6177 let mut result = ::std::vec::Vec::new();
6178 if cursor.goto_first_child() {
6179 loop {
6180 if cursor.field_name().is_none()
6181 && cursor.node().is_named()
6182 && !cursor.node().is_extra()
6183 {
6184 result.push(cursor.node());
6185 }
6186 if !cursor.goto_next_sibling() {
6187 break;
6188 }
6189 }
6190 }
6191 result
6192 };
6193 let mut items = ::std::vec::Vec::new();
6194 for child in non_field_children {
6195 items.push(
6196 <SwitchLabelChildren as ::treesitter_types::FromNode>::from_node(
6197 child, src,
6198 )?,
6199 );
6200 }
6201 items
6202 },
6203 })
6204 }
6205}
6206impl ::treesitter_types::Spanned for SwitchLabel<'_> {
6207 fn span(&self) -> ::treesitter_types::Span {
6208 self.span
6209 }
6210}
6211#[derive(Debug, Clone)]
6212pub struct SwitchRule<'tree> {
6213 pub span: ::treesitter_types::Span,
6214 pub children: ::std::vec::Vec<SwitchRuleChildren<'tree>>,
6215}
6216impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRule<'tree> {
6217 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6218 fn from_node(
6219 node: ::tree_sitter::Node<'tree>,
6220 src: &'tree [u8],
6221 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6222 debug_assert_eq!(node.kind(), "switch_rule");
6223 Ok(Self {
6224 span: ::treesitter_types::Span::from(node),
6225 children: {
6226 #[allow(clippy::suspicious_else_formatting)]
6227 let non_field_children = {
6228 let mut cursor = node.walk();
6229 let mut result = ::std::vec::Vec::new();
6230 if cursor.goto_first_child() {
6231 loop {
6232 if cursor.field_name().is_none()
6233 && cursor.node().is_named()
6234 && !cursor.node().is_extra()
6235 {
6236 result.push(cursor.node());
6237 }
6238 if !cursor.goto_next_sibling() {
6239 break;
6240 }
6241 }
6242 }
6243 result
6244 };
6245 let mut items = ::std::vec::Vec::new();
6246 for child in non_field_children {
6247 items.push(
6248 <SwitchRuleChildren as ::treesitter_types::FromNode>::from_node(
6249 child, src,
6250 )?,
6251 );
6252 }
6253 items
6254 },
6255 })
6256 }
6257}
6258impl ::treesitter_types::Spanned for SwitchRule<'_> {
6259 fn span(&self) -> ::treesitter_types::Span {
6260 self.span
6261 }
6262}
6263#[derive(Debug, Clone)]
6264pub struct SynchronizedStatement<'tree> {
6265 pub span: ::treesitter_types::Span,
6266 pub body: Block<'tree>,
6267 pub children: ParenthesizedExpression<'tree>,
6268}
6269impl<'tree> ::treesitter_types::FromNode<'tree> for SynchronizedStatement<'tree> {
6270 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6271 fn from_node(
6272 node: ::tree_sitter::Node<'tree>,
6273 src: &'tree [u8],
6274 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6275 debug_assert_eq!(node.kind(), "synchronized_statement");
6276 Ok(Self {
6277 span: ::treesitter_types::Span::from(node),
6278 body: {
6279 let child = node
6280 .child_by_field_name("body")
6281 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6282 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
6283 },
6284 children: {
6285 #[allow(clippy::suspicious_else_formatting)]
6286 let non_field_children = {
6287 let mut cursor = node.walk();
6288 let mut result = ::std::vec::Vec::new();
6289 if cursor.goto_first_child() {
6290 loop {
6291 if cursor.field_name().is_none()
6292 && cursor.node().is_named()
6293 && !cursor.node().is_extra()
6294 {
6295 result.push(cursor.node());
6296 }
6297 if !cursor.goto_next_sibling() {
6298 break;
6299 }
6300 }
6301 }
6302 result
6303 };
6304 let child = if let Some(&c) = non_field_children.first() {
6305 c
6306 } else {
6307 let mut fallback_cursor = node.walk();
6308 let mut fallback_child = None;
6309 if fallback_cursor.goto_first_child() {
6310 loop {
6311 if fallback_cursor.field_name().is_none()
6312 && !fallback_cursor.node().is_extra()
6313 {
6314 fallback_child = Some(fallback_cursor.node());
6315 break;
6316 }
6317 if !fallback_cursor.goto_next_sibling() {
6318 break;
6319 }
6320 }
6321 }
6322 fallback_child.ok_or_else(|| {
6323 ::treesitter_types::ParseError::missing_field("children", node)
6324 })?
6325 };
6326 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6327 },
6328 })
6329 }
6330}
6331impl ::treesitter_types::Spanned for SynchronizedStatement<'_> {
6332 fn span(&self) -> ::treesitter_types::Span {
6333 self.span
6334 }
6335}
6336#[derive(Debug, Clone)]
6337pub struct TemplateExpression<'tree> {
6338 pub span: ::treesitter_types::Span,
6339 pub template_argument: StringLiteral<'tree>,
6340 pub template_processor: PrimaryExpression<'tree>,
6341}
6342impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateExpression<'tree> {
6343 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6344 fn from_node(
6345 node: ::tree_sitter::Node<'tree>,
6346 src: &'tree [u8],
6347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6348 debug_assert_eq!(node.kind(), "template_expression");
6349 Ok(Self {
6350 span: ::treesitter_types::Span::from(node),
6351 template_argument: {
6352 let child = node
6353 .child_by_field_name("template_argument")
6354 .ok_or_else(|| {
6355 ::treesitter_types::ParseError::missing_field("template_argument", node)
6356 })?;
6357 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?
6358 },
6359 template_processor: {
6360 let child = node
6361 .child_by_field_name("template_processor")
6362 .ok_or_else(|| {
6363 ::treesitter_types::ParseError::missing_field("template_processor", node)
6364 })?;
6365 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6366 },
6367 })
6368 }
6369}
6370impl ::treesitter_types::Spanned for TemplateExpression<'_> {
6371 fn span(&self) -> ::treesitter_types::Span {
6372 self.span
6373 }
6374}
6375#[derive(Debug, Clone)]
6376pub struct TernaryExpression<'tree> {
6377 pub span: ::treesitter_types::Span,
6378 pub alternative: Expression<'tree>,
6379 pub condition: Expression<'tree>,
6380 pub consequence: Expression<'tree>,
6381}
6382impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
6383 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6384 fn from_node(
6385 node: ::tree_sitter::Node<'tree>,
6386 src: &'tree [u8],
6387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6388 debug_assert_eq!(node.kind(), "ternary_expression");
6389 Ok(Self {
6390 span: ::treesitter_types::Span::from(node),
6391 alternative: {
6392 let child = node.child_by_field_name("alternative").ok_or_else(|| {
6393 ::treesitter_types::ParseError::missing_field("alternative", node)
6394 })?;
6395 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6396 },
6397 condition: {
6398 let child = node.child_by_field_name("condition").ok_or_else(|| {
6399 ::treesitter_types::ParseError::missing_field("condition", node)
6400 })?;
6401 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6402 },
6403 consequence: {
6404 let child = node.child_by_field_name("consequence").ok_or_else(|| {
6405 ::treesitter_types::ParseError::missing_field("consequence", node)
6406 })?;
6407 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6408 },
6409 })
6410 }
6411}
6412impl ::treesitter_types::Spanned for TernaryExpression<'_> {
6413 fn span(&self) -> ::treesitter_types::Span {
6414 self.span
6415 }
6416}
6417#[derive(Debug, Clone)]
6418pub struct ThrowStatement<'tree> {
6419 pub span: ::treesitter_types::Span,
6420 pub children: Expression<'tree>,
6421}
6422impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
6423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6424 fn from_node(
6425 node: ::tree_sitter::Node<'tree>,
6426 src: &'tree [u8],
6427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6428 debug_assert_eq!(node.kind(), "throw_statement");
6429 Ok(Self {
6430 span: ::treesitter_types::Span::from(node),
6431 children: {
6432 #[allow(clippy::suspicious_else_formatting)]
6433 let non_field_children = {
6434 let mut cursor = node.walk();
6435 let mut result = ::std::vec::Vec::new();
6436 if cursor.goto_first_child() {
6437 loop {
6438 if cursor.field_name().is_none()
6439 && cursor.node().is_named()
6440 && !cursor.node().is_extra()
6441 {
6442 result.push(cursor.node());
6443 }
6444 if !cursor.goto_next_sibling() {
6445 break;
6446 }
6447 }
6448 }
6449 result
6450 };
6451 let child = if let Some(&c) = non_field_children.first() {
6452 c
6453 } else {
6454 let mut fallback_cursor = node.walk();
6455 let mut fallback_child = None;
6456 if fallback_cursor.goto_first_child() {
6457 loop {
6458 if fallback_cursor.field_name().is_none()
6459 && !fallback_cursor.node().is_extra()
6460 {
6461 fallback_child = Some(fallback_cursor.node());
6462 break;
6463 }
6464 if !fallback_cursor.goto_next_sibling() {
6465 break;
6466 }
6467 }
6468 }
6469 fallback_child.ok_or_else(|| {
6470 ::treesitter_types::ParseError::missing_field("children", node)
6471 })?
6472 };
6473 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6474 },
6475 })
6476 }
6477}
6478impl ::treesitter_types::Spanned for ThrowStatement<'_> {
6479 fn span(&self) -> ::treesitter_types::Span {
6480 self.span
6481 }
6482}
6483#[derive(Debug, Clone)]
6484pub struct Throws<'tree> {
6485 pub span: ::treesitter_types::Span,
6486 pub children: ::std::vec::Vec<Type<'tree>>,
6487}
6488impl<'tree> ::treesitter_types::FromNode<'tree> for Throws<'tree> {
6489 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6490 fn from_node(
6491 node: ::tree_sitter::Node<'tree>,
6492 src: &'tree [u8],
6493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6494 debug_assert_eq!(node.kind(), "throws");
6495 Ok(Self {
6496 span: ::treesitter_types::Span::from(node),
6497 children: {
6498 #[allow(clippy::suspicious_else_formatting)]
6499 let non_field_children = {
6500 let mut cursor = node.walk();
6501 let mut result = ::std::vec::Vec::new();
6502 if cursor.goto_first_child() {
6503 loop {
6504 if cursor.field_name().is_none()
6505 && cursor.node().is_named()
6506 && !cursor.node().is_extra()
6507 {
6508 result.push(cursor.node());
6509 }
6510 if !cursor.goto_next_sibling() {
6511 break;
6512 }
6513 }
6514 }
6515 result
6516 };
6517 let mut items = ::std::vec::Vec::new();
6518 for child in non_field_children {
6519 items.push(<Type as ::treesitter_types::FromNode>::from_node(
6520 child, src,
6521 )?);
6522 }
6523 items
6524 },
6525 })
6526 }
6527}
6528impl ::treesitter_types::Spanned for Throws<'_> {
6529 fn span(&self) -> ::treesitter_types::Span {
6530 self.span
6531 }
6532}
6533#[derive(Debug, Clone)]
6534pub struct TryStatement<'tree> {
6535 pub span: ::treesitter_types::Span,
6536 pub body: Block<'tree>,
6537 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
6538}
6539impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
6540 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6541 fn from_node(
6542 node: ::tree_sitter::Node<'tree>,
6543 src: &'tree [u8],
6544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6545 debug_assert_eq!(node.kind(), "try_statement");
6546 Ok(Self {
6547 span: ::treesitter_types::Span::from(node),
6548 body: {
6549 let child = node
6550 .child_by_field_name("body")
6551 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6552 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
6553 },
6554 children: {
6555 #[allow(clippy::suspicious_else_formatting)]
6556 let non_field_children = {
6557 let mut cursor = node.walk();
6558 let mut result = ::std::vec::Vec::new();
6559 if cursor.goto_first_child() {
6560 loop {
6561 if cursor.field_name().is_none()
6562 && cursor.node().is_named()
6563 && !cursor.node().is_extra()
6564 {
6565 result.push(cursor.node());
6566 }
6567 if !cursor.goto_next_sibling() {
6568 break;
6569 }
6570 }
6571 }
6572 result
6573 };
6574 let mut items = ::std::vec::Vec::new();
6575 for child in non_field_children {
6576 items.push(
6577 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
6578 child, src,
6579 )?,
6580 );
6581 }
6582 items
6583 },
6584 })
6585 }
6586}
6587impl ::treesitter_types::Spanned for TryStatement<'_> {
6588 fn span(&self) -> ::treesitter_types::Span {
6589 self.span
6590 }
6591}
6592#[derive(Debug, Clone)]
6593pub struct TryWithResourcesStatement<'tree> {
6594 pub span: ::treesitter_types::Span,
6595 pub body: Block<'tree>,
6596 pub resources: ResourceSpecification<'tree>,
6597 pub children: ::std::vec::Vec<TryWithResourcesStatementChildren<'tree>>,
6598}
6599impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatement<'tree> {
6600 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6601 fn from_node(
6602 node: ::tree_sitter::Node<'tree>,
6603 src: &'tree [u8],
6604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6605 debug_assert_eq!(node.kind(), "try_with_resources_statement");
6606 Ok(Self {
6607 span: ::treesitter_types::Span::from(node),
6608 body: {
6609 let child = node
6610 .child_by_field_name("body")
6611 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6612 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
6613 },
6614 resources: {
6615 let child = node.child_by_field_name("resources").ok_or_else(|| {
6616 ::treesitter_types::ParseError::missing_field("resources", node)
6617 })?;
6618 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(child, src)?
6619 },
6620 children: {
6621 #[allow(clippy::suspicious_else_formatting)]
6622 let non_field_children = {
6623 let mut cursor = node.walk();
6624 let mut result = ::std::vec::Vec::new();
6625 if cursor.goto_first_child() {
6626 loop {
6627 if cursor.field_name().is_none()
6628 && cursor.node().is_named()
6629 && !cursor.node().is_extra()
6630 {
6631 result.push(cursor.node());
6632 }
6633 if !cursor.goto_next_sibling() {
6634 break;
6635 }
6636 }
6637 }
6638 result
6639 };
6640 let mut items = ::std::vec::Vec::new();
6641 for child in non_field_children {
6642 items
6643 .push(
6644 <TryWithResourcesStatementChildren as ::treesitter_types::FromNode>::from_node(
6645 child,
6646 src,
6647 )?,
6648 );
6649 }
6650 items
6651 },
6652 })
6653 }
6654}
6655impl ::treesitter_types::Spanned for TryWithResourcesStatement<'_> {
6656 fn span(&self) -> ::treesitter_types::Span {
6657 self.span
6658 }
6659}
6660#[derive(Debug, Clone)]
6661pub struct TypeArguments<'tree> {
6662 pub span: ::treesitter_types::Span,
6663 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
6664}
6665impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
6666 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6667 fn from_node(
6668 node: ::tree_sitter::Node<'tree>,
6669 src: &'tree [u8],
6670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6671 debug_assert_eq!(node.kind(), "type_arguments");
6672 Ok(Self {
6673 span: ::treesitter_types::Span::from(node),
6674 children: {
6675 #[allow(clippy::suspicious_else_formatting)]
6676 let non_field_children = {
6677 let mut cursor = node.walk();
6678 let mut result = ::std::vec::Vec::new();
6679 if cursor.goto_first_child() {
6680 loop {
6681 if cursor.field_name().is_none()
6682 && cursor.node().is_named()
6683 && !cursor.node().is_extra()
6684 {
6685 result.push(cursor.node());
6686 }
6687 if !cursor.goto_next_sibling() {
6688 break;
6689 }
6690 }
6691 }
6692 result
6693 };
6694 let mut items = ::std::vec::Vec::new();
6695 for child in non_field_children {
6696 items.push(
6697 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
6698 child, src,
6699 )?,
6700 );
6701 }
6702 items
6703 },
6704 })
6705 }
6706}
6707impl ::treesitter_types::Spanned for TypeArguments<'_> {
6708 fn span(&self) -> ::treesitter_types::Span {
6709 self.span
6710 }
6711}
6712#[derive(Debug, Clone)]
6713pub struct TypeBound<'tree> {
6714 pub span: ::treesitter_types::Span,
6715 pub children: ::std::vec::Vec<Type<'tree>>,
6716}
6717impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBound<'tree> {
6718 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6719 fn from_node(
6720 node: ::tree_sitter::Node<'tree>,
6721 src: &'tree [u8],
6722 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6723 debug_assert_eq!(node.kind(), "type_bound");
6724 Ok(Self {
6725 span: ::treesitter_types::Span::from(node),
6726 children: {
6727 #[allow(clippy::suspicious_else_formatting)]
6728 let non_field_children = {
6729 let mut cursor = node.walk();
6730 let mut result = ::std::vec::Vec::new();
6731 if cursor.goto_first_child() {
6732 loop {
6733 if cursor.field_name().is_none()
6734 && cursor.node().is_named()
6735 && !cursor.node().is_extra()
6736 {
6737 result.push(cursor.node());
6738 }
6739 if !cursor.goto_next_sibling() {
6740 break;
6741 }
6742 }
6743 }
6744 result
6745 };
6746 let mut items = ::std::vec::Vec::new();
6747 for child in non_field_children {
6748 items.push(<Type as ::treesitter_types::FromNode>::from_node(
6749 child, src,
6750 )?);
6751 }
6752 items
6753 },
6754 })
6755 }
6756}
6757impl ::treesitter_types::Spanned for TypeBound<'_> {
6758 fn span(&self) -> ::treesitter_types::Span {
6759 self.span
6760 }
6761}
6762#[derive(Debug, Clone)]
6763pub struct TypeList<'tree> {
6764 pub span: ::treesitter_types::Span,
6765 pub children: ::std::vec::Vec<Type<'tree>>,
6766}
6767impl<'tree> ::treesitter_types::FromNode<'tree> for TypeList<'tree> {
6768 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6769 fn from_node(
6770 node: ::tree_sitter::Node<'tree>,
6771 src: &'tree [u8],
6772 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6773 debug_assert_eq!(node.kind(), "type_list");
6774 Ok(Self {
6775 span: ::treesitter_types::Span::from(node),
6776 children: {
6777 #[allow(clippy::suspicious_else_formatting)]
6778 let non_field_children = {
6779 let mut cursor = node.walk();
6780 let mut result = ::std::vec::Vec::new();
6781 if cursor.goto_first_child() {
6782 loop {
6783 if cursor.field_name().is_none()
6784 && cursor.node().is_named()
6785 && !cursor.node().is_extra()
6786 {
6787 result.push(cursor.node());
6788 }
6789 if !cursor.goto_next_sibling() {
6790 break;
6791 }
6792 }
6793 }
6794 result
6795 };
6796 let mut items = ::std::vec::Vec::new();
6797 for child in non_field_children {
6798 items.push(<Type as ::treesitter_types::FromNode>::from_node(
6799 child, src,
6800 )?);
6801 }
6802 items
6803 },
6804 })
6805 }
6806}
6807impl ::treesitter_types::Spanned for TypeList<'_> {
6808 fn span(&self) -> ::treesitter_types::Span {
6809 self.span
6810 }
6811}
6812#[derive(Debug, Clone)]
6813pub struct TypeParameter<'tree> {
6814 pub span: ::treesitter_types::Span,
6815 pub children: ::std::vec::Vec<TypeParameterChildren<'tree>>,
6816}
6817impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
6818 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6819 fn from_node(
6820 node: ::tree_sitter::Node<'tree>,
6821 src: &'tree [u8],
6822 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6823 debug_assert_eq!(node.kind(), "type_parameter");
6824 Ok(Self {
6825 span: ::treesitter_types::Span::from(node),
6826 children: {
6827 #[allow(clippy::suspicious_else_formatting)]
6828 let non_field_children = {
6829 let mut cursor = node.walk();
6830 let mut result = ::std::vec::Vec::new();
6831 if cursor.goto_first_child() {
6832 loop {
6833 if cursor.field_name().is_none()
6834 && cursor.node().is_named()
6835 && !cursor.node().is_extra()
6836 {
6837 result.push(cursor.node());
6838 }
6839 if !cursor.goto_next_sibling() {
6840 break;
6841 }
6842 }
6843 }
6844 result
6845 };
6846 let mut items = ::std::vec::Vec::new();
6847 for child in non_field_children {
6848 items.push(
6849 <TypeParameterChildren as ::treesitter_types::FromNode>::from_node(
6850 child, src,
6851 )?,
6852 );
6853 }
6854 items
6855 },
6856 })
6857 }
6858}
6859impl ::treesitter_types::Spanned for TypeParameter<'_> {
6860 fn span(&self) -> ::treesitter_types::Span {
6861 self.span
6862 }
6863}
6864#[derive(Debug, Clone)]
6865pub struct TypeParameters<'tree> {
6866 pub span: ::treesitter_types::Span,
6867 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
6868}
6869impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
6870 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6871 fn from_node(
6872 node: ::tree_sitter::Node<'tree>,
6873 src: &'tree [u8],
6874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6875 debug_assert_eq!(node.kind(), "type_parameters");
6876 Ok(Self {
6877 span: ::treesitter_types::Span::from(node),
6878 children: {
6879 #[allow(clippy::suspicious_else_formatting)]
6880 let non_field_children = {
6881 let mut cursor = node.walk();
6882 let mut result = ::std::vec::Vec::new();
6883 if cursor.goto_first_child() {
6884 loop {
6885 if cursor.field_name().is_none()
6886 && cursor.node().is_named()
6887 && !cursor.node().is_extra()
6888 {
6889 result.push(cursor.node());
6890 }
6891 if !cursor.goto_next_sibling() {
6892 break;
6893 }
6894 }
6895 }
6896 result
6897 };
6898 let mut items = ::std::vec::Vec::new();
6899 for child in non_field_children {
6900 items.push(<TypeParameter as ::treesitter_types::FromNode>::from_node(
6901 child, src,
6902 )?);
6903 }
6904 items
6905 },
6906 })
6907 }
6908}
6909impl ::treesitter_types::Spanned for TypeParameters<'_> {
6910 fn span(&self) -> ::treesitter_types::Span {
6911 self.span
6912 }
6913}
6914#[derive(Debug, Clone)]
6915pub struct TypePattern<'tree> {
6916 pub span: ::treesitter_types::Span,
6917 pub children: ::std::vec::Vec<TypePatternChildren<'tree>>,
6918}
6919impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
6920 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6921 fn from_node(
6922 node: ::tree_sitter::Node<'tree>,
6923 src: &'tree [u8],
6924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6925 debug_assert_eq!(node.kind(), "type_pattern");
6926 Ok(Self {
6927 span: ::treesitter_types::Span::from(node),
6928 children: {
6929 #[allow(clippy::suspicious_else_formatting)]
6930 let non_field_children = {
6931 let mut cursor = node.walk();
6932 let mut result = ::std::vec::Vec::new();
6933 if cursor.goto_first_child() {
6934 loop {
6935 if cursor.field_name().is_none()
6936 && cursor.node().is_named()
6937 && !cursor.node().is_extra()
6938 {
6939 result.push(cursor.node());
6940 }
6941 if !cursor.goto_next_sibling() {
6942 break;
6943 }
6944 }
6945 }
6946 result
6947 };
6948 let mut items = ::std::vec::Vec::new();
6949 for child in non_field_children {
6950 items.push(
6951 <TypePatternChildren as ::treesitter_types::FromNode>::from_node(
6952 child, src,
6953 )?,
6954 );
6955 }
6956 items
6957 },
6958 })
6959 }
6960}
6961impl ::treesitter_types::Spanned for TypePattern<'_> {
6962 fn span(&self) -> ::treesitter_types::Span {
6963 self.span
6964 }
6965}
6966#[derive(Debug, Clone)]
6967pub struct UnaryExpression<'tree> {
6968 pub span: ::treesitter_types::Span,
6969 pub operand: Expression<'tree>,
6970 pub operator: UnaryExpressionOperator,
6971}
6972impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
6973 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6974 fn from_node(
6975 node: ::tree_sitter::Node<'tree>,
6976 src: &'tree [u8],
6977 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6978 debug_assert_eq!(node.kind(), "unary_expression");
6979 Ok(Self {
6980 span: ::treesitter_types::Span::from(node),
6981 operand: {
6982 let child = node.child_by_field_name("operand").ok_or_else(|| {
6983 ::treesitter_types::ParseError::missing_field("operand", node)
6984 })?;
6985 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6986 },
6987 operator: {
6988 let child = node.child_by_field_name("operator").ok_or_else(|| {
6989 ::treesitter_types::ParseError::missing_field("operator", node)
6990 })?;
6991 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
6992 },
6993 })
6994 }
6995}
6996impl ::treesitter_types::Spanned for UnaryExpression<'_> {
6997 fn span(&self) -> ::treesitter_types::Span {
6998 self.span
6999 }
7000}
7001#[derive(Debug, Clone)]
7002pub struct UpdateExpression<'tree> {
7003 pub span: ::treesitter_types::Span,
7004 pub children: Expression<'tree>,
7005}
7006impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
7007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7008 fn from_node(
7009 node: ::tree_sitter::Node<'tree>,
7010 src: &'tree [u8],
7011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7012 debug_assert_eq!(node.kind(), "update_expression");
7013 Ok(Self {
7014 span: ::treesitter_types::Span::from(node),
7015 children: {
7016 #[allow(clippy::suspicious_else_formatting)]
7017 let non_field_children = {
7018 let mut cursor = node.walk();
7019 let mut result = ::std::vec::Vec::new();
7020 if cursor.goto_first_child() {
7021 loop {
7022 if cursor.field_name().is_none()
7023 && cursor.node().is_named()
7024 && !cursor.node().is_extra()
7025 {
7026 result.push(cursor.node());
7027 }
7028 if !cursor.goto_next_sibling() {
7029 break;
7030 }
7031 }
7032 }
7033 result
7034 };
7035 let child = if let Some(&c) = non_field_children.first() {
7036 c
7037 } else {
7038 let mut fallback_cursor = node.walk();
7039 let mut fallback_child = None;
7040 if fallback_cursor.goto_first_child() {
7041 loop {
7042 if fallback_cursor.field_name().is_none()
7043 && !fallback_cursor.node().is_extra()
7044 {
7045 fallback_child = Some(fallback_cursor.node());
7046 break;
7047 }
7048 if !fallback_cursor.goto_next_sibling() {
7049 break;
7050 }
7051 }
7052 }
7053 fallback_child.ok_or_else(|| {
7054 ::treesitter_types::ParseError::missing_field("children", node)
7055 })?
7056 };
7057 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7058 },
7059 })
7060 }
7061}
7062impl ::treesitter_types::Spanned for UpdateExpression<'_> {
7063 fn span(&self) -> ::treesitter_types::Span {
7064 self.span
7065 }
7066}
7067#[derive(Debug, Clone)]
7068pub struct UsesModuleDirective<'tree> {
7069 pub span: ::treesitter_types::Span,
7070 pub r#type: UsesModuleDirectiveType<'tree>,
7071}
7072impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirective<'tree> {
7073 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7074 fn from_node(
7075 node: ::tree_sitter::Node<'tree>,
7076 src: &'tree [u8],
7077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7078 debug_assert_eq!(node.kind(), "uses_module_directive");
7079 Ok(Self {
7080 span: ::treesitter_types::Span::from(node),
7081 r#type: {
7082 let child = node
7083 .child_by_field_name("type")
7084 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7085 <UsesModuleDirectiveType as ::treesitter_types::FromNode>::from_node(child, src)?
7086 },
7087 })
7088 }
7089}
7090impl ::treesitter_types::Spanned for UsesModuleDirective<'_> {
7091 fn span(&self) -> ::treesitter_types::Span {
7092 self.span
7093 }
7094}
7095#[derive(Debug, Clone)]
7096pub struct VariableDeclarator<'tree> {
7097 pub span: ::treesitter_types::Span,
7098 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
7099 pub name: VariableDeclaratorName<'tree>,
7100 pub value: ::core::option::Option<VariableDeclaratorValue<'tree>>,
7101}
7102impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
7103 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7104 fn from_node(
7105 node: ::tree_sitter::Node<'tree>,
7106 src: &'tree [u8],
7107 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7108 debug_assert_eq!(node.kind(), "variable_declarator");
7109 Ok(Self {
7110 span: ::treesitter_types::Span::from(node),
7111 dimensions: match node.child_by_field_name("dimensions") {
7112 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
7113 child, src,
7114 )?),
7115 None => None,
7116 },
7117 name: {
7118 let child = node
7119 .child_by_field_name("name")
7120 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7121 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)?
7122 },
7123 value: match node.child_by_field_name("value") {
7124 Some(child) => Some(
7125 <VariableDeclaratorValue as ::treesitter_types::FromNode>::from_node(
7126 child, src,
7127 )?,
7128 ),
7129 None => None,
7130 },
7131 })
7132 }
7133}
7134impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
7135 fn span(&self) -> ::treesitter_types::Span {
7136 self.span
7137 }
7138}
7139#[derive(Debug, Clone)]
7140pub struct WhileStatement<'tree> {
7141 pub span: ::treesitter_types::Span,
7142 pub body: Statement<'tree>,
7143 pub condition: ParenthesizedExpression<'tree>,
7144}
7145impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
7146 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7147 fn from_node(
7148 node: ::tree_sitter::Node<'tree>,
7149 src: &'tree [u8],
7150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7151 debug_assert_eq!(node.kind(), "while_statement");
7152 Ok(Self {
7153 span: ::treesitter_types::Span::from(node),
7154 body: {
7155 let child = node
7156 .child_by_field_name("body")
7157 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7158 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
7159 },
7160 condition: {
7161 let child = node.child_by_field_name("condition").ok_or_else(|| {
7162 ::treesitter_types::ParseError::missing_field("condition", node)
7163 })?;
7164 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
7165 },
7166 })
7167 }
7168}
7169impl ::treesitter_types::Spanned for WhileStatement<'_> {
7170 fn span(&self) -> ::treesitter_types::Span {
7171 self.span
7172 }
7173}
7174#[derive(Debug, Clone)]
7175pub struct Wildcard<'tree> {
7176 pub span: ::treesitter_types::Span,
7177 pub children: ::std::vec::Vec<WildcardChildren<'tree>>,
7178}
7179impl<'tree> ::treesitter_types::FromNode<'tree> for Wildcard<'tree> {
7180 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7181 fn from_node(
7182 node: ::tree_sitter::Node<'tree>,
7183 src: &'tree [u8],
7184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7185 debug_assert_eq!(node.kind(), "wildcard");
7186 Ok(Self {
7187 span: ::treesitter_types::Span::from(node),
7188 children: {
7189 #[allow(clippy::suspicious_else_formatting)]
7190 let non_field_children = {
7191 let mut cursor = node.walk();
7192 let mut result = ::std::vec::Vec::new();
7193 if cursor.goto_first_child() {
7194 loop {
7195 if cursor.field_name().is_none()
7196 && cursor.node().is_named()
7197 && !cursor.node().is_extra()
7198 {
7199 result.push(cursor.node());
7200 }
7201 if !cursor.goto_next_sibling() {
7202 break;
7203 }
7204 }
7205 }
7206 result
7207 };
7208 let mut items = ::std::vec::Vec::new();
7209 for child in non_field_children {
7210 items.push(
7211 <WildcardChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7212 );
7213 }
7214 items
7215 },
7216 })
7217 }
7218}
7219impl ::treesitter_types::Spanned for Wildcard<'_> {
7220 fn span(&self) -> ::treesitter_types::Span {
7221 self.span
7222 }
7223}
7224#[derive(Debug, Clone)]
7225pub struct YieldStatement<'tree> {
7226 pub span: ::treesitter_types::Span,
7227 pub children: Expression<'tree>,
7228}
7229impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
7230 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7231 fn from_node(
7232 node: ::tree_sitter::Node<'tree>,
7233 src: &'tree [u8],
7234 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7235 debug_assert_eq!(node.kind(), "yield_statement");
7236 Ok(Self {
7237 span: ::treesitter_types::Span::from(node),
7238 children: {
7239 #[allow(clippy::suspicious_else_formatting)]
7240 let non_field_children = {
7241 let mut cursor = node.walk();
7242 let mut result = ::std::vec::Vec::new();
7243 if cursor.goto_first_child() {
7244 loop {
7245 if cursor.field_name().is_none()
7246 && cursor.node().is_named()
7247 && !cursor.node().is_extra()
7248 {
7249 result.push(cursor.node());
7250 }
7251 if !cursor.goto_next_sibling() {
7252 break;
7253 }
7254 }
7255 }
7256 result
7257 };
7258 let child = if let Some(&c) = non_field_children.first() {
7259 c
7260 } else {
7261 let mut fallback_cursor = node.walk();
7262 let mut fallback_child = None;
7263 if fallback_cursor.goto_first_child() {
7264 loop {
7265 if fallback_cursor.field_name().is_none()
7266 && !fallback_cursor.node().is_extra()
7267 {
7268 fallback_child = Some(fallback_cursor.node());
7269 break;
7270 }
7271 if !fallback_cursor.goto_next_sibling() {
7272 break;
7273 }
7274 }
7275 }
7276 fallback_child.ok_or_else(|| {
7277 ::treesitter_types::ParseError::missing_field("children", node)
7278 })?
7279 };
7280 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7281 },
7282 })
7283 }
7284}
7285impl ::treesitter_types::Spanned for YieldStatement<'_> {
7286 fn span(&self) -> ::treesitter_types::Span {
7287 self.span
7288 }
7289}
7290#[derive(Debug, Clone)]
7291pub struct BinaryIntegerLiteral<'tree> {
7292 pub span: ::treesitter_types::Span,
7293 text: &'tree str,
7294}
7295impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryIntegerLiteral<'tree> {
7296 fn from_node(
7297 node: ::tree_sitter::Node<'tree>,
7298 src: &'tree [u8],
7299 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7300 debug_assert_eq!(node.kind(), "binary_integer_literal");
7301 Ok(Self {
7302 span: ::treesitter_types::Span::from(node),
7303 text: node.utf8_text(src)?,
7304 })
7305 }
7306}
7307impl<'tree> ::treesitter_types::LeafNode<'tree> for BinaryIntegerLiteral<'tree> {
7308 fn text(&self) -> &'tree str {
7309 self.text
7310 }
7311}
7312impl ::treesitter_types::Spanned for BinaryIntegerLiteral<'_> {
7313 fn span(&self) -> ::treesitter_types::Span {
7314 self.span
7315 }
7316}
7317#[derive(Debug, Clone)]
7318pub struct BlockComment<'tree> {
7319 pub span: ::treesitter_types::Span,
7320 text: &'tree str,
7321}
7322impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
7323 fn from_node(
7324 node: ::tree_sitter::Node<'tree>,
7325 src: &'tree [u8],
7326 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7327 debug_assert_eq!(node.kind(), "block_comment");
7328 Ok(Self {
7329 span: ::treesitter_types::Span::from(node),
7330 text: node.utf8_text(src)?,
7331 })
7332 }
7333}
7334impl<'tree> ::treesitter_types::LeafNode<'tree> for BlockComment<'tree> {
7335 fn text(&self) -> &'tree str {
7336 self.text
7337 }
7338}
7339impl ::treesitter_types::Spanned for BlockComment<'_> {
7340 fn span(&self) -> ::treesitter_types::Span {
7341 self.span
7342 }
7343}
7344#[derive(Debug, Clone)]
7345pub struct BooleanType<'tree> {
7346 pub span: ::treesitter_types::Span,
7347 text: &'tree str,
7348}
7349impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanType<'tree> {
7350 fn from_node(
7351 node: ::tree_sitter::Node<'tree>,
7352 src: &'tree [u8],
7353 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7354 debug_assert_eq!(node.kind(), "boolean_type");
7355 Ok(Self {
7356 span: ::treesitter_types::Span::from(node),
7357 text: node.utf8_text(src)?,
7358 })
7359 }
7360}
7361impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanType<'tree> {
7362 fn text(&self) -> &'tree str {
7363 self.text
7364 }
7365}
7366impl ::treesitter_types::Spanned for BooleanType<'_> {
7367 fn span(&self) -> ::treesitter_types::Span {
7368 self.span
7369 }
7370}
7371#[derive(Debug, Clone)]
7372pub struct CharacterLiteral<'tree> {
7373 pub span: ::treesitter_types::Span,
7374 text: &'tree str,
7375}
7376impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
7377 fn from_node(
7378 node: ::tree_sitter::Node<'tree>,
7379 src: &'tree [u8],
7380 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7381 debug_assert_eq!(node.kind(), "character_literal");
7382 Ok(Self {
7383 span: ::treesitter_types::Span::from(node),
7384 text: node.utf8_text(src)?,
7385 })
7386 }
7387}
7388impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteral<'tree> {
7389 fn text(&self) -> &'tree str {
7390 self.text
7391 }
7392}
7393impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
7394 fn span(&self) -> ::treesitter_types::Span {
7395 self.span
7396 }
7397}
7398#[derive(Debug, Clone)]
7399pub struct DecimalFloatingPointLiteral<'tree> {
7400 pub span: ::treesitter_types::Span,
7401 text: &'tree str,
7402}
7403impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalFloatingPointLiteral<'tree> {
7404 fn from_node(
7405 node: ::tree_sitter::Node<'tree>,
7406 src: &'tree [u8],
7407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7408 debug_assert_eq!(node.kind(), "decimal_floating_point_literal");
7409 Ok(Self {
7410 span: ::treesitter_types::Span::from(node),
7411 text: node.utf8_text(src)?,
7412 })
7413 }
7414}
7415impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalFloatingPointLiteral<'tree> {
7416 fn text(&self) -> &'tree str {
7417 self.text
7418 }
7419}
7420impl ::treesitter_types::Spanned for DecimalFloatingPointLiteral<'_> {
7421 fn span(&self) -> ::treesitter_types::Span {
7422 self.span
7423 }
7424}
7425#[derive(Debug, Clone)]
7426pub struct DecimalIntegerLiteral<'tree> {
7427 pub span: ::treesitter_types::Span,
7428 text: &'tree str,
7429}
7430impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalIntegerLiteral<'tree> {
7431 fn from_node(
7432 node: ::tree_sitter::Node<'tree>,
7433 src: &'tree [u8],
7434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7435 debug_assert_eq!(node.kind(), "decimal_integer_literal");
7436 Ok(Self {
7437 span: ::treesitter_types::Span::from(node),
7438 text: node.utf8_text(src)?,
7439 })
7440 }
7441}
7442impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalIntegerLiteral<'tree> {
7443 fn text(&self) -> &'tree str {
7444 self.text
7445 }
7446}
7447impl ::treesitter_types::Spanned for DecimalIntegerLiteral<'_> {
7448 fn span(&self) -> ::treesitter_types::Span {
7449 self.span
7450 }
7451}
7452#[derive(Debug, Clone)]
7453pub struct EscapeSequence<'tree> {
7454 pub span: ::treesitter_types::Span,
7455 text: &'tree str,
7456}
7457impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
7458 fn from_node(
7459 node: ::tree_sitter::Node<'tree>,
7460 src: &'tree [u8],
7461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7462 debug_assert_eq!(node.kind(), "escape_sequence");
7463 Ok(Self {
7464 span: ::treesitter_types::Span::from(node),
7465 text: node.utf8_text(src)?,
7466 })
7467 }
7468}
7469impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
7470 fn text(&self) -> &'tree str {
7471 self.text
7472 }
7473}
7474impl ::treesitter_types::Spanned for EscapeSequence<'_> {
7475 fn span(&self) -> ::treesitter_types::Span {
7476 self.span
7477 }
7478}
7479#[derive(Debug, Clone)]
7480pub struct False<'tree> {
7481 pub span: ::treesitter_types::Span,
7482 text: &'tree str,
7483}
7484impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
7485 fn from_node(
7486 node: ::tree_sitter::Node<'tree>,
7487 src: &'tree [u8],
7488 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7489 debug_assert_eq!(node.kind(), "false");
7490 Ok(Self {
7491 span: ::treesitter_types::Span::from(node),
7492 text: node.utf8_text(src)?,
7493 })
7494 }
7495}
7496impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
7497 fn text(&self) -> &'tree str {
7498 self.text
7499 }
7500}
7501impl ::treesitter_types::Spanned for False<'_> {
7502 fn span(&self) -> ::treesitter_types::Span {
7503 self.span
7504 }
7505}
7506#[derive(Debug, Clone)]
7507pub struct HexFloatingPointLiteral<'tree> {
7508 pub span: ::treesitter_types::Span,
7509 text: &'tree str,
7510}
7511impl<'tree> ::treesitter_types::FromNode<'tree> for HexFloatingPointLiteral<'tree> {
7512 fn from_node(
7513 node: ::tree_sitter::Node<'tree>,
7514 src: &'tree [u8],
7515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7516 debug_assert_eq!(node.kind(), "hex_floating_point_literal");
7517 Ok(Self {
7518 span: ::treesitter_types::Span::from(node),
7519 text: node.utf8_text(src)?,
7520 })
7521 }
7522}
7523impl<'tree> ::treesitter_types::LeafNode<'tree> for HexFloatingPointLiteral<'tree> {
7524 fn text(&self) -> &'tree str {
7525 self.text
7526 }
7527}
7528impl ::treesitter_types::Spanned for HexFloatingPointLiteral<'_> {
7529 fn span(&self) -> ::treesitter_types::Span {
7530 self.span
7531 }
7532}
7533#[derive(Debug, Clone)]
7534pub struct HexIntegerLiteral<'tree> {
7535 pub span: ::treesitter_types::Span,
7536 text: &'tree str,
7537}
7538impl<'tree> ::treesitter_types::FromNode<'tree> for HexIntegerLiteral<'tree> {
7539 fn from_node(
7540 node: ::tree_sitter::Node<'tree>,
7541 src: &'tree [u8],
7542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7543 debug_assert_eq!(node.kind(), "hex_integer_literal");
7544 Ok(Self {
7545 span: ::treesitter_types::Span::from(node),
7546 text: node.utf8_text(src)?,
7547 })
7548 }
7549}
7550impl<'tree> ::treesitter_types::LeafNode<'tree> for HexIntegerLiteral<'tree> {
7551 fn text(&self) -> &'tree str {
7552 self.text
7553 }
7554}
7555impl ::treesitter_types::Spanned for HexIntegerLiteral<'_> {
7556 fn span(&self) -> ::treesitter_types::Span {
7557 self.span
7558 }
7559}
7560#[derive(Debug, Clone)]
7561pub struct Identifier<'tree> {
7562 pub span: ::treesitter_types::Span,
7563 text: &'tree str,
7564}
7565impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
7566 fn from_node(
7567 node: ::tree_sitter::Node<'tree>,
7568 src: &'tree [u8],
7569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7570 debug_assert_eq!(node.kind(), "identifier");
7571 Ok(Self {
7572 span: ::treesitter_types::Span::from(node),
7573 text: node.utf8_text(src)?,
7574 })
7575 }
7576}
7577impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
7578 fn text(&self) -> &'tree str {
7579 self.text
7580 }
7581}
7582impl ::treesitter_types::Spanned for Identifier<'_> {
7583 fn span(&self) -> ::treesitter_types::Span {
7584 self.span
7585 }
7586}
7587#[derive(Debug, Clone)]
7588pub struct LineComment<'tree> {
7589 pub span: ::treesitter_types::Span,
7590 text: &'tree str,
7591}
7592impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
7593 fn from_node(
7594 node: ::tree_sitter::Node<'tree>,
7595 src: &'tree [u8],
7596 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7597 debug_assert_eq!(node.kind(), "line_comment");
7598 Ok(Self {
7599 span: ::treesitter_types::Span::from(node),
7600 text: node.utf8_text(src)?,
7601 })
7602 }
7603}
7604impl<'tree> ::treesitter_types::LeafNode<'tree> for LineComment<'tree> {
7605 fn text(&self) -> &'tree str {
7606 self.text
7607 }
7608}
7609impl ::treesitter_types::Spanned for LineComment<'_> {
7610 fn span(&self) -> ::treesitter_types::Span {
7611 self.span
7612 }
7613}
7614#[derive(Debug, Clone)]
7615pub struct NullLiteral<'tree> {
7616 pub span: ::treesitter_types::Span,
7617 text: &'tree str,
7618}
7619impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
7620 fn from_node(
7621 node: ::tree_sitter::Node<'tree>,
7622 src: &'tree [u8],
7623 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7624 debug_assert_eq!(node.kind(), "null_literal");
7625 Ok(Self {
7626 span: ::treesitter_types::Span::from(node),
7627 text: node.utf8_text(src)?,
7628 })
7629 }
7630}
7631impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
7632 fn text(&self) -> &'tree str {
7633 self.text
7634 }
7635}
7636impl ::treesitter_types::Spanned for NullLiteral<'_> {
7637 fn span(&self) -> ::treesitter_types::Span {
7638 self.span
7639 }
7640}
7641#[derive(Debug, Clone)]
7642pub struct OctalIntegerLiteral<'tree> {
7643 pub span: ::treesitter_types::Span,
7644 text: &'tree str,
7645}
7646impl<'tree> ::treesitter_types::FromNode<'tree> for OctalIntegerLiteral<'tree> {
7647 fn from_node(
7648 node: ::tree_sitter::Node<'tree>,
7649 src: &'tree [u8],
7650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7651 debug_assert_eq!(node.kind(), "octal_integer_literal");
7652 Ok(Self {
7653 span: ::treesitter_types::Span::from(node),
7654 text: node.utf8_text(src)?,
7655 })
7656 }
7657}
7658impl<'tree> ::treesitter_types::LeafNode<'tree> for OctalIntegerLiteral<'tree> {
7659 fn text(&self) -> &'tree str {
7660 self.text
7661 }
7662}
7663impl ::treesitter_types::Spanned for OctalIntegerLiteral<'_> {
7664 fn span(&self) -> ::treesitter_types::Span {
7665 self.span
7666 }
7667}
7668#[derive(Debug, Clone)]
7669pub struct StringFragment<'tree> {
7670 pub span: ::treesitter_types::Span,
7671 text: &'tree str,
7672}
7673impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
7674 fn from_node(
7675 node: ::tree_sitter::Node<'tree>,
7676 src: &'tree [u8],
7677 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7678 debug_assert_eq!(node.kind(), "string_fragment");
7679 Ok(Self {
7680 span: ::treesitter_types::Span::from(node),
7681 text: node.utf8_text(src)?,
7682 })
7683 }
7684}
7685impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
7686 fn text(&self) -> &'tree str {
7687 self.text
7688 }
7689}
7690impl ::treesitter_types::Spanned for StringFragment<'_> {
7691 fn span(&self) -> ::treesitter_types::Span {
7692 self.span
7693 }
7694}
7695#[derive(Debug, Clone)]
7696pub struct Super<'tree> {
7697 pub span: ::treesitter_types::Span,
7698 text: &'tree str,
7699}
7700impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
7701 fn from_node(
7702 node: ::tree_sitter::Node<'tree>,
7703 src: &'tree [u8],
7704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7705 debug_assert_eq!(node.kind(), "super");
7706 Ok(Self {
7707 span: ::treesitter_types::Span::from(node),
7708 text: node.utf8_text(src)?,
7709 })
7710 }
7711}
7712impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
7713 fn text(&self) -> &'tree str {
7714 self.text
7715 }
7716}
7717impl ::treesitter_types::Spanned for Super<'_> {
7718 fn span(&self) -> ::treesitter_types::Span {
7719 self.span
7720 }
7721}
7722#[derive(Debug, Clone)]
7723pub struct This<'tree> {
7724 pub span: ::treesitter_types::Span,
7725 text: &'tree str,
7726}
7727impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
7728 fn from_node(
7729 node: ::tree_sitter::Node<'tree>,
7730 src: &'tree [u8],
7731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7732 debug_assert_eq!(node.kind(), "this");
7733 Ok(Self {
7734 span: ::treesitter_types::Span::from(node),
7735 text: node.utf8_text(src)?,
7736 })
7737 }
7738}
7739impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
7740 fn text(&self) -> &'tree str {
7741 self.text
7742 }
7743}
7744impl ::treesitter_types::Spanned for This<'_> {
7745 fn span(&self) -> ::treesitter_types::Span {
7746 self.span
7747 }
7748}
7749#[derive(Debug, Clone)]
7750pub struct True<'tree> {
7751 pub span: ::treesitter_types::Span,
7752 text: &'tree str,
7753}
7754impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
7755 fn from_node(
7756 node: ::tree_sitter::Node<'tree>,
7757 src: &'tree [u8],
7758 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7759 debug_assert_eq!(node.kind(), "true");
7760 Ok(Self {
7761 span: ::treesitter_types::Span::from(node),
7762 text: node.utf8_text(src)?,
7763 })
7764 }
7765}
7766impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
7767 fn text(&self) -> &'tree str {
7768 self.text
7769 }
7770}
7771impl ::treesitter_types::Spanned for True<'_> {
7772 fn span(&self) -> ::treesitter_types::Span {
7773 self.span
7774 }
7775}
7776#[derive(Debug, Clone)]
7777pub struct TypeIdentifier<'tree> {
7778 pub span: ::treesitter_types::Span,
7779 text: &'tree str,
7780}
7781impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
7782 fn from_node(
7783 node: ::tree_sitter::Node<'tree>,
7784 src: &'tree [u8],
7785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7786 debug_assert_eq!(node.kind(), "type_identifier");
7787 Ok(Self {
7788 span: ::treesitter_types::Span::from(node),
7789 text: node.utf8_text(src)?,
7790 })
7791 }
7792}
7793impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
7794 fn text(&self) -> &'tree str {
7795 self.text
7796 }
7797}
7798impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
7799 fn span(&self) -> ::treesitter_types::Span {
7800 self.span
7801 }
7802}
7803#[derive(Debug, Clone)]
7804pub struct UnderscorePattern<'tree> {
7805 pub span: ::treesitter_types::Span,
7806 text: &'tree str,
7807}
7808impl<'tree> ::treesitter_types::FromNode<'tree> for UnderscorePattern<'tree> {
7809 fn from_node(
7810 node: ::tree_sitter::Node<'tree>,
7811 src: &'tree [u8],
7812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7813 debug_assert_eq!(node.kind(), "underscore_pattern");
7814 Ok(Self {
7815 span: ::treesitter_types::Span::from(node),
7816 text: node.utf8_text(src)?,
7817 })
7818 }
7819}
7820impl<'tree> ::treesitter_types::LeafNode<'tree> for UnderscorePattern<'tree> {
7821 fn text(&self) -> &'tree str {
7822 self.text
7823 }
7824}
7825impl ::treesitter_types::Spanned for UnderscorePattern<'_> {
7826 fn span(&self) -> ::treesitter_types::Span {
7827 self.span
7828 }
7829}
7830#[derive(Debug, Clone)]
7831pub struct VoidType<'tree> {
7832 pub span: ::treesitter_types::Span,
7833 text: &'tree str,
7834}
7835impl<'tree> ::treesitter_types::FromNode<'tree> for VoidType<'tree> {
7836 fn from_node(
7837 node: ::tree_sitter::Node<'tree>,
7838 src: &'tree [u8],
7839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7840 debug_assert_eq!(node.kind(), "void_type");
7841 Ok(Self {
7842 span: ::treesitter_types::Span::from(node),
7843 text: node.utf8_text(src)?,
7844 })
7845 }
7846}
7847impl<'tree> ::treesitter_types::LeafNode<'tree> for VoidType<'tree> {
7848 fn text(&self) -> &'tree str {
7849 self.text
7850 }
7851}
7852impl ::treesitter_types::Spanned for VoidType<'_> {
7853 fn span(&self) -> ::treesitter_types::Span {
7854 self.span
7855 }
7856}
7857#[derive(Debug, Clone)]
7858pub enum AnnotatedTypeChildren<'tree> {
7859 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
7860 Annotation(::std::boxed::Box<Annotation<'tree>>),
7861 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
7862}
7863impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotatedTypeChildren<'tree> {
7864 #[allow(clippy::collapsible_else_if)]
7865 fn from_node(
7866 node: ::tree_sitter::Node<'tree>,
7867 src: &'tree [u8],
7868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7869 match node.kind() {
7870 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
7871 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
7872 ))),
7873 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
7874 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
7875 ))),
7876 _other => {
7877 if let Ok(v) =
7878 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
7879 {
7880 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
7881 } else {
7882 Err(::treesitter_types::ParseError::unexpected_kind(
7883 _other, node,
7884 ))
7885 }
7886 }
7887 }
7888 }
7889}
7890impl ::treesitter_types::Spanned for AnnotatedTypeChildren<'_> {
7891 fn span(&self) -> ::treesitter_types::Span {
7892 match self {
7893 Self::UnannotatedType(inner) => inner.span(),
7894 Self::Annotation(inner) => inner.span(),
7895 Self::MarkerAnnotation(inner) => inner.span(),
7896 }
7897 }
7898}
7899#[derive(Debug, Clone)]
7900pub enum AnnotationName<'tree> {
7901 Identifier(::std::boxed::Box<Identifier<'tree>>),
7902 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
7903}
7904impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationName<'tree> {
7905 #[allow(clippy::collapsible_else_if)]
7906 fn from_node(
7907 node: ::tree_sitter::Node<'tree>,
7908 src: &'tree [u8],
7909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7910 match node.kind() {
7911 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7912 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7913 ))),
7914 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
7915 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7916 ))),
7917 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7918 }
7919 }
7920}
7921impl ::treesitter_types::Spanned for AnnotationName<'_> {
7922 fn span(&self) -> ::treesitter_types::Span {
7923 match self {
7924 Self::Identifier(inner) => inner.span(),
7925 Self::ScopedIdentifier(inner) => inner.span(),
7926 }
7927 }
7928}
7929#[derive(Debug, Clone)]
7930pub enum AnnotationArgumentListChildren<'tree> {
7931 Annotation(::std::boxed::Box<Annotation<'tree>>),
7932 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
7933 ElementValuePair(::std::boxed::Box<ElementValuePair<'tree>>),
7934 Expression(::std::boxed::Box<Expression<'tree>>),
7935 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
7936}
7937impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationArgumentListChildren<'tree> {
7938 #[allow(clippy::collapsible_else_if)]
7939 fn from_node(
7940 node: ::tree_sitter::Node<'tree>,
7941 src: &'tree [u8],
7942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7943 match node.kind() {
7944 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
7945 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
7946 ))),
7947 "element_value_array_initializer" => {
7948 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
7949 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
7950 node, src,
7951 )?,
7952 )))
7953 }
7954 "element_value_pair" => Ok(Self::ElementValuePair(::std::boxed::Box::new(
7955 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)?,
7956 ))),
7957 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
7958 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
7959 ))),
7960 _other => {
7961 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7962 Ok(Self::Expression(::std::boxed::Box::new(v)))
7963 } else {
7964 Err(::treesitter_types::ParseError::unexpected_kind(
7965 _other, node,
7966 ))
7967 }
7968 }
7969 }
7970 }
7971}
7972impl ::treesitter_types::Spanned for AnnotationArgumentListChildren<'_> {
7973 fn span(&self) -> ::treesitter_types::Span {
7974 match self {
7975 Self::Annotation(inner) => inner.span(),
7976 Self::ElementValueArrayInitializer(inner) => inner.span(),
7977 Self::ElementValuePair(inner) => inner.span(),
7978 Self::Expression(inner) => inner.span(),
7979 Self::MarkerAnnotation(inner) => inner.span(),
7980 }
7981 }
7982}
7983#[derive(Debug, Clone)]
7984pub enum AnnotationTypeBodyChildren<'tree> {
7985 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
7986 AnnotationTypeElementDeclaration(::std::boxed::Box<AnnotationTypeElementDeclaration<'tree>>),
7987 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
7988 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
7989 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
7990 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
7991}
7992impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeBodyChildren<'tree> {
7993 #[allow(clippy::collapsible_else_if)]
7994 fn from_node(
7995 node: ::tree_sitter::Node<'tree>,
7996 src: &'tree [u8],
7997 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7998 match node.kind() {
7999 "annotation_type_declaration" => {
8000 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
8001 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
8002 node, src,
8003 )?,
8004 )))
8005 }
8006 "annotation_type_element_declaration" => Ok(Self::AnnotationTypeElementDeclaration(
8007 ::std::boxed::Box::new(
8008 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
8009 node, src,
8010 )?,
8011 ),
8012 )),
8013 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
8014 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8015 ))),
8016 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
8017 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8018 ))),
8019 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
8020 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8021 ))),
8022 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
8023 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8024 ))),
8025 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8026 }
8027 }
8028}
8029impl ::treesitter_types::Spanned for AnnotationTypeBodyChildren<'_> {
8030 fn span(&self) -> ::treesitter_types::Span {
8031 match self {
8032 Self::AnnotationTypeDeclaration(inner) => inner.span(),
8033 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
8034 Self::ClassDeclaration(inner) => inner.span(),
8035 Self::ConstantDeclaration(inner) => inner.span(),
8036 Self::EnumDeclaration(inner) => inner.span(),
8037 Self::InterfaceDeclaration(inner) => inner.span(),
8038 }
8039 }
8040}
8041#[derive(Debug, Clone)]
8042pub enum AnnotationTypeElementDeclarationValue<'tree> {
8043 Annotation(::std::boxed::Box<Annotation<'tree>>),
8044 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
8045 Expression(::std::boxed::Box<Expression<'tree>>),
8046 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8047}
8048impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeElementDeclarationValue<'tree> {
8049 #[allow(clippy::collapsible_else_if)]
8050 fn from_node(
8051 node: ::tree_sitter::Node<'tree>,
8052 src: &'tree [u8],
8053 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8054 match node.kind() {
8055 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8056 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8057 ))),
8058 "element_value_array_initializer" => {
8059 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
8060 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
8061 node, src,
8062 )?,
8063 )))
8064 }
8065 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8066 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8067 ))),
8068 _other => {
8069 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8070 Ok(Self::Expression(::std::boxed::Box::new(v)))
8071 } else {
8072 Err(::treesitter_types::ParseError::unexpected_kind(
8073 _other, node,
8074 ))
8075 }
8076 }
8077 }
8078 }
8079}
8080impl ::treesitter_types::Spanned for AnnotationTypeElementDeclarationValue<'_> {
8081 fn span(&self) -> ::treesitter_types::Span {
8082 match self {
8083 Self::Annotation(inner) => inner.span(),
8084 Self::ElementValueArrayInitializer(inner) => inner.span(),
8085 Self::Expression(inner) => inner.span(),
8086 Self::MarkerAnnotation(inner) => inner.span(),
8087 }
8088 }
8089}
8090#[derive(Debug, Clone)]
8091pub enum ArrayCreationExpressionDimensions<'tree> {
8092 Dimensions(::std::boxed::Box<Dimensions<'tree>>),
8093 DimensionsExpr(::std::boxed::Box<DimensionsExpr<'tree>>),
8094}
8095impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionDimensions<'tree> {
8096 #[allow(clippy::collapsible_else_if)]
8097 fn from_node(
8098 node: ::tree_sitter::Node<'tree>,
8099 src: &'tree [u8],
8100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8101 match node.kind() {
8102 "dimensions" => Ok(Self::Dimensions(::std::boxed::Box::new(
8103 <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)?,
8104 ))),
8105 "dimensions_expr" => Ok(Self::DimensionsExpr(::std::boxed::Box::new(
8106 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)?,
8107 ))),
8108 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8109 }
8110 }
8111}
8112impl ::treesitter_types::Spanned for ArrayCreationExpressionDimensions<'_> {
8113 fn span(&self) -> ::treesitter_types::Span {
8114 match self {
8115 Self::Dimensions(inner) => inner.span(),
8116 Self::DimensionsExpr(inner) => inner.span(),
8117 }
8118 }
8119}
8120#[derive(Debug, Clone)]
8121pub enum ArrayCreationExpressionChildren<'tree> {
8122 Annotation(::std::boxed::Box<Annotation<'tree>>),
8123 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8124}
8125impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionChildren<'tree> {
8126 #[allow(clippy::collapsible_else_if)]
8127 fn from_node(
8128 node: ::tree_sitter::Node<'tree>,
8129 src: &'tree [u8],
8130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8131 match node.kind() {
8132 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8133 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8134 ))),
8135 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8136 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8137 ))),
8138 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8139 }
8140 }
8141}
8142impl ::treesitter_types::Spanned for ArrayCreationExpressionChildren<'_> {
8143 fn span(&self) -> ::treesitter_types::Span {
8144 match self {
8145 Self::Annotation(inner) => inner.span(),
8146 Self::MarkerAnnotation(inner) => inner.span(),
8147 }
8148 }
8149}
8150#[derive(Debug, Clone)]
8151pub enum ArrayInitializerChildren<'tree> {
8152 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
8153 Expression(::std::boxed::Box<Expression<'tree>>),
8154}
8155impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayInitializerChildren<'tree> {
8156 #[allow(clippy::collapsible_else_if)]
8157 fn from_node(
8158 node: ::tree_sitter::Node<'tree>,
8159 src: &'tree [u8],
8160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8161 match node.kind() {
8162 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
8163 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
8164 ))),
8165 _other => {
8166 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8167 Ok(Self::Expression(::std::boxed::Box::new(v)))
8168 } else {
8169 Err(::treesitter_types::ParseError::unexpected_kind(
8170 _other, node,
8171 ))
8172 }
8173 }
8174 }
8175 }
8176}
8177impl ::treesitter_types::Spanned for ArrayInitializerChildren<'_> {
8178 fn span(&self) -> ::treesitter_types::Span {
8179 match self {
8180 Self::ArrayInitializer(inner) => inner.span(),
8181 Self::Expression(inner) => inner.span(),
8182 }
8183 }
8184}
8185#[derive(Debug, Clone)]
8186pub enum AssignmentExpressionLeft<'tree> {
8187 ArrayAccess(::std::boxed::Box<ArrayAccess<'tree>>),
8188 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
8189 Identifier(::std::boxed::Box<Identifier<'tree>>),
8190}
8191impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
8192 #[allow(clippy::collapsible_else_if)]
8193 fn from_node(
8194 node: ::tree_sitter::Node<'tree>,
8195 src: &'tree [u8],
8196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8197 match node.kind() {
8198 "array_access" => Ok(Self::ArrayAccess(::std::boxed::Box::new(
8199 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
8200 ))),
8201 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
8202 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
8203 ))),
8204 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8205 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8206 ))),
8207 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8208 }
8209 }
8210}
8211impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
8212 fn span(&self) -> ::treesitter_types::Span {
8213 match self {
8214 Self::ArrayAccess(inner) => inner.span(),
8215 Self::FieldAccess(inner) => inner.span(),
8216 Self::Identifier(inner) => inner.span(),
8217 }
8218 }
8219}
8220#[derive(Debug, Clone)]
8221pub enum AssignmentExpressionOperator {
8222 PercentEq(::treesitter_types::Span),
8223 AmpEq(::treesitter_types::Span),
8224 StarEq(::treesitter_types::Span),
8225 PlusEq(::treesitter_types::Span),
8226 MinusEq(::treesitter_types::Span),
8227 SlashEq(::treesitter_types::Span),
8228 ShlEq(::treesitter_types::Span),
8229 Eq(::treesitter_types::Span),
8230 ShrEq(::treesitter_types::Span),
8231 GtGtGtEq(::treesitter_types::Span),
8232 CaretEq(::treesitter_types::Span),
8233 PipeEq(::treesitter_types::Span),
8234}
8235impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
8236 #[allow(clippy::collapsible_else_if)]
8237 fn from_node(
8238 node: ::tree_sitter::Node<'tree>,
8239 _src: &'tree [u8],
8240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8241 match node.kind() {
8242 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
8243 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
8244 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
8245 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
8246 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
8247 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
8248 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
8249 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
8250 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
8251 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
8252 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
8253 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
8254 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8255 }
8256 }
8257}
8258impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
8259 fn span(&self) -> ::treesitter_types::Span {
8260 match self {
8261 Self::PercentEq(span) => *span,
8262 Self::AmpEq(span) => *span,
8263 Self::StarEq(span) => *span,
8264 Self::PlusEq(span) => *span,
8265 Self::MinusEq(span) => *span,
8266 Self::SlashEq(span) => *span,
8267 Self::ShlEq(span) => *span,
8268 Self::Eq(span) => *span,
8269 Self::ShrEq(span) => *span,
8270 Self::GtGtGtEq(span) => *span,
8271 Self::CaretEq(span) => *span,
8272 Self::PipeEq(span) => *span,
8273 }
8274 }
8275}
8276#[derive(Debug, Clone)]
8277pub enum BinaryExpressionOperator {
8278 NotEq(::treesitter_types::Span),
8279 Percent(::treesitter_types::Span),
8280 Amp(::treesitter_types::Span),
8281 AmpAmp(::treesitter_types::Span),
8282 Star(::treesitter_types::Span),
8283 Plus(::treesitter_types::Span),
8284 Minus(::treesitter_types::Span),
8285 Slash(::treesitter_types::Span),
8286 Lt(::treesitter_types::Span),
8287 Shl(::treesitter_types::Span),
8288 LtEq(::treesitter_types::Span),
8289 EqEq(::treesitter_types::Span),
8290 Gt(::treesitter_types::Span),
8291 GtEq(::treesitter_types::Span),
8292 Shr(::treesitter_types::Span),
8293 GtGtGt(::treesitter_types::Span),
8294 Caret(::treesitter_types::Span),
8295 Pipe(::treesitter_types::Span),
8296 PipePipe(::treesitter_types::Span),
8297}
8298impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
8299 #[allow(clippy::collapsible_else_if)]
8300 fn from_node(
8301 node: ::tree_sitter::Node<'tree>,
8302 _src: &'tree [u8],
8303 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8304 match node.kind() {
8305 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
8306 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
8307 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
8308 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
8309 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
8310 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
8311 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
8312 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
8313 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
8314 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
8315 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
8316 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
8317 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
8318 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
8319 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
8320 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
8321 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
8322 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
8323 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
8324 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8325 }
8326 }
8327}
8328impl ::treesitter_types::Spanned for BinaryExpressionOperator {
8329 fn span(&self) -> ::treesitter_types::Span {
8330 match self {
8331 Self::NotEq(span) => *span,
8332 Self::Percent(span) => *span,
8333 Self::Amp(span) => *span,
8334 Self::AmpAmp(span) => *span,
8335 Self::Star(span) => *span,
8336 Self::Plus(span) => *span,
8337 Self::Minus(span) => *span,
8338 Self::Slash(span) => *span,
8339 Self::Lt(span) => *span,
8340 Self::Shl(span) => *span,
8341 Self::LtEq(span) => *span,
8342 Self::EqEq(span) => *span,
8343 Self::Gt(span) => *span,
8344 Self::GtEq(span) => *span,
8345 Self::Shr(span) => *span,
8346 Self::GtGtGt(span) => *span,
8347 Self::Caret(span) => *span,
8348 Self::Pipe(span) => *span,
8349 Self::PipePipe(span) => *span,
8350 }
8351 }
8352}
8353#[derive(Debug, Clone)]
8354pub enum CatchFormalParameterName<'tree> {
8355 Identifier(::std::boxed::Box<Identifier<'tree>>),
8356 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
8357}
8358impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterName<'tree> {
8359 #[allow(clippy::collapsible_else_if)]
8360 fn from_node(
8361 node: ::tree_sitter::Node<'tree>,
8362 src: &'tree [u8],
8363 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8364 match node.kind() {
8365 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8366 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8367 ))),
8368 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
8369 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8370 ))),
8371 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8372 }
8373 }
8374}
8375impl ::treesitter_types::Spanned for CatchFormalParameterName<'_> {
8376 fn span(&self) -> ::treesitter_types::Span {
8377 match self {
8378 Self::Identifier(inner) => inner.span(),
8379 Self::UnderscorePattern(inner) => inner.span(),
8380 }
8381 }
8382}
8383#[derive(Debug, Clone)]
8384pub enum CatchFormalParameterChildren<'tree> {
8385 CatchType(::std::boxed::Box<CatchType<'tree>>),
8386 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
8387}
8388impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterChildren<'tree> {
8389 #[allow(clippy::collapsible_else_if)]
8390 fn from_node(
8391 node: ::tree_sitter::Node<'tree>,
8392 src: &'tree [u8],
8393 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8394 match node.kind() {
8395 "catch_type" => Ok(Self::CatchType(::std::boxed::Box::new(
8396 <CatchType as ::treesitter_types::FromNode>::from_node(node, src)?,
8397 ))),
8398 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
8399 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
8400 ))),
8401 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8402 }
8403 }
8404}
8405impl ::treesitter_types::Spanned for CatchFormalParameterChildren<'_> {
8406 fn span(&self) -> ::treesitter_types::Span {
8407 match self {
8408 Self::CatchType(inner) => inner.span(),
8409 Self::Modifiers(inner) => inner.span(),
8410 }
8411 }
8412}
8413#[derive(Debug, Clone)]
8414pub enum ClassBodyChildren<'tree> {
8415 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
8416 Block(::std::boxed::Box<Block<'tree>>),
8417 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
8418 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
8419 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
8420 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
8421 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
8422 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
8423 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
8424 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
8425 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
8426}
8427impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyChildren<'tree> {
8428 #[allow(clippy::collapsible_else_if)]
8429 fn from_node(
8430 node: ::tree_sitter::Node<'tree>,
8431 src: &'tree [u8],
8432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8433 match node.kind() {
8434 "annotation_type_declaration" => {
8435 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
8436 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
8437 node, src,
8438 )?,
8439 )))
8440 }
8441 "block" => Ok(Self::Block(::std::boxed::Box::new(
8442 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
8443 ))),
8444 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
8445 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8446 ))),
8447 "compact_constructor_declaration" => {
8448 Ok(Self::CompactConstructorDeclaration(::std::boxed::Box::new(
8449 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
8450 node, src,
8451 )?,
8452 )))
8453 }
8454 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
8455 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8456 ))),
8457 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
8458 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8459 ))),
8460 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
8461 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8462 ))),
8463 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
8464 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8465 ))),
8466 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
8467 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8468 ))),
8469 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
8470 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8471 ))),
8472 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
8473 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
8474 ))),
8475 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8476 }
8477 }
8478}
8479impl ::treesitter_types::Spanned for ClassBodyChildren<'_> {
8480 fn span(&self) -> ::treesitter_types::Span {
8481 match self {
8482 Self::AnnotationTypeDeclaration(inner) => inner.span(),
8483 Self::Block(inner) => inner.span(),
8484 Self::ClassDeclaration(inner) => inner.span(),
8485 Self::CompactConstructorDeclaration(inner) => inner.span(),
8486 Self::ConstructorDeclaration(inner) => inner.span(),
8487 Self::EnumDeclaration(inner) => inner.span(),
8488 Self::FieldDeclaration(inner) => inner.span(),
8489 Self::InterfaceDeclaration(inner) => inner.span(),
8490 Self::MethodDeclaration(inner) => inner.span(),
8491 Self::RecordDeclaration(inner) => inner.span(),
8492 Self::StaticInitializer(inner) => inner.span(),
8493 }
8494 }
8495}
8496#[derive(Debug, Clone)]
8497pub enum ConstructorBodyChildren<'tree> {
8498 ExplicitConstructorInvocation(::std::boxed::Box<ExplicitConstructorInvocation<'tree>>),
8499 Statement(::std::boxed::Box<Statement<'tree>>),
8500}
8501impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBodyChildren<'tree> {
8502 #[allow(clippy::collapsible_else_if)]
8503 fn from_node(
8504 node: ::tree_sitter::Node<'tree>,
8505 src: &'tree [u8],
8506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8507 match node.kind() {
8508 "explicit_constructor_invocation" => {
8509 Ok(Self::ExplicitConstructorInvocation(::std::boxed::Box::new(
8510 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
8511 node, src,
8512 )?,
8513 )))
8514 }
8515 _other => {
8516 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8517 Ok(Self::Statement(::std::boxed::Box::new(v)))
8518 } else {
8519 Err(::treesitter_types::ParseError::unexpected_kind(
8520 _other, node,
8521 ))
8522 }
8523 }
8524 }
8525 }
8526}
8527impl ::treesitter_types::Spanned for ConstructorBodyChildren<'_> {
8528 fn span(&self) -> ::treesitter_types::Span {
8529 match self {
8530 Self::ExplicitConstructorInvocation(inner) => inner.span(),
8531 Self::Statement(inner) => inner.span(),
8532 }
8533 }
8534}
8535#[derive(Debug, Clone)]
8536pub enum ConstructorDeclarationChildren<'tree> {
8537 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
8538 Throws(::std::boxed::Box<Throws<'tree>>),
8539}
8540impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
8541 #[allow(clippy::collapsible_else_if)]
8542 fn from_node(
8543 node: ::tree_sitter::Node<'tree>,
8544 src: &'tree [u8],
8545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8546 match node.kind() {
8547 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
8548 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
8549 ))),
8550 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
8551 <Throws as ::treesitter_types::FromNode>::from_node(node, src)?,
8552 ))),
8553 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8554 }
8555 }
8556}
8557impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
8558 fn span(&self) -> ::treesitter_types::Span {
8559 match self {
8560 Self::Modifiers(inner) => inner.span(),
8561 Self::Throws(inner) => inner.span(),
8562 }
8563 }
8564}
8565#[derive(Debug, Clone)]
8566pub enum DimensionsChildren<'tree> {
8567 Annotation(::std::boxed::Box<Annotation<'tree>>),
8568 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8569}
8570impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsChildren<'tree> {
8571 #[allow(clippy::collapsible_else_if)]
8572 fn from_node(
8573 node: ::tree_sitter::Node<'tree>,
8574 src: &'tree [u8],
8575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8576 match node.kind() {
8577 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8578 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8579 ))),
8580 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8581 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8582 ))),
8583 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8584 }
8585 }
8586}
8587impl ::treesitter_types::Spanned for DimensionsChildren<'_> {
8588 fn span(&self) -> ::treesitter_types::Span {
8589 match self {
8590 Self::Annotation(inner) => inner.span(),
8591 Self::MarkerAnnotation(inner) => inner.span(),
8592 }
8593 }
8594}
8595#[derive(Debug, Clone)]
8596pub enum DimensionsExprChildren<'tree> {
8597 Annotation(::std::boxed::Box<Annotation<'tree>>),
8598 Expression(::std::boxed::Box<Expression<'tree>>),
8599 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8600}
8601impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExprChildren<'tree> {
8602 #[allow(clippy::collapsible_else_if)]
8603 fn from_node(
8604 node: ::tree_sitter::Node<'tree>,
8605 src: &'tree [u8],
8606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8607 match node.kind() {
8608 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8609 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8610 ))),
8611 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8612 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8613 ))),
8614 _other => {
8615 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8616 Ok(Self::Expression(::std::boxed::Box::new(v)))
8617 } else {
8618 Err(::treesitter_types::ParseError::unexpected_kind(
8619 _other, node,
8620 ))
8621 }
8622 }
8623 }
8624 }
8625}
8626impl ::treesitter_types::Spanned for DimensionsExprChildren<'_> {
8627 fn span(&self) -> ::treesitter_types::Span {
8628 match self {
8629 Self::Annotation(inner) => inner.span(),
8630 Self::Expression(inner) => inner.span(),
8631 Self::MarkerAnnotation(inner) => inner.span(),
8632 }
8633 }
8634}
8635#[derive(Debug, Clone)]
8636pub enum ElementValueArrayInitializerChildren<'tree> {
8637 Annotation(::std::boxed::Box<Annotation<'tree>>),
8638 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
8639 Expression(::std::boxed::Box<Expression<'tree>>),
8640 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8641}
8642impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializerChildren<'tree> {
8643 #[allow(clippy::collapsible_else_if)]
8644 fn from_node(
8645 node: ::tree_sitter::Node<'tree>,
8646 src: &'tree [u8],
8647 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8648 match node.kind() {
8649 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8650 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8651 ))),
8652 "element_value_array_initializer" => {
8653 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
8654 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
8655 node, src,
8656 )?,
8657 )))
8658 }
8659 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8660 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8661 ))),
8662 _other => {
8663 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8664 Ok(Self::Expression(::std::boxed::Box::new(v)))
8665 } else {
8666 Err(::treesitter_types::ParseError::unexpected_kind(
8667 _other, node,
8668 ))
8669 }
8670 }
8671 }
8672 }
8673}
8674impl ::treesitter_types::Spanned for ElementValueArrayInitializerChildren<'_> {
8675 fn span(&self) -> ::treesitter_types::Span {
8676 match self {
8677 Self::Annotation(inner) => inner.span(),
8678 Self::ElementValueArrayInitializer(inner) => inner.span(),
8679 Self::Expression(inner) => inner.span(),
8680 Self::MarkerAnnotation(inner) => inner.span(),
8681 }
8682 }
8683}
8684#[derive(Debug, Clone)]
8685pub enum ElementValuePairValue<'tree> {
8686 Annotation(::std::boxed::Box<Annotation<'tree>>),
8687 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
8688 Expression(::std::boxed::Box<Expression<'tree>>),
8689 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8690}
8691impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePairValue<'tree> {
8692 #[allow(clippy::collapsible_else_if)]
8693 fn from_node(
8694 node: ::tree_sitter::Node<'tree>,
8695 src: &'tree [u8],
8696 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8697 match node.kind() {
8698 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8699 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8700 ))),
8701 "element_value_array_initializer" => {
8702 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
8703 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
8704 node, src,
8705 )?,
8706 )))
8707 }
8708 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8709 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8710 ))),
8711 _other => {
8712 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8713 Ok(Self::Expression(::std::boxed::Box::new(v)))
8714 } else {
8715 Err(::treesitter_types::ParseError::unexpected_kind(
8716 _other, node,
8717 ))
8718 }
8719 }
8720 }
8721 }
8722}
8723impl ::treesitter_types::Spanned for ElementValuePairValue<'_> {
8724 fn span(&self) -> ::treesitter_types::Span {
8725 match self {
8726 Self::Annotation(inner) => inner.span(),
8727 Self::ElementValueArrayInitializer(inner) => inner.span(),
8728 Self::Expression(inner) => inner.span(),
8729 Self::MarkerAnnotation(inner) => inner.span(),
8730 }
8731 }
8732}
8733#[derive(Debug, Clone)]
8734pub enum EnhancedForStatementName<'tree> {
8735 Identifier(::std::boxed::Box<Identifier<'tree>>),
8736 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
8737}
8738impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatementName<'tree> {
8739 #[allow(clippy::collapsible_else_if)]
8740 fn from_node(
8741 node: ::tree_sitter::Node<'tree>,
8742 src: &'tree [u8],
8743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8744 match node.kind() {
8745 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8746 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8747 ))),
8748 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
8749 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8750 ))),
8751 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8752 }
8753 }
8754}
8755impl ::treesitter_types::Spanned for EnhancedForStatementName<'_> {
8756 fn span(&self) -> ::treesitter_types::Span {
8757 match self {
8758 Self::Identifier(inner) => inner.span(),
8759 Self::UnderscorePattern(inner) => inner.span(),
8760 }
8761 }
8762}
8763#[derive(Debug, Clone)]
8764pub enum EnumBodyChildren<'tree> {
8765 EnumBodyDeclarations(::std::boxed::Box<EnumBodyDeclarations<'tree>>),
8766 EnumConstant(::std::boxed::Box<EnumConstant<'tree>>),
8767}
8768impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyChildren<'tree> {
8769 #[allow(clippy::collapsible_else_if)]
8770 fn from_node(
8771 node: ::tree_sitter::Node<'tree>,
8772 src: &'tree [u8],
8773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8774 match node.kind() {
8775 "enum_body_declarations" => Ok(Self::EnumBodyDeclarations(::std::boxed::Box::new(
8776 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)?,
8777 ))),
8778 "enum_constant" => Ok(Self::EnumConstant(::std::boxed::Box::new(
8779 <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)?,
8780 ))),
8781 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8782 }
8783 }
8784}
8785impl ::treesitter_types::Spanned for EnumBodyChildren<'_> {
8786 fn span(&self) -> ::treesitter_types::Span {
8787 match self {
8788 Self::EnumBodyDeclarations(inner) => inner.span(),
8789 Self::EnumConstant(inner) => inner.span(),
8790 }
8791 }
8792}
8793#[derive(Debug, Clone)]
8794pub enum EnumBodyDeclarationsChildren<'tree> {
8795 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
8796 Block(::std::boxed::Box<Block<'tree>>),
8797 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
8798 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
8799 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
8800 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
8801 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
8802 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
8803 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
8804 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
8805 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
8806}
8807impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarationsChildren<'tree> {
8808 #[allow(clippy::collapsible_else_if)]
8809 fn from_node(
8810 node: ::tree_sitter::Node<'tree>,
8811 src: &'tree [u8],
8812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8813 match node.kind() {
8814 "annotation_type_declaration" => {
8815 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
8816 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
8817 node, src,
8818 )?,
8819 )))
8820 }
8821 "block" => Ok(Self::Block(::std::boxed::Box::new(
8822 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
8823 ))),
8824 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
8825 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8826 ))),
8827 "compact_constructor_declaration" => {
8828 Ok(Self::CompactConstructorDeclaration(::std::boxed::Box::new(
8829 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
8830 node, src,
8831 )?,
8832 )))
8833 }
8834 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
8835 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8836 ))),
8837 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
8838 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8839 ))),
8840 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
8841 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8842 ))),
8843 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
8844 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8845 ))),
8846 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
8847 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8848 ))),
8849 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
8850 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8851 ))),
8852 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
8853 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
8854 ))),
8855 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8856 }
8857 }
8858}
8859impl ::treesitter_types::Spanned for EnumBodyDeclarationsChildren<'_> {
8860 fn span(&self) -> ::treesitter_types::Span {
8861 match self {
8862 Self::AnnotationTypeDeclaration(inner) => inner.span(),
8863 Self::Block(inner) => inner.span(),
8864 Self::ClassDeclaration(inner) => inner.span(),
8865 Self::CompactConstructorDeclaration(inner) => inner.span(),
8866 Self::ConstructorDeclaration(inner) => inner.span(),
8867 Self::EnumDeclaration(inner) => inner.span(),
8868 Self::FieldDeclaration(inner) => inner.span(),
8869 Self::InterfaceDeclaration(inner) => inner.span(),
8870 Self::MethodDeclaration(inner) => inner.span(),
8871 Self::RecordDeclaration(inner) => inner.span(),
8872 Self::StaticInitializer(inner) => inner.span(),
8873 }
8874 }
8875}
8876#[derive(Debug, Clone)]
8877pub enum ExplicitConstructorInvocationConstructor<'tree> {
8878 Super(::std::boxed::Box<Super<'tree>>),
8879 This(::std::boxed::Box<This<'tree>>),
8880}
8881impl<'tree> ::treesitter_types::FromNode<'tree>
8882 for ExplicitConstructorInvocationConstructor<'tree>
8883{
8884 #[allow(clippy::collapsible_else_if)]
8885 fn from_node(
8886 node: ::tree_sitter::Node<'tree>,
8887 src: &'tree [u8],
8888 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8889 match node.kind() {
8890 "super" => Ok(Self::Super(::std::boxed::Box::new(
8891 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
8892 ))),
8893 "this" => Ok(Self::This(::std::boxed::Box::new(
8894 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
8895 ))),
8896 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8897 }
8898 }
8899}
8900impl ::treesitter_types::Spanned for ExplicitConstructorInvocationConstructor<'_> {
8901 fn span(&self) -> ::treesitter_types::Span {
8902 match self {
8903 Self::Super(inner) => inner.span(),
8904 Self::This(inner) => inner.span(),
8905 }
8906 }
8907}
8908#[derive(Debug, Clone)]
8909pub enum ExportsModuleDirectiveModules<'tree> {
8910 Identifier(::std::boxed::Box<Identifier<'tree>>),
8911 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
8912}
8913impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectiveModules<'tree> {
8914 #[allow(clippy::collapsible_else_if)]
8915 fn from_node(
8916 node: ::tree_sitter::Node<'tree>,
8917 src: &'tree [u8],
8918 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8919 match node.kind() {
8920 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8921 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8922 ))),
8923 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
8924 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8925 ))),
8926 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8927 }
8928 }
8929}
8930impl ::treesitter_types::Spanned for ExportsModuleDirectiveModules<'_> {
8931 fn span(&self) -> ::treesitter_types::Span {
8932 match self {
8933 Self::Identifier(inner) => inner.span(),
8934 Self::ScopedIdentifier(inner) => inner.span(),
8935 }
8936 }
8937}
8938#[derive(Debug, Clone)]
8939pub enum ExportsModuleDirectivePackage<'tree> {
8940 Identifier(::std::boxed::Box<Identifier<'tree>>),
8941 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
8942}
8943impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectivePackage<'tree> {
8944 #[allow(clippy::collapsible_else_if)]
8945 fn from_node(
8946 node: ::tree_sitter::Node<'tree>,
8947 src: &'tree [u8],
8948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8949 match node.kind() {
8950 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8951 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8952 ))),
8953 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
8954 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8955 ))),
8956 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8957 }
8958 }
8959}
8960impl ::treesitter_types::Spanned for ExportsModuleDirectivePackage<'_> {
8961 fn span(&self) -> ::treesitter_types::Span {
8962 match self {
8963 Self::Identifier(inner) => inner.span(),
8964 Self::ScopedIdentifier(inner) => inner.span(),
8965 }
8966 }
8967}
8968#[derive(Debug, Clone)]
8969pub enum FieldAccessField<'tree> {
8970 Identifier(::std::boxed::Box<Identifier<'tree>>),
8971 This(::std::boxed::Box<This<'tree>>),
8972}
8973impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessField<'tree> {
8974 #[allow(clippy::collapsible_else_if)]
8975 fn from_node(
8976 node: ::tree_sitter::Node<'tree>,
8977 src: &'tree [u8],
8978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8979 match node.kind() {
8980 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8981 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8982 ))),
8983 "this" => Ok(Self::This(::std::boxed::Box::new(
8984 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
8985 ))),
8986 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8987 }
8988 }
8989}
8990impl ::treesitter_types::Spanned for FieldAccessField<'_> {
8991 fn span(&self) -> ::treesitter_types::Span {
8992 match self {
8993 Self::Identifier(inner) => inner.span(),
8994 Self::This(inner) => inner.span(),
8995 }
8996 }
8997}
8998#[derive(Debug, Clone)]
8999pub enum FieldAccessObject<'tree> {
9000 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
9001 Super(::std::boxed::Box<Super<'tree>>),
9002}
9003impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessObject<'tree> {
9004 #[allow(clippy::collapsible_else_if)]
9005 fn from_node(
9006 node: ::tree_sitter::Node<'tree>,
9007 src: &'tree [u8],
9008 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9009 match node.kind() {
9010 "super" => Ok(Self::Super(::std::boxed::Box::new(
9011 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9012 ))),
9013 _other => {
9014 if let Ok(v) =
9015 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9016 {
9017 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
9018 } else {
9019 Err(::treesitter_types::ParseError::unexpected_kind(
9020 _other, node,
9021 ))
9022 }
9023 }
9024 }
9025 }
9026}
9027impl ::treesitter_types::Spanned for FieldAccessObject<'_> {
9028 fn span(&self) -> ::treesitter_types::Span {
9029 match self {
9030 Self::PrimaryExpression(inner) => inner.span(),
9031 Self::Super(inner) => inner.span(),
9032 }
9033 }
9034}
9035#[derive(Debug, Clone)]
9036pub enum ForStatementInit<'tree> {
9037 Expression(::std::boxed::Box<Expression<'tree>>),
9038 LocalVariableDeclaration(::std::boxed::Box<LocalVariableDeclaration<'tree>>),
9039}
9040impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInit<'tree> {
9041 #[allow(clippy::collapsible_else_if)]
9042 fn from_node(
9043 node: ::tree_sitter::Node<'tree>,
9044 src: &'tree [u8],
9045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9046 match node.kind() {
9047 "local_variable_declaration" => {
9048 Ok(Self::LocalVariableDeclaration(::std::boxed::Box::new(
9049 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(
9050 node, src,
9051 )?,
9052 )))
9053 }
9054 _other => {
9055 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9056 Ok(Self::Expression(::std::boxed::Box::new(v)))
9057 } else {
9058 Err(::treesitter_types::ParseError::unexpected_kind(
9059 _other, node,
9060 ))
9061 }
9062 }
9063 }
9064 }
9065}
9066impl ::treesitter_types::Spanned for ForStatementInit<'_> {
9067 fn span(&self) -> ::treesitter_types::Span {
9068 match self {
9069 Self::Expression(inner) => inner.span(),
9070 Self::LocalVariableDeclaration(inner) => inner.span(),
9071 }
9072 }
9073}
9074#[derive(Debug, Clone)]
9075pub enum FormalParameterName<'tree> {
9076 Identifier(::std::boxed::Box<Identifier<'tree>>),
9077 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
9078}
9079impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameterName<'tree> {
9080 #[allow(clippy::collapsible_else_if)]
9081 fn from_node(
9082 node: ::tree_sitter::Node<'tree>,
9083 src: &'tree [u8],
9084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9085 match node.kind() {
9086 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9087 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9088 ))),
9089 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
9090 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9091 ))),
9092 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9093 }
9094 }
9095}
9096impl ::treesitter_types::Spanned for FormalParameterName<'_> {
9097 fn span(&self) -> ::treesitter_types::Span {
9098 match self {
9099 Self::Identifier(inner) => inner.span(),
9100 Self::UnderscorePattern(inner) => inner.span(),
9101 }
9102 }
9103}
9104#[derive(Debug, Clone)]
9105pub enum FormalParametersChildren<'tree> {
9106 FormalParameter(::std::boxed::Box<FormalParameter<'tree>>),
9107 ReceiverParameter(::std::boxed::Box<ReceiverParameter<'tree>>),
9108 SpreadParameter(::std::boxed::Box<SpreadParameter<'tree>>),
9109}
9110impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
9111 #[allow(clippy::collapsible_else_if)]
9112 fn from_node(
9113 node: ::tree_sitter::Node<'tree>,
9114 src: &'tree [u8],
9115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9116 match node.kind() {
9117 "formal_parameter" => Ok(Self::FormalParameter(::std::boxed::Box::new(
9118 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9119 ))),
9120 "receiver_parameter" => Ok(Self::ReceiverParameter(::std::boxed::Box::new(
9121 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9122 ))),
9123 "spread_parameter" => Ok(Self::SpreadParameter(::std::boxed::Box::new(
9124 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9125 ))),
9126 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9127 }
9128 }
9129}
9130impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
9131 fn span(&self) -> ::treesitter_types::Span {
9132 match self {
9133 Self::FormalParameter(inner) => inner.span(),
9134 Self::ReceiverParameter(inner) => inner.span(),
9135 Self::SpreadParameter(inner) => inner.span(),
9136 }
9137 }
9138}
9139#[derive(Debug, Clone)]
9140pub enum GenericTypeChildren<'tree> {
9141 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
9142 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
9143 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
9144}
9145impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeChildren<'tree> {
9146 #[allow(clippy::collapsible_else_if)]
9147 fn from_node(
9148 node: ::tree_sitter::Node<'tree>,
9149 src: &'tree [u8],
9150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9151 match node.kind() {
9152 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
9153 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9154 ))),
9155 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
9156 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
9157 ))),
9158 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
9159 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9160 ))),
9161 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9162 }
9163 }
9164}
9165impl ::treesitter_types::Spanned for GenericTypeChildren<'_> {
9166 fn span(&self) -> ::treesitter_types::Span {
9167 match self {
9168 Self::ScopedTypeIdentifier(inner) => inner.span(),
9169 Self::TypeArguments(inner) => inner.span(),
9170 Self::TypeIdentifier(inner) => inner.span(),
9171 }
9172 }
9173}
9174#[derive(Debug, Clone)]
9175pub enum ImportDeclarationChildren<'tree> {
9176 Asterisk(::std::boxed::Box<Asterisk<'tree>>),
9177 Identifier(::std::boxed::Box<Identifier<'tree>>),
9178 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9179}
9180impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclarationChildren<'tree> {
9181 #[allow(clippy::collapsible_else_if)]
9182 fn from_node(
9183 node: ::tree_sitter::Node<'tree>,
9184 src: &'tree [u8],
9185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9186 match node.kind() {
9187 "asterisk" => Ok(Self::Asterisk(::std::boxed::Box::new(
9188 <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)?,
9189 ))),
9190 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9191 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9192 ))),
9193 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9194 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9195 ))),
9196 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9197 }
9198 }
9199}
9200impl ::treesitter_types::Spanned for ImportDeclarationChildren<'_> {
9201 fn span(&self) -> ::treesitter_types::Span {
9202 match self {
9203 Self::Asterisk(inner) => inner.span(),
9204 Self::Identifier(inner) => inner.span(),
9205 Self::ScopedIdentifier(inner) => inner.span(),
9206 }
9207 }
9208}
9209#[derive(Debug, Clone)]
9210pub enum InterfaceBodyChildren<'tree> {
9211 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
9212 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
9213 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
9214 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9215 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
9216 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
9217 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
9218}
9219impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBodyChildren<'tree> {
9220 #[allow(clippy::collapsible_else_if)]
9221 fn from_node(
9222 node: ::tree_sitter::Node<'tree>,
9223 src: &'tree [u8],
9224 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9225 match node.kind() {
9226 "annotation_type_declaration" => {
9227 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
9228 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
9229 node, src,
9230 )?,
9231 )))
9232 }
9233 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
9234 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9235 ))),
9236 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
9237 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9238 ))),
9239 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
9240 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9241 ))),
9242 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
9243 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9244 ))),
9245 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
9246 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9247 ))),
9248 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
9249 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9250 ))),
9251 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9252 }
9253 }
9254}
9255impl ::treesitter_types::Spanned for InterfaceBodyChildren<'_> {
9256 fn span(&self) -> ::treesitter_types::Span {
9257 match self {
9258 Self::AnnotationTypeDeclaration(inner) => inner.span(),
9259 Self::ClassDeclaration(inner) => inner.span(),
9260 Self::ConstantDeclaration(inner) => inner.span(),
9261 Self::EnumDeclaration(inner) => inner.span(),
9262 Self::InterfaceDeclaration(inner) => inner.span(),
9263 Self::MethodDeclaration(inner) => inner.span(),
9264 Self::RecordDeclaration(inner) => inner.span(),
9265 }
9266 }
9267}
9268#[derive(Debug, Clone)]
9269pub enum InterfaceDeclarationChildren<'tree> {
9270 ExtendsInterfaces(::std::boxed::Box<ExtendsInterfaces<'tree>>),
9271 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9272}
9273impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
9274 #[allow(clippy::collapsible_else_if)]
9275 fn from_node(
9276 node: ::tree_sitter::Node<'tree>,
9277 src: &'tree [u8],
9278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9279 match node.kind() {
9280 "extends_interfaces" => Ok(Self::ExtendsInterfaces(::std::boxed::Box::new(
9281 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)?,
9282 ))),
9283 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9284 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
9285 ))),
9286 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9287 }
9288 }
9289}
9290impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
9291 fn span(&self) -> ::treesitter_types::Span {
9292 match self {
9293 Self::ExtendsInterfaces(inner) => inner.span(),
9294 Self::Modifiers(inner) => inner.span(),
9295 }
9296 }
9297}
9298#[derive(Debug, Clone)]
9299pub enum LabeledStatementChildren<'tree> {
9300 Identifier(::std::boxed::Box<Identifier<'tree>>),
9301 Statement(::std::boxed::Box<Statement<'tree>>),
9302}
9303impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
9304 #[allow(clippy::collapsible_else_if)]
9305 fn from_node(
9306 node: ::tree_sitter::Node<'tree>,
9307 src: &'tree [u8],
9308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9309 match node.kind() {
9310 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9311 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9312 ))),
9313 _other => {
9314 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9315 Ok(Self::Statement(::std::boxed::Box::new(v)))
9316 } else {
9317 Err(::treesitter_types::ParseError::unexpected_kind(
9318 _other, node,
9319 ))
9320 }
9321 }
9322 }
9323 }
9324}
9325impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
9326 fn span(&self) -> ::treesitter_types::Span {
9327 match self {
9328 Self::Identifier(inner) => inner.span(),
9329 Self::Statement(inner) => inner.span(),
9330 }
9331 }
9332}
9333#[derive(Debug, Clone)]
9334pub enum LambdaExpressionBody<'tree> {
9335 Block(::std::boxed::Box<Block<'tree>>),
9336 Expression(::std::boxed::Box<Expression<'tree>>),
9337}
9338impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
9339 #[allow(clippy::collapsible_else_if)]
9340 fn from_node(
9341 node: ::tree_sitter::Node<'tree>,
9342 src: &'tree [u8],
9343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9344 match node.kind() {
9345 "block" => Ok(Self::Block(::std::boxed::Box::new(
9346 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9347 ))),
9348 _other => {
9349 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9350 Ok(Self::Expression(::std::boxed::Box::new(v)))
9351 } else {
9352 Err(::treesitter_types::ParseError::unexpected_kind(
9353 _other, node,
9354 ))
9355 }
9356 }
9357 }
9358 }
9359}
9360impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
9361 fn span(&self) -> ::treesitter_types::Span {
9362 match self {
9363 Self::Block(inner) => inner.span(),
9364 Self::Expression(inner) => inner.span(),
9365 }
9366 }
9367}
9368#[derive(Debug, Clone)]
9369pub enum LambdaExpressionParameters<'tree> {
9370 FormalParameters(::std::boxed::Box<FormalParameters<'tree>>),
9371 Identifier(::std::boxed::Box<Identifier<'tree>>),
9372 InferredParameters(::std::boxed::Box<InferredParameters<'tree>>),
9373}
9374impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
9375 #[allow(clippy::collapsible_else_if)]
9376 fn from_node(
9377 node: ::tree_sitter::Node<'tree>,
9378 src: &'tree [u8],
9379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9380 match node.kind() {
9381 "formal_parameters" => Ok(Self::FormalParameters(::std::boxed::Box::new(
9382 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)?,
9383 ))),
9384 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9385 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9386 ))),
9387 "inferred_parameters" => Ok(Self::InferredParameters(::std::boxed::Box::new(
9388 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)?,
9389 ))),
9390 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9391 }
9392 }
9393}
9394impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
9395 fn span(&self) -> ::treesitter_types::Span {
9396 match self {
9397 Self::FormalParameters(inner) => inner.span(),
9398 Self::Identifier(inner) => inner.span(),
9399 Self::InferredParameters(inner) => inner.span(),
9400 }
9401 }
9402}
9403#[derive(Debug, Clone)]
9404pub enum MarkerAnnotationName<'tree> {
9405 Identifier(::std::boxed::Box<Identifier<'tree>>),
9406 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9407}
9408impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotationName<'tree> {
9409 #[allow(clippy::collapsible_else_if)]
9410 fn from_node(
9411 node: ::tree_sitter::Node<'tree>,
9412 src: &'tree [u8],
9413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9414 match node.kind() {
9415 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9416 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9417 ))),
9418 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9419 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9420 ))),
9421 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9422 }
9423 }
9424}
9425impl ::treesitter_types::Spanned for MarkerAnnotationName<'_> {
9426 fn span(&self) -> ::treesitter_types::Span {
9427 match self {
9428 Self::Identifier(inner) => inner.span(),
9429 Self::ScopedIdentifier(inner) => inner.span(),
9430 }
9431 }
9432}
9433#[derive(Debug, Clone)]
9434pub enum MethodDeclarationChildren<'tree> {
9435 Annotation(::std::boxed::Box<Annotation<'tree>>),
9436 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9437 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9438 Throws(::std::boxed::Box<Throws<'tree>>),
9439}
9440impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
9441 #[allow(clippy::collapsible_else_if)]
9442 fn from_node(
9443 node: ::tree_sitter::Node<'tree>,
9444 src: &'tree [u8],
9445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9446 match node.kind() {
9447 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9448 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9449 ))),
9450 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9451 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9452 ))),
9453 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9454 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
9455 ))),
9456 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
9457 <Throws as ::treesitter_types::FromNode>::from_node(node, src)?,
9458 ))),
9459 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9460 }
9461 }
9462}
9463impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
9464 fn span(&self) -> ::treesitter_types::Span {
9465 match self {
9466 Self::Annotation(inner) => inner.span(),
9467 Self::MarkerAnnotation(inner) => inner.span(),
9468 Self::Modifiers(inner) => inner.span(),
9469 Self::Throws(inner) => inner.span(),
9470 }
9471 }
9472}
9473#[derive(Debug, Clone)]
9474pub enum MethodInvocationObject<'tree> {
9475 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
9476 Super(::std::boxed::Box<Super<'tree>>),
9477}
9478impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocationObject<'tree> {
9479 #[allow(clippy::collapsible_else_if)]
9480 fn from_node(
9481 node: ::tree_sitter::Node<'tree>,
9482 src: &'tree [u8],
9483 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9484 match node.kind() {
9485 "super" => Ok(Self::Super(::std::boxed::Box::new(
9486 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9487 ))),
9488 _other => {
9489 if let Ok(v) =
9490 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9491 {
9492 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
9493 } else {
9494 Err(::treesitter_types::ParseError::unexpected_kind(
9495 _other, node,
9496 ))
9497 }
9498 }
9499 }
9500 }
9501}
9502impl ::treesitter_types::Spanned for MethodInvocationObject<'_> {
9503 fn span(&self) -> ::treesitter_types::Span {
9504 match self {
9505 Self::PrimaryExpression(inner) => inner.span(),
9506 Self::Super(inner) => inner.span(),
9507 }
9508 }
9509}
9510#[derive(Debug, Clone)]
9511pub enum MethodReferenceChildren<'tree> {
9512 Type(::std::boxed::Box<Type<'tree>>),
9513 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
9514 Super(::std::boxed::Box<Super<'tree>>),
9515 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
9516}
9517impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReferenceChildren<'tree> {
9518 #[allow(clippy::collapsible_else_if)]
9519 fn from_node(
9520 node: ::tree_sitter::Node<'tree>,
9521 src: &'tree [u8],
9522 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9523 match node.kind() {
9524 "super" => Ok(Self::Super(::std::boxed::Box::new(
9525 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9526 ))),
9527 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
9528 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
9529 ))),
9530 _other => {
9531 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9532 Ok(Self::Type(::std::boxed::Box::new(v)))
9533 } else {
9534 if let Ok(v) =
9535 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9536 {
9537 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
9538 } else {
9539 Err(::treesitter_types::ParseError::unexpected_kind(
9540 _other, node,
9541 ))
9542 }
9543 }
9544 }
9545 }
9546 }
9547}
9548impl ::treesitter_types::Spanned for MethodReferenceChildren<'_> {
9549 fn span(&self) -> ::treesitter_types::Span {
9550 match self {
9551 Self::Type(inner) => inner.span(),
9552 Self::PrimaryExpression(inner) => inner.span(),
9553 Self::Super(inner) => inner.span(),
9554 Self::TypeArguments(inner) => inner.span(),
9555 }
9556 }
9557}
9558#[derive(Debug, Clone)]
9559pub enum ModifiersChildren<'tree> {
9560 Annotation(::std::boxed::Box<Annotation<'tree>>),
9561 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9562}
9563impl<'tree> ::treesitter_types::FromNode<'tree> for ModifiersChildren<'tree> {
9564 #[allow(clippy::collapsible_else_if)]
9565 fn from_node(
9566 node: ::tree_sitter::Node<'tree>,
9567 src: &'tree [u8],
9568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9569 match node.kind() {
9570 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9571 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9572 ))),
9573 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9574 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9575 ))),
9576 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9577 }
9578 }
9579}
9580impl ::treesitter_types::Spanned for ModifiersChildren<'_> {
9581 fn span(&self) -> ::treesitter_types::Span {
9582 match self {
9583 Self::Annotation(inner) => inner.span(),
9584 Self::MarkerAnnotation(inner) => inner.span(),
9585 }
9586 }
9587}
9588#[derive(Debug, Clone)]
9589pub enum ModuleDeclarationName<'tree> {
9590 Identifier(::std::boxed::Box<Identifier<'tree>>),
9591 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9592}
9593impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationName<'tree> {
9594 #[allow(clippy::collapsible_else_if)]
9595 fn from_node(
9596 node: ::tree_sitter::Node<'tree>,
9597 src: &'tree [u8],
9598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9599 match node.kind() {
9600 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9601 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9602 ))),
9603 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9604 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9605 ))),
9606 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9607 }
9608 }
9609}
9610impl ::treesitter_types::Spanned for ModuleDeclarationName<'_> {
9611 fn span(&self) -> ::treesitter_types::Span {
9612 match self {
9613 Self::Identifier(inner) => inner.span(),
9614 Self::ScopedIdentifier(inner) => inner.span(),
9615 }
9616 }
9617}
9618#[derive(Debug, Clone)]
9619pub enum ModuleDeclarationChildren<'tree> {
9620 Annotation(::std::boxed::Box<Annotation<'tree>>),
9621 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9622}
9623impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationChildren<'tree> {
9624 #[allow(clippy::collapsible_else_if)]
9625 fn from_node(
9626 node: ::tree_sitter::Node<'tree>,
9627 src: &'tree [u8],
9628 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9629 match node.kind() {
9630 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9631 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9632 ))),
9633 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9634 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9635 ))),
9636 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9637 }
9638 }
9639}
9640impl ::treesitter_types::Spanned for ModuleDeclarationChildren<'_> {
9641 fn span(&self) -> ::treesitter_types::Span {
9642 match self {
9643 Self::Annotation(inner) => inner.span(),
9644 Self::MarkerAnnotation(inner) => inner.span(),
9645 }
9646 }
9647}
9648#[derive(Debug, Clone)]
9649pub enum ObjectCreationExpressionChildren<'tree> {
9650 Annotation(::std::boxed::Box<Annotation<'tree>>),
9651 ClassBody(::std::boxed::Box<ClassBody<'tree>>),
9652 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9653 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
9654}
9655impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpressionChildren<'tree> {
9656 #[allow(clippy::collapsible_else_if)]
9657 fn from_node(
9658 node: ::tree_sitter::Node<'tree>,
9659 src: &'tree [u8],
9660 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9661 match node.kind() {
9662 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9663 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9664 ))),
9665 "class_body" => Ok(Self::ClassBody(::std::boxed::Box::new(
9666 <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)?,
9667 ))),
9668 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9669 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9670 ))),
9671 _other => {
9672 if let Ok(v) =
9673 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9674 {
9675 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
9676 } else {
9677 Err(::treesitter_types::ParseError::unexpected_kind(
9678 _other, node,
9679 ))
9680 }
9681 }
9682 }
9683 }
9684}
9685impl ::treesitter_types::Spanned for ObjectCreationExpressionChildren<'_> {
9686 fn span(&self) -> ::treesitter_types::Span {
9687 match self {
9688 Self::Annotation(inner) => inner.span(),
9689 Self::ClassBody(inner) => inner.span(),
9690 Self::MarkerAnnotation(inner) => inner.span(),
9691 Self::PrimaryExpression(inner) => inner.span(),
9692 }
9693 }
9694}
9695#[derive(Debug, Clone)]
9696pub enum OpensModuleDirectiveModules<'tree> {
9697 Identifier(::std::boxed::Box<Identifier<'tree>>),
9698 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9699}
9700impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectiveModules<'tree> {
9701 #[allow(clippy::collapsible_else_if)]
9702 fn from_node(
9703 node: ::tree_sitter::Node<'tree>,
9704 src: &'tree [u8],
9705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9706 match node.kind() {
9707 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9708 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9709 ))),
9710 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9711 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9712 ))),
9713 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9714 }
9715 }
9716}
9717impl ::treesitter_types::Spanned for OpensModuleDirectiveModules<'_> {
9718 fn span(&self) -> ::treesitter_types::Span {
9719 match self {
9720 Self::Identifier(inner) => inner.span(),
9721 Self::ScopedIdentifier(inner) => inner.span(),
9722 }
9723 }
9724}
9725#[derive(Debug, Clone)]
9726pub enum OpensModuleDirectivePackage<'tree> {
9727 Identifier(::std::boxed::Box<Identifier<'tree>>),
9728 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9729}
9730impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectivePackage<'tree> {
9731 #[allow(clippy::collapsible_else_if)]
9732 fn from_node(
9733 node: ::tree_sitter::Node<'tree>,
9734 src: &'tree [u8],
9735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9736 match node.kind() {
9737 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9738 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9739 ))),
9740 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9741 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9742 ))),
9743 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9744 }
9745 }
9746}
9747impl ::treesitter_types::Spanned for OpensModuleDirectivePackage<'_> {
9748 fn span(&self) -> ::treesitter_types::Span {
9749 match self {
9750 Self::Identifier(inner) => inner.span(),
9751 Self::ScopedIdentifier(inner) => inner.span(),
9752 }
9753 }
9754}
9755#[derive(Debug, Clone)]
9756pub enum PackageDeclarationChildren<'tree> {
9757 Annotation(::std::boxed::Box<Annotation<'tree>>),
9758 Identifier(::std::boxed::Box<Identifier<'tree>>),
9759 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9760 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9761}
9762impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclarationChildren<'tree> {
9763 #[allow(clippy::collapsible_else_if)]
9764 fn from_node(
9765 node: ::tree_sitter::Node<'tree>,
9766 src: &'tree [u8],
9767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9768 match node.kind() {
9769 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9770 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9771 ))),
9772 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9773 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9774 ))),
9775 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9776 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9777 ))),
9778 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9779 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9780 ))),
9781 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9782 }
9783 }
9784}
9785impl ::treesitter_types::Spanned for PackageDeclarationChildren<'_> {
9786 fn span(&self) -> ::treesitter_types::Span {
9787 match self {
9788 Self::Annotation(inner) => inner.span(),
9789 Self::Identifier(inner) => inner.span(),
9790 Self::MarkerAnnotation(inner) => inner.span(),
9791 Self::ScopedIdentifier(inner) => inner.span(),
9792 }
9793 }
9794}
9795#[derive(Debug, Clone)]
9796pub enum PatternChildren<'tree> {
9797 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
9798 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
9799}
9800impl<'tree> ::treesitter_types::FromNode<'tree> for PatternChildren<'tree> {
9801 #[allow(clippy::collapsible_else_if)]
9802 fn from_node(
9803 node: ::tree_sitter::Node<'tree>,
9804 src: &'tree [u8],
9805 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9806 match node.kind() {
9807 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
9808 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9809 ))),
9810 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
9811 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9812 ))),
9813 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9814 }
9815 }
9816}
9817impl ::treesitter_types::Spanned for PatternChildren<'_> {
9818 fn span(&self) -> ::treesitter_types::Span {
9819 match self {
9820 Self::RecordPattern(inner) => inner.span(),
9821 Self::TypePattern(inner) => inner.span(),
9822 }
9823 }
9824}
9825#[derive(Debug, Clone)]
9826pub enum ProgramChildren<'tree> {
9827 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
9828 Statement(::std::boxed::Box<Statement<'tree>>),
9829}
9830impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
9831 #[allow(clippy::collapsible_else_if)]
9832 fn from_node(
9833 node: ::tree_sitter::Node<'tree>,
9834 src: &'tree [u8],
9835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9836 match node.kind() {
9837 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
9838 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9839 ))),
9840 _other => {
9841 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9842 Ok(Self::Statement(::std::boxed::Box::new(v)))
9843 } else {
9844 Err(::treesitter_types::ParseError::unexpected_kind(
9845 _other, node,
9846 ))
9847 }
9848 }
9849 }
9850 }
9851}
9852impl ::treesitter_types::Spanned for ProgramChildren<'_> {
9853 fn span(&self) -> ::treesitter_types::Span {
9854 match self {
9855 Self::MethodDeclaration(inner) => inner.span(),
9856 Self::Statement(inner) => inner.span(),
9857 }
9858 }
9859}
9860#[derive(Debug, Clone)]
9861pub enum ProvidesModuleDirectiveProvided<'tree> {
9862 Identifier(::std::boxed::Box<Identifier<'tree>>),
9863 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9864}
9865impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvided<'tree> {
9866 #[allow(clippy::collapsible_else_if)]
9867 fn from_node(
9868 node: ::tree_sitter::Node<'tree>,
9869 src: &'tree [u8],
9870 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9871 match node.kind() {
9872 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9873 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9874 ))),
9875 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9876 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9877 ))),
9878 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9879 }
9880 }
9881}
9882impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvided<'_> {
9883 fn span(&self) -> ::treesitter_types::Span {
9884 match self {
9885 Self::Identifier(inner) => inner.span(),
9886 Self::ScopedIdentifier(inner) => inner.span(),
9887 }
9888 }
9889}
9890#[derive(Debug, Clone)]
9891pub enum ProvidesModuleDirectiveProvider<'tree> {
9892 Identifier(::std::boxed::Box<Identifier<'tree>>),
9893 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9894}
9895impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvider<'tree> {
9896 #[allow(clippy::collapsible_else_if)]
9897 fn from_node(
9898 node: ::tree_sitter::Node<'tree>,
9899 src: &'tree [u8],
9900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9901 match node.kind() {
9902 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9903 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9904 ))),
9905 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9906 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9907 ))),
9908 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9909 }
9910 }
9911}
9912impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvider<'_> {
9913 fn span(&self) -> ::treesitter_types::Span {
9914 match self {
9915 Self::Identifier(inner) => inner.span(),
9916 Self::ScopedIdentifier(inner) => inner.span(),
9917 }
9918 }
9919}
9920#[derive(Debug, Clone)]
9921pub enum ProvidesModuleDirectiveChildren<'tree> {
9922 Identifier(::std::boxed::Box<Identifier<'tree>>),
9923 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9924}
9925impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveChildren<'tree> {
9926 #[allow(clippy::collapsible_else_if)]
9927 fn from_node(
9928 node: ::tree_sitter::Node<'tree>,
9929 src: &'tree [u8],
9930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9931 match node.kind() {
9932 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9933 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9934 ))),
9935 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9936 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9937 ))),
9938 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9939 }
9940 }
9941}
9942impl ::treesitter_types::Spanned for ProvidesModuleDirectiveChildren<'_> {
9943 fn span(&self) -> ::treesitter_types::Span {
9944 match self {
9945 Self::Identifier(inner) => inner.span(),
9946 Self::ScopedIdentifier(inner) => inner.span(),
9947 }
9948 }
9949}
9950#[derive(Debug, Clone)]
9951pub enum ReceiverParameterChildren<'tree> {
9952 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
9953 Annotation(::std::boxed::Box<Annotation<'tree>>),
9954 Identifier(::std::boxed::Box<Identifier<'tree>>),
9955 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9956 This(::std::boxed::Box<This<'tree>>),
9957}
9958impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameterChildren<'tree> {
9959 #[allow(clippy::collapsible_else_if)]
9960 fn from_node(
9961 node: ::tree_sitter::Node<'tree>,
9962 src: &'tree [u8],
9963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9964 match node.kind() {
9965 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9966 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9967 ))),
9968 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9969 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9970 ))),
9971 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9972 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9973 ))),
9974 "this" => Ok(Self::This(::std::boxed::Box::new(
9975 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
9976 ))),
9977 _other => {
9978 if let Ok(v) =
9979 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
9980 {
9981 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
9982 } else {
9983 Err(::treesitter_types::ParseError::unexpected_kind(
9984 _other, node,
9985 ))
9986 }
9987 }
9988 }
9989 }
9990}
9991impl ::treesitter_types::Spanned for ReceiverParameterChildren<'_> {
9992 fn span(&self) -> ::treesitter_types::Span {
9993 match self {
9994 Self::UnannotatedType(inner) => inner.span(),
9995 Self::Annotation(inner) => inner.span(),
9996 Self::Identifier(inner) => inner.span(),
9997 Self::MarkerAnnotation(inner) => inner.span(),
9998 Self::This(inner) => inner.span(),
9999 }
10000 }
10001}
10002#[derive(Debug, Clone)]
10003pub enum RecordPatternChildren<'tree> {
10004 GenericType(::std::boxed::Box<GenericType<'tree>>),
10005 Identifier(::std::boxed::Box<Identifier<'tree>>),
10006 RecordPatternBody(::std::boxed::Box<RecordPatternBody<'tree>>),
10007}
10008impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternChildren<'tree> {
10009 #[allow(clippy::collapsible_else_if)]
10010 fn from_node(
10011 node: ::tree_sitter::Node<'tree>,
10012 src: &'tree [u8],
10013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10014 match node.kind() {
10015 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10016 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10017 ))),
10018 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10019 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10020 ))),
10021 "record_pattern_body" => Ok(Self::RecordPatternBody(::std::boxed::Box::new(
10022 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)?,
10023 ))),
10024 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10025 }
10026 }
10027}
10028impl ::treesitter_types::Spanned for RecordPatternChildren<'_> {
10029 fn span(&self) -> ::treesitter_types::Span {
10030 match self {
10031 Self::GenericType(inner) => inner.span(),
10032 Self::Identifier(inner) => inner.span(),
10033 Self::RecordPatternBody(inner) => inner.span(),
10034 }
10035 }
10036}
10037#[derive(Debug, Clone)]
10038pub enum RecordPatternBodyChildren<'tree> {
10039 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
10040 RecordPatternComponent(::std::boxed::Box<RecordPatternComponent<'tree>>),
10041}
10042impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBodyChildren<'tree> {
10043 #[allow(clippy::collapsible_else_if)]
10044 fn from_node(
10045 node: ::tree_sitter::Node<'tree>,
10046 src: &'tree [u8],
10047 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10048 match node.kind() {
10049 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
10050 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10051 ))),
10052 "record_pattern_component" => Ok(Self::RecordPatternComponent(::std::boxed::Box::new(
10053 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)?,
10054 ))),
10055 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10056 }
10057 }
10058}
10059impl ::treesitter_types::Spanned for RecordPatternBodyChildren<'_> {
10060 fn span(&self) -> ::treesitter_types::Span {
10061 match self {
10062 Self::RecordPattern(inner) => inner.span(),
10063 Self::RecordPatternComponent(inner) => inner.span(),
10064 }
10065 }
10066}
10067#[derive(Debug, Clone)]
10068pub enum RecordPatternComponentChildren<'tree> {
10069 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
10070 Identifier(::std::boxed::Box<Identifier<'tree>>),
10071 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10072}
10073impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponentChildren<'tree> {
10074 #[allow(clippy::collapsible_else_if)]
10075 fn from_node(
10076 node: ::tree_sitter::Node<'tree>,
10077 src: &'tree [u8],
10078 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10079 match node.kind() {
10080 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10081 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10082 ))),
10083 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10084 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10085 ))),
10086 _other => {
10087 if let Ok(v) =
10088 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
10089 {
10090 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
10091 } else {
10092 Err(::treesitter_types::ParseError::unexpected_kind(
10093 _other, node,
10094 ))
10095 }
10096 }
10097 }
10098 }
10099}
10100impl ::treesitter_types::Spanned for RecordPatternComponentChildren<'_> {
10101 fn span(&self) -> ::treesitter_types::Span {
10102 match self {
10103 Self::UnannotatedType(inner) => inner.span(),
10104 Self::Identifier(inner) => inner.span(),
10105 Self::UnderscorePattern(inner) => inner.span(),
10106 }
10107 }
10108}
10109#[derive(Debug, Clone)]
10110pub enum RequiresModuleDirectiveModule<'tree> {
10111 Identifier(::std::boxed::Box<Identifier<'tree>>),
10112 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10113}
10114impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirectiveModule<'tree> {
10115 #[allow(clippy::collapsible_else_if)]
10116 fn from_node(
10117 node: ::tree_sitter::Node<'tree>,
10118 src: &'tree [u8],
10119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10120 match node.kind() {
10121 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10122 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10123 ))),
10124 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10125 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10126 ))),
10127 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10128 }
10129 }
10130}
10131impl ::treesitter_types::Spanned for RequiresModuleDirectiveModule<'_> {
10132 fn span(&self) -> ::treesitter_types::Span {
10133 match self {
10134 Self::Identifier(inner) => inner.span(),
10135 Self::ScopedIdentifier(inner) => inner.span(),
10136 }
10137 }
10138}
10139#[derive(Debug, Clone)]
10140pub enum ResourceName<'tree> {
10141 Identifier(::std::boxed::Box<Identifier<'tree>>),
10142 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10143}
10144impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceName<'tree> {
10145 #[allow(clippy::collapsible_else_if)]
10146 fn from_node(
10147 node: ::tree_sitter::Node<'tree>,
10148 src: &'tree [u8],
10149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10150 match node.kind() {
10151 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10152 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10153 ))),
10154 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10155 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10156 ))),
10157 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10158 }
10159 }
10160}
10161impl ::treesitter_types::Spanned for ResourceName<'_> {
10162 fn span(&self) -> ::treesitter_types::Span {
10163 match self {
10164 Self::Identifier(inner) => inner.span(),
10165 Self::UnderscorePattern(inner) => inner.span(),
10166 }
10167 }
10168}
10169#[derive(Debug, Clone)]
10170pub enum ResourceChildren<'tree> {
10171 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
10172 Identifier(::std::boxed::Box<Identifier<'tree>>),
10173 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10174}
10175impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceChildren<'tree> {
10176 #[allow(clippy::collapsible_else_if)]
10177 fn from_node(
10178 node: ::tree_sitter::Node<'tree>,
10179 src: &'tree [u8],
10180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10181 match node.kind() {
10182 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
10183 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
10184 ))),
10185 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10186 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10187 ))),
10188 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10189 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10190 ))),
10191 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10192 }
10193 }
10194}
10195impl ::treesitter_types::Spanned for ResourceChildren<'_> {
10196 fn span(&self) -> ::treesitter_types::Span {
10197 match self {
10198 Self::FieldAccess(inner) => inner.span(),
10199 Self::Identifier(inner) => inner.span(),
10200 Self::Modifiers(inner) => inner.span(),
10201 }
10202 }
10203}
10204#[derive(Debug, Clone)]
10205pub enum ScopedIdentifierScope<'tree> {
10206 Identifier(::std::boxed::Box<Identifier<'tree>>),
10207 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10208}
10209impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierScope<'tree> {
10210 #[allow(clippy::collapsible_else_if)]
10211 fn from_node(
10212 node: ::tree_sitter::Node<'tree>,
10213 src: &'tree [u8],
10214 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10215 match node.kind() {
10216 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10217 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10218 ))),
10219 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10220 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10221 ))),
10222 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10223 }
10224 }
10225}
10226impl ::treesitter_types::Spanned for ScopedIdentifierScope<'_> {
10227 fn span(&self) -> ::treesitter_types::Span {
10228 match self {
10229 Self::Identifier(inner) => inner.span(),
10230 Self::ScopedIdentifier(inner) => inner.span(),
10231 }
10232 }
10233}
10234#[derive(Debug, Clone)]
10235pub enum ScopedTypeIdentifierChildren<'tree> {
10236 Annotation(::std::boxed::Box<Annotation<'tree>>),
10237 GenericType(::std::boxed::Box<GenericType<'tree>>),
10238 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10239 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10240 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10241}
10242impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierChildren<'tree> {
10243 #[allow(clippy::collapsible_else_if)]
10244 fn from_node(
10245 node: ::tree_sitter::Node<'tree>,
10246 src: &'tree [u8],
10247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10248 match node.kind() {
10249 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10250 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10251 ))),
10252 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10253 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10254 ))),
10255 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10256 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10257 ))),
10258 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10259 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10260 ))),
10261 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10262 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10263 ))),
10264 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10265 }
10266 }
10267}
10268impl ::treesitter_types::Spanned for ScopedTypeIdentifierChildren<'_> {
10269 fn span(&self) -> ::treesitter_types::Span {
10270 match self {
10271 Self::Annotation(inner) => inner.span(),
10272 Self::GenericType(inner) => inner.span(),
10273 Self::MarkerAnnotation(inner) => inner.span(),
10274 Self::ScopedTypeIdentifier(inner) => inner.span(),
10275 Self::TypeIdentifier(inner) => inner.span(),
10276 }
10277 }
10278}
10279#[derive(Debug, Clone)]
10280pub enum SpreadParameterChildren<'tree> {
10281 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
10282 Annotation(::std::boxed::Box<Annotation<'tree>>),
10283 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10284 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10285 VariableDeclarator(::std::boxed::Box<VariableDeclarator<'tree>>),
10286}
10287impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameterChildren<'tree> {
10288 #[allow(clippy::collapsible_else_if)]
10289 fn from_node(
10290 node: ::tree_sitter::Node<'tree>,
10291 src: &'tree [u8],
10292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10293 match node.kind() {
10294 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10295 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10296 ))),
10297 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10298 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10299 ))),
10300 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10301 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10302 ))),
10303 "variable_declarator" => Ok(Self::VariableDeclarator(::std::boxed::Box::new(
10304 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
10305 ))),
10306 _other => {
10307 if let Ok(v) =
10308 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
10309 {
10310 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
10311 } else {
10312 Err(::treesitter_types::ParseError::unexpected_kind(
10313 _other, node,
10314 ))
10315 }
10316 }
10317 }
10318 }
10319}
10320impl ::treesitter_types::Spanned for SpreadParameterChildren<'_> {
10321 fn span(&self) -> ::treesitter_types::Span {
10322 match self {
10323 Self::UnannotatedType(inner) => inner.span(),
10324 Self::Annotation(inner) => inner.span(),
10325 Self::MarkerAnnotation(inner) => inner.span(),
10326 Self::Modifiers(inner) => inner.span(),
10327 Self::VariableDeclarator(inner) => inner.span(),
10328 }
10329 }
10330}
10331#[derive(Debug, Clone)]
10332pub enum StringLiteralChildren<'tree> {
10333 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
10334 MultilineStringFragment(::std::boxed::Box<MultilineStringFragment<'tree>>),
10335 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
10336 StringInterpolation(::std::boxed::Box<StringInterpolation<'tree>>),
10337}
10338impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
10339 #[allow(clippy::collapsible_else_if)]
10340 fn from_node(
10341 node: ::tree_sitter::Node<'tree>,
10342 src: &'tree [u8],
10343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10344 match node.kind() {
10345 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
10346 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
10347 ))),
10348 "multiline_string_fragment" => {
10349 Ok(Self::MultilineStringFragment(::std::boxed::Box::new(
10350 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(
10351 node, src,
10352 )?,
10353 )))
10354 }
10355 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
10356 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
10357 ))),
10358 "string_interpolation" => Ok(Self::StringInterpolation(::std::boxed::Box::new(
10359 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
10360 ))),
10361 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10362 }
10363 }
10364}
10365impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
10366 fn span(&self) -> ::treesitter_types::Span {
10367 match self {
10368 Self::EscapeSequence(inner) => inner.span(),
10369 Self::MultilineStringFragment(inner) => inner.span(),
10370 Self::StringFragment(inner) => inner.span(),
10371 Self::StringInterpolation(inner) => inner.span(),
10372 }
10373 }
10374}
10375#[derive(Debug, Clone)]
10376pub enum SwitchBlockChildren<'tree> {
10377 SwitchBlockStatementGroup(::std::boxed::Box<SwitchBlockStatementGroup<'tree>>),
10378 SwitchRule(::std::boxed::Box<SwitchRule<'tree>>),
10379}
10380impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockChildren<'tree> {
10381 #[allow(clippy::collapsible_else_if)]
10382 fn from_node(
10383 node: ::tree_sitter::Node<'tree>,
10384 src: &'tree [u8],
10385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10386 match node.kind() {
10387 "switch_block_statement_group" => {
10388 Ok(Self::SwitchBlockStatementGroup(::std::boxed::Box::new(
10389 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(
10390 node, src,
10391 )?,
10392 )))
10393 }
10394 "switch_rule" => Ok(Self::SwitchRule(::std::boxed::Box::new(
10395 <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)?,
10396 ))),
10397 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10398 }
10399 }
10400}
10401impl ::treesitter_types::Spanned for SwitchBlockChildren<'_> {
10402 fn span(&self) -> ::treesitter_types::Span {
10403 match self {
10404 Self::SwitchBlockStatementGroup(inner) => inner.span(),
10405 Self::SwitchRule(inner) => inner.span(),
10406 }
10407 }
10408}
10409#[derive(Debug, Clone)]
10410pub enum SwitchBlockStatementGroupChildren<'tree> {
10411 Statement(::std::boxed::Box<Statement<'tree>>),
10412 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
10413}
10414impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroupChildren<'tree> {
10415 #[allow(clippy::collapsible_else_if)]
10416 fn from_node(
10417 node: ::tree_sitter::Node<'tree>,
10418 src: &'tree [u8],
10419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10420 match node.kind() {
10421 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
10422 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)?,
10423 ))),
10424 _other => {
10425 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
10426 Ok(Self::Statement(::std::boxed::Box::new(v)))
10427 } else {
10428 Err(::treesitter_types::ParseError::unexpected_kind(
10429 _other, node,
10430 ))
10431 }
10432 }
10433 }
10434 }
10435}
10436impl ::treesitter_types::Spanned for SwitchBlockStatementGroupChildren<'_> {
10437 fn span(&self) -> ::treesitter_types::Span {
10438 match self {
10439 Self::Statement(inner) => inner.span(),
10440 Self::SwitchLabel(inner) => inner.span(),
10441 }
10442 }
10443}
10444#[derive(Debug, Clone)]
10445pub enum SwitchLabelChildren<'tree> {
10446 Expression(::std::boxed::Box<Expression<'tree>>),
10447 Guard(::std::boxed::Box<Guard<'tree>>),
10448 Pattern(::std::boxed::Box<Pattern<'tree>>),
10449}
10450impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabelChildren<'tree> {
10451 #[allow(clippy::collapsible_else_if)]
10452 fn from_node(
10453 node: ::tree_sitter::Node<'tree>,
10454 src: &'tree [u8],
10455 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10456 match node.kind() {
10457 "guard" => Ok(Self::Guard(::std::boxed::Box::new(
10458 <Guard as ::treesitter_types::FromNode>::from_node(node, src)?,
10459 ))),
10460 "pattern" => Ok(Self::Pattern(::std::boxed::Box::new(
10461 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10462 ))),
10463 _other => {
10464 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10465 Ok(Self::Expression(::std::boxed::Box::new(v)))
10466 } else {
10467 Err(::treesitter_types::ParseError::unexpected_kind(
10468 _other, node,
10469 ))
10470 }
10471 }
10472 }
10473 }
10474}
10475impl ::treesitter_types::Spanned for SwitchLabelChildren<'_> {
10476 fn span(&self) -> ::treesitter_types::Span {
10477 match self {
10478 Self::Expression(inner) => inner.span(),
10479 Self::Guard(inner) => inner.span(),
10480 Self::Pattern(inner) => inner.span(),
10481 }
10482 }
10483}
10484#[derive(Debug, Clone)]
10485pub enum SwitchRuleChildren<'tree> {
10486 Block(::std::boxed::Box<Block<'tree>>),
10487 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
10488 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
10489 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
10490}
10491impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRuleChildren<'tree> {
10492 #[allow(clippy::collapsible_else_if)]
10493 fn from_node(
10494 node: ::tree_sitter::Node<'tree>,
10495 src: &'tree [u8],
10496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10497 match node.kind() {
10498 "block" => Ok(Self::Block(::std::boxed::Box::new(
10499 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
10500 ))),
10501 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
10502 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
10503 ))),
10504 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
10505 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)?,
10506 ))),
10507 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
10508 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
10509 ))),
10510 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10511 }
10512 }
10513}
10514impl ::treesitter_types::Spanned for SwitchRuleChildren<'_> {
10515 fn span(&self) -> ::treesitter_types::Span {
10516 match self {
10517 Self::Block(inner) => inner.span(),
10518 Self::ExpressionStatement(inner) => inner.span(),
10519 Self::SwitchLabel(inner) => inner.span(),
10520 Self::ThrowStatement(inner) => inner.span(),
10521 }
10522 }
10523}
10524#[derive(Debug, Clone)]
10525pub enum TryStatementChildren<'tree> {
10526 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
10527 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
10528}
10529impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
10530 #[allow(clippy::collapsible_else_if)]
10531 fn from_node(
10532 node: ::tree_sitter::Node<'tree>,
10533 src: &'tree [u8],
10534 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10535 match node.kind() {
10536 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
10537 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10538 ))),
10539 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
10540 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10541 ))),
10542 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10543 }
10544 }
10545}
10546impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
10547 fn span(&self) -> ::treesitter_types::Span {
10548 match self {
10549 Self::CatchClause(inner) => inner.span(),
10550 Self::FinallyClause(inner) => inner.span(),
10551 }
10552 }
10553}
10554#[derive(Debug, Clone)]
10555pub enum TryWithResourcesStatementChildren<'tree> {
10556 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
10557 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
10558}
10559impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatementChildren<'tree> {
10560 #[allow(clippy::collapsible_else_if)]
10561 fn from_node(
10562 node: ::tree_sitter::Node<'tree>,
10563 src: &'tree [u8],
10564 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10565 match node.kind() {
10566 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
10567 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10568 ))),
10569 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
10570 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10571 ))),
10572 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10573 }
10574 }
10575}
10576impl ::treesitter_types::Spanned for TryWithResourcesStatementChildren<'_> {
10577 fn span(&self) -> ::treesitter_types::Span {
10578 match self {
10579 Self::CatchClause(inner) => inner.span(),
10580 Self::FinallyClause(inner) => inner.span(),
10581 }
10582 }
10583}
10584#[derive(Debug, Clone)]
10585pub enum TypeArgumentsChildren<'tree> {
10586 Type(::std::boxed::Box<Type<'tree>>),
10587 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
10588}
10589impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
10590 #[allow(clippy::collapsible_else_if)]
10591 fn from_node(
10592 node: ::tree_sitter::Node<'tree>,
10593 src: &'tree [u8],
10594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10595 match node.kind() {
10596 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
10597 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
10598 ))),
10599 _other => {
10600 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10601 Ok(Self::Type(::std::boxed::Box::new(v)))
10602 } else {
10603 Err(::treesitter_types::ParseError::unexpected_kind(
10604 _other, node,
10605 ))
10606 }
10607 }
10608 }
10609 }
10610}
10611impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
10612 fn span(&self) -> ::treesitter_types::Span {
10613 match self {
10614 Self::Type(inner) => inner.span(),
10615 Self::Wildcard(inner) => inner.span(),
10616 }
10617 }
10618}
10619#[derive(Debug, Clone)]
10620pub enum TypeParameterChildren<'tree> {
10621 Annotation(::std::boxed::Box<Annotation<'tree>>),
10622 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10623 TypeBound(::std::boxed::Box<TypeBound<'tree>>),
10624 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10625}
10626impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterChildren<'tree> {
10627 #[allow(clippy::collapsible_else_if)]
10628 fn from_node(
10629 node: ::tree_sitter::Node<'tree>,
10630 src: &'tree [u8],
10631 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10632 match node.kind() {
10633 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10634 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10635 ))),
10636 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10637 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10638 ))),
10639 "type_bound" => Ok(Self::TypeBound(::std::boxed::Box::new(
10640 <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)?,
10641 ))),
10642 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10643 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10644 ))),
10645 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10646 }
10647 }
10648}
10649impl ::treesitter_types::Spanned for TypeParameterChildren<'_> {
10650 fn span(&self) -> ::treesitter_types::Span {
10651 match self {
10652 Self::Annotation(inner) => inner.span(),
10653 Self::MarkerAnnotation(inner) => inner.span(),
10654 Self::TypeBound(inner) => inner.span(),
10655 Self::TypeIdentifier(inner) => inner.span(),
10656 }
10657 }
10658}
10659#[derive(Debug, Clone)]
10660pub enum TypePatternChildren<'tree> {
10661 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
10662 Identifier(::std::boxed::Box<Identifier<'tree>>),
10663}
10664impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatternChildren<'tree> {
10665 #[allow(clippy::collapsible_else_if)]
10666 fn from_node(
10667 node: ::tree_sitter::Node<'tree>,
10668 src: &'tree [u8],
10669 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10670 match node.kind() {
10671 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10672 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10673 ))),
10674 _other => {
10675 if let Ok(v) =
10676 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
10677 {
10678 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
10679 } else {
10680 Err(::treesitter_types::ParseError::unexpected_kind(
10681 _other, node,
10682 ))
10683 }
10684 }
10685 }
10686 }
10687}
10688impl ::treesitter_types::Spanned for TypePatternChildren<'_> {
10689 fn span(&self) -> ::treesitter_types::Span {
10690 match self {
10691 Self::UnannotatedType(inner) => inner.span(),
10692 Self::Identifier(inner) => inner.span(),
10693 }
10694 }
10695}
10696#[derive(Debug, Clone)]
10697pub enum UnaryExpressionOperator {
10698 Bang(::treesitter_types::Span),
10699 Plus(::treesitter_types::Span),
10700 Minus(::treesitter_types::Span),
10701 Tilde(::treesitter_types::Span),
10702}
10703impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
10704 #[allow(clippy::collapsible_else_if)]
10705 fn from_node(
10706 node: ::tree_sitter::Node<'tree>,
10707 _src: &'tree [u8],
10708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10709 match node.kind() {
10710 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
10711 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10712 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10713 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
10714 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10715 }
10716 }
10717}
10718impl ::treesitter_types::Spanned for UnaryExpressionOperator {
10719 fn span(&self) -> ::treesitter_types::Span {
10720 match self {
10721 Self::Bang(span) => *span,
10722 Self::Plus(span) => *span,
10723 Self::Minus(span) => *span,
10724 Self::Tilde(span) => *span,
10725 }
10726 }
10727}
10728#[derive(Debug, Clone)]
10729pub enum UsesModuleDirectiveType<'tree> {
10730 Identifier(::std::boxed::Box<Identifier<'tree>>),
10731 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10732}
10733impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirectiveType<'tree> {
10734 #[allow(clippy::collapsible_else_if)]
10735 fn from_node(
10736 node: ::tree_sitter::Node<'tree>,
10737 src: &'tree [u8],
10738 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10739 match node.kind() {
10740 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10741 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10742 ))),
10743 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10744 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10745 ))),
10746 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10747 }
10748 }
10749}
10750impl ::treesitter_types::Spanned for UsesModuleDirectiveType<'_> {
10751 fn span(&self) -> ::treesitter_types::Span {
10752 match self {
10753 Self::Identifier(inner) => inner.span(),
10754 Self::ScopedIdentifier(inner) => inner.span(),
10755 }
10756 }
10757}
10758#[derive(Debug, Clone)]
10759pub enum VariableDeclaratorName<'tree> {
10760 Identifier(::std::boxed::Box<Identifier<'tree>>),
10761 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10762}
10763impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
10764 #[allow(clippy::collapsible_else_if)]
10765 fn from_node(
10766 node: ::tree_sitter::Node<'tree>,
10767 src: &'tree [u8],
10768 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10769 match node.kind() {
10770 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10771 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10772 ))),
10773 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10774 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10775 ))),
10776 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10777 }
10778 }
10779}
10780impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
10781 fn span(&self) -> ::treesitter_types::Span {
10782 match self {
10783 Self::Identifier(inner) => inner.span(),
10784 Self::UnderscorePattern(inner) => inner.span(),
10785 }
10786 }
10787}
10788#[derive(Debug, Clone)]
10789pub enum VariableDeclaratorValue<'tree> {
10790 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
10791 Expression(::std::boxed::Box<Expression<'tree>>),
10792}
10793impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorValue<'tree> {
10794 #[allow(clippy::collapsible_else_if)]
10795 fn from_node(
10796 node: ::tree_sitter::Node<'tree>,
10797 src: &'tree [u8],
10798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10799 match node.kind() {
10800 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
10801 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
10802 ))),
10803 _other => {
10804 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10805 Ok(Self::Expression(::std::boxed::Box::new(v)))
10806 } else {
10807 Err(::treesitter_types::ParseError::unexpected_kind(
10808 _other, node,
10809 ))
10810 }
10811 }
10812 }
10813 }
10814}
10815impl ::treesitter_types::Spanned for VariableDeclaratorValue<'_> {
10816 fn span(&self) -> ::treesitter_types::Span {
10817 match self {
10818 Self::ArrayInitializer(inner) => inner.span(),
10819 Self::Expression(inner) => inner.span(),
10820 }
10821 }
10822}
10823#[derive(Debug, Clone)]
10824pub enum WildcardChildren<'tree> {
10825 Type(::std::boxed::Box<Type<'tree>>),
10826 Annotation(::std::boxed::Box<Annotation<'tree>>),
10827 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10828 Super(::std::boxed::Box<Super<'tree>>),
10829}
10830impl<'tree> ::treesitter_types::FromNode<'tree> for WildcardChildren<'tree> {
10831 #[allow(clippy::collapsible_else_if)]
10832 fn from_node(
10833 node: ::tree_sitter::Node<'tree>,
10834 src: &'tree [u8],
10835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10836 match node.kind() {
10837 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10838 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10839 ))),
10840 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10841 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10842 ))),
10843 "super" => Ok(Self::Super(::std::boxed::Box::new(
10844 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10845 ))),
10846 _other => {
10847 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10848 Ok(Self::Type(::std::boxed::Box::new(v)))
10849 } else {
10850 Err(::treesitter_types::ParseError::unexpected_kind(
10851 _other, node,
10852 ))
10853 }
10854 }
10855 }
10856 }
10857}
10858impl ::treesitter_types::Spanned for WildcardChildren<'_> {
10859 fn span(&self) -> ::treesitter_types::Span {
10860 match self {
10861 Self::Type(inner) => inner.span(),
10862 Self::Annotation(inner) => inner.span(),
10863 Self::MarkerAnnotation(inner) => inner.span(),
10864 Self::Super(inner) => inner.span(),
10865 }
10866 }
10867}
10868#[derive(Debug, Clone)]
10869pub enum AnyNode<'tree> {
10870 Literal(Literal<'tree>),
10871 SimpleType(SimpleType<'tree>),
10872 Type(Type<'tree>),
10873 UnannotatedType(UnannotatedType<'tree>),
10874 Declaration(Declaration<'tree>),
10875 Expression(Expression<'tree>),
10876 ModuleDirective(ModuleDirective<'tree>),
10877 PrimaryExpression(PrimaryExpression<'tree>),
10878 Statement(Statement<'tree>),
10879 AnnotatedType(AnnotatedType<'tree>),
10880 Annotation(Annotation<'tree>),
10881 AnnotationArgumentList(AnnotationArgumentList<'tree>),
10882 AnnotationTypeBody(AnnotationTypeBody<'tree>),
10883 AnnotationTypeDeclaration(AnnotationTypeDeclaration<'tree>),
10884 AnnotationTypeElementDeclaration(AnnotationTypeElementDeclaration<'tree>),
10885 ArgumentList(ArgumentList<'tree>),
10886 ArrayAccess(ArrayAccess<'tree>),
10887 ArrayCreationExpression(ArrayCreationExpression<'tree>),
10888 ArrayInitializer(ArrayInitializer<'tree>),
10889 ArrayType(ArrayType<'tree>),
10890 AssertStatement(AssertStatement<'tree>),
10891 AssignmentExpression(AssignmentExpression<'tree>),
10892 Asterisk(Asterisk<'tree>),
10893 BinaryExpression(BinaryExpression<'tree>),
10894 Block(Block<'tree>),
10895 BreakStatement(BreakStatement<'tree>),
10896 CastExpression(CastExpression<'tree>),
10897 CatchClause(CatchClause<'tree>),
10898 CatchFormalParameter(CatchFormalParameter<'tree>),
10899 CatchType(CatchType<'tree>),
10900 ClassBody(ClassBody<'tree>),
10901 ClassDeclaration(ClassDeclaration<'tree>),
10902 ClassLiteral(ClassLiteral<'tree>),
10903 CompactConstructorDeclaration(CompactConstructorDeclaration<'tree>),
10904 ConstantDeclaration(ConstantDeclaration<'tree>),
10905 ConstructorBody(ConstructorBody<'tree>),
10906 ConstructorDeclaration(ConstructorDeclaration<'tree>),
10907 ContinueStatement(ContinueStatement<'tree>),
10908 Dimensions(Dimensions<'tree>),
10909 DimensionsExpr(DimensionsExpr<'tree>),
10910 DoStatement(DoStatement<'tree>),
10911 ElementValueArrayInitializer(ElementValueArrayInitializer<'tree>),
10912 ElementValuePair(ElementValuePair<'tree>),
10913 EnhancedForStatement(EnhancedForStatement<'tree>),
10914 EnumBody(EnumBody<'tree>),
10915 EnumBodyDeclarations(EnumBodyDeclarations<'tree>),
10916 EnumConstant(EnumConstant<'tree>),
10917 EnumDeclaration(EnumDeclaration<'tree>),
10918 ExplicitConstructorInvocation(ExplicitConstructorInvocation<'tree>),
10919 ExportsModuleDirective(ExportsModuleDirective<'tree>),
10920 ExpressionStatement(ExpressionStatement<'tree>),
10921 ExtendsInterfaces(ExtendsInterfaces<'tree>),
10922 FieldAccess(FieldAccess<'tree>),
10923 FieldDeclaration(FieldDeclaration<'tree>),
10924 FinallyClause(FinallyClause<'tree>),
10925 FloatingPointType(FloatingPointType<'tree>),
10926 ForStatement(ForStatement<'tree>),
10927 FormalParameter(FormalParameter<'tree>),
10928 FormalParameters(FormalParameters<'tree>),
10929 GenericType(GenericType<'tree>),
10930 Guard(Guard<'tree>),
10931 IfStatement(IfStatement<'tree>),
10932 ImportDeclaration(ImportDeclaration<'tree>),
10933 InferredParameters(InferredParameters<'tree>),
10934 InstanceofExpression(InstanceofExpression<'tree>),
10935 IntegralType(IntegralType<'tree>),
10936 InterfaceBody(InterfaceBody<'tree>),
10937 InterfaceDeclaration(InterfaceDeclaration<'tree>),
10938 LabeledStatement(LabeledStatement<'tree>),
10939 LambdaExpression(LambdaExpression<'tree>),
10940 LocalVariableDeclaration(LocalVariableDeclaration<'tree>),
10941 MarkerAnnotation(MarkerAnnotation<'tree>),
10942 MethodDeclaration(MethodDeclaration<'tree>),
10943 MethodInvocation(MethodInvocation<'tree>),
10944 MethodReference(MethodReference<'tree>),
10945 Modifiers(Modifiers<'tree>),
10946 ModuleBody(ModuleBody<'tree>),
10947 ModuleDeclaration(ModuleDeclaration<'tree>),
10948 MultilineStringFragment(MultilineStringFragment<'tree>),
10949 ObjectCreationExpression(ObjectCreationExpression<'tree>),
10950 OpensModuleDirective(OpensModuleDirective<'tree>),
10951 PackageDeclaration(PackageDeclaration<'tree>),
10952 ParenthesizedExpression(ParenthesizedExpression<'tree>),
10953 Pattern(Pattern<'tree>),
10954 Permits(Permits<'tree>),
10955 Program(Program<'tree>),
10956 ProvidesModuleDirective(ProvidesModuleDirective<'tree>),
10957 ReceiverParameter(ReceiverParameter<'tree>),
10958 RecordDeclaration(RecordDeclaration<'tree>),
10959 RecordPattern(RecordPattern<'tree>),
10960 RecordPatternBody(RecordPatternBody<'tree>),
10961 RecordPatternComponent(RecordPatternComponent<'tree>),
10962 RequiresModifier(RequiresModifier<'tree>),
10963 RequiresModuleDirective(RequiresModuleDirective<'tree>),
10964 Resource(Resource<'tree>),
10965 ResourceSpecification(ResourceSpecification<'tree>),
10966 ReturnStatement(ReturnStatement<'tree>),
10967 ScopedIdentifier(ScopedIdentifier<'tree>),
10968 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
10969 SpreadParameter(SpreadParameter<'tree>),
10970 StaticInitializer(StaticInitializer<'tree>),
10971 StringInterpolation(StringInterpolation<'tree>),
10972 StringLiteral(StringLiteral<'tree>),
10973 SuperInterfaces(SuperInterfaces<'tree>),
10974 Superclass(Superclass<'tree>),
10975 SwitchBlock(SwitchBlock<'tree>),
10976 SwitchBlockStatementGroup(SwitchBlockStatementGroup<'tree>),
10977 SwitchExpression(SwitchExpression<'tree>),
10978 SwitchLabel(SwitchLabel<'tree>),
10979 SwitchRule(SwitchRule<'tree>),
10980 SynchronizedStatement(SynchronizedStatement<'tree>),
10981 TemplateExpression(TemplateExpression<'tree>),
10982 TernaryExpression(TernaryExpression<'tree>),
10983 ThrowStatement(ThrowStatement<'tree>),
10984 Throws(Throws<'tree>),
10985 TryStatement(TryStatement<'tree>),
10986 TryWithResourcesStatement(TryWithResourcesStatement<'tree>),
10987 TypeArguments(TypeArguments<'tree>),
10988 TypeBound(TypeBound<'tree>),
10989 TypeList(TypeList<'tree>),
10990 TypeParameter(TypeParameter<'tree>),
10991 TypeParameters(TypeParameters<'tree>),
10992 TypePattern(TypePattern<'tree>),
10993 UnaryExpression(UnaryExpression<'tree>),
10994 UpdateExpression(UpdateExpression<'tree>),
10995 UsesModuleDirective(UsesModuleDirective<'tree>),
10996 VariableDeclarator(VariableDeclarator<'tree>),
10997 WhileStatement(WhileStatement<'tree>),
10998 Wildcard(Wildcard<'tree>),
10999 YieldStatement(YieldStatement<'tree>),
11000 BinaryIntegerLiteral(BinaryIntegerLiteral<'tree>),
11001 BlockComment(BlockComment<'tree>),
11002 BooleanType(BooleanType<'tree>),
11003 CharacterLiteral(CharacterLiteral<'tree>),
11004 DecimalFloatingPointLiteral(DecimalFloatingPointLiteral<'tree>),
11005 DecimalIntegerLiteral(DecimalIntegerLiteral<'tree>),
11006 EscapeSequence(EscapeSequence<'tree>),
11007 False(False<'tree>),
11008 HexFloatingPointLiteral(HexFloatingPointLiteral<'tree>),
11009 HexIntegerLiteral(HexIntegerLiteral<'tree>),
11010 Identifier(Identifier<'tree>),
11011 LineComment(LineComment<'tree>),
11012 NullLiteral(NullLiteral<'tree>),
11013 OctalIntegerLiteral(OctalIntegerLiteral<'tree>),
11014 StringFragment(StringFragment<'tree>),
11015 Super(Super<'tree>),
11016 This(This<'tree>),
11017 True(True<'tree>),
11018 TypeIdentifier(TypeIdentifier<'tree>),
11019 UnderscorePattern(UnderscorePattern<'tree>),
11020 VoidType(VoidType<'tree>),
11021 Unknown(::tree_sitter::Node<'tree>),
11022}
11023impl<'tree> AnyNode<'tree> {
11024 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
11025 match node.kind() {
11026 "_literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
11027 .map(Self::Literal)
11028 .unwrap_or(Self::Unknown(node)),
11029 "_simple_type" => <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
11030 .map(Self::SimpleType)
11031 .unwrap_or(Self::Unknown(node)),
11032 "_type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
11033 .map(Self::Type)
11034 .unwrap_or(Self::Unknown(node)),
11035 "_unannotated_type" => {
11036 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11037 .map(Self::UnannotatedType)
11038 .unwrap_or(Self::Unknown(node))
11039 }
11040 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
11041 .map(Self::Declaration)
11042 .unwrap_or(Self::Unknown(node)),
11043 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11044 .map(Self::Expression)
11045 .unwrap_or(Self::Unknown(node)),
11046 "module_directive" => {
11047 <ModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11048 .map(Self::ModuleDirective)
11049 .unwrap_or(Self::Unknown(node))
11050 }
11051 "primary_expression" => {
11052 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11053 .map(Self::PrimaryExpression)
11054 .unwrap_or(Self::Unknown(node))
11055 }
11056 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11057 .map(Self::Statement)
11058 .unwrap_or(Self::Unknown(node)),
11059 "annotated_type" => {
11060 <AnnotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11061 .map(Self::AnnotatedType)
11062 .unwrap_or(Self::Unknown(node))
11063 }
11064 "annotation" => <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11065 .map(Self::Annotation)
11066 .unwrap_or(Self::Unknown(node)),
11067 "annotation_argument_list" => {
11068 <AnnotationArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
11069 .map(Self::AnnotationArgumentList)
11070 .unwrap_or(Self::Unknown(node))
11071 }
11072 "annotation_type_body" => {
11073 <AnnotationTypeBody as ::treesitter_types::FromNode>::from_node(node, src)
11074 .map(Self::AnnotationTypeBody)
11075 .unwrap_or(Self::Unknown(node))
11076 }
11077 "annotation_type_declaration" => {
11078 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11079 .map(Self::AnnotationTypeDeclaration)
11080 .unwrap_or(Self::Unknown(node))
11081 }
11082 "annotation_type_element_declaration" => {
11083 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
11084 node, src,
11085 )
11086 .map(Self::AnnotationTypeElementDeclaration)
11087 .unwrap_or(Self::Unknown(node))
11088 }
11089 "argument_list" => <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
11090 .map(Self::ArgumentList)
11091 .unwrap_or(Self::Unknown(node)),
11092 "array_access" => <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)
11093 .map(Self::ArrayAccess)
11094 .unwrap_or(Self::Unknown(node)),
11095 "array_creation_expression" => {
11096 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
11097 .map(Self::ArrayCreationExpression)
11098 .unwrap_or(Self::Unknown(node))
11099 }
11100 "array_initializer" => {
11101 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11102 .map(Self::ArrayInitializer)
11103 .unwrap_or(Self::Unknown(node))
11104 }
11105 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
11106 .map(Self::ArrayType)
11107 .unwrap_or(Self::Unknown(node)),
11108 "assert_statement" => {
11109 <AssertStatement as ::treesitter_types::FromNode>::from_node(node, src)
11110 .map(Self::AssertStatement)
11111 .unwrap_or(Self::Unknown(node))
11112 }
11113 "assignment_expression" => {
11114 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
11115 .map(Self::AssignmentExpression)
11116 .unwrap_or(Self::Unknown(node))
11117 }
11118 "asterisk" => <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)
11119 .map(Self::Asterisk)
11120 .unwrap_or(Self::Unknown(node)),
11121 "binary_expression" => {
11122 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11123 .map(Self::BinaryExpression)
11124 .unwrap_or(Self::Unknown(node))
11125 }
11126 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
11127 .map(Self::Block)
11128 .unwrap_or(Self::Unknown(node)),
11129 "break_statement" => {
11130 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
11131 .map(Self::BreakStatement)
11132 .unwrap_or(Self::Unknown(node))
11133 }
11134 "cast_expression" => {
11135 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
11136 .map(Self::CastExpression)
11137 .unwrap_or(Self::Unknown(node))
11138 }
11139 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
11140 .map(Self::CatchClause)
11141 .unwrap_or(Self::Unknown(node)),
11142 "catch_formal_parameter" => {
11143 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
11144 .map(Self::CatchFormalParameter)
11145 .unwrap_or(Self::Unknown(node))
11146 }
11147 "catch_type" => <CatchType as ::treesitter_types::FromNode>::from_node(node, src)
11148 .map(Self::CatchType)
11149 .unwrap_or(Self::Unknown(node)),
11150 "class_body" => <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
11151 .map(Self::ClassBody)
11152 .unwrap_or(Self::Unknown(node)),
11153 "class_declaration" => {
11154 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11155 .map(Self::ClassDeclaration)
11156 .unwrap_or(Self::Unknown(node))
11157 }
11158 "class_literal" => <ClassLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11159 .map(Self::ClassLiteral)
11160 .unwrap_or(Self::Unknown(node)),
11161 "compact_constructor_declaration" => {
11162 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
11163 node, src,
11164 )
11165 .map(Self::CompactConstructorDeclaration)
11166 .unwrap_or(Self::Unknown(node))
11167 }
11168 "constant_declaration" => {
11169 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11170 .map(Self::ConstantDeclaration)
11171 .unwrap_or(Self::Unknown(node))
11172 }
11173 "constructor_body" => {
11174 <ConstructorBody as ::treesitter_types::FromNode>::from_node(node, src)
11175 .map(Self::ConstructorBody)
11176 .unwrap_or(Self::Unknown(node))
11177 }
11178 "constructor_declaration" => {
11179 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11180 .map(Self::ConstructorDeclaration)
11181 .unwrap_or(Self::Unknown(node))
11182 }
11183 "continue_statement" => {
11184 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
11185 .map(Self::ContinueStatement)
11186 .unwrap_or(Self::Unknown(node))
11187 }
11188 "dimensions" => <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)
11189 .map(Self::Dimensions)
11190 .unwrap_or(Self::Unknown(node)),
11191 "dimensions_expr" => {
11192 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)
11193 .map(Self::DimensionsExpr)
11194 .unwrap_or(Self::Unknown(node))
11195 }
11196 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
11197 .map(Self::DoStatement)
11198 .unwrap_or(Self::Unknown(node)),
11199 "element_value_array_initializer" => {
11200 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11201 .map(Self::ElementValueArrayInitializer)
11202 .unwrap_or(Self::Unknown(node))
11203 }
11204 "element_value_pair" => {
11205 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)
11206 .map(Self::ElementValuePair)
11207 .unwrap_or(Self::Unknown(node))
11208 }
11209 "enhanced_for_statement" => {
11210 <EnhancedForStatement as ::treesitter_types::FromNode>::from_node(node, src)
11211 .map(Self::EnhancedForStatement)
11212 .unwrap_or(Self::Unknown(node))
11213 }
11214 "enum_body" => <EnumBody as ::treesitter_types::FromNode>::from_node(node, src)
11215 .map(Self::EnumBody)
11216 .unwrap_or(Self::Unknown(node)),
11217 "enum_body_declarations" => {
11218 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
11219 .map(Self::EnumBodyDeclarations)
11220 .unwrap_or(Self::Unknown(node))
11221 }
11222 "enum_constant" => <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)
11223 .map(Self::EnumConstant)
11224 .unwrap_or(Self::Unknown(node)),
11225 "enum_declaration" => {
11226 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11227 .map(Self::EnumDeclaration)
11228 .unwrap_or(Self::Unknown(node))
11229 }
11230 "explicit_constructor_invocation" => {
11231 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
11232 node, src,
11233 )
11234 .map(Self::ExplicitConstructorInvocation)
11235 .unwrap_or(Self::Unknown(node))
11236 }
11237 "exports_module_directive" => {
11238 <ExportsModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11239 .map(Self::ExportsModuleDirective)
11240 .unwrap_or(Self::Unknown(node))
11241 }
11242 "expression_statement" => {
11243 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
11244 .map(Self::ExpressionStatement)
11245 .unwrap_or(Self::Unknown(node))
11246 }
11247 "extends_interfaces" => {
11248 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
11249 .map(Self::ExtendsInterfaces)
11250 .unwrap_or(Self::Unknown(node))
11251 }
11252 "field_access" => <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
11253 .map(Self::FieldAccess)
11254 .unwrap_or(Self::Unknown(node)),
11255 "field_declaration" => {
11256 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11257 .map(Self::FieldDeclaration)
11258 .unwrap_or(Self::Unknown(node))
11259 }
11260 "finally_clause" => {
11261 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
11262 .map(Self::FinallyClause)
11263 .unwrap_or(Self::Unknown(node))
11264 }
11265 "floating_point_type" => {
11266 <FloatingPointType as ::treesitter_types::FromNode>::from_node(node, src)
11267 .map(Self::FloatingPointType)
11268 .unwrap_or(Self::Unknown(node))
11269 }
11270 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
11271 .map(Self::ForStatement)
11272 .unwrap_or(Self::Unknown(node)),
11273 "formal_parameter" => {
11274 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
11275 .map(Self::FormalParameter)
11276 .unwrap_or(Self::Unknown(node))
11277 }
11278 "formal_parameters" => {
11279 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
11280 .map(Self::FormalParameters)
11281 .unwrap_or(Self::Unknown(node))
11282 }
11283 "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
11284 .map(Self::GenericType)
11285 .unwrap_or(Self::Unknown(node)),
11286 "guard" => <Guard as ::treesitter_types::FromNode>::from_node(node, src)
11287 .map(Self::Guard)
11288 .unwrap_or(Self::Unknown(node)),
11289 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
11290 .map(Self::IfStatement)
11291 .unwrap_or(Self::Unknown(node)),
11292 "import_declaration" => {
11293 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11294 .map(Self::ImportDeclaration)
11295 .unwrap_or(Self::Unknown(node))
11296 }
11297 "inferred_parameters" => {
11298 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)
11299 .map(Self::InferredParameters)
11300 .unwrap_or(Self::Unknown(node))
11301 }
11302 "instanceof_expression" => {
11303 <InstanceofExpression as ::treesitter_types::FromNode>::from_node(node, src)
11304 .map(Self::InstanceofExpression)
11305 .unwrap_or(Self::Unknown(node))
11306 }
11307 "integral_type" => <IntegralType as ::treesitter_types::FromNode>::from_node(node, src)
11308 .map(Self::IntegralType)
11309 .unwrap_or(Self::Unknown(node)),
11310 "interface_body" => {
11311 <InterfaceBody as ::treesitter_types::FromNode>::from_node(node, src)
11312 .map(Self::InterfaceBody)
11313 .unwrap_or(Self::Unknown(node))
11314 }
11315 "interface_declaration" => {
11316 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11317 .map(Self::InterfaceDeclaration)
11318 .unwrap_or(Self::Unknown(node))
11319 }
11320 "labeled_statement" => {
11321 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
11322 .map(Self::LabeledStatement)
11323 .unwrap_or(Self::Unknown(node))
11324 }
11325 "lambda_expression" => {
11326 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
11327 .map(Self::LambdaExpression)
11328 .unwrap_or(Self::Unknown(node))
11329 }
11330 "local_variable_declaration" => {
11331 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11332 .map(Self::LocalVariableDeclaration)
11333 .unwrap_or(Self::Unknown(node))
11334 }
11335 "marker_annotation" => {
11336 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
11337 .map(Self::MarkerAnnotation)
11338 .unwrap_or(Self::Unknown(node))
11339 }
11340 "method_declaration" => {
11341 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11342 .map(Self::MethodDeclaration)
11343 .unwrap_or(Self::Unknown(node))
11344 }
11345 "method_invocation" => {
11346 <MethodInvocation as ::treesitter_types::FromNode>::from_node(node, src)
11347 .map(Self::MethodInvocation)
11348 .unwrap_or(Self::Unknown(node))
11349 }
11350 "method_reference" => {
11351 <MethodReference as ::treesitter_types::FromNode>::from_node(node, src)
11352 .map(Self::MethodReference)
11353 .unwrap_or(Self::Unknown(node))
11354 }
11355 "modifiers" => <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
11356 .map(Self::Modifiers)
11357 .unwrap_or(Self::Unknown(node)),
11358 "module_body" => <ModuleBody as ::treesitter_types::FromNode>::from_node(node, src)
11359 .map(Self::ModuleBody)
11360 .unwrap_or(Self::Unknown(node)),
11361 "module_declaration" => {
11362 <ModuleDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11363 .map(Self::ModuleDeclaration)
11364 .unwrap_or(Self::Unknown(node))
11365 }
11366 "multiline_string_fragment" => {
11367 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(node, src)
11368 .map(Self::MultilineStringFragment)
11369 .unwrap_or(Self::Unknown(node))
11370 }
11371 "object_creation_expression" => {
11372 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
11373 .map(Self::ObjectCreationExpression)
11374 .unwrap_or(Self::Unknown(node))
11375 }
11376 "opens_module_directive" => {
11377 <OpensModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11378 .map(Self::OpensModuleDirective)
11379 .unwrap_or(Self::Unknown(node))
11380 }
11381 "package_declaration" => {
11382 <PackageDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11383 .map(Self::PackageDeclaration)
11384 .unwrap_or(Self::Unknown(node))
11385 }
11386 "parenthesized_expression" => {
11387 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
11388 .map(Self::ParenthesizedExpression)
11389 .unwrap_or(Self::Unknown(node))
11390 }
11391 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
11392 .map(Self::Pattern)
11393 .unwrap_or(Self::Unknown(node)),
11394 "permits" => <Permits as ::treesitter_types::FromNode>::from_node(node, src)
11395 .map(Self::Permits)
11396 .unwrap_or(Self::Unknown(node)),
11397 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
11398 .map(Self::Program)
11399 .unwrap_or(Self::Unknown(node)),
11400 "provides_module_directive" => {
11401 <ProvidesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11402 .map(Self::ProvidesModuleDirective)
11403 .unwrap_or(Self::Unknown(node))
11404 }
11405 "receiver_parameter" => {
11406 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)
11407 .map(Self::ReceiverParameter)
11408 .unwrap_or(Self::Unknown(node))
11409 }
11410 "record_declaration" => {
11411 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11412 .map(Self::RecordDeclaration)
11413 .unwrap_or(Self::Unknown(node))
11414 }
11415 "record_pattern" => {
11416 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)
11417 .map(Self::RecordPattern)
11418 .unwrap_or(Self::Unknown(node))
11419 }
11420 "record_pattern_body" => {
11421 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)
11422 .map(Self::RecordPatternBody)
11423 .unwrap_or(Self::Unknown(node))
11424 }
11425 "record_pattern_component" => {
11426 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)
11427 .map(Self::RecordPatternComponent)
11428 .unwrap_or(Self::Unknown(node))
11429 }
11430 "requires_modifier" => {
11431 <RequiresModifier as ::treesitter_types::FromNode>::from_node(node, src)
11432 .map(Self::RequiresModifier)
11433 .unwrap_or(Self::Unknown(node))
11434 }
11435 "requires_module_directive" => {
11436 <RequiresModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11437 .map(Self::RequiresModuleDirective)
11438 .unwrap_or(Self::Unknown(node))
11439 }
11440 "resource" => <Resource as ::treesitter_types::FromNode>::from_node(node, src)
11441 .map(Self::Resource)
11442 .unwrap_or(Self::Unknown(node)),
11443 "resource_specification" => {
11444 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(node, src)
11445 .map(Self::ResourceSpecification)
11446 .unwrap_or(Self::Unknown(node))
11447 }
11448 "return_statement" => {
11449 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
11450 .map(Self::ReturnStatement)
11451 .unwrap_or(Self::Unknown(node))
11452 }
11453 "scoped_identifier" => {
11454 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11455 .map(Self::ScopedIdentifier)
11456 .unwrap_or(Self::Unknown(node))
11457 }
11458 "scoped_type_identifier" => {
11459 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11460 .map(Self::ScopedTypeIdentifier)
11461 .unwrap_or(Self::Unknown(node))
11462 }
11463 "spread_parameter" => {
11464 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)
11465 .map(Self::SpreadParameter)
11466 .unwrap_or(Self::Unknown(node))
11467 }
11468 "static_initializer" => {
11469 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11470 .map(Self::StaticInitializer)
11471 .unwrap_or(Self::Unknown(node))
11472 }
11473 "string_interpolation" => {
11474 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
11475 .map(Self::StringInterpolation)
11476 .unwrap_or(Self::Unknown(node))
11477 }
11478 "string_literal" => {
11479 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11480 .map(Self::StringLiteral)
11481 .unwrap_or(Self::Unknown(node))
11482 }
11483 "super_interfaces" => {
11484 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
11485 .map(Self::SuperInterfaces)
11486 .unwrap_or(Self::Unknown(node))
11487 }
11488 "superclass" => <Superclass as ::treesitter_types::FromNode>::from_node(node, src)
11489 .map(Self::Superclass)
11490 .unwrap_or(Self::Unknown(node)),
11491 "switch_block" => <SwitchBlock as ::treesitter_types::FromNode>::from_node(node, src)
11492 .map(Self::SwitchBlock)
11493 .unwrap_or(Self::Unknown(node)),
11494 "switch_block_statement_group" => {
11495 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(node, src)
11496 .map(Self::SwitchBlockStatementGroup)
11497 .unwrap_or(Self::Unknown(node))
11498 }
11499 "switch_expression" => {
11500 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
11501 .map(Self::SwitchExpression)
11502 .unwrap_or(Self::Unknown(node))
11503 }
11504 "switch_label" => <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)
11505 .map(Self::SwitchLabel)
11506 .unwrap_or(Self::Unknown(node)),
11507 "switch_rule" => <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)
11508 .map(Self::SwitchRule)
11509 .unwrap_or(Self::Unknown(node)),
11510 "synchronized_statement" => {
11511 <SynchronizedStatement as ::treesitter_types::FromNode>::from_node(node, src)
11512 .map(Self::SynchronizedStatement)
11513 .unwrap_or(Self::Unknown(node))
11514 }
11515 "template_expression" => {
11516 <TemplateExpression as ::treesitter_types::FromNode>::from_node(node, src)
11517 .map(Self::TemplateExpression)
11518 .unwrap_or(Self::Unknown(node))
11519 }
11520 "ternary_expression" => {
11521 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11522 .map(Self::TernaryExpression)
11523 .unwrap_or(Self::Unknown(node))
11524 }
11525 "throw_statement" => {
11526 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
11527 .map(Self::ThrowStatement)
11528 .unwrap_or(Self::Unknown(node))
11529 }
11530 "throws" => <Throws as ::treesitter_types::FromNode>::from_node(node, src)
11531 .map(Self::Throws)
11532 .unwrap_or(Self::Unknown(node)),
11533 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
11534 .map(Self::TryStatement)
11535 .unwrap_or(Self::Unknown(node)),
11536 "try_with_resources_statement" => {
11537 <TryWithResourcesStatement as ::treesitter_types::FromNode>::from_node(node, src)
11538 .map(Self::TryWithResourcesStatement)
11539 .unwrap_or(Self::Unknown(node))
11540 }
11541 "type_arguments" => {
11542 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
11543 .map(Self::TypeArguments)
11544 .unwrap_or(Self::Unknown(node))
11545 }
11546 "type_bound" => <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)
11547 .map(Self::TypeBound)
11548 .unwrap_or(Self::Unknown(node)),
11549 "type_list" => <TypeList as ::treesitter_types::FromNode>::from_node(node, src)
11550 .map(Self::TypeList)
11551 .unwrap_or(Self::Unknown(node)),
11552 "type_parameter" => {
11553 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
11554 .map(Self::TypeParameter)
11555 .unwrap_or(Self::Unknown(node))
11556 }
11557 "type_parameters" => {
11558 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
11559 .map(Self::TypeParameters)
11560 .unwrap_or(Self::Unknown(node))
11561 }
11562 "type_pattern" => <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
11563 .map(Self::TypePattern)
11564 .unwrap_or(Self::Unknown(node)),
11565 "unary_expression" => {
11566 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11567 .map(Self::UnaryExpression)
11568 .unwrap_or(Self::Unknown(node))
11569 }
11570 "update_expression" => {
11571 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
11572 .map(Self::UpdateExpression)
11573 .unwrap_or(Self::Unknown(node))
11574 }
11575 "uses_module_directive" => {
11576 <UsesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11577 .map(Self::UsesModuleDirective)
11578 .unwrap_or(Self::Unknown(node))
11579 }
11580 "variable_declarator" => {
11581 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11582 .map(Self::VariableDeclarator)
11583 .unwrap_or(Self::Unknown(node))
11584 }
11585 "while_statement" => {
11586 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
11587 .map(Self::WhileStatement)
11588 .unwrap_or(Self::Unknown(node))
11589 }
11590 "wildcard" => <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
11591 .map(Self::Wildcard)
11592 .unwrap_or(Self::Unknown(node)),
11593 "yield_statement" => {
11594 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
11595 .map(Self::YieldStatement)
11596 .unwrap_or(Self::Unknown(node))
11597 }
11598 "binary_integer_literal" => {
11599 <BinaryIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11600 .map(Self::BinaryIntegerLiteral)
11601 .unwrap_or(Self::Unknown(node))
11602 }
11603 "block_comment" => <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
11604 .map(Self::BlockComment)
11605 .unwrap_or(Self::Unknown(node)),
11606 "boolean_type" => <BooleanType as ::treesitter_types::FromNode>::from_node(node, src)
11607 .map(Self::BooleanType)
11608 .unwrap_or(Self::Unknown(node)),
11609 "character_literal" => {
11610 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11611 .map(Self::CharacterLiteral)
11612 .unwrap_or(Self::Unknown(node))
11613 }
11614 "decimal_floating_point_literal" => {
11615 <DecimalFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11616 .map(Self::DecimalFloatingPointLiteral)
11617 .unwrap_or(Self::Unknown(node))
11618 }
11619 "decimal_integer_literal" => {
11620 <DecimalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11621 .map(Self::DecimalIntegerLiteral)
11622 .unwrap_or(Self::Unknown(node))
11623 }
11624 "escape_sequence" => {
11625 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
11626 .map(Self::EscapeSequence)
11627 .unwrap_or(Self::Unknown(node))
11628 }
11629 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
11630 .map(Self::False)
11631 .unwrap_or(Self::Unknown(node)),
11632 "hex_floating_point_literal" => {
11633 <HexFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11634 .map(Self::HexFloatingPointLiteral)
11635 .unwrap_or(Self::Unknown(node))
11636 }
11637 "hex_integer_literal" => {
11638 <HexIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11639 .map(Self::HexIntegerLiteral)
11640 .unwrap_or(Self::Unknown(node))
11641 }
11642 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11643 .map(Self::Identifier)
11644 .unwrap_or(Self::Unknown(node)),
11645 "line_comment" => <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
11646 .map(Self::LineComment)
11647 .unwrap_or(Self::Unknown(node)),
11648 "null_literal" => <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11649 .map(Self::NullLiteral)
11650 .unwrap_or(Self::Unknown(node)),
11651 "octal_integer_literal" => {
11652 <OctalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11653 .map(Self::OctalIntegerLiteral)
11654 .unwrap_or(Self::Unknown(node))
11655 }
11656 "string_fragment" => {
11657 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
11658 .map(Self::StringFragment)
11659 .unwrap_or(Self::Unknown(node))
11660 }
11661 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
11662 .map(Self::Super)
11663 .unwrap_or(Self::Unknown(node)),
11664 "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
11665 .map(Self::This)
11666 .unwrap_or(Self::Unknown(node)),
11667 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
11668 .map(Self::True)
11669 .unwrap_or(Self::Unknown(node)),
11670 "type_identifier" => {
11671 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11672 .map(Self::TypeIdentifier)
11673 .unwrap_or(Self::Unknown(node))
11674 }
11675 "underscore_pattern" => {
11676 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
11677 .map(Self::UnderscorePattern)
11678 .unwrap_or(Self::Unknown(node))
11679 }
11680 "void_type" => <VoidType as ::treesitter_types::FromNode>::from_node(node, src)
11681 .map(Self::VoidType)
11682 .unwrap_or(Self::Unknown(node)),
11683 _ => Self::Unknown(node),
11684 }
11685 }
11686}
11687impl ::treesitter_types::Spanned for AnyNode<'_> {
11688 fn span(&self) -> ::treesitter_types::Span {
11689 match self {
11690 Self::Literal(inner) => inner.span(),
11691 Self::SimpleType(inner) => inner.span(),
11692 Self::Type(inner) => inner.span(),
11693 Self::UnannotatedType(inner) => inner.span(),
11694 Self::Declaration(inner) => inner.span(),
11695 Self::Expression(inner) => inner.span(),
11696 Self::ModuleDirective(inner) => inner.span(),
11697 Self::PrimaryExpression(inner) => inner.span(),
11698 Self::Statement(inner) => inner.span(),
11699 Self::AnnotatedType(inner) => inner.span(),
11700 Self::Annotation(inner) => inner.span(),
11701 Self::AnnotationArgumentList(inner) => inner.span(),
11702 Self::AnnotationTypeBody(inner) => inner.span(),
11703 Self::AnnotationTypeDeclaration(inner) => inner.span(),
11704 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
11705 Self::ArgumentList(inner) => inner.span(),
11706 Self::ArrayAccess(inner) => inner.span(),
11707 Self::ArrayCreationExpression(inner) => inner.span(),
11708 Self::ArrayInitializer(inner) => inner.span(),
11709 Self::ArrayType(inner) => inner.span(),
11710 Self::AssertStatement(inner) => inner.span(),
11711 Self::AssignmentExpression(inner) => inner.span(),
11712 Self::Asterisk(inner) => inner.span(),
11713 Self::BinaryExpression(inner) => inner.span(),
11714 Self::Block(inner) => inner.span(),
11715 Self::BreakStatement(inner) => inner.span(),
11716 Self::CastExpression(inner) => inner.span(),
11717 Self::CatchClause(inner) => inner.span(),
11718 Self::CatchFormalParameter(inner) => inner.span(),
11719 Self::CatchType(inner) => inner.span(),
11720 Self::ClassBody(inner) => inner.span(),
11721 Self::ClassDeclaration(inner) => inner.span(),
11722 Self::ClassLiteral(inner) => inner.span(),
11723 Self::CompactConstructorDeclaration(inner) => inner.span(),
11724 Self::ConstantDeclaration(inner) => inner.span(),
11725 Self::ConstructorBody(inner) => inner.span(),
11726 Self::ConstructorDeclaration(inner) => inner.span(),
11727 Self::ContinueStatement(inner) => inner.span(),
11728 Self::Dimensions(inner) => inner.span(),
11729 Self::DimensionsExpr(inner) => inner.span(),
11730 Self::DoStatement(inner) => inner.span(),
11731 Self::ElementValueArrayInitializer(inner) => inner.span(),
11732 Self::ElementValuePair(inner) => inner.span(),
11733 Self::EnhancedForStatement(inner) => inner.span(),
11734 Self::EnumBody(inner) => inner.span(),
11735 Self::EnumBodyDeclarations(inner) => inner.span(),
11736 Self::EnumConstant(inner) => inner.span(),
11737 Self::EnumDeclaration(inner) => inner.span(),
11738 Self::ExplicitConstructorInvocation(inner) => inner.span(),
11739 Self::ExportsModuleDirective(inner) => inner.span(),
11740 Self::ExpressionStatement(inner) => inner.span(),
11741 Self::ExtendsInterfaces(inner) => inner.span(),
11742 Self::FieldAccess(inner) => inner.span(),
11743 Self::FieldDeclaration(inner) => inner.span(),
11744 Self::FinallyClause(inner) => inner.span(),
11745 Self::FloatingPointType(inner) => inner.span(),
11746 Self::ForStatement(inner) => inner.span(),
11747 Self::FormalParameter(inner) => inner.span(),
11748 Self::FormalParameters(inner) => inner.span(),
11749 Self::GenericType(inner) => inner.span(),
11750 Self::Guard(inner) => inner.span(),
11751 Self::IfStatement(inner) => inner.span(),
11752 Self::ImportDeclaration(inner) => inner.span(),
11753 Self::InferredParameters(inner) => inner.span(),
11754 Self::InstanceofExpression(inner) => inner.span(),
11755 Self::IntegralType(inner) => inner.span(),
11756 Self::InterfaceBody(inner) => inner.span(),
11757 Self::InterfaceDeclaration(inner) => inner.span(),
11758 Self::LabeledStatement(inner) => inner.span(),
11759 Self::LambdaExpression(inner) => inner.span(),
11760 Self::LocalVariableDeclaration(inner) => inner.span(),
11761 Self::MarkerAnnotation(inner) => inner.span(),
11762 Self::MethodDeclaration(inner) => inner.span(),
11763 Self::MethodInvocation(inner) => inner.span(),
11764 Self::MethodReference(inner) => inner.span(),
11765 Self::Modifiers(inner) => inner.span(),
11766 Self::ModuleBody(inner) => inner.span(),
11767 Self::ModuleDeclaration(inner) => inner.span(),
11768 Self::MultilineStringFragment(inner) => inner.span(),
11769 Self::ObjectCreationExpression(inner) => inner.span(),
11770 Self::OpensModuleDirective(inner) => inner.span(),
11771 Self::PackageDeclaration(inner) => inner.span(),
11772 Self::ParenthesizedExpression(inner) => inner.span(),
11773 Self::Pattern(inner) => inner.span(),
11774 Self::Permits(inner) => inner.span(),
11775 Self::Program(inner) => inner.span(),
11776 Self::ProvidesModuleDirective(inner) => inner.span(),
11777 Self::ReceiverParameter(inner) => inner.span(),
11778 Self::RecordDeclaration(inner) => inner.span(),
11779 Self::RecordPattern(inner) => inner.span(),
11780 Self::RecordPatternBody(inner) => inner.span(),
11781 Self::RecordPatternComponent(inner) => inner.span(),
11782 Self::RequiresModifier(inner) => inner.span(),
11783 Self::RequiresModuleDirective(inner) => inner.span(),
11784 Self::Resource(inner) => inner.span(),
11785 Self::ResourceSpecification(inner) => inner.span(),
11786 Self::ReturnStatement(inner) => inner.span(),
11787 Self::ScopedIdentifier(inner) => inner.span(),
11788 Self::ScopedTypeIdentifier(inner) => inner.span(),
11789 Self::SpreadParameter(inner) => inner.span(),
11790 Self::StaticInitializer(inner) => inner.span(),
11791 Self::StringInterpolation(inner) => inner.span(),
11792 Self::StringLiteral(inner) => inner.span(),
11793 Self::SuperInterfaces(inner) => inner.span(),
11794 Self::Superclass(inner) => inner.span(),
11795 Self::SwitchBlock(inner) => inner.span(),
11796 Self::SwitchBlockStatementGroup(inner) => inner.span(),
11797 Self::SwitchExpression(inner) => inner.span(),
11798 Self::SwitchLabel(inner) => inner.span(),
11799 Self::SwitchRule(inner) => inner.span(),
11800 Self::SynchronizedStatement(inner) => inner.span(),
11801 Self::TemplateExpression(inner) => inner.span(),
11802 Self::TernaryExpression(inner) => inner.span(),
11803 Self::ThrowStatement(inner) => inner.span(),
11804 Self::Throws(inner) => inner.span(),
11805 Self::TryStatement(inner) => inner.span(),
11806 Self::TryWithResourcesStatement(inner) => inner.span(),
11807 Self::TypeArguments(inner) => inner.span(),
11808 Self::TypeBound(inner) => inner.span(),
11809 Self::TypeList(inner) => inner.span(),
11810 Self::TypeParameter(inner) => inner.span(),
11811 Self::TypeParameters(inner) => inner.span(),
11812 Self::TypePattern(inner) => inner.span(),
11813 Self::UnaryExpression(inner) => inner.span(),
11814 Self::UpdateExpression(inner) => inner.span(),
11815 Self::UsesModuleDirective(inner) => inner.span(),
11816 Self::VariableDeclarator(inner) => inner.span(),
11817 Self::WhileStatement(inner) => inner.span(),
11818 Self::Wildcard(inner) => inner.span(),
11819 Self::YieldStatement(inner) => inner.span(),
11820 Self::BinaryIntegerLiteral(inner) => inner.span(),
11821 Self::BlockComment(inner) => inner.span(),
11822 Self::BooleanType(inner) => inner.span(),
11823 Self::CharacterLiteral(inner) => inner.span(),
11824 Self::DecimalFloatingPointLiteral(inner) => inner.span(),
11825 Self::DecimalIntegerLiteral(inner) => inner.span(),
11826 Self::EscapeSequence(inner) => inner.span(),
11827 Self::False(inner) => inner.span(),
11828 Self::HexFloatingPointLiteral(inner) => inner.span(),
11829 Self::HexIntegerLiteral(inner) => inner.span(),
11830 Self::Identifier(inner) => inner.span(),
11831 Self::LineComment(inner) => inner.span(),
11832 Self::NullLiteral(inner) => inner.span(),
11833 Self::OctalIntegerLiteral(inner) => inner.span(),
11834 Self::StringFragment(inner) => inner.span(),
11835 Self::Super(inner) => inner.span(),
11836 Self::This(inner) => inner.span(),
11837 Self::True(inner) => inner.span(),
11838 Self::TypeIdentifier(inner) => inner.span(),
11839 Self::UnderscorePattern(inner) => inner.span(),
11840 Self::VoidType(inner) => inner.span(),
11841 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
11842 }
11843 }
11844}