1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Literal<'tree> {
3 BinaryIntegerLiteral(::std::boxed::Box<BinaryIntegerLiteral<'tree>>),
4 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
5 DecimalFloatingPointLiteral(::std::boxed::Box<DecimalFloatingPointLiteral<'tree>>),
6 DecimalIntegerLiteral(::std::boxed::Box<DecimalIntegerLiteral<'tree>>),
7 False(::std::boxed::Box<False<'tree>>),
8 HexFloatingPointLiteral(::std::boxed::Box<HexFloatingPointLiteral<'tree>>),
9 HexIntegerLiteral(::std::boxed::Box<HexIntegerLiteral<'tree>>),
10 NullLiteral(::std::boxed::Box<NullLiteral<'tree>>),
11 OctalIntegerLiteral(::std::boxed::Box<OctalIntegerLiteral<'tree>>),
12 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
13 True(::std::boxed::Box<True<'tree>>),
14}
15impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
16 #[allow(clippy::collapsible_else_if)]
17 fn from_node(
18 node: ::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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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 let candidate = fallback_cursor.node();
1599 #[allow(clippy::needless_question_mark)]
1600 if (|| -> ::core::result::Result<
1601 _,
1602 ::treesitter_types::ParseError,
1603 > {
1604 let child = candidate;
1605 Ok(
1606 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(
1607 child,
1608 src,
1609 )?,
1610 )
1611 })()
1612 .is_ok()
1613 {
1614 fallback_child = Some(candidate);
1615 break;
1616 }
1617 }
1618 if !fallback_cursor.goto_next_sibling() {
1619 break;
1620 }
1621 }
1622 }
1623 if fallback_child.is_none() {
1624 let mut cursor2 = node.walk();
1625 if cursor2.goto_first_child() {
1626 loop {
1627 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1628 let candidate = cursor2.node();
1629 #[allow(clippy::needless_question_mark)]
1630 if (|| -> ::core::result::Result<
1631 _,
1632 ::treesitter_types::ParseError,
1633 > {
1634 let child = candidate;
1635 Ok(
1636 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(
1637 child,
1638 src,
1639 )?,
1640 )
1641 })()
1642 .is_ok()
1643 {
1644 fallback_child = Some(candidate);
1645 break;
1646 }
1647 }
1648 if !cursor2.goto_next_sibling() {
1649 break;
1650 }
1651 }
1652 }
1653 }
1654 fallback_child.ok_or_else(|| {
1655 ::treesitter_types::ParseError::missing_field("children", node)
1656 })?
1657 };
1658 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(child, src)?
1659 },
1660 })
1661 }
1662}
1663impl ::treesitter_types::Spanned for CatchClause<'_> {
1664 fn span(&self) -> ::treesitter_types::Span {
1665 self.span
1666 }
1667}
1668#[derive(Debug, Clone, PartialEq, Eq)]
1669pub struct CatchFormalParameter<'tree> {
1670 pub span: ::treesitter_types::Span,
1671 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
1672 pub name: CatchFormalParameterName<'tree>,
1673 pub children: ::std::vec::Vec<CatchFormalParameterChildren<'tree>>,
1674}
1675impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameter<'tree> {
1676 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1677 fn from_node(
1678 node: ::tree_sitter::Node<'tree>,
1679 src: &'tree [u8],
1680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1681 debug_assert_eq!(node.kind(), "catch_formal_parameter");
1682 Ok(Self {
1683 span: ::treesitter_types::Span::from(node),
1684 dimensions: match node.child_by_field_name("dimensions") {
1685 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
1686 child, src,
1687 )?),
1688 None => None,
1689 },
1690 name: {
1691 let child = node
1692 .child_by_field_name("name")
1693 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1694 <CatchFormalParameterName as ::treesitter_types::FromNode>::from_node(child, src)?
1695 },
1696 children: {
1697 #[allow(clippy::suspicious_else_formatting)]
1698 let non_field_children = {
1699 let mut cursor = node.walk();
1700 let mut result = ::std::vec::Vec::new();
1701 if cursor.goto_first_child() {
1702 loop {
1703 if cursor.field_name().is_none()
1704 && cursor.node().is_named()
1705 && !cursor.node().is_extra()
1706 {
1707 result.push(cursor.node());
1708 }
1709 if !cursor.goto_next_sibling() {
1710 break;
1711 }
1712 }
1713 }
1714 result
1715 };
1716 let mut items = ::std::vec::Vec::new();
1717 for child in non_field_children {
1718 items.push(
1719 <CatchFormalParameterChildren as ::treesitter_types::FromNode>::from_node(
1720 child, src,
1721 )?,
1722 );
1723 }
1724 items
1725 },
1726 })
1727 }
1728}
1729impl ::treesitter_types::Spanned for CatchFormalParameter<'_> {
1730 fn span(&self) -> ::treesitter_types::Span {
1731 self.span
1732 }
1733}
1734#[derive(Debug, Clone, PartialEq, Eq)]
1735pub struct CatchType<'tree> {
1736 pub span: ::treesitter_types::Span,
1737 pub children: ::std::vec::Vec<UnannotatedType<'tree>>,
1738}
1739impl<'tree> ::treesitter_types::FromNode<'tree> for CatchType<'tree> {
1740 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1741 fn from_node(
1742 node: ::tree_sitter::Node<'tree>,
1743 src: &'tree [u8],
1744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1745 debug_assert_eq!(node.kind(), "catch_type");
1746 Ok(Self {
1747 span: ::treesitter_types::Span::from(node),
1748 children: {
1749 #[allow(clippy::suspicious_else_formatting)]
1750 let non_field_children = {
1751 let mut cursor = node.walk();
1752 let mut result = ::std::vec::Vec::new();
1753 if cursor.goto_first_child() {
1754 loop {
1755 if cursor.field_name().is_none()
1756 && cursor.node().is_named()
1757 && !cursor.node().is_extra()
1758 {
1759 result.push(cursor.node());
1760 }
1761 if !cursor.goto_next_sibling() {
1762 break;
1763 }
1764 }
1765 }
1766 result
1767 };
1768 let mut items = ::std::vec::Vec::new();
1769 for child in non_field_children {
1770 items.push(
1771 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?,
1772 );
1773 }
1774 items
1775 },
1776 })
1777 }
1778}
1779impl ::treesitter_types::Spanned for CatchType<'_> {
1780 fn span(&self) -> ::treesitter_types::Span {
1781 self.span
1782 }
1783}
1784#[derive(Debug, Clone, PartialEq, Eq)]
1785pub struct ClassBody<'tree> {
1786 pub span: ::treesitter_types::Span,
1787 pub children: ::std::vec::Vec<ClassBodyChildren<'tree>>,
1788}
1789impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1790 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1791 fn from_node(
1792 node: ::tree_sitter::Node<'tree>,
1793 src: &'tree [u8],
1794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1795 debug_assert_eq!(node.kind(), "class_body");
1796 Ok(Self {
1797 span: ::treesitter_types::Span::from(node),
1798 children: {
1799 #[allow(clippy::suspicious_else_formatting)]
1800 let non_field_children = {
1801 let mut cursor = node.walk();
1802 let mut result = ::std::vec::Vec::new();
1803 if cursor.goto_first_child() {
1804 loop {
1805 if cursor.field_name().is_none()
1806 && cursor.node().is_named()
1807 && !cursor.node().is_extra()
1808 {
1809 result.push(cursor.node());
1810 }
1811 if !cursor.goto_next_sibling() {
1812 break;
1813 }
1814 }
1815 }
1816 result
1817 };
1818 let mut items = ::std::vec::Vec::new();
1819 for child in non_field_children {
1820 items.push(
1821 <ClassBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1822 );
1823 }
1824 items
1825 },
1826 })
1827 }
1828}
1829impl ::treesitter_types::Spanned for ClassBody<'_> {
1830 fn span(&self) -> ::treesitter_types::Span {
1831 self.span
1832 }
1833}
1834#[derive(Debug, Clone, PartialEq, Eq)]
1835pub struct ClassDeclaration<'tree> {
1836 pub span: ::treesitter_types::Span,
1837 pub body: ClassBody<'tree>,
1838 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
1839 pub name: Identifier<'tree>,
1840 pub permits: ::core::option::Option<Permits<'tree>>,
1841 pub superclass: ::core::option::Option<Superclass<'tree>>,
1842 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1843 pub children: ::core::option::Option<Modifiers<'tree>>,
1844}
1845impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1846 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1847 fn from_node(
1848 node: ::tree_sitter::Node<'tree>,
1849 src: &'tree [u8],
1850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1851 debug_assert_eq!(node.kind(), "class_declaration");
1852 Ok(Self {
1853 span: ::treesitter_types::Span::from(node),
1854 body: {
1855 let child = node
1856 .child_by_field_name("body")
1857 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1858 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
1859 },
1860 interfaces: match node.child_by_field_name("interfaces") {
1861 Some(child) => {
1862 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
1863 }
1864 None => None,
1865 },
1866 name: {
1867 let child = node
1868 .child_by_field_name("name")
1869 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1870 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1871 },
1872 permits: match node.child_by_field_name("permits") {
1873 Some(child) => Some(<Permits as ::treesitter_types::FromNode>::from_node(
1874 child, src,
1875 )?),
1876 None => None,
1877 },
1878 superclass: match node.child_by_field_name("superclass") {
1879 Some(child) => Some(<Superclass as ::treesitter_types::FromNode>::from_node(
1880 child, src,
1881 )?),
1882 None => None,
1883 },
1884 type_parameters: match node.child_by_field_name("type_parameters") {
1885 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
1886 child, src,
1887 )?),
1888 None => None,
1889 },
1890 children: {
1891 #[allow(clippy::suspicious_else_formatting)]
1892 let non_field_children = {
1893 let mut cursor = node.walk();
1894 let mut result = ::std::vec::Vec::new();
1895 if cursor.goto_first_child() {
1896 loop {
1897 if cursor.field_name().is_none()
1898 && cursor.node().is_named()
1899 && !cursor.node().is_extra()
1900 {
1901 result.push(cursor.node());
1902 }
1903 if !cursor.goto_next_sibling() {
1904 break;
1905 }
1906 }
1907 }
1908 result
1909 };
1910 match non_field_children.first() {
1911 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
1912 child, src,
1913 )?),
1914 None => None,
1915 }
1916 },
1917 })
1918 }
1919}
1920impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
1921 fn span(&self) -> ::treesitter_types::Span {
1922 self.span
1923 }
1924}
1925#[derive(Debug, Clone, PartialEq, Eq)]
1926pub struct ClassLiteral<'tree> {
1927 pub span: ::treesitter_types::Span,
1928 pub children: UnannotatedType<'tree>,
1929}
1930impl<'tree> ::treesitter_types::FromNode<'tree> for ClassLiteral<'tree> {
1931 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1932 fn from_node(
1933 node: ::tree_sitter::Node<'tree>,
1934 src: &'tree [u8],
1935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1936 debug_assert_eq!(node.kind(), "class_literal");
1937 Ok(Self {
1938 span: ::treesitter_types::Span::from(node),
1939 children: {
1940 #[allow(clippy::suspicious_else_formatting)]
1941 let non_field_children = {
1942 let mut cursor = node.walk();
1943 let mut result = ::std::vec::Vec::new();
1944 if cursor.goto_first_child() {
1945 loop {
1946 if cursor.field_name().is_none()
1947 && cursor.node().is_named()
1948 && !cursor.node().is_extra()
1949 {
1950 result.push(cursor.node());
1951 }
1952 if !cursor.goto_next_sibling() {
1953 break;
1954 }
1955 }
1956 }
1957 result
1958 };
1959 let child = if let Some(&c) = non_field_children.first() {
1960 c
1961 } else {
1962 let mut fallback_cursor = node.walk();
1963 let mut fallback_child = None;
1964 if fallback_cursor.goto_first_child() {
1965 loop {
1966 if fallback_cursor.field_name().is_none()
1967 && !fallback_cursor.node().is_extra()
1968 {
1969 let candidate = fallback_cursor.node();
1970 #[allow(clippy::needless_question_mark)]
1971 if (|| -> ::core::result::Result<
1972 _,
1973 ::treesitter_types::ParseError,
1974 > {
1975 let child = candidate;
1976 Ok(
1977 <UnannotatedType as ::treesitter_types::FromNode>::from_node(
1978 child,
1979 src,
1980 )?,
1981 )
1982 })()
1983 .is_ok()
1984 {
1985 fallback_child = Some(candidate);
1986 break;
1987 }
1988 }
1989 if !fallback_cursor.goto_next_sibling() {
1990 break;
1991 }
1992 }
1993 }
1994 if fallback_child.is_none() {
1995 let mut cursor2 = node.walk();
1996 if cursor2.goto_first_child() {
1997 loop {
1998 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1999 let candidate = cursor2.node();
2000 #[allow(clippy::needless_question_mark)]
2001 if (|| -> ::core::result::Result<
2002 _,
2003 ::treesitter_types::ParseError,
2004 > {
2005 let child = candidate;
2006 Ok(
2007 <UnannotatedType as ::treesitter_types::FromNode>::from_node(
2008 child,
2009 src,
2010 )?,
2011 )
2012 })()
2013 .is_ok()
2014 {
2015 fallback_child = Some(candidate);
2016 break;
2017 }
2018 }
2019 if !cursor2.goto_next_sibling() {
2020 break;
2021 }
2022 }
2023 }
2024 }
2025 fallback_child.ok_or_else(|| {
2026 ::treesitter_types::ParseError::missing_field("children", node)
2027 })?
2028 };
2029 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
2030 },
2031 })
2032 }
2033}
2034impl ::treesitter_types::Spanned for ClassLiteral<'_> {
2035 fn span(&self) -> ::treesitter_types::Span {
2036 self.span
2037 }
2038}
2039#[derive(Debug, Clone, PartialEq, Eq)]
2040pub struct CompactConstructorDeclaration<'tree> {
2041 pub span: ::treesitter_types::Span,
2042 pub body: Block<'tree>,
2043 pub name: Identifier<'tree>,
2044 pub children: ::core::option::Option<Modifiers<'tree>>,
2045}
2046impl<'tree> ::treesitter_types::FromNode<'tree> for CompactConstructorDeclaration<'tree> {
2047 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2048 fn from_node(
2049 node: ::tree_sitter::Node<'tree>,
2050 src: &'tree [u8],
2051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2052 debug_assert_eq!(node.kind(), "compact_constructor_declaration");
2053 Ok(Self {
2054 span: ::treesitter_types::Span::from(node),
2055 body: {
2056 let child = node
2057 .child_by_field_name("body")
2058 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2059 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
2060 },
2061 name: {
2062 let child = node
2063 .child_by_field_name("name")
2064 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2065 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2066 },
2067 children: {
2068 #[allow(clippy::suspicious_else_formatting)]
2069 let non_field_children = {
2070 let mut cursor = node.walk();
2071 let mut result = ::std::vec::Vec::new();
2072 if cursor.goto_first_child() {
2073 loop {
2074 if cursor.field_name().is_none()
2075 && cursor.node().is_named()
2076 && !cursor.node().is_extra()
2077 {
2078 result.push(cursor.node());
2079 }
2080 if !cursor.goto_next_sibling() {
2081 break;
2082 }
2083 }
2084 }
2085 result
2086 };
2087 match non_field_children.first() {
2088 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2089 child, src,
2090 )?),
2091 None => None,
2092 }
2093 },
2094 })
2095 }
2096}
2097impl ::treesitter_types::Spanned for CompactConstructorDeclaration<'_> {
2098 fn span(&self) -> ::treesitter_types::Span {
2099 self.span
2100 }
2101}
2102#[derive(Debug, Clone, PartialEq, Eq)]
2103pub struct ConstantDeclaration<'tree> {
2104 pub span: ::treesitter_types::Span,
2105 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
2106 pub r#type: UnannotatedType<'tree>,
2107 pub children: ::core::option::Option<Modifiers<'tree>>,
2108}
2109impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantDeclaration<'tree> {
2110 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2111 fn from_node(
2112 node: ::tree_sitter::Node<'tree>,
2113 src: &'tree [u8],
2114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2115 debug_assert_eq!(node.kind(), "constant_declaration");
2116 Ok(Self {
2117 span: ::treesitter_types::Span::from(node),
2118 declarator: {
2119 let mut cursor = node.walk();
2120 let mut items = ::std::vec::Vec::new();
2121 for child in node.children_by_field_name("declarator", &mut cursor) {
2122 items.push(
2123 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
2124 child, src,
2125 )?,
2126 );
2127 }
2128 items
2129 },
2130 r#type: {
2131 let child = node
2132 .child_by_field_name("type")
2133 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2134 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
2135 },
2136 children: {
2137 #[allow(clippy::suspicious_else_formatting)]
2138 let non_field_children = {
2139 let mut cursor = node.walk();
2140 let mut result = ::std::vec::Vec::new();
2141 if cursor.goto_first_child() {
2142 loop {
2143 if cursor.field_name().is_none()
2144 && cursor.node().is_named()
2145 && !cursor.node().is_extra()
2146 {
2147 result.push(cursor.node());
2148 }
2149 if !cursor.goto_next_sibling() {
2150 break;
2151 }
2152 }
2153 }
2154 result
2155 };
2156 match non_field_children.first() {
2157 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2158 child, src,
2159 )?),
2160 None => None,
2161 }
2162 },
2163 })
2164 }
2165}
2166impl ::treesitter_types::Spanned for ConstantDeclaration<'_> {
2167 fn span(&self) -> ::treesitter_types::Span {
2168 self.span
2169 }
2170}
2171#[derive(Debug, Clone, PartialEq, Eq)]
2172pub struct ConstructorBody<'tree> {
2173 pub span: ::treesitter_types::Span,
2174 pub children: ::std::vec::Vec<ConstructorBodyChildren<'tree>>,
2175}
2176impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBody<'tree> {
2177 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2178 fn from_node(
2179 node: ::tree_sitter::Node<'tree>,
2180 src: &'tree [u8],
2181 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2182 debug_assert_eq!(node.kind(), "constructor_body");
2183 Ok(Self {
2184 span: ::treesitter_types::Span::from(node),
2185 children: {
2186 #[allow(clippy::suspicious_else_formatting)]
2187 let non_field_children = {
2188 let mut cursor = node.walk();
2189 let mut result = ::std::vec::Vec::new();
2190 if cursor.goto_first_child() {
2191 loop {
2192 if cursor.field_name().is_none()
2193 && cursor.node().is_named()
2194 && !cursor.node().is_extra()
2195 {
2196 result.push(cursor.node());
2197 }
2198 if !cursor.goto_next_sibling() {
2199 break;
2200 }
2201 }
2202 }
2203 result
2204 };
2205 let mut items = ::std::vec::Vec::new();
2206 for child in non_field_children {
2207 items.push(
2208 <ConstructorBodyChildren as ::treesitter_types::FromNode>::from_node(
2209 child, src,
2210 )?,
2211 );
2212 }
2213 items
2214 },
2215 })
2216 }
2217}
2218impl ::treesitter_types::Spanned for ConstructorBody<'_> {
2219 fn span(&self) -> ::treesitter_types::Span {
2220 self.span
2221 }
2222}
2223#[derive(Debug, Clone, PartialEq, Eq)]
2224pub struct ConstructorDeclaration<'tree> {
2225 pub span: ::treesitter_types::Span,
2226 pub body: ConstructorBody<'tree>,
2227 pub name: Identifier<'tree>,
2228 pub parameters: FormalParameters<'tree>,
2229 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2230 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
2231}
2232impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
2233 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2234 fn from_node(
2235 node: ::tree_sitter::Node<'tree>,
2236 src: &'tree [u8],
2237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2238 debug_assert_eq!(node.kind(), "constructor_declaration");
2239 Ok(Self {
2240 span: ::treesitter_types::Span::from(node),
2241 body: {
2242 let child = node
2243 .child_by_field_name("body")
2244 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2245 <ConstructorBody as ::treesitter_types::FromNode>::from_node(child, src)?
2246 },
2247 name: {
2248 let child = node
2249 .child_by_field_name("name")
2250 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2251 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2252 },
2253 parameters: {
2254 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2255 ::treesitter_types::ParseError::missing_field("parameters", node)
2256 })?;
2257 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2258 },
2259 type_parameters: match node.child_by_field_name("type_parameters") {
2260 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2261 child, src,
2262 )?),
2263 None => None,
2264 },
2265 children: {
2266 #[allow(clippy::suspicious_else_formatting)]
2267 let non_field_children = {
2268 let mut cursor = node.walk();
2269 let mut result = ::std::vec::Vec::new();
2270 if cursor.goto_first_child() {
2271 loop {
2272 if cursor.field_name().is_none()
2273 && cursor.node().is_named()
2274 && !cursor.node().is_extra()
2275 {
2276 result.push(cursor.node());
2277 }
2278 if !cursor.goto_next_sibling() {
2279 break;
2280 }
2281 }
2282 }
2283 result
2284 };
2285 let mut items = ::std::vec::Vec::new();
2286 for child in non_field_children {
2287 items
2288 .push(
2289 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2290 child,
2291 src,
2292 )?,
2293 );
2294 }
2295 items
2296 },
2297 })
2298 }
2299}
2300impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
2301 fn span(&self) -> ::treesitter_types::Span {
2302 self.span
2303 }
2304}
2305#[derive(Debug, Clone, PartialEq, Eq)]
2306pub struct ContinueStatement<'tree> {
2307 pub span: ::treesitter_types::Span,
2308 pub children: ::core::option::Option<Identifier<'tree>>,
2309}
2310impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2311 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2312 fn from_node(
2313 node: ::tree_sitter::Node<'tree>,
2314 src: &'tree [u8],
2315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2316 debug_assert_eq!(node.kind(), "continue_statement");
2317 Ok(Self {
2318 span: ::treesitter_types::Span::from(node),
2319 children: {
2320 #[allow(clippy::suspicious_else_formatting)]
2321 let non_field_children = {
2322 let mut cursor = node.walk();
2323 let mut result = ::std::vec::Vec::new();
2324 if cursor.goto_first_child() {
2325 loop {
2326 if cursor.field_name().is_none()
2327 && cursor.node().is_named()
2328 && !cursor.node().is_extra()
2329 {
2330 result.push(cursor.node());
2331 }
2332 if !cursor.goto_next_sibling() {
2333 break;
2334 }
2335 }
2336 }
2337 result
2338 };
2339 match non_field_children.first() {
2340 Some(&child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2341 child, src,
2342 )?),
2343 None => None,
2344 }
2345 },
2346 })
2347 }
2348}
2349impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2350 fn span(&self) -> ::treesitter_types::Span {
2351 self.span
2352 }
2353}
2354#[derive(Debug, Clone, PartialEq, Eq)]
2355pub struct Dimensions<'tree> {
2356 pub span: ::treesitter_types::Span,
2357 pub children: ::std::vec::Vec<DimensionsChildren<'tree>>,
2358}
2359impl<'tree> ::treesitter_types::FromNode<'tree> for Dimensions<'tree> {
2360 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2361 fn from_node(
2362 node: ::tree_sitter::Node<'tree>,
2363 src: &'tree [u8],
2364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2365 debug_assert_eq!(node.kind(), "dimensions");
2366 Ok(Self {
2367 span: ::treesitter_types::Span::from(node),
2368 children: {
2369 #[allow(clippy::suspicious_else_formatting)]
2370 let non_field_children = {
2371 let mut cursor = node.walk();
2372 let mut result = ::std::vec::Vec::new();
2373 if cursor.goto_first_child() {
2374 loop {
2375 if cursor.field_name().is_none()
2376 && cursor.node().is_named()
2377 && !cursor.node().is_extra()
2378 {
2379 result.push(cursor.node());
2380 }
2381 if !cursor.goto_next_sibling() {
2382 break;
2383 }
2384 }
2385 }
2386 result
2387 };
2388 let mut items = ::std::vec::Vec::new();
2389 for child in non_field_children {
2390 items.push(
2391 <DimensionsChildren as ::treesitter_types::FromNode>::from_node(
2392 child, src,
2393 )?,
2394 );
2395 }
2396 items
2397 },
2398 })
2399 }
2400}
2401impl ::treesitter_types::Spanned for Dimensions<'_> {
2402 fn span(&self) -> ::treesitter_types::Span {
2403 self.span
2404 }
2405}
2406#[derive(Debug, Clone, PartialEq, Eq)]
2407pub struct DimensionsExpr<'tree> {
2408 pub span: ::treesitter_types::Span,
2409 pub children: ::std::vec::Vec<DimensionsExprChildren<'tree>>,
2410}
2411impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExpr<'tree> {
2412 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2413 fn from_node(
2414 node: ::tree_sitter::Node<'tree>,
2415 src: &'tree [u8],
2416 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2417 debug_assert_eq!(node.kind(), "dimensions_expr");
2418 Ok(Self {
2419 span: ::treesitter_types::Span::from(node),
2420 children: {
2421 #[allow(clippy::suspicious_else_formatting)]
2422 let non_field_children = {
2423 let mut cursor = node.walk();
2424 let mut result = ::std::vec::Vec::new();
2425 if cursor.goto_first_child() {
2426 loop {
2427 if cursor.field_name().is_none()
2428 && cursor.node().is_named()
2429 && !cursor.node().is_extra()
2430 {
2431 result.push(cursor.node());
2432 }
2433 if !cursor.goto_next_sibling() {
2434 break;
2435 }
2436 }
2437 }
2438 result
2439 };
2440 let mut items = ::std::vec::Vec::new();
2441 for child in non_field_children {
2442 items.push(
2443 <DimensionsExprChildren as ::treesitter_types::FromNode>::from_node(
2444 child, src,
2445 )?,
2446 );
2447 }
2448 items
2449 },
2450 })
2451 }
2452}
2453impl ::treesitter_types::Spanned for DimensionsExpr<'_> {
2454 fn span(&self) -> ::treesitter_types::Span {
2455 self.span
2456 }
2457}
2458#[derive(Debug, Clone, PartialEq, Eq)]
2459pub struct DoStatement<'tree> {
2460 pub span: ::treesitter_types::Span,
2461 pub body: Statement<'tree>,
2462 pub condition: ParenthesizedExpression<'tree>,
2463}
2464impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2465 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2466 fn from_node(
2467 node: ::tree_sitter::Node<'tree>,
2468 src: &'tree [u8],
2469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2470 debug_assert_eq!(node.kind(), "do_statement");
2471 Ok(Self {
2472 span: ::treesitter_types::Span::from(node),
2473 body: {
2474 let child = node
2475 .child_by_field_name("body")
2476 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2477 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2478 },
2479 condition: {
2480 let child = node.child_by_field_name("condition").ok_or_else(|| {
2481 ::treesitter_types::ParseError::missing_field("condition", node)
2482 })?;
2483 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2484 },
2485 })
2486 }
2487}
2488impl ::treesitter_types::Spanned for DoStatement<'_> {
2489 fn span(&self) -> ::treesitter_types::Span {
2490 self.span
2491 }
2492}
2493#[derive(Debug, Clone, PartialEq, Eq)]
2494pub struct ElementValueArrayInitializer<'tree> {
2495 pub span: ::treesitter_types::Span,
2496 pub children: ::std::vec::Vec<ElementValueArrayInitializerChildren<'tree>>,
2497}
2498impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializer<'tree> {
2499 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2500 fn from_node(
2501 node: ::tree_sitter::Node<'tree>,
2502 src: &'tree [u8],
2503 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2504 debug_assert_eq!(node.kind(), "element_value_array_initializer");
2505 Ok(Self {
2506 span: ::treesitter_types::Span::from(node),
2507 children: {
2508 #[allow(clippy::suspicious_else_formatting)]
2509 let non_field_children = {
2510 let mut cursor = node.walk();
2511 let mut result = ::std::vec::Vec::new();
2512 if cursor.goto_first_child() {
2513 loop {
2514 if cursor.field_name().is_none()
2515 && cursor.node().is_named()
2516 && !cursor.node().is_extra()
2517 {
2518 result.push(cursor.node());
2519 }
2520 if !cursor.goto_next_sibling() {
2521 break;
2522 }
2523 }
2524 }
2525 result
2526 };
2527 let mut items = ::std::vec::Vec::new();
2528 for child in non_field_children {
2529 items
2530 .push(
2531 <ElementValueArrayInitializerChildren as ::treesitter_types::FromNode>::from_node(
2532 child,
2533 src,
2534 )?,
2535 );
2536 }
2537 items
2538 },
2539 })
2540 }
2541}
2542impl ::treesitter_types::Spanned for ElementValueArrayInitializer<'_> {
2543 fn span(&self) -> ::treesitter_types::Span {
2544 self.span
2545 }
2546}
2547#[derive(Debug, Clone, PartialEq, Eq)]
2548pub struct ElementValuePair<'tree> {
2549 pub span: ::treesitter_types::Span,
2550 pub key: Identifier<'tree>,
2551 pub value: ElementValuePairValue<'tree>,
2552}
2553impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePair<'tree> {
2554 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2555 fn from_node(
2556 node: ::tree_sitter::Node<'tree>,
2557 src: &'tree [u8],
2558 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2559 debug_assert_eq!(node.kind(), "element_value_pair");
2560 Ok(Self {
2561 span: ::treesitter_types::Span::from(node),
2562 key: {
2563 let child = node
2564 .child_by_field_name("key")
2565 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
2566 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2567 },
2568 value: {
2569 let child = node
2570 .child_by_field_name("value")
2571 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2572 <ElementValuePairValue as ::treesitter_types::FromNode>::from_node(child, src)?
2573 },
2574 })
2575 }
2576}
2577impl ::treesitter_types::Spanned for ElementValuePair<'_> {
2578 fn span(&self) -> ::treesitter_types::Span {
2579 self.span
2580 }
2581}
2582#[derive(Debug, Clone, PartialEq, Eq)]
2583pub struct EnhancedForStatement<'tree> {
2584 pub span: ::treesitter_types::Span,
2585 pub body: Statement<'tree>,
2586 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
2587 pub name: EnhancedForStatementName<'tree>,
2588 pub r#type: UnannotatedType<'tree>,
2589 pub value: Expression<'tree>,
2590 pub children: ::core::option::Option<Modifiers<'tree>>,
2591}
2592impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatement<'tree> {
2593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2594 fn from_node(
2595 node: ::tree_sitter::Node<'tree>,
2596 src: &'tree [u8],
2597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2598 debug_assert_eq!(node.kind(), "enhanced_for_statement");
2599 Ok(Self {
2600 span: ::treesitter_types::Span::from(node),
2601 body: {
2602 let child = node
2603 .child_by_field_name("body")
2604 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2605 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2606 },
2607 dimensions: match node.child_by_field_name("dimensions") {
2608 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
2609 child, src,
2610 )?),
2611 None => None,
2612 },
2613 name: {
2614 let child = node
2615 .child_by_field_name("name")
2616 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2617 <EnhancedForStatementName as ::treesitter_types::FromNode>::from_node(child, src)?
2618 },
2619 r#type: {
2620 let child = node
2621 .child_by_field_name("type")
2622 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2623 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
2624 },
2625 value: {
2626 let child = node
2627 .child_by_field_name("value")
2628 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2629 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2630 },
2631 children: {
2632 #[allow(clippy::suspicious_else_formatting)]
2633 let non_field_children = {
2634 let mut cursor = node.walk();
2635 let mut result = ::std::vec::Vec::new();
2636 if cursor.goto_first_child() {
2637 loop {
2638 if cursor.field_name().is_none()
2639 && cursor.node().is_named()
2640 && !cursor.node().is_extra()
2641 {
2642 result.push(cursor.node());
2643 }
2644 if !cursor.goto_next_sibling() {
2645 break;
2646 }
2647 }
2648 }
2649 result
2650 };
2651 match non_field_children.first() {
2652 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2653 child, src,
2654 )?),
2655 None => None,
2656 }
2657 },
2658 })
2659 }
2660}
2661impl ::treesitter_types::Spanned for EnhancedForStatement<'_> {
2662 fn span(&self) -> ::treesitter_types::Span {
2663 self.span
2664 }
2665}
2666#[derive(Debug, Clone, PartialEq, Eq)]
2667pub struct EnumBody<'tree> {
2668 pub span: ::treesitter_types::Span,
2669 pub children: ::std::vec::Vec<EnumBodyChildren<'tree>>,
2670}
2671impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBody<'tree> {
2672 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2673 fn from_node(
2674 node: ::tree_sitter::Node<'tree>,
2675 src: &'tree [u8],
2676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2677 debug_assert_eq!(node.kind(), "enum_body");
2678 Ok(Self {
2679 span: ::treesitter_types::Span::from(node),
2680 children: {
2681 #[allow(clippy::suspicious_else_formatting)]
2682 let non_field_children = {
2683 let mut cursor = node.walk();
2684 let mut result = ::std::vec::Vec::new();
2685 if cursor.goto_first_child() {
2686 loop {
2687 if cursor.field_name().is_none()
2688 && cursor.node().is_named()
2689 && !cursor.node().is_extra()
2690 {
2691 result.push(cursor.node());
2692 }
2693 if !cursor.goto_next_sibling() {
2694 break;
2695 }
2696 }
2697 }
2698 result
2699 };
2700 let mut items = ::std::vec::Vec::new();
2701 for child in non_field_children {
2702 items.push(
2703 <EnumBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2704 );
2705 }
2706 items
2707 },
2708 })
2709 }
2710}
2711impl ::treesitter_types::Spanned for EnumBody<'_> {
2712 fn span(&self) -> ::treesitter_types::Span {
2713 self.span
2714 }
2715}
2716#[derive(Debug, Clone, PartialEq, Eq)]
2717pub struct EnumBodyDeclarations<'tree> {
2718 pub span: ::treesitter_types::Span,
2719 pub children: ::std::vec::Vec<EnumBodyDeclarationsChildren<'tree>>,
2720}
2721impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarations<'tree> {
2722 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2723 fn from_node(
2724 node: ::tree_sitter::Node<'tree>,
2725 src: &'tree [u8],
2726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2727 debug_assert_eq!(node.kind(), "enum_body_declarations");
2728 Ok(Self {
2729 span: ::treesitter_types::Span::from(node),
2730 children: {
2731 #[allow(clippy::suspicious_else_formatting)]
2732 let non_field_children = {
2733 let mut cursor = node.walk();
2734 let mut result = ::std::vec::Vec::new();
2735 if cursor.goto_first_child() {
2736 loop {
2737 if cursor.field_name().is_none()
2738 && cursor.node().is_named()
2739 && !cursor.node().is_extra()
2740 {
2741 result.push(cursor.node());
2742 }
2743 if !cursor.goto_next_sibling() {
2744 break;
2745 }
2746 }
2747 }
2748 result
2749 };
2750 let mut items = ::std::vec::Vec::new();
2751 for child in non_field_children {
2752 items.push(
2753 <EnumBodyDeclarationsChildren as ::treesitter_types::FromNode>::from_node(
2754 child, src,
2755 )?,
2756 );
2757 }
2758 items
2759 },
2760 })
2761 }
2762}
2763impl ::treesitter_types::Spanned for EnumBodyDeclarations<'_> {
2764 fn span(&self) -> ::treesitter_types::Span {
2765 self.span
2766 }
2767}
2768#[derive(Debug, Clone, PartialEq, Eq)]
2769pub struct EnumConstant<'tree> {
2770 pub span: ::treesitter_types::Span,
2771 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
2772 pub body: ::core::option::Option<ClassBody<'tree>>,
2773 pub name: Identifier<'tree>,
2774 pub children: ::core::option::Option<Modifiers<'tree>>,
2775}
2776impl<'tree> ::treesitter_types::FromNode<'tree> for EnumConstant<'tree> {
2777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2778 fn from_node(
2779 node: ::tree_sitter::Node<'tree>,
2780 src: &'tree [u8],
2781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2782 debug_assert_eq!(node.kind(), "enum_constant");
2783 Ok(Self {
2784 span: ::treesitter_types::Span::from(node),
2785 arguments: match node.child_by_field_name("arguments") {
2786 Some(child) => Some(<ArgumentList as ::treesitter_types::FromNode>::from_node(
2787 child, src,
2788 )?),
2789 None => None,
2790 },
2791 body: match node.child_by_field_name("body") {
2792 Some(child) => Some(<ClassBody as ::treesitter_types::FromNode>::from_node(
2793 child, src,
2794 )?),
2795 None => None,
2796 },
2797 name: {
2798 let child = node
2799 .child_by_field_name("name")
2800 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2801 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2802 },
2803 children: {
2804 #[allow(clippy::suspicious_else_formatting)]
2805 let non_field_children = {
2806 let mut cursor = node.walk();
2807 let mut result = ::std::vec::Vec::new();
2808 if cursor.goto_first_child() {
2809 loop {
2810 if cursor.field_name().is_none()
2811 && cursor.node().is_named()
2812 && !cursor.node().is_extra()
2813 {
2814 result.push(cursor.node());
2815 }
2816 if !cursor.goto_next_sibling() {
2817 break;
2818 }
2819 }
2820 }
2821 result
2822 };
2823 match non_field_children.first() {
2824 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2825 child, src,
2826 )?),
2827 None => None,
2828 }
2829 },
2830 })
2831 }
2832}
2833impl ::treesitter_types::Spanned for EnumConstant<'_> {
2834 fn span(&self) -> ::treesitter_types::Span {
2835 self.span
2836 }
2837}
2838#[derive(Debug, Clone, PartialEq, Eq)]
2839pub struct EnumDeclaration<'tree> {
2840 pub span: ::treesitter_types::Span,
2841 pub body: EnumBody<'tree>,
2842 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
2843 pub name: Identifier<'tree>,
2844 pub children: ::core::option::Option<Modifiers<'tree>>,
2845}
2846impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
2847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2848 fn from_node(
2849 node: ::tree_sitter::Node<'tree>,
2850 src: &'tree [u8],
2851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2852 debug_assert_eq!(node.kind(), "enum_declaration");
2853 Ok(Self {
2854 span: ::treesitter_types::Span::from(node),
2855 body: {
2856 let child = node
2857 .child_by_field_name("body")
2858 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2859 <EnumBody as ::treesitter_types::FromNode>::from_node(child, src)?
2860 },
2861 interfaces: match node.child_by_field_name("interfaces") {
2862 Some(child) => {
2863 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
2864 }
2865 None => None,
2866 },
2867 name: {
2868 let child = node
2869 .child_by_field_name("name")
2870 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2871 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2872 },
2873 children: {
2874 #[allow(clippy::suspicious_else_formatting)]
2875 let non_field_children = {
2876 let mut cursor = node.walk();
2877 let mut result = ::std::vec::Vec::new();
2878 if cursor.goto_first_child() {
2879 loop {
2880 if cursor.field_name().is_none()
2881 && cursor.node().is_named()
2882 && !cursor.node().is_extra()
2883 {
2884 result.push(cursor.node());
2885 }
2886 if !cursor.goto_next_sibling() {
2887 break;
2888 }
2889 }
2890 }
2891 result
2892 };
2893 match non_field_children.first() {
2894 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
2895 child, src,
2896 )?),
2897 None => None,
2898 }
2899 },
2900 })
2901 }
2902}
2903impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
2904 fn span(&self) -> ::treesitter_types::Span {
2905 self.span
2906 }
2907}
2908#[derive(Debug, Clone, PartialEq, Eq)]
2909pub struct ExplicitConstructorInvocation<'tree> {
2910 pub span: ::treesitter_types::Span,
2911 pub arguments: ArgumentList<'tree>,
2912 pub constructor: ExplicitConstructorInvocationConstructor<'tree>,
2913 pub object: ::core::option::Option<PrimaryExpression<'tree>>,
2914 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
2915}
2916impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitConstructorInvocation<'tree> {
2917 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2918 fn from_node(
2919 node: ::tree_sitter::Node<'tree>,
2920 src: &'tree [u8],
2921 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2922 debug_assert_eq!(node.kind(), "explicit_constructor_invocation");
2923 Ok(Self {
2924 span: ::treesitter_types::Span::from(node),
2925 arguments: {
2926 let child = node.child_by_field_name("arguments").ok_or_else(|| {
2927 ::treesitter_types::ParseError::missing_field("arguments", node)
2928 })?;
2929 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
2930 },
2931 constructor: {
2932 let child = node.child_by_field_name("constructor").ok_or_else(|| {
2933 ::treesitter_types::ParseError::missing_field("constructor", node)
2934 })?;
2935 <ExplicitConstructorInvocationConstructor as ::treesitter_types::FromNode>::from_node(
2936 child,
2937 src,
2938 )?
2939 },
2940 object: match node.child_by_field_name("object") {
2941 Some(child) => Some(
2942 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?,
2943 ),
2944 None => None,
2945 },
2946 type_arguments: match node.child_by_field_name("type_arguments") {
2947 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
2948 child, src,
2949 )?),
2950 None => None,
2951 },
2952 })
2953 }
2954}
2955impl ::treesitter_types::Spanned for ExplicitConstructorInvocation<'_> {
2956 fn span(&self) -> ::treesitter_types::Span {
2957 self.span
2958 }
2959}
2960#[derive(Debug, Clone, PartialEq, Eq)]
2961pub struct ExportsModuleDirective<'tree> {
2962 pub span: ::treesitter_types::Span,
2963 pub modules: ::std::vec::Vec<ExportsModuleDirectiveModules<'tree>>,
2964 pub package: ExportsModuleDirectivePackage<'tree>,
2965}
2966impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirective<'tree> {
2967 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2968 fn from_node(
2969 node: ::tree_sitter::Node<'tree>,
2970 src: &'tree [u8],
2971 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2972 debug_assert_eq!(node.kind(), "exports_module_directive");
2973 Ok(Self {
2974 span: ::treesitter_types::Span::from(node),
2975 modules: {
2976 let mut cursor = node.walk();
2977 let mut items = ::std::vec::Vec::new();
2978 for child in node.children_by_field_name("modules", &mut cursor) {
2979 items.push(
2980 <ExportsModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
2981 child, src,
2982 )?,
2983 );
2984 }
2985 items
2986 },
2987 package: {
2988 let child = node.child_by_field_name("package").ok_or_else(|| {
2989 ::treesitter_types::ParseError::missing_field("package", node)
2990 })?;
2991 <ExportsModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
2992 child, src,
2993 )?
2994 },
2995 })
2996 }
2997}
2998impl ::treesitter_types::Spanned for ExportsModuleDirective<'_> {
2999 fn span(&self) -> ::treesitter_types::Span {
3000 self.span
3001 }
3002}
3003#[derive(Debug, Clone, PartialEq, Eq)]
3004pub struct ExpressionStatement<'tree> {
3005 pub span: ::treesitter_types::Span,
3006 pub children: Expression<'tree>,
3007}
3008impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3009 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3010 fn from_node(
3011 node: ::tree_sitter::Node<'tree>,
3012 src: &'tree [u8],
3013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3014 debug_assert_eq!(node.kind(), "expression_statement");
3015 Ok(Self {
3016 span: ::treesitter_types::Span::from(node),
3017 children: {
3018 #[allow(clippy::suspicious_else_formatting)]
3019 let non_field_children = {
3020 let mut cursor = node.walk();
3021 let mut result = ::std::vec::Vec::new();
3022 if cursor.goto_first_child() {
3023 loop {
3024 if cursor.field_name().is_none()
3025 && cursor.node().is_named()
3026 && !cursor.node().is_extra()
3027 {
3028 result.push(cursor.node());
3029 }
3030 if !cursor.goto_next_sibling() {
3031 break;
3032 }
3033 }
3034 }
3035 result
3036 };
3037 let child = if let Some(&c) = non_field_children.first() {
3038 c
3039 } else {
3040 let mut fallback_cursor = node.walk();
3041 let mut fallback_child = None;
3042 if fallback_cursor.goto_first_child() {
3043 loop {
3044 if fallback_cursor.field_name().is_none()
3045 && !fallback_cursor.node().is_extra()
3046 {
3047 let candidate = fallback_cursor.node();
3048 #[allow(clippy::needless_question_mark)]
3049 if (|| -> ::core::result::Result<
3050 _,
3051 ::treesitter_types::ParseError,
3052 > {
3053 let child = candidate;
3054 Ok(
3055 <Expression as ::treesitter_types::FromNode>::from_node(
3056 child,
3057 src,
3058 )?,
3059 )
3060 })()
3061 .is_ok()
3062 {
3063 fallback_child = Some(candidate);
3064 break;
3065 }
3066 }
3067 if !fallback_cursor.goto_next_sibling() {
3068 break;
3069 }
3070 }
3071 }
3072 if fallback_child.is_none() {
3073 let mut cursor2 = node.walk();
3074 if cursor2.goto_first_child() {
3075 loop {
3076 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3077 let candidate = cursor2.node();
3078 #[allow(clippy::needless_question_mark)]
3079 if (|| -> ::core::result::Result<
3080 _,
3081 ::treesitter_types::ParseError,
3082 > {
3083 let child = candidate;
3084 Ok(
3085 <Expression as ::treesitter_types::FromNode>::from_node(
3086 child,
3087 src,
3088 )?,
3089 )
3090 })()
3091 .is_ok()
3092 {
3093 fallback_child = Some(candidate);
3094 break;
3095 }
3096 }
3097 if !cursor2.goto_next_sibling() {
3098 break;
3099 }
3100 }
3101 }
3102 }
3103 fallback_child.ok_or_else(|| {
3104 ::treesitter_types::ParseError::missing_field("children", node)
3105 })?
3106 };
3107 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3108 },
3109 })
3110 }
3111}
3112impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3113 fn span(&self) -> ::treesitter_types::Span {
3114 self.span
3115 }
3116}
3117#[derive(Debug, Clone, PartialEq, Eq)]
3118pub struct ExtendsInterfaces<'tree> {
3119 pub span: ::treesitter_types::Span,
3120 pub children: TypeList<'tree>,
3121}
3122impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsInterfaces<'tree> {
3123 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3124 fn from_node(
3125 node: ::tree_sitter::Node<'tree>,
3126 src: &'tree [u8],
3127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3128 debug_assert_eq!(node.kind(), "extends_interfaces");
3129 Ok(Self {
3130 span: ::treesitter_types::Span::from(node),
3131 children: {
3132 #[allow(clippy::suspicious_else_formatting)]
3133 let non_field_children = {
3134 let mut cursor = node.walk();
3135 let mut result = ::std::vec::Vec::new();
3136 if cursor.goto_first_child() {
3137 loop {
3138 if cursor.field_name().is_none()
3139 && cursor.node().is_named()
3140 && !cursor.node().is_extra()
3141 {
3142 result.push(cursor.node());
3143 }
3144 if !cursor.goto_next_sibling() {
3145 break;
3146 }
3147 }
3148 }
3149 result
3150 };
3151 let child = if let Some(&c) = non_field_children.first() {
3152 c
3153 } else {
3154 let mut fallback_cursor = node.walk();
3155 let mut fallback_child = None;
3156 if fallback_cursor.goto_first_child() {
3157 loop {
3158 if fallback_cursor.field_name().is_none()
3159 && !fallback_cursor.node().is_extra()
3160 {
3161 let candidate = fallback_cursor.node();
3162 #[allow(clippy::needless_question_mark)]
3163 if (|| -> ::core::result::Result<
3164 _,
3165 ::treesitter_types::ParseError,
3166 > {
3167 let child = candidate;
3168 Ok(
3169 <TypeList as ::treesitter_types::FromNode>::from_node(
3170 child,
3171 src,
3172 )?,
3173 )
3174 })()
3175 .is_ok()
3176 {
3177 fallback_child = Some(candidate);
3178 break;
3179 }
3180 }
3181 if !fallback_cursor.goto_next_sibling() {
3182 break;
3183 }
3184 }
3185 }
3186 if fallback_child.is_none() {
3187 let mut cursor2 = node.walk();
3188 if cursor2.goto_first_child() {
3189 loop {
3190 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3191 let candidate = cursor2.node();
3192 #[allow(clippy::needless_question_mark)]
3193 if (|| -> ::core::result::Result<
3194 _,
3195 ::treesitter_types::ParseError,
3196 > {
3197 let child = candidate;
3198 Ok(
3199 <TypeList as ::treesitter_types::FromNode>::from_node(
3200 child,
3201 src,
3202 )?,
3203 )
3204 })()
3205 .is_ok()
3206 {
3207 fallback_child = Some(candidate);
3208 break;
3209 }
3210 }
3211 if !cursor2.goto_next_sibling() {
3212 break;
3213 }
3214 }
3215 }
3216 }
3217 fallback_child.ok_or_else(|| {
3218 ::treesitter_types::ParseError::missing_field("children", node)
3219 })?
3220 };
3221 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
3222 },
3223 })
3224 }
3225}
3226impl ::treesitter_types::Spanned for ExtendsInterfaces<'_> {
3227 fn span(&self) -> ::treesitter_types::Span {
3228 self.span
3229 }
3230}
3231#[derive(Debug, Clone, PartialEq, Eq)]
3232pub struct FieldAccess<'tree> {
3233 pub span: ::treesitter_types::Span,
3234 pub field: FieldAccessField<'tree>,
3235 pub object: FieldAccessObject<'tree>,
3236 pub children: ::core::option::Option<Super<'tree>>,
3237}
3238impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccess<'tree> {
3239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3240 fn from_node(
3241 node: ::tree_sitter::Node<'tree>,
3242 src: &'tree [u8],
3243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3244 debug_assert_eq!(node.kind(), "field_access");
3245 Ok(Self {
3246 span: ::treesitter_types::Span::from(node),
3247 field: {
3248 let child = node
3249 .child_by_field_name("field")
3250 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3251 <FieldAccessField as ::treesitter_types::FromNode>::from_node(child, src)?
3252 },
3253 object: {
3254 let child = node
3255 .child_by_field_name("object")
3256 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
3257 <FieldAccessObject as ::treesitter_types::FromNode>::from_node(child, src)?
3258 },
3259 children: {
3260 #[allow(clippy::suspicious_else_formatting)]
3261 let non_field_children = {
3262 let mut cursor = node.walk();
3263 let mut result = ::std::vec::Vec::new();
3264 if cursor.goto_first_child() {
3265 loop {
3266 if cursor.field_name().is_none()
3267 && cursor.node().is_named()
3268 && !cursor.node().is_extra()
3269 {
3270 result.push(cursor.node());
3271 }
3272 if !cursor.goto_next_sibling() {
3273 break;
3274 }
3275 }
3276 }
3277 result
3278 };
3279 match non_field_children.first() {
3280 Some(&child) => Some(<Super as ::treesitter_types::FromNode>::from_node(
3281 child, src,
3282 )?),
3283 None => None,
3284 }
3285 },
3286 })
3287 }
3288}
3289impl ::treesitter_types::Spanned for FieldAccess<'_> {
3290 fn span(&self) -> ::treesitter_types::Span {
3291 self.span
3292 }
3293}
3294#[derive(Debug, Clone, PartialEq, Eq)]
3295pub struct FieldDeclaration<'tree> {
3296 pub span: ::treesitter_types::Span,
3297 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
3298 pub r#type: UnannotatedType<'tree>,
3299 pub children: ::core::option::Option<Modifiers<'tree>>,
3300}
3301impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
3302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3303 fn from_node(
3304 node: ::tree_sitter::Node<'tree>,
3305 src: &'tree [u8],
3306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3307 debug_assert_eq!(node.kind(), "field_declaration");
3308 Ok(Self {
3309 span: ::treesitter_types::Span::from(node),
3310 declarator: {
3311 let mut cursor = node.walk();
3312 let mut items = ::std::vec::Vec::new();
3313 for child in node.children_by_field_name("declarator", &mut cursor) {
3314 items.push(
3315 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
3316 child, src,
3317 )?,
3318 );
3319 }
3320 items
3321 },
3322 r#type: {
3323 let child = node
3324 .child_by_field_name("type")
3325 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3326 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
3327 },
3328 children: {
3329 #[allow(clippy::suspicious_else_formatting)]
3330 let non_field_children = {
3331 let mut cursor = node.walk();
3332 let mut result = ::std::vec::Vec::new();
3333 if cursor.goto_first_child() {
3334 loop {
3335 if cursor.field_name().is_none()
3336 && cursor.node().is_named()
3337 && !cursor.node().is_extra()
3338 {
3339 result.push(cursor.node());
3340 }
3341 if !cursor.goto_next_sibling() {
3342 break;
3343 }
3344 }
3345 }
3346 result
3347 };
3348 match non_field_children.first() {
3349 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
3350 child, src,
3351 )?),
3352 None => None,
3353 }
3354 },
3355 })
3356 }
3357}
3358impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
3359 fn span(&self) -> ::treesitter_types::Span {
3360 self.span
3361 }
3362}
3363#[derive(Debug, Clone, PartialEq, Eq)]
3364pub struct FinallyClause<'tree> {
3365 pub span: ::treesitter_types::Span,
3366 pub children: Block<'tree>,
3367}
3368impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3370 fn from_node(
3371 node: ::tree_sitter::Node<'tree>,
3372 src: &'tree [u8],
3373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3374 debug_assert_eq!(node.kind(), "finally_clause");
3375 Ok(Self {
3376 span: ::treesitter_types::Span::from(node),
3377 children: {
3378 #[allow(clippy::suspicious_else_formatting)]
3379 let non_field_children = {
3380 let mut cursor = node.walk();
3381 let mut result = ::std::vec::Vec::new();
3382 if cursor.goto_first_child() {
3383 loop {
3384 if cursor.field_name().is_none()
3385 && cursor.node().is_named()
3386 && !cursor.node().is_extra()
3387 {
3388 result.push(cursor.node());
3389 }
3390 if !cursor.goto_next_sibling() {
3391 break;
3392 }
3393 }
3394 }
3395 result
3396 };
3397 let child = if let Some(&c) = non_field_children.first() {
3398 c
3399 } else {
3400 let mut fallback_cursor = node.walk();
3401 let mut fallback_child = None;
3402 if fallback_cursor.goto_first_child() {
3403 loop {
3404 if fallback_cursor.field_name().is_none()
3405 && !fallback_cursor.node().is_extra()
3406 {
3407 let candidate = fallback_cursor.node();
3408 #[allow(clippy::needless_question_mark)]
3409 if (|| -> ::core::result::Result<
3410 _,
3411 ::treesitter_types::ParseError,
3412 > {
3413 let child = candidate;
3414 Ok(
3415 <Block as ::treesitter_types::FromNode>::from_node(
3416 child,
3417 src,
3418 )?,
3419 )
3420 })()
3421 .is_ok()
3422 {
3423 fallback_child = Some(candidate);
3424 break;
3425 }
3426 }
3427 if !fallback_cursor.goto_next_sibling() {
3428 break;
3429 }
3430 }
3431 }
3432 if fallback_child.is_none() {
3433 let mut cursor2 = node.walk();
3434 if cursor2.goto_first_child() {
3435 loop {
3436 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3437 let candidate = cursor2.node();
3438 #[allow(clippy::needless_question_mark)]
3439 if (|| -> ::core::result::Result<
3440 _,
3441 ::treesitter_types::ParseError,
3442 > {
3443 let child = candidate;
3444 Ok(
3445 <Block as ::treesitter_types::FromNode>::from_node(
3446 child,
3447 src,
3448 )?,
3449 )
3450 })()
3451 .is_ok()
3452 {
3453 fallback_child = Some(candidate);
3454 break;
3455 }
3456 }
3457 if !cursor2.goto_next_sibling() {
3458 break;
3459 }
3460 }
3461 }
3462 }
3463 fallback_child.ok_or_else(|| {
3464 ::treesitter_types::ParseError::missing_field("children", node)
3465 })?
3466 };
3467 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3468 },
3469 })
3470 }
3471}
3472impl ::treesitter_types::Spanned for FinallyClause<'_> {
3473 fn span(&self) -> ::treesitter_types::Span {
3474 self.span
3475 }
3476}
3477#[derive(Debug, Clone, PartialEq, Eq)]
3478pub struct FloatingPointType<'tree> {
3479 pub span: ::treesitter_types::Span,
3480 text: &'tree str,
3481}
3482impl<'tree> ::treesitter_types::FromNode<'tree> for FloatingPointType<'tree> {
3483 fn from_node(
3484 node: ::tree_sitter::Node<'tree>,
3485 src: &'tree [u8],
3486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3487 debug_assert_eq!(node.kind(), "floating_point_type");
3488 Ok(Self {
3489 span: ::treesitter_types::Span::from(node),
3490 text: node.utf8_text(src)?,
3491 })
3492 }
3493}
3494impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatingPointType<'tree> {
3495 fn text(&self) -> &'tree str {
3496 self.text
3497 }
3498}
3499impl ::treesitter_types::Spanned for FloatingPointType<'_> {
3500 fn span(&self) -> ::treesitter_types::Span {
3501 self.span
3502 }
3503}
3504#[derive(Debug, Clone, PartialEq, Eq)]
3505pub struct ForStatement<'tree> {
3506 pub span: ::treesitter_types::Span,
3507 pub body: Statement<'tree>,
3508 pub condition: ::core::option::Option<Expression<'tree>>,
3509 pub init: ::std::vec::Vec<ForStatementInit<'tree>>,
3510 pub update: ::std::vec::Vec<Expression<'tree>>,
3511}
3512impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3513 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3514 fn from_node(
3515 node: ::tree_sitter::Node<'tree>,
3516 src: &'tree [u8],
3517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3518 debug_assert_eq!(node.kind(), "for_statement");
3519 Ok(Self {
3520 span: ::treesitter_types::Span::from(node),
3521 body: {
3522 let child = node
3523 .child_by_field_name("body")
3524 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3525 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3526 },
3527 condition: match node.child_by_field_name("condition") {
3528 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3529 child, src,
3530 )?),
3531 None => None,
3532 },
3533 init: {
3534 let mut cursor = node.walk();
3535 let mut items = ::std::vec::Vec::new();
3536 for child in node.children_by_field_name("init", &mut cursor) {
3537 items.push(
3538 <ForStatementInit as ::treesitter_types::FromNode>::from_node(child, src)?,
3539 );
3540 }
3541 items
3542 },
3543 update: {
3544 let mut cursor = node.walk();
3545 let mut items = ::std::vec::Vec::new();
3546 for child in node.children_by_field_name("update", &mut cursor) {
3547 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
3548 child, src,
3549 )?);
3550 }
3551 items
3552 },
3553 })
3554 }
3555}
3556impl ::treesitter_types::Spanned for ForStatement<'_> {
3557 fn span(&self) -> ::treesitter_types::Span {
3558 self.span
3559 }
3560}
3561#[derive(Debug, Clone, PartialEq, Eq)]
3562pub struct FormalParameter<'tree> {
3563 pub span: ::treesitter_types::Span,
3564 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
3565 pub name: FormalParameterName<'tree>,
3566 pub r#type: UnannotatedType<'tree>,
3567 pub children: ::core::option::Option<Modifiers<'tree>>,
3568}
3569impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameter<'tree> {
3570 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3571 fn from_node(
3572 node: ::tree_sitter::Node<'tree>,
3573 src: &'tree [u8],
3574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3575 debug_assert_eq!(node.kind(), "formal_parameter");
3576 Ok(Self {
3577 span: ::treesitter_types::Span::from(node),
3578 dimensions: match node.child_by_field_name("dimensions") {
3579 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
3580 child, src,
3581 )?),
3582 None => None,
3583 },
3584 name: {
3585 let child = node
3586 .child_by_field_name("name")
3587 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3588 <FormalParameterName as ::treesitter_types::FromNode>::from_node(child, src)?
3589 },
3590 r#type: {
3591 let child = node
3592 .child_by_field_name("type")
3593 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3594 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
3595 },
3596 children: {
3597 #[allow(clippy::suspicious_else_formatting)]
3598 let non_field_children = {
3599 let mut cursor = node.walk();
3600 let mut result = ::std::vec::Vec::new();
3601 if cursor.goto_first_child() {
3602 loop {
3603 if cursor.field_name().is_none()
3604 && cursor.node().is_named()
3605 && !cursor.node().is_extra()
3606 {
3607 result.push(cursor.node());
3608 }
3609 if !cursor.goto_next_sibling() {
3610 break;
3611 }
3612 }
3613 }
3614 result
3615 };
3616 match non_field_children.first() {
3617 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
3618 child, src,
3619 )?),
3620 None => None,
3621 }
3622 },
3623 })
3624 }
3625}
3626impl ::treesitter_types::Spanned for FormalParameter<'_> {
3627 fn span(&self) -> ::treesitter_types::Span {
3628 self.span
3629 }
3630}
3631#[derive(Debug, Clone, PartialEq, Eq)]
3632pub struct FormalParameters<'tree> {
3633 pub span: ::treesitter_types::Span,
3634 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
3635}
3636impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
3637 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3638 fn from_node(
3639 node: ::tree_sitter::Node<'tree>,
3640 src: &'tree [u8],
3641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3642 debug_assert_eq!(node.kind(), "formal_parameters");
3643 Ok(Self {
3644 span: ::treesitter_types::Span::from(node),
3645 children: {
3646 #[allow(clippy::suspicious_else_formatting)]
3647 let non_field_children = {
3648 let mut cursor = node.walk();
3649 let mut result = ::std::vec::Vec::new();
3650 if cursor.goto_first_child() {
3651 loop {
3652 if cursor.field_name().is_none()
3653 && cursor.node().is_named()
3654 && !cursor.node().is_extra()
3655 {
3656 result.push(cursor.node());
3657 }
3658 if !cursor.goto_next_sibling() {
3659 break;
3660 }
3661 }
3662 }
3663 result
3664 };
3665 let mut items = ::std::vec::Vec::new();
3666 for child in non_field_children {
3667 items.push(
3668 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
3669 child, src,
3670 )?,
3671 );
3672 }
3673 items
3674 },
3675 })
3676 }
3677}
3678impl ::treesitter_types::Spanned for FormalParameters<'_> {
3679 fn span(&self) -> ::treesitter_types::Span {
3680 self.span
3681 }
3682}
3683#[derive(Debug, Clone, PartialEq, Eq)]
3684pub struct GenericType<'tree> {
3685 pub span: ::treesitter_types::Span,
3686 pub children: ::std::vec::Vec<GenericTypeChildren<'tree>>,
3687}
3688impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
3689 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3690 fn from_node(
3691 node: ::tree_sitter::Node<'tree>,
3692 src: &'tree [u8],
3693 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3694 debug_assert_eq!(node.kind(), "generic_type");
3695 Ok(Self {
3696 span: ::treesitter_types::Span::from(node),
3697 children: {
3698 #[allow(clippy::suspicious_else_formatting)]
3699 let non_field_children = {
3700 let mut cursor = node.walk();
3701 let mut result = ::std::vec::Vec::new();
3702 if cursor.goto_first_child() {
3703 loop {
3704 if cursor.field_name().is_none()
3705 && cursor.node().is_named()
3706 && !cursor.node().is_extra()
3707 {
3708 result.push(cursor.node());
3709 }
3710 if !cursor.goto_next_sibling() {
3711 break;
3712 }
3713 }
3714 }
3715 result
3716 };
3717 let mut items = ::std::vec::Vec::new();
3718 for child in non_field_children {
3719 items.push(
3720 <GenericTypeChildren as ::treesitter_types::FromNode>::from_node(
3721 child, src,
3722 )?,
3723 );
3724 }
3725 items
3726 },
3727 })
3728 }
3729}
3730impl ::treesitter_types::Spanned for GenericType<'_> {
3731 fn span(&self) -> ::treesitter_types::Span {
3732 self.span
3733 }
3734}
3735#[derive(Debug, Clone, PartialEq, Eq)]
3736pub struct Guard<'tree> {
3737 pub span: ::treesitter_types::Span,
3738 pub children: Expression<'tree>,
3739}
3740impl<'tree> ::treesitter_types::FromNode<'tree> for Guard<'tree> {
3741 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3742 fn from_node(
3743 node: ::tree_sitter::Node<'tree>,
3744 src: &'tree [u8],
3745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3746 debug_assert_eq!(node.kind(), "guard");
3747 Ok(Self {
3748 span: ::treesitter_types::Span::from(node),
3749 children: {
3750 #[allow(clippy::suspicious_else_formatting)]
3751 let non_field_children = {
3752 let mut cursor = node.walk();
3753 let mut result = ::std::vec::Vec::new();
3754 if cursor.goto_first_child() {
3755 loop {
3756 if cursor.field_name().is_none()
3757 && cursor.node().is_named()
3758 && !cursor.node().is_extra()
3759 {
3760 result.push(cursor.node());
3761 }
3762 if !cursor.goto_next_sibling() {
3763 break;
3764 }
3765 }
3766 }
3767 result
3768 };
3769 let child = if let Some(&c) = non_field_children.first() {
3770 c
3771 } else {
3772 let mut fallback_cursor = node.walk();
3773 let mut fallback_child = None;
3774 if fallback_cursor.goto_first_child() {
3775 loop {
3776 if fallback_cursor.field_name().is_none()
3777 && !fallback_cursor.node().is_extra()
3778 {
3779 let candidate = fallback_cursor.node();
3780 #[allow(clippy::needless_question_mark)]
3781 if (|| -> ::core::result::Result<
3782 _,
3783 ::treesitter_types::ParseError,
3784 > {
3785 let child = candidate;
3786 Ok(
3787 <Expression as ::treesitter_types::FromNode>::from_node(
3788 child,
3789 src,
3790 )?,
3791 )
3792 })()
3793 .is_ok()
3794 {
3795 fallback_child = Some(candidate);
3796 break;
3797 }
3798 }
3799 if !fallback_cursor.goto_next_sibling() {
3800 break;
3801 }
3802 }
3803 }
3804 if fallback_child.is_none() {
3805 let mut cursor2 = node.walk();
3806 if cursor2.goto_first_child() {
3807 loop {
3808 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3809 let candidate = cursor2.node();
3810 #[allow(clippy::needless_question_mark)]
3811 if (|| -> ::core::result::Result<
3812 _,
3813 ::treesitter_types::ParseError,
3814 > {
3815 let child = candidate;
3816 Ok(
3817 <Expression as ::treesitter_types::FromNode>::from_node(
3818 child,
3819 src,
3820 )?,
3821 )
3822 })()
3823 .is_ok()
3824 {
3825 fallback_child = Some(candidate);
3826 break;
3827 }
3828 }
3829 if !cursor2.goto_next_sibling() {
3830 break;
3831 }
3832 }
3833 }
3834 }
3835 fallback_child.ok_or_else(|| {
3836 ::treesitter_types::ParseError::missing_field("children", node)
3837 })?
3838 };
3839 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3840 },
3841 })
3842 }
3843}
3844impl ::treesitter_types::Spanned for Guard<'_> {
3845 fn span(&self) -> ::treesitter_types::Span {
3846 self.span
3847 }
3848}
3849#[derive(Debug, Clone, PartialEq, Eq)]
3850pub struct IfStatement<'tree> {
3851 pub span: ::treesitter_types::Span,
3852 pub alternative: ::core::option::Option<Statement<'tree>>,
3853 pub condition: ParenthesizedExpression<'tree>,
3854 pub consequence: Statement<'tree>,
3855}
3856impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
3857 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3858 fn from_node(
3859 node: ::tree_sitter::Node<'tree>,
3860 src: &'tree [u8],
3861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3862 debug_assert_eq!(node.kind(), "if_statement");
3863 Ok(Self {
3864 span: ::treesitter_types::Span::from(node),
3865 alternative: match node.child_by_field_name("alternative") {
3866 Some(child) => Some(<Statement as ::treesitter_types::FromNode>::from_node(
3867 child, src,
3868 )?),
3869 None => None,
3870 },
3871 condition: {
3872 let child = node.child_by_field_name("condition").ok_or_else(|| {
3873 ::treesitter_types::ParseError::missing_field("condition", node)
3874 })?;
3875 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
3876 },
3877 consequence: {
3878 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3879 ::treesitter_types::ParseError::missing_field("consequence", node)
3880 })?;
3881 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3882 },
3883 })
3884 }
3885}
3886impl ::treesitter_types::Spanned for IfStatement<'_> {
3887 fn span(&self) -> ::treesitter_types::Span {
3888 self.span
3889 }
3890}
3891#[derive(Debug, Clone, PartialEq, Eq)]
3892pub struct ImportDeclaration<'tree> {
3893 pub span: ::treesitter_types::Span,
3894 pub children: ::std::vec::Vec<ImportDeclarationChildren<'tree>>,
3895}
3896impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclaration<'tree> {
3897 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3898 fn from_node(
3899 node: ::tree_sitter::Node<'tree>,
3900 src: &'tree [u8],
3901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3902 debug_assert_eq!(node.kind(), "import_declaration");
3903 Ok(Self {
3904 span: ::treesitter_types::Span::from(node),
3905 children: {
3906 #[allow(clippy::suspicious_else_formatting)]
3907 let non_field_children = {
3908 let mut cursor = node.walk();
3909 let mut result = ::std::vec::Vec::new();
3910 if cursor.goto_first_child() {
3911 loop {
3912 if cursor.field_name().is_none()
3913 && cursor.node().is_named()
3914 && !cursor.node().is_extra()
3915 {
3916 result.push(cursor.node());
3917 }
3918 if !cursor.goto_next_sibling() {
3919 break;
3920 }
3921 }
3922 }
3923 result
3924 };
3925 let mut items = ::std::vec::Vec::new();
3926 for child in non_field_children {
3927 items.push(
3928 <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3929 child, src,
3930 )?,
3931 );
3932 }
3933 items
3934 },
3935 })
3936 }
3937}
3938impl ::treesitter_types::Spanned for ImportDeclaration<'_> {
3939 fn span(&self) -> ::treesitter_types::Span {
3940 self.span
3941 }
3942}
3943#[derive(Debug, Clone, PartialEq, Eq)]
3944pub struct InferredParameters<'tree> {
3945 pub span: ::treesitter_types::Span,
3946 pub children: ::std::vec::Vec<Identifier<'tree>>,
3947}
3948impl<'tree> ::treesitter_types::FromNode<'tree> for InferredParameters<'tree> {
3949 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3950 fn from_node(
3951 node: ::tree_sitter::Node<'tree>,
3952 src: &'tree [u8],
3953 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3954 debug_assert_eq!(node.kind(), "inferred_parameters");
3955 Ok(Self {
3956 span: ::treesitter_types::Span::from(node),
3957 children: {
3958 #[allow(clippy::suspicious_else_formatting)]
3959 let non_field_children = {
3960 let mut cursor = node.walk();
3961 let mut result = ::std::vec::Vec::new();
3962 if cursor.goto_first_child() {
3963 loop {
3964 if cursor.field_name().is_none()
3965 && cursor.node().is_named()
3966 && !cursor.node().is_extra()
3967 {
3968 result.push(cursor.node());
3969 }
3970 if !cursor.goto_next_sibling() {
3971 break;
3972 }
3973 }
3974 }
3975 result
3976 };
3977 let mut items = ::std::vec::Vec::new();
3978 for child in non_field_children {
3979 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
3980 child, src,
3981 )?);
3982 }
3983 items
3984 },
3985 })
3986 }
3987}
3988impl ::treesitter_types::Spanned for InferredParameters<'_> {
3989 fn span(&self) -> ::treesitter_types::Span {
3990 self.span
3991 }
3992}
3993#[derive(Debug, Clone, PartialEq, Eq)]
3994pub struct InstanceofExpression<'tree> {
3995 pub span: ::treesitter_types::Span,
3996 pub left: Expression<'tree>,
3997 pub name: ::core::option::Option<Identifier<'tree>>,
3998 pub pattern: ::core::option::Option<RecordPattern<'tree>>,
3999 pub right: ::core::option::Option<Type<'tree>>,
4000}
4001impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceofExpression<'tree> {
4002 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4003 fn from_node(
4004 node: ::tree_sitter::Node<'tree>,
4005 src: &'tree [u8],
4006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4007 debug_assert_eq!(node.kind(), "instanceof_expression");
4008 Ok(Self {
4009 span: ::treesitter_types::Span::from(node),
4010 left: {
4011 let child = node
4012 .child_by_field_name("left")
4013 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4014 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4015 },
4016 name: match node.child_by_field_name("name") {
4017 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
4018 child, src,
4019 )?),
4020 None => None,
4021 },
4022 pattern: match node.child_by_field_name("pattern") {
4023 Some(child) => Some(<RecordPattern as ::treesitter_types::FromNode>::from_node(
4024 child, src,
4025 )?),
4026 None => None,
4027 },
4028 right: match node.child_by_field_name("right") {
4029 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
4030 child, src,
4031 )?),
4032 None => None,
4033 },
4034 })
4035 }
4036}
4037impl ::treesitter_types::Spanned for InstanceofExpression<'_> {
4038 fn span(&self) -> ::treesitter_types::Span {
4039 self.span
4040 }
4041}
4042#[derive(Debug, Clone, PartialEq, Eq)]
4043pub struct IntegralType<'tree> {
4044 pub span: ::treesitter_types::Span,
4045 text: &'tree str,
4046}
4047impl<'tree> ::treesitter_types::FromNode<'tree> for IntegralType<'tree> {
4048 fn from_node(
4049 node: ::tree_sitter::Node<'tree>,
4050 src: &'tree [u8],
4051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4052 debug_assert_eq!(node.kind(), "integral_type");
4053 Ok(Self {
4054 span: ::treesitter_types::Span::from(node),
4055 text: node.utf8_text(src)?,
4056 })
4057 }
4058}
4059impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegralType<'tree> {
4060 fn text(&self) -> &'tree str {
4061 self.text
4062 }
4063}
4064impl ::treesitter_types::Spanned for IntegralType<'_> {
4065 fn span(&self) -> ::treesitter_types::Span {
4066 self.span
4067 }
4068}
4069#[derive(Debug, Clone, PartialEq, Eq)]
4070pub struct InterfaceBody<'tree> {
4071 pub span: ::treesitter_types::Span,
4072 pub children: ::std::vec::Vec<InterfaceBodyChildren<'tree>>,
4073}
4074impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBody<'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(), "interface_body");
4081 Ok(Self {
4082 span: ::treesitter_types::Span::from(node),
4083 children: {
4084 #[allow(clippy::suspicious_else_formatting)]
4085 let non_field_children = {
4086 let mut cursor = node.walk();
4087 let mut result = ::std::vec::Vec::new();
4088 if cursor.goto_first_child() {
4089 loop {
4090 if cursor.field_name().is_none()
4091 && cursor.node().is_named()
4092 && !cursor.node().is_extra()
4093 {
4094 result.push(cursor.node());
4095 }
4096 if !cursor.goto_next_sibling() {
4097 break;
4098 }
4099 }
4100 }
4101 result
4102 };
4103 let mut items = ::std::vec::Vec::new();
4104 for child in non_field_children {
4105 items.push(
4106 <InterfaceBodyChildren as ::treesitter_types::FromNode>::from_node(
4107 child, src,
4108 )?,
4109 );
4110 }
4111 items
4112 },
4113 })
4114 }
4115}
4116impl ::treesitter_types::Spanned for InterfaceBody<'_> {
4117 fn span(&self) -> ::treesitter_types::Span {
4118 self.span
4119 }
4120}
4121#[derive(Debug, Clone, PartialEq, Eq)]
4122pub struct InterfaceDeclaration<'tree> {
4123 pub span: ::treesitter_types::Span,
4124 pub body: InterfaceBody<'tree>,
4125 pub name: Identifier<'tree>,
4126 pub permits: ::core::option::Option<Permits<'tree>>,
4127 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4128 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
4129}
4130impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
4131 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4132 fn from_node(
4133 node: ::tree_sitter::Node<'tree>,
4134 src: &'tree [u8],
4135 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4136 debug_assert_eq!(node.kind(), "interface_declaration");
4137 Ok(Self {
4138 span: ::treesitter_types::Span::from(node),
4139 body: {
4140 let child = node
4141 .child_by_field_name("body")
4142 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4143 <InterfaceBody as ::treesitter_types::FromNode>::from_node(child, src)?
4144 },
4145 name: {
4146 let child = node
4147 .child_by_field_name("name")
4148 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4149 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4150 },
4151 permits: match node.child_by_field_name("permits") {
4152 Some(child) => Some(<Permits as ::treesitter_types::FromNode>::from_node(
4153 child, src,
4154 )?),
4155 None => None,
4156 },
4157 type_parameters: match node.child_by_field_name("type_parameters") {
4158 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
4159 child, src,
4160 )?),
4161 None => None,
4162 },
4163 children: {
4164 #[allow(clippy::suspicious_else_formatting)]
4165 let non_field_children = {
4166 let mut cursor = node.walk();
4167 let mut result = ::std::vec::Vec::new();
4168 if cursor.goto_first_child() {
4169 loop {
4170 if cursor.field_name().is_none()
4171 && cursor.node().is_named()
4172 && !cursor.node().is_extra()
4173 {
4174 result.push(cursor.node());
4175 }
4176 if !cursor.goto_next_sibling() {
4177 break;
4178 }
4179 }
4180 }
4181 result
4182 };
4183 let mut items = ::std::vec::Vec::new();
4184 for child in non_field_children {
4185 items.push(
4186 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4187 child, src,
4188 )?,
4189 );
4190 }
4191 items
4192 },
4193 })
4194 }
4195}
4196impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
4197 fn span(&self) -> ::treesitter_types::Span {
4198 self.span
4199 }
4200}
4201#[derive(Debug, Clone, PartialEq, Eq)]
4202pub struct LabeledStatement<'tree> {
4203 pub span: ::treesitter_types::Span,
4204 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
4205}
4206impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
4207 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4208 fn from_node(
4209 node: ::tree_sitter::Node<'tree>,
4210 src: &'tree [u8],
4211 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4212 debug_assert_eq!(node.kind(), "labeled_statement");
4213 Ok(Self {
4214 span: ::treesitter_types::Span::from(node),
4215 children: {
4216 #[allow(clippy::suspicious_else_formatting)]
4217 let non_field_children = {
4218 let mut cursor = node.walk();
4219 let mut result = ::std::vec::Vec::new();
4220 if cursor.goto_first_child() {
4221 loop {
4222 if cursor.field_name().is_none()
4223 && cursor.node().is_named()
4224 && !cursor.node().is_extra()
4225 {
4226 result.push(cursor.node());
4227 }
4228 if !cursor.goto_next_sibling() {
4229 break;
4230 }
4231 }
4232 }
4233 result
4234 };
4235 let mut items = ::std::vec::Vec::new();
4236 for child in non_field_children {
4237 items.push(
4238 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
4239 child, src,
4240 )?,
4241 );
4242 }
4243 items
4244 },
4245 })
4246 }
4247}
4248impl ::treesitter_types::Spanned for LabeledStatement<'_> {
4249 fn span(&self) -> ::treesitter_types::Span {
4250 self.span
4251 }
4252}
4253#[derive(Debug, Clone, PartialEq, Eq)]
4254pub struct LambdaExpression<'tree> {
4255 pub span: ::treesitter_types::Span,
4256 pub body: LambdaExpressionBody<'tree>,
4257 pub parameters: LambdaExpressionParameters<'tree>,
4258}
4259impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
4260 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4261 fn from_node(
4262 node: ::tree_sitter::Node<'tree>,
4263 src: &'tree [u8],
4264 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4265 debug_assert_eq!(node.kind(), "lambda_expression");
4266 Ok(Self {
4267 span: ::treesitter_types::Span::from(node),
4268 body: {
4269 let child = node
4270 .child_by_field_name("body")
4271 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4272 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)?
4273 },
4274 parameters: {
4275 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4276 ::treesitter_types::ParseError::missing_field("parameters", node)
4277 })?;
4278 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(child, src)?
4279 },
4280 })
4281 }
4282}
4283impl ::treesitter_types::Spanned for LambdaExpression<'_> {
4284 fn span(&self) -> ::treesitter_types::Span {
4285 self.span
4286 }
4287}
4288#[derive(Debug, Clone, PartialEq, Eq)]
4289pub struct LocalVariableDeclaration<'tree> {
4290 pub span: ::treesitter_types::Span,
4291 pub declarator: ::std::vec::Vec<VariableDeclarator<'tree>>,
4292 pub r#type: UnannotatedType<'tree>,
4293 pub children: ::core::option::Option<Modifiers<'tree>>,
4294}
4295impl<'tree> ::treesitter_types::FromNode<'tree> for LocalVariableDeclaration<'tree> {
4296 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4297 fn from_node(
4298 node: ::tree_sitter::Node<'tree>,
4299 src: &'tree [u8],
4300 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4301 debug_assert_eq!(node.kind(), "local_variable_declaration");
4302 Ok(Self {
4303 span: ::treesitter_types::Span::from(node),
4304 declarator: {
4305 let mut cursor = node.walk();
4306 let mut items = ::std::vec::Vec::new();
4307 for child in node.children_by_field_name("declarator", &mut cursor) {
4308 items.push(
4309 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
4310 child, src,
4311 )?,
4312 );
4313 }
4314 items
4315 },
4316 r#type: {
4317 let child = node
4318 .child_by_field_name("type")
4319 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4320 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
4321 },
4322 children: {
4323 #[allow(clippy::suspicious_else_formatting)]
4324 let non_field_children = {
4325 let mut cursor = node.walk();
4326 let mut result = ::std::vec::Vec::new();
4327 if cursor.goto_first_child() {
4328 loop {
4329 if cursor.field_name().is_none()
4330 && cursor.node().is_named()
4331 && !cursor.node().is_extra()
4332 {
4333 result.push(cursor.node());
4334 }
4335 if !cursor.goto_next_sibling() {
4336 break;
4337 }
4338 }
4339 }
4340 result
4341 };
4342 match non_field_children.first() {
4343 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
4344 child, src,
4345 )?),
4346 None => None,
4347 }
4348 },
4349 })
4350 }
4351}
4352impl ::treesitter_types::Spanned for LocalVariableDeclaration<'_> {
4353 fn span(&self) -> ::treesitter_types::Span {
4354 self.span
4355 }
4356}
4357#[derive(Debug, Clone, PartialEq, Eq)]
4358pub struct MarkerAnnotation<'tree> {
4359 pub span: ::treesitter_types::Span,
4360 pub name: MarkerAnnotationName<'tree>,
4361}
4362impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotation<'tree> {
4363 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4364 fn from_node(
4365 node: ::tree_sitter::Node<'tree>,
4366 src: &'tree [u8],
4367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4368 debug_assert_eq!(node.kind(), "marker_annotation");
4369 Ok(Self {
4370 span: ::treesitter_types::Span::from(node),
4371 name: {
4372 let child = node
4373 .child_by_field_name("name")
4374 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4375 <MarkerAnnotationName as ::treesitter_types::FromNode>::from_node(child, src)?
4376 },
4377 })
4378 }
4379}
4380impl ::treesitter_types::Spanned for MarkerAnnotation<'_> {
4381 fn span(&self) -> ::treesitter_types::Span {
4382 self.span
4383 }
4384}
4385#[derive(Debug, Clone, PartialEq, Eq)]
4386pub struct MethodDeclaration<'tree> {
4387 pub span: ::treesitter_types::Span,
4388 pub body: ::core::option::Option<Block<'tree>>,
4389 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
4390 pub name: Identifier<'tree>,
4391 pub parameters: FormalParameters<'tree>,
4392 pub r#type: UnannotatedType<'tree>,
4393 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4394 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
4395}
4396impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
4397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4398 fn from_node(
4399 node: ::tree_sitter::Node<'tree>,
4400 src: &'tree [u8],
4401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4402 debug_assert_eq!(node.kind(), "method_declaration");
4403 Ok(Self {
4404 span: ::treesitter_types::Span::from(node),
4405 body: match node.child_by_field_name("body") {
4406 Some(child) => Some(<Block as ::treesitter_types::FromNode>::from_node(
4407 child, src,
4408 )?),
4409 None => None,
4410 },
4411 dimensions: match node.child_by_field_name("dimensions") {
4412 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
4413 child, src,
4414 )?),
4415 None => None,
4416 },
4417 name: {
4418 let child = node
4419 .child_by_field_name("name")
4420 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4421 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4422 },
4423 parameters: {
4424 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4425 ::treesitter_types::ParseError::missing_field("parameters", node)
4426 })?;
4427 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
4428 },
4429 r#type: {
4430 let child = node
4431 .child_by_field_name("type")
4432 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4433 <UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?
4434 },
4435 type_parameters: match node.child_by_field_name("type_parameters") {
4436 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
4437 child, src,
4438 )?),
4439 None => None,
4440 },
4441 children: {
4442 #[allow(clippy::suspicious_else_formatting)]
4443 let non_field_children = {
4444 let mut cursor = node.walk();
4445 let mut result = ::std::vec::Vec::new();
4446 if cursor.goto_first_child() {
4447 loop {
4448 if cursor.field_name().is_none()
4449 && cursor.node().is_named()
4450 && !cursor.node().is_extra()
4451 {
4452 result.push(cursor.node());
4453 }
4454 if !cursor.goto_next_sibling() {
4455 break;
4456 }
4457 }
4458 }
4459 result
4460 };
4461 let mut items = ::std::vec::Vec::new();
4462 for child in non_field_children {
4463 items.push(
4464 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4465 child, src,
4466 )?,
4467 );
4468 }
4469 items
4470 },
4471 })
4472 }
4473}
4474impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
4475 fn span(&self) -> ::treesitter_types::Span {
4476 self.span
4477 }
4478}
4479#[derive(Debug, Clone, PartialEq, Eq)]
4480pub struct MethodInvocation<'tree> {
4481 pub span: ::treesitter_types::Span,
4482 pub arguments: ArgumentList<'tree>,
4483 pub name: Identifier<'tree>,
4484 pub object: ::core::option::Option<MethodInvocationObject<'tree>>,
4485 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
4486 pub children: ::core::option::Option<Super<'tree>>,
4487}
4488impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocation<'tree> {
4489 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4490 fn from_node(
4491 node: ::tree_sitter::Node<'tree>,
4492 src: &'tree [u8],
4493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4494 debug_assert_eq!(node.kind(), "method_invocation");
4495 Ok(Self {
4496 span: ::treesitter_types::Span::from(node),
4497 arguments: {
4498 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4499 ::treesitter_types::ParseError::missing_field("arguments", node)
4500 })?;
4501 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
4502 },
4503 name: {
4504 let child = node
4505 .child_by_field_name("name")
4506 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4507 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4508 },
4509 object: match node.child_by_field_name("object") {
4510 Some(child) => Some(
4511 <MethodInvocationObject as ::treesitter_types::FromNode>::from_node(
4512 child, src,
4513 )?,
4514 ),
4515 None => None,
4516 },
4517 type_arguments: match node.child_by_field_name("type_arguments") {
4518 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
4519 child, src,
4520 )?),
4521 None => None,
4522 },
4523 children: {
4524 #[allow(clippy::suspicious_else_formatting)]
4525 let non_field_children = {
4526 let mut cursor = node.walk();
4527 let mut result = ::std::vec::Vec::new();
4528 if cursor.goto_first_child() {
4529 loop {
4530 if cursor.field_name().is_none()
4531 && cursor.node().is_named()
4532 && !cursor.node().is_extra()
4533 {
4534 result.push(cursor.node());
4535 }
4536 if !cursor.goto_next_sibling() {
4537 break;
4538 }
4539 }
4540 }
4541 result
4542 };
4543 match non_field_children.first() {
4544 Some(&child) => Some(<Super as ::treesitter_types::FromNode>::from_node(
4545 child, src,
4546 )?),
4547 None => None,
4548 }
4549 },
4550 })
4551 }
4552}
4553impl ::treesitter_types::Spanned for MethodInvocation<'_> {
4554 fn span(&self) -> ::treesitter_types::Span {
4555 self.span
4556 }
4557}
4558#[derive(Debug, Clone, PartialEq, Eq)]
4559pub struct MethodReference<'tree> {
4560 pub span: ::treesitter_types::Span,
4561 pub children: ::std::vec::Vec<MethodReferenceChildren<'tree>>,
4562}
4563impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReference<'tree> {
4564 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4565 fn from_node(
4566 node: ::tree_sitter::Node<'tree>,
4567 src: &'tree [u8],
4568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4569 debug_assert_eq!(node.kind(), "method_reference");
4570 Ok(Self {
4571 span: ::treesitter_types::Span::from(node),
4572 children: {
4573 #[allow(clippy::suspicious_else_formatting)]
4574 let non_field_children = {
4575 let mut cursor = node.walk();
4576 let mut result = ::std::vec::Vec::new();
4577 if cursor.goto_first_child() {
4578 loop {
4579 if cursor.field_name().is_none()
4580 && cursor.node().is_named()
4581 && !cursor.node().is_extra()
4582 {
4583 result.push(cursor.node());
4584 }
4585 if !cursor.goto_next_sibling() {
4586 break;
4587 }
4588 }
4589 }
4590 result
4591 };
4592 let mut items = ::std::vec::Vec::new();
4593 for child in non_field_children {
4594 items.push(
4595 <MethodReferenceChildren as ::treesitter_types::FromNode>::from_node(
4596 child, src,
4597 )?,
4598 );
4599 }
4600 items
4601 },
4602 })
4603 }
4604}
4605impl ::treesitter_types::Spanned for MethodReference<'_> {
4606 fn span(&self) -> ::treesitter_types::Span {
4607 self.span
4608 }
4609}
4610#[derive(Debug, Clone, PartialEq, Eq)]
4611pub struct Modifiers<'tree> {
4612 pub span: ::treesitter_types::Span,
4613 pub children: ::std::vec::Vec<ModifiersChildren<'tree>>,
4614}
4615impl<'tree> ::treesitter_types::FromNode<'tree> for Modifiers<'tree> {
4616 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4617 fn from_node(
4618 node: ::tree_sitter::Node<'tree>,
4619 src: &'tree [u8],
4620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4621 debug_assert_eq!(node.kind(), "modifiers");
4622 Ok(Self {
4623 span: ::treesitter_types::Span::from(node),
4624 children: {
4625 #[allow(clippy::suspicious_else_formatting)]
4626 let non_field_children = {
4627 let mut cursor = node.walk();
4628 let mut result = ::std::vec::Vec::new();
4629 if cursor.goto_first_child() {
4630 loop {
4631 if cursor.field_name().is_none()
4632 && cursor.node().is_named()
4633 && !cursor.node().is_extra()
4634 {
4635 result.push(cursor.node());
4636 }
4637 if !cursor.goto_next_sibling() {
4638 break;
4639 }
4640 }
4641 }
4642 result
4643 };
4644 let mut items = ::std::vec::Vec::new();
4645 for child in non_field_children {
4646 items.push(
4647 <ModifiersChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4648 );
4649 }
4650 items
4651 },
4652 })
4653 }
4654}
4655impl ::treesitter_types::Spanned for Modifiers<'_> {
4656 fn span(&self) -> ::treesitter_types::Span {
4657 self.span
4658 }
4659}
4660#[derive(Debug, Clone, PartialEq, Eq)]
4661pub struct ModuleBody<'tree> {
4662 pub span: ::treesitter_types::Span,
4663 pub children: ::std::vec::Vec<ModuleDirective<'tree>>,
4664}
4665impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleBody<'tree> {
4666 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4667 fn from_node(
4668 node: ::tree_sitter::Node<'tree>,
4669 src: &'tree [u8],
4670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4671 debug_assert_eq!(node.kind(), "module_body");
4672 Ok(Self {
4673 span: ::treesitter_types::Span::from(node),
4674 children: {
4675 #[allow(clippy::suspicious_else_formatting)]
4676 let non_field_children = {
4677 let mut cursor = node.walk();
4678 let mut result = ::std::vec::Vec::new();
4679 if cursor.goto_first_child() {
4680 loop {
4681 if cursor.field_name().is_none()
4682 && cursor.node().is_named()
4683 && !cursor.node().is_extra()
4684 {
4685 result.push(cursor.node());
4686 }
4687 if !cursor.goto_next_sibling() {
4688 break;
4689 }
4690 }
4691 }
4692 result
4693 };
4694 let mut items = ::std::vec::Vec::new();
4695 for child in non_field_children {
4696 items.push(
4697 <ModuleDirective as ::treesitter_types::FromNode>::from_node(child, src)?,
4698 );
4699 }
4700 items
4701 },
4702 })
4703 }
4704}
4705impl ::treesitter_types::Spanned for ModuleBody<'_> {
4706 fn span(&self) -> ::treesitter_types::Span {
4707 self.span
4708 }
4709}
4710#[derive(Debug, Clone, PartialEq, Eq)]
4711pub struct ModuleDeclaration<'tree> {
4712 pub span: ::treesitter_types::Span,
4713 pub body: ModuleBody<'tree>,
4714 pub name: ModuleDeclarationName<'tree>,
4715 pub children: ::std::vec::Vec<ModuleDeclarationChildren<'tree>>,
4716}
4717impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclaration<'tree> {
4718 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4719 fn from_node(
4720 node: ::tree_sitter::Node<'tree>,
4721 src: &'tree [u8],
4722 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4723 debug_assert_eq!(node.kind(), "module_declaration");
4724 Ok(Self {
4725 span: ::treesitter_types::Span::from(node),
4726 body: {
4727 let child = node
4728 .child_by_field_name("body")
4729 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4730 <ModuleBody as ::treesitter_types::FromNode>::from_node(child, src)?
4731 },
4732 name: {
4733 let child = node
4734 .child_by_field_name("name")
4735 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4736 <ModuleDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)?
4737 },
4738 children: {
4739 #[allow(clippy::suspicious_else_formatting)]
4740 let non_field_children = {
4741 let mut cursor = node.walk();
4742 let mut result = ::std::vec::Vec::new();
4743 if cursor.goto_first_child() {
4744 loop {
4745 if cursor.field_name().is_none()
4746 && cursor.node().is_named()
4747 && !cursor.node().is_extra()
4748 {
4749 result.push(cursor.node());
4750 }
4751 if !cursor.goto_next_sibling() {
4752 break;
4753 }
4754 }
4755 }
4756 result
4757 };
4758 let mut items = ::std::vec::Vec::new();
4759 for child in non_field_children {
4760 items.push(
4761 <ModuleDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4762 child, src,
4763 )?,
4764 );
4765 }
4766 items
4767 },
4768 })
4769 }
4770}
4771impl ::treesitter_types::Spanned for ModuleDeclaration<'_> {
4772 fn span(&self) -> ::treesitter_types::Span {
4773 self.span
4774 }
4775}
4776#[derive(Debug, Clone, PartialEq, Eq)]
4777pub struct MultilineStringFragment<'tree> {
4778 pub span: ::treesitter_types::Span,
4779 text: &'tree str,
4780}
4781impl<'tree> ::treesitter_types::FromNode<'tree> for MultilineStringFragment<'tree> {
4782 fn from_node(
4783 node: ::tree_sitter::Node<'tree>,
4784 src: &'tree [u8],
4785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4786 debug_assert_eq!(node.kind(), "multiline_string_fragment");
4787 Ok(Self {
4788 span: ::treesitter_types::Span::from(node),
4789 text: node.utf8_text(src)?,
4790 })
4791 }
4792}
4793impl<'tree> ::treesitter_types::LeafNode<'tree> for MultilineStringFragment<'tree> {
4794 fn text(&self) -> &'tree str {
4795 self.text
4796 }
4797}
4798impl ::treesitter_types::Spanned for MultilineStringFragment<'_> {
4799 fn span(&self) -> ::treesitter_types::Span {
4800 self.span
4801 }
4802}
4803#[derive(Debug, Clone, PartialEq, Eq)]
4804pub struct ObjectCreationExpression<'tree> {
4805 pub span: ::treesitter_types::Span,
4806 pub arguments: ArgumentList<'tree>,
4807 pub r#type: SimpleType<'tree>,
4808 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
4809 pub children: ::std::vec::Vec<ObjectCreationExpressionChildren<'tree>>,
4810}
4811impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
4812 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4813 fn from_node(
4814 node: ::tree_sitter::Node<'tree>,
4815 src: &'tree [u8],
4816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4817 debug_assert_eq!(node.kind(), "object_creation_expression");
4818 Ok(Self {
4819 span: ::treesitter_types::Span::from(node),
4820 arguments: {
4821 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4822 ::treesitter_types::ParseError::missing_field("arguments", node)
4823 })?;
4824 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
4825 },
4826 r#type: {
4827 let child = node
4828 .child_by_field_name("type")
4829 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4830 <SimpleType as ::treesitter_types::FromNode>::from_node(child, src)?
4831 },
4832 type_arguments: match node.child_by_field_name("type_arguments") {
4833 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
4834 child, src,
4835 )?),
4836 None => None,
4837 },
4838 children: {
4839 #[allow(clippy::suspicious_else_formatting)]
4840 let non_field_children = {
4841 let mut cursor = node.walk();
4842 let mut result = ::std::vec::Vec::new();
4843 if cursor.goto_first_child() {
4844 loop {
4845 if cursor.field_name().is_none()
4846 && cursor.node().is_named()
4847 && !cursor.node().is_extra()
4848 {
4849 result.push(cursor.node());
4850 }
4851 if !cursor.goto_next_sibling() {
4852 break;
4853 }
4854 }
4855 }
4856 result
4857 };
4858 let mut items = ::std::vec::Vec::new();
4859 for child in non_field_children {
4860 items
4861 .push(
4862 <ObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
4863 child,
4864 src,
4865 )?,
4866 );
4867 }
4868 items
4869 },
4870 })
4871 }
4872}
4873impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
4874 fn span(&self) -> ::treesitter_types::Span {
4875 self.span
4876 }
4877}
4878#[derive(Debug, Clone, PartialEq, Eq)]
4879pub struct OpensModuleDirective<'tree> {
4880 pub span: ::treesitter_types::Span,
4881 pub modules: ::std::vec::Vec<OpensModuleDirectiveModules<'tree>>,
4882 pub package: OpensModuleDirectivePackage<'tree>,
4883}
4884impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirective<'tree> {
4885 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4886 fn from_node(
4887 node: ::tree_sitter::Node<'tree>,
4888 src: &'tree [u8],
4889 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4890 debug_assert_eq!(node.kind(), "opens_module_directive");
4891 Ok(Self {
4892 span: ::treesitter_types::Span::from(node),
4893 modules: {
4894 let mut cursor = node.walk();
4895 let mut items = ::std::vec::Vec::new();
4896 for child in node.children_by_field_name("modules", &mut cursor) {
4897 items.push(
4898 <OpensModuleDirectiveModules as ::treesitter_types::FromNode>::from_node(
4899 child, src,
4900 )?,
4901 );
4902 }
4903 items
4904 },
4905 package: {
4906 let child = node.child_by_field_name("package").ok_or_else(|| {
4907 ::treesitter_types::ParseError::missing_field("package", node)
4908 })?;
4909 <OpensModuleDirectivePackage as ::treesitter_types::FromNode>::from_node(
4910 child, src,
4911 )?
4912 },
4913 })
4914 }
4915}
4916impl ::treesitter_types::Spanned for OpensModuleDirective<'_> {
4917 fn span(&self) -> ::treesitter_types::Span {
4918 self.span
4919 }
4920}
4921#[derive(Debug, Clone, PartialEq, Eq)]
4922pub struct PackageDeclaration<'tree> {
4923 pub span: ::treesitter_types::Span,
4924 pub children: ::std::vec::Vec<PackageDeclarationChildren<'tree>>,
4925}
4926impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclaration<'tree> {
4927 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4928 fn from_node(
4929 node: ::tree_sitter::Node<'tree>,
4930 src: &'tree [u8],
4931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4932 debug_assert_eq!(node.kind(), "package_declaration");
4933 Ok(Self {
4934 span: ::treesitter_types::Span::from(node),
4935 children: {
4936 #[allow(clippy::suspicious_else_formatting)]
4937 let non_field_children = {
4938 let mut cursor = node.walk();
4939 let mut result = ::std::vec::Vec::new();
4940 if cursor.goto_first_child() {
4941 loop {
4942 if cursor.field_name().is_none()
4943 && cursor.node().is_named()
4944 && !cursor.node().is_extra()
4945 {
4946 result.push(cursor.node());
4947 }
4948 if !cursor.goto_next_sibling() {
4949 break;
4950 }
4951 }
4952 }
4953 result
4954 };
4955 let mut items = ::std::vec::Vec::new();
4956 for child in non_field_children {
4957 items.push(
4958 <PackageDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4959 child, src,
4960 )?,
4961 );
4962 }
4963 items
4964 },
4965 })
4966 }
4967}
4968impl ::treesitter_types::Spanned for PackageDeclaration<'_> {
4969 fn span(&self) -> ::treesitter_types::Span {
4970 self.span
4971 }
4972}
4973#[derive(Debug, Clone, PartialEq, Eq)]
4974pub struct ParenthesizedExpression<'tree> {
4975 pub span: ::treesitter_types::Span,
4976 pub children: Expression<'tree>,
4977}
4978impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
4979 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4980 fn from_node(
4981 node: ::tree_sitter::Node<'tree>,
4982 src: &'tree [u8],
4983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4984 debug_assert_eq!(node.kind(), "parenthesized_expression");
4985 Ok(Self {
4986 span: ::treesitter_types::Span::from(node),
4987 children: {
4988 #[allow(clippy::suspicious_else_formatting)]
4989 let non_field_children = {
4990 let mut cursor = node.walk();
4991 let mut result = ::std::vec::Vec::new();
4992 if cursor.goto_first_child() {
4993 loop {
4994 if cursor.field_name().is_none()
4995 && cursor.node().is_named()
4996 && !cursor.node().is_extra()
4997 {
4998 result.push(cursor.node());
4999 }
5000 if !cursor.goto_next_sibling() {
5001 break;
5002 }
5003 }
5004 }
5005 result
5006 };
5007 let child = if let Some(&c) = non_field_children.first() {
5008 c
5009 } else {
5010 let mut fallback_cursor = node.walk();
5011 let mut fallback_child = None;
5012 if fallback_cursor.goto_first_child() {
5013 loop {
5014 if fallback_cursor.field_name().is_none()
5015 && !fallback_cursor.node().is_extra()
5016 {
5017 let candidate = fallback_cursor.node();
5018 #[allow(clippy::needless_question_mark)]
5019 if (|| -> ::core::result::Result<
5020 _,
5021 ::treesitter_types::ParseError,
5022 > {
5023 let child = candidate;
5024 Ok(
5025 <Expression as ::treesitter_types::FromNode>::from_node(
5026 child,
5027 src,
5028 )?,
5029 )
5030 })()
5031 .is_ok()
5032 {
5033 fallback_child = Some(candidate);
5034 break;
5035 }
5036 }
5037 if !fallback_cursor.goto_next_sibling() {
5038 break;
5039 }
5040 }
5041 }
5042 if fallback_child.is_none() {
5043 let mut cursor2 = node.walk();
5044 if cursor2.goto_first_child() {
5045 loop {
5046 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5047 let candidate = cursor2.node();
5048 #[allow(clippy::needless_question_mark)]
5049 if (|| -> ::core::result::Result<
5050 _,
5051 ::treesitter_types::ParseError,
5052 > {
5053 let child = candidate;
5054 Ok(
5055 <Expression as ::treesitter_types::FromNode>::from_node(
5056 child,
5057 src,
5058 )?,
5059 )
5060 })()
5061 .is_ok()
5062 {
5063 fallback_child = Some(candidate);
5064 break;
5065 }
5066 }
5067 if !cursor2.goto_next_sibling() {
5068 break;
5069 }
5070 }
5071 }
5072 }
5073 fallback_child.ok_or_else(|| {
5074 ::treesitter_types::ParseError::missing_field("children", node)
5075 })?
5076 };
5077 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5078 },
5079 })
5080 }
5081}
5082impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
5083 fn span(&self) -> ::treesitter_types::Span {
5084 self.span
5085 }
5086}
5087#[derive(Debug, Clone, PartialEq, Eq)]
5088pub struct Pattern<'tree> {
5089 pub span: ::treesitter_types::Span,
5090 pub children: PatternChildren<'tree>,
5091}
5092impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
5093 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5094 fn from_node(
5095 node: ::tree_sitter::Node<'tree>,
5096 src: &'tree [u8],
5097 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5098 debug_assert_eq!(node.kind(), "pattern");
5099 Ok(Self {
5100 span: ::treesitter_types::Span::from(node),
5101 children: {
5102 #[allow(clippy::suspicious_else_formatting)]
5103 let non_field_children = {
5104 let mut cursor = node.walk();
5105 let mut result = ::std::vec::Vec::new();
5106 if cursor.goto_first_child() {
5107 loop {
5108 if cursor.field_name().is_none()
5109 && cursor.node().is_named()
5110 && !cursor.node().is_extra()
5111 {
5112 result.push(cursor.node());
5113 }
5114 if !cursor.goto_next_sibling() {
5115 break;
5116 }
5117 }
5118 }
5119 result
5120 };
5121 let child = if let Some(&c) = non_field_children.first() {
5122 c
5123 } else {
5124 let mut fallback_cursor = node.walk();
5125 let mut fallback_child = None;
5126 if fallback_cursor.goto_first_child() {
5127 loop {
5128 if fallback_cursor.field_name().is_none()
5129 && !fallback_cursor.node().is_extra()
5130 {
5131 let candidate = fallback_cursor.node();
5132 #[allow(clippy::needless_question_mark)]
5133 if (|| -> ::core::result::Result<
5134 _,
5135 ::treesitter_types::ParseError,
5136 > {
5137 let child = candidate;
5138 Ok(
5139 <PatternChildren as ::treesitter_types::FromNode>::from_node(
5140 child,
5141 src,
5142 )?,
5143 )
5144 })()
5145 .is_ok()
5146 {
5147 fallback_child = Some(candidate);
5148 break;
5149 }
5150 }
5151 if !fallback_cursor.goto_next_sibling() {
5152 break;
5153 }
5154 }
5155 }
5156 if fallback_child.is_none() {
5157 let mut cursor2 = node.walk();
5158 if cursor2.goto_first_child() {
5159 loop {
5160 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5161 let candidate = cursor2.node();
5162 #[allow(clippy::needless_question_mark)]
5163 if (|| -> ::core::result::Result<
5164 _,
5165 ::treesitter_types::ParseError,
5166 > {
5167 let child = candidate;
5168 Ok(
5169 <PatternChildren as ::treesitter_types::FromNode>::from_node(
5170 child,
5171 src,
5172 )?,
5173 )
5174 })()
5175 .is_ok()
5176 {
5177 fallback_child = Some(candidate);
5178 break;
5179 }
5180 }
5181 if !cursor2.goto_next_sibling() {
5182 break;
5183 }
5184 }
5185 }
5186 }
5187 fallback_child.ok_or_else(|| {
5188 ::treesitter_types::ParseError::missing_field("children", node)
5189 })?
5190 };
5191 <PatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5192 },
5193 })
5194 }
5195}
5196impl ::treesitter_types::Spanned for Pattern<'_> {
5197 fn span(&self) -> ::treesitter_types::Span {
5198 self.span
5199 }
5200}
5201#[derive(Debug, Clone, PartialEq, Eq)]
5202pub struct Permits<'tree> {
5203 pub span: ::treesitter_types::Span,
5204 pub children: TypeList<'tree>,
5205}
5206impl<'tree> ::treesitter_types::FromNode<'tree> for Permits<'tree> {
5207 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5208 fn from_node(
5209 node: ::tree_sitter::Node<'tree>,
5210 src: &'tree [u8],
5211 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5212 debug_assert_eq!(node.kind(), "permits");
5213 Ok(Self {
5214 span: ::treesitter_types::Span::from(node),
5215 children: {
5216 #[allow(clippy::suspicious_else_formatting)]
5217 let non_field_children = {
5218 let mut cursor = node.walk();
5219 let mut result = ::std::vec::Vec::new();
5220 if cursor.goto_first_child() {
5221 loop {
5222 if cursor.field_name().is_none()
5223 && cursor.node().is_named()
5224 && !cursor.node().is_extra()
5225 {
5226 result.push(cursor.node());
5227 }
5228 if !cursor.goto_next_sibling() {
5229 break;
5230 }
5231 }
5232 }
5233 result
5234 };
5235 let child = if let Some(&c) = non_field_children.first() {
5236 c
5237 } else {
5238 let mut fallback_cursor = node.walk();
5239 let mut fallback_child = None;
5240 if fallback_cursor.goto_first_child() {
5241 loop {
5242 if fallback_cursor.field_name().is_none()
5243 && !fallback_cursor.node().is_extra()
5244 {
5245 let candidate = fallback_cursor.node();
5246 #[allow(clippy::needless_question_mark)]
5247 if (|| -> ::core::result::Result<
5248 _,
5249 ::treesitter_types::ParseError,
5250 > {
5251 let child = candidate;
5252 Ok(
5253 <TypeList as ::treesitter_types::FromNode>::from_node(
5254 child,
5255 src,
5256 )?,
5257 )
5258 })()
5259 .is_ok()
5260 {
5261 fallback_child = Some(candidate);
5262 break;
5263 }
5264 }
5265 if !fallback_cursor.goto_next_sibling() {
5266 break;
5267 }
5268 }
5269 }
5270 if fallback_child.is_none() {
5271 let mut cursor2 = node.walk();
5272 if cursor2.goto_first_child() {
5273 loop {
5274 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5275 let candidate = cursor2.node();
5276 #[allow(clippy::needless_question_mark)]
5277 if (|| -> ::core::result::Result<
5278 _,
5279 ::treesitter_types::ParseError,
5280 > {
5281 let child = candidate;
5282 Ok(
5283 <TypeList as ::treesitter_types::FromNode>::from_node(
5284 child,
5285 src,
5286 )?,
5287 )
5288 })()
5289 .is_ok()
5290 {
5291 fallback_child = Some(candidate);
5292 break;
5293 }
5294 }
5295 if !cursor2.goto_next_sibling() {
5296 break;
5297 }
5298 }
5299 }
5300 }
5301 fallback_child.ok_or_else(|| {
5302 ::treesitter_types::ParseError::missing_field("children", node)
5303 })?
5304 };
5305 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
5306 },
5307 })
5308 }
5309}
5310impl ::treesitter_types::Spanned for Permits<'_> {
5311 fn span(&self) -> ::treesitter_types::Span {
5312 self.span
5313 }
5314}
5315#[derive(Debug, Clone, PartialEq, Eq)]
5316pub struct Program<'tree> {
5317 pub span: ::treesitter_types::Span,
5318 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
5319}
5320impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
5321 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5322 fn from_node(
5323 node: ::tree_sitter::Node<'tree>,
5324 src: &'tree [u8],
5325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5326 debug_assert_eq!(node.kind(), "program");
5327 Ok(Self {
5328 span: ::treesitter_types::Span::from(node),
5329 children: {
5330 #[allow(clippy::suspicious_else_formatting)]
5331 let non_field_children = {
5332 let mut cursor = node.walk();
5333 let mut result = ::std::vec::Vec::new();
5334 if cursor.goto_first_child() {
5335 loop {
5336 if cursor.field_name().is_none()
5337 && cursor.node().is_named()
5338 && !cursor.node().is_extra()
5339 {
5340 result.push(cursor.node());
5341 }
5342 if !cursor.goto_next_sibling() {
5343 break;
5344 }
5345 }
5346 }
5347 result
5348 };
5349 let mut items = ::std::vec::Vec::new();
5350 for child in non_field_children {
5351 items.push(
5352 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5353 );
5354 }
5355 items
5356 },
5357 })
5358 }
5359}
5360impl ::treesitter_types::Spanned for Program<'_> {
5361 fn span(&self) -> ::treesitter_types::Span {
5362 self.span
5363 }
5364}
5365#[derive(Debug, Clone, PartialEq, Eq)]
5366pub struct ProvidesModuleDirective<'tree> {
5367 pub span: ::treesitter_types::Span,
5368 pub provided: ProvidesModuleDirectiveProvided<'tree>,
5369 pub provider: ::std::vec::Vec<ProvidesModuleDirectiveProvider<'tree>>,
5370 pub children: ProvidesModuleDirectiveChildren<'tree>,
5371}
5372impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirective<'tree> {
5373 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5374 fn from_node(
5375 node: ::tree_sitter::Node<'tree>,
5376 src: &'tree [u8],
5377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5378 debug_assert_eq!(node.kind(), "provides_module_directive");
5379 Ok(Self {
5380 span: ::treesitter_types::Span::from(node),
5381 provided: {
5382 let child = node.child_by_field_name("provided").ok_or_else(|| {
5383 ::treesitter_types::ParseError::missing_field("provided", node)
5384 })?;
5385 <ProvidesModuleDirectiveProvided as ::treesitter_types::FromNode>::from_node(
5386 child, src,
5387 )?
5388 },
5389 provider: {
5390 let mut cursor = node.walk();
5391 let mut items = ::std::vec::Vec::new();
5392 for child in node.children_by_field_name("provider", &mut cursor) {
5393 items
5394 .push(
5395 <ProvidesModuleDirectiveProvider as ::treesitter_types::FromNode>::from_node(
5396 child,
5397 src,
5398 )?,
5399 );
5400 }
5401 items
5402 },
5403 children: {
5404 #[allow(clippy::suspicious_else_formatting)]
5405 let non_field_children = {
5406 let mut cursor = node.walk();
5407 let mut result = ::std::vec::Vec::new();
5408 if cursor.goto_first_child() {
5409 loop {
5410 if cursor.field_name().is_none()
5411 && cursor.node().is_named()
5412 && !cursor.node().is_extra()
5413 {
5414 result.push(cursor.node());
5415 }
5416 if !cursor.goto_next_sibling() {
5417 break;
5418 }
5419 }
5420 }
5421 result
5422 };
5423 let child = if let Some(&c) = non_field_children.first() {
5424 c
5425 } else {
5426 let mut fallback_cursor = node.walk();
5427 let mut fallback_child = None;
5428 if fallback_cursor.goto_first_child() {
5429 loop {
5430 if fallback_cursor.field_name().is_none()
5431 && !fallback_cursor.node().is_extra()
5432 {
5433 let candidate = fallback_cursor.node();
5434 #[allow(clippy::needless_question_mark)]
5435 if (|| -> ::core::result::Result<
5436 _,
5437 ::treesitter_types::ParseError,
5438 > {
5439 let child = candidate;
5440 Ok(
5441 <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5442 child,
5443 src,
5444 )?,
5445 )
5446 })()
5447 .is_ok()
5448 {
5449 fallback_child = Some(candidate);
5450 break;
5451 }
5452 }
5453 if !fallback_cursor.goto_next_sibling() {
5454 break;
5455 }
5456 }
5457 }
5458 if fallback_child.is_none() {
5459 let mut cursor2 = node.walk();
5460 if cursor2.goto_first_child() {
5461 loop {
5462 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5463 let candidate = cursor2.node();
5464 #[allow(clippy::needless_question_mark)]
5465 if (|| -> ::core::result::Result<
5466 _,
5467 ::treesitter_types::ParseError,
5468 > {
5469 let child = candidate;
5470 Ok(
5471 <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5472 child,
5473 src,
5474 )?,
5475 )
5476 })()
5477 .is_ok()
5478 {
5479 fallback_child = Some(candidate);
5480 break;
5481 }
5482 }
5483 if !cursor2.goto_next_sibling() {
5484 break;
5485 }
5486 }
5487 }
5488 }
5489 fallback_child.ok_or_else(|| {
5490 ::treesitter_types::ParseError::missing_field("children", node)
5491 })?
5492 };
5493 <ProvidesModuleDirectiveChildren as ::treesitter_types::FromNode>::from_node(
5494 child, src,
5495 )?
5496 },
5497 })
5498 }
5499}
5500impl ::treesitter_types::Spanned for ProvidesModuleDirective<'_> {
5501 fn span(&self) -> ::treesitter_types::Span {
5502 self.span
5503 }
5504}
5505#[derive(Debug, Clone, PartialEq, Eq)]
5506pub struct ReceiverParameter<'tree> {
5507 pub span: ::treesitter_types::Span,
5508 pub children: ::std::vec::Vec<ReceiverParameterChildren<'tree>>,
5509}
5510impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameter<'tree> {
5511 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5512 fn from_node(
5513 node: ::tree_sitter::Node<'tree>,
5514 src: &'tree [u8],
5515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5516 debug_assert_eq!(node.kind(), "receiver_parameter");
5517 Ok(Self {
5518 span: ::treesitter_types::Span::from(node),
5519 children: {
5520 #[allow(clippy::suspicious_else_formatting)]
5521 let non_field_children = {
5522 let mut cursor = node.walk();
5523 let mut result = ::std::vec::Vec::new();
5524 if cursor.goto_first_child() {
5525 loop {
5526 if cursor.field_name().is_none()
5527 && cursor.node().is_named()
5528 && !cursor.node().is_extra()
5529 {
5530 result.push(cursor.node());
5531 }
5532 if !cursor.goto_next_sibling() {
5533 break;
5534 }
5535 }
5536 }
5537 result
5538 };
5539 let mut items = ::std::vec::Vec::new();
5540 for child in non_field_children {
5541 items.push(
5542 <ReceiverParameterChildren as ::treesitter_types::FromNode>::from_node(
5543 child, src,
5544 )?,
5545 );
5546 }
5547 items
5548 },
5549 })
5550 }
5551}
5552impl ::treesitter_types::Spanned for ReceiverParameter<'_> {
5553 fn span(&self) -> ::treesitter_types::Span {
5554 self.span
5555 }
5556}
5557#[derive(Debug, Clone, PartialEq, Eq)]
5558pub struct RecordDeclaration<'tree> {
5559 pub span: ::treesitter_types::Span,
5560 pub body: ClassBody<'tree>,
5561 pub interfaces: ::core::option::Option<SuperInterfaces<'tree>>,
5562 pub name: Identifier<'tree>,
5563 pub parameters: FormalParameters<'tree>,
5564 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
5565 pub children: ::core::option::Option<Modifiers<'tree>>,
5566}
5567impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
5568 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5569 fn from_node(
5570 node: ::tree_sitter::Node<'tree>,
5571 src: &'tree [u8],
5572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5573 debug_assert_eq!(node.kind(), "record_declaration");
5574 Ok(Self {
5575 span: ::treesitter_types::Span::from(node),
5576 body: {
5577 let child = node
5578 .child_by_field_name("body")
5579 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5580 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
5581 },
5582 interfaces: match node.child_by_field_name("interfaces") {
5583 Some(child) => {
5584 Some(<SuperInterfaces as ::treesitter_types::FromNode>::from_node(child, src)?)
5585 }
5586 None => None,
5587 },
5588 name: {
5589 let child = node
5590 .child_by_field_name("name")
5591 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5592 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5593 },
5594 parameters: {
5595 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5596 ::treesitter_types::ParseError::missing_field("parameters", node)
5597 })?;
5598 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
5599 },
5600 type_parameters: match node.child_by_field_name("type_parameters") {
5601 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
5602 child, src,
5603 )?),
5604 None => None,
5605 },
5606 children: {
5607 #[allow(clippy::suspicious_else_formatting)]
5608 let non_field_children = {
5609 let mut cursor = node.walk();
5610 let mut result = ::std::vec::Vec::new();
5611 if cursor.goto_first_child() {
5612 loop {
5613 if cursor.field_name().is_none()
5614 && cursor.node().is_named()
5615 && !cursor.node().is_extra()
5616 {
5617 result.push(cursor.node());
5618 }
5619 if !cursor.goto_next_sibling() {
5620 break;
5621 }
5622 }
5623 }
5624 result
5625 };
5626 match non_field_children.first() {
5627 Some(&child) => Some(<Modifiers as ::treesitter_types::FromNode>::from_node(
5628 child, src,
5629 )?),
5630 None => None,
5631 }
5632 },
5633 })
5634 }
5635}
5636impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
5637 fn span(&self) -> ::treesitter_types::Span {
5638 self.span
5639 }
5640}
5641#[derive(Debug, Clone, PartialEq, Eq)]
5642pub struct RecordPattern<'tree> {
5643 pub span: ::treesitter_types::Span,
5644 pub children: ::std::vec::Vec<RecordPatternChildren<'tree>>,
5645}
5646impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPattern<'tree> {
5647 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5648 fn from_node(
5649 node: ::tree_sitter::Node<'tree>,
5650 src: &'tree [u8],
5651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5652 debug_assert_eq!(node.kind(), "record_pattern");
5653 Ok(Self {
5654 span: ::treesitter_types::Span::from(node),
5655 children: {
5656 #[allow(clippy::suspicious_else_formatting)]
5657 let non_field_children = {
5658 let mut cursor = node.walk();
5659 let mut result = ::std::vec::Vec::new();
5660 if cursor.goto_first_child() {
5661 loop {
5662 if cursor.field_name().is_none()
5663 && cursor.node().is_named()
5664 && !cursor.node().is_extra()
5665 {
5666 result.push(cursor.node());
5667 }
5668 if !cursor.goto_next_sibling() {
5669 break;
5670 }
5671 }
5672 }
5673 result
5674 };
5675 let mut items = ::std::vec::Vec::new();
5676 for child in non_field_children {
5677 items.push(
5678 <RecordPatternChildren as ::treesitter_types::FromNode>::from_node(
5679 child, src,
5680 )?,
5681 );
5682 }
5683 items
5684 },
5685 })
5686 }
5687}
5688impl ::treesitter_types::Spanned for RecordPattern<'_> {
5689 fn span(&self) -> ::treesitter_types::Span {
5690 self.span
5691 }
5692}
5693#[derive(Debug, Clone, PartialEq, Eq)]
5694pub struct RecordPatternBody<'tree> {
5695 pub span: ::treesitter_types::Span,
5696 pub children: ::std::vec::Vec<RecordPatternBodyChildren<'tree>>,
5697}
5698impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBody<'tree> {
5699 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5700 fn from_node(
5701 node: ::tree_sitter::Node<'tree>,
5702 src: &'tree [u8],
5703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5704 debug_assert_eq!(node.kind(), "record_pattern_body");
5705 Ok(Self {
5706 span: ::treesitter_types::Span::from(node),
5707 children: {
5708 #[allow(clippy::suspicious_else_formatting)]
5709 let non_field_children = {
5710 let mut cursor = node.walk();
5711 let mut result = ::std::vec::Vec::new();
5712 if cursor.goto_first_child() {
5713 loop {
5714 if cursor.field_name().is_none()
5715 && cursor.node().is_named()
5716 && !cursor.node().is_extra()
5717 {
5718 result.push(cursor.node());
5719 }
5720 if !cursor.goto_next_sibling() {
5721 break;
5722 }
5723 }
5724 }
5725 result
5726 };
5727 let mut items = ::std::vec::Vec::new();
5728 for child in non_field_children {
5729 items.push(
5730 <RecordPatternBodyChildren as ::treesitter_types::FromNode>::from_node(
5731 child, src,
5732 )?,
5733 );
5734 }
5735 items
5736 },
5737 })
5738 }
5739}
5740impl ::treesitter_types::Spanned for RecordPatternBody<'_> {
5741 fn span(&self) -> ::treesitter_types::Span {
5742 self.span
5743 }
5744}
5745#[derive(Debug, Clone, PartialEq, Eq)]
5746pub struct RecordPatternComponent<'tree> {
5747 pub span: ::treesitter_types::Span,
5748 pub children: ::std::vec::Vec<RecordPatternComponentChildren<'tree>>,
5749}
5750impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponent<'tree> {
5751 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5752 fn from_node(
5753 node: ::tree_sitter::Node<'tree>,
5754 src: &'tree [u8],
5755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5756 debug_assert_eq!(node.kind(), "record_pattern_component");
5757 Ok(Self {
5758 span: ::treesitter_types::Span::from(node),
5759 children: {
5760 #[allow(clippy::suspicious_else_formatting)]
5761 let non_field_children = {
5762 let mut cursor = node.walk();
5763 let mut result = ::std::vec::Vec::new();
5764 if cursor.goto_first_child() {
5765 loop {
5766 if cursor.field_name().is_none()
5767 && cursor.node().is_named()
5768 && !cursor.node().is_extra()
5769 {
5770 result.push(cursor.node());
5771 }
5772 if !cursor.goto_next_sibling() {
5773 break;
5774 }
5775 }
5776 }
5777 result
5778 };
5779 let mut items = ::std::vec::Vec::new();
5780 for child in non_field_children {
5781 items
5782 .push(
5783 <RecordPatternComponentChildren as ::treesitter_types::FromNode>::from_node(
5784 child,
5785 src,
5786 )?,
5787 );
5788 }
5789 items
5790 },
5791 })
5792 }
5793}
5794impl ::treesitter_types::Spanned for RecordPatternComponent<'_> {
5795 fn span(&self) -> ::treesitter_types::Span {
5796 self.span
5797 }
5798}
5799#[derive(Debug, Clone, PartialEq, Eq)]
5800pub struct RequiresModifier<'tree> {
5801 pub span: ::treesitter_types::Span,
5802 text: &'tree str,
5803}
5804impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModifier<'tree> {
5805 fn from_node(
5806 node: ::tree_sitter::Node<'tree>,
5807 src: &'tree [u8],
5808 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5809 debug_assert_eq!(node.kind(), "requires_modifier");
5810 Ok(Self {
5811 span: ::treesitter_types::Span::from(node),
5812 text: node.utf8_text(src)?,
5813 })
5814 }
5815}
5816impl<'tree> ::treesitter_types::LeafNode<'tree> for RequiresModifier<'tree> {
5817 fn text(&self) -> &'tree str {
5818 self.text
5819 }
5820}
5821impl ::treesitter_types::Spanned for RequiresModifier<'_> {
5822 fn span(&self) -> ::treesitter_types::Span {
5823 self.span
5824 }
5825}
5826#[derive(Debug, Clone, PartialEq, Eq)]
5827pub struct RequiresModuleDirective<'tree> {
5828 pub span: ::treesitter_types::Span,
5829 pub modifiers: ::std::vec::Vec<RequiresModifier<'tree>>,
5830 pub module: RequiresModuleDirectiveModule<'tree>,
5831}
5832impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirective<'tree> {
5833 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5834 fn from_node(
5835 node: ::tree_sitter::Node<'tree>,
5836 src: &'tree [u8],
5837 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5838 debug_assert_eq!(node.kind(), "requires_module_directive");
5839 Ok(Self {
5840 span: ::treesitter_types::Span::from(node),
5841 modifiers: {
5842 let mut cursor = node.walk();
5843 let mut items = ::std::vec::Vec::new();
5844 for child in node.children_by_field_name("modifiers", &mut cursor) {
5845 items.push(
5846 <RequiresModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5847 );
5848 }
5849 items
5850 },
5851 module: {
5852 let child = node
5853 .child_by_field_name("module")
5854 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
5855 <RequiresModuleDirectiveModule as ::treesitter_types::FromNode>::from_node(
5856 child, src,
5857 )?
5858 },
5859 })
5860 }
5861}
5862impl ::treesitter_types::Spanned for RequiresModuleDirective<'_> {
5863 fn span(&self) -> ::treesitter_types::Span {
5864 self.span
5865 }
5866}
5867#[derive(Debug, Clone, PartialEq, Eq)]
5868pub struct Resource<'tree> {
5869 pub span: ::treesitter_types::Span,
5870 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
5871 pub name: ::core::option::Option<ResourceName<'tree>>,
5872 pub r#type: ::core::option::Option<UnannotatedType<'tree>>,
5873 pub value: ::core::option::Option<Expression<'tree>>,
5874 pub children: ::core::option::Option<ResourceChildren<'tree>>,
5875}
5876impl<'tree> ::treesitter_types::FromNode<'tree> for Resource<'tree> {
5877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5878 fn from_node(
5879 node: ::tree_sitter::Node<'tree>,
5880 src: &'tree [u8],
5881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5882 debug_assert_eq!(node.kind(), "resource");
5883 Ok(Self {
5884 span: ::treesitter_types::Span::from(node),
5885 dimensions: match node.child_by_field_name("dimensions") {
5886 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
5887 child, src,
5888 )?),
5889 None => None,
5890 },
5891 name: match node.child_by_field_name("name") {
5892 Some(child) => Some(<ResourceName as ::treesitter_types::FromNode>::from_node(
5893 child, src,
5894 )?),
5895 None => None,
5896 },
5897 r#type: match node.child_by_field_name("type") {
5898 Some(child) => {
5899 Some(<UnannotatedType as ::treesitter_types::FromNode>::from_node(child, src)?)
5900 }
5901 None => None,
5902 },
5903 value: match node.child_by_field_name("value") {
5904 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5905 child, src,
5906 )?),
5907 None => None,
5908 },
5909 children: {
5910 #[allow(clippy::suspicious_else_formatting)]
5911 let non_field_children = {
5912 let mut cursor = node.walk();
5913 let mut result = ::std::vec::Vec::new();
5914 if cursor.goto_first_child() {
5915 loop {
5916 if cursor.field_name().is_none()
5917 && cursor.node().is_named()
5918 && !cursor.node().is_extra()
5919 {
5920 result.push(cursor.node());
5921 }
5922 if !cursor.goto_next_sibling() {
5923 break;
5924 }
5925 }
5926 }
5927 result
5928 };
5929 match non_field_children.first() {
5930 Some(&child) => Some(
5931 <ResourceChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5932 ),
5933 None => None,
5934 }
5935 },
5936 })
5937 }
5938}
5939impl ::treesitter_types::Spanned for Resource<'_> {
5940 fn span(&self) -> ::treesitter_types::Span {
5941 self.span
5942 }
5943}
5944#[derive(Debug, Clone, PartialEq, Eq)]
5945pub struct ResourceSpecification<'tree> {
5946 pub span: ::treesitter_types::Span,
5947 pub children: ::std::vec::Vec<Resource<'tree>>,
5948}
5949impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceSpecification<'tree> {
5950 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5951 fn from_node(
5952 node: ::tree_sitter::Node<'tree>,
5953 src: &'tree [u8],
5954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5955 debug_assert_eq!(node.kind(), "resource_specification");
5956 Ok(Self {
5957 span: ::treesitter_types::Span::from(node),
5958 children: {
5959 #[allow(clippy::suspicious_else_formatting)]
5960 let non_field_children = {
5961 let mut cursor = node.walk();
5962 let mut result = ::std::vec::Vec::new();
5963 if cursor.goto_first_child() {
5964 loop {
5965 if cursor.field_name().is_none()
5966 && cursor.node().is_named()
5967 && !cursor.node().is_extra()
5968 {
5969 result.push(cursor.node());
5970 }
5971 if !cursor.goto_next_sibling() {
5972 break;
5973 }
5974 }
5975 }
5976 result
5977 };
5978 let mut items = ::std::vec::Vec::new();
5979 for child in non_field_children {
5980 items.push(<Resource as ::treesitter_types::FromNode>::from_node(
5981 child, src,
5982 )?);
5983 }
5984 items
5985 },
5986 })
5987 }
5988}
5989impl ::treesitter_types::Spanned for ResourceSpecification<'_> {
5990 fn span(&self) -> ::treesitter_types::Span {
5991 self.span
5992 }
5993}
5994#[derive(Debug, Clone, PartialEq, Eq)]
5995pub struct ReturnStatement<'tree> {
5996 pub span: ::treesitter_types::Span,
5997 pub children: ::core::option::Option<Expression<'tree>>,
5998}
5999impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
6000 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6001 fn from_node(
6002 node: ::tree_sitter::Node<'tree>,
6003 src: &'tree [u8],
6004 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6005 debug_assert_eq!(node.kind(), "return_statement");
6006 Ok(Self {
6007 span: ::treesitter_types::Span::from(node),
6008 children: {
6009 #[allow(clippy::suspicious_else_formatting)]
6010 let non_field_children = {
6011 let mut cursor = node.walk();
6012 let mut result = ::std::vec::Vec::new();
6013 if cursor.goto_first_child() {
6014 loop {
6015 if cursor.field_name().is_none()
6016 && cursor.node().is_named()
6017 && !cursor.node().is_extra()
6018 {
6019 result.push(cursor.node());
6020 }
6021 if !cursor.goto_next_sibling() {
6022 break;
6023 }
6024 }
6025 }
6026 result
6027 };
6028 match non_field_children.first() {
6029 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6030 child, src,
6031 )?),
6032 None => None,
6033 }
6034 },
6035 })
6036 }
6037}
6038impl ::treesitter_types::Spanned for ReturnStatement<'_> {
6039 fn span(&self) -> ::treesitter_types::Span {
6040 self.span
6041 }
6042}
6043#[derive(Debug, Clone, PartialEq, Eq)]
6044pub struct ScopedIdentifier<'tree> {
6045 pub span: ::treesitter_types::Span,
6046 pub name: Identifier<'tree>,
6047 pub scope: ScopedIdentifierScope<'tree>,
6048}
6049impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
6050 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6051 fn from_node(
6052 node: ::tree_sitter::Node<'tree>,
6053 src: &'tree [u8],
6054 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6055 debug_assert_eq!(node.kind(), "scoped_identifier");
6056 Ok(Self {
6057 span: ::treesitter_types::Span::from(node),
6058 name: {
6059 let child = node
6060 .child_by_field_name("name")
6061 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6062 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
6063 },
6064 scope: {
6065 let child = node
6066 .child_by_field_name("scope")
6067 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
6068 <ScopedIdentifierScope as ::treesitter_types::FromNode>::from_node(child, src)?
6069 },
6070 })
6071 }
6072}
6073impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
6074 fn span(&self) -> ::treesitter_types::Span {
6075 self.span
6076 }
6077}
6078#[derive(Debug, Clone, PartialEq, Eq)]
6079pub struct ScopedTypeIdentifier<'tree> {
6080 pub span: ::treesitter_types::Span,
6081 pub children: ::std::vec::Vec<ScopedTypeIdentifierChildren<'tree>>,
6082}
6083impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
6084 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6085 fn from_node(
6086 node: ::tree_sitter::Node<'tree>,
6087 src: &'tree [u8],
6088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6089 debug_assert_eq!(node.kind(), "scoped_type_identifier");
6090 Ok(Self {
6091 span: ::treesitter_types::Span::from(node),
6092 children: {
6093 #[allow(clippy::suspicious_else_formatting)]
6094 let non_field_children = {
6095 let mut cursor = node.walk();
6096 let mut result = ::std::vec::Vec::new();
6097 if cursor.goto_first_child() {
6098 loop {
6099 if cursor.field_name().is_none()
6100 && cursor.node().is_named()
6101 && !cursor.node().is_extra()
6102 {
6103 result.push(cursor.node());
6104 }
6105 if !cursor.goto_next_sibling() {
6106 break;
6107 }
6108 }
6109 }
6110 result
6111 };
6112 let mut items = ::std::vec::Vec::new();
6113 for child in non_field_children {
6114 items.push(
6115 <ScopedTypeIdentifierChildren as ::treesitter_types::FromNode>::from_node(
6116 child, src,
6117 )?,
6118 );
6119 }
6120 items
6121 },
6122 })
6123 }
6124}
6125impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
6126 fn span(&self) -> ::treesitter_types::Span {
6127 self.span
6128 }
6129}
6130#[derive(Debug, Clone, PartialEq, Eq)]
6131pub struct SpreadParameter<'tree> {
6132 pub span: ::treesitter_types::Span,
6133 pub children: ::std::vec::Vec<SpreadParameterChildren<'tree>>,
6134}
6135impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameter<'tree> {
6136 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6137 fn from_node(
6138 node: ::tree_sitter::Node<'tree>,
6139 src: &'tree [u8],
6140 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6141 debug_assert_eq!(node.kind(), "spread_parameter");
6142 Ok(Self {
6143 span: ::treesitter_types::Span::from(node),
6144 children: {
6145 #[allow(clippy::suspicious_else_formatting)]
6146 let non_field_children = {
6147 let mut cursor = node.walk();
6148 let mut result = ::std::vec::Vec::new();
6149 if cursor.goto_first_child() {
6150 loop {
6151 if cursor.field_name().is_none()
6152 && cursor.node().is_named()
6153 && !cursor.node().is_extra()
6154 {
6155 result.push(cursor.node());
6156 }
6157 if !cursor.goto_next_sibling() {
6158 break;
6159 }
6160 }
6161 }
6162 result
6163 };
6164 let mut items = ::std::vec::Vec::new();
6165 for child in non_field_children {
6166 items.push(
6167 <SpreadParameterChildren as ::treesitter_types::FromNode>::from_node(
6168 child, src,
6169 )?,
6170 );
6171 }
6172 items
6173 },
6174 })
6175 }
6176}
6177impl ::treesitter_types::Spanned for SpreadParameter<'_> {
6178 fn span(&self) -> ::treesitter_types::Span {
6179 self.span
6180 }
6181}
6182#[derive(Debug, Clone, PartialEq, Eq)]
6183pub struct StaticInitializer<'tree> {
6184 pub span: ::treesitter_types::Span,
6185 pub children: Block<'tree>,
6186}
6187impl<'tree> ::treesitter_types::FromNode<'tree> for StaticInitializer<'tree> {
6188 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6189 fn from_node(
6190 node: ::tree_sitter::Node<'tree>,
6191 src: &'tree [u8],
6192 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6193 debug_assert_eq!(node.kind(), "static_initializer");
6194 Ok(Self {
6195 span: ::treesitter_types::Span::from(node),
6196 children: {
6197 #[allow(clippy::suspicious_else_formatting)]
6198 let non_field_children = {
6199 let mut cursor = node.walk();
6200 let mut result = ::std::vec::Vec::new();
6201 if cursor.goto_first_child() {
6202 loop {
6203 if cursor.field_name().is_none()
6204 && cursor.node().is_named()
6205 && !cursor.node().is_extra()
6206 {
6207 result.push(cursor.node());
6208 }
6209 if !cursor.goto_next_sibling() {
6210 break;
6211 }
6212 }
6213 }
6214 result
6215 };
6216 let child = if let Some(&c) = non_field_children.first() {
6217 c
6218 } else {
6219 let mut fallback_cursor = node.walk();
6220 let mut fallback_child = None;
6221 if fallback_cursor.goto_first_child() {
6222 loop {
6223 if fallback_cursor.field_name().is_none()
6224 && !fallback_cursor.node().is_extra()
6225 {
6226 let candidate = fallback_cursor.node();
6227 #[allow(clippy::needless_question_mark)]
6228 if (|| -> ::core::result::Result<
6229 _,
6230 ::treesitter_types::ParseError,
6231 > {
6232 let child = candidate;
6233 Ok(
6234 <Block as ::treesitter_types::FromNode>::from_node(
6235 child,
6236 src,
6237 )?,
6238 )
6239 })()
6240 .is_ok()
6241 {
6242 fallback_child = Some(candidate);
6243 break;
6244 }
6245 }
6246 if !fallback_cursor.goto_next_sibling() {
6247 break;
6248 }
6249 }
6250 }
6251 if fallback_child.is_none() {
6252 let mut cursor2 = node.walk();
6253 if cursor2.goto_first_child() {
6254 loop {
6255 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6256 let candidate = cursor2.node();
6257 #[allow(clippy::needless_question_mark)]
6258 if (|| -> ::core::result::Result<
6259 _,
6260 ::treesitter_types::ParseError,
6261 > {
6262 let child = candidate;
6263 Ok(
6264 <Block as ::treesitter_types::FromNode>::from_node(
6265 child,
6266 src,
6267 )?,
6268 )
6269 })()
6270 .is_ok()
6271 {
6272 fallback_child = Some(candidate);
6273 break;
6274 }
6275 }
6276 if !cursor2.goto_next_sibling() {
6277 break;
6278 }
6279 }
6280 }
6281 }
6282 fallback_child.ok_or_else(|| {
6283 ::treesitter_types::ParseError::missing_field("children", node)
6284 })?
6285 };
6286 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
6287 },
6288 })
6289 }
6290}
6291impl ::treesitter_types::Spanned for StaticInitializer<'_> {
6292 fn span(&self) -> ::treesitter_types::Span {
6293 self.span
6294 }
6295}
6296#[derive(Debug, Clone, PartialEq, Eq)]
6297pub struct StringInterpolation<'tree> {
6298 pub span: ::treesitter_types::Span,
6299 pub children: Expression<'tree>,
6300}
6301impl<'tree> ::treesitter_types::FromNode<'tree> for StringInterpolation<'tree> {
6302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6303 fn from_node(
6304 node: ::tree_sitter::Node<'tree>,
6305 src: &'tree [u8],
6306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6307 debug_assert_eq!(node.kind(), "string_interpolation");
6308 Ok(Self {
6309 span: ::treesitter_types::Span::from(node),
6310 children: {
6311 #[allow(clippy::suspicious_else_formatting)]
6312 let non_field_children = {
6313 let mut cursor = node.walk();
6314 let mut result = ::std::vec::Vec::new();
6315 if cursor.goto_first_child() {
6316 loop {
6317 if cursor.field_name().is_none()
6318 && cursor.node().is_named()
6319 && !cursor.node().is_extra()
6320 {
6321 result.push(cursor.node());
6322 }
6323 if !cursor.goto_next_sibling() {
6324 break;
6325 }
6326 }
6327 }
6328 result
6329 };
6330 let child = if let Some(&c) = non_field_children.first() {
6331 c
6332 } else {
6333 let mut fallback_cursor = node.walk();
6334 let mut fallback_child = None;
6335 if fallback_cursor.goto_first_child() {
6336 loop {
6337 if fallback_cursor.field_name().is_none()
6338 && !fallback_cursor.node().is_extra()
6339 {
6340 let candidate = fallback_cursor.node();
6341 #[allow(clippy::needless_question_mark)]
6342 if (|| -> ::core::result::Result<
6343 _,
6344 ::treesitter_types::ParseError,
6345 > {
6346 let child = candidate;
6347 Ok(
6348 <Expression as ::treesitter_types::FromNode>::from_node(
6349 child,
6350 src,
6351 )?,
6352 )
6353 })()
6354 .is_ok()
6355 {
6356 fallback_child = Some(candidate);
6357 break;
6358 }
6359 }
6360 if !fallback_cursor.goto_next_sibling() {
6361 break;
6362 }
6363 }
6364 }
6365 if fallback_child.is_none() {
6366 let mut cursor2 = node.walk();
6367 if cursor2.goto_first_child() {
6368 loop {
6369 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6370 let candidate = cursor2.node();
6371 #[allow(clippy::needless_question_mark)]
6372 if (|| -> ::core::result::Result<
6373 _,
6374 ::treesitter_types::ParseError,
6375 > {
6376 let child = candidate;
6377 Ok(
6378 <Expression as ::treesitter_types::FromNode>::from_node(
6379 child,
6380 src,
6381 )?,
6382 )
6383 })()
6384 .is_ok()
6385 {
6386 fallback_child = Some(candidate);
6387 break;
6388 }
6389 }
6390 if !cursor2.goto_next_sibling() {
6391 break;
6392 }
6393 }
6394 }
6395 }
6396 fallback_child.ok_or_else(|| {
6397 ::treesitter_types::ParseError::missing_field("children", node)
6398 })?
6399 };
6400 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6401 },
6402 })
6403 }
6404}
6405impl ::treesitter_types::Spanned for StringInterpolation<'_> {
6406 fn span(&self) -> ::treesitter_types::Span {
6407 self.span
6408 }
6409}
6410#[derive(Debug, Clone, PartialEq, Eq)]
6411pub struct StringLiteral<'tree> {
6412 pub span: ::treesitter_types::Span,
6413 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
6414}
6415impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
6416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6417 fn from_node(
6418 node: ::tree_sitter::Node<'tree>,
6419 src: &'tree [u8],
6420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6421 debug_assert_eq!(node.kind(), "string_literal");
6422 Ok(Self {
6423 span: ::treesitter_types::Span::from(node),
6424 children: {
6425 #[allow(clippy::suspicious_else_formatting)]
6426 let non_field_children = {
6427 let mut cursor = node.walk();
6428 let mut result = ::std::vec::Vec::new();
6429 if cursor.goto_first_child() {
6430 loop {
6431 if cursor.field_name().is_none()
6432 && cursor.node().is_named()
6433 && !cursor.node().is_extra()
6434 {
6435 result.push(cursor.node());
6436 }
6437 if !cursor.goto_next_sibling() {
6438 break;
6439 }
6440 }
6441 }
6442 result
6443 };
6444 let mut items = ::std::vec::Vec::new();
6445 for child in non_field_children {
6446 items.push(
6447 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
6448 child, src,
6449 )?,
6450 );
6451 }
6452 items
6453 },
6454 })
6455 }
6456}
6457impl ::treesitter_types::Spanned for StringLiteral<'_> {
6458 fn span(&self) -> ::treesitter_types::Span {
6459 self.span
6460 }
6461}
6462#[derive(Debug, Clone, PartialEq, Eq)]
6463pub struct SuperInterfaces<'tree> {
6464 pub span: ::treesitter_types::Span,
6465 pub children: TypeList<'tree>,
6466}
6467impl<'tree> ::treesitter_types::FromNode<'tree> for SuperInterfaces<'tree> {
6468 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6469 fn from_node(
6470 node: ::tree_sitter::Node<'tree>,
6471 src: &'tree [u8],
6472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6473 debug_assert_eq!(node.kind(), "super_interfaces");
6474 Ok(Self {
6475 span: ::treesitter_types::Span::from(node),
6476 children: {
6477 #[allow(clippy::suspicious_else_formatting)]
6478 let non_field_children = {
6479 let mut cursor = node.walk();
6480 let mut result = ::std::vec::Vec::new();
6481 if cursor.goto_first_child() {
6482 loop {
6483 if cursor.field_name().is_none()
6484 && cursor.node().is_named()
6485 && !cursor.node().is_extra()
6486 {
6487 result.push(cursor.node());
6488 }
6489 if !cursor.goto_next_sibling() {
6490 break;
6491 }
6492 }
6493 }
6494 result
6495 };
6496 let child = if let Some(&c) = non_field_children.first() {
6497 c
6498 } else {
6499 let mut fallback_cursor = node.walk();
6500 let mut fallback_child = None;
6501 if fallback_cursor.goto_first_child() {
6502 loop {
6503 if fallback_cursor.field_name().is_none()
6504 && !fallback_cursor.node().is_extra()
6505 {
6506 let candidate = fallback_cursor.node();
6507 #[allow(clippy::needless_question_mark)]
6508 if (|| -> ::core::result::Result<
6509 _,
6510 ::treesitter_types::ParseError,
6511 > {
6512 let child = candidate;
6513 Ok(
6514 <TypeList as ::treesitter_types::FromNode>::from_node(
6515 child,
6516 src,
6517 )?,
6518 )
6519 })()
6520 .is_ok()
6521 {
6522 fallback_child = Some(candidate);
6523 break;
6524 }
6525 }
6526 if !fallback_cursor.goto_next_sibling() {
6527 break;
6528 }
6529 }
6530 }
6531 if fallback_child.is_none() {
6532 let mut cursor2 = node.walk();
6533 if cursor2.goto_first_child() {
6534 loop {
6535 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6536 let candidate = cursor2.node();
6537 #[allow(clippy::needless_question_mark)]
6538 if (|| -> ::core::result::Result<
6539 _,
6540 ::treesitter_types::ParseError,
6541 > {
6542 let child = candidate;
6543 Ok(
6544 <TypeList as ::treesitter_types::FromNode>::from_node(
6545 child,
6546 src,
6547 )?,
6548 )
6549 })()
6550 .is_ok()
6551 {
6552 fallback_child = Some(candidate);
6553 break;
6554 }
6555 }
6556 if !cursor2.goto_next_sibling() {
6557 break;
6558 }
6559 }
6560 }
6561 }
6562 fallback_child.ok_or_else(|| {
6563 ::treesitter_types::ParseError::missing_field("children", node)
6564 })?
6565 };
6566 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
6567 },
6568 })
6569 }
6570}
6571impl ::treesitter_types::Spanned for SuperInterfaces<'_> {
6572 fn span(&self) -> ::treesitter_types::Span {
6573 self.span
6574 }
6575}
6576#[derive(Debug, Clone, PartialEq, Eq)]
6577pub struct Superclass<'tree> {
6578 pub span: ::treesitter_types::Span,
6579 pub children: Type<'tree>,
6580}
6581impl<'tree> ::treesitter_types::FromNode<'tree> for Superclass<'tree> {
6582 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6583 fn from_node(
6584 node: ::tree_sitter::Node<'tree>,
6585 src: &'tree [u8],
6586 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6587 debug_assert_eq!(node.kind(), "superclass");
6588 Ok(Self {
6589 span: ::treesitter_types::Span::from(node),
6590 children: {
6591 #[allow(clippy::suspicious_else_formatting)]
6592 let non_field_children = {
6593 let mut cursor = node.walk();
6594 let mut result = ::std::vec::Vec::new();
6595 if cursor.goto_first_child() {
6596 loop {
6597 if cursor.field_name().is_none()
6598 && cursor.node().is_named()
6599 && !cursor.node().is_extra()
6600 {
6601 result.push(cursor.node());
6602 }
6603 if !cursor.goto_next_sibling() {
6604 break;
6605 }
6606 }
6607 }
6608 result
6609 };
6610 let child = if let Some(&c) = non_field_children.first() {
6611 c
6612 } else {
6613 let mut fallback_cursor = node.walk();
6614 let mut fallback_child = None;
6615 if fallback_cursor.goto_first_child() {
6616 loop {
6617 if fallback_cursor.field_name().is_none()
6618 && !fallback_cursor.node().is_extra()
6619 {
6620 let candidate = fallback_cursor.node();
6621 #[allow(clippy::needless_question_mark)]
6622 if (|| -> ::core::result::Result<
6623 _,
6624 ::treesitter_types::ParseError,
6625 > {
6626 let child = candidate;
6627 Ok(
6628 <Type as ::treesitter_types::FromNode>::from_node(
6629 child,
6630 src,
6631 )?,
6632 )
6633 })()
6634 .is_ok()
6635 {
6636 fallback_child = Some(candidate);
6637 break;
6638 }
6639 }
6640 if !fallback_cursor.goto_next_sibling() {
6641 break;
6642 }
6643 }
6644 }
6645 if fallback_child.is_none() {
6646 let mut cursor2 = node.walk();
6647 if cursor2.goto_first_child() {
6648 loop {
6649 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6650 let candidate = cursor2.node();
6651 #[allow(clippy::needless_question_mark)]
6652 if (|| -> ::core::result::Result<
6653 _,
6654 ::treesitter_types::ParseError,
6655 > {
6656 let child = candidate;
6657 Ok(
6658 <Type as ::treesitter_types::FromNode>::from_node(
6659 child,
6660 src,
6661 )?,
6662 )
6663 })()
6664 .is_ok()
6665 {
6666 fallback_child = Some(candidate);
6667 break;
6668 }
6669 }
6670 if !cursor2.goto_next_sibling() {
6671 break;
6672 }
6673 }
6674 }
6675 }
6676 fallback_child.ok_or_else(|| {
6677 ::treesitter_types::ParseError::missing_field("children", node)
6678 })?
6679 };
6680 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6681 },
6682 })
6683 }
6684}
6685impl ::treesitter_types::Spanned for Superclass<'_> {
6686 fn span(&self) -> ::treesitter_types::Span {
6687 self.span
6688 }
6689}
6690#[derive(Debug, Clone, PartialEq, Eq)]
6691pub struct SwitchBlock<'tree> {
6692 pub span: ::treesitter_types::Span,
6693 pub children: ::std::vec::Vec<SwitchBlockChildren<'tree>>,
6694}
6695impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlock<'tree> {
6696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6697 fn from_node(
6698 node: ::tree_sitter::Node<'tree>,
6699 src: &'tree [u8],
6700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6701 debug_assert_eq!(node.kind(), "switch_block");
6702 Ok(Self {
6703 span: ::treesitter_types::Span::from(node),
6704 children: {
6705 #[allow(clippy::suspicious_else_formatting)]
6706 let non_field_children = {
6707 let mut cursor = node.walk();
6708 let mut result = ::std::vec::Vec::new();
6709 if cursor.goto_first_child() {
6710 loop {
6711 if cursor.field_name().is_none()
6712 && cursor.node().is_named()
6713 && !cursor.node().is_extra()
6714 {
6715 result.push(cursor.node());
6716 }
6717 if !cursor.goto_next_sibling() {
6718 break;
6719 }
6720 }
6721 }
6722 result
6723 };
6724 let mut items = ::std::vec::Vec::new();
6725 for child in non_field_children {
6726 items.push(
6727 <SwitchBlockChildren as ::treesitter_types::FromNode>::from_node(
6728 child, src,
6729 )?,
6730 );
6731 }
6732 items
6733 },
6734 })
6735 }
6736}
6737impl ::treesitter_types::Spanned for SwitchBlock<'_> {
6738 fn span(&self) -> ::treesitter_types::Span {
6739 self.span
6740 }
6741}
6742#[derive(Debug, Clone, PartialEq, Eq)]
6743pub struct SwitchBlockStatementGroup<'tree> {
6744 pub span: ::treesitter_types::Span,
6745 pub children: ::std::vec::Vec<SwitchBlockStatementGroupChildren<'tree>>,
6746}
6747impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroup<'tree> {
6748 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6749 fn from_node(
6750 node: ::tree_sitter::Node<'tree>,
6751 src: &'tree [u8],
6752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6753 debug_assert_eq!(node.kind(), "switch_block_statement_group");
6754 Ok(Self {
6755 span: ::treesitter_types::Span::from(node),
6756 children: {
6757 #[allow(clippy::suspicious_else_formatting)]
6758 let non_field_children = {
6759 let mut cursor = node.walk();
6760 let mut result = ::std::vec::Vec::new();
6761 if cursor.goto_first_child() {
6762 loop {
6763 if cursor.field_name().is_none()
6764 && cursor.node().is_named()
6765 && !cursor.node().is_extra()
6766 {
6767 result.push(cursor.node());
6768 }
6769 if !cursor.goto_next_sibling() {
6770 break;
6771 }
6772 }
6773 }
6774 result
6775 };
6776 let mut items = ::std::vec::Vec::new();
6777 for child in non_field_children {
6778 items
6779 .push(
6780 <SwitchBlockStatementGroupChildren as ::treesitter_types::FromNode>::from_node(
6781 child,
6782 src,
6783 )?,
6784 );
6785 }
6786 items
6787 },
6788 })
6789 }
6790}
6791impl ::treesitter_types::Spanned for SwitchBlockStatementGroup<'_> {
6792 fn span(&self) -> ::treesitter_types::Span {
6793 self.span
6794 }
6795}
6796#[derive(Debug, Clone, PartialEq, Eq)]
6797pub struct SwitchExpression<'tree> {
6798 pub span: ::treesitter_types::Span,
6799 pub body: SwitchBlock<'tree>,
6800 pub condition: ParenthesizedExpression<'tree>,
6801}
6802impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
6803 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6804 fn from_node(
6805 node: ::tree_sitter::Node<'tree>,
6806 src: &'tree [u8],
6807 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6808 debug_assert_eq!(node.kind(), "switch_expression");
6809 Ok(Self {
6810 span: ::treesitter_types::Span::from(node),
6811 body: {
6812 let child = node
6813 .child_by_field_name("body")
6814 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6815 <SwitchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
6816 },
6817 condition: {
6818 let child = node.child_by_field_name("condition").ok_or_else(|| {
6819 ::treesitter_types::ParseError::missing_field("condition", node)
6820 })?;
6821 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6822 },
6823 })
6824 }
6825}
6826impl ::treesitter_types::Spanned for SwitchExpression<'_> {
6827 fn span(&self) -> ::treesitter_types::Span {
6828 self.span
6829 }
6830}
6831#[derive(Debug, Clone, PartialEq, Eq)]
6832pub struct SwitchLabel<'tree> {
6833 pub span: ::treesitter_types::Span,
6834 pub children: ::std::vec::Vec<SwitchLabelChildren<'tree>>,
6835}
6836impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabel<'tree> {
6837 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6838 fn from_node(
6839 node: ::tree_sitter::Node<'tree>,
6840 src: &'tree [u8],
6841 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6842 debug_assert_eq!(node.kind(), "switch_label");
6843 Ok(Self {
6844 span: ::treesitter_types::Span::from(node),
6845 children: {
6846 #[allow(clippy::suspicious_else_formatting)]
6847 let non_field_children = {
6848 let mut cursor = node.walk();
6849 let mut result = ::std::vec::Vec::new();
6850 if cursor.goto_first_child() {
6851 loop {
6852 if cursor.field_name().is_none()
6853 && cursor.node().is_named()
6854 && !cursor.node().is_extra()
6855 {
6856 result.push(cursor.node());
6857 }
6858 if !cursor.goto_next_sibling() {
6859 break;
6860 }
6861 }
6862 }
6863 result
6864 };
6865 let mut items = ::std::vec::Vec::new();
6866 for child in non_field_children {
6867 items.push(
6868 <SwitchLabelChildren as ::treesitter_types::FromNode>::from_node(
6869 child, src,
6870 )?,
6871 );
6872 }
6873 items
6874 },
6875 })
6876 }
6877}
6878impl ::treesitter_types::Spanned for SwitchLabel<'_> {
6879 fn span(&self) -> ::treesitter_types::Span {
6880 self.span
6881 }
6882}
6883#[derive(Debug, Clone, PartialEq, Eq)]
6884pub struct SwitchRule<'tree> {
6885 pub span: ::treesitter_types::Span,
6886 pub children: ::std::vec::Vec<SwitchRuleChildren<'tree>>,
6887}
6888impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRule<'tree> {
6889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6890 fn from_node(
6891 node: ::tree_sitter::Node<'tree>,
6892 src: &'tree [u8],
6893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6894 debug_assert_eq!(node.kind(), "switch_rule");
6895 Ok(Self {
6896 span: ::treesitter_types::Span::from(node),
6897 children: {
6898 #[allow(clippy::suspicious_else_formatting)]
6899 let non_field_children = {
6900 let mut cursor = node.walk();
6901 let mut result = ::std::vec::Vec::new();
6902 if cursor.goto_first_child() {
6903 loop {
6904 if cursor.field_name().is_none()
6905 && cursor.node().is_named()
6906 && !cursor.node().is_extra()
6907 {
6908 result.push(cursor.node());
6909 }
6910 if !cursor.goto_next_sibling() {
6911 break;
6912 }
6913 }
6914 }
6915 result
6916 };
6917 let mut items = ::std::vec::Vec::new();
6918 for child in non_field_children {
6919 items.push(
6920 <SwitchRuleChildren as ::treesitter_types::FromNode>::from_node(
6921 child, src,
6922 )?,
6923 );
6924 }
6925 items
6926 },
6927 })
6928 }
6929}
6930impl ::treesitter_types::Spanned for SwitchRule<'_> {
6931 fn span(&self) -> ::treesitter_types::Span {
6932 self.span
6933 }
6934}
6935#[derive(Debug, Clone, PartialEq, Eq)]
6936pub struct SynchronizedStatement<'tree> {
6937 pub span: ::treesitter_types::Span,
6938 pub body: Block<'tree>,
6939 pub children: ParenthesizedExpression<'tree>,
6940}
6941impl<'tree> ::treesitter_types::FromNode<'tree> for SynchronizedStatement<'tree> {
6942 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6943 fn from_node(
6944 node: ::tree_sitter::Node<'tree>,
6945 src: &'tree [u8],
6946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6947 debug_assert_eq!(node.kind(), "synchronized_statement");
6948 Ok(Self {
6949 span: ::treesitter_types::Span::from(node),
6950 body: {
6951 let child = node
6952 .child_by_field_name("body")
6953 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6954 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
6955 },
6956 children: {
6957 #[allow(clippy::suspicious_else_formatting)]
6958 let non_field_children = {
6959 let mut cursor = node.walk();
6960 let mut result = ::std::vec::Vec::new();
6961 if cursor.goto_first_child() {
6962 loop {
6963 if cursor.field_name().is_none()
6964 && cursor.node().is_named()
6965 && !cursor.node().is_extra()
6966 {
6967 result.push(cursor.node());
6968 }
6969 if !cursor.goto_next_sibling() {
6970 break;
6971 }
6972 }
6973 }
6974 result
6975 };
6976 let child = if let Some(&c) = non_field_children.first() {
6977 c
6978 } else {
6979 let mut fallback_cursor = node.walk();
6980 let mut fallback_child = None;
6981 if fallback_cursor.goto_first_child() {
6982 loop {
6983 if fallback_cursor.field_name().is_none()
6984 && !fallback_cursor.node().is_extra()
6985 {
6986 let candidate = fallback_cursor.node();
6987 #[allow(clippy::needless_question_mark)]
6988 if (|| -> ::core::result::Result<
6989 _,
6990 ::treesitter_types::ParseError,
6991 > {
6992 let child = candidate;
6993 Ok(
6994 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
6995 child,
6996 src,
6997 )?,
6998 )
6999 })()
7000 .is_ok()
7001 {
7002 fallback_child = Some(candidate);
7003 break;
7004 }
7005 }
7006 if !fallback_cursor.goto_next_sibling() {
7007 break;
7008 }
7009 }
7010 }
7011 if fallback_child.is_none() {
7012 let mut cursor2 = node.walk();
7013 if cursor2.goto_first_child() {
7014 loop {
7015 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7016 let candidate = cursor2.node();
7017 #[allow(clippy::needless_question_mark)]
7018 if (|| -> ::core::result::Result<
7019 _,
7020 ::treesitter_types::ParseError,
7021 > {
7022 let child = candidate;
7023 Ok(
7024 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
7025 child,
7026 src,
7027 )?,
7028 )
7029 })()
7030 .is_ok()
7031 {
7032 fallback_child = Some(candidate);
7033 break;
7034 }
7035 }
7036 if !cursor2.goto_next_sibling() {
7037 break;
7038 }
7039 }
7040 }
7041 }
7042 fallback_child.ok_or_else(|| {
7043 ::treesitter_types::ParseError::missing_field("children", node)
7044 })?
7045 };
7046 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
7047 },
7048 })
7049 }
7050}
7051impl ::treesitter_types::Spanned for SynchronizedStatement<'_> {
7052 fn span(&self) -> ::treesitter_types::Span {
7053 self.span
7054 }
7055}
7056#[derive(Debug, Clone, PartialEq, Eq)]
7057pub struct TemplateExpression<'tree> {
7058 pub span: ::treesitter_types::Span,
7059 pub template_argument: StringLiteral<'tree>,
7060 pub template_processor: PrimaryExpression<'tree>,
7061}
7062impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateExpression<'tree> {
7063 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7064 fn from_node(
7065 node: ::tree_sitter::Node<'tree>,
7066 src: &'tree [u8],
7067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7068 debug_assert_eq!(node.kind(), "template_expression");
7069 Ok(Self {
7070 span: ::treesitter_types::Span::from(node),
7071 template_argument: {
7072 let child = node
7073 .child_by_field_name("template_argument")
7074 .ok_or_else(|| {
7075 ::treesitter_types::ParseError::missing_field("template_argument", node)
7076 })?;
7077 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?
7078 },
7079 template_processor: {
7080 let child = node
7081 .child_by_field_name("template_processor")
7082 .ok_or_else(|| {
7083 ::treesitter_types::ParseError::missing_field("template_processor", node)
7084 })?;
7085 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
7086 },
7087 })
7088 }
7089}
7090impl ::treesitter_types::Spanned for TemplateExpression<'_> {
7091 fn span(&self) -> ::treesitter_types::Span {
7092 self.span
7093 }
7094}
7095#[derive(Debug, Clone, PartialEq, Eq)]
7096pub struct TernaryExpression<'tree> {
7097 pub span: ::treesitter_types::Span,
7098 pub alternative: Expression<'tree>,
7099 pub condition: Expression<'tree>,
7100 pub consequence: Expression<'tree>,
7101}
7102impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'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(), "ternary_expression");
7109 Ok(Self {
7110 span: ::treesitter_types::Span::from(node),
7111 alternative: {
7112 let child = node.child_by_field_name("alternative").ok_or_else(|| {
7113 ::treesitter_types::ParseError::missing_field("alternative", node)
7114 })?;
7115 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7116 },
7117 condition: {
7118 let child = node.child_by_field_name("condition").ok_or_else(|| {
7119 ::treesitter_types::ParseError::missing_field("condition", node)
7120 })?;
7121 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7122 },
7123 consequence: {
7124 let child = node.child_by_field_name("consequence").ok_or_else(|| {
7125 ::treesitter_types::ParseError::missing_field("consequence", node)
7126 })?;
7127 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7128 },
7129 })
7130 }
7131}
7132impl ::treesitter_types::Spanned for TernaryExpression<'_> {
7133 fn span(&self) -> ::treesitter_types::Span {
7134 self.span
7135 }
7136}
7137#[derive(Debug, Clone, PartialEq, Eq)]
7138pub struct ThrowStatement<'tree> {
7139 pub span: ::treesitter_types::Span,
7140 pub children: Expression<'tree>,
7141}
7142impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
7143 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7144 fn from_node(
7145 node: ::tree_sitter::Node<'tree>,
7146 src: &'tree [u8],
7147 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7148 debug_assert_eq!(node.kind(), "throw_statement");
7149 Ok(Self {
7150 span: ::treesitter_types::Span::from(node),
7151 children: {
7152 #[allow(clippy::suspicious_else_formatting)]
7153 let non_field_children = {
7154 let mut cursor = node.walk();
7155 let mut result = ::std::vec::Vec::new();
7156 if cursor.goto_first_child() {
7157 loop {
7158 if cursor.field_name().is_none()
7159 && cursor.node().is_named()
7160 && !cursor.node().is_extra()
7161 {
7162 result.push(cursor.node());
7163 }
7164 if !cursor.goto_next_sibling() {
7165 break;
7166 }
7167 }
7168 }
7169 result
7170 };
7171 let child = if let Some(&c) = non_field_children.first() {
7172 c
7173 } else {
7174 let mut fallback_cursor = node.walk();
7175 let mut fallback_child = None;
7176 if fallback_cursor.goto_first_child() {
7177 loop {
7178 if fallback_cursor.field_name().is_none()
7179 && !fallback_cursor.node().is_extra()
7180 {
7181 let candidate = fallback_cursor.node();
7182 #[allow(clippy::needless_question_mark)]
7183 if (|| -> ::core::result::Result<
7184 _,
7185 ::treesitter_types::ParseError,
7186 > {
7187 let child = candidate;
7188 Ok(
7189 <Expression as ::treesitter_types::FromNode>::from_node(
7190 child,
7191 src,
7192 )?,
7193 )
7194 })()
7195 .is_ok()
7196 {
7197 fallback_child = Some(candidate);
7198 break;
7199 }
7200 }
7201 if !fallback_cursor.goto_next_sibling() {
7202 break;
7203 }
7204 }
7205 }
7206 if fallback_child.is_none() {
7207 let mut cursor2 = node.walk();
7208 if cursor2.goto_first_child() {
7209 loop {
7210 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7211 let candidate = cursor2.node();
7212 #[allow(clippy::needless_question_mark)]
7213 if (|| -> ::core::result::Result<
7214 _,
7215 ::treesitter_types::ParseError,
7216 > {
7217 let child = candidate;
7218 Ok(
7219 <Expression as ::treesitter_types::FromNode>::from_node(
7220 child,
7221 src,
7222 )?,
7223 )
7224 })()
7225 .is_ok()
7226 {
7227 fallback_child = Some(candidate);
7228 break;
7229 }
7230 }
7231 if !cursor2.goto_next_sibling() {
7232 break;
7233 }
7234 }
7235 }
7236 }
7237 fallback_child.ok_or_else(|| {
7238 ::treesitter_types::ParseError::missing_field("children", node)
7239 })?
7240 };
7241 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7242 },
7243 })
7244 }
7245}
7246impl ::treesitter_types::Spanned for ThrowStatement<'_> {
7247 fn span(&self) -> ::treesitter_types::Span {
7248 self.span
7249 }
7250}
7251#[derive(Debug, Clone, PartialEq, Eq)]
7252pub struct Throws<'tree> {
7253 pub span: ::treesitter_types::Span,
7254 pub children: ::std::vec::Vec<Type<'tree>>,
7255}
7256impl<'tree> ::treesitter_types::FromNode<'tree> for Throws<'tree> {
7257 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7258 fn from_node(
7259 node: ::tree_sitter::Node<'tree>,
7260 src: &'tree [u8],
7261 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7262 debug_assert_eq!(node.kind(), "throws");
7263 Ok(Self {
7264 span: ::treesitter_types::Span::from(node),
7265 children: {
7266 #[allow(clippy::suspicious_else_formatting)]
7267 let non_field_children = {
7268 let mut cursor = node.walk();
7269 let mut result = ::std::vec::Vec::new();
7270 if cursor.goto_first_child() {
7271 loop {
7272 if cursor.field_name().is_none()
7273 && cursor.node().is_named()
7274 && !cursor.node().is_extra()
7275 {
7276 result.push(cursor.node());
7277 }
7278 if !cursor.goto_next_sibling() {
7279 break;
7280 }
7281 }
7282 }
7283 result
7284 };
7285 let mut items = ::std::vec::Vec::new();
7286 for child in non_field_children {
7287 items.push(<Type as ::treesitter_types::FromNode>::from_node(
7288 child, src,
7289 )?);
7290 }
7291 items
7292 },
7293 })
7294 }
7295}
7296impl ::treesitter_types::Spanned for Throws<'_> {
7297 fn span(&self) -> ::treesitter_types::Span {
7298 self.span
7299 }
7300}
7301#[derive(Debug, Clone, PartialEq, Eq)]
7302pub struct TryStatement<'tree> {
7303 pub span: ::treesitter_types::Span,
7304 pub body: Block<'tree>,
7305 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
7306}
7307impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
7308 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7309 fn from_node(
7310 node: ::tree_sitter::Node<'tree>,
7311 src: &'tree [u8],
7312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7313 debug_assert_eq!(node.kind(), "try_statement");
7314 Ok(Self {
7315 span: ::treesitter_types::Span::from(node),
7316 body: {
7317 let child = node
7318 .child_by_field_name("body")
7319 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7320 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
7321 },
7322 children: {
7323 #[allow(clippy::suspicious_else_formatting)]
7324 let non_field_children = {
7325 let mut cursor = node.walk();
7326 let mut result = ::std::vec::Vec::new();
7327 if cursor.goto_first_child() {
7328 loop {
7329 if cursor.field_name().is_none()
7330 && cursor.node().is_named()
7331 && !cursor.node().is_extra()
7332 {
7333 result.push(cursor.node());
7334 }
7335 if !cursor.goto_next_sibling() {
7336 break;
7337 }
7338 }
7339 }
7340 result
7341 };
7342 let mut items = ::std::vec::Vec::new();
7343 for child in non_field_children {
7344 items.push(
7345 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
7346 child, src,
7347 )?,
7348 );
7349 }
7350 items
7351 },
7352 })
7353 }
7354}
7355impl ::treesitter_types::Spanned for TryStatement<'_> {
7356 fn span(&self) -> ::treesitter_types::Span {
7357 self.span
7358 }
7359}
7360#[derive(Debug, Clone, PartialEq, Eq)]
7361pub struct TryWithResourcesStatement<'tree> {
7362 pub span: ::treesitter_types::Span,
7363 pub body: Block<'tree>,
7364 pub resources: ResourceSpecification<'tree>,
7365 pub children: ::std::vec::Vec<TryWithResourcesStatementChildren<'tree>>,
7366}
7367impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatement<'tree> {
7368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7369 fn from_node(
7370 node: ::tree_sitter::Node<'tree>,
7371 src: &'tree [u8],
7372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7373 debug_assert_eq!(node.kind(), "try_with_resources_statement");
7374 Ok(Self {
7375 span: ::treesitter_types::Span::from(node),
7376 body: {
7377 let child = node
7378 .child_by_field_name("body")
7379 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7380 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
7381 },
7382 resources: {
7383 let child = node.child_by_field_name("resources").ok_or_else(|| {
7384 ::treesitter_types::ParseError::missing_field("resources", node)
7385 })?;
7386 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(child, src)?
7387 },
7388 children: {
7389 #[allow(clippy::suspicious_else_formatting)]
7390 let non_field_children = {
7391 let mut cursor = node.walk();
7392 let mut result = ::std::vec::Vec::new();
7393 if cursor.goto_first_child() {
7394 loop {
7395 if cursor.field_name().is_none()
7396 && cursor.node().is_named()
7397 && !cursor.node().is_extra()
7398 {
7399 result.push(cursor.node());
7400 }
7401 if !cursor.goto_next_sibling() {
7402 break;
7403 }
7404 }
7405 }
7406 result
7407 };
7408 let mut items = ::std::vec::Vec::new();
7409 for child in non_field_children {
7410 items
7411 .push(
7412 <TryWithResourcesStatementChildren as ::treesitter_types::FromNode>::from_node(
7413 child,
7414 src,
7415 )?,
7416 );
7417 }
7418 items
7419 },
7420 })
7421 }
7422}
7423impl ::treesitter_types::Spanned for TryWithResourcesStatement<'_> {
7424 fn span(&self) -> ::treesitter_types::Span {
7425 self.span
7426 }
7427}
7428#[derive(Debug, Clone, PartialEq, Eq)]
7429pub struct TypeArguments<'tree> {
7430 pub span: ::treesitter_types::Span,
7431 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
7432}
7433impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
7434 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7435 fn from_node(
7436 node: ::tree_sitter::Node<'tree>,
7437 src: &'tree [u8],
7438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7439 debug_assert_eq!(node.kind(), "type_arguments");
7440 Ok(Self {
7441 span: ::treesitter_types::Span::from(node),
7442 children: {
7443 #[allow(clippy::suspicious_else_formatting)]
7444 let non_field_children = {
7445 let mut cursor = node.walk();
7446 let mut result = ::std::vec::Vec::new();
7447 if cursor.goto_first_child() {
7448 loop {
7449 if cursor.field_name().is_none()
7450 && cursor.node().is_named()
7451 && !cursor.node().is_extra()
7452 {
7453 result.push(cursor.node());
7454 }
7455 if !cursor.goto_next_sibling() {
7456 break;
7457 }
7458 }
7459 }
7460 result
7461 };
7462 let mut items = ::std::vec::Vec::new();
7463 for child in non_field_children {
7464 items.push(
7465 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
7466 child, src,
7467 )?,
7468 );
7469 }
7470 items
7471 },
7472 })
7473 }
7474}
7475impl ::treesitter_types::Spanned for TypeArguments<'_> {
7476 fn span(&self) -> ::treesitter_types::Span {
7477 self.span
7478 }
7479}
7480#[derive(Debug, Clone, PartialEq, Eq)]
7481pub struct TypeBound<'tree> {
7482 pub span: ::treesitter_types::Span,
7483 pub children: ::std::vec::Vec<Type<'tree>>,
7484}
7485impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBound<'tree> {
7486 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7487 fn from_node(
7488 node: ::tree_sitter::Node<'tree>,
7489 src: &'tree [u8],
7490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7491 debug_assert_eq!(node.kind(), "type_bound");
7492 Ok(Self {
7493 span: ::treesitter_types::Span::from(node),
7494 children: {
7495 #[allow(clippy::suspicious_else_formatting)]
7496 let non_field_children = {
7497 let mut cursor = node.walk();
7498 let mut result = ::std::vec::Vec::new();
7499 if cursor.goto_first_child() {
7500 loop {
7501 if cursor.field_name().is_none()
7502 && cursor.node().is_named()
7503 && !cursor.node().is_extra()
7504 {
7505 result.push(cursor.node());
7506 }
7507 if !cursor.goto_next_sibling() {
7508 break;
7509 }
7510 }
7511 }
7512 result
7513 };
7514 let mut items = ::std::vec::Vec::new();
7515 for child in non_field_children {
7516 items.push(<Type as ::treesitter_types::FromNode>::from_node(
7517 child, src,
7518 )?);
7519 }
7520 items
7521 },
7522 })
7523 }
7524}
7525impl ::treesitter_types::Spanned for TypeBound<'_> {
7526 fn span(&self) -> ::treesitter_types::Span {
7527 self.span
7528 }
7529}
7530#[derive(Debug, Clone, PartialEq, Eq)]
7531pub struct TypeList<'tree> {
7532 pub span: ::treesitter_types::Span,
7533 pub children: ::std::vec::Vec<Type<'tree>>,
7534}
7535impl<'tree> ::treesitter_types::FromNode<'tree> for TypeList<'tree> {
7536 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7537 fn from_node(
7538 node: ::tree_sitter::Node<'tree>,
7539 src: &'tree [u8],
7540 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7541 debug_assert_eq!(node.kind(), "type_list");
7542 Ok(Self {
7543 span: ::treesitter_types::Span::from(node),
7544 children: {
7545 #[allow(clippy::suspicious_else_formatting)]
7546 let non_field_children = {
7547 let mut cursor = node.walk();
7548 let mut result = ::std::vec::Vec::new();
7549 if cursor.goto_first_child() {
7550 loop {
7551 if cursor.field_name().is_none()
7552 && cursor.node().is_named()
7553 && !cursor.node().is_extra()
7554 {
7555 result.push(cursor.node());
7556 }
7557 if !cursor.goto_next_sibling() {
7558 break;
7559 }
7560 }
7561 }
7562 result
7563 };
7564 let mut items = ::std::vec::Vec::new();
7565 for child in non_field_children {
7566 items.push(<Type as ::treesitter_types::FromNode>::from_node(
7567 child, src,
7568 )?);
7569 }
7570 items
7571 },
7572 })
7573 }
7574}
7575impl ::treesitter_types::Spanned for TypeList<'_> {
7576 fn span(&self) -> ::treesitter_types::Span {
7577 self.span
7578 }
7579}
7580#[derive(Debug, Clone, PartialEq, Eq)]
7581pub struct TypeParameter<'tree> {
7582 pub span: ::treesitter_types::Span,
7583 pub children: ::std::vec::Vec<TypeParameterChildren<'tree>>,
7584}
7585impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
7586 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7587 fn from_node(
7588 node: ::tree_sitter::Node<'tree>,
7589 src: &'tree [u8],
7590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7591 debug_assert_eq!(node.kind(), "type_parameter");
7592 Ok(Self {
7593 span: ::treesitter_types::Span::from(node),
7594 children: {
7595 #[allow(clippy::suspicious_else_formatting)]
7596 let non_field_children = {
7597 let mut cursor = node.walk();
7598 let mut result = ::std::vec::Vec::new();
7599 if cursor.goto_first_child() {
7600 loop {
7601 if cursor.field_name().is_none()
7602 && cursor.node().is_named()
7603 && !cursor.node().is_extra()
7604 {
7605 result.push(cursor.node());
7606 }
7607 if !cursor.goto_next_sibling() {
7608 break;
7609 }
7610 }
7611 }
7612 result
7613 };
7614 let mut items = ::std::vec::Vec::new();
7615 for child in non_field_children {
7616 items.push(
7617 <TypeParameterChildren as ::treesitter_types::FromNode>::from_node(
7618 child, src,
7619 )?,
7620 );
7621 }
7622 items
7623 },
7624 })
7625 }
7626}
7627impl ::treesitter_types::Spanned for TypeParameter<'_> {
7628 fn span(&self) -> ::treesitter_types::Span {
7629 self.span
7630 }
7631}
7632#[derive(Debug, Clone, PartialEq, Eq)]
7633pub struct TypeParameters<'tree> {
7634 pub span: ::treesitter_types::Span,
7635 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
7636}
7637impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
7638 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7639 fn from_node(
7640 node: ::tree_sitter::Node<'tree>,
7641 src: &'tree [u8],
7642 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7643 debug_assert_eq!(node.kind(), "type_parameters");
7644 Ok(Self {
7645 span: ::treesitter_types::Span::from(node),
7646 children: {
7647 #[allow(clippy::suspicious_else_formatting)]
7648 let non_field_children = {
7649 let mut cursor = node.walk();
7650 let mut result = ::std::vec::Vec::new();
7651 if cursor.goto_first_child() {
7652 loop {
7653 if cursor.field_name().is_none()
7654 && cursor.node().is_named()
7655 && !cursor.node().is_extra()
7656 {
7657 result.push(cursor.node());
7658 }
7659 if !cursor.goto_next_sibling() {
7660 break;
7661 }
7662 }
7663 }
7664 result
7665 };
7666 let mut items = ::std::vec::Vec::new();
7667 for child in non_field_children {
7668 items.push(<TypeParameter as ::treesitter_types::FromNode>::from_node(
7669 child, src,
7670 )?);
7671 }
7672 items
7673 },
7674 })
7675 }
7676}
7677impl ::treesitter_types::Spanned for TypeParameters<'_> {
7678 fn span(&self) -> ::treesitter_types::Span {
7679 self.span
7680 }
7681}
7682#[derive(Debug, Clone, PartialEq, Eq)]
7683pub struct TypePattern<'tree> {
7684 pub span: ::treesitter_types::Span,
7685 pub children: ::std::vec::Vec<TypePatternChildren<'tree>>,
7686}
7687impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
7688 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7689 fn from_node(
7690 node: ::tree_sitter::Node<'tree>,
7691 src: &'tree [u8],
7692 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7693 debug_assert_eq!(node.kind(), "type_pattern");
7694 Ok(Self {
7695 span: ::treesitter_types::Span::from(node),
7696 children: {
7697 #[allow(clippy::suspicious_else_formatting)]
7698 let non_field_children = {
7699 let mut cursor = node.walk();
7700 let mut result = ::std::vec::Vec::new();
7701 if cursor.goto_first_child() {
7702 loop {
7703 if cursor.field_name().is_none()
7704 && cursor.node().is_named()
7705 && !cursor.node().is_extra()
7706 {
7707 result.push(cursor.node());
7708 }
7709 if !cursor.goto_next_sibling() {
7710 break;
7711 }
7712 }
7713 }
7714 result
7715 };
7716 let mut items = ::std::vec::Vec::new();
7717 for child in non_field_children {
7718 items.push(
7719 <TypePatternChildren as ::treesitter_types::FromNode>::from_node(
7720 child, src,
7721 )?,
7722 );
7723 }
7724 items
7725 },
7726 })
7727 }
7728}
7729impl ::treesitter_types::Spanned for TypePattern<'_> {
7730 fn span(&self) -> ::treesitter_types::Span {
7731 self.span
7732 }
7733}
7734#[derive(Debug, Clone, PartialEq, Eq)]
7735pub struct UnaryExpression<'tree> {
7736 pub span: ::treesitter_types::Span,
7737 pub operand: Expression<'tree>,
7738 pub operator: UnaryExpressionOperator,
7739}
7740impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
7741 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7742 fn from_node(
7743 node: ::tree_sitter::Node<'tree>,
7744 src: &'tree [u8],
7745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7746 debug_assert_eq!(node.kind(), "unary_expression");
7747 Ok(Self {
7748 span: ::treesitter_types::Span::from(node),
7749 operand: {
7750 let child = node.child_by_field_name("operand").ok_or_else(|| {
7751 ::treesitter_types::ParseError::missing_field("operand", node)
7752 })?;
7753 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7754 },
7755 operator: {
7756 let child = node.child_by_field_name("operator").ok_or_else(|| {
7757 ::treesitter_types::ParseError::missing_field("operator", node)
7758 })?;
7759 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
7760 },
7761 })
7762 }
7763}
7764impl ::treesitter_types::Spanned for UnaryExpression<'_> {
7765 fn span(&self) -> ::treesitter_types::Span {
7766 self.span
7767 }
7768}
7769#[derive(Debug, Clone, PartialEq, Eq)]
7770pub struct UpdateExpression<'tree> {
7771 pub span: ::treesitter_types::Span,
7772 pub children: Expression<'tree>,
7773}
7774impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
7775 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7776 fn from_node(
7777 node: ::tree_sitter::Node<'tree>,
7778 src: &'tree [u8],
7779 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7780 debug_assert_eq!(node.kind(), "update_expression");
7781 Ok(Self {
7782 span: ::treesitter_types::Span::from(node),
7783 children: {
7784 #[allow(clippy::suspicious_else_formatting)]
7785 let non_field_children = {
7786 let mut cursor = node.walk();
7787 let mut result = ::std::vec::Vec::new();
7788 if cursor.goto_first_child() {
7789 loop {
7790 if cursor.field_name().is_none()
7791 && cursor.node().is_named()
7792 && !cursor.node().is_extra()
7793 {
7794 result.push(cursor.node());
7795 }
7796 if !cursor.goto_next_sibling() {
7797 break;
7798 }
7799 }
7800 }
7801 result
7802 };
7803 let child = if let Some(&c) = non_field_children.first() {
7804 c
7805 } else {
7806 let mut fallback_cursor = node.walk();
7807 let mut fallback_child = None;
7808 if fallback_cursor.goto_first_child() {
7809 loop {
7810 if fallback_cursor.field_name().is_none()
7811 && !fallback_cursor.node().is_extra()
7812 {
7813 let candidate = fallback_cursor.node();
7814 #[allow(clippy::needless_question_mark)]
7815 if (|| -> ::core::result::Result<
7816 _,
7817 ::treesitter_types::ParseError,
7818 > {
7819 let child = candidate;
7820 Ok(
7821 <Expression as ::treesitter_types::FromNode>::from_node(
7822 child,
7823 src,
7824 )?,
7825 )
7826 })()
7827 .is_ok()
7828 {
7829 fallback_child = Some(candidate);
7830 break;
7831 }
7832 }
7833 if !fallback_cursor.goto_next_sibling() {
7834 break;
7835 }
7836 }
7837 }
7838 if fallback_child.is_none() {
7839 let mut cursor2 = node.walk();
7840 if cursor2.goto_first_child() {
7841 loop {
7842 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7843 let candidate = cursor2.node();
7844 #[allow(clippy::needless_question_mark)]
7845 if (|| -> ::core::result::Result<
7846 _,
7847 ::treesitter_types::ParseError,
7848 > {
7849 let child = candidate;
7850 Ok(
7851 <Expression as ::treesitter_types::FromNode>::from_node(
7852 child,
7853 src,
7854 )?,
7855 )
7856 })()
7857 .is_ok()
7858 {
7859 fallback_child = Some(candidate);
7860 break;
7861 }
7862 }
7863 if !cursor2.goto_next_sibling() {
7864 break;
7865 }
7866 }
7867 }
7868 }
7869 fallback_child.ok_or_else(|| {
7870 ::treesitter_types::ParseError::missing_field("children", node)
7871 })?
7872 };
7873 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7874 },
7875 })
7876 }
7877}
7878impl ::treesitter_types::Spanned for UpdateExpression<'_> {
7879 fn span(&self) -> ::treesitter_types::Span {
7880 self.span
7881 }
7882}
7883#[derive(Debug, Clone, PartialEq, Eq)]
7884pub struct UsesModuleDirective<'tree> {
7885 pub span: ::treesitter_types::Span,
7886 pub r#type: UsesModuleDirectiveType<'tree>,
7887}
7888impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirective<'tree> {
7889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7890 fn from_node(
7891 node: ::tree_sitter::Node<'tree>,
7892 src: &'tree [u8],
7893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7894 debug_assert_eq!(node.kind(), "uses_module_directive");
7895 Ok(Self {
7896 span: ::treesitter_types::Span::from(node),
7897 r#type: {
7898 let child = node
7899 .child_by_field_name("type")
7900 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7901 <UsesModuleDirectiveType as ::treesitter_types::FromNode>::from_node(child, src)?
7902 },
7903 })
7904 }
7905}
7906impl ::treesitter_types::Spanned for UsesModuleDirective<'_> {
7907 fn span(&self) -> ::treesitter_types::Span {
7908 self.span
7909 }
7910}
7911#[derive(Debug, Clone, PartialEq, Eq)]
7912pub struct VariableDeclarator<'tree> {
7913 pub span: ::treesitter_types::Span,
7914 pub dimensions: ::core::option::Option<Dimensions<'tree>>,
7915 pub name: VariableDeclaratorName<'tree>,
7916 pub value: ::core::option::Option<VariableDeclaratorValue<'tree>>,
7917}
7918impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
7919 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7920 fn from_node(
7921 node: ::tree_sitter::Node<'tree>,
7922 src: &'tree [u8],
7923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7924 debug_assert_eq!(node.kind(), "variable_declarator");
7925 Ok(Self {
7926 span: ::treesitter_types::Span::from(node),
7927 dimensions: match node.child_by_field_name("dimensions") {
7928 Some(child) => Some(<Dimensions as ::treesitter_types::FromNode>::from_node(
7929 child, src,
7930 )?),
7931 None => None,
7932 },
7933 name: {
7934 let child = node
7935 .child_by_field_name("name")
7936 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7937 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)?
7938 },
7939 value: match node.child_by_field_name("value") {
7940 Some(child) => Some(
7941 <VariableDeclaratorValue as ::treesitter_types::FromNode>::from_node(
7942 child, src,
7943 )?,
7944 ),
7945 None => None,
7946 },
7947 })
7948 }
7949}
7950impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
7951 fn span(&self) -> ::treesitter_types::Span {
7952 self.span
7953 }
7954}
7955#[derive(Debug, Clone, PartialEq, Eq)]
7956pub struct WhileStatement<'tree> {
7957 pub span: ::treesitter_types::Span,
7958 pub body: Statement<'tree>,
7959 pub condition: ParenthesizedExpression<'tree>,
7960}
7961impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
7962 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7963 fn from_node(
7964 node: ::tree_sitter::Node<'tree>,
7965 src: &'tree [u8],
7966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7967 debug_assert_eq!(node.kind(), "while_statement");
7968 Ok(Self {
7969 span: ::treesitter_types::Span::from(node),
7970 body: {
7971 let child = node
7972 .child_by_field_name("body")
7973 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7974 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
7975 },
7976 condition: {
7977 let child = node.child_by_field_name("condition").ok_or_else(|| {
7978 ::treesitter_types::ParseError::missing_field("condition", node)
7979 })?;
7980 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
7981 },
7982 })
7983 }
7984}
7985impl ::treesitter_types::Spanned for WhileStatement<'_> {
7986 fn span(&self) -> ::treesitter_types::Span {
7987 self.span
7988 }
7989}
7990#[derive(Debug, Clone, PartialEq, Eq)]
7991pub struct Wildcard<'tree> {
7992 pub span: ::treesitter_types::Span,
7993 pub children: ::std::vec::Vec<WildcardChildren<'tree>>,
7994}
7995impl<'tree> ::treesitter_types::FromNode<'tree> for Wildcard<'tree> {
7996 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7997 fn from_node(
7998 node: ::tree_sitter::Node<'tree>,
7999 src: &'tree [u8],
8000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8001 debug_assert_eq!(node.kind(), "wildcard");
8002 Ok(Self {
8003 span: ::treesitter_types::Span::from(node),
8004 children: {
8005 #[allow(clippy::suspicious_else_formatting)]
8006 let non_field_children = {
8007 let mut cursor = node.walk();
8008 let mut result = ::std::vec::Vec::new();
8009 if cursor.goto_first_child() {
8010 loop {
8011 if cursor.field_name().is_none()
8012 && cursor.node().is_named()
8013 && !cursor.node().is_extra()
8014 {
8015 result.push(cursor.node());
8016 }
8017 if !cursor.goto_next_sibling() {
8018 break;
8019 }
8020 }
8021 }
8022 result
8023 };
8024 let mut items = ::std::vec::Vec::new();
8025 for child in non_field_children {
8026 items.push(
8027 <WildcardChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8028 );
8029 }
8030 items
8031 },
8032 })
8033 }
8034}
8035impl ::treesitter_types::Spanned for Wildcard<'_> {
8036 fn span(&self) -> ::treesitter_types::Span {
8037 self.span
8038 }
8039}
8040#[derive(Debug, Clone, PartialEq, Eq)]
8041pub struct YieldStatement<'tree> {
8042 pub span: ::treesitter_types::Span,
8043 pub children: Expression<'tree>,
8044}
8045impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
8046 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8047 fn from_node(
8048 node: ::tree_sitter::Node<'tree>,
8049 src: &'tree [u8],
8050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8051 debug_assert_eq!(node.kind(), "yield_statement");
8052 Ok(Self {
8053 span: ::treesitter_types::Span::from(node),
8054 children: {
8055 #[allow(clippy::suspicious_else_formatting)]
8056 let non_field_children = {
8057 let mut cursor = node.walk();
8058 let mut result = ::std::vec::Vec::new();
8059 if cursor.goto_first_child() {
8060 loop {
8061 if cursor.field_name().is_none()
8062 && cursor.node().is_named()
8063 && !cursor.node().is_extra()
8064 {
8065 result.push(cursor.node());
8066 }
8067 if !cursor.goto_next_sibling() {
8068 break;
8069 }
8070 }
8071 }
8072 result
8073 };
8074 let child = if let Some(&c) = non_field_children.first() {
8075 c
8076 } else {
8077 let mut fallback_cursor = node.walk();
8078 let mut fallback_child = None;
8079 if fallback_cursor.goto_first_child() {
8080 loop {
8081 if fallback_cursor.field_name().is_none()
8082 && !fallback_cursor.node().is_extra()
8083 {
8084 let candidate = fallback_cursor.node();
8085 #[allow(clippy::needless_question_mark)]
8086 if (|| -> ::core::result::Result<
8087 _,
8088 ::treesitter_types::ParseError,
8089 > {
8090 let child = candidate;
8091 Ok(
8092 <Expression as ::treesitter_types::FromNode>::from_node(
8093 child,
8094 src,
8095 )?,
8096 )
8097 })()
8098 .is_ok()
8099 {
8100 fallback_child = Some(candidate);
8101 break;
8102 }
8103 }
8104 if !fallback_cursor.goto_next_sibling() {
8105 break;
8106 }
8107 }
8108 }
8109 if fallback_child.is_none() {
8110 let mut cursor2 = node.walk();
8111 if cursor2.goto_first_child() {
8112 loop {
8113 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8114 let candidate = cursor2.node();
8115 #[allow(clippy::needless_question_mark)]
8116 if (|| -> ::core::result::Result<
8117 _,
8118 ::treesitter_types::ParseError,
8119 > {
8120 let child = candidate;
8121 Ok(
8122 <Expression as ::treesitter_types::FromNode>::from_node(
8123 child,
8124 src,
8125 )?,
8126 )
8127 })()
8128 .is_ok()
8129 {
8130 fallback_child = Some(candidate);
8131 break;
8132 }
8133 }
8134 if !cursor2.goto_next_sibling() {
8135 break;
8136 }
8137 }
8138 }
8139 }
8140 fallback_child.ok_or_else(|| {
8141 ::treesitter_types::ParseError::missing_field("children", node)
8142 })?
8143 };
8144 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8145 },
8146 })
8147 }
8148}
8149impl ::treesitter_types::Spanned for YieldStatement<'_> {
8150 fn span(&self) -> ::treesitter_types::Span {
8151 self.span
8152 }
8153}
8154#[derive(Debug, Clone, PartialEq, Eq)]
8155pub struct BinaryIntegerLiteral<'tree> {
8156 pub span: ::treesitter_types::Span,
8157 text: &'tree str,
8158}
8159impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryIntegerLiteral<'tree> {
8160 fn from_node(
8161 node: ::tree_sitter::Node<'tree>,
8162 src: &'tree [u8],
8163 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8164 debug_assert_eq!(node.kind(), "binary_integer_literal");
8165 Ok(Self {
8166 span: ::treesitter_types::Span::from(node),
8167 text: node.utf8_text(src)?,
8168 })
8169 }
8170}
8171impl<'tree> ::treesitter_types::LeafNode<'tree> for BinaryIntegerLiteral<'tree> {
8172 fn text(&self) -> &'tree str {
8173 self.text
8174 }
8175}
8176impl ::treesitter_types::Spanned for BinaryIntegerLiteral<'_> {
8177 fn span(&self) -> ::treesitter_types::Span {
8178 self.span
8179 }
8180}
8181#[derive(Debug, Clone, PartialEq, Eq)]
8182pub struct BlockComment<'tree> {
8183 pub span: ::treesitter_types::Span,
8184 text: &'tree str,
8185}
8186impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
8187 fn from_node(
8188 node: ::tree_sitter::Node<'tree>,
8189 src: &'tree [u8],
8190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8191 debug_assert_eq!(node.kind(), "block_comment");
8192 Ok(Self {
8193 span: ::treesitter_types::Span::from(node),
8194 text: node.utf8_text(src)?,
8195 })
8196 }
8197}
8198impl<'tree> ::treesitter_types::LeafNode<'tree> for BlockComment<'tree> {
8199 fn text(&self) -> &'tree str {
8200 self.text
8201 }
8202}
8203impl ::treesitter_types::Spanned for BlockComment<'_> {
8204 fn span(&self) -> ::treesitter_types::Span {
8205 self.span
8206 }
8207}
8208#[derive(Debug, Clone, PartialEq, Eq)]
8209pub struct BooleanType<'tree> {
8210 pub span: ::treesitter_types::Span,
8211 text: &'tree str,
8212}
8213impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanType<'tree> {
8214 fn from_node(
8215 node: ::tree_sitter::Node<'tree>,
8216 src: &'tree [u8],
8217 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8218 debug_assert_eq!(node.kind(), "boolean_type");
8219 Ok(Self {
8220 span: ::treesitter_types::Span::from(node),
8221 text: node.utf8_text(src)?,
8222 })
8223 }
8224}
8225impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanType<'tree> {
8226 fn text(&self) -> &'tree str {
8227 self.text
8228 }
8229}
8230impl ::treesitter_types::Spanned for BooleanType<'_> {
8231 fn span(&self) -> ::treesitter_types::Span {
8232 self.span
8233 }
8234}
8235#[derive(Debug, Clone, PartialEq, Eq)]
8236pub struct CharacterLiteral<'tree> {
8237 pub span: ::treesitter_types::Span,
8238 text: &'tree str,
8239}
8240impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
8241 fn from_node(
8242 node: ::tree_sitter::Node<'tree>,
8243 src: &'tree [u8],
8244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8245 debug_assert_eq!(node.kind(), "character_literal");
8246 Ok(Self {
8247 span: ::treesitter_types::Span::from(node),
8248 text: node.utf8_text(src)?,
8249 })
8250 }
8251}
8252impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteral<'tree> {
8253 fn text(&self) -> &'tree str {
8254 self.text
8255 }
8256}
8257impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
8258 fn span(&self) -> ::treesitter_types::Span {
8259 self.span
8260 }
8261}
8262#[derive(Debug, Clone, PartialEq, Eq)]
8263pub struct DecimalFloatingPointLiteral<'tree> {
8264 pub span: ::treesitter_types::Span,
8265 text: &'tree str,
8266}
8267impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalFloatingPointLiteral<'tree> {
8268 fn from_node(
8269 node: ::tree_sitter::Node<'tree>,
8270 src: &'tree [u8],
8271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8272 debug_assert_eq!(node.kind(), "decimal_floating_point_literal");
8273 Ok(Self {
8274 span: ::treesitter_types::Span::from(node),
8275 text: node.utf8_text(src)?,
8276 })
8277 }
8278}
8279impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalFloatingPointLiteral<'tree> {
8280 fn text(&self) -> &'tree str {
8281 self.text
8282 }
8283}
8284impl ::treesitter_types::Spanned for DecimalFloatingPointLiteral<'_> {
8285 fn span(&self) -> ::treesitter_types::Span {
8286 self.span
8287 }
8288}
8289#[derive(Debug, Clone, PartialEq, Eq)]
8290pub struct DecimalIntegerLiteral<'tree> {
8291 pub span: ::treesitter_types::Span,
8292 text: &'tree str,
8293}
8294impl<'tree> ::treesitter_types::FromNode<'tree> for DecimalIntegerLiteral<'tree> {
8295 fn from_node(
8296 node: ::tree_sitter::Node<'tree>,
8297 src: &'tree [u8],
8298 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8299 debug_assert_eq!(node.kind(), "decimal_integer_literal");
8300 Ok(Self {
8301 span: ::treesitter_types::Span::from(node),
8302 text: node.utf8_text(src)?,
8303 })
8304 }
8305}
8306impl<'tree> ::treesitter_types::LeafNode<'tree> for DecimalIntegerLiteral<'tree> {
8307 fn text(&self) -> &'tree str {
8308 self.text
8309 }
8310}
8311impl ::treesitter_types::Spanned for DecimalIntegerLiteral<'_> {
8312 fn span(&self) -> ::treesitter_types::Span {
8313 self.span
8314 }
8315}
8316#[derive(Debug, Clone, PartialEq, Eq)]
8317pub struct EscapeSequence<'tree> {
8318 pub span: ::treesitter_types::Span,
8319 text: &'tree str,
8320}
8321impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
8322 fn from_node(
8323 node: ::tree_sitter::Node<'tree>,
8324 src: &'tree [u8],
8325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8326 debug_assert_eq!(node.kind(), "escape_sequence");
8327 Ok(Self {
8328 span: ::treesitter_types::Span::from(node),
8329 text: node.utf8_text(src)?,
8330 })
8331 }
8332}
8333impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
8334 fn text(&self) -> &'tree str {
8335 self.text
8336 }
8337}
8338impl ::treesitter_types::Spanned for EscapeSequence<'_> {
8339 fn span(&self) -> ::treesitter_types::Span {
8340 self.span
8341 }
8342}
8343#[derive(Debug, Clone, PartialEq, Eq)]
8344pub struct False<'tree> {
8345 pub span: ::treesitter_types::Span,
8346 text: &'tree str,
8347}
8348impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
8349 fn from_node(
8350 node: ::tree_sitter::Node<'tree>,
8351 src: &'tree [u8],
8352 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8353 debug_assert_eq!(node.kind(), "false");
8354 Ok(Self {
8355 span: ::treesitter_types::Span::from(node),
8356 text: node.utf8_text(src)?,
8357 })
8358 }
8359}
8360impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
8361 fn text(&self) -> &'tree str {
8362 self.text
8363 }
8364}
8365impl ::treesitter_types::Spanned for False<'_> {
8366 fn span(&self) -> ::treesitter_types::Span {
8367 self.span
8368 }
8369}
8370#[derive(Debug, Clone, PartialEq, Eq)]
8371pub struct HexFloatingPointLiteral<'tree> {
8372 pub span: ::treesitter_types::Span,
8373 text: &'tree str,
8374}
8375impl<'tree> ::treesitter_types::FromNode<'tree> for HexFloatingPointLiteral<'tree> {
8376 fn from_node(
8377 node: ::tree_sitter::Node<'tree>,
8378 src: &'tree [u8],
8379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8380 debug_assert_eq!(node.kind(), "hex_floating_point_literal");
8381 Ok(Self {
8382 span: ::treesitter_types::Span::from(node),
8383 text: node.utf8_text(src)?,
8384 })
8385 }
8386}
8387impl<'tree> ::treesitter_types::LeafNode<'tree> for HexFloatingPointLiteral<'tree> {
8388 fn text(&self) -> &'tree str {
8389 self.text
8390 }
8391}
8392impl ::treesitter_types::Spanned for HexFloatingPointLiteral<'_> {
8393 fn span(&self) -> ::treesitter_types::Span {
8394 self.span
8395 }
8396}
8397#[derive(Debug, Clone, PartialEq, Eq)]
8398pub struct HexIntegerLiteral<'tree> {
8399 pub span: ::treesitter_types::Span,
8400 text: &'tree str,
8401}
8402impl<'tree> ::treesitter_types::FromNode<'tree> for HexIntegerLiteral<'tree> {
8403 fn from_node(
8404 node: ::tree_sitter::Node<'tree>,
8405 src: &'tree [u8],
8406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8407 debug_assert_eq!(node.kind(), "hex_integer_literal");
8408 Ok(Self {
8409 span: ::treesitter_types::Span::from(node),
8410 text: node.utf8_text(src)?,
8411 })
8412 }
8413}
8414impl<'tree> ::treesitter_types::LeafNode<'tree> for HexIntegerLiteral<'tree> {
8415 fn text(&self) -> &'tree str {
8416 self.text
8417 }
8418}
8419impl ::treesitter_types::Spanned for HexIntegerLiteral<'_> {
8420 fn span(&self) -> ::treesitter_types::Span {
8421 self.span
8422 }
8423}
8424#[derive(Debug, Clone, PartialEq, Eq)]
8425pub struct Identifier<'tree> {
8426 pub span: ::treesitter_types::Span,
8427 text: &'tree str,
8428}
8429impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
8430 fn from_node(
8431 node: ::tree_sitter::Node<'tree>,
8432 src: &'tree [u8],
8433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8434 debug_assert_eq!(node.kind(), "identifier");
8435 Ok(Self {
8436 span: ::treesitter_types::Span::from(node),
8437 text: node.utf8_text(src)?,
8438 })
8439 }
8440}
8441impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
8442 fn text(&self) -> &'tree str {
8443 self.text
8444 }
8445}
8446impl ::treesitter_types::Spanned for Identifier<'_> {
8447 fn span(&self) -> ::treesitter_types::Span {
8448 self.span
8449 }
8450}
8451#[derive(Debug, Clone, PartialEq, Eq)]
8452pub struct LineComment<'tree> {
8453 pub span: ::treesitter_types::Span,
8454 text: &'tree str,
8455}
8456impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
8457 fn from_node(
8458 node: ::tree_sitter::Node<'tree>,
8459 src: &'tree [u8],
8460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8461 debug_assert_eq!(node.kind(), "line_comment");
8462 Ok(Self {
8463 span: ::treesitter_types::Span::from(node),
8464 text: node.utf8_text(src)?,
8465 })
8466 }
8467}
8468impl<'tree> ::treesitter_types::LeafNode<'tree> for LineComment<'tree> {
8469 fn text(&self) -> &'tree str {
8470 self.text
8471 }
8472}
8473impl ::treesitter_types::Spanned for LineComment<'_> {
8474 fn span(&self) -> ::treesitter_types::Span {
8475 self.span
8476 }
8477}
8478#[derive(Debug, Clone, PartialEq, Eq)]
8479pub struct NullLiteral<'tree> {
8480 pub span: ::treesitter_types::Span,
8481 text: &'tree str,
8482}
8483impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
8484 fn from_node(
8485 node: ::tree_sitter::Node<'tree>,
8486 src: &'tree [u8],
8487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8488 debug_assert_eq!(node.kind(), "null_literal");
8489 Ok(Self {
8490 span: ::treesitter_types::Span::from(node),
8491 text: node.utf8_text(src)?,
8492 })
8493 }
8494}
8495impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
8496 fn text(&self) -> &'tree str {
8497 self.text
8498 }
8499}
8500impl ::treesitter_types::Spanned for NullLiteral<'_> {
8501 fn span(&self) -> ::treesitter_types::Span {
8502 self.span
8503 }
8504}
8505#[derive(Debug, Clone, PartialEq, Eq)]
8506pub struct OctalIntegerLiteral<'tree> {
8507 pub span: ::treesitter_types::Span,
8508 text: &'tree str,
8509}
8510impl<'tree> ::treesitter_types::FromNode<'tree> for OctalIntegerLiteral<'tree> {
8511 fn from_node(
8512 node: ::tree_sitter::Node<'tree>,
8513 src: &'tree [u8],
8514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8515 debug_assert_eq!(node.kind(), "octal_integer_literal");
8516 Ok(Self {
8517 span: ::treesitter_types::Span::from(node),
8518 text: node.utf8_text(src)?,
8519 })
8520 }
8521}
8522impl<'tree> ::treesitter_types::LeafNode<'tree> for OctalIntegerLiteral<'tree> {
8523 fn text(&self) -> &'tree str {
8524 self.text
8525 }
8526}
8527impl ::treesitter_types::Spanned for OctalIntegerLiteral<'_> {
8528 fn span(&self) -> ::treesitter_types::Span {
8529 self.span
8530 }
8531}
8532#[derive(Debug, Clone, PartialEq, Eq)]
8533pub struct StringFragment<'tree> {
8534 pub span: ::treesitter_types::Span,
8535 text: &'tree str,
8536}
8537impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
8538 fn from_node(
8539 node: ::tree_sitter::Node<'tree>,
8540 src: &'tree [u8],
8541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8542 debug_assert_eq!(node.kind(), "string_fragment");
8543 Ok(Self {
8544 span: ::treesitter_types::Span::from(node),
8545 text: node.utf8_text(src)?,
8546 })
8547 }
8548}
8549impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
8550 fn text(&self) -> &'tree str {
8551 self.text
8552 }
8553}
8554impl ::treesitter_types::Spanned for StringFragment<'_> {
8555 fn span(&self) -> ::treesitter_types::Span {
8556 self.span
8557 }
8558}
8559#[derive(Debug, Clone, PartialEq, Eq)]
8560pub struct Super<'tree> {
8561 pub span: ::treesitter_types::Span,
8562 text: &'tree str,
8563}
8564impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
8565 fn from_node(
8566 node: ::tree_sitter::Node<'tree>,
8567 src: &'tree [u8],
8568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8569 debug_assert_eq!(node.kind(), "super");
8570 Ok(Self {
8571 span: ::treesitter_types::Span::from(node),
8572 text: node.utf8_text(src)?,
8573 })
8574 }
8575}
8576impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
8577 fn text(&self) -> &'tree str {
8578 self.text
8579 }
8580}
8581impl ::treesitter_types::Spanned for Super<'_> {
8582 fn span(&self) -> ::treesitter_types::Span {
8583 self.span
8584 }
8585}
8586#[derive(Debug, Clone, PartialEq, Eq)]
8587pub struct This<'tree> {
8588 pub span: ::treesitter_types::Span,
8589 text: &'tree str,
8590}
8591impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
8592 fn from_node(
8593 node: ::tree_sitter::Node<'tree>,
8594 src: &'tree [u8],
8595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8596 debug_assert_eq!(node.kind(), "this");
8597 Ok(Self {
8598 span: ::treesitter_types::Span::from(node),
8599 text: node.utf8_text(src)?,
8600 })
8601 }
8602}
8603impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
8604 fn text(&self) -> &'tree str {
8605 self.text
8606 }
8607}
8608impl ::treesitter_types::Spanned for This<'_> {
8609 fn span(&self) -> ::treesitter_types::Span {
8610 self.span
8611 }
8612}
8613#[derive(Debug, Clone, PartialEq, Eq)]
8614pub struct True<'tree> {
8615 pub span: ::treesitter_types::Span,
8616 text: &'tree str,
8617}
8618impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
8619 fn from_node(
8620 node: ::tree_sitter::Node<'tree>,
8621 src: &'tree [u8],
8622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8623 debug_assert_eq!(node.kind(), "true");
8624 Ok(Self {
8625 span: ::treesitter_types::Span::from(node),
8626 text: node.utf8_text(src)?,
8627 })
8628 }
8629}
8630impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
8631 fn text(&self) -> &'tree str {
8632 self.text
8633 }
8634}
8635impl ::treesitter_types::Spanned for True<'_> {
8636 fn span(&self) -> ::treesitter_types::Span {
8637 self.span
8638 }
8639}
8640#[derive(Debug, Clone, PartialEq, Eq)]
8641pub struct TypeIdentifier<'tree> {
8642 pub span: ::treesitter_types::Span,
8643 text: &'tree str,
8644}
8645impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
8646 fn from_node(
8647 node: ::tree_sitter::Node<'tree>,
8648 src: &'tree [u8],
8649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8650 debug_assert_eq!(node.kind(), "type_identifier");
8651 Ok(Self {
8652 span: ::treesitter_types::Span::from(node),
8653 text: node.utf8_text(src)?,
8654 })
8655 }
8656}
8657impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
8658 fn text(&self) -> &'tree str {
8659 self.text
8660 }
8661}
8662impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
8663 fn span(&self) -> ::treesitter_types::Span {
8664 self.span
8665 }
8666}
8667#[derive(Debug, Clone, PartialEq, Eq)]
8668pub struct UnderscorePattern<'tree> {
8669 pub span: ::treesitter_types::Span,
8670 text: &'tree str,
8671}
8672impl<'tree> ::treesitter_types::FromNode<'tree> for UnderscorePattern<'tree> {
8673 fn from_node(
8674 node: ::tree_sitter::Node<'tree>,
8675 src: &'tree [u8],
8676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8677 debug_assert_eq!(node.kind(), "underscore_pattern");
8678 Ok(Self {
8679 span: ::treesitter_types::Span::from(node),
8680 text: node.utf8_text(src)?,
8681 })
8682 }
8683}
8684impl<'tree> ::treesitter_types::LeafNode<'tree> for UnderscorePattern<'tree> {
8685 fn text(&self) -> &'tree str {
8686 self.text
8687 }
8688}
8689impl ::treesitter_types::Spanned for UnderscorePattern<'_> {
8690 fn span(&self) -> ::treesitter_types::Span {
8691 self.span
8692 }
8693}
8694#[derive(Debug, Clone, PartialEq, Eq)]
8695pub struct VoidType<'tree> {
8696 pub span: ::treesitter_types::Span,
8697 text: &'tree str,
8698}
8699impl<'tree> ::treesitter_types::FromNode<'tree> for VoidType<'tree> {
8700 fn from_node(
8701 node: ::tree_sitter::Node<'tree>,
8702 src: &'tree [u8],
8703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8704 debug_assert_eq!(node.kind(), "void_type");
8705 Ok(Self {
8706 span: ::treesitter_types::Span::from(node),
8707 text: node.utf8_text(src)?,
8708 })
8709 }
8710}
8711impl<'tree> ::treesitter_types::LeafNode<'tree> for VoidType<'tree> {
8712 fn text(&self) -> &'tree str {
8713 self.text
8714 }
8715}
8716impl ::treesitter_types::Spanned for VoidType<'_> {
8717 fn span(&self) -> ::treesitter_types::Span {
8718 self.span
8719 }
8720}
8721#[derive(Debug, Clone, PartialEq, Eq)]
8722pub enum AnnotatedTypeChildren<'tree> {
8723 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
8724 Annotation(::std::boxed::Box<Annotation<'tree>>),
8725 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8726}
8727impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotatedTypeChildren<'tree> {
8728 #[allow(clippy::collapsible_else_if)]
8729 fn from_node(
8730 node: ::tree_sitter::Node<'tree>,
8731 src: &'tree [u8],
8732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8733 match node.kind() {
8734 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8735 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8736 ))),
8737 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8738 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8739 ))),
8740 _other => {
8741 if let Ok(v) =
8742 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
8743 {
8744 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
8745 } else {
8746 Err(::treesitter_types::ParseError::unexpected_kind(
8747 _other, node,
8748 ))
8749 }
8750 }
8751 }
8752 }
8753}
8754impl ::treesitter_types::Spanned for AnnotatedTypeChildren<'_> {
8755 fn span(&self) -> ::treesitter_types::Span {
8756 match self {
8757 Self::UnannotatedType(inner) => inner.span(),
8758 Self::Annotation(inner) => inner.span(),
8759 Self::MarkerAnnotation(inner) => inner.span(),
8760 }
8761 }
8762}
8763#[derive(Debug, Clone, PartialEq, Eq)]
8764pub enum AnnotationName<'tree> {
8765 Identifier(::std::boxed::Box<Identifier<'tree>>),
8766 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
8767}
8768impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationName<'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 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8776 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8777 ))),
8778 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
8779 <ScopedIdentifier 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 AnnotationName<'_> {
8786 fn span(&self) -> ::treesitter_types::Span {
8787 match self {
8788 Self::Identifier(inner) => inner.span(),
8789 Self::ScopedIdentifier(inner) => inner.span(),
8790 }
8791 }
8792}
8793#[derive(Debug, Clone, PartialEq, Eq)]
8794pub enum AnnotationArgumentListChildren<'tree> {
8795 Annotation(::std::boxed::Box<Annotation<'tree>>),
8796 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
8797 ElementValuePair(::std::boxed::Box<ElementValuePair<'tree>>),
8798 Expression(::std::boxed::Box<Expression<'tree>>),
8799 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8800}
8801impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationArgumentListChildren<'tree> {
8802 #[allow(clippy::collapsible_else_if)]
8803 fn from_node(
8804 node: ::tree_sitter::Node<'tree>,
8805 src: &'tree [u8],
8806 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8807 match node.kind() {
8808 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8809 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8810 ))),
8811 "element_value_array_initializer" => {
8812 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
8813 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
8814 node, src,
8815 )?,
8816 )))
8817 }
8818 "element_value_pair" => Ok(Self::ElementValuePair(::std::boxed::Box::new(
8819 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)?,
8820 ))),
8821 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8822 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8823 ))),
8824 _other => {
8825 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8826 Ok(Self::Expression(::std::boxed::Box::new(v)))
8827 } else {
8828 Err(::treesitter_types::ParseError::unexpected_kind(
8829 _other, node,
8830 ))
8831 }
8832 }
8833 }
8834 }
8835}
8836impl ::treesitter_types::Spanned for AnnotationArgumentListChildren<'_> {
8837 fn span(&self) -> ::treesitter_types::Span {
8838 match self {
8839 Self::Annotation(inner) => inner.span(),
8840 Self::ElementValueArrayInitializer(inner) => inner.span(),
8841 Self::ElementValuePair(inner) => inner.span(),
8842 Self::Expression(inner) => inner.span(),
8843 Self::MarkerAnnotation(inner) => inner.span(),
8844 }
8845 }
8846}
8847#[derive(Debug, Clone, PartialEq, Eq)]
8848pub enum AnnotationTypeBodyChildren<'tree> {
8849 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
8850 AnnotationTypeElementDeclaration(::std::boxed::Box<AnnotationTypeElementDeclaration<'tree>>),
8851 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
8852 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
8853 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
8854 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
8855}
8856impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeBodyChildren<'tree> {
8857 #[allow(clippy::collapsible_else_if)]
8858 fn from_node(
8859 node: ::tree_sitter::Node<'tree>,
8860 src: &'tree [u8],
8861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8862 match node.kind() {
8863 "annotation_type_declaration" => {
8864 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
8865 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
8866 node, src,
8867 )?,
8868 )))
8869 }
8870 "annotation_type_element_declaration" => Ok(Self::AnnotationTypeElementDeclaration(
8871 ::std::boxed::Box::new(
8872 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
8873 node, src,
8874 )?,
8875 ),
8876 )),
8877 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
8878 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8879 ))),
8880 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
8881 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8882 ))),
8883 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
8884 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8885 ))),
8886 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
8887 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
8888 ))),
8889 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8890 }
8891 }
8892}
8893impl ::treesitter_types::Spanned for AnnotationTypeBodyChildren<'_> {
8894 fn span(&self) -> ::treesitter_types::Span {
8895 match self {
8896 Self::AnnotationTypeDeclaration(inner) => inner.span(),
8897 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
8898 Self::ClassDeclaration(inner) => inner.span(),
8899 Self::ConstantDeclaration(inner) => inner.span(),
8900 Self::EnumDeclaration(inner) => inner.span(),
8901 Self::InterfaceDeclaration(inner) => inner.span(),
8902 }
8903 }
8904}
8905#[derive(Debug, Clone, PartialEq, Eq)]
8906pub enum AnnotationTypeElementDeclarationValue<'tree> {
8907 Annotation(::std::boxed::Box<Annotation<'tree>>),
8908 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
8909 Expression(::std::boxed::Box<Expression<'tree>>),
8910 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8911}
8912impl<'tree> ::treesitter_types::FromNode<'tree> for AnnotationTypeElementDeclarationValue<'tree> {
8913 #[allow(clippy::collapsible_else_if)]
8914 fn from_node(
8915 node: ::tree_sitter::Node<'tree>,
8916 src: &'tree [u8],
8917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8918 match node.kind() {
8919 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8920 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8921 ))),
8922 "element_value_array_initializer" => {
8923 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
8924 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
8925 node, src,
8926 )?,
8927 )))
8928 }
8929 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
8930 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8931 ))),
8932 _other => {
8933 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8934 Ok(Self::Expression(::std::boxed::Box::new(v)))
8935 } else {
8936 Err(::treesitter_types::ParseError::unexpected_kind(
8937 _other, node,
8938 ))
8939 }
8940 }
8941 }
8942 }
8943}
8944impl ::treesitter_types::Spanned for AnnotationTypeElementDeclarationValue<'_> {
8945 fn span(&self) -> ::treesitter_types::Span {
8946 match self {
8947 Self::Annotation(inner) => inner.span(),
8948 Self::ElementValueArrayInitializer(inner) => inner.span(),
8949 Self::Expression(inner) => inner.span(),
8950 Self::MarkerAnnotation(inner) => inner.span(),
8951 }
8952 }
8953}
8954#[derive(Debug, Clone, PartialEq, Eq)]
8955pub enum ArrayCreationExpressionDimensions<'tree> {
8956 Dimensions(::std::boxed::Box<Dimensions<'tree>>),
8957 DimensionsExpr(::std::boxed::Box<DimensionsExpr<'tree>>),
8958}
8959impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionDimensions<'tree> {
8960 #[allow(clippy::collapsible_else_if)]
8961 fn from_node(
8962 node: ::tree_sitter::Node<'tree>,
8963 src: &'tree [u8],
8964 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8965 match node.kind() {
8966 "dimensions" => Ok(Self::Dimensions(::std::boxed::Box::new(
8967 <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)?,
8968 ))),
8969 "dimensions_expr" => Ok(Self::DimensionsExpr(::std::boxed::Box::new(
8970 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)?,
8971 ))),
8972 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8973 }
8974 }
8975}
8976impl ::treesitter_types::Spanned for ArrayCreationExpressionDimensions<'_> {
8977 fn span(&self) -> ::treesitter_types::Span {
8978 match self {
8979 Self::Dimensions(inner) => inner.span(),
8980 Self::DimensionsExpr(inner) => inner.span(),
8981 }
8982 }
8983}
8984#[derive(Debug, Clone, PartialEq, Eq)]
8985pub enum ArrayCreationExpressionChildren<'tree> {
8986 Annotation(::std::boxed::Box<Annotation<'tree>>),
8987 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
8988}
8989impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpressionChildren<'tree> {
8990 #[allow(clippy::collapsible_else_if)]
8991 fn from_node(
8992 node: ::tree_sitter::Node<'tree>,
8993 src: &'tree [u8],
8994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8995 match node.kind() {
8996 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
8997 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
8998 ))),
8999 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9000 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9001 ))),
9002 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9003 }
9004 }
9005}
9006impl ::treesitter_types::Spanned for ArrayCreationExpressionChildren<'_> {
9007 fn span(&self) -> ::treesitter_types::Span {
9008 match self {
9009 Self::Annotation(inner) => inner.span(),
9010 Self::MarkerAnnotation(inner) => inner.span(),
9011 }
9012 }
9013}
9014#[derive(Debug, Clone, PartialEq, Eq)]
9015pub enum ArrayInitializerChildren<'tree> {
9016 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
9017 Expression(::std::boxed::Box<Expression<'tree>>),
9018}
9019impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayInitializerChildren<'tree> {
9020 #[allow(clippy::collapsible_else_if)]
9021 fn from_node(
9022 node: ::tree_sitter::Node<'tree>,
9023 src: &'tree [u8],
9024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9025 match node.kind() {
9026 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
9027 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
9028 ))),
9029 _other => {
9030 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9031 Ok(Self::Expression(::std::boxed::Box::new(v)))
9032 } else {
9033 Err(::treesitter_types::ParseError::unexpected_kind(
9034 _other, node,
9035 ))
9036 }
9037 }
9038 }
9039 }
9040}
9041impl ::treesitter_types::Spanned for ArrayInitializerChildren<'_> {
9042 fn span(&self) -> ::treesitter_types::Span {
9043 match self {
9044 Self::ArrayInitializer(inner) => inner.span(),
9045 Self::Expression(inner) => inner.span(),
9046 }
9047 }
9048}
9049#[derive(Debug, Clone, PartialEq, Eq)]
9050pub enum AssignmentExpressionLeft<'tree> {
9051 ArrayAccess(::std::boxed::Box<ArrayAccess<'tree>>),
9052 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
9053 Identifier(::std::boxed::Box<Identifier<'tree>>),
9054}
9055impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
9056 #[allow(clippy::collapsible_else_if)]
9057 fn from_node(
9058 node: ::tree_sitter::Node<'tree>,
9059 src: &'tree [u8],
9060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9061 match node.kind() {
9062 "array_access" => Ok(Self::ArrayAccess(::std::boxed::Box::new(
9063 <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
9064 ))),
9065 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
9066 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
9067 ))),
9068 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9069 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9070 ))),
9071 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9072 }
9073 }
9074}
9075impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
9076 fn span(&self) -> ::treesitter_types::Span {
9077 match self {
9078 Self::ArrayAccess(inner) => inner.span(),
9079 Self::FieldAccess(inner) => inner.span(),
9080 Self::Identifier(inner) => inner.span(),
9081 }
9082 }
9083}
9084#[derive(Debug, Clone, PartialEq, Eq)]
9085pub enum AssignmentExpressionOperator {
9086 PercentEq(::treesitter_types::Span),
9087 AmpEq(::treesitter_types::Span),
9088 StarEq(::treesitter_types::Span),
9089 PlusEq(::treesitter_types::Span),
9090 MinusEq(::treesitter_types::Span),
9091 SlashEq(::treesitter_types::Span),
9092 ShlEq(::treesitter_types::Span),
9093 Eq(::treesitter_types::Span),
9094 ShrEq(::treesitter_types::Span),
9095 GtGtGtEq(::treesitter_types::Span),
9096 CaretEq(::treesitter_types::Span),
9097 PipeEq(::treesitter_types::Span),
9098}
9099impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
9100 #[allow(clippy::collapsible_else_if)]
9101 fn from_node(
9102 node: ::tree_sitter::Node<'tree>,
9103 _src: &'tree [u8],
9104 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9105 match node.kind() {
9106 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
9107 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
9108 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
9109 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
9110 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
9111 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
9112 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
9113 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
9114 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
9115 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
9116 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
9117 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
9118 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9119 }
9120 }
9121}
9122impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
9123 fn span(&self) -> ::treesitter_types::Span {
9124 match self {
9125 Self::PercentEq(span) => *span,
9126 Self::AmpEq(span) => *span,
9127 Self::StarEq(span) => *span,
9128 Self::PlusEq(span) => *span,
9129 Self::MinusEq(span) => *span,
9130 Self::SlashEq(span) => *span,
9131 Self::ShlEq(span) => *span,
9132 Self::Eq(span) => *span,
9133 Self::ShrEq(span) => *span,
9134 Self::GtGtGtEq(span) => *span,
9135 Self::CaretEq(span) => *span,
9136 Self::PipeEq(span) => *span,
9137 }
9138 }
9139}
9140#[derive(Debug, Clone, PartialEq, Eq)]
9141pub enum BinaryExpressionOperator {
9142 NotEq(::treesitter_types::Span),
9143 Percent(::treesitter_types::Span),
9144 Amp(::treesitter_types::Span),
9145 AmpAmp(::treesitter_types::Span),
9146 Star(::treesitter_types::Span),
9147 Plus(::treesitter_types::Span),
9148 Minus(::treesitter_types::Span),
9149 Slash(::treesitter_types::Span),
9150 Lt(::treesitter_types::Span),
9151 Shl(::treesitter_types::Span),
9152 LtEq(::treesitter_types::Span),
9153 EqEq(::treesitter_types::Span),
9154 Gt(::treesitter_types::Span),
9155 GtEq(::treesitter_types::Span),
9156 Shr(::treesitter_types::Span),
9157 GtGtGt(::treesitter_types::Span),
9158 Caret(::treesitter_types::Span),
9159 Pipe(::treesitter_types::Span),
9160 PipePipe(::treesitter_types::Span),
9161}
9162impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
9163 #[allow(clippy::collapsible_else_if)]
9164 fn from_node(
9165 node: ::tree_sitter::Node<'tree>,
9166 _src: &'tree [u8],
9167 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9168 match node.kind() {
9169 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
9170 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
9171 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
9172 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
9173 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
9174 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9175 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9176 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
9177 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
9178 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
9179 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
9180 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
9181 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
9182 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
9183 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
9184 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
9185 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
9186 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
9187 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
9188 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9189 }
9190 }
9191}
9192impl ::treesitter_types::Spanned for BinaryExpressionOperator {
9193 fn span(&self) -> ::treesitter_types::Span {
9194 match self {
9195 Self::NotEq(span) => *span,
9196 Self::Percent(span) => *span,
9197 Self::Amp(span) => *span,
9198 Self::AmpAmp(span) => *span,
9199 Self::Star(span) => *span,
9200 Self::Plus(span) => *span,
9201 Self::Minus(span) => *span,
9202 Self::Slash(span) => *span,
9203 Self::Lt(span) => *span,
9204 Self::Shl(span) => *span,
9205 Self::LtEq(span) => *span,
9206 Self::EqEq(span) => *span,
9207 Self::Gt(span) => *span,
9208 Self::GtEq(span) => *span,
9209 Self::Shr(span) => *span,
9210 Self::GtGtGt(span) => *span,
9211 Self::Caret(span) => *span,
9212 Self::Pipe(span) => *span,
9213 Self::PipePipe(span) => *span,
9214 }
9215 }
9216}
9217#[derive(Debug, Clone, PartialEq, Eq)]
9218pub enum CatchFormalParameterName<'tree> {
9219 Identifier(::std::boxed::Box<Identifier<'tree>>),
9220 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
9221}
9222impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterName<'tree> {
9223 #[allow(clippy::collapsible_else_if)]
9224 fn from_node(
9225 node: ::tree_sitter::Node<'tree>,
9226 src: &'tree [u8],
9227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9228 match node.kind() {
9229 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9230 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9231 ))),
9232 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
9233 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9234 ))),
9235 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9236 }
9237 }
9238}
9239impl ::treesitter_types::Spanned for CatchFormalParameterName<'_> {
9240 fn span(&self) -> ::treesitter_types::Span {
9241 match self {
9242 Self::Identifier(inner) => inner.span(),
9243 Self::UnderscorePattern(inner) => inner.span(),
9244 }
9245 }
9246}
9247#[derive(Debug, Clone, PartialEq, Eq)]
9248pub enum CatchFormalParameterChildren<'tree> {
9249 CatchType(::std::boxed::Box<CatchType<'tree>>),
9250 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9251}
9252impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFormalParameterChildren<'tree> {
9253 #[allow(clippy::collapsible_else_if)]
9254 fn from_node(
9255 node: ::tree_sitter::Node<'tree>,
9256 src: &'tree [u8],
9257 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9258 match node.kind() {
9259 "catch_type" => Ok(Self::CatchType(::std::boxed::Box::new(
9260 <CatchType as ::treesitter_types::FromNode>::from_node(node, src)?,
9261 ))),
9262 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9263 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
9264 ))),
9265 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9266 }
9267 }
9268}
9269impl ::treesitter_types::Spanned for CatchFormalParameterChildren<'_> {
9270 fn span(&self) -> ::treesitter_types::Span {
9271 match self {
9272 Self::CatchType(inner) => inner.span(),
9273 Self::Modifiers(inner) => inner.span(),
9274 }
9275 }
9276}
9277#[derive(Debug, Clone, PartialEq, Eq)]
9278pub enum ClassBodyChildren<'tree> {
9279 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
9280 Block(::std::boxed::Box<Block<'tree>>),
9281 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
9282 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
9283 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
9284 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9285 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
9286 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
9287 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
9288 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
9289 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
9290}
9291impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyChildren<'tree> {
9292 #[allow(clippy::collapsible_else_if)]
9293 fn from_node(
9294 node: ::tree_sitter::Node<'tree>,
9295 src: &'tree [u8],
9296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9297 match node.kind() {
9298 "annotation_type_declaration" => {
9299 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
9300 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
9301 node, src,
9302 )?,
9303 )))
9304 }
9305 "block" => Ok(Self::Block(::std::boxed::Box::new(
9306 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9307 ))),
9308 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
9309 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9310 ))),
9311 "compact_constructor_declaration" => {
9312 Ok(Self::CompactConstructorDeclaration(::std::boxed::Box::new(
9313 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
9314 node, src,
9315 )?,
9316 )))
9317 }
9318 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
9319 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9320 ))),
9321 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
9322 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9323 ))),
9324 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
9325 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9326 ))),
9327 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
9328 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9329 ))),
9330 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
9331 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9332 ))),
9333 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
9334 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9335 ))),
9336 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
9337 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
9338 ))),
9339 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9340 }
9341 }
9342}
9343impl ::treesitter_types::Spanned for ClassBodyChildren<'_> {
9344 fn span(&self) -> ::treesitter_types::Span {
9345 match self {
9346 Self::AnnotationTypeDeclaration(inner) => inner.span(),
9347 Self::Block(inner) => inner.span(),
9348 Self::ClassDeclaration(inner) => inner.span(),
9349 Self::CompactConstructorDeclaration(inner) => inner.span(),
9350 Self::ConstructorDeclaration(inner) => inner.span(),
9351 Self::EnumDeclaration(inner) => inner.span(),
9352 Self::FieldDeclaration(inner) => inner.span(),
9353 Self::InterfaceDeclaration(inner) => inner.span(),
9354 Self::MethodDeclaration(inner) => inner.span(),
9355 Self::RecordDeclaration(inner) => inner.span(),
9356 Self::StaticInitializer(inner) => inner.span(),
9357 }
9358 }
9359}
9360#[derive(Debug, Clone, PartialEq, Eq)]
9361pub enum ConstructorBodyChildren<'tree> {
9362 ExplicitConstructorInvocation(::std::boxed::Box<ExplicitConstructorInvocation<'tree>>),
9363 Statement(::std::boxed::Box<Statement<'tree>>),
9364}
9365impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorBodyChildren<'tree> {
9366 #[allow(clippy::collapsible_else_if)]
9367 fn from_node(
9368 node: ::tree_sitter::Node<'tree>,
9369 src: &'tree [u8],
9370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9371 match node.kind() {
9372 "explicit_constructor_invocation" => {
9373 Ok(Self::ExplicitConstructorInvocation(::std::boxed::Box::new(
9374 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
9375 node, src,
9376 )?,
9377 )))
9378 }
9379 _other => {
9380 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
9381 Ok(Self::Statement(::std::boxed::Box::new(v)))
9382 } else {
9383 Err(::treesitter_types::ParseError::unexpected_kind(
9384 _other, node,
9385 ))
9386 }
9387 }
9388 }
9389 }
9390}
9391impl ::treesitter_types::Spanned for ConstructorBodyChildren<'_> {
9392 fn span(&self) -> ::treesitter_types::Span {
9393 match self {
9394 Self::ExplicitConstructorInvocation(inner) => inner.span(),
9395 Self::Statement(inner) => inner.span(),
9396 }
9397 }
9398}
9399#[derive(Debug, Clone, PartialEq, Eq)]
9400pub enum ConstructorDeclarationChildren<'tree> {
9401 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
9402 Throws(::std::boxed::Box<Throws<'tree>>),
9403}
9404impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
9405 #[allow(clippy::collapsible_else_if)]
9406 fn from_node(
9407 node: ::tree_sitter::Node<'tree>,
9408 src: &'tree [u8],
9409 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9410 match node.kind() {
9411 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
9412 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
9413 ))),
9414 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
9415 <Throws as ::treesitter_types::FromNode>::from_node(node, src)?,
9416 ))),
9417 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9418 }
9419 }
9420}
9421impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
9422 fn span(&self) -> ::treesitter_types::Span {
9423 match self {
9424 Self::Modifiers(inner) => inner.span(),
9425 Self::Throws(inner) => inner.span(),
9426 }
9427 }
9428}
9429#[derive(Debug, Clone, PartialEq, Eq)]
9430pub enum DimensionsChildren<'tree> {
9431 Annotation(::std::boxed::Box<Annotation<'tree>>),
9432 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9433}
9434impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsChildren<'tree> {
9435 #[allow(clippy::collapsible_else_if)]
9436 fn from_node(
9437 node: ::tree_sitter::Node<'tree>,
9438 src: &'tree [u8],
9439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9440 match node.kind() {
9441 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9442 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9443 ))),
9444 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9445 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9446 ))),
9447 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9448 }
9449 }
9450}
9451impl ::treesitter_types::Spanned for DimensionsChildren<'_> {
9452 fn span(&self) -> ::treesitter_types::Span {
9453 match self {
9454 Self::Annotation(inner) => inner.span(),
9455 Self::MarkerAnnotation(inner) => inner.span(),
9456 }
9457 }
9458}
9459#[derive(Debug, Clone, PartialEq, Eq)]
9460pub enum DimensionsExprChildren<'tree> {
9461 Annotation(::std::boxed::Box<Annotation<'tree>>),
9462 Expression(::std::boxed::Box<Expression<'tree>>),
9463 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9464}
9465impl<'tree> ::treesitter_types::FromNode<'tree> for DimensionsExprChildren<'tree> {
9466 #[allow(clippy::collapsible_else_if)]
9467 fn from_node(
9468 node: ::tree_sitter::Node<'tree>,
9469 src: &'tree [u8],
9470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9471 match node.kind() {
9472 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9473 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9474 ))),
9475 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9476 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9477 ))),
9478 _other => {
9479 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9480 Ok(Self::Expression(::std::boxed::Box::new(v)))
9481 } else {
9482 Err(::treesitter_types::ParseError::unexpected_kind(
9483 _other, node,
9484 ))
9485 }
9486 }
9487 }
9488 }
9489}
9490impl ::treesitter_types::Spanned for DimensionsExprChildren<'_> {
9491 fn span(&self) -> ::treesitter_types::Span {
9492 match self {
9493 Self::Annotation(inner) => inner.span(),
9494 Self::Expression(inner) => inner.span(),
9495 Self::MarkerAnnotation(inner) => inner.span(),
9496 }
9497 }
9498}
9499#[derive(Debug, Clone, PartialEq, Eq)]
9500pub enum ElementValueArrayInitializerChildren<'tree> {
9501 Annotation(::std::boxed::Box<Annotation<'tree>>),
9502 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9503 Expression(::std::boxed::Box<Expression<'tree>>),
9504 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9505}
9506impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValueArrayInitializerChildren<'tree> {
9507 #[allow(clippy::collapsible_else_if)]
9508 fn from_node(
9509 node: ::tree_sitter::Node<'tree>,
9510 src: &'tree [u8],
9511 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9512 match node.kind() {
9513 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9514 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9515 ))),
9516 "element_value_array_initializer" => {
9517 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
9518 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9519 node, src,
9520 )?,
9521 )))
9522 }
9523 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9524 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9525 ))),
9526 _other => {
9527 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9528 Ok(Self::Expression(::std::boxed::Box::new(v)))
9529 } else {
9530 Err(::treesitter_types::ParseError::unexpected_kind(
9531 _other, node,
9532 ))
9533 }
9534 }
9535 }
9536 }
9537}
9538impl ::treesitter_types::Spanned for ElementValueArrayInitializerChildren<'_> {
9539 fn span(&self) -> ::treesitter_types::Span {
9540 match self {
9541 Self::Annotation(inner) => inner.span(),
9542 Self::ElementValueArrayInitializer(inner) => inner.span(),
9543 Self::Expression(inner) => inner.span(),
9544 Self::MarkerAnnotation(inner) => inner.span(),
9545 }
9546 }
9547}
9548#[derive(Debug, Clone, PartialEq, Eq)]
9549pub enum ElementValuePairValue<'tree> {
9550 Annotation(::std::boxed::Box<Annotation<'tree>>),
9551 ElementValueArrayInitializer(::std::boxed::Box<ElementValueArrayInitializer<'tree>>),
9552 Expression(::std::boxed::Box<Expression<'tree>>),
9553 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
9554}
9555impl<'tree> ::treesitter_types::FromNode<'tree> for ElementValuePairValue<'tree> {
9556 #[allow(clippy::collapsible_else_if)]
9557 fn from_node(
9558 node: ::tree_sitter::Node<'tree>,
9559 src: &'tree [u8],
9560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9561 match node.kind() {
9562 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
9563 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9564 ))),
9565 "element_value_array_initializer" => {
9566 Ok(Self::ElementValueArrayInitializer(::std::boxed::Box::new(
9567 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(
9568 node, src,
9569 )?,
9570 )))
9571 }
9572 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
9573 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9574 ))),
9575 _other => {
9576 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9577 Ok(Self::Expression(::std::boxed::Box::new(v)))
9578 } else {
9579 Err(::treesitter_types::ParseError::unexpected_kind(
9580 _other, node,
9581 ))
9582 }
9583 }
9584 }
9585 }
9586}
9587impl ::treesitter_types::Spanned for ElementValuePairValue<'_> {
9588 fn span(&self) -> ::treesitter_types::Span {
9589 match self {
9590 Self::Annotation(inner) => inner.span(),
9591 Self::ElementValueArrayInitializer(inner) => inner.span(),
9592 Self::Expression(inner) => inner.span(),
9593 Self::MarkerAnnotation(inner) => inner.span(),
9594 }
9595 }
9596}
9597#[derive(Debug, Clone, PartialEq, Eq)]
9598pub enum EnhancedForStatementName<'tree> {
9599 Identifier(::std::boxed::Box<Identifier<'tree>>),
9600 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
9601}
9602impl<'tree> ::treesitter_types::FromNode<'tree> for EnhancedForStatementName<'tree> {
9603 #[allow(clippy::collapsible_else_if)]
9604 fn from_node(
9605 node: ::tree_sitter::Node<'tree>,
9606 src: &'tree [u8],
9607 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9608 match node.kind() {
9609 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9610 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9611 ))),
9612 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
9613 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9614 ))),
9615 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9616 }
9617 }
9618}
9619impl ::treesitter_types::Spanned for EnhancedForStatementName<'_> {
9620 fn span(&self) -> ::treesitter_types::Span {
9621 match self {
9622 Self::Identifier(inner) => inner.span(),
9623 Self::UnderscorePattern(inner) => inner.span(),
9624 }
9625 }
9626}
9627#[derive(Debug, Clone, PartialEq, Eq)]
9628pub enum EnumBodyChildren<'tree> {
9629 EnumBodyDeclarations(::std::boxed::Box<EnumBodyDeclarations<'tree>>),
9630 EnumConstant(::std::boxed::Box<EnumConstant<'tree>>),
9631}
9632impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyChildren<'tree> {
9633 #[allow(clippy::collapsible_else_if)]
9634 fn from_node(
9635 node: ::tree_sitter::Node<'tree>,
9636 src: &'tree [u8],
9637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9638 match node.kind() {
9639 "enum_body_declarations" => Ok(Self::EnumBodyDeclarations(::std::boxed::Box::new(
9640 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)?,
9641 ))),
9642 "enum_constant" => Ok(Self::EnumConstant(::std::boxed::Box::new(
9643 <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)?,
9644 ))),
9645 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9646 }
9647 }
9648}
9649impl ::treesitter_types::Spanned for EnumBodyChildren<'_> {
9650 fn span(&self) -> ::treesitter_types::Span {
9651 match self {
9652 Self::EnumBodyDeclarations(inner) => inner.span(),
9653 Self::EnumConstant(inner) => inner.span(),
9654 }
9655 }
9656}
9657#[derive(Debug, Clone, PartialEq, Eq)]
9658pub enum EnumBodyDeclarationsChildren<'tree> {
9659 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
9660 Block(::std::boxed::Box<Block<'tree>>),
9661 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
9662 CompactConstructorDeclaration(::std::boxed::Box<CompactConstructorDeclaration<'tree>>),
9663 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
9664 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9665 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
9666 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
9667 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
9668 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
9669 StaticInitializer(::std::boxed::Box<StaticInitializer<'tree>>),
9670}
9671impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyDeclarationsChildren<'tree> {
9672 #[allow(clippy::collapsible_else_if)]
9673 fn from_node(
9674 node: ::tree_sitter::Node<'tree>,
9675 src: &'tree [u8],
9676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9677 match node.kind() {
9678 "annotation_type_declaration" => {
9679 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
9680 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
9681 node, src,
9682 )?,
9683 )))
9684 }
9685 "block" => Ok(Self::Block(::std::boxed::Box::new(
9686 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9687 ))),
9688 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
9689 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9690 ))),
9691 "compact_constructor_declaration" => {
9692 Ok(Self::CompactConstructorDeclaration(::std::boxed::Box::new(
9693 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
9694 node, src,
9695 )?,
9696 )))
9697 }
9698 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
9699 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9700 ))),
9701 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
9702 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9703 ))),
9704 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
9705 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9706 ))),
9707 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
9708 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9709 ))),
9710 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
9711 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9712 ))),
9713 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
9714 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9715 ))),
9716 "static_initializer" => Ok(Self::StaticInitializer(::std::boxed::Box::new(
9717 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
9718 ))),
9719 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9720 }
9721 }
9722}
9723impl ::treesitter_types::Spanned for EnumBodyDeclarationsChildren<'_> {
9724 fn span(&self) -> ::treesitter_types::Span {
9725 match self {
9726 Self::AnnotationTypeDeclaration(inner) => inner.span(),
9727 Self::Block(inner) => inner.span(),
9728 Self::ClassDeclaration(inner) => inner.span(),
9729 Self::CompactConstructorDeclaration(inner) => inner.span(),
9730 Self::ConstructorDeclaration(inner) => inner.span(),
9731 Self::EnumDeclaration(inner) => inner.span(),
9732 Self::FieldDeclaration(inner) => inner.span(),
9733 Self::InterfaceDeclaration(inner) => inner.span(),
9734 Self::MethodDeclaration(inner) => inner.span(),
9735 Self::RecordDeclaration(inner) => inner.span(),
9736 Self::StaticInitializer(inner) => inner.span(),
9737 }
9738 }
9739}
9740#[derive(Debug, Clone, PartialEq, Eq)]
9741pub enum ExplicitConstructorInvocationConstructor<'tree> {
9742 Super(::std::boxed::Box<Super<'tree>>),
9743 This(::std::boxed::Box<This<'tree>>),
9744}
9745impl<'tree> ::treesitter_types::FromNode<'tree>
9746 for ExplicitConstructorInvocationConstructor<'tree>
9747{
9748 #[allow(clippy::collapsible_else_if)]
9749 fn from_node(
9750 node: ::tree_sitter::Node<'tree>,
9751 src: &'tree [u8],
9752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9753 match node.kind() {
9754 "super" => Ok(Self::Super(::std::boxed::Box::new(
9755 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9756 ))),
9757 "this" => Ok(Self::This(::std::boxed::Box::new(
9758 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
9759 ))),
9760 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9761 }
9762 }
9763}
9764impl ::treesitter_types::Spanned for ExplicitConstructorInvocationConstructor<'_> {
9765 fn span(&self) -> ::treesitter_types::Span {
9766 match self {
9767 Self::Super(inner) => inner.span(),
9768 Self::This(inner) => inner.span(),
9769 }
9770 }
9771}
9772#[derive(Debug, Clone, PartialEq, Eq)]
9773pub enum ExportsModuleDirectiveModules<'tree> {
9774 Identifier(::std::boxed::Box<Identifier<'tree>>),
9775 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9776}
9777impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectiveModules<'tree> {
9778 #[allow(clippy::collapsible_else_if)]
9779 fn from_node(
9780 node: ::tree_sitter::Node<'tree>,
9781 src: &'tree [u8],
9782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9783 match node.kind() {
9784 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9785 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9786 ))),
9787 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9788 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9789 ))),
9790 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9791 }
9792 }
9793}
9794impl ::treesitter_types::Spanned for ExportsModuleDirectiveModules<'_> {
9795 fn span(&self) -> ::treesitter_types::Span {
9796 match self {
9797 Self::Identifier(inner) => inner.span(),
9798 Self::ScopedIdentifier(inner) => inner.span(),
9799 }
9800 }
9801}
9802#[derive(Debug, Clone, PartialEq, Eq)]
9803pub enum ExportsModuleDirectivePackage<'tree> {
9804 Identifier(::std::boxed::Box<Identifier<'tree>>),
9805 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9806}
9807impl<'tree> ::treesitter_types::FromNode<'tree> for ExportsModuleDirectivePackage<'tree> {
9808 #[allow(clippy::collapsible_else_if)]
9809 fn from_node(
9810 node: ::tree_sitter::Node<'tree>,
9811 src: &'tree [u8],
9812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9813 match node.kind() {
9814 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9815 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9816 ))),
9817 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9818 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9819 ))),
9820 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9821 }
9822 }
9823}
9824impl ::treesitter_types::Spanned for ExportsModuleDirectivePackage<'_> {
9825 fn span(&self) -> ::treesitter_types::Span {
9826 match self {
9827 Self::Identifier(inner) => inner.span(),
9828 Self::ScopedIdentifier(inner) => inner.span(),
9829 }
9830 }
9831}
9832#[derive(Debug, Clone, PartialEq, Eq)]
9833pub enum FieldAccessField<'tree> {
9834 Identifier(::std::boxed::Box<Identifier<'tree>>),
9835 This(::std::boxed::Box<This<'tree>>),
9836}
9837impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessField<'tree> {
9838 #[allow(clippy::collapsible_else_if)]
9839 fn from_node(
9840 node: ::tree_sitter::Node<'tree>,
9841 src: &'tree [u8],
9842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9843 match node.kind() {
9844 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9845 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9846 ))),
9847 "this" => Ok(Self::This(::std::boxed::Box::new(
9848 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
9849 ))),
9850 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9851 }
9852 }
9853}
9854impl ::treesitter_types::Spanned for FieldAccessField<'_> {
9855 fn span(&self) -> ::treesitter_types::Span {
9856 match self {
9857 Self::Identifier(inner) => inner.span(),
9858 Self::This(inner) => inner.span(),
9859 }
9860 }
9861}
9862#[derive(Debug, Clone, PartialEq, Eq)]
9863pub enum FieldAccessObject<'tree> {
9864 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
9865 Super(::std::boxed::Box<Super<'tree>>),
9866}
9867impl<'tree> ::treesitter_types::FromNode<'tree> for FieldAccessObject<'tree> {
9868 #[allow(clippy::collapsible_else_if)]
9869 fn from_node(
9870 node: ::tree_sitter::Node<'tree>,
9871 src: &'tree [u8],
9872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9873 match node.kind() {
9874 "super" => Ok(Self::Super(::std::boxed::Box::new(
9875 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9876 ))),
9877 _other => {
9878 if let Ok(v) =
9879 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9880 {
9881 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
9882 } else {
9883 Err(::treesitter_types::ParseError::unexpected_kind(
9884 _other, node,
9885 ))
9886 }
9887 }
9888 }
9889 }
9890}
9891impl ::treesitter_types::Spanned for FieldAccessObject<'_> {
9892 fn span(&self) -> ::treesitter_types::Span {
9893 match self {
9894 Self::PrimaryExpression(inner) => inner.span(),
9895 Self::Super(inner) => inner.span(),
9896 }
9897 }
9898}
9899#[derive(Debug, Clone, PartialEq, Eq)]
9900pub enum ForStatementInit<'tree> {
9901 Expression(::std::boxed::Box<Expression<'tree>>),
9902 LocalVariableDeclaration(::std::boxed::Box<LocalVariableDeclaration<'tree>>),
9903}
9904impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInit<'tree> {
9905 #[allow(clippy::collapsible_else_if)]
9906 fn from_node(
9907 node: ::tree_sitter::Node<'tree>,
9908 src: &'tree [u8],
9909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9910 match node.kind() {
9911 "local_variable_declaration" => {
9912 Ok(Self::LocalVariableDeclaration(::std::boxed::Box::new(
9913 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(
9914 node, src,
9915 )?,
9916 )))
9917 }
9918 _other => {
9919 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9920 Ok(Self::Expression(::std::boxed::Box::new(v)))
9921 } else {
9922 Err(::treesitter_types::ParseError::unexpected_kind(
9923 _other, node,
9924 ))
9925 }
9926 }
9927 }
9928 }
9929}
9930impl ::treesitter_types::Spanned for ForStatementInit<'_> {
9931 fn span(&self) -> ::treesitter_types::Span {
9932 match self {
9933 Self::Expression(inner) => inner.span(),
9934 Self::LocalVariableDeclaration(inner) => inner.span(),
9935 }
9936 }
9937}
9938#[derive(Debug, Clone, PartialEq, Eq)]
9939pub enum FormalParameterName<'tree> {
9940 Identifier(::std::boxed::Box<Identifier<'tree>>),
9941 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
9942}
9943impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameterName<'tree> {
9944 #[allow(clippy::collapsible_else_if)]
9945 fn from_node(
9946 node: ::tree_sitter::Node<'tree>,
9947 src: &'tree [u8],
9948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9949 match node.kind() {
9950 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9951 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9952 ))),
9953 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
9954 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9955 ))),
9956 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9957 }
9958 }
9959}
9960impl ::treesitter_types::Spanned for FormalParameterName<'_> {
9961 fn span(&self) -> ::treesitter_types::Span {
9962 match self {
9963 Self::Identifier(inner) => inner.span(),
9964 Self::UnderscorePattern(inner) => inner.span(),
9965 }
9966 }
9967}
9968#[derive(Debug, Clone, PartialEq, Eq)]
9969pub enum FormalParametersChildren<'tree> {
9970 FormalParameter(::std::boxed::Box<FormalParameter<'tree>>),
9971 ReceiverParameter(::std::boxed::Box<ReceiverParameter<'tree>>),
9972 SpreadParameter(::std::boxed::Box<SpreadParameter<'tree>>),
9973}
9974impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
9975 #[allow(clippy::collapsible_else_if)]
9976 fn from_node(
9977 node: ::tree_sitter::Node<'tree>,
9978 src: &'tree [u8],
9979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9980 match node.kind() {
9981 "formal_parameter" => Ok(Self::FormalParameter(::std::boxed::Box::new(
9982 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9983 ))),
9984 "receiver_parameter" => Ok(Self::ReceiverParameter(::std::boxed::Box::new(
9985 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9986 ))),
9987 "spread_parameter" => Ok(Self::SpreadParameter(::std::boxed::Box::new(
9988 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9989 ))),
9990 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9991 }
9992 }
9993}
9994impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
9995 fn span(&self) -> ::treesitter_types::Span {
9996 match self {
9997 Self::FormalParameter(inner) => inner.span(),
9998 Self::ReceiverParameter(inner) => inner.span(),
9999 Self::SpreadParameter(inner) => inner.span(),
10000 }
10001 }
10002}
10003#[derive(Debug, Clone, PartialEq, Eq)]
10004pub enum GenericTypeChildren<'tree> {
10005 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10006 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
10007 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10008}
10009impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeChildren<'tree> {
10010 #[allow(clippy::collapsible_else_if)]
10011 fn from_node(
10012 node: ::tree_sitter::Node<'tree>,
10013 src: &'tree [u8],
10014 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10015 match node.kind() {
10016 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10017 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10018 ))),
10019 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
10020 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
10021 ))),
10022 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10023 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10024 ))),
10025 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10026 }
10027 }
10028}
10029impl ::treesitter_types::Spanned for GenericTypeChildren<'_> {
10030 fn span(&self) -> ::treesitter_types::Span {
10031 match self {
10032 Self::ScopedTypeIdentifier(inner) => inner.span(),
10033 Self::TypeArguments(inner) => inner.span(),
10034 Self::TypeIdentifier(inner) => inner.span(),
10035 }
10036 }
10037}
10038#[derive(Debug, Clone, PartialEq, Eq)]
10039pub enum ImportDeclarationChildren<'tree> {
10040 Asterisk(::std::boxed::Box<Asterisk<'tree>>),
10041 Identifier(::std::boxed::Box<Identifier<'tree>>),
10042 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10043}
10044impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclarationChildren<'tree> {
10045 #[allow(clippy::collapsible_else_if)]
10046 fn from_node(
10047 node: ::tree_sitter::Node<'tree>,
10048 src: &'tree [u8],
10049 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10050 match node.kind() {
10051 "asterisk" => Ok(Self::Asterisk(::std::boxed::Box::new(
10052 <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)?,
10053 ))),
10054 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10055 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10056 ))),
10057 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10058 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10059 ))),
10060 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10061 }
10062 }
10063}
10064impl ::treesitter_types::Spanned for ImportDeclarationChildren<'_> {
10065 fn span(&self) -> ::treesitter_types::Span {
10066 match self {
10067 Self::Asterisk(inner) => inner.span(),
10068 Self::Identifier(inner) => inner.span(),
10069 Self::ScopedIdentifier(inner) => inner.span(),
10070 }
10071 }
10072}
10073#[derive(Debug, Clone, PartialEq, Eq)]
10074pub enum InterfaceBodyChildren<'tree> {
10075 AnnotationTypeDeclaration(::std::boxed::Box<AnnotationTypeDeclaration<'tree>>),
10076 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
10077 ConstantDeclaration(::std::boxed::Box<ConstantDeclaration<'tree>>),
10078 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
10079 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
10080 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
10081 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
10082}
10083impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBodyChildren<'tree> {
10084 #[allow(clippy::collapsible_else_if)]
10085 fn from_node(
10086 node: ::tree_sitter::Node<'tree>,
10087 src: &'tree [u8],
10088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10089 match node.kind() {
10090 "annotation_type_declaration" => {
10091 Ok(Self::AnnotationTypeDeclaration(::std::boxed::Box::new(
10092 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(
10093 node, src,
10094 )?,
10095 )))
10096 }
10097 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
10098 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10099 ))),
10100 "constant_declaration" => Ok(Self::ConstantDeclaration(::std::boxed::Box::new(
10101 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10102 ))),
10103 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
10104 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10105 ))),
10106 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
10107 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10108 ))),
10109 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
10110 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10111 ))),
10112 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
10113 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10114 ))),
10115 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10116 }
10117 }
10118}
10119impl ::treesitter_types::Spanned for InterfaceBodyChildren<'_> {
10120 fn span(&self) -> ::treesitter_types::Span {
10121 match self {
10122 Self::AnnotationTypeDeclaration(inner) => inner.span(),
10123 Self::ClassDeclaration(inner) => inner.span(),
10124 Self::ConstantDeclaration(inner) => inner.span(),
10125 Self::EnumDeclaration(inner) => inner.span(),
10126 Self::InterfaceDeclaration(inner) => inner.span(),
10127 Self::MethodDeclaration(inner) => inner.span(),
10128 Self::RecordDeclaration(inner) => inner.span(),
10129 }
10130 }
10131}
10132#[derive(Debug, Clone, PartialEq, Eq)]
10133pub enum InterfaceDeclarationChildren<'tree> {
10134 ExtendsInterfaces(::std::boxed::Box<ExtendsInterfaces<'tree>>),
10135 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10136}
10137impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
10138 #[allow(clippy::collapsible_else_if)]
10139 fn from_node(
10140 node: ::tree_sitter::Node<'tree>,
10141 src: &'tree [u8],
10142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10143 match node.kind() {
10144 "extends_interfaces" => Ok(Self::ExtendsInterfaces(::std::boxed::Box::new(
10145 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)?,
10146 ))),
10147 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10148 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10149 ))),
10150 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10151 }
10152 }
10153}
10154impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
10155 fn span(&self) -> ::treesitter_types::Span {
10156 match self {
10157 Self::ExtendsInterfaces(inner) => inner.span(),
10158 Self::Modifiers(inner) => inner.span(),
10159 }
10160 }
10161}
10162#[derive(Debug, Clone, PartialEq, Eq)]
10163pub enum LabeledStatementChildren<'tree> {
10164 Identifier(::std::boxed::Box<Identifier<'tree>>),
10165 Statement(::std::boxed::Box<Statement<'tree>>),
10166}
10167impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
10168 #[allow(clippy::collapsible_else_if)]
10169 fn from_node(
10170 node: ::tree_sitter::Node<'tree>,
10171 src: &'tree [u8],
10172 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10173 match node.kind() {
10174 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10175 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10176 ))),
10177 _other => {
10178 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
10179 Ok(Self::Statement(::std::boxed::Box::new(v)))
10180 } else {
10181 Err(::treesitter_types::ParseError::unexpected_kind(
10182 _other, node,
10183 ))
10184 }
10185 }
10186 }
10187 }
10188}
10189impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
10190 fn span(&self) -> ::treesitter_types::Span {
10191 match self {
10192 Self::Identifier(inner) => inner.span(),
10193 Self::Statement(inner) => inner.span(),
10194 }
10195 }
10196}
10197#[derive(Debug, Clone, PartialEq, Eq)]
10198pub enum LambdaExpressionBody<'tree> {
10199 Block(::std::boxed::Box<Block<'tree>>),
10200 Expression(::std::boxed::Box<Expression<'tree>>),
10201}
10202impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
10203 #[allow(clippy::collapsible_else_if)]
10204 fn from_node(
10205 node: ::tree_sitter::Node<'tree>,
10206 src: &'tree [u8],
10207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10208 match node.kind() {
10209 "block" => Ok(Self::Block(::std::boxed::Box::new(
10210 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
10211 ))),
10212 _other => {
10213 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10214 Ok(Self::Expression(::std::boxed::Box::new(v)))
10215 } else {
10216 Err(::treesitter_types::ParseError::unexpected_kind(
10217 _other, node,
10218 ))
10219 }
10220 }
10221 }
10222 }
10223}
10224impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
10225 fn span(&self) -> ::treesitter_types::Span {
10226 match self {
10227 Self::Block(inner) => inner.span(),
10228 Self::Expression(inner) => inner.span(),
10229 }
10230 }
10231}
10232#[derive(Debug, Clone, PartialEq, Eq)]
10233pub enum LambdaExpressionParameters<'tree> {
10234 FormalParameters(::std::boxed::Box<FormalParameters<'tree>>),
10235 Identifier(::std::boxed::Box<Identifier<'tree>>),
10236 InferredParameters(::std::boxed::Box<InferredParameters<'tree>>),
10237}
10238impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
10239 #[allow(clippy::collapsible_else_if)]
10240 fn from_node(
10241 node: ::tree_sitter::Node<'tree>,
10242 src: &'tree [u8],
10243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10244 match node.kind() {
10245 "formal_parameters" => Ok(Self::FormalParameters(::std::boxed::Box::new(
10246 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)?,
10247 ))),
10248 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10249 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10250 ))),
10251 "inferred_parameters" => Ok(Self::InferredParameters(::std::boxed::Box::new(
10252 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)?,
10253 ))),
10254 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10255 }
10256 }
10257}
10258impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
10259 fn span(&self) -> ::treesitter_types::Span {
10260 match self {
10261 Self::FormalParameters(inner) => inner.span(),
10262 Self::Identifier(inner) => inner.span(),
10263 Self::InferredParameters(inner) => inner.span(),
10264 }
10265 }
10266}
10267#[derive(Debug, Clone, PartialEq, Eq)]
10268pub enum MarkerAnnotationName<'tree> {
10269 Identifier(::std::boxed::Box<Identifier<'tree>>),
10270 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10271}
10272impl<'tree> ::treesitter_types::FromNode<'tree> for MarkerAnnotationName<'tree> {
10273 #[allow(clippy::collapsible_else_if)]
10274 fn from_node(
10275 node: ::tree_sitter::Node<'tree>,
10276 src: &'tree [u8],
10277 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10278 match node.kind() {
10279 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10280 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10281 ))),
10282 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10283 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10284 ))),
10285 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10286 }
10287 }
10288}
10289impl ::treesitter_types::Spanned for MarkerAnnotationName<'_> {
10290 fn span(&self) -> ::treesitter_types::Span {
10291 match self {
10292 Self::Identifier(inner) => inner.span(),
10293 Self::ScopedIdentifier(inner) => inner.span(),
10294 }
10295 }
10296}
10297#[derive(Debug, Clone, PartialEq, Eq)]
10298pub enum MethodDeclarationChildren<'tree> {
10299 Annotation(::std::boxed::Box<Annotation<'tree>>),
10300 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10301 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
10302 Throws(::std::boxed::Box<Throws<'tree>>),
10303}
10304impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
10305 #[allow(clippy::collapsible_else_if)]
10306 fn from_node(
10307 node: ::tree_sitter::Node<'tree>,
10308 src: &'tree [u8],
10309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10310 match node.kind() {
10311 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10312 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10313 ))),
10314 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10315 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10316 ))),
10317 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
10318 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10319 ))),
10320 "throws" => Ok(Self::Throws(::std::boxed::Box::new(
10321 <Throws as ::treesitter_types::FromNode>::from_node(node, src)?,
10322 ))),
10323 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10324 }
10325 }
10326}
10327impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
10328 fn span(&self) -> ::treesitter_types::Span {
10329 match self {
10330 Self::Annotation(inner) => inner.span(),
10331 Self::MarkerAnnotation(inner) => inner.span(),
10332 Self::Modifiers(inner) => inner.span(),
10333 Self::Throws(inner) => inner.span(),
10334 }
10335 }
10336}
10337#[derive(Debug, Clone, PartialEq, Eq)]
10338pub enum MethodInvocationObject<'tree> {
10339 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10340 Super(::std::boxed::Box<Super<'tree>>),
10341}
10342impl<'tree> ::treesitter_types::FromNode<'tree> for MethodInvocationObject<'tree> {
10343 #[allow(clippy::collapsible_else_if)]
10344 fn from_node(
10345 node: ::tree_sitter::Node<'tree>,
10346 src: &'tree [u8],
10347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10348 match node.kind() {
10349 "super" => Ok(Self::Super(::std::boxed::Box::new(
10350 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10351 ))),
10352 _other => {
10353 if let Ok(v) =
10354 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10355 {
10356 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10357 } else {
10358 Err(::treesitter_types::ParseError::unexpected_kind(
10359 _other, node,
10360 ))
10361 }
10362 }
10363 }
10364 }
10365}
10366impl ::treesitter_types::Spanned for MethodInvocationObject<'_> {
10367 fn span(&self) -> ::treesitter_types::Span {
10368 match self {
10369 Self::PrimaryExpression(inner) => inner.span(),
10370 Self::Super(inner) => inner.span(),
10371 }
10372 }
10373}
10374#[derive(Debug, Clone, PartialEq, Eq)]
10375pub enum MethodReferenceChildren<'tree> {
10376 Type(::std::boxed::Box<Type<'tree>>),
10377 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10378 Super(::std::boxed::Box<Super<'tree>>),
10379 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
10380}
10381impl<'tree> ::treesitter_types::FromNode<'tree> for MethodReferenceChildren<'tree> {
10382 #[allow(clippy::collapsible_else_if)]
10383 fn from_node(
10384 node: ::tree_sitter::Node<'tree>,
10385 src: &'tree [u8],
10386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10387 match node.kind() {
10388 "super" => Ok(Self::Super(::std::boxed::Box::new(
10389 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10390 ))),
10391 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
10392 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
10393 ))),
10394 _other => {
10395 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10396 Ok(Self::Type(::std::boxed::Box::new(v)))
10397 } else {
10398 if let Ok(v) =
10399 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10400 {
10401 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10402 } else {
10403 Err(::treesitter_types::ParseError::unexpected_kind(
10404 _other, node,
10405 ))
10406 }
10407 }
10408 }
10409 }
10410 }
10411}
10412impl ::treesitter_types::Spanned for MethodReferenceChildren<'_> {
10413 fn span(&self) -> ::treesitter_types::Span {
10414 match self {
10415 Self::Type(inner) => inner.span(),
10416 Self::PrimaryExpression(inner) => inner.span(),
10417 Self::Super(inner) => inner.span(),
10418 Self::TypeArguments(inner) => inner.span(),
10419 }
10420 }
10421}
10422#[derive(Debug, Clone, PartialEq, Eq)]
10423pub enum ModifiersChildren<'tree> {
10424 Annotation(::std::boxed::Box<Annotation<'tree>>),
10425 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10426}
10427impl<'tree> ::treesitter_types::FromNode<'tree> for ModifiersChildren<'tree> {
10428 #[allow(clippy::collapsible_else_if)]
10429 fn from_node(
10430 node: ::tree_sitter::Node<'tree>,
10431 src: &'tree [u8],
10432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10433 match node.kind() {
10434 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10435 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10436 ))),
10437 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10438 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10439 ))),
10440 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10441 }
10442 }
10443}
10444impl ::treesitter_types::Spanned for ModifiersChildren<'_> {
10445 fn span(&self) -> ::treesitter_types::Span {
10446 match self {
10447 Self::Annotation(inner) => inner.span(),
10448 Self::MarkerAnnotation(inner) => inner.span(),
10449 }
10450 }
10451}
10452#[derive(Debug, Clone, PartialEq, Eq)]
10453pub enum ModuleDeclarationName<'tree> {
10454 Identifier(::std::boxed::Box<Identifier<'tree>>),
10455 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10456}
10457impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationName<'tree> {
10458 #[allow(clippy::collapsible_else_if)]
10459 fn from_node(
10460 node: ::tree_sitter::Node<'tree>,
10461 src: &'tree [u8],
10462 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10463 match node.kind() {
10464 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10465 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10466 ))),
10467 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10468 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10469 ))),
10470 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10471 }
10472 }
10473}
10474impl ::treesitter_types::Spanned for ModuleDeclarationName<'_> {
10475 fn span(&self) -> ::treesitter_types::Span {
10476 match self {
10477 Self::Identifier(inner) => inner.span(),
10478 Self::ScopedIdentifier(inner) => inner.span(),
10479 }
10480 }
10481}
10482#[derive(Debug, Clone, PartialEq, Eq)]
10483pub enum ModuleDeclarationChildren<'tree> {
10484 Annotation(::std::boxed::Box<Annotation<'tree>>),
10485 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10486}
10487impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleDeclarationChildren<'tree> {
10488 #[allow(clippy::collapsible_else_if)]
10489 fn from_node(
10490 node: ::tree_sitter::Node<'tree>,
10491 src: &'tree [u8],
10492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10493 match node.kind() {
10494 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10495 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10496 ))),
10497 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10498 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10499 ))),
10500 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10501 }
10502 }
10503}
10504impl ::treesitter_types::Spanned for ModuleDeclarationChildren<'_> {
10505 fn span(&self) -> ::treesitter_types::Span {
10506 match self {
10507 Self::Annotation(inner) => inner.span(),
10508 Self::MarkerAnnotation(inner) => inner.span(),
10509 }
10510 }
10511}
10512#[derive(Debug, Clone, PartialEq, Eq)]
10513pub enum ObjectCreationExpressionChildren<'tree> {
10514 Annotation(::std::boxed::Box<Annotation<'tree>>),
10515 ClassBody(::std::boxed::Box<ClassBody<'tree>>),
10516 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10517 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10518}
10519impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpressionChildren<'tree> {
10520 #[allow(clippy::collapsible_else_if)]
10521 fn from_node(
10522 node: ::tree_sitter::Node<'tree>,
10523 src: &'tree [u8],
10524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10525 match node.kind() {
10526 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10527 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10528 ))),
10529 "class_body" => Ok(Self::ClassBody(::std::boxed::Box::new(
10530 <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)?,
10531 ))),
10532 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10533 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10534 ))),
10535 _other => {
10536 if let Ok(v) =
10537 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10538 {
10539 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10540 } else {
10541 Err(::treesitter_types::ParseError::unexpected_kind(
10542 _other, node,
10543 ))
10544 }
10545 }
10546 }
10547 }
10548}
10549impl ::treesitter_types::Spanned for ObjectCreationExpressionChildren<'_> {
10550 fn span(&self) -> ::treesitter_types::Span {
10551 match self {
10552 Self::Annotation(inner) => inner.span(),
10553 Self::ClassBody(inner) => inner.span(),
10554 Self::MarkerAnnotation(inner) => inner.span(),
10555 Self::PrimaryExpression(inner) => inner.span(),
10556 }
10557 }
10558}
10559#[derive(Debug, Clone, PartialEq, Eq)]
10560pub enum OpensModuleDirectiveModules<'tree> {
10561 Identifier(::std::boxed::Box<Identifier<'tree>>),
10562 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10563}
10564impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectiveModules<'tree> {
10565 #[allow(clippy::collapsible_else_if)]
10566 fn from_node(
10567 node: ::tree_sitter::Node<'tree>,
10568 src: &'tree [u8],
10569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10570 match node.kind() {
10571 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10572 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10573 ))),
10574 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10575 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10576 ))),
10577 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10578 }
10579 }
10580}
10581impl ::treesitter_types::Spanned for OpensModuleDirectiveModules<'_> {
10582 fn span(&self) -> ::treesitter_types::Span {
10583 match self {
10584 Self::Identifier(inner) => inner.span(),
10585 Self::ScopedIdentifier(inner) => inner.span(),
10586 }
10587 }
10588}
10589#[derive(Debug, Clone, PartialEq, Eq)]
10590pub enum OpensModuleDirectivePackage<'tree> {
10591 Identifier(::std::boxed::Box<Identifier<'tree>>),
10592 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10593}
10594impl<'tree> ::treesitter_types::FromNode<'tree> for OpensModuleDirectivePackage<'tree> {
10595 #[allow(clippy::collapsible_else_if)]
10596 fn from_node(
10597 node: ::tree_sitter::Node<'tree>,
10598 src: &'tree [u8],
10599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10600 match node.kind() {
10601 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10602 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10603 ))),
10604 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10605 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10606 ))),
10607 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10608 }
10609 }
10610}
10611impl ::treesitter_types::Spanned for OpensModuleDirectivePackage<'_> {
10612 fn span(&self) -> ::treesitter_types::Span {
10613 match self {
10614 Self::Identifier(inner) => inner.span(),
10615 Self::ScopedIdentifier(inner) => inner.span(),
10616 }
10617 }
10618}
10619#[derive(Debug, Clone, PartialEq, Eq)]
10620pub enum PackageDeclarationChildren<'tree> {
10621 Annotation(::std::boxed::Box<Annotation<'tree>>),
10622 Identifier(::std::boxed::Box<Identifier<'tree>>),
10623 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10624 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10625}
10626impl<'tree> ::treesitter_types::FromNode<'tree> for PackageDeclarationChildren<'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 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10637 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10638 ))),
10639 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10640 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10641 ))),
10642 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10643 <ScopedIdentifier 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 PackageDeclarationChildren<'_> {
10650 fn span(&self) -> ::treesitter_types::Span {
10651 match self {
10652 Self::Annotation(inner) => inner.span(),
10653 Self::Identifier(inner) => inner.span(),
10654 Self::MarkerAnnotation(inner) => inner.span(),
10655 Self::ScopedIdentifier(inner) => inner.span(),
10656 }
10657 }
10658}
10659#[derive(Debug, Clone, PartialEq, Eq)]
10660pub enum PatternChildren<'tree> {
10661 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
10662 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
10663}
10664impl<'tree> ::treesitter_types::FromNode<'tree> for PatternChildren<'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 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
10672 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10673 ))),
10674 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
10675 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10676 ))),
10677 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10678 }
10679 }
10680}
10681impl ::treesitter_types::Spanned for PatternChildren<'_> {
10682 fn span(&self) -> ::treesitter_types::Span {
10683 match self {
10684 Self::RecordPattern(inner) => inner.span(),
10685 Self::TypePattern(inner) => inner.span(),
10686 }
10687 }
10688}
10689#[derive(Debug, Clone, PartialEq, Eq)]
10690pub enum ProgramChildren<'tree> {
10691 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
10692 Statement(::std::boxed::Box<Statement<'tree>>),
10693}
10694impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
10695 #[allow(clippy::collapsible_else_if)]
10696 fn from_node(
10697 node: ::tree_sitter::Node<'tree>,
10698 src: &'tree [u8],
10699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10700 match node.kind() {
10701 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
10702 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10703 ))),
10704 _other => {
10705 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
10706 Ok(Self::Statement(::std::boxed::Box::new(v)))
10707 } else {
10708 Err(::treesitter_types::ParseError::unexpected_kind(
10709 _other, node,
10710 ))
10711 }
10712 }
10713 }
10714 }
10715}
10716impl ::treesitter_types::Spanned for ProgramChildren<'_> {
10717 fn span(&self) -> ::treesitter_types::Span {
10718 match self {
10719 Self::MethodDeclaration(inner) => inner.span(),
10720 Self::Statement(inner) => inner.span(),
10721 }
10722 }
10723}
10724#[derive(Debug, Clone, PartialEq, Eq)]
10725pub enum ProvidesModuleDirectiveProvided<'tree> {
10726 Identifier(::std::boxed::Box<Identifier<'tree>>),
10727 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10728}
10729impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvided<'tree> {
10730 #[allow(clippy::collapsible_else_if)]
10731 fn from_node(
10732 node: ::tree_sitter::Node<'tree>,
10733 src: &'tree [u8],
10734 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10735 match node.kind() {
10736 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10737 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10738 ))),
10739 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10740 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10741 ))),
10742 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10743 }
10744 }
10745}
10746impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvided<'_> {
10747 fn span(&self) -> ::treesitter_types::Span {
10748 match self {
10749 Self::Identifier(inner) => inner.span(),
10750 Self::ScopedIdentifier(inner) => inner.span(),
10751 }
10752 }
10753}
10754#[derive(Debug, Clone, PartialEq, Eq)]
10755pub enum ProvidesModuleDirectiveProvider<'tree> {
10756 Identifier(::std::boxed::Box<Identifier<'tree>>),
10757 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10758}
10759impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveProvider<'tree> {
10760 #[allow(clippy::collapsible_else_if)]
10761 fn from_node(
10762 node: ::tree_sitter::Node<'tree>,
10763 src: &'tree [u8],
10764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10765 match node.kind() {
10766 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10767 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10768 ))),
10769 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10770 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10771 ))),
10772 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10773 }
10774 }
10775}
10776impl ::treesitter_types::Spanned for ProvidesModuleDirectiveProvider<'_> {
10777 fn span(&self) -> ::treesitter_types::Span {
10778 match self {
10779 Self::Identifier(inner) => inner.span(),
10780 Self::ScopedIdentifier(inner) => inner.span(),
10781 }
10782 }
10783}
10784#[derive(Debug, Clone, PartialEq, Eq)]
10785pub enum ProvidesModuleDirectiveChildren<'tree> {
10786 Identifier(::std::boxed::Box<Identifier<'tree>>),
10787 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10788}
10789impl<'tree> ::treesitter_types::FromNode<'tree> for ProvidesModuleDirectiveChildren<'tree> {
10790 #[allow(clippy::collapsible_else_if)]
10791 fn from_node(
10792 node: ::tree_sitter::Node<'tree>,
10793 src: &'tree [u8],
10794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10795 match node.kind() {
10796 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10797 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10798 ))),
10799 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10800 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10801 ))),
10802 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10803 }
10804 }
10805}
10806impl ::treesitter_types::Spanned for ProvidesModuleDirectiveChildren<'_> {
10807 fn span(&self) -> ::treesitter_types::Span {
10808 match self {
10809 Self::Identifier(inner) => inner.span(),
10810 Self::ScopedIdentifier(inner) => inner.span(),
10811 }
10812 }
10813}
10814#[derive(Debug, Clone, PartialEq, Eq)]
10815pub enum ReceiverParameterChildren<'tree> {
10816 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
10817 Annotation(::std::boxed::Box<Annotation<'tree>>),
10818 Identifier(::std::boxed::Box<Identifier<'tree>>),
10819 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
10820 This(::std::boxed::Box<This<'tree>>),
10821}
10822impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiverParameterChildren<'tree> {
10823 #[allow(clippy::collapsible_else_if)]
10824 fn from_node(
10825 node: ::tree_sitter::Node<'tree>,
10826 src: &'tree [u8],
10827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10828 match node.kind() {
10829 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
10830 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10831 ))),
10832 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10833 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10834 ))),
10835 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
10836 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10837 ))),
10838 "this" => Ok(Self::This(::std::boxed::Box::new(
10839 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
10840 ))),
10841 _other => {
10842 if let Ok(v) =
10843 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
10844 {
10845 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
10846 } else {
10847 Err(::treesitter_types::ParseError::unexpected_kind(
10848 _other, node,
10849 ))
10850 }
10851 }
10852 }
10853 }
10854}
10855impl ::treesitter_types::Spanned for ReceiverParameterChildren<'_> {
10856 fn span(&self) -> ::treesitter_types::Span {
10857 match self {
10858 Self::UnannotatedType(inner) => inner.span(),
10859 Self::Annotation(inner) => inner.span(),
10860 Self::Identifier(inner) => inner.span(),
10861 Self::MarkerAnnotation(inner) => inner.span(),
10862 Self::This(inner) => inner.span(),
10863 }
10864 }
10865}
10866#[derive(Debug, Clone, PartialEq, Eq)]
10867pub enum RecordPatternChildren<'tree> {
10868 GenericType(::std::boxed::Box<GenericType<'tree>>),
10869 Identifier(::std::boxed::Box<Identifier<'tree>>),
10870 RecordPatternBody(::std::boxed::Box<RecordPatternBody<'tree>>),
10871}
10872impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternChildren<'tree> {
10873 #[allow(clippy::collapsible_else_if)]
10874 fn from_node(
10875 node: ::tree_sitter::Node<'tree>,
10876 src: &'tree [u8],
10877 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10878 match node.kind() {
10879 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10880 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10881 ))),
10882 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10883 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10884 ))),
10885 "record_pattern_body" => Ok(Self::RecordPatternBody(::std::boxed::Box::new(
10886 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)?,
10887 ))),
10888 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10889 }
10890 }
10891}
10892impl ::treesitter_types::Spanned for RecordPatternChildren<'_> {
10893 fn span(&self) -> ::treesitter_types::Span {
10894 match self {
10895 Self::GenericType(inner) => inner.span(),
10896 Self::Identifier(inner) => inner.span(),
10897 Self::RecordPatternBody(inner) => inner.span(),
10898 }
10899 }
10900}
10901#[derive(Debug, Clone, PartialEq, Eq)]
10902pub enum RecordPatternBodyChildren<'tree> {
10903 RecordPattern(::std::boxed::Box<RecordPattern<'tree>>),
10904 RecordPatternComponent(::std::boxed::Box<RecordPatternComponent<'tree>>),
10905}
10906impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternBodyChildren<'tree> {
10907 #[allow(clippy::collapsible_else_if)]
10908 fn from_node(
10909 node: ::tree_sitter::Node<'tree>,
10910 src: &'tree [u8],
10911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10912 match node.kind() {
10913 "record_pattern" => Ok(Self::RecordPattern(::std::boxed::Box::new(
10914 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10915 ))),
10916 "record_pattern_component" => Ok(Self::RecordPatternComponent(::std::boxed::Box::new(
10917 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)?,
10918 ))),
10919 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10920 }
10921 }
10922}
10923impl ::treesitter_types::Spanned for RecordPatternBodyChildren<'_> {
10924 fn span(&self) -> ::treesitter_types::Span {
10925 match self {
10926 Self::RecordPattern(inner) => inner.span(),
10927 Self::RecordPatternComponent(inner) => inner.span(),
10928 }
10929 }
10930}
10931#[derive(Debug, Clone, PartialEq, Eq)]
10932pub enum RecordPatternComponentChildren<'tree> {
10933 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
10934 Identifier(::std::boxed::Box<Identifier<'tree>>),
10935 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
10936}
10937impl<'tree> ::treesitter_types::FromNode<'tree> for RecordPatternComponentChildren<'tree> {
10938 #[allow(clippy::collapsible_else_if)]
10939 fn from_node(
10940 node: ::tree_sitter::Node<'tree>,
10941 src: &'tree [u8],
10942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10943 match node.kind() {
10944 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10945 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10946 ))),
10947 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
10948 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10949 ))),
10950 _other => {
10951 if let Ok(v) =
10952 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
10953 {
10954 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
10955 } else {
10956 Err(::treesitter_types::ParseError::unexpected_kind(
10957 _other, node,
10958 ))
10959 }
10960 }
10961 }
10962 }
10963}
10964impl ::treesitter_types::Spanned for RecordPatternComponentChildren<'_> {
10965 fn span(&self) -> ::treesitter_types::Span {
10966 match self {
10967 Self::UnannotatedType(inner) => inner.span(),
10968 Self::Identifier(inner) => inner.span(),
10969 Self::UnderscorePattern(inner) => inner.span(),
10970 }
10971 }
10972}
10973#[derive(Debug, Clone, PartialEq, Eq)]
10974pub enum RequiresModuleDirectiveModule<'tree> {
10975 Identifier(::std::boxed::Box<Identifier<'tree>>),
10976 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10977}
10978impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresModuleDirectiveModule<'tree> {
10979 #[allow(clippy::collapsible_else_if)]
10980 fn from_node(
10981 node: ::tree_sitter::Node<'tree>,
10982 src: &'tree [u8],
10983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10984 match node.kind() {
10985 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10986 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10987 ))),
10988 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10989 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10990 ))),
10991 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10992 }
10993 }
10994}
10995impl ::treesitter_types::Spanned for RequiresModuleDirectiveModule<'_> {
10996 fn span(&self) -> ::treesitter_types::Span {
10997 match self {
10998 Self::Identifier(inner) => inner.span(),
10999 Self::ScopedIdentifier(inner) => inner.span(),
11000 }
11001 }
11002}
11003#[derive(Debug, Clone, PartialEq, Eq)]
11004pub enum ResourceName<'tree> {
11005 Identifier(::std::boxed::Box<Identifier<'tree>>),
11006 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
11007}
11008impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceName<'tree> {
11009 #[allow(clippy::collapsible_else_if)]
11010 fn from_node(
11011 node: ::tree_sitter::Node<'tree>,
11012 src: &'tree [u8],
11013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11014 match node.kind() {
11015 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11016 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11017 ))),
11018 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
11019 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11020 ))),
11021 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11022 }
11023 }
11024}
11025impl ::treesitter_types::Spanned for ResourceName<'_> {
11026 fn span(&self) -> ::treesitter_types::Span {
11027 match self {
11028 Self::Identifier(inner) => inner.span(),
11029 Self::UnderscorePattern(inner) => inner.span(),
11030 }
11031 }
11032}
11033#[derive(Debug, Clone, PartialEq, Eq)]
11034pub enum ResourceChildren<'tree> {
11035 FieldAccess(::std::boxed::Box<FieldAccess<'tree>>),
11036 Identifier(::std::boxed::Box<Identifier<'tree>>),
11037 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
11038}
11039impl<'tree> ::treesitter_types::FromNode<'tree> for ResourceChildren<'tree> {
11040 #[allow(clippy::collapsible_else_if)]
11041 fn from_node(
11042 node: ::tree_sitter::Node<'tree>,
11043 src: &'tree [u8],
11044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11045 match node.kind() {
11046 "field_access" => Ok(Self::FieldAccess(::std::boxed::Box::new(
11047 <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)?,
11048 ))),
11049 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11050 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11051 ))),
11052 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
11053 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
11054 ))),
11055 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11056 }
11057 }
11058}
11059impl ::treesitter_types::Spanned for ResourceChildren<'_> {
11060 fn span(&self) -> ::treesitter_types::Span {
11061 match self {
11062 Self::FieldAccess(inner) => inner.span(),
11063 Self::Identifier(inner) => inner.span(),
11064 Self::Modifiers(inner) => inner.span(),
11065 }
11066 }
11067}
11068#[derive(Debug, Clone, PartialEq, Eq)]
11069pub enum ScopedIdentifierScope<'tree> {
11070 Identifier(::std::boxed::Box<Identifier<'tree>>),
11071 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11072}
11073impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierScope<'tree> {
11074 #[allow(clippy::collapsible_else_if)]
11075 fn from_node(
11076 node: ::tree_sitter::Node<'tree>,
11077 src: &'tree [u8],
11078 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11079 match node.kind() {
11080 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11081 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11082 ))),
11083 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11084 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11085 ))),
11086 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11087 }
11088 }
11089}
11090impl ::treesitter_types::Spanned for ScopedIdentifierScope<'_> {
11091 fn span(&self) -> ::treesitter_types::Span {
11092 match self {
11093 Self::Identifier(inner) => inner.span(),
11094 Self::ScopedIdentifier(inner) => inner.span(),
11095 }
11096 }
11097}
11098#[derive(Debug, Clone, PartialEq, Eq)]
11099pub enum ScopedTypeIdentifierChildren<'tree> {
11100 Annotation(::std::boxed::Box<Annotation<'tree>>),
11101 GenericType(::std::boxed::Box<GenericType<'tree>>),
11102 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11103 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11104 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11105}
11106impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierChildren<'tree> {
11107 #[allow(clippy::collapsible_else_if)]
11108 fn from_node(
11109 node: ::tree_sitter::Node<'tree>,
11110 src: &'tree [u8],
11111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11112 match node.kind() {
11113 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11114 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11115 ))),
11116 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11117 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
11118 ))),
11119 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11120 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11121 ))),
11122 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11123 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11124 ))),
11125 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11126 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11127 ))),
11128 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11129 }
11130 }
11131}
11132impl ::treesitter_types::Spanned for ScopedTypeIdentifierChildren<'_> {
11133 fn span(&self) -> ::treesitter_types::Span {
11134 match self {
11135 Self::Annotation(inner) => inner.span(),
11136 Self::GenericType(inner) => inner.span(),
11137 Self::MarkerAnnotation(inner) => inner.span(),
11138 Self::ScopedTypeIdentifier(inner) => inner.span(),
11139 Self::TypeIdentifier(inner) => inner.span(),
11140 }
11141 }
11142}
11143#[derive(Debug, Clone, PartialEq, Eq)]
11144pub enum SpreadParameterChildren<'tree> {
11145 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
11146 Annotation(::std::boxed::Box<Annotation<'tree>>),
11147 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11148 Modifiers(::std::boxed::Box<Modifiers<'tree>>),
11149 VariableDeclarator(::std::boxed::Box<VariableDeclarator<'tree>>),
11150}
11151impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadParameterChildren<'tree> {
11152 #[allow(clippy::collapsible_else_if)]
11153 fn from_node(
11154 node: ::tree_sitter::Node<'tree>,
11155 src: &'tree [u8],
11156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11157 match node.kind() {
11158 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11159 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11160 ))),
11161 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11162 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11163 ))),
11164 "modifiers" => Ok(Self::Modifiers(::std::boxed::Box::new(
11165 <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
11166 ))),
11167 "variable_declarator" => Ok(Self::VariableDeclarator(::std::boxed::Box::new(
11168 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
11169 ))),
11170 _other => {
11171 if let Ok(v) =
11172 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11173 {
11174 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
11175 } else {
11176 Err(::treesitter_types::ParseError::unexpected_kind(
11177 _other, node,
11178 ))
11179 }
11180 }
11181 }
11182 }
11183}
11184impl ::treesitter_types::Spanned for SpreadParameterChildren<'_> {
11185 fn span(&self) -> ::treesitter_types::Span {
11186 match self {
11187 Self::UnannotatedType(inner) => inner.span(),
11188 Self::Annotation(inner) => inner.span(),
11189 Self::MarkerAnnotation(inner) => inner.span(),
11190 Self::Modifiers(inner) => inner.span(),
11191 Self::VariableDeclarator(inner) => inner.span(),
11192 }
11193 }
11194}
11195#[derive(Debug, Clone, PartialEq, Eq)]
11196pub enum StringLiteralChildren<'tree> {
11197 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11198 MultilineStringFragment(::std::boxed::Box<MultilineStringFragment<'tree>>),
11199 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
11200 StringInterpolation(::std::boxed::Box<StringInterpolation<'tree>>),
11201}
11202impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
11203 #[allow(clippy::collapsible_else_if)]
11204 fn from_node(
11205 node: ::tree_sitter::Node<'tree>,
11206 src: &'tree [u8],
11207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11208 match node.kind() {
11209 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11210 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
11211 ))),
11212 "multiline_string_fragment" => {
11213 Ok(Self::MultilineStringFragment(::std::boxed::Box::new(
11214 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(
11215 node, src,
11216 )?,
11217 )))
11218 }
11219 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
11220 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
11221 ))),
11222 "string_interpolation" => Ok(Self::StringInterpolation(::std::boxed::Box::new(
11223 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
11224 ))),
11225 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11226 }
11227 }
11228}
11229impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
11230 fn span(&self) -> ::treesitter_types::Span {
11231 match self {
11232 Self::EscapeSequence(inner) => inner.span(),
11233 Self::MultilineStringFragment(inner) => inner.span(),
11234 Self::StringFragment(inner) => inner.span(),
11235 Self::StringInterpolation(inner) => inner.span(),
11236 }
11237 }
11238}
11239#[derive(Debug, Clone, PartialEq, Eq)]
11240pub enum SwitchBlockChildren<'tree> {
11241 SwitchBlockStatementGroup(::std::boxed::Box<SwitchBlockStatementGroup<'tree>>),
11242 SwitchRule(::std::boxed::Box<SwitchRule<'tree>>),
11243}
11244impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockChildren<'tree> {
11245 #[allow(clippy::collapsible_else_if)]
11246 fn from_node(
11247 node: ::tree_sitter::Node<'tree>,
11248 src: &'tree [u8],
11249 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11250 match node.kind() {
11251 "switch_block_statement_group" => {
11252 Ok(Self::SwitchBlockStatementGroup(::std::boxed::Box::new(
11253 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(
11254 node, src,
11255 )?,
11256 )))
11257 }
11258 "switch_rule" => Ok(Self::SwitchRule(::std::boxed::Box::new(
11259 <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)?,
11260 ))),
11261 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11262 }
11263 }
11264}
11265impl ::treesitter_types::Spanned for SwitchBlockChildren<'_> {
11266 fn span(&self) -> ::treesitter_types::Span {
11267 match self {
11268 Self::SwitchBlockStatementGroup(inner) => inner.span(),
11269 Self::SwitchRule(inner) => inner.span(),
11270 }
11271 }
11272}
11273#[derive(Debug, Clone, PartialEq, Eq)]
11274pub enum SwitchBlockStatementGroupChildren<'tree> {
11275 Statement(::std::boxed::Box<Statement<'tree>>),
11276 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
11277}
11278impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockStatementGroupChildren<'tree> {
11279 #[allow(clippy::collapsible_else_if)]
11280 fn from_node(
11281 node: ::tree_sitter::Node<'tree>,
11282 src: &'tree [u8],
11283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11284 match node.kind() {
11285 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
11286 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)?,
11287 ))),
11288 _other => {
11289 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
11290 Ok(Self::Statement(::std::boxed::Box::new(v)))
11291 } else {
11292 Err(::treesitter_types::ParseError::unexpected_kind(
11293 _other, node,
11294 ))
11295 }
11296 }
11297 }
11298 }
11299}
11300impl ::treesitter_types::Spanned for SwitchBlockStatementGroupChildren<'_> {
11301 fn span(&self) -> ::treesitter_types::Span {
11302 match self {
11303 Self::Statement(inner) => inner.span(),
11304 Self::SwitchLabel(inner) => inner.span(),
11305 }
11306 }
11307}
11308#[derive(Debug, Clone, PartialEq, Eq)]
11309pub enum SwitchLabelChildren<'tree> {
11310 Expression(::std::boxed::Box<Expression<'tree>>),
11311 Guard(::std::boxed::Box<Guard<'tree>>),
11312 Pattern(::std::boxed::Box<Pattern<'tree>>),
11313}
11314impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchLabelChildren<'tree> {
11315 #[allow(clippy::collapsible_else_if)]
11316 fn from_node(
11317 node: ::tree_sitter::Node<'tree>,
11318 src: &'tree [u8],
11319 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11320 match node.kind() {
11321 "guard" => Ok(Self::Guard(::std::boxed::Box::new(
11322 <Guard as ::treesitter_types::FromNode>::from_node(node, src)?,
11323 ))),
11324 "pattern" => Ok(Self::Pattern(::std::boxed::Box::new(
11325 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11326 ))),
11327 _other => {
11328 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11329 Ok(Self::Expression(::std::boxed::Box::new(v)))
11330 } else {
11331 Err(::treesitter_types::ParseError::unexpected_kind(
11332 _other, node,
11333 ))
11334 }
11335 }
11336 }
11337 }
11338}
11339impl ::treesitter_types::Spanned for SwitchLabelChildren<'_> {
11340 fn span(&self) -> ::treesitter_types::Span {
11341 match self {
11342 Self::Expression(inner) => inner.span(),
11343 Self::Guard(inner) => inner.span(),
11344 Self::Pattern(inner) => inner.span(),
11345 }
11346 }
11347}
11348#[derive(Debug, Clone, PartialEq, Eq)]
11349pub enum SwitchRuleChildren<'tree> {
11350 Block(::std::boxed::Box<Block<'tree>>),
11351 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
11352 SwitchLabel(::std::boxed::Box<SwitchLabel<'tree>>),
11353 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
11354}
11355impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchRuleChildren<'tree> {
11356 #[allow(clippy::collapsible_else_if)]
11357 fn from_node(
11358 node: ::tree_sitter::Node<'tree>,
11359 src: &'tree [u8],
11360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11361 match node.kind() {
11362 "block" => Ok(Self::Block(::std::boxed::Box::new(
11363 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
11364 ))),
11365 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
11366 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
11367 ))),
11368 "switch_label" => Ok(Self::SwitchLabel(::std::boxed::Box::new(
11369 <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)?,
11370 ))),
11371 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
11372 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
11373 ))),
11374 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11375 }
11376 }
11377}
11378impl ::treesitter_types::Spanned for SwitchRuleChildren<'_> {
11379 fn span(&self) -> ::treesitter_types::Span {
11380 match self {
11381 Self::Block(inner) => inner.span(),
11382 Self::ExpressionStatement(inner) => inner.span(),
11383 Self::SwitchLabel(inner) => inner.span(),
11384 Self::ThrowStatement(inner) => inner.span(),
11385 }
11386 }
11387}
11388#[derive(Debug, Clone, PartialEq, Eq)]
11389pub enum TryStatementChildren<'tree> {
11390 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
11391 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
11392}
11393impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
11394 #[allow(clippy::collapsible_else_if)]
11395 fn from_node(
11396 node: ::tree_sitter::Node<'tree>,
11397 src: &'tree [u8],
11398 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11399 match node.kind() {
11400 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
11401 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11402 ))),
11403 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
11404 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11405 ))),
11406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11407 }
11408 }
11409}
11410impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
11411 fn span(&self) -> ::treesitter_types::Span {
11412 match self {
11413 Self::CatchClause(inner) => inner.span(),
11414 Self::FinallyClause(inner) => inner.span(),
11415 }
11416 }
11417}
11418#[derive(Debug, Clone, PartialEq, Eq)]
11419pub enum TryWithResourcesStatementChildren<'tree> {
11420 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
11421 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
11422}
11423impl<'tree> ::treesitter_types::FromNode<'tree> for TryWithResourcesStatementChildren<'tree> {
11424 #[allow(clippy::collapsible_else_if)]
11425 fn from_node(
11426 node: ::tree_sitter::Node<'tree>,
11427 src: &'tree [u8],
11428 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11429 match node.kind() {
11430 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
11431 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11432 ))),
11433 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
11434 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11435 ))),
11436 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11437 }
11438 }
11439}
11440impl ::treesitter_types::Spanned for TryWithResourcesStatementChildren<'_> {
11441 fn span(&self) -> ::treesitter_types::Span {
11442 match self {
11443 Self::CatchClause(inner) => inner.span(),
11444 Self::FinallyClause(inner) => inner.span(),
11445 }
11446 }
11447}
11448#[derive(Debug, Clone, PartialEq, Eq)]
11449pub enum TypeArgumentsChildren<'tree> {
11450 Type(::std::boxed::Box<Type<'tree>>),
11451 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
11452}
11453impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
11454 #[allow(clippy::collapsible_else_if)]
11455 fn from_node(
11456 node: ::tree_sitter::Node<'tree>,
11457 src: &'tree [u8],
11458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11459 match node.kind() {
11460 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
11461 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
11462 ))),
11463 _other => {
11464 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11465 Ok(Self::Type(::std::boxed::Box::new(v)))
11466 } else {
11467 Err(::treesitter_types::ParseError::unexpected_kind(
11468 _other, node,
11469 ))
11470 }
11471 }
11472 }
11473 }
11474}
11475impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
11476 fn span(&self) -> ::treesitter_types::Span {
11477 match self {
11478 Self::Type(inner) => inner.span(),
11479 Self::Wildcard(inner) => inner.span(),
11480 }
11481 }
11482}
11483#[derive(Debug, Clone, PartialEq, Eq)]
11484pub enum TypeParameterChildren<'tree> {
11485 Annotation(::std::boxed::Box<Annotation<'tree>>),
11486 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11487 TypeBound(::std::boxed::Box<TypeBound<'tree>>),
11488 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11489}
11490impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterChildren<'tree> {
11491 #[allow(clippy::collapsible_else_if)]
11492 fn from_node(
11493 node: ::tree_sitter::Node<'tree>,
11494 src: &'tree [u8],
11495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11496 match node.kind() {
11497 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11498 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11499 ))),
11500 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11501 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11502 ))),
11503 "type_bound" => Ok(Self::TypeBound(::std::boxed::Box::new(
11504 <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)?,
11505 ))),
11506 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11507 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11508 ))),
11509 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11510 }
11511 }
11512}
11513impl ::treesitter_types::Spanned for TypeParameterChildren<'_> {
11514 fn span(&self) -> ::treesitter_types::Span {
11515 match self {
11516 Self::Annotation(inner) => inner.span(),
11517 Self::MarkerAnnotation(inner) => inner.span(),
11518 Self::TypeBound(inner) => inner.span(),
11519 Self::TypeIdentifier(inner) => inner.span(),
11520 }
11521 }
11522}
11523#[derive(Debug, Clone, PartialEq, Eq)]
11524pub enum TypePatternChildren<'tree> {
11525 UnannotatedType(::std::boxed::Box<UnannotatedType<'tree>>),
11526 Identifier(::std::boxed::Box<Identifier<'tree>>),
11527}
11528impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatternChildren<'tree> {
11529 #[allow(clippy::collapsible_else_if)]
11530 fn from_node(
11531 node: ::tree_sitter::Node<'tree>,
11532 src: &'tree [u8],
11533 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11534 match node.kind() {
11535 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11536 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11537 ))),
11538 _other => {
11539 if let Ok(v) =
11540 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11541 {
11542 Ok(Self::UnannotatedType(::std::boxed::Box::new(v)))
11543 } else {
11544 Err(::treesitter_types::ParseError::unexpected_kind(
11545 _other, node,
11546 ))
11547 }
11548 }
11549 }
11550 }
11551}
11552impl ::treesitter_types::Spanned for TypePatternChildren<'_> {
11553 fn span(&self) -> ::treesitter_types::Span {
11554 match self {
11555 Self::UnannotatedType(inner) => inner.span(),
11556 Self::Identifier(inner) => inner.span(),
11557 }
11558 }
11559}
11560#[derive(Debug, Clone, PartialEq, Eq)]
11561pub enum UnaryExpressionOperator {
11562 Bang(::treesitter_types::Span),
11563 Plus(::treesitter_types::Span),
11564 Minus(::treesitter_types::Span),
11565 Tilde(::treesitter_types::Span),
11566}
11567impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
11568 #[allow(clippy::collapsible_else_if)]
11569 fn from_node(
11570 node: ::tree_sitter::Node<'tree>,
11571 _src: &'tree [u8],
11572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11573 match node.kind() {
11574 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
11575 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
11576 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
11577 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
11578 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11579 }
11580 }
11581}
11582impl ::treesitter_types::Spanned for UnaryExpressionOperator {
11583 fn span(&self) -> ::treesitter_types::Span {
11584 match self {
11585 Self::Bang(span) => *span,
11586 Self::Plus(span) => *span,
11587 Self::Minus(span) => *span,
11588 Self::Tilde(span) => *span,
11589 }
11590 }
11591}
11592#[derive(Debug, Clone, PartialEq, Eq)]
11593pub enum UsesModuleDirectiveType<'tree> {
11594 Identifier(::std::boxed::Box<Identifier<'tree>>),
11595 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11596}
11597impl<'tree> ::treesitter_types::FromNode<'tree> for UsesModuleDirectiveType<'tree> {
11598 #[allow(clippy::collapsible_else_if)]
11599 fn from_node(
11600 node: ::tree_sitter::Node<'tree>,
11601 src: &'tree [u8],
11602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11603 match node.kind() {
11604 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11605 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11606 ))),
11607 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11608 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11609 ))),
11610 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11611 }
11612 }
11613}
11614impl ::treesitter_types::Spanned for UsesModuleDirectiveType<'_> {
11615 fn span(&self) -> ::treesitter_types::Span {
11616 match self {
11617 Self::Identifier(inner) => inner.span(),
11618 Self::ScopedIdentifier(inner) => inner.span(),
11619 }
11620 }
11621}
11622#[derive(Debug, Clone, PartialEq, Eq)]
11623pub enum VariableDeclaratorName<'tree> {
11624 Identifier(::std::boxed::Box<Identifier<'tree>>),
11625 UnderscorePattern(::std::boxed::Box<UnderscorePattern<'tree>>),
11626}
11627impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
11628 #[allow(clippy::collapsible_else_if)]
11629 fn from_node(
11630 node: ::tree_sitter::Node<'tree>,
11631 src: &'tree [u8],
11632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11633 match node.kind() {
11634 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11635 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11636 ))),
11637 "underscore_pattern" => Ok(Self::UnderscorePattern(::std::boxed::Box::new(
11638 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11639 ))),
11640 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11641 }
11642 }
11643}
11644impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
11645 fn span(&self) -> ::treesitter_types::Span {
11646 match self {
11647 Self::Identifier(inner) => inner.span(),
11648 Self::UnderscorePattern(inner) => inner.span(),
11649 }
11650 }
11651}
11652#[derive(Debug, Clone, PartialEq, Eq)]
11653pub enum VariableDeclaratorValue<'tree> {
11654 ArrayInitializer(::std::boxed::Box<ArrayInitializer<'tree>>),
11655 Expression(::std::boxed::Box<Expression<'tree>>),
11656}
11657impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorValue<'tree> {
11658 #[allow(clippy::collapsible_else_if)]
11659 fn from_node(
11660 node: ::tree_sitter::Node<'tree>,
11661 src: &'tree [u8],
11662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11663 match node.kind() {
11664 "array_initializer" => Ok(Self::ArrayInitializer(::std::boxed::Box::new(
11665 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
11666 ))),
11667 _other => {
11668 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11669 Ok(Self::Expression(::std::boxed::Box::new(v)))
11670 } else {
11671 Err(::treesitter_types::ParseError::unexpected_kind(
11672 _other, node,
11673 ))
11674 }
11675 }
11676 }
11677 }
11678}
11679impl ::treesitter_types::Spanned for VariableDeclaratorValue<'_> {
11680 fn span(&self) -> ::treesitter_types::Span {
11681 match self {
11682 Self::ArrayInitializer(inner) => inner.span(),
11683 Self::Expression(inner) => inner.span(),
11684 }
11685 }
11686}
11687#[derive(Debug, Clone, PartialEq, Eq)]
11688pub enum WildcardChildren<'tree> {
11689 Type(::std::boxed::Box<Type<'tree>>),
11690 Annotation(::std::boxed::Box<Annotation<'tree>>),
11691 MarkerAnnotation(::std::boxed::Box<MarkerAnnotation<'tree>>),
11692 Super(::std::boxed::Box<Super<'tree>>),
11693}
11694impl<'tree> ::treesitter_types::FromNode<'tree> for WildcardChildren<'tree> {
11695 #[allow(clippy::collapsible_else_if)]
11696 fn from_node(
11697 node: ::tree_sitter::Node<'tree>,
11698 src: &'tree [u8],
11699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11700 match node.kind() {
11701 "annotation" => Ok(Self::Annotation(::std::boxed::Box::new(
11702 <Annotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11703 ))),
11704 "marker_annotation" => Ok(Self::MarkerAnnotation(::std::boxed::Box::new(
11705 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11706 ))),
11707 "super" => Ok(Self::Super(::std::boxed::Box::new(
11708 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11709 ))),
11710 _other => {
11711 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11712 Ok(Self::Type(::std::boxed::Box::new(v)))
11713 } else {
11714 Err(::treesitter_types::ParseError::unexpected_kind(
11715 _other, node,
11716 ))
11717 }
11718 }
11719 }
11720 }
11721}
11722impl ::treesitter_types::Spanned for WildcardChildren<'_> {
11723 fn span(&self) -> ::treesitter_types::Span {
11724 match self {
11725 Self::Type(inner) => inner.span(),
11726 Self::Annotation(inner) => inner.span(),
11727 Self::MarkerAnnotation(inner) => inner.span(),
11728 Self::Super(inner) => inner.span(),
11729 }
11730 }
11731}
11732#[derive(Debug, Clone, PartialEq, Eq)]
11733pub enum AnyNode<'tree> {
11734 Literal(Literal<'tree>),
11735 SimpleType(SimpleType<'tree>),
11736 Type(Type<'tree>),
11737 UnannotatedType(UnannotatedType<'tree>),
11738 Declaration(Declaration<'tree>),
11739 Expression(Expression<'tree>),
11740 ModuleDirective(ModuleDirective<'tree>),
11741 PrimaryExpression(PrimaryExpression<'tree>),
11742 Statement(Statement<'tree>),
11743 AnnotatedType(AnnotatedType<'tree>),
11744 Annotation(Annotation<'tree>),
11745 AnnotationArgumentList(AnnotationArgumentList<'tree>),
11746 AnnotationTypeBody(AnnotationTypeBody<'tree>),
11747 AnnotationTypeDeclaration(AnnotationTypeDeclaration<'tree>),
11748 AnnotationTypeElementDeclaration(AnnotationTypeElementDeclaration<'tree>),
11749 ArgumentList(ArgumentList<'tree>),
11750 ArrayAccess(ArrayAccess<'tree>),
11751 ArrayCreationExpression(ArrayCreationExpression<'tree>),
11752 ArrayInitializer(ArrayInitializer<'tree>),
11753 ArrayType(ArrayType<'tree>),
11754 AssertStatement(AssertStatement<'tree>),
11755 AssignmentExpression(AssignmentExpression<'tree>),
11756 Asterisk(Asterisk<'tree>),
11757 BinaryExpression(BinaryExpression<'tree>),
11758 Block(Block<'tree>),
11759 BreakStatement(BreakStatement<'tree>),
11760 CastExpression(CastExpression<'tree>),
11761 CatchClause(CatchClause<'tree>),
11762 CatchFormalParameter(CatchFormalParameter<'tree>),
11763 CatchType(CatchType<'tree>),
11764 ClassBody(ClassBody<'tree>),
11765 ClassDeclaration(ClassDeclaration<'tree>),
11766 ClassLiteral(ClassLiteral<'tree>),
11767 CompactConstructorDeclaration(CompactConstructorDeclaration<'tree>),
11768 ConstantDeclaration(ConstantDeclaration<'tree>),
11769 ConstructorBody(ConstructorBody<'tree>),
11770 ConstructorDeclaration(ConstructorDeclaration<'tree>),
11771 ContinueStatement(ContinueStatement<'tree>),
11772 Dimensions(Dimensions<'tree>),
11773 DimensionsExpr(DimensionsExpr<'tree>),
11774 DoStatement(DoStatement<'tree>),
11775 ElementValueArrayInitializer(ElementValueArrayInitializer<'tree>),
11776 ElementValuePair(ElementValuePair<'tree>),
11777 EnhancedForStatement(EnhancedForStatement<'tree>),
11778 EnumBody(EnumBody<'tree>),
11779 EnumBodyDeclarations(EnumBodyDeclarations<'tree>),
11780 EnumConstant(EnumConstant<'tree>),
11781 EnumDeclaration(EnumDeclaration<'tree>),
11782 ExplicitConstructorInvocation(ExplicitConstructorInvocation<'tree>),
11783 ExportsModuleDirective(ExportsModuleDirective<'tree>),
11784 ExpressionStatement(ExpressionStatement<'tree>),
11785 ExtendsInterfaces(ExtendsInterfaces<'tree>),
11786 FieldAccess(FieldAccess<'tree>),
11787 FieldDeclaration(FieldDeclaration<'tree>),
11788 FinallyClause(FinallyClause<'tree>),
11789 FloatingPointType(FloatingPointType<'tree>),
11790 ForStatement(ForStatement<'tree>),
11791 FormalParameter(FormalParameter<'tree>),
11792 FormalParameters(FormalParameters<'tree>),
11793 GenericType(GenericType<'tree>),
11794 Guard(Guard<'tree>),
11795 IfStatement(IfStatement<'tree>),
11796 ImportDeclaration(ImportDeclaration<'tree>),
11797 InferredParameters(InferredParameters<'tree>),
11798 InstanceofExpression(InstanceofExpression<'tree>),
11799 IntegralType(IntegralType<'tree>),
11800 InterfaceBody(InterfaceBody<'tree>),
11801 InterfaceDeclaration(InterfaceDeclaration<'tree>),
11802 LabeledStatement(LabeledStatement<'tree>),
11803 LambdaExpression(LambdaExpression<'tree>),
11804 LocalVariableDeclaration(LocalVariableDeclaration<'tree>),
11805 MarkerAnnotation(MarkerAnnotation<'tree>),
11806 MethodDeclaration(MethodDeclaration<'tree>),
11807 MethodInvocation(MethodInvocation<'tree>),
11808 MethodReference(MethodReference<'tree>),
11809 Modifiers(Modifiers<'tree>),
11810 ModuleBody(ModuleBody<'tree>),
11811 ModuleDeclaration(ModuleDeclaration<'tree>),
11812 MultilineStringFragment(MultilineStringFragment<'tree>),
11813 ObjectCreationExpression(ObjectCreationExpression<'tree>),
11814 OpensModuleDirective(OpensModuleDirective<'tree>),
11815 PackageDeclaration(PackageDeclaration<'tree>),
11816 ParenthesizedExpression(ParenthesizedExpression<'tree>),
11817 Pattern(Pattern<'tree>),
11818 Permits(Permits<'tree>),
11819 Program(Program<'tree>),
11820 ProvidesModuleDirective(ProvidesModuleDirective<'tree>),
11821 ReceiverParameter(ReceiverParameter<'tree>),
11822 RecordDeclaration(RecordDeclaration<'tree>),
11823 RecordPattern(RecordPattern<'tree>),
11824 RecordPatternBody(RecordPatternBody<'tree>),
11825 RecordPatternComponent(RecordPatternComponent<'tree>),
11826 RequiresModifier(RequiresModifier<'tree>),
11827 RequiresModuleDirective(RequiresModuleDirective<'tree>),
11828 Resource(Resource<'tree>),
11829 ResourceSpecification(ResourceSpecification<'tree>),
11830 ReturnStatement(ReturnStatement<'tree>),
11831 ScopedIdentifier(ScopedIdentifier<'tree>),
11832 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
11833 SpreadParameter(SpreadParameter<'tree>),
11834 StaticInitializer(StaticInitializer<'tree>),
11835 StringInterpolation(StringInterpolation<'tree>),
11836 StringLiteral(StringLiteral<'tree>),
11837 SuperInterfaces(SuperInterfaces<'tree>),
11838 Superclass(Superclass<'tree>),
11839 SwitchBlock(SwitchBlock<'tree>),
11840 SwitchBlockStatementGroup(SwitchBlockStatementGroup<'tree>),
11841 SwitchExpression(SwitchExpression<'tree>),
11842 SwitchLabel(SwitchLabel<'tree>),
11843 SwitchRule(SwitchRule<'tree>),
11844 SynchronizedStatement(SynchronizedStatement<'tree>),
11845 TemplateExpression(TemplateExpression<'tree>),
11846 TernaryExpression(TernaryExpression<'tree>),
11847 ThrowStatement(ThrowStatement<'tree>),
11848 Throws(Throws<'tree>),
11849 TryStatement(TryStatement<'tree>),
11850 TryWithResourcesStatement(TryWithResourcesStatement<'tree>),
11851 TypeArguments(TypeArguments<'tree>),
11852 TypeBound(TypeBound<'tree>),
11853 TypeList(TypeList<'tree>),
11854 TypeParameter(TypeParameter<'tree>),
11855 TypeParameters(TypeParameters<'tree>),
11856 TypePattern(TypePattern<'tree>),
11857 UnaryExpression(UnaryExpression<'tree>),
11858 UpdateExpression(UpdateExpression<'tree>),
11859 UsesModuleDirective(UsesModuleDirective<'tree>),
11860 VariableDeclarator(VariableDeclarator<'tree>),
11861 WhileStatement(WhileStatement<'tree>),
11862 Wildcard(Wildcard<'tree>),
11863 YieldStatement(YieldStatement<'tree>),
11864 BinaryIntegerLiteral(BinaryIntegerLiteral<'tree>),
11865 BlockComment(BlockComment<'tree>),
11866 BooleanType(BooleanType<'tree>),
11867 CharacterLiteral(CharacterLiteral<'tree>),
11868 DecimalFloatingPointLiteral(DecimalFloatingPointLiteral<'tree>),
11869 DecimalIntegerLiteral(DecimalIntegerLiteral<'tree>),
11870 EscapeSequence(EscapeSequence<'tree>),
11871 False(False<'tree>),
11872 HexFloatingPointLiteral(HexFloatingPointLiteral<'tree>),
11873 HexIntegerLiteral(HexIntegerLiteral<'tree>),
11874 Identifier(Identifier<'tree>),
11875 LineComment(LineComment<'tree>),
11876 NullLiteral(NullLiteral<'tree>),
11877 OctalIntegerLiteral(OctalIntegerLiteral<'tree>),
11878 StringFragment(StringFragment<'tree>),
11879 Super(Super<'tree>),
11880 This(This<'tree>),
11881 True(True<'tree>),
11882 TypeIdentifier(TypeIdentifier<'tree>),
11883 UnderscorePattern(UnderscorePattern<'tree>),
11884 VoidType(VoidType<'tree>),
11885 Unknown(::tree_sitter::Node<'tree>),
11886}
11887impl<'tree> AnyNode<'tree> {
11888 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
11889 match node.kind() {
11890 "_literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
11891 .map(Self::Literal)
11892 .unwrap_or(Self::Unknown(node)),
11893 "_simple_type" => <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
11894 .map(Self::SimpleType)
11895 .unwrap_or(Self::Unknown(node)),
11896 "_type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
11897 .map(Self::Type)
11898 .unwrap_or(Self::Unknown(node)),
11899 "_unannotated_type" => {
11900 <UnannotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11901 .map(Self::UnannotatedType)
11902 .unwrap_or(Self::Unknown(node))
11903 }
11904 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
11905 .map(Self::Declaration)
11906 .unwrap_or(Self::Unknown(node)),
11907 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11908 .map(Self::Expression)
11909 .unwrap_or(Self::Unknown(node)),
11910 "module_directive" => {
11911 <ModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
11912 .map(Self::ModuleDirective)
11913 .unwrap_or(Self::Unknown(node))
11914 }
11915 "primary_expression" => {
11916 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11917 .map(Self::PrimaryExpression)
11918 .unwrap_or(Self::Unknown(node))
11919 }
11920 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11921 .map(Self::Statement)
11922 .unwrap_or(Self::Unknown(node)),
11923 "annotated_type" => {
11924 <AnnotatedType as ::treesitter_types::FromNode>::from_node(node, src)
11925 .map(Self::AnnotatedType)
11926 .unwrap_or(Self::Unknown(node))
11927 }
11928 "annotation" => <Annotation as ::treesitter_types::FromNode>::from_node(node, src)
11929 .map(Self::Annotation)
11930 .unwrap_or(Self::Unknown(node)),
11931 "annotation_argument_list" => {
11932 <AnnotationArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
11933 .map(Self::AnnotationArgumentList)
11934 .unwrap_or(Self::Unknown(node))
11935 }
11936 "annotation_type_body" => {
11937 <AnnotationTypeBody as ::treesitter_types::FromNode>::from_node(node, src)
11938 .map(Self::AnnotationTypeBody)
11939 .unwrap_or(Self::Unknown(node))
11940 }
11941 "annotation_type_declaration" => {
11942 <AnnotationTypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11943 .map(Self::AnnotationTypeDeclaration)
11944 .unwrap_or(Self::Unknown(node))
11945 }
11946 "annotation_type_element_declaration" => {
11947 <AnnotationTypeElementDeclaration as ::treesitter_types::FromNode>::from_node(
11948 node, src,
11949 )
11950 .map(Self::AnnotationTypeElementDeclaration)
11951 .unwrap_or(Self::Unknown(node))
11952 }
11953 "argument_list" => <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
11954 .map(Self::ArgumentList)
11955 .unwrap_or(Self::Unknown(node)),
11956 "array_access" => <ArrayAccess as ::treesitter_types::FromNode>::from_node(node, src)
11957 .map(Self::ArrayAccess)
11958 .unwrap_or(Self::Unknown(node)),
11959 "array_creation_expression" => {
11960 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
11961 .map(Self::ArrayCreationExpression)
11962 .unwrap_or(Self::Unknown(node))
11963 }
11964 "array_initializer" => {
11965 <ArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11966 .map(Self::ArrayInitializer)
11967 .unwrap_or(Self::Unknown(node))
11968 }
11969 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
11970 .map(Self::ArrayType)
11971 .unwrap_or(Self::Unknown(node)),
11972 "assert_statement" => {
11973 <AssertStatement as ::treesitter_types::FromNode>::from_node(node, src)
11974 .map(Self::AssertStatement)
11975 .unwrap_or(Self::Unknown(node))
11976 }
11977 "assignment_expression" => {
11978 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
11979 .map(Self::AssignmentExpression)
11980 .unwrap_or(Self::Unknown(node))
11981 }
11982 "asterisk" => <Asterisk as ::treesitter_types::FromNode>::from_node(node, src)
11983 .map(Self::Asterisk)
11984 .unwrap_or(Self::Unknown(node)),
11985 "binary_expression" => {
11986 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11987 .map(Self::BinaryExpression)
11988 .unwrap_or(Self::Unknown(node))
11989 }
11990 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
11991 .map(Self::Block)
11992 .unwrap_or(Self::Unknown(node)),
11993 "break_statement" => {
11994 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
11995 .map(Self::BreakStatement)
11996 .unwrap_or(Self::Unknown(node))
11997 }
11998 "cast_expression" => {
11999 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
12000 .map(Self::CastExpression)
12001 .unwrap_or(Self::Unknown(node))
12002 }
12003 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
12004 .map(Self::CatchClause)
12005 .unwrap_or(Self::Unknown(node)),
12006 "catch_formal_parameter" => {
12007 <CatchFormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
12008 .map(Self::CatchFormalParameter)
12009 .unwrap_or(Self::Unknown(node))
12010 }
12011 "catch_type" => <CatchType as ::treesitter_types::FromNode>::from_node(node, src)
12012 .map(Self::CatchType)
12013 .unwrap_or(Self::Unknown(node)),
12014 "class_body" => <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
12015 .map(Self::ClassBody)
12016 .unwrap_or(Self::Unknown(node)),
12017 "class_declaration" => {
12018 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12019 .map(Self::ClassDeclaration)
12020 .unwrap_or(Self::Unknown(node))
12021 }
12022 "class_literal" => <ClassLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12023 .map(Self::ClassLiteral)
12024 .unwrap_or(Self::Unknown(node)),
12025 "compact_constructor_declaration" => {
12026 <CompactConstructorDeclaration as ::treesitter_types::FromNode>::from_node(
12027 node, src,
12028 )
12029 .map(Self::CompactConstructorDeclaration)
12030 .unwrap_or(Self::Unknown(node))
12031 }
12032 "constant_declaration" => {
12033 <ConstantDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12034 .map(Self::ConstantDeclaration)
12035 .unwrap_or(Self::Unknown(node))
12036 }
12037 "constructor_body" => {
12038 <ConstructorBody as ::treesitter_types::FromNode>::from_node(node, src)
12039 .map(Self::ConstructorBody)
12040 .unwrap_or(Self::Unknown(node))
12041 }
12042 "constructor_declaration" => {
12043 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12044 .map(Self::ConstructorDeclaration)
12045 .unwrap_or(Self::Unknown(node))
12046 }
12047 "continue_statement" => {
12048 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
12049 .map(Self::ContinueStatement)
12050 .unwrap_or(Self::Unknown(node))
12051 }
12052 "dimensions" => <Dimensions as ::treesitter_types::FromNode>::from_node(node, src)
12053 .map(Self::Dimensions)
12054 .unwrap_or(Self::Unknown(node)),
12055 "dimensions_expr" => {
12056 <DimensionsExpr as ::treesitter_types::FromNode>::from_node(node, src)
12057 .map(Self::DimensionsExpr)
12058 .unwrap_or(Self::Unknown(node))
12059 }
12060 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
12061 .map(Self::DoStatement)
12062 .unwrap_or(Self::Unknown(node)),
12063 "element_value_array_initializer" => {
12064 <ElementValueArrayInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12065 .map(Self::ElementValueArrayInitializer)
12066 .unwrap_or(Self::Unknown(node))
12067 }
12068 "element_value_pair" => {
12069 <ElementValuePair as ::treesitter_types::FromNode>::from_node(node, src)
12070 .map(Self::ElementValuePair)
12071 .unwrap_or(Self::Unknown(node))
12072 }
12073 "enhanced_for_statement" => {
12074 <EnhancedForStatement as ::treesitter_types::FromNode>::from_node(node, src)
12075 .map(Self::EnhancedForStatement)
12076 .unwrap_or(Self::Unknown(node))
12077 }
12078 "enum_body" => <EnumBody as ::treesitter_types::FromNode>::from_node(node, src)
12079 .map(Self::EnumBody)
12080 .unwrap_or(Self::Unknown(node)),
12081 "enum_body_declarations" => {
12082 <EnumBodyDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
12083 .map(Self::EnumBodyDeclarations)
12084 .unwrap_or(Self::Unknown(node))
12085 }
12086 "enum_constant" => <EnumConstant as ::treesitter_types::FromNode>::from_node(node, src)
12087 .map(Self::EnumConstant)
12088 .unwrap_or(Self::Unknown(node)),
12089 "enum_declaration" => {
12090 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12091 .map(Self::EnumDeclaration)
12092 .unwrap_or(Self::Unknown(node))
12093 }
12094 "explicit_constructor_invocation" => {
12095 <ExplicitConstructorInvocation as ::treesitter_types::FromNode>::from_node(
12096 node, src,
12097 )
12098 .map(Self::ExplicitConstructorInvocation)
12099 .unwrap_or(Self::Unknown(node))
12100 }
12101 "exports_module_directive" => {
12102 <ExportsModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12103 .map(Self::ExportsModuleDirective)
12104 .unwrap_or(Self::Unknown(node))
12105 }
12106 "expression_statement" => {
12107 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
12108 .map(Self::ExpressionStatement)
12109 .unwrap_or(Self::Unknown(node))
12110 }
12111 "extends_interfaces" => {
12112 <ExtendsInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
12113 .map(Self::ExtendsInterfaces)
12114 .unwrap_or(Self::Unknown(node))
12115 }
12116 "field_access" => <FieldAccess as ::treesitter_types::FromNode>::from_node(node, src)
12117 .map(Self::FieldAccess)
12118 .unwrap_or(Self::Unknown(node)),
12119 "field_declaration" => {
12120 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12121 .map(Self::FieldDeclaration)
12122 .unwrap_or(Self::Unknown(node))
12123 }
12124 "finally_clause" => {
12125 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
12126 .map(Self::FinallyClause)
12127 .unwrap_or(Self::Unknown(node))
12128 }
12129 "floating_point_type" => {
12130 <FloatingPointType as ::treesitter_types::FromNode>::from_node(node, src)
12131 .map(Self::FloatingPointType)
12132 .unwrap_or(Self::Unknown(node))
12133 }
12134 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
12135 .map(Self::ForStatement)
12136 .unwrap_or(Self::Unknown(node)),
12137 "formal_parameter" => {
12138 <FormalParameter as ::treesitter_types::FromNode>::from_node(node, src)
12139 .map(Self::FormalParameter)
12140 .unwrap_or(Self::Unknown(node))
12141 }
12142 "formal_parameters" => {
12143 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
12144 .map(Self::FormalParameters)
12145 .unwrap_or(Self::Unknown(node))
12146 }
12147 "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
12148 .map(Self::GenericType)
12149 .unwrap_or(Self::Unknown(node)),
12150 "guard" => <Guard as ::treesitter_types::FromNode>::from_node(node, src)
12151 .map(Self::Guard)
12152 .unwrap_or(Self::Unknown(node)),
12153 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
12154 .map(Self::IfStatement)
12155 .unwrap_or(Self::Unknown(node)),
12156 "import_declaration" => {
12157 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12158 .map(Self::ImportDeclaration)
12159 .unwrap_or(Self::Unknown(node))
12160 }
12161 "inferred_parameters" => {
12162 <InferredParameters as ::treesitter_types::FromNode>::from_node(node, src)
12163 .map(Self::InferredParameters)
12164 .unwrap_or(Self::Unknown(node))
12165 }
12166 "instanceof_expression" => {
12167 <InstanceofExpression as ::treesitter_types::FromNode>::from_node(node, src)
12168 .map(Self::InstanceofExpression)
12169 .unwrap_or(Self::Unknown(node))
12170 }
12171 "integral_type" => <IntegralType as ::treesitter_types::FromNode>::from_node(node, src)
12172 .map(Self::IntegralType)
12173 .unwrap_or(Self::Unknown(node)),
12174 "interface_body" => {
12175 <InterfaceBody as ::treesitter_types::FromNode>::from_node(node, src)
12176 .map(Self::InterfaceBody)
12177 .unwrap_or(Self::Unknown(node))
12178 }
12179 "interface_declaration" => {
12180 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12181 .map(Self::InterfaceDeclaration)
12182 .unwrap_or(Self::Unknown(node))
12183 }
12184 "labeled_statement" => {
12185 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
12186 .map(Self::LabeledStatement)
12187 .unwrap_or(Self::Unknown(node))
12188 }
12189 "lambda_expression" => {
12190 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
12191 .map(Self::LambdaExpression)
12192 .unwrap_or(Self::Unknown(node))
12193 }
12194 "local_variable_declaration" => {
12195 <LocalVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12196 .map(Self::LocalVariableDeclaration)
12197 .unwrap_or(Self::Unknown(node))
12198 }
12199 "marker_annotation" => {
12200 <MarkerAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
12201 .map(Self::MarkerAnnotation)
12202 .unwrap_or(Self::Unknown(node))
12203 }
12204 "method_declaration" => {
12205 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12206 .map(Self::MethodDeclaration)
12207 .unwrap_or(Self::Unknown(node))
12208 }
12209 "method_invocation" => {
12210 <MethodInvocation as ::treesitter_types::FromNode>::from_node(node, src)
12211 .map(Self::MethodInvocation)
12212 .unwrap_or(Self::Unknown(node))
12213 }
12214 "method_reference" => {
12215 <MethodReference as ::treesitter_types::FromNode>::from_node(node, src)
12216 .map(Self::MethodReference)
12217 .unwrap_or(Self::Unknown(node))
12218 }
12219 "modifiers" => <Modifiers as ::treesitter_types::FromNode>::from_node(node, src)
12220 .map(Self::Modifiers)
12221 .unwrap_or(Self::Unknown(node)),
12222 "module_body" => <ModuleBody as ::treesitter_types::FromNode>::from_node(node, src)
12223 .map(Self::ModuleBody)
12224 .unwrap_or(Self::Unknown(node)),
12225 "module_declaration" => {
12226 <ModuleDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12227 .map(Self::ModuleDeclaration)
12228 .unwrap_or(Self::Unknown(node))
12229 }
12230 "multiline_string_fragment" => {
12231 <MultilineStringFragment as ::treesitter_types::FromNode>::from_node(node, src)
12232 .map(Self::MultilineStringFragment)
12233 .unwrap_or(Self::Unknown(node))
12234 }
12235 "object_creation_expression" => {
12236 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12237 .map(Self::ObjectCreationExpression)
12238 .unwrap_or(Self::Unknown(node))
12239 }
12240 "opens_module_directive" => {
12241 <OpensModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12242 .map(Self::OpensModuleDirective)
12243 .unwrap_or(Self::Unknown(node))
12244 }
12245 "package_declaration" => {
12246 <PackageDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12247 .map(Self::PackageDeclaration)
12248 .unwrap_or(Self::Unknown(node))
12249 }
12250 "parenthesized_expression" => {
12251 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
12252 .map(Self::ParenthesizedExpression)
12253 .unwrap_or(Self::Unknown(node))
12254 }
12255 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12256 .map(Self::Pattern)
12257 .unwrap_or(Self::Unknown(node)),
12258 "permits" => <Permits as ::treesitter_types::FromNode>::from_node(node, src)
12259 .map(Self::Permits)
12260 .unwrap_or(Self::Unknown(node)),
12261 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
12262 .map(Self::Program)
12263 .unwrap_or(Self::Unknown(node)),
12264 "provides_module_directive" => {
12265 <ProvidesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12266 .map(Self::ProvidesModuleDirective)
12267 .unwrap_or(Self::Unknown(node))
12268 }
12269 "receiver_parameter" => {
12270 <ReceiverParameter as ::treesitter_types::FromNode>::from_node(node, src)
12271 .map(Self::ReceiverParameter)
12272 .unwrap_or(Self::Unknown(node))
12273 }
12274 "record_declaration" => {
12275 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12276 .map(Self::RecordDeclaration)
12277 .unwrap_or(Self::Unknown(node))
12278 }
12279 "record_pattern" => {
12280 <RecordPattern as ::treesitter_types::FromNode>::from_node(node, src)
12281 .map(Self::RecordPattern)
12282 .unwrap_or(Self::Unknown(node))
12283 }
12284 "record_pattern_body" => {
12285 <RecordPatternBody as ::treesitter_types::FromNode>::from_node(node, src)
12286 .map(Self::RecordPatternBody)
12287 .unwrap_or(Self::Unknown(node))
12288 }
12289 "record_pattern_component" => {
12290 <RecordPatternComponent as ::treesitter_types::FromNode>::from_node(node, src)
12291 .map(Self::RecordPatternComponent)
12292 .unwrap_or(Self::Unknown(node))
12293 }
12294 "requires_modifier" => {
12295 <RequiresModifier as ::treesitter_types::FromNode>::from_node(node, src)
12296 .map(Self::RequiresModifier)
12297 .unwrap_or(Self::Unknown(node))
12298 }
12299 "requires_module_directive" => {
12300 <RequiresModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12301 .map(Self::RequiresModuleDirective)
12302 .unwrap_or(Self::Unknown(node))
12303 }
12304 "resource" => <Resource as ::treesitter_types::FromNode>::from_node(node, src)
12305 .map(Self::Resource)
12306 .unwrap_or(Self::Unknown(node)),
12307 "resource_specification" => {
12308 <ResourceSpecification as ::treesitter_types::FromNode>::from_node(node, src)
12309 .map(Self::ResourceSpecification)
12310 .unwrap_or(Self::Unknown(node))
12311 }
12312 "return_statement" => {
12313 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
12314 .map(Self::ReturnStatement)
12315 .unwrap_or(Self::Unknown(node))
12316 }
12317 "scoped_identifier" => {
12318 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12319 .map(Self::ScopedIdentifier)
12320 .unwrap_or(Self::Unknown(node))
12321 }
12322 "scoped_type_identifier" => {
12323 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12324 .map(Self::ScopedTypeIdentifier)
12325 .unwrap_or(Self::Unknown(node))
12326 }
12327 "spread_parameter" => {
12328 <SpreadParameter as ::treesitter_types::FromNode>::from_node(node, src)
12329 .map(Self::SpreadParameter)
12330 .unwrap_or(Self::Unknown(node))
12331 }
12332 "static_initializer" => {
12333 <StaticInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12334 .map(Self::StaticInitializer)
12335 .unwrap_or(Self::Unknown(node))
12336 }
12337 "string_interpolation" => {
12338 <StringInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
12339 .map(Self::StringInterpolation)
12340 .unwrap_or(Self::Unknown(node))
12341 }
12342 "string_literal" => {
12343 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12344 .map(Self::StringLiteral)
12345 .unwrap_or(Self::Unknown(node))
12346 }
12347 "super_interfaces" => {
12348 <SuperInterfaces as ::treesitter_types::FromNode>::from_node(node, src)
12349 .map(Self::SuperInterfaces)
12350 .unwrap_or(Self::Unknown(node))
12351 }
12352 "superclass" => <Superclass as ::treesitter_types::FromNode>::from_node(node, src)
12353 .map(Self::Superclass)
12354 .unwrap_or(Self::Unknown(node)),
12355 "switch_block" => <SwitchBlock as ::treesitter_types::FromNode>::from_node(node, src)
12356 .map(Self::SwitchBlock)
12357 .unwrap_or(Self::Unknown(node)),
12358 "switch_block_statement_group" => {
12359 <SwitchBlockStatementGroup as ::treesitter_types::FromNode>::from_node(node, src)
12360 .map(Self::SwitchBlockStatementGroup)
12361 .unwrap_or(Self::Unknown(node))
12362 }
12363 "switch_expression" => {
12364 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
12365 .map(Self::SwitchExpression)
12366 .unwrap_or(Self::Unknown(node))
12367 }
12368 "switch_label" => <SwitchLabel as ::treesitter_types::FromNode>::from_node(node, src)
12369 .map(Self::SwitchLabel)
12370 .unwrap_or(Self::Unknown(node)),
12371 "switch_rule" => <SwitchRule as ::treesitter_types::FromNode>::from_node(node, src)
12372 .map(Self::SwitchRule)
12373 .unwrap_or(Self::Unknown(node)),
12374 "synchronized_statement" => {
12375 <SynchronizedStatement as ::treesitter_types::FromNode>::from_node(node, src)
12376 .map(Self::SynchronizedStatement)
12377 .unwrap_or(Self::Unknown(node))
12378 }
12379 "template_expression" => {
12380 <TemplateExpression as ::treesitter_types::FromNode>::from_node(node, src)
12381 .map(Self::TemplateExpression)
12382 .unwrap_or(Self::Unknown(node))
12383 }
12384 "ternary_expression" => {
12385 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12386 .map(Self::TernaryExpression)
12387 .unwrap_or(Self::Unknown(node))
12388 }
12389 "throw_statement" => {
12390 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
12391 .map(Self::ThrowStatement)
12392 .unwrap_or(Self::Unknown(node))
12393 }
12394 "throws" => <Throws as ::treesitter_types::FromNode>::from_node(node, src)
12395 .map(Self::Throws)
12396 .unwrap_or(Self::Unknown(node)),
12397 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
12398 .map(Self::TryStatement)
12399 .unwrap_or(Self::Unknown(node)),
12400 "try_with_resources_statement" => {
12401 <TryWithResourcesStatement as ::treesitter_types::FromNode>::from_node(node, src)
12402 .map(Self::TryWithResourcesStatement)
12403 .unwrap_or(Self::Unknown(node))
12404 }
12405 "type_arguments" => {
12406 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
12407 .map(Self::TypeArguments)
12408 .unwrap_or(Self::Unknown(node))
12409 }
12410 "type_bound" => <TypeBound as ::treesitter_types::FromNode>::from_node(node, src)
12411 .map(Self::TypeBound)
12412 .unwrap_or(Self::Unknown(node)),
12413 "type_list" => <TypeList as ::treesitter_types::FromNode>::from_node(node, src)
12414 .map(Self::TypeList)
12415 .unwrap_or(Self::Unknown(node)),
12416 "type_parameter" => {
12417 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
12418 .map(Self::TypeParameter)
12419 .unwrap_or(Self::Unknown(node))
12420 }
12421 "type_parameters" => {
12422 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
12423 .map(Self::TypeParameters)
12424 .unwrap_or(Self::Unknown(node))
12425 }
12426 "type_pattern" => <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
12427 .map(Self::TypePattern)
12428 .unwrap_or(Self::Unknown(node)),
12429 "unary_expression" => {
12430 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12431 .map(Self::UnaryExpression)
12432 .unwrap_or(Self::Unknown(node))
12433 }
12434 "update_expression" => {
12435 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
12436 .map(Self::UpdateExpression)
12437 .unwrap_or(Self::Unknown(node))
12438 }
12439 "uses_module_directive" => {
12440 <UsesModuleDirective as ::treesitter_types::FromNode>::from_node(node, src)
12441 .map(Self::UsesModuleDirective)
12442 .unwrap_or(Self::Unknown(node))
12443 }
12444 "variable_declarator" => {
12445 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12446 .map(Self::VariableDeclarator)
12447 .unwrap_or(Self::Unknown(node))
12448 }
12449 "while_statement" => {
12450 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
12451 .map(Self::WhileStatement)
12452 .unwrap_or(Self::Unknown(node))
12453 }
12454 "wildcard" => <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
12455 .map(Self::Wildcard)
12456 .unwrap_or(Self::Unknown(node)),
12457 "yield_statement" => {
12458 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
12459 .map(Self::YieldStatement)
12460 .unwrap_or(Self::Unknown(node))
12461 }
12462 "binary_integer_literal" => {
12463 <BinaryIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12464 .map(Self::BinaryIntegerLiteral)
12465 .unwrap_or(Self::Unknown(node))
12466 }
12467 "block_comment" => <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
12468 .map(Self::BlockComment)
12469 .unwrap_or(Self::Unknown(node)),
12470 "boolean_type" => <BooleanType as ::treesitter_types::FromNode>::from_node(node, src)
12471 .map(Self::BooleanType)
12472 .unwrap_or(Self::Unknown(node)),
12473 "character_literal" => {
12474 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12475 .map(Self::CharacterLiteral)
12476 .unwrap_or(Self::Unknown(node))
12477 }
12478 "decimal_floating_point_literal" => {
12479 <DecimalFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12480 .map(Self::DecimalFloatingPointLiteral)
12481 .unwrap_or(Self::Unknown(node))
12482 }
12483 "decimal_integer_literal" => {
12484 <DecimalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12485 .map(Self::DecimalIntegerLiteral)
12486 .unwrap_or(Self::Unknown(node))
12487 }
12488 "escape_sequence" => {
12489 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
12490 .map(Self::EscapeSequence)
12491 .unwrap_or(Self::Unknown(node))
12492 }
12493 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
12494 .map(Self::False)
12495 .unwrap_or(Self::Unknown(node)),
12496 "hex_floating_point_literal" => {
12497 <HexFloatingPointLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12498 .map(Self::HexFloatingPointLiteral)
12499 .unwrap_or(Self::Unknown(node))
12500 }
12501 "hex_integer_literal" => {
12502 <HexIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12503 .map(Self::HexIntegerLiteral)
12504 .unwrap_or(Self::Unknown(node))
12505 }
12506 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12507 .map(Self::Identifier)
12508 .unwrap_or(Self::Unknown(node)),
12509 "line_comment" => <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
12510 .map(Self::LineComment)
12511 .unwrap_or(Self::Unknown(node)),
12512 "null_literal" => <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12513 .map(Self::NullLiteral)
12514 .unwrap_or(Self::Unknown(node)),
12515 "octal_integer_literal" => {
12516 <OctalIntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12517 .map(Self::OctalIntegerLiteral)
12518 .unwrap_or(Self::Unknown(node))
12519 }
12520 "string_fragment" => {
12521 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
12522 .map(Self::StringFragment)
12523 .unwrap_or(Self::Unknown(node))
12524 }
12525 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
12526 .map(Self::Super)
12527 .unwrap_or(Self::Unknown(node)),
12528 "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
12529 .map(Self::This)
12530 .unwrap_or(Self::Unknown(node)),
12531 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
12532 .map(Self::True)
12533 .unwrap_or(Self::Unknown(node)),
12534 "type_identifier" => {
12535 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12536 .map(Self::TypeIdentifier)
12537 .unwrap_or(Self::Unknown(node))
12538 }
12539 "underscore_pattern" => {
12540 <UnderscorePattern as ::treesitter_types::FromNode>::from_node(node, src)
12541 .map(Self::UnderscorePattern)
12542 .unwrap_or(Self::Unknown(node))
12543 }
12544 "void_type" => <VoidType as ::treesitter_types::FromNode>::from_node(node, src)
12545 .map(Self::VoidType)
12546 .unwrap_or(Self::Unknown(node)),
12547 _ => Self::Unknown(node),
12548 }
12549 }
12550}
12551impl ::treesitter_types::Spanned for AnyNode<'_> {
12552 fn span(&self) -> ::treesitter_types::Span {
12553 match self {
12554 Self::Literal(inner) => inner.span(),
12555 Self::SimpleType(inner) => inner.span(),
12556 Self::Type(inner) => inner.span(),
12557 Self::UnannotatedType(inner) => inner.span(),
12558 Self::Declaration(inner) => inner.span(),
12559 Self::Expression(inner) => inner.span(),
12560 Self::ModuleDirective(inner) => inner.span(),
12561 Self::PrimaryExpression(inner) => inner.span(),
12562 Self::Statement(inner) => inner.span(),
12563 Self::AnnotatedType(inner) => inner.span(),
12564 Self::Annotation(inner) => inner.span(),
12565 Self::AnnotationArgumentList(inner) => inner.span(),
12566 Self::AnnotationTypeBody(inner) => inner.span(),
12567 Self::AnnotationTypeDeclaration(inner) => inner.span(),
12568 Self::AnnotationTypeElementDeclaration(inner) => inner.span(),
12569 Self::ArgumentList(inner) => inner.span(),
12570 Self::ArrayAccess(inner) => inner.span(),
12571 Self::ArrayCreationExpression(inner) => inner.span(),
12572 Self::ArrayInitializer(inner) => inner.span(),
12573 Self::ArrayType(inner) => inner.span(),
12574 Self::AssertStatement(inner) => inner.span(),
12575 Self::AssignmentExpression(inner) => inner.span(),
12576 Self::Asterisk(inner) => inner.span(),
12577 Self::BinaryExpression(inner) => inner.span(),
12578 Self::Block(inner) => inner.span(),
12579 Self::BreakStatement(inner) => inner.span(),
12580 Self::CastExpression(inner) => inner.span(),
12581 Self::CatchClause(inner) => inner.span(),
12582 Self::CatchFormalParameter(inner) => inner.span(),
12583 Self::CatchType(inner) => inner.span(),
12584 Self::ClassBody(inner) => inner.span(),
12585 Self::ClassDeclaration(inner) => inner.span(),
12586 Self::ClassLiteral(inner) => inner.span(),
12587 Self::CompactConstructorDeclaration(inner) => inner.span(),
12588 Self::ConstantDeclaration(inner) => inner.span(),
12589 Self::ConstructorBody(inner) => inner.span(),
12590 Self::ConstructorDeclaration(inner) => inner.span(),
12591 Self::ContinueStatement(inner) => inner.span(),
12592 Self::Dimensions(inner) => inner.span(),
12593 Self::DimensionsExpr(inner) => inner.span(),
12594 Self::DoStatement(inner) => inner.span(),
12595 Self::ElementValueArrayInitializer(inner) => inner.span(),
12596 Self::ElementValuePair(inner) => inner.span(),
12597 Self::EnhancedForStatement(inner) => inner.span(),
12598 Self::EnumBody(inner) => inner.span(),
12599 Self::EnumBodyDeclarations(inner) => inner.span(),
12600 Self::EnumConstant(inner) => inner.span(),
12601 Self::EnumDeclaration(inner) => inner.span(),
12602 Self::ExplicitConstructorInvocation(inner) => inner.span(),
12603 Self::ExportsModuleDirective(inner) => inner.span(),
12604 Self::ExpressionStatement(inner) => inner.span(),
12605 Self::ExtendsInterfaces(inner) => inner.span(),
12606 Self::FieldAccess(inner) => inner.span(),
12607 Self::FieldDeclaration(inner) => inner.span(),
12608 Self::FinallyClause(inner) => inner.span(),
12609 Self::FloatingPointType(inner) => inner.span(),
12610 Self::ForStatement(inner) => inner.span(),
12611 Self::FormalParameter(inner) => inner.span(),
12612 Self::FormalParameters(inner) => inner.span(),
12613 Self::GenericType(inner) => inner.span(),
12614 Self::Guard(inner) => inner.span(),
12615 Self::IfStatement(inner) => inner.span(),
12616 Self::ImportDeclaration(inner) => inner.span(),
12617 Self::InferredParameters(inner) => inner.span(),
12618 Self::InstanceofExpression(inner) => inner.span(),
12619 Self::IntegralType(inner) => inner.span(),
12620 Self::InterfaceBody(inner) => inner.span(),
12621 Self::InterfaceDeclaration(inner) => inner.span(),
12622 Self::LabeledStatement(inner) => inner.span(),
12623 Self::LambdaExpression(inner) => inner.span(),
12624 Self::LocalVariableDeclaration(inner) => inner.span(),
12625 Self::MarkerAnnotation(inner) => inner.span(),
12626 Self::MethodDeclaration(inner) => inner.span(),
12627 Self::MethodInvocation(inner) => inner.span(),
12628 Self::MethodReference(inner) => inner.span(),
12629 Self::Modifiers(inner) => inner.span(),
12630 Self::ModuleBody(inner) => inner.span(),
12631 Self::ModuleDeclaration(inner) => inner.span(),
12632 Self::MultilineStringFragment(inner) => inner.span(),
12633 Self::ObjectCreationExpression(inner) => inner.span(),
12634 Self::OpensModuleDirective(inner) => inner.span(),
12635 Self::PackageDeclaration(inner) => inner.span(),
12636 Self::ParenthesizedExpression(inner) => inner.span(),
12637 Self::Pattern(inner) => inner.span(),
12638 Self::Permits(inner) => inner.span(),
12639 Self::Program(inner) => inner.span(),
12640 Self::ProvidesModuleDirective(inner) => inner.span(),
12641 Self::ReceiverParameter(inner) => inner.span(),
12642 Self::RecordDeclaration(inner) => inner.span(),
12643 Self::RecordPattern(inner) => inner.span(),
12644 Self::RecordPatternBody(inner) => inner.span(),
12645 Self::RecordPatternComponent(inner) => inner.span(),
12646 Self::RequiresModifier(inner) => inner.span(),
12647 Self::RequiresModuleDirective(inner) => inner.span(),
12648 Self::Resource(inner) => inner.span(),
12649 Self::ResourceSpecification(inner) => inner.span(),
12650 Self::ReturnStatement(inner) => inner.span(),
12651 Self::ScopedIdentifier(inner) => inner.span(),
12652 Self::ScopedTypeIdentifier(inner) => inner.span(),
12653 Self::SpreadParameter(inner) => inner.span(),
12654 Self::StaticInitializer(inner) => inner.span(),
12655 Self::StringInterpolation(inner) => inner.span(),
12656 Self::StringLiteral(inner) => inner.span(),
12657 Self::SuperInterfaces(inner) => inner.span(),
12658 Self::Superclass(inner) => inner.span(),
12659 Self::SwitchBlock(inner) => inner.span(),
12660 Self::SwitchBlockStatementGroup(inner) => inner.span(),
12661 Self::SwitchExpression(inner) => inner.span(),
12662 Self::SwitchLabel(inner) => inner.span(),
12663 Self::SwitchRule(inner) => inner.span(),
12664 Self::SynchronizedStatement(inner) => inner.span(),
12665 Self::TemplateExpression(inner) => inner.span(),
12666 Self::TernaryExpression(inner) => inner.span(),
12667 Self::ThrowStatement(inner) => inner.span(),
12668 Self::Throws(inner) => inner.span(),
12669 Self::TryStatement(inner) => inner.span(),
12670 Self::TryWithResourcesStatement(inner) => inner.span(),
12671 Self::TypeArguments(inner) => inner.span(),
12672 Self::TypeBound(inner) => inner.span(),
12673 Self::TypeList(inner) => inner.span(),
12674 Self::TypeParameter(inner) => inner.span(),
12675 Self::TypeParameters(inner) => inner.span(),
12676 Self::TypePattern(inner) => inner.span(),
12677 Self::UnaryExpression(inner) => inner.span(),
12678 Self::UpdateExpression(inner) => inner.span(),
12679 Self::UsesModuleDirective(inner) => inner.span(),
12680 Self::VariableDeclarator(inner) => inner.span(),
12681 Self::WhileStatement(inner) => inner.span(),
12682 Self::Wildcard(inner) => inner.span(),
12683 Self::YieldStatement(inner) => inner.span(),
12684 Self::BinaryIntegerLiteral(inner) => inner.span(),
12685 Self::BlockComment(inner) => inner.span(),
12686 Self::BooleanType(inner) => inner.span(),
12687 Self::CharacterLiteral(inner) => inner.span(),
12688 Self::DecimalFloatingPointLiteral(inner) => inner.span(),
12689 Self::DecimalIntegerLiteral(inner) => inner.span(),
12690 Self::EscapeSequence(inner) => inner.span(),
12691 Self::False(inner) => inner.span(),
12692 Self::HexFloatingPointLiteral(inner) => inner.span(),
12693 Self::HexIntegerLiteral(inner) => inner.span(),
12694 Self::Identifier(inner) => inner.span(),
12695 Self::LineComment(inner) => inner.span(),
12696 Self::NullLiteral(inner) => inner.span(),
12697 Self::OctalIntegerLiteral(inner) => inner.span(),
12698 Self::StringFragment(inner) => inner.span(),
12699 Self::Super(inner) => inner.span(),
12700 Self::This(inner) => inner.span(),
12701 Self::True(inner) => inner.span(),
12702 Self::TypeIdentifier(inner) => inner.span(),
12703 Self::UnderscorePattern(inner) => inner.span(),
12704 Self::VoidType(inner) => inner.span(),
12705 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
12706 }
12707 }
12708}