1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Declaration<'tree> {
3 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
4 ConstructorDeclaration(::std::boxed::Box<ConstructorDeclaration<'tree>>),
5 ConversionOperatorDeclaration(::std::boxed::Box<ConversionOperatorDeclaration<'tree>>),
6 DelegateDeclaration(::std::boxed::Box<DelegateDeclaration<'tree>>),
7 DestructorDeclaration(::std::boxed::Box<DestructorDeclaration<'tree>>),
8 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
9 EventDeclaration(::std::boxed::Box<EventDeclaration<'tree>>),
10 EventFieldDeclaration(::std::boxed::Box<EventFieldDeclaration<'tree>>),
11 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
12 IndexerDeclaration(::std::boxed::Box<IndexerDeclaration<'tree>>),
13 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
14 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
15 NamespaceDeclaration(::std::boxed::Box<NamespaceDeclaration<'tree>>),
16 OperatorDeclaration(::std::boxed::Box<OperatorDeclaration<'tree>>),
17 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
18 PropertyDeclaration(::std::boxed::Box<PropertyDeclaration<'tree>>),
19 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
20 StructDeclaration(::std::boxed::Box<StructDeclaration<'tree>>),
21 UsingDirective(::std::boxed::Box<UsingDirective<'tree>>),
22}
23impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
24 #[allow(clippy::collapsible_else_if)]
25 fn from_node(
26 node: ::tree_sitter::Node<'tree>,
27 src: &'tree [u8],
28 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
29 match node.kind() {
30 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
31 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
32 ))),
33 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
34 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
35 ))),
36 "conversion_operator_declaration" => {
37 Ok(Self::ConversionOperatorDeclaration(::std::boxed::Box::new(
38 <ConversionOperatorDeclaration as ::treesitter_types::FromNode>::from_node(
39 node, src,
40 )?,
41 )))
42 }
43 "delegate_declaration" => Ok(Self::DelegateDeclaration(::std::boxed::Box::new(
44 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
45 ))),
46 "destructor_declaration" => Ok(Self::DestructorDeclaration(::std::boxed::Box::new(
47 <DestructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
48 ))),
49 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
50 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
51 ))),
52 "event_declaration" => Ok(Self::EventDeclaration(::std::boxed::Box::new(
53 <EventDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
54 ))),
55 "event_field_declaration" => Ok(Self::EventFieldDeclaration(::std::boxed::Box::new(
56 <EventFieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
57 ))),
58 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
59 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
60 ))),
61 "indexer_declaration" => Ok(Self::IndexerDeclaration(::std::boxed::Box::new(
62 <IndexerDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
63 ))),
64 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
65 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
66 ))),
67 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
68 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
69 ))),
70 "namespace_declaration" => Ok(Self::NamespaceDeclaration(::std::boxed::Box::new(
71 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
72 ))),
73 "operator_declaration" => Ok(Self::OperatorDeclaration(::std::boxed::Box::new(
74 <OperatorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
75 ))),
76 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
77 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
78 ))),
79 "property_declaration" => Ok(Self::PropertyDeclaration(::std::boxed::Box::new(
80 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
81 ))),
82 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
83 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
84 ))),
85 "struct_declaration" => Ok(Self::StructDeclaration(::std::boxed::Box::new(
86 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
87 ))),
88 "using_directive" => Ok(Self::UsingDirective(::std::boxed::Box::new(
89 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
90 ))),
91 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
92 }
93 }
94}
95impl ::treesitter_types::Spanned for Declaration<'_> {
96 fn span(&self) -> ::treesitter_types::Span {
97 match self {
98 Self::ClassDeclaration(inner) => inner.span(),
99 Self::ConstructorDeclaration(inner) => inner.span(),
100 Self::ConversionOperatorDeclaration(inner) => inner.span(),
101 Self::DelegateDeclaration(inner) => inner.span(),
102 Self::DestructorDeclaration(inner) => inner.span(),
103 Self::EnumDeclaration(inner) => inner.span(),
104 Self::EventDeclaration(inner) => inner.span(),
105 Self::EventFieldDeclaration(inner) => inner.span(),
106 Self::FieldDeclaration(inner) => inner.span(),
107 Self::IndexerDeclaration(inner) => inner.span(),
108 Self::InterfaceDeclaration(inner) => inner.span(),
109 Self::MethodDeclaration(inner) => inner.span(),
110 Self::NamespaceDeclaration(inner) => inner.span(),
111 Self::OperatorDeclaration(inner) => inner.span(),
112 Self::PreprocIf(inner) => inner.span(),
113 Self::PropertyDeclaration(inner) => inner.span(),
114 Self::RecordDeclaration(inner) => inner.span(),
115 Self::StructDeclaration(inner) => inner.span(),
116 Self::UsingDirective(inner) => inner.span(),
117 }
118 }
119}
120#[derive(Debug, Clone, PartialEq, Eq)]
121pub enum Expression<'tree> {
122 LvalueExpression(::std::boxed::Box<LvalueExpression<'tree>>),
123 NonLvalueExpression(::std::boxed::Box<NonLvalueExpression<'tree>>),
124}
125impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
126 #[allow(clippy::collapsible_else_if)]
127 fn from_node(
128 node: ::tree_sitter::Node<'tree>,
129 src: &'tree [u8],
130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
131 if let Ok(v) = <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src) {
132 Ok(Self::LvalueExpression(::std::boxed::Box::new(v)))
133 } else {
134 if let Ok(v) =
135 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
136 {
137 Ok(Self::NonLvalueExpression(::std::boxed::Box::new(v)))
138 } else {
139 Err(::treesitter_types::ParseError::unexpected_kind(
140 node.kind(),
141 node,
142 ))
143 }
144 }
145 }
146}
147impl ::treesitter_types::Spanned for Expression<'_> {
148 fn span(&self) -> ::treesitter_types::Span {
149 match self {
150 Self::LvalueExpression(inner) => inner.span(),
151 Self::NonLvalueExpression(inner) => inner.span(),
152 }
153 }
154}
155#[derive(Debug, Clone, PartialEq, Eq)]
156pub enum Literal<'tree> {
157 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
158 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
159 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
160 NullLiteral(::std::boxed::Box<NullLiteral<'tree>>),
161 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
162 RealLiteral(::std::boxed::Box<RealLiteral<'tree>>),
163 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
164 VerbatimStringLiteral(::std::boxed::Box<VerbatimStringLiteral<'tree>>),
165}
166impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
167 #[allow(clippy::collapsible_else_if)]
168 fn from_node(
169 node: ::tree_sitter::Node<'tree>,
170 src: &'tree [u8],
171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
172 match node.kind() {
173 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
174 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
175 ))),
176 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
177 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
178 ))),
179 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
180 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
181 ))),
182 "null_literal" => Ok(Self::NullLiteral(::std::boxed::Box::new(
183 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
184 ))),
185 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
186 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
187 ))),
188 "real_literal" => Ok(Self::RealLiteral(::std::boxed::Box::new(
189 <RealLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
190 ))),
191 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
192 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
193 ))),
194 "verbatim_string_literal" => Ok(Self::VerbatimStringLiteral(::std::boxed::Box::new(
195 <VerbatimStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
196 ))),
197 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
198 }
199 }
200}
201impl ::treesitter_types::Spanned for Literal<'_> {
202 fn span(&self) -> ::treesitter_types::Span {
203 match self {
204 Self::BooleanLiteral(inner) => inner.span(),
205 Self::CharacterLiteral(inner) => inner.span(),
206 Self::IntegerLiteral(inner) => inner.span(),
207 Self::NullLiteral(inner) => inner.span(),
208 Self::RawStringLiteral(inner) => inner.span(),
209 Self::RealLiteral(inner) => inner.span(),
210 Self::StringLiteral(inner) => inner.span(),
211 Self::VerbatimStringLiteral(inner) => inner.span(),
212 }
213 }
214}
215#[derive(Debug, Clone, PartialEq, Eq)]
216pub enum LvalueExpression<'tree> {
217 ElementAccessExpression(::std::boxed::Box<ElementAccessExpression<'tree>>),
218 ElementBindingExpression(::std::boxed::Box<ElementBindingExpression<'tree>>),
219 GenericName(::std::boxed::Box<GenericName<'tree>>),
220 Identifier(::std::boxed::Box<Identifier<'tree>>),
221 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
222 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
223 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
224 This(::treesitter_types::Span),
225 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
226}
227impl<'tree> ::treesitter_types::FromNode<'tree> for LvalueExpression<'tree> {
228 #[allow(clippy::collapsible_else_if)]
229 fn from_node(
230 node: ::tree_sitter::Node<'tree>,
231 src: &'tree [u8],
232 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
233 match node.kind() {
234 "element_access_expression" => {
235 Ok(Self::ElementAccessExpression(::std::boxed::Box::new(
236 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(
237 node, src,
238 )?,
239 )))
240 }
241 "element_binding_expression" => {
242 Ok(Self::ElementBindingExpression(::std::boxed::Box::new(
243 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(
244 node, src,
245 )?,
246 )))
247 }
248 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
249 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
250 ))),
251 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
252 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
253 ))),
254 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
255 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
256 ))),
257 "parenthesized_expression" => {
258 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
259 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
260 node, src,
261 )?,
262 )))
263 }
264 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
265 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
266 ))),
267 "this" => Ok(Self::This(::treesitter_types::Span::from(node))),
268 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
269 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
270 ))),
271 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
272 }
273 }
274}
275impl ::treesitter_types::Spanned for LvalueExpression<'_> {
276 fn span(&self) -> ::treesitter_types::Span {
277 match self {
278 Self::ElementAccessExpression(inner) => inner.span(),
279 Self::ElementBindingExpression(inner) => inner.span(),
280 Self::GenericName(inner) => inner.span(),
281 Self::Identifier(inner) => inner.span(),
282 Self::MemberAccessExpression(inner) => inner.span(),
283 Self::ParenthesizedExpression(inner) => inner.span(),
284 Self::PrefixUnaryExpression(inner) => inner.span(),
285 Self::This(span) => *span,
286 Self::TupleExpression(inner) => inner.span(),
287 }
288 }
289}
290#[derive(Debug, Clone, PartialEq, Eq)]
291pub enum NonLvalueExpression<'tree> {
292 AnonymousMethodExpression(::std::boxed::Box<AnonymousMethodExpression<'tree>>),
293 AnonymousObjectCreationExpression(::std::boxed::Box<AnonymousObjectCreationExpression<'tree>>),
294 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
295 AsExpression(::std::boxed::Box<AsExpression<'tree>>),
296 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
297 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
298 Base(::treesitter_types::Span),
299 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
300 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
301 CheckedExpression(::std::boxed::Box<CheckedExpression<'tree>>),
302 ConditionalAccessExpression(::std::boxed::Box<ConditionalAccessExpression<'tree>>),
303 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
304 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
305 ImplicitArrayCreationExpression(::std::boxed::Box<ImplicitArrayCreationExpression<'tree>>),
306 ImplicitObjectCreationExpression(::std::boxed::Box<ImplicitObjectCreationExpression<'tree>>),
307 ImplicitStackallocExpression(::std::boxed::Box<ImplicitStackallocExpression<'tree>>),
308 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
309 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
310 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
311 IsExpression(::std::boxed::Box<IsExpression<'tree>>),
312 IsPatternExpression(::std::boxed::Box<IsPatternExpression<'tree>>),
313 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
314 Literal(::std::boxed::Box<Literal<'tree>>),
315 MakerefExpression(::std::boxed::Box<MakerefExpression<'tree>>),
316 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
317 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
318 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
319 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
320 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
321 QueryExpression(::std::boxed::Box<QueryExpression<'tree>>),
322 RangeExpression(::std::boxed::Box<RangeExpression<'tree>>),
323 RefExpression(::std::boxed::Box<RefExpression<'tree>>),
324 ReftypeExpression(::std::boxed::Box<ReftypeExpression<'tree>>),
325 RefvalueExpression(::std::boxed::Box<RefvalueExpression<'tree>>),
326 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
327 StackallocExpression(::std::boxed::Box<StackallocExpression<'tree>>),
328 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
329 ThrowExpression(::std::boxed::Box<ThrowExpression<'tree>>),
330 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
331 WithExpression(::std::boxed::Box<WithExpression<'tree>>),
332}
333impl<'tree> ::treesitter_types::FromNode<'tree> for NonLvalueExpression<'tree> {
334 #[allow(clippy::collapsible_else_if)]
335 fn from_node(
336 node: ::tree_sitter::Node<'tree>,
337 src: &'tree [u8],
338 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
339 match node.kind() {
340 "anonymous_method_expression" => {
341 Ok(Self::AnonymousMethodExpression(::std::boxed::Box::new(
342 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(
343 node, src,
344 )?,
345 )))
346 }
347 "anonymous_object_creation_expression" => Ok(Self::AnonymousObjectCreationExpression(
348 ::std::boxed::Box::new(
349 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
350 node, src,
351 )?,
352 ),
353 )),
354 "array_creation_expression" => {
355 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
356 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
357 node, src,
358 )?,
359 )))
360 }
361 "as_expression" => Ok(Self::AsExpression(::std::boxed::Box::new(
362 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
363 ))),
364 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
365 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
366 ))),
367 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
368 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
369 ))),
370 "base" => Ok(Self::Base(::treesitter_types::Span::from(node))),
371 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
372 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
373 ))),
374 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
375 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
376 ))),
377 "checked_expression" => Ok(Self::CheckedExpression(::std::boxed::Box::new(
378 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
379 ))),
380 "conditional_access_expression" => {
381 Ok(Self::ConditionalAccessExpression(::std::boxed::Box::new(
382 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
383 node, src,
384 )?,
385 )))
386 }
387 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
388 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
389 ))),
390 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
391 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
392 ))),
393 "implicit_array_creation_expression" => Ok(Self::ImplicitArrayCreationExpression(
394 ::std::boxed::Box::new(
395 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
396 node, src,
397 )?,
398 ),
399 )),
400 "implicit_object_creation_expression" => Ok(Self::ImplicitObjectCreationExpression(
401 ::std::boxed::Box::new(
402 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
403 node, src,
404 )?,
405 ),
406 )),
407 "implicit_stackalloc_expression" => {
408 Ok(Self::ImplicitStackallocExpression(::std::boxed::Box::new(
409 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(
410 node, src,
411 )?,
412 )))
413 }
414 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
415 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
416 ))),
417 "interpolated_string_expression" => {
418 Ok(Self::InterpolatedStringExpression(::std::boxed::Box::new(
419 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
420 node, src,
421 )?,
422 )))
423 }
424 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
425 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
426 ))),
427 "is_expression" => Ok(Self::IsExpression(::std::boxed::Box::new(
428 <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
429 ))),
430 "is_pattern_expression" => Ok(Self::IsPatternExpression(::std::boxed::Box::new(
431 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
432 ))),
433 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
434 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
435 ))),
436 "makeref_expression" => Ok(Self::MakerefExpression(::std::boxed::Box::new(
437 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
438 ))),
439 "object_creation_expression" => {
440 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
441 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
442 node, src,
443 )?,
444 )))
445 }
446 "parenthesized_expression" => {
447 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
448 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
449 node, src,
450 )?,
451 )))
452 }
453 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
454 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
455 ))),
456 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
457 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
458 ))),
459 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
460 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
461 ))),
462 "query_expression" => Ok(Self::QueryExpression(::std::boxed::Box::new(
463 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
464 ))),
465 "range_expression" => Ok(Self::RangeExpression(::std::boxed::Box::new(
466 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
467 ))),
468 "ref_expression" => Ok(Self::RefExpression(::std::boxed::Box::new(
469 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
470 ))),
471 "reftype_expression" => Ok(Self::ReftypeExpression(::std::boxed::Box::new(
472 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
473 ))),
474 "refvalue_expression" => Ok(Self::RefvalueExpression(::std::boxed::Box::new(
475 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
476 ))),
477 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
478 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
479 ))),
480 "stackalloc_expression" => Ok(Self::StackallocExpression(::std::boxed::Box::new(
481 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
482 ))),
483 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
484 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
485 ))),
486 "throw_expression" => Ok(Self::ThrowExpression(::std::boxed::Box::new(
487 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
488 ))),
489 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
490 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
491 ))),
492 "with_expression" => Ok(Self::WithExpression(::std::boxed::Box::new(
493 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
494 ))),
495 _other => {
496 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
497 Ok(Self::Literal(::std::boxed::Box::new(v)))
498 } else {
499 Err(::treesitter_types::ParseError::unexpected_kind(
500 _other, node,
501 ))
502 }
503 }
504 }
505 }
506}
507impl ::treesitter_types::Spanned for NonLvalueExpression<'_> {
508 fn span(&self) -> ::treesitter_types::Span {
509 match self {
510 Self::AnonymousMethodExpression(inner) => inner.span(),
511 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
512 Self::ArrayCreationExpression(inner) => inner.span(),
513 Self::AsExpression(inner) => inner.span(),
514 Self::AssignmentExpression(inner) => inner.span(),
515 Self::AwaitExpression(inner) => inner.span(),
516 Self::Base(span) => *span,
517 Self::BinaryExpression(inner) => inner.span(),
518 Self::CastExpression(inner) => inner.span(),
519 Self::CheckedExpression(inner) => inner.span(),
520 Self::ConditionalAccessExpression(inner) => inner.span(),
521 Self::ConditionalExpression(inner) => inner.span(),
522 Self::DefaultExpression(inner) => inner.span(),
523 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
524 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
525 Self::ImplicitStackallocExpression(inner) => inner.span(),
526 Self::InitializerExpression(inner) => inner.span(),
527 Self::InterpolatedStringExpression(inner) => inner.span(),
528 Self::InvocationExpression(inner) => inner.span(),
529 Self::IsExpression(inner) => inner.span(),
530 Self::IsPatternExpression(inner) => inner.span(),
531 Self::LambdaExpression(inner) => inner.span(),
532 Self::Literal(inner) => inner.span(),
533 Self::MakerefExpression(inner) => inner.span(),
534 Self::ObjectCreationExpression(inner) => inner.span(),
535 Self::ParenthesizedExpression(inner) => inner.span(),
536 Self::PostfixUnaryExpression(inner) => inner.span(),
537 Self::PrefixUnaryExpression(inner) => inner.span(),
538 Self::PreprocIf(inner) => inner.span(),
539 Self::QueryExpression(inner) => inner.span(),
540 Self::RangeExpression(inner) => inner.span(),
541 Self::RefExpression(inner) => inner.span(),
542 Self::ReftypeExpression(inner) => inner.span(),
543 Self::RefvalueExpression(inner) => inner.span(),
544 Self::SizeofExpression(inner) => inner.span(),
545 Self::StackallocExpression(inner) => inner.span(),
546 Self::SwitchExpression(inner) => inner.span(),
547 Self::ThrowExpression(inner) => inner.span(),
548 Self::TypeofExpression(inner) => inner.span(),
549 Self::WithExpression(inner) => inner.span(),
550 }
551 }
552}
553#[derive(Debug, Clone, PartialEq, Eq)]
554pub enum Pattern<'tree> {
555 AndPattern(::std::boxed::Box<AndPattern<'tree>>),
556 ConstantPattern(::std::boxed::Box<ConstantPattern<'tree>>),
557 DeclarationPattern(::std::boxed::Box<DeclarationPattern<'tree>>),
558 Discard(::std::boxed::Box<Discard<'tree>>),
559 ListPattern(::std::boxed::Box<ListPattern<'tree>>),
560 NegatedPattern(::std::boxed::Box<NegatedPattern<'tree>>),
561 OrPattern(::std::boxed::Box<OrPattern<'tree>>),
562 ParenthesizedPattern(::std::boxed::Box<ParenthesizedPattern<'tree>>),
563 RecursivePattern(::std::boxed::Box<RecursivePattern<'tree>>),
564 RelationalPattern(::std::boxed::Box<RelationalPattern<'tree>>),
565 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
566 VarPattern(::std::boxed::Box<VarPattern<'tree>>),
567}
568impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
569 #[allow(clippy::collapsible_else_if)]
570 fn from_node(
571 node: ::tree_sitter::Node<'tree>,
572 src: &'tree [u8],
573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
574 match node.kind() {
575 "and_pattern" => Ok(Self::AndPattern(::std::boxed::Box::new(
576 <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
577 ))),
578 "constant_pattern" => Ok(Self::ConstantPattern(::std::boxed::Box::new(
579 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
580 ))),
581 "declaration_pattern" => Ok(Self::DeclarationPattern(::std::boxed::Box::new(
582 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
583 ))),
584 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
585 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
586 ))),
587 "list_pattern" => Ok(Self::ListPattern(::std::boxed::Box::new(
588 <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
589 ))),
590 "negated_pattern" => Ok(Self::NegatedPattern(::std::boxed::Box::new(
591 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
592 ))),
593 "or_pattern" => Ok(Self::OrPattern(::std::boxed::Box::new(
594 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
595 ))),
596 "parenthesized_pattern" => Ok(Self::ParenthesizedPattern(::std::boxed::Box::new(
597 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
598 ))),
599 "recursive_pattern" => Ok(Self::RecursivePattern(::std::boxed::Box::new(
600 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
601 ))),
602 "relational_pattern" => Ok(Self::RelationalPattern(::std::boxed::Box::new(
603 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
604 ))),
605 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
606 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
607 ))),
608 "var_pattern" => Ok(Self::VarPattern(::std::boxed::Box::new(
609 <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
610 ))),
611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
612 }
613 }
614}
615impl ::treesitter_types::Spanned for Pattern<'_> {
616 fn span(&self) -> ::treesitter_types::Span {
617 match self {
618 Self::AndPattern(inner) => inner.span(),
619 Self::ConstantPattern(inner) => inner.span(),
620 Self::DeclarationPattern(inner) => inner.span(),
621 Self::Discard(inner) => inner.span(),
622 Self::ListPattern(inner) => inner.span(),
623 Self::NegatedPattern(inner) => inner.span(),
624 Self::OrPattern(inner) => inner.span(),
625 Self::ParenthesizedPattern(inner) => inner.span(),
626 Self::RecursivePattern(inner) => inner.span(),
627 Self::RelationalPattern(inner) => inner.span(),
628 Self::TypePattern(inner) => inner.span(),
629 Self::VarPattern(inner) => inner.span(),
630 }
631 }
632}
633#[derive(Debug, Clone, PartialEq, Eq)]
634pub enum Statement<'tree> {
635 Block(::std::boxed::Box<Block<'tree>>),
636 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
637 CheckedStatement(::std::boxed::Box<CheckedStatement<'tree>>),
638 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
639 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
640 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
641 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
642 FixedStatement(::std::boxed::Box<FixedStatement<'tree>>),
643 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
644 ForeachStatement(::std::boxed::Box<ForeachStatement<'tree>>),
645 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
646 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
647 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
648 LocalDeclarationStatement(::std::boxed::Box<LocalDeclarationStatement<'tree>>),
649 LocalFunctionStatement(::std::boxed::Box<LocalFunctionStatement<'tree>>),
650 LockStatement(::std::boxed::Box<LockStatement<'tree>>),
651 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
652 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
653 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
654 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
655 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
656 UnsafeStatement(::std::boxed::Box<UnsafeStatement<'tree>>),
657 UsingStatement(::std::boxed::Box<UsingStatement<'tree>>),
658 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
659 YieldStatement(::std::boxed::Box<YieldStatement<'tree>>),
660}
661impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
662 #[allow(clippy::collapsible_else_if)]
663 fn from_node(
664 node: ::tree_sitter::Node<'tree>,
665 src: &'tree [u8],
666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
667 match node.kind() {
668 "block" => Ok(Self::Block(::std::boxed::Box::new(
669 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
670 ))),
671 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
672 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
673 ))),
674 "checked_statement" => Ok(Self::CheckedStatement(::std::boxed::Box::new(
675 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
676 ))),
677 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
678 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
679 ))),
680 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
681 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
682 ))),
683 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
684 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
685 ))),
686 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
687 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
688 ))),
689 "fixed_statement" => Ok(Self::FixedStatement(::std::boxed::Box::new(
690 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
691 ))),
692 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
693 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
694 ))),
695 "foreach_statement" => Ok(Self::ForeachStatement(::std::boxed::Box::new(
696 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
697 ))),
698 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
699 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
700 ))),
701 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
702 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
703 ))),
704 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
705 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
706 ))),
707 "local_declaration_statement" => {
708 Ok(Self::LocalDeclarationStatement(::std::boxed::Box::new(
709 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(
710 node, src,
711 )?,
712 )))
713 }
714 "local_function_statement" => Ok(Self::LocalFunctionStatement(::std::boxed::Box::new(
715 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
716 ))),
717 "lock_statement" => Ok(Self::LockStatement(::std::boxed::Box::new(
718 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
719 ))),
720 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
721 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
722 ))),
723 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
724 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
725 ))),
726 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
727 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
728 ))),
729 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
730 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
731 ))),
732 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
733 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
734 ))),
735 "unsafe_statement" => Ok(Self::UnsafeStatement(::std::boxed::Box::new(
736 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
737 ))),
738 "using_statement" => Ok(Self::UsingStatement(::std::boxed::Box::new(
739 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
740 ))),
741 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
742 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
743 ))),
744 "yield_statement" => Ok(Self::YieldStatement(::std::boxed::Box::new(
745 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
746 ))),
747 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
748 }
749 }
750}
751impl ::treesitter_types::Spanned for Statement<'_> {
752 fn span(&self) -> ::treesitter_types::Span {
753 match self {
754 Self::Block(inner) => inner.span(),
755 Self::BreakStatement(inner) => inner.span(),
756 Self::CheckedStatement(inner) => inner.span(),
757 Self::ContinueStatement(inner) => inner.span(),
758 Self::DoStatement(inner) => inner.span(),
759 Self::EmptyStatement(inner) => inner.span(),
760 Self::ExpressionStatement(inner) => inner.span(),
761 Self::FixedStatement(inner) => inner.span(),
762 Self::ForStatement(inner) => inner.span(),
763 Self::ForeachStatement(inner) => inner.span(),
764 Self::GotoStatement(inner) => inner.span(),
765 Self::IfStatement(inner) => inner.span(),
766 Self::LabeledStatement(inner) => inner.span(),
767 Self::LocalDeclarationStatement(inner) => inner.span(),
768 Self::LocalFunctionStatement(inner) => inner.span(),
769 Self::LockStatement(inner) => inner.span(),
770 Self::PreprocIf(inner) => inner.span(),
771 Self::ReturnStatement(inner) => inner.span(),
772 Self::SwitchStatement(inner) => inner.span(),
773 Self::ThrowStatement(inner) => inner.span(),
774 Self::TryStatement(inner) => inner.span(),
775 Self::UnsafeStatement(inner) => inner.span(),
776 Self::UsingStatement(inner) => inner.span(),
777 Self::WhileStatement(inner) => inner.span(),
778 Self::YieldStatement(inner) => inner.span(),
779 }
780 }
781}
782#[derive(Debug, Clone, PartialEq, Eq)]
783pub enum Type<'tree> {
784 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
785 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
786 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
787 GenericName(::std::boxed::Box<GenericName<'tree>>),
788 Identifier(::std::boxed::Box<Identifier<'tree>>),
789 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
790 NullableType(::std::boxed::Box<NullableType<'tree>>),
791 PointerType(::std::boxed::Box<PointerType<'tree>>),
792 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
793 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
794 RefType(::std::boxed::Box<RefType<'tree>>),
795 ScopedType(::std::boxed::Box<ScopedType<'tree>>),
796 TupleType(::std::boxed::Box<TupleType<'tree>>),
797}
798impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
799 #[allow(clippy::collapsible_else_if)]
800 fn from_node(
801 node: ::tree_sitter::Node<'tree>,
802 src: &'tree [u8],
803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
804 match node.kind() {
805 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
806 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
807 ))),
808 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
809 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
810 ))),
811 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
812 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
813 ))),
814 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
815 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
816 ))),
817 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
818 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
819 ))),
820 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
821 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)?,
822 ))),
823 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
824 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
825 ))),
826 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
827 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
828 ))),
829 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
830 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
831 ))),
832 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
833 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
834 ))),
835 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
836 <RefType as ::treesitter_types::FromNode>::from_node(node, src)?,
837 ))),
838 "scoped_type" => Ok(Self::ScopedType(::std::boxed::Box::new(
839 <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)?,
840 ))),
841 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
842 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
843 ))),
844 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
845 }
846 }
847}
848impl ::treesitter_types::Spanned for Type<'_> {
849 fn span(&self) -> ::treesitter_types::Span {
850 match self {
851 Self::AliasQualifiedName(inner) => inner.span(),
852 Self::ArrayType(inner) => inner.span(),
853 Self::FunctionPointerType(inner) => inner.span(),
854 Self::GenericName(inner) => inner.span(),
855 Self::Identifier(inner) => inner.span(),
856 Self::ImplicitType(inner) => inner.span(),
857 Self::NullableType(inner) => inner.span(),
858 Self::PointerType(inner) => inner.span(),
859 Self::PredefinedType(inner) => inner.span(),
860 Self::QualifiedName(inner) => inner.span(),
861 Self::RefType(inner) => inner.span(),
862 Self::ScopedType(inner) => inner.span(),
863 Self::TupleType(inner) => inner.span(),
864 }
865 }
866}
867#[derive(Debug, Clone, PartialEq, Eq)]
868pub enum TypeDeclaration<'tree> {
869 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
870 DelegateDeclaration(::std::boxed::Box<DelegateDeclaration<'tree>>),
871 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
872 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
873 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
874 StructDeclaration(::std::boxed::Box<StructDeclaration<'tree>>),
875}
876impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclaration<'tree> {
877 #[allow(clippy::collapsible_else_if)]
878 fn from_node(
879 node: ::tree_sitter::Node<'tree>,
880 src: &'tree [u8],
881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
882 match node.kind() {
883 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
884 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
885 ))),
886 "delegate_declaration" => Ok(Self::DelegateDeclaration(::std::boxed::Box::new(
887 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
888 ))),
889 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
890 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
891 ))),
892 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
893 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
894 ))),
895 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
896 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
897 ))),
898 "struct_declaration" => Ok(Self::StructDeclaration(::std::boxed::Box::new(
899 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
900 ))),
901 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
902 }
903 }
904}
905impl ::treesitter_types::Spanned for TypeDeclaration<'_> {
906 fn span(&self) -> ::treesitter_types::Span {
907 match self {
908 Self::ClassDeclaration(inner) => inner.span(),
909 Self::DelegateDeclaration(inner) => inner.span(),
910 Self::EnumDeclaration(inner) => inner.span(),
911 Self::InterfaceDeclaration(inner) => inner.span(),
912 Self::RecordDeclaration(inner) => inner.span(),
913 Self::StructDeclaration(inner) => inner.span(),
914 }
915 }
916}
917#[derive(Debug, Clone, PartialEq, Eq)]
918pub struct AccessorDeclaration<'tree> {
919 pub span: ::treesitter_types::Span,
920 pub body: ::core::option::Option<AccessorDeclarationBody<'tree>>,
921 pub name: AccessorDeclarationName<'tree>,
922 pub children: ::std::vec::Vec<AccessorDeclarationChildren<'tree>>,
923}
924impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclaration<'tree> {
925 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
926 fn from_node(
927 node: ::tree_sitter::Node<'tree>,
928 src: &'tree [u8],
929 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
930 debug_assert_eq!(node.kind(), "accessor_declaration");
931 Ok(Self {
932 span: ::treesitter_types::Span::from(node),
933 body: match node.child_by_field_name("body") {
934 Some(child) => Some(
935 <AccessorDeclarationBody as ::treesitter_types::FromNode>::from_node(
936 child, src,
937 )?,
938 ),
939 None => None,
940 },
941 name: {
942 let child = node
943 .child_by_field_name("name")
944 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
945 <AccessorDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)?
946 },
947 children: {
948 #[allow(clippy::suspicious_else_formatting)]
949 let non_field_children = {
950 let mut cursor = node.walk();
951 let mut result = ::std::vec::Vec::new();
952 if cursor.goto_first_child() {
953 loop {
954 if cursor.field_name().is_none()
955 && cursor.node().is_named()
956 && !cursor.node().is_extra()
957 {
958 result.push(cursor.node());
959 }
960 if !cursor.goto_next_sibling() {
961 break;
962 }
963 }
964 }
965 result
966 };
967 let mut items = ::std::vec::Vec::new();
968 for child in non_field_children {
969 items.push(
970 <AccessorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
971 child, src,
972 )?,
973 );
974 }
975 items
976 },
977 })
978 }
979}
980impl ::treesitter_types::Spanned for AccessorDeclaration<'_> {
981 fn span(&self) -> ::treesitter_types::Span {
982 self.span
983 }
984}
985#[derive(Debug, Clone, PartialEq, Eq)]
986pub struct AccessorList<'tree> {
987 pub span: ::treesitter_types::Span,
988 pub children: ::std::vec::Vec<AccessorDeclaration<'tree>>,
989}
990impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorList<'tree> {
991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
992 fn from_node(
993 node: ::tree_sitter::Node<'tree>,
994 src: &'tree [u8],
995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
996 debug_assert_eq!(node.kind(), "accessor_list");
997 Ok(Self {
998 span: ::treesitter_types::Span::from(node),
999 children: {
1000 #[allow(clippy::suspicious_else_formatting)]
1001 let non_field_children = {
1002 let mut cursor = node.walk();
1003 let mut result = ::std::vec::Vec::new();
1004 if cursor.goto_first_child() {
1005 loop {
1006 if cursor.field_name().is_none()
1007 && cursor.node().is_named()
1008 && !cursor.node().is_extra()
1009 {
1010 result.push(cursor.node());
1011 }
1012 if !cursor.goto_next_sibling() {
1013 break;
1014 }
1015 }
1016 }
1017 result
1018 };
1019 let mut items = ::std::vec::Vec::new();
1020 for child in non_field_children {
1021 items.push(
1022 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(
1023 child, src,
1024 )?,
1025 );
1026 }
1027 items
1028 },
1029 })
1030 }
1031}
1032impl ::treesitter_types::Spanned for AccessorList<'_> {
1033 fn span(&self) -> ::treesitter_types::Span {
1034 self.span
1035 }
1036}
1037#[derive(Debug, Clone, PartialEq, Eq)]
1038pub struct AliasQualifiedName<'tree> {
1039 pub span: ::treesitter_types::Span,
1040 pub alias: Identifier<'tree>,
1041 pub name: AliasQualifiedNameName<'tree>,
1042}
1043impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedName<'tree> {
1044 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1045 fn from_node(
1046 node: ::tree_sitter::Node<'tree>,
1047 src: &'tree [u8],
1048 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1049 debug_assert_eq!(node.kind(), "alias_qualified_name");
1050 Ok(Self {
1051 span: ::treesitter_types::Span::from(node),
1052 alias: {
1053 let child = node
1054 .child_by_field_name("alias")
1055 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
1056 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1057 },
1058 name: {
1059 let child = node
1060 .child_by_field_name("name")
1061 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1062 <AliasQualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)?
1063 },
1064 })
1065 }
1066}
1067impl ::treesitter_types::Spanned for AliasQualifiedName<'_> {
1068 fn span(&self) -> ::treesitter_types::Span {
1069 self.span
1070 }
1071}
1072#[derive(Debug, Clone, PartialEq, Eq)]
1073pub struct AndPattern<'tree> {
1074 pub span: ::treesitter_types::Span,
1075 pub left: Pattern<'tree>,
1076 pub operator: AndPatternOperator,
1077 pub right: Pattern<'tree>,
1078}
1079impl<'tree> ::treesitter_types::FromNode<'tree> for AndPattern<'tree> {
1080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1081 fn from_node(
1082 node: ::tree_sitter::Node<'tree>,
1083 src: &'tree [u8],
1084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1085 debug_assert_eq!(node.kind(), "and_pattern");
1086 Ok(Self {
1087 span: ::treesitter_types::Span::from(node),
1088 left: {
1089 let child = node
1090 .child_by_field_name("left")
1091 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1092 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
1093 },
1094 operator: {
1095 let child = node.child_by_field_name("operator").ok_or_else(|| {
1096 ::treesitter_types::ParseError::missing_field("operator", node)
1097 })?;
1098 <AndPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1099 },
1100 right: {
1101 let child = node
1102 .child_by_field_name("right")
1103 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1104 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
1105 },
1106 })
1107 }
1108}
1109impl ::treesitter_types::Spanned for AndPattern<'_> {
1110 fn span(&self) -> ::treesitter_types::Span {
1111 self.span
1112 }
1113}
1114#[derive(Debug, Clone, PartialEq, Eq)]
1115pub struct AnonymousMethodExpression<'tree> {
1116 pub span: ::treesitter_types::Span,
1117 pub parameters: ::core::option::Option<ParameterList<'tree>>,
1118 pub children: ::std::vec::Vec<AnonymousMethodExpressionChildren<'tree>>,
1119}
1120impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpression<'tree> {
1121 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1122 fn from_node(
1123 node: ::tree_sitter::Node<'tree>,
1124 src: &'tree [u8],
1125 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1126 debug_assert_eq!(node.kind(), "anonymous_method_expression");
1127 Ok(Self {
1128 span: ::treesitter_types::Span::from(node),
1129 parameters: match node.child_by_field_name("parameters") {
1130 Some(child) => Some(<ParameterList as ::treesitter_types::FromNode>::from_node(
1131 child, src,
1132 )?),
1133 None => None,
1134 },
1135 children: {
1136 #[allow(clippy::suspicious_else_formatting)]
1137 let non_field_children = {
1138 let mut cursor = node.walk();
1139 let mut result = ::std::vec::Vec::new();
1140 if cursor.goto_first_child() {
1141 loop {
1142 if cursor.field_name().is_none()
1143 && cursor.node().is_named()
1144 && !cursor.node().is_extra()
1145 {
1146 result.push(cursor.node());
1147 }
1148 if !cursor.goto_next_sibling() {
1149 break;
1150 }
1151 }
1152 }
1153 result
1154 };
1155 let mut items = ::std::vec::Vec::new();
1156 for child in non_field_children {
1157 items
1158 .push(
1159 <AnonymousMethodExpressionChildren as ::treesitter_types::FromNode>::from_node(
1160 child,
1161 src,
1162 )?,
1163 );
1164 }
1165 items
1166 },
1167 })
1168 }
1169}
1170impl ::treesitter_types::Spanned for AnonymousMethodExpression<'_> {
1171 fn span(&self) -> ::treesitter_types::Span {
1172 self.span
1173 }
1174}
1175#[derive(Debug, Clone, PartialEq, Eq)]
1176pub struct AnonymousObjectCreationExpression<'tree> {
1177 pub span: ::treesitter_types::Span,
1178 pub children: ::std::vec::Vec<AnonymousObjectCreationExpressionChildren<'tree>>,
1179}
1180impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousObjectCreationExpression<'tree> {
1181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1182 fn from_node(
1183 node: ::tree_sitter::Node<'tree>,
1184 src: &'tree [u8],
1185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1186 debug_assert_eq!(node.kind(), "anonymous_object_creation_expression");
1187 Ok(Self {
1188 span: ::treesitter_types::Span::from(node),
1189 children: {
1190 #[allow(clippy::suspicious_else_formatting)]
1191 let non_field_children = {
1192 let mut cursor = node.walk();
1193 let mut result = ::std::vec::Vec::new();
1194 if cursor.goto_first_child() {
1195 loop {
1196 if cursor.field_name().is_none()
1197 && cursor.node().is_named()
1198 && !cursor.node().is_extra()
1199 {
1200 result.push(cursor.node());
1201 }
1202 if !cursor.goto_next_sibling() {
1203 break;
1204 }
1205 }
1206 }
1207 result
1208 };
1209 let mut items = ::std::vec::Vec::new();
1210 for child in non_field_children {
1211 items
1212 .push(
1213 <AnonymousObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
1214 child,
1215 src,
1216 )?,
1217 );
1218 }
1219 items
1220 },
1221 })
1222 }
1223}
1224impl ::treesitter_types::Spanned for AnonymousObjectCreationExpression<'_> {
1225 fn span(&self) -> ::treesitter_types::Span {
1226 self.span
1227 }
1228}
1229#[derive(Debug, Clone, PartialEq, Eq)]
1230pub struct Argument<'tree> {
1231 pub span: ::treesitter_types::Span,
1232 pub name: ::core::option::Option<Identifier<'tree>>,
1233 pub children: ArgumentChildren<'tree>,
1234}
1235impl<'tree> ::treesitter_types::FromNode<'tree> for Argument<'tree> {
1236 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1237 fn from_node(
1238 node: ::tree_sitter::Node<'tree>,
1239 src: &'tree [u8],
1240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1241 debug_assert_eq!(node.kind(), "argument");
1242 Ok(Self {
1243 span: ::treesitter_types::Span::from(node),
1244 name: match node.child_by_field_name("name") {
1245 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1246 child, src,
1247 )?),
1248 None => None,
1249 },
1250 children: {
1251 #[allow(clippy::suspicious_else_formatting)]
1252 let non_field_children = {
1253 let mut cursor = node.walk();
1254 let mut result = ::std::vec::Vec::new();
1255 if cursor.goto_first_child() {
1256 loop {
1257 if cursor.field_name().is_none()
1258 && cursor.node().is_named()
1259 && !cursor.node().is_extra()
1260 {
1261 result.push(cursor.node());
1262 }
1263 if !cursor.goto_next_sibling() {
1264 break;
1265 }
1266 }
1267 }
1268 result
1269 };
1270 let child = if let Some(&c) = non_field_children.first() {
1271 c
1272 } else {
1273 let mut fallback_cursor = node.walk();
1274 let mut fallback_child = None;
1275 if fallback_cursor.goto_first_child() {
1276 loop {
1277 if fallback_cursor.field_name().is_none()
1278 && !fallback_cursor.node().is_extra()
1279 {
1280 let candidate = fallback_cursor.node();
1281 #[allow(clippy::needless_question_mark)]
1282 if (|| -> ::core::result::Result<
1283 _,
1284 ::treesitter_types::ParseError,
1285 > {
1286 let child = candidate;
1287 Ok(
1288 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1289 child,
1290 src,
1291 )?,
1292 )
1293 })()
1294 .is_ok()
1295 {
1296 fallback_child = Some(candidate);
1297 break;
1298 }
1299 }
1300 if !fallback_cursor.goto_next_sibling() {
1301 break;
1302 }
1303 }
1304 }
1305 if fallback_child.is_none() {
1306 let mut cursor2 = node.walk();
1307 if cursor2.goto_first_child() {
1308 loop {
1309 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1310 let candidate = cursor2.node();
1311 #[allow(clippy::needless_question_mark)]
1312 if (|| -> ::core::result::Result<
1313 _,
1314 ::treesitter_types::ParseError,
1315 > {
1316 let child = candidate;
1317 Ok(
1318 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1319 child,
1320 src,
1321 )?,
1322 )
1323 })()
1324 .is_ok()
1325 {
1326 fallback_child = Some(candidate);
1327 break;
1328 }
1329 }
1330 if !cursor2.goto_next_sibling() {
1331 break;
1332 }
1333 }
1334 }
1335 }
1336 fallback_child.ok_or_else(|| {
1337 ::treesitter_types::ParseError::missing_field("children", node)
1338 })?
1339 };
1340 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1341 },
1342 })
1343 }
1344}
1345impl ::treesitter_types::Spanned for Argument<'_> {
1346 fn span(&self) -> ::treesitter_types::Span {
1347 self.span
1348 }
1349}
1350#[derive(Debug, Clone, PartialEq, Eq)]
1351pub struct ArgumentList<'tree> {
1352 pub span: ::treesitter_types::Span,
1353 pub children: ::std::vec::Vec<Argument<'tree>>,
1354}
1355impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1356 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1357 fn from_node(
1358 node: ::tree_sitter::Node<'tree>,
1359 src: &'tree [u8],
1360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1361 debug_assert_eq!(node.kind(), "argument_list");
1362 Ok(Self {
1363 span: ::treesitter_types::Span::from(node),
1364 children: {
1365 #[allow(clippy::suspicious_else_formatting)]
1366 let non_field_children = {
1367 let mut cursor = node.walk();
1368 let mut result = ::std::vec::Vec::new();
1369 if cursor.goto_first_child() {
1370 loop {
1371 if cursor.field_name().is_none()
1372 && cursor.node().is_named()
1373 && !cursor.node().is_extra()
1374 {
1375 result.push(cursor.node());
1376 }
1377 if !cursor.goto_next_sibling() {
1378 break;
1379 }
1380 }
1381 }
1382 result
1383 };
1384 let mut items = ::std::vec::Vec::new();
1385 for child in non_field_children {
1386 items.push(<Argument as ::treesitter_types::FromNode>::from_node(
1387 child, src,
1388 )?);
1389 }
1390 items
1391 },
1392 })
1393 }
1394}
1395impl ::treesitter_types::Spanned for ArgumentList<'_> {
1396 fn span(&self) -> ::treesitter_types::Span {
1397 self.span
1398 }
1399}
1400#[derive(Debug, Clone, PartialEq, Eq)]
1401pub struct ArrayCreationExpression<'tree> {
1402 pub span: ::treesitter_types::Span,
1403 pub r#type: ArrayType<'tree>,
1404 pub children: ::core::option::Option<InitializerExpression<'tree>>,
1405}
1406impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1407 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1408 fn from_node(
1409 node: ::tree_sitter::Node<'tree>,
1410 src: &'tree [u8],
1411 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1412 debug_assert_eq!(node.kind(), "array_creation_expression");
1413 Ok(Self {
1414 span: ::treesitter_types::Span::from(node),
1415 r#type: {
1416 let child = node
1417 .child_by_field_name("type")
1418 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1419 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)?
1420 },
1421 children: {
1422 #[allow(clippy::suspicious_else_formatting)]
1423 let non_field_children = {
1424 let mut cursor = node.walk();
1425 let mut result = ::std::vec::Vec::new();
1426 if cursor.goto_first_child() {
1427 loop {
1428 if cursor.field_name().is_none()
1429 && cursor.node().is_named()
1430 && !cursor.node().is_extra()
1431 {
1432 result.push(cursor.node());
1433 }
1434 if !cursor.goto_next_sibling() {
1435 break;
1436 }
1437 }
1438 }
1439 result
1440 };
1441 match non_field_children.first() {
1442 Some(&child) => Some(
1443 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
1444 child, src,
1445 )?,
1446 ),
1447 None => None,
1448 }
1449 },
1450 })
1451 }
1452}
1453impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1454 fn span(&self) -> ::treesitter_types::Span {
1455 self.span
1456 }
1457}
1458#[derive(Debug, Clone, PartialEq, Eq)]
1459pub struct ArrayRankSpecifier<'tree> {
1460 pub span: ::treesitter_types::Span,
1461 pub children: ::std::vec::Vec<Expression<'tree>>,
1462}
1463impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayRankSpecifier<'tree> {
1464 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1465 fn from_node(
1466 node: ::tree_sitter::Node<'tree>,
1467 src: &'tree [u8],
1468 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1469 debug_assert_eq!(node.kind(), "array_rank_specifier");
1470 Ok(Self {
1471 span: ::treesitter_types::Span::from(node),
1472 children: {
1473 #[allow(clippy::suspicious_else_formatting)]
1474 let non_field_children = {
1475 let mut cursor = node.walk();
1476 let mut result = ::std::vec::Vec::new();
1477 if cursor.goto_first_child() {
1478 loop {
1479 if cursor.field_name().is_none()
1480 && cursor.node().is_named()
1481 && !cursor.node().is_extra()
1482 {
1483 result.push(cursor.node());
1484 }
1485 if !cursor.goto_next_sibling() {
1486 break;
1487 }
1488 }
1489 }
1490 result
1491 };
1492 let mut items = ::std::vec::Vec::new();
1493 for child in non_field_children {
1494 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
1495 child, src,
1496 )?);
1497 }
1498 items
1499 },
1500 })
1501 }
1502}
1503impl ::treesitter_types::Spanned for ArrayRankSpecifier<'_> {
1504 fn span(&self) -> ::treesitter_types::Span {
1505 self.span
1506 }
1507}
1508#[derive(Debug, Clone, PartialEq, Eq)]
1509pub struct ArrayType<'tree> {
1510 pub span: ::treesitter_types::Span,
1511 pub rank: ArrayRankSpecifier<'tree>,
1512 pub r#type: ArrayTypeType<'tree>,
1513}
1514impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'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(), "array_type");
1521 Ok(Self {
1522 span: ::treesitter_types::Span::from(node),
1523 rank: {
1524 let child = node
1525 .child_by_field_name("rank")
1526 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("rank", node))?;
1527 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
1528 },
1529 r#type: {
1530 let child = node
1531 .child_by_field_name("type")
1532 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1533 <ArrayTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
1534 },
1535 })
1536 }
1537}
1538impl ::treesitter_types::Spanned for ArrayType<'_> {
1539 fn span(&self) -> ::treesitter_types::Span {
1540 self.span
1541 }
1542}
1543#[derive(Debug, Clone, PartialEq, Eq)]
1544pub struct ArrowExpressionClause<'tree> {
1545 pub span: ::treesitter_types::Span,
1546 pub children: Expression<'tree>,
1547}
1548impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowExpressionClause<'tree> {
1549 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1550 fn from_node(
1551 node: ::tree_sitter::Node<'tree>,
1552 src: &'tree [u8],
1553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1554 debug_assert_eq!(node.kind(), "arrow_expression_clause");
1555 Ok(Self {
1556 span: ::treesitter_types::Span::from(node),
1557 children: {
1558 #[allow(clippy::suspicious_else_formatting)]
1559 let non_field_children = {
1560 let mut cursor = node.walk();
1561 let mut result = ::std::vec::Vec::new();
1562 if cursor.goto_first_child() {
1563 loop {
1564 if cursor.field_name().is_none()
1565 && cursor.node().is_named()
1566 && !cursor.node().is_extra()
1567 {
1568 result.push(cursor.node());
1569 }
1570 if !cursor.goto_next_sibling() {
1571 break;
1572 }
1573 }
1574 }
1575 result
1576 };
1577 let child = if let Some(&c) = non_field_children.first() {
1578 c
1579 } else {
1580 let mut fallback_cursor = node.walk();
1581 let mut fallback_child = None;
1582 if fallback_cursor.goto_first_child() {
1583 loop {
1584 if fallback_cursor.field_name().is_none()
1585 && !fallback_cursor.node().is_extra()
1586 {
1587 let candidate = fallback_cursor.node();
1588 #[allow(clippy::needless_question_mark)]
1589 if (|| -> ::core::result::Result<
1590 _,
1591 ::treesitter_types::ParseError,
1592 > {
1593 let child = candidate;
1594 Ok(
1595 <Expression as ::treesitter_types::FromNode>::from_node(
1596 child,
1597 src,
1598 )?,
1599 )
1600 })()
1601 .is_ok()
1602 {
1603 fallback_child = Some(candidate);
1604 break;
1605 }
1606 }
1607 if !fallback_cursor.goto_next_sibling() {
1608 break;
1609 }
1610 }
1611 }
1612 if fallback_child.is_none() {
1613 let mut cursor2 = node.walk();
1614 if cursor2.goto_first_child() {
1615 loop {
1616 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1617 let candidate = cursor2.node();
1618 #[allow(clippy::needless_question_mark)]
1619 if (|| -> ::core::result::Result<
1620 _,
1621 ::treesitter_types::ParseError,
1622 > {
1623 let child = candidate;
1624 Ok(
1625 <Expression as ::treesitter_types::FromNode>::from_node(
1626 child,
1627 src,
1628 )?,
1629 )
1630 })()
1631 .is_ok()
1632 {
1633 fallback_child = Some(candidate);
1634 break;
1635 }
1636 }
1637 if !cursor2.goto_next_sibling() {
1638 break;
1639 }
1640 }
1641 }
1642 }
1643 fallback_child.ok_or_else(|| {
1644 ::treesitter_types::ParseError::missing_field("children", node)
1645 })?
1646 };
1647 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1648 },
1649 })
1650 }
1651}
1652impl ::treesitter_types::Spanned for ArrowExpressionClause<'_> {
1653 fn span(&self) -> ::treesitter_types::Span {
1654 self.span
1655 }
1656}
1657#[derive(Debug, Clone, PartialEq, Eq)]
1658pub struct AsExpression<'tree> {
1659 pub span: ::treesitter_types::Span,
1660 pub left: Expression<'tree>,
1661 pub operator: AsExpressionOperator,
1662 pub right: Type<'tree>,
1663}
1664impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpression<'tree> {
1665 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1666 fn from_node(
1667 node: ::tree_sitter::Node<'tree>,
1668 src: &'tree [u8],
1669 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1670 debug_assert_eq!(node.kind(), "as_expression");
1671 Ok(Self {
1672 span: ::treesitter_types::Span::from(node),
1673 left: {
1674 let child = node
1675 .child_by_field_name("left")
1676 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1677 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1678 },
1679 operator: {
1680 let child = node.child_by_field_name("operator").ok_or_else(|| {
1681 ::treesitter_types::ParseError::missing_field("operator", node)
1682 })?;
1683 <AsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1684 },
1685 right: {
1686 let child = node
1687 .child_by_field_name("right")
1688 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1689 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
1690 },
1691 })
1692 }
1693}
1694impl ::treesitter_types::Spanned for AsExpression<'_> {
1695 fn span(&self) -> ::treesitter_types::Span {
1696 self.span
1697 }
1698}
1699#[derive(Debug, Clone, PartialEq, Eq)]
1700pub struct AssignmentExpression<'tree> {
1701 pub span: ::treesitter_types::Span,
1702 pub left: LvalueExpression<'tree>,
1703 pub operator: AssignmentExpressionOperator,
1704 pub right: Expression<'tree>,
1705}
1706impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1707 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1708 fn from_node(
1709 node: ::tree_sitter::Node<'tree>,
1710 src: &'tree [u8],
1711 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1712 debug_assert_eq!(node.kind(), "assignment_expression");
1713 Ok(Self {
1714 span: ::treesitter_types::Span::from(node),
1715 left: {
1716 let child = node
1717 .child_by_field_name("left")
1718 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1719 <LvalueExpression as ::treesitter_types::FromNode>::from_node(child, src)?
1720 },
1721 operator: {
1722 let child = node.child_by_field_name("operator").ok_or_else(|| {
1723 ::treesitter_types::ParseError::missing_field("operator", node)
1724 })?;
1725 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1726 child, src,
1727 )?
1728 },
1729 right: {
1730 let child = node
1731 .child_by_field_name("right")
1732 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1733 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1734 },
1735 })
1736 }
1737}
1738impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1739 fn span(&self) -> ::treesitter_types::Span {
1740 self.span
1741 }
1742}
1743#[derive(Debug, Clone, PartialEq, Eq)]
1744pub struct Attribute<'tree> {
1745 pub span: ::treesitter_types::Span,
1746 pub name: AttributeName<'tree>,
1747 pub children: ::core::option::Option<AttributeArgumentList<'tree>>,
1748}
1749impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1750 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1751 fn from_node(
1752 node: ::tree_sitter::Node<'tree>,
1753 src: &'tree [u8],
1754 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1755 debug_assert_eq!(node.kind(), "attribute");
1756 Ok(Self {
1757 span: ::treesitter_types::Span::from(node),
1758 name: {
1759 let child = node
1760 .child_by_field_name("name")
1761 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1762 <AttributeName as ::treesitter_types::FromNode>::from_node(child, src)?
1763 },
1764 children: {
1765 #[allow(clippy::suspicious_else_formatting)]
1766 let non_field_children = {
1767 let mut cursor = node.walk();
1768 let mut result = ::std::vec::Vec::new();
1769 if cursor.goto_first_child() {
1770 loop {
1771 if cursor.field_name().is_none()
1772 && cursor.node().is_named()
1773 && !cursor.node().is_extra()
1774 {
1775 result.push(cursor.node());
1776 }
1777 if !cursor.goto_next_sibling() {
1778 break;
1779 }
1780 }
1781 }
1782 result
1783 };
1784 match non_field_children.first() {
1785 Some(&child) => Some(
1786 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(
1787 child, src,
1788 )?,
1789 ),
1790 None => None,
1791 }
1792 },
1793 })
1794 }
1795}
1796impl ::treesitter_types::Spanned for Attribute<'_> {
1797 fn span(&self) -> ::treesitter_types::Span {
1798 self.span
1799 }
1800}
1801#[derive(Debug, Clone, PartialEq, Eq)]
1802pub struct AttributeArgument<'tree> {
1803 pub span: ::treesitter_types::Span,
1804 pub children: ::std::vec::Vec<AttributeArgumentChildren<'tree>>,
1805}
1806impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgument<'tree> {
1807 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1808 fn from_node(
1809 node: ::tree_sitter::Node<'tree>,
1810 src: &'tree [u8],
1811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1812 debug_assert_eq!(node.kind(), "attribute_argument");
1813 Ok(Self {
1814 span: ::treesitter_types::Span::from(node),
1815 children: {
1816 #[allow(clippy::suspicious_else_formatting)]
1817 let non_field_children = {
1818 let mut cursor = node.walk();
1819 let mut result = ::std::vec::Vec::new();
1820 if cursor.goto_first_child() {
1821 loop {
1822 if cursor.field_name().is_none()
1823 && cursor.node().is_named()
1824 && !cursor.node().is_extra()
1825 {
1826 result.push(cursor.node());
1827 }
1828 if !cursor.goto_next_sibling() {
1829 break;
1830 }
1831 }
1832 }
1833 result
1834 };
1835 let mut items = ::std::vec::Vec::new();
1836 for child in non_field_children {
1837 items.push(
1838 <AttributeArgumentChildren as ::treesitter_types::FromNode>::from_node(
1839 child, src,
1840 )?,
1841 );
1842 }
1843 items
1844 },
1845 })
1846 }
1847}
1848impl ::treesitter_types::Spanned for AttributeArgument<'_> {
1849 fn span(&self) -> ::treesitter_types::Span {
1850 self.span
1851 }
1852}
1853#[derive(Debug, Clone, PartialEq, Eq)]
1854pub struct AttributeArgumentList<'tree> {
1855 pub span: ::treesitter_types::Span,
1856 pub children: ::std::vec::Vec<AttributeArgument<'tree>>,
1857}
1858impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgumentList<'tree> {
1859 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1860 fn from_node(
1861 node: ::tree_sitter::Node<'tree>,
1862 src: &'tree [u8],
1863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1864 debug_assert_eq!(node.kind(), "attribute_argument_list");
1865 Ok(Self {
1866 span: ::treesitter_types::Span::from(node),
1867 children: {
1868 #[allow(clippy::suspicious_else_formatting)]
1869 let non_field_children = {
1870 let mut cursor = node.walk();
1871 let mut result = ::std::vec::Vec::new();
1872 if cursor.goto_first_child() {
1873 loop {
1874 if cursor.field_name().is_none()
1875 && cursor.node().is_named()
1876 && !cursor.node().is_extra()
1877 {
1878 result.push(cursor.node());
1879 }
1880 if !cursor.goto_next_sibling() {
1881 break;
1882 }
1883 }
1884 }
1885 result
1886 };
1887 let mut items = ::std::vec::Vec::new();
1888 for child in non_field_children {
1889 items.push(
1890 <AttributeArgument as ::treesitter_types::FromNode>::from_node(child, src)?,
1891 );
1892 }
1893 items
1894 },
1895 })
1896 }
1897}
1898impl ::treesitter_types::Spanned for AttributeArgumentList<'_> {
1899 fn span(&self) -> ::treesitter_types::Span {
1900 self.span
1901 }
1902}
1903#[derive(Debug, Clone, PartialEq, Eq)]
1904pub struct AttributeList<'tree> {
1905 pub span: ::treesitter_types::Span,
1906 pub children: ::std::vec::Vec<AttributeListChildren<'tree>>,
1907}
1908impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeList<'tree> {
1909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1910 fn from_node(
1911 node: ::tree_sitter::Node<'tree>,
1912 src: &'tree [u8],
1913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1914 debug_assert_eq!(node.kind(), "attribute_list");
1915 Ok(Self {
1916 span: ::treesitter_types::Span::from(node),
1917 children: {
1918 #[allow(clippy::suspicious_else_formatting)]
1919 let non_field_children = {
1920 let mut cursor = node.walk();
1921 let mut result = ::std::vec::Vec::new();
1922 if cursor.goto_first_child() {
1923 loop {
1924 if cursor.field_name().is_none()
1925 && cursor.node().is_named()
1926 && !cursor.node().is_extra()
1927 {
1928 result.push(cursor.node());
1929 }
1930 if !cursor.goto_next_sibling() {
1931 break;
1932 }
1933 }
1934 }
1935 result
1936 };
1937 let mut items = ::std::vec::Vec::new();
1938 for child in non_field_children {
1939 items.push(
1940 <AttributeListChildren as ::treesitter_types::FromNode>::from_node(
1941 child, src,
1942 )?,
1943 );
1944 }
1945 items
1946 },
1947 })
1948 }
1949}
1950impl ::treesitter_types::Spanned for AttributeList<'_> {
1951 fn span(&self) -> ::treesitter_types::Span {
1952 self.span
1953 }
1954}
1955#[derive(Debug, Clone, PartialEq, Eq)]
1956pub struct AttributeTargetSpecifier<'tree> {
1957 pub span: ::treesitter_types::Span,
1958 text: &'tree str,
1959}
1960impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeTargetSpecifier<'tree> {
1961 fn from_node(
1962 node: ::tree_sitter::Node<'tree>,
1963 src: &'tree [u8],
1964 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1965 debug_assert_eq!(node.kind(), "attribute_target_specifier");
1966 Ok(Self {
1967 span: ::treesitter_types::Span::from(node),
1968 text: node.utf8_text(src)?,
1969 })
1970 }
1971}
1972impl<'tree> ::treesitter_types::LeafNode<'tree> for AttributeTargetSpecifier<'tree> {
1973 fn text(&self) -> &'tree str {
1974 self.text
1975 }
1976}
1977impl ::treesitter_types::Spanned for AttributeTargetSpecifier<'_> {
1978 fn span(&self) -> ::treesitter_types::Span {
1979 self.span
1980 }
1981}
1982#[derive(Debug, Clone, PartialEq, Eq)]
1983pub struct AwaitExpression<'tree> {
1984 pub span: ::treesitter_types::Span,
1985 pub children: Expression<'tree>,
1986}
1987impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
1988 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1989 fn from_node(
1990 node: ::tree_sitter::Node<'tree>,
1991 src: &'tree [u8],
1992 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1993 debug_assert_eq!(node.kind(), "await_expression");
1994 Ok(Self {
1995 span: ::treesitter_types::Span::from(node),
1996 children: {
1997 #[allow(clippy::suspicious_else_formatting)]
1998 let non_field_children = {
1999 let mut cursor = node.walk();
2000 let mut result = ::std::vec::Vec::new();
2001 if cursor.goto_first_child() {
2002 loop {
2003 if cursor.field_name().is_none()
2004 && cursor.node().is_named()
2005 && !cursor.node().is_extra()
2006 {
2007 result.push(cursor.node());
2008 }
2009 if !cursor.goto_next_sibling() {
2010 break;
2011 }
2012 }
2013 }
2014 result
2015 };
2016 let child = if let Some(&c) = non_field_children.first() {
2017 c
2018 } else {
2019 let mut fallback_cursor = node.walk();
2020 let mut fallback_child = None;
2021 if fallback_cursor.goto_first_child() {
2022 loop {
2023 if fallback_cursor.field_name().is_none()
2024 && !fallback_cursor.node().is_extra()
2025 {
2026 let candidate = fallback_cursor.node();
2027 #[allow(clippy::needless_question_mark)]
2028 if (|| -> ::core::result::Result<
2029 _,
2030 ::treesitter_types::ParseError,
2031 > {
2032 let child = candidate;
2033 Ok(
2034 <Expression as ::treesitter_types::FromNode>::from_node(
2035 child,
2036 src,
2037 )?,
2038 )
2039 })()
2040 .is_ok()
2041 {
2042 fallback_child = Some(candidate);
2043 break;
2044 }
2045 }
2046 if !fallback_cursor.goto_next_sibling() {
2047 break;
2048 }
2049 }
2050 }
2051 if fallback_child.is_none() {
2052 let mut cursor2 = node.walk();
2053 if cursor2.goto_first_child() {
2054 loop {
2055 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2056 let candidate = cursor2.node();
2057 #[allow(clippy::needless_question_mark)]
2058 if (|| -> ::core::result::Result<
2059 _,
2060 ::treesitter_types::ParseError,
2061 > {
2062 let child = candidate;
2063 Ok(
2064 <Expression as ::treesitter_types::FromNode>::from_node(
2065 child,
2066 src,
2067 )?,
2068 )
2069 })()
2070 .is_ok()
2071 {
2072 fallback_child = Some(candidate);
2073 break;
2074 }
2075 }
2076 if !cursor2.goto_next_sibling() {
2077 break;
2078 }
2079 }
2080 }
2081 }
2082 fallback_child.ok_or_else(|| {
2083 ::treesitter_types::ParseError::missing_field("children", node)
2084 })?
2085 };
2086 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2087 },
2088 })
2089 }
2090}
2091impl ::treesitter_types::Spanned for AwaitExpression<'_> {
2092 fn span(&self) -> ::treesitter_types::Span {
2093 self.span
2094 }
2095}
2096#[derive(Debug, Clone, PartialEq, Eq)]
2097pub struct BaseList<'tree> {
2098 pub span: ::treesitter_types::Span,
2099 pub children: ::std::vec::Vec<BaseListChildren<'tree>>,
2100}
2101impl<'tree> ::treesitter_types::FromNode<'tree> for BaseList<'tree> {
2102 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2103 fn from_node(
2104 node: ::tree_sitter::Node<'tree>,
2105 src: &'tree [u8],
2106 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2107 debug_assert_eq!(node.kind(), "base_list");
2108 Ok(Self {
2109 span: ::treesitter_types::Span::from(node),
2110 children: {
2111 #[allow(clippy::suspicious_else_formatting)]
2112 let non_field_children = {
2113 let mut cursor = node.walk();
2114 let mut result = ::std::vec::Vec::new();
2115 if cursor.goto_first_child() {
2116 loop {
2117 if cursor.field_name().is_none()
2118 && cursor.node().is_named()
2119 && !cursor.node().is_extra()
2120 {
2121 result.push(cursor.node());
2122 }
2123 if !cursor.goto_next_sibling() {
2124 break;
2125 }
2126 }
2127 }
2128 result
2129 };
2130 let mut items = ::std::vec::Vec::new();
2131 for child in non_field_children {
2132 items.push(
2133 <BaseListChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2134 );
2135 }
2136 items
2137 },
2138 })
2139 }
2140}
2141impl ::treesitter_types::Spanned for BaseList<'_> {
2142 fn span(&self) -> ::treesitter_types::Span {
2143 self.span
2144 }
2145}
2146#[derive(Debug, Clone, PartialEq, Eq)]
2147pub struct BinaryExpression<'tree> {
2148 pub span: ::treesitter_types::Span,
2149 pub left: BinaryExpressionLeft<'tree>,
2150 pub operator: BinaryExpressionOperator,
2151 pub right: BinaryExpressionRight<'tree>,
2152}
2153impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
2154 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2155 fn from_node(
2156 node: ::tree_sitter::Node<'tree>,
2157 src: &'tree [u8],
2158 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2159 debug_assert_eq!(node.kind(), "binary_expression");
2160 Ok(Self {
2161 span: ::treesitter_types::Span::from(node),
2162 left: {
2163 let child = node
2164 .child_by_field_name("left")
2165 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2166 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
2167 },
2168 operator: {
2169 let child = node.child_by_field_name("operator").ok_or_else(|| {
2170 ::treesitter_types::ParseError::missing_field("operator", node)
2171 })?;
2172 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
2173 },
2174 right: {
2175 let child = node
2176 .child_by_field_name("right")
2177 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2178 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
2179 },
2180 })
2181 }
2182}
2183impl ::treesitter_types::Spanned for BinaryExpression<'_> {
2184 fn span(&self) -> ::treesitter_types::Span {
2185 self.span
2186 }
2187}
2188#[derive(Debug, Clone, PartialEq, Eq)]
2189pub struct Block<'tree> {
2190 pub span: ::treesitter_types::Span,
2191 pub children: ::std::vec::Vec<Statement<'tree>>,
2192}
2193impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
2194 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2195 fn from_node(
2196 node: ::tree_sitter::Node<'tree>,
2197 src: &'tree [u8],
2198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2199 debug_assert_eq!(node.kind(), "block");
2200 Ok(Self {
2201 span: ::treesitter_types::Span::from(node),
2202 children: {
2203 #[allow(clippy::suspicious_else_formatting)]
2204 let non_field_children = {
2205 let mut cursor = node.walk();
2206 let mut result = ::std::vec::Vec::new();
2207 if cursor.goto_first_child() {
2208 loop {
2209 if cursor.field_name().is_none()
2210 && cursor.node().is_named()
2211 && !cursor.node().is_extra()
2212 {
2213 result.push(cursor.node());
2214 }
2215 if !cursor.goto_next_sibling() {
2216 break;
2217 }
2218 }
2219 }
2220 result
2221 };
2222 let mut items = ::std::vec::Vec::new();
2223 for child in non_field_children {
2224 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
2225 child, src,
2226 )?);
2227 }
2228 items
2229 },
2230 })
2231 }
2232}
2233impl ::treesitter_types::Spanned for Block<'_> {
2234 fn span(&self) -> ::treesitter_types::Span {
2235 self.span
2236 }
2237}
2238#[derive(Debug, Clone, PartialEq, Eq)]
2239pub struct BooleanLiteral<'tree> {
2240 pub span: ::treesitter_types::Span,
2241 text: &'tree str,
2242}
2243impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
2244 fn from_node(
2245 node: ::tree_sitter::Node<'tree>,
2246 src: &'tree [u8],
2247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2248 debug_assert_eq!(node.kind(), "boolean_literal");
2249 Ok(Self {
2250 span: ::treesitter_types::Span::from(node),
2251 text: node.utf8_text(src)?,
2252 })
2253 }
2254}
2255impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
2256 fn text(&self) -> &'tree str {
2257 self.text
2258 }
2259}
2260impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
2261 fn span(&self) -> ::treesitter_types::Span {
2262 self.span
2263 }
2264}
2265#[derive(Debug, Clone, PartialEq, Eq)]
2266pub struct BracketedArgumentList<'tree> {
2267 pub span: ::treesitter_types::Span,
2268 pub children: ::std::vec::Vec<Argument<'tree>>,
2269}
2270impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedArgumentList<'tree> {
2271 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2272 fn from_node(
2273 node: ::tree_sitter::Node<'tree>,
2274 src: &'tree [u8],
2275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2276 debug_assert_eq!(node.kind(), "bracketed_argument_list");
2277 Ok(Self {
2278 span: ::treesitter_types::Span::from(node),
2279 children: {
2280 #[allow(clippy::suspicious_else_formatting)]
2281 let non_field_children = {
2282 let mut cursor = node.walk();
2283 let mut result = ::std::vec::Vec::new();
2284 if cursor.goto_first_child() {
2285 loop {
2286 if cursor.field_name().is_none()
2287 && cursor.node().is_named()
2288 && !cursor.node().is_extra()
2289 {
2290 result.push(cursor.node());
2291 }
2292 if !cursor.goto_next_sibling() {
2293 break;
2294 }
2295 }
2296 }
2297 result
2298 };
2299 let mut items = ::std::vec::Vec::new();
2300 for child in non_field_children {
2301 items.push(<Argument as ::treesitter_types::FromNode>::from_node(
2302 child, src,
2303 )?);
2304 }
2305 items
2306 },
2307 })
2308 }
2309}
2310impl ::treesitter_types::Spanned for BracketedArgumentList<'_> {
2311 fn span(&self) -> ::treesitter_types::Span {
2312 self.span
2313 }
2314}
2315#[derive(Debug, Clone, PartialEq, Eq)]
2316pub struct BracketedParameterList<'tree> {
2317 pub span: ::treesitter_types::Span,
2318 pub name: ::std::vec::Vec<Identifier<'tree>>,
2319 pub r#type: ::std::vec::Vec<BracketedParameterListType<'tree>>,
2320 pub children: ::std::vec::Vec<BracketedParameterListChildren<'tree>>,
2321}
2322impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterList<'tree> {
2323 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2324 fn from_node(
2325 node: ::tree_sitter::Node<'tree>,
2326 src: &'tree [u8],
2327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2328 debug_assert_eq!(node.kind(), "bracketed_parameter_list");
2329 Ok(Self {
2330 span: ::treesitter_types::Span::from(node),
2331 name: {
2332 let mut cursor = node.walk();
2333 let mut items = ::std::vec::Vec::new();
2334 for child in node.children_by_field_name("name", &mut cursor) {
2335 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
2336 child, src,
2337 )?);
2338 }
2339 items
2340 },
2341 r#type: {
2342 let mut cursor = node.walk();
2343 let mut items = ::std::vec::Vec::new();
2344 for child in node.children_by_field_name("type", &mut cursor) {
2345 items.push(
2346 <BracketedParameterListType as ::treesitter_types::FromNode>::from_node(
2347 child, src,
2348 )?,
2349 );
2350 }
2351 items
2352 },
2353 children: {
2354 #[allow(clippy::suspicious_else_formatting)]
2355 let non_field_children = {
2356 let mut cursor = node.walk();
2357 let mut result = ::std::vec::Vec::new();
2358 if cursor.goto_first_child() {
2359 loop {
2360 if cursor.field_name().is_none()
2361 && cursor.node().is_named()
2362 && !cursor.node().is_extra()
2363 {
2364 result.push(cursor.node());
2365 }
2366 if !cursor.goto_next_sibling() {
2367 break;
2368 }
2369 }
2370 }
2371 result
2372 };
2373 let mut items = ::std::vec::Vec::new();
2374 for child in non_field_children {
2375 items
2376 .push(
2377 <BracketedParameterListChildren as ::treesitter_types::FromNode>::from_node(
2378 child,
2379 src,
2380 )?,
2381 );
2382 }
2383 items
2384 },
2385 })
2386 }
2387}
2388impl ::treesitter_types::Spanned for BracketedParameterList<'_> {
2389 fn span(&self) -> ::treesitter_types::Span {
2390 self.span
2391 }
2392}
2393#[derive(Debug, Clone, PartialEq, Eq)]
2394pub struct BreakStatement<'tree> {
2395 pub span: ::treesitter_types::Span,
2396 text: &'tree str,
2397}
2398impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
2399 fn from_node(
2400 node: ::tree_sitter::Node<'tree>,
2401 src: &'tree [u8],
2402 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2403 debug_assert_eq!(node.kind(), "break_statement");
2404 Ok(Self {
2405 span: ::treesitter_types::Span::from(node),
2406 text: node.utf8_text(src)?,
2407 })
2408 }
2409}
2410impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
2411 fn text(&self) -> &'tree str {
2412 self.text
2413 }
2414}
2415impl ::treesitter_types::Spanned for BreakStatement<'_> {
2416 fn span(&self) -> ::treesitter_types::Span {
2417 self.span
2418 }
2419}
2420#[derive(Debug, Clone, PartialEq, Eq)]
2421pub struct CallingConvention<'tree> {
2422 pub span: ::treesitter_types::Span,
2423 pub children: ::std::vec::Vec<Identifier<'tree>>,
2424}
2425impl<'tree> ::treesitter_types::FromNode<'tree> for CallingConvention<'tree> {
2426 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2427 fn from_node(
2428 node: ::tree_sitter::Node<'tree>,
2429 src: &'tree [u8],
2430 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2431 debug_assert_eq!(node.kind(), "calling_convention");
2432 Ok(Self {
2433 span: ::treesitter_types::Span::from(node),
2434 children: {
2435 #[allow(clippy::suspicious_else_formatting)]
2436 let non_field_children = {
2437 let mut cursor = node.walk();
2438 let mut result = ::std::vec::Vec::new();
2439 if cursor.goto_first_child() {
2440 loop {
2441 if cursor.field_name().is_none()
2442 && cursor.node().is_named()
2443 && !cursor.node().is_extra()
2444 {
2445 result.push(cursor.node());
2446 }
2447 if !cursor.goto_next_sibling() {
2448 break;
2449 }
2450 }
2451 }
2452 result
2453 };
2454 let mut items = ::std::vec::Vec::new();
2455 for child in non_field_children {
2456 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
2457 child, src,
2458 )?);
2459 }
2460 items
2461 },
2462 })
2463 }
2464}
2465impl ::treesitter_types::Spanned for CallingConvention<'_> {
2466 fn span(&self) -> ::treesitter_types::Span {
2467 self.span
2468 }
2469}
2470#[derive(Debug, Clone, PartialEq, Eq)]
2471pub struct CastExpression<'tree> {
2472 pub span: ::treesitter_types::Span,
2473 pub r#type: Type<'tree>,
2474 pub value: Expression<'tree>,
2475}
2476impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
2477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2478 fn from_node(
2479 node: ::tree_sitter::Node<'tree>,
2480 src: &'tree [u8],
2481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2482 debug_assert_eq!(node.kind(), "cast_expression");
2483 Ok(Self {
2484 span: ::treesitter_types::Span::from(node),
2485 r#type: {
2486 let child = node
2487 .child_by_field_name("type")
2488 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2489 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2490 },
2491 value: {
2492 let child = node
2493 .child_by_field_name("value")
2494 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2495 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2496 },
2497 })
2498 }
2499}
2500impl ::treesitter_types::Spanned for CastExpression<'_> {
2501 fn span(&self) -> ::treesitter_types::Span {
2502 self.span
2503 }
2504}
2505#[derive(Debug, Clone, PartialEq, Eq)]
2506pub struct CatchClause<'tree> {
2507 pub span: ::treesitter_types::Span,
2508 pub body: Block<'tree>,
2509 pub children: ::std::vec::Vec<CatchClauseChildren<'tree>>,
2510}
2511impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2512 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2513 fn from_node(
2514 node: ::tree_sitter::Node<'tree>,
2515 src: &'tree [u8],
2516 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2517 debug_assert_eq!(node.kind(), "catch_clause");
2518 Ok(Self {
2519 span: ::treesitter_types::Span::from(node),
2520 body: {
2521 let child = node
2522 .child_by_field_name("body")
2523 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2524 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
2525 },
2526 children: {
2527 #[allow(clippy::suspicious_else_formatting)]
2528 let non_field_children = {
2529 let mut cursor = node.walk();
2530 let mut result = ::std::vec::Vec::new();
2531 if cursor.goto_first_child() {
2532 loop {
2533 if cursor.field_name().is_none()
2534 && cursor.node().is_named()
2535 && !cursor.node().is_extra()
2536 {
2537 result.push(cursor.node());
2538 }
2539 if !cursor.goto_next_sibling() {
2540 break;
2541 }
2542 }
2543 }
2544 result
2545 };
2546 let mut items = ::std::vec::Vec::new();
2547 for child in non_field_children {
2548 items.push(
2549 <CatchClauseChildren as ::treesitter_types::FromNode>::from_node(
2550 child, src,
2551 )?,
2552 );
2553 }
2554 items
2555 },
2556 })
2557 }
2558}
2559impl ::treesitter_types::Spanned for CatchClause<'_> {
2560 fn span(&self) -> ::treesitter_types::Span {
2561 self.span
2562 }
2563}
2564#[derive(Debug, Clone, PartialEq, Eq)]
2565pub struct CatchDeclaration<'tree> {
2566 pub span: ::treesitter_types::Span,
2567 pub name: ::core::option::Option<Identifier<'tree>>,
2568 pub r#type: Type<'tree>,
2569}
2570impl<'tree> ::treesitter_types::FromNode<'tree> for CatchDeclaration<'tree> {
2571 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2572 fn from_node(
2573 node: ::tree_sitter::Node<'tree>,
2574 src: &'tree [u8],
2575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2576 debug_assert_eq!(node.kind(), "catch_declaration");
2577 Ok(Self {
2578 span: ::treesitter_types::Span::from(node),
2579 name: match node.child_by_field_name("name") {
2580 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2581 child, src,
2582 )?),
2583 None => None,
2584 },
2585 r#type: {
2586 let child = node
2587 .child_by_field_name("type")
2588 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2589 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2590 },
2591 })
2592 }
2593}
2594impl ::treesitter_types::Spanned for CatchDeclaration<'_> {
2595 fn span(&self) -> ::treesitter_types::Span {
2596 self.span
2597 }
2598}
2599#[derive(Debug, Clone, PartialEq, Eq)]
2600pub struct CatchFilterClause<'tree> {
2601 pub span: ::treesitter_types::Span,
2602 pub children: Expression<'tree>,
2603}
2604impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFilterClause<'tree> {
2605 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2606 fn from_node(
2607 node: ::tree_sitter::Node<'tree>,
2608 src: &'tree [u8],
2609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2610 debug_assert_eq!(node.kind(), "catch_filter_clause");
2611 Ok(Self {
2612 span: ::treesitter_types::Span::from(node),
2613 children: {
2614 #[allow(clippy::suspicious_else_formatting)]
2615 let non_field_children = {
2616 let mut cursor = node.walk();
2617 let mut result = ::std::vec::Vec::new();
2618 if cursor.goto_first_child() {
2619 loop {
2620 if cursor.field_name().is_none()
2621 && cursor.node().is_named()
2622 && !cursor.node().is_extra()
2623 {
2624 result.push(cursor.node());
2625 }
2626 if !cursor.goto_next_sibling() {
2627 break;
2628 }
2629 }
2630 }
2631 result
2632 };
2633 let child = if let Some(&c) = non_field_children.first() {
2634 c
2635 } else {
2636 let mut fallback_cursor = node.walk();
2637 let mut fallback_child = None;
2638 if fallback_cursor.goto_first_child() {
2639 loop {
2640 if fallback_cursor.field_name().is_none()
2641 && !fallback_cursor.node().is_extra()
2642 {
2643 let candidate = fallback_cursor.node();
2644 #[allow(clippy::needless_question_mark)]
2645 if (|| -> ::core::result::Result<
2646 _,
2647 ::treesitter_types::ParseError,
2648 > {
2649 let child = candidate;
2650 Ok(
2651 <Expression as ::treesitter_types::FromNode>::from_node(
2652 child,
2653 src,
2654 )?,
2655 )
2656 })()
2657 .is_ok()
2658 {
2659 fallback_child = Some(candidate);
2660 break;
2661 }
2662 }
2663 if !fallback_cursor.goto_next_sibling() {
2664 break;
2665 }
2666 }
2667 }
2668 if fallback_child.is_none() {
2669 let mut cursor2 = node.walk();
2670 if cursor2.goto_first_child() {
2671 loop {
2672 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2673 let candidate = cursor2.node();
2674 #[allow(clippy::needless_question_mark)]
2675 if (|| -> ::core::result::Result<
2676 _,
2677 ::treesitter_types::ParseError,
2678 > {
2679 let child = candidate;
2680 Ok(
2681 <Expression as ::treesitter_types::FromNode>::from_node(
2682 child,
2683 src,
2684 )?,
2685 )
2686 })()
2687 .is_ok()
2688 {
2689 fallback_child = Some(candidate);
2690 break;
2691 }
2692 }
2693 if !cursor2.goto_next_sibling() {
2694 break;
2695 }
2696 }
2697 }
2698 }
2699 fallback_child.ok_or_else(|| {
2700 ::treesitter_types::ParseError::missing_field("children", node)
2701 })?
2702 };
2703 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2704 },
2705 })
2706 }
2707}
2708impl ::treesitter_types::Spanned for CatchFilterClause<'_> {
2709 fn span(&self) -> ::treesitter_types::Span {
2710 self.span
2711 }
2712}
2713#[derive(Debug, Clone, PartialEq, Eq)]
2714pub struct CharacterLiteral<'tree> {
2715 pub span: ::treesitter_types::Span,
2716 pub children: CharacterLiteralChildren<'tree>,
2717}
2718impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
2719 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2720 fn from_node(
2721 node: ::tree_sitter::Node<'tree>,
2722 src: &'tree [u8],
2723 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2724 debug_assert_eq!(node.kind(), "character_literal");
2725 Ok(Self {
2726 span: ::treesitter_types::Span::from(node),
2727 children: {
2728 #[allow(clippy::suspicious_else_formatting)]
2729 let non_field_children = {
2730 let mut cursor = node.walk();
2731 let mut result = ::std::vec::Vec::new();
2732 if cursor.goto_first_child() {
2733 loop {
2734 if cursor.field_name().is_none()
2735 && cursor.node().is_named()
2736 && !cursor.node().is_extra()
2737 {
2738 result.push(cursor.node());
2739 }
2740 if !cursor.goto_next_sibling() {
2741 break;
2742 }
2743 }
2744 }
2745 result
2746 };
2747 let child = if let Some(&c) = non_field_children.first() {
2748 c
2749 } else {
2750 let mut fallback_cursor = node.walk();
2751 let mut fallback_child = None;
2752 if fallback_cursor.goto_first_child() {
2753 loop {
2754 if fallback_cursor.field_name().is_none()
2755 && !fallback_cursor.node().is_extra()
2756 {
2757 let candidate = fallback_cursor.node();
2758 #[allow(clippy::needless_question_mark)]
2759 if (|| -> ::core::result::Result<
2760 _,
2761 ::treesitter_types::ParseError,
2762 > {
2763 let child = candidate;
2764 Ok(
2765 <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
2766 child,
2767 src,
2768 )?,
2769 )
2770 })()
2771 .is_ok()
2772 {
2773 fallback_child = Some(candidate);
2774 break;
2775 }
2776 }
2777 if !fallback_cursor.goto_next_sibling() {
2778 break;
2779 }
2780 }
2781 }
2782 if fallback_child.is_none() {
2783 let mut cursor2 = node.walk();
2784 if cursor2.goto_first_child() {
2785 loop {
2786 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2787 let candidate = cursor2.node();
2788 #[allow(clippy::needless_question_mark)]
2789 if (|| -> ::core::result::Result<
2790 _,
2791 ::treesitter_types::ParseError,
2792 > {
2793 let child = candidate;
2794 Ok(
2795 <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
2796 child,
2797 src,
2798 )?,
2799 )
2800 })()
2801 .is_ok()
2802 {
2803 fallback_child = Some(candidate);
2804 break;
2805 }
2806 }
2807 if !cursor2.goto_next_sibling() {
2808 break;
2809 }
2810 }
2811 }
2812 }
2813 fallback_child.ok_or_else(|| {
2814 ::treesitter_types::ParseError::missing_field("children", node)
2815 })?
2816 };
2817 <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2818 },
2819 })
2820 }
2821}
2822impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
2823 fn span(&self) -> ::treesitter_types::Span {
2824 self.span
2825 }
2826}
2827#[derive(Debug, Clone, PartialEq, Eq)]
2828pub struct CheckedExpression<'tree> {
2829 pub span: ::treesitter_types::Span,
2830 pub children: Expression<'tree>,
2831}
2832impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedExpression<'tree> {
2833 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2834 fn from_node(
2835 node: ::tree_sitter::Node<'tree>,
2836 src: &'tree [u8],
2837 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2838 debug_assert_eq!(node.kind(), "checked_expression");
2839 Ok(Self {
2840 span: ::treesitter_types::Span::from(node),
2841 children: {
2842 #[allow(clippy::suspicious_else_formatting)]
2843 let non_field_children = {
2844 let mut cursor = node.walk();
2845 let mut result = ::std::vec::Vec::new();
2846 if cursor.goto_first_child() {
2847 loop {
2848 if cursor.field_name().is_none()
2849 && cursor.node().is_named()
2850 && !cursor.node().is_extra()
2851 {
2852 result.push(cursor.node());
2853 }
2854 if !cursor.goto_next_sibling() {
2855 break;
2856 }
2857 }
2858 }
2859 result
2860 };
2861 let child = if let Some(&c) = non_field_children.first() {
2862 c
2863 } else {
2864 let mut fallback_cursor = node.walk();
2865 let mut fallback_child = None;
2866 if fallback_cursor.goto_first_child() {
2867 loop {
2868 if fallback_cursor.field_name().is_none()
2869 && !fallback_cursor.node().is_extra()
2870 {
2871 let candidate = fallback_cursor.node();
2872 #[allow(clippy::needless_question_mark)]
2873 if (|| -> ::core::result::Result<
2874 _,
2875 ::treesitter_types::ParseError,
2876 > {
2877 let child = candidate;
2878 Ok(
2879 <Expression as ::treesitter_types::FromNode>::from_node(
2880 child,
2881 src,
2882 )?,
2883 )
2884 })()
2885 .is_ok()
2886 {
2887 fallback_child = Some(candidate);
2888 break;
2889 }
2890 }
2891 if !fallback_cursor.goto_next_sibling() {
2892 break;
2893 }
2894 }
2895 }
2896 if fallback_child.is_none() {
2897 let mut cursor2 = node.walk();
2898 if cursor2.goto_first_child() {
2899 loop {
2900 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2901 let candidate = cursor2.node();
2902 #[allow(clippy::needless_question_mark)]
2903 if (|| -> ::core::result::Result<
2904 _,
2905 ::treesitter_types::ParseError,
2906 > {
2907 let child = candidate;
2908 Ok(
2909 <Expression as ::treesitter_types::FromNode>::from_node(
2910 child,
2911 src,
2912 )?,
2913 )
2914 })()
2915 .is_ok()
2916 {
2917 fallback_child = Some(candidate);
2918 break;
2919 }
2920 }
2921 if !cursor2.goto_next_sibling() {
2922 break;
2923 }
2924 }
2925 }
2926 }
2927 fallback_child.ok_or_else(|| {
2928 ::treesitter_types::ParseError::missing_field("children", node)
2929 })?
2930 };
2931 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2932 },
2933 })
2934 }
2935}
2936impl ::treesitter_types::Spanned for CheckedExpression<'_> {
2937 fn span(&self) -> ::treesitter_types::Span {
2938 self.span
2939 }
2940}
2941#[derive(Debug, Clone, PartialEq, Eq)]
2942pub struct CheckedStatement<'tree> {
2943 pub span: ::treesitter_types::Span,
2944 pub children: Block<'tree>,
2945}
2946impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedStatement<'tree> {
2947 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2948 fn from_node(
2949 node: ::tree_sitter::Node<'tree>,
2950 src: &'tree [u8],
2951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2952 debug_assert_eq!(node.kind(), "checked_statement");
2953 Ok(Self {
2954 span: ::treesitter_types::Span::from(node),
2955 children: {
2956 #[allow(clippy::suspicious_else_formatting)]
2957 let non_field_children = {
2958 let mut cursor = node.walk();
2959 let mut result = ::std::vec::Vec::new();
2960 if cursor.goto_first_child() {
2961 loop {
2962 if cursor.field_name().is_none()
2963 && cursor.node().is_named()
2964 && !cursor.node().is_extra()
2965 {
2966 result.push(cursor.node());
2967 }
2968 if !cursor.goto_next_sibling() {
2969 break;
2970 }
2971 }
2972 }
2973 result
2974 };
2975 let child = if let Some(&c) = non_field_children.first() {
2976 c
2977 } else {
2978 let mut fallback_cursor = node.walk();
2979 let mut fallback_child = None;
2980 if fallback_cursor.goto_first_child() {
2981 loop {
2982 if fallback_cursor.field_name().is_none()
2983 && !fallback_cursor.node().is_extra()
2984 {
2985 let candidate = fallback_cursor.node();
2986 #[allow(clippy::needless_question_mark)]
2987 if (|| -> ::core::result::Result<
2988 _,
2989 ::treesitter_types::ParseError,
2990 > {
2991 let child = candidate;
2992 Ok(
2993 <Block as ::treesitter_types::FromNode>::from_node(
2994 child,
2995 src,
2996 )?,
2997 )
2998 })()
2999 .is_ok()
3000 {
3001 fallback_child = Some(candidate);
3002 break;
3003 }
3004 }
3005 if !fallback_cursor.goto_next_sibling() {
3006 break;
3007 }
3008 }
3009 }
3010 if fallback_child.is_none() {
3011 let mut cursor2 = node.walk();
3012 if cursor2.goto_first_child() {
3013 loop {
3014 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3015 let candidate = cursor2.node();
3016 #[allow(clippy::needless_question_mark)]
3017 if (|| -> ::core::result::Result<
3018 _,
3019 ::treesitter_types::ParseError,
3020 > {
3021 let child = candidate;
3022 Ok(
3023 <Block as ::treesitter_types::FromNode>::from_node(
3024 child,
3025 src,
3026 )?,
3027 )
3028 })()
3029 .is_ok()
3030 {
3031 fallback_child = Some(candidate);
3032 break;
3033 }
3034 }
3035 if !cursor2.goto_next_sibling() {
3036 break;
3037 }
3038 }
3039 }
3040 }
3041 fallback_child.ok_or_else(|| {
3042 ::treesitter_types::ParseError::missing_field("children", node)
3043 })?
3044 };
3045 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3046 },
3047 })
3048 }
3049}
3050impl ::treesitter_types::Spanned for CheckedStatement<'_> {
3051 fn span(&self) -> ::treesitter_types::Span {
3052 self.span
3053 }
3054}
3055#[derive(Debug, Clone, PartialEq, Eq)]
3056pub struct ClassDeclaration<'tree> {
3057 pub span: ::treesitter_types::Span,
3058 pub body: DeclarationList<'tree>,
3059 pub name: Identifier<'tree>,
3060 pub children: ::std::vec::Vec<ClassDeclarationChildren<'tree>>,
3061}
3062impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
3063 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3064 fn from_node(
3065 node: ::tree_sitter::Node<'tree>,
3066 src: &'tree [u8],
3067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3068 debug_assert_eq!(node.kind(), "class_declaration");
3069 Ok(Self {
3070 span: ::treesitter_types::Span::from(node),
3071 body: {
3072 let child = node
3073 .child_by_field_name("body")
3074 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3075 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
3076 },
3077 name: {
3078 let child = node
3079 .child_by_field_name("name")
3080 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3081 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3082 },
3083 children: {
3084 #[allow(clippy::suspicious_else_formatting)]
3085 let non_field_children = {
3086 let mut cursor = node.walk();
3087 let mut result = ::std::vec::Vec::new();
3088 if cursor.goto_first_child() {
3089 loop {
3090 if cursor.field_name().is_none()
3091 && cursor.node().is_named()
3092 && !cursor.node().is_extra()
3093 {
3094 result.push(cursor.node());
3095 }
3096 if !cursor.goto_next_sibling() {
3097 break;
3098 }
3099 }
3100 }
3101 result
3102 };
3103 let mut items = ::std::vec::Vec::new();
3104 for child in non_field_children {
3105 items.push(
3106 <ClassDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3107 child, src,
3108 )?,
3109 );
3110 }
3111 items
3112 },
3113 })
3114 }
3115}
3116impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
3117 fn span(&self) -> ::treesitter_types::Span {
3118 self.span
3119 }
3120}
3121#[derive(Debug, Clone, PartialEq, Eq)]
3122pub struct CompilationUnit<'tree> {
3123 pub span: ::treesitter_types::Span,
3124 pub children: ::std::vec::Vec<CompilationUnitChildren<'tree>>,
3125}
3126impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnit<'tree> {
3127 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3128 fn from_node(
3129 node: ::tree_sitter::Node<'tree>,
3130 src: &'tree [u8],
3131 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3132 debug_assert_eq!(node.kind(), "compilation_unit");
3133 Ok(Self {
3134 span: ::treesitter_types::Span::from(node),
3135 children: {
3136 #[allow(clippy::suspicious_else_formatting)]
3137 let non_field_children = {
3138 let mut cursor = node.walk();
3139 let mut result = ::std::vec::Vec::new();
3140 if cursor.goto_first_child() {
3141 loop {
3142 if cursor.field_name().is_none()
3143 && cursor.node().is_named()
3144 && !cursor.node().is_extra()
3145 {
3146 result.push(cursor.node());
3147 }
3148 if !cursor.goto_next_sibling() {
3149 break;
3150 }
3151 }
3152 }
3153 result
3154 };
3155 let mut items = ::std::vec::Vec::new();
3156 for child in non_field_children {
3157 items.push(
3158 <CompilationUnitChildren as ::treesitter_types::FromNode>::from_node(
3159 child, src,
3160 )?,
3161 );
3162 }
3163 items
3164 },
3165 })
3166 }
3167}
3168impl ::treesitter_types::Spanned for CompilationUnit<'_> {
3169 fn span(&self) -> ::treesitter_types::Span {
3170 self.span
3171 }
3172}
3173#[derive(Debug, Clone, PartialEq, Eq)]
3174pub struct ConditionalAccessExpression<'tree> {
3175 pub span: ::treesitter_types::Span,
3176 pub condition: Expression<'tree>,
3177 pub children: ConditionalAccessExpressionChildren<'tree>,
3178}
3179impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpression<'tree> {
3180 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3181 fn from_node(
3182 node: ::tree_sitter::Node<'tree>,
3183 src: &'tree [u8],
3184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3185 debug_assert_eq!(node.kind(), "conditional_access_expression");
3186 Ok(Self {
3187 span: ::treesitter_types::Span::from(node),
3188 condition: {
3189 let child = node.child_by_field_name("condition").ok_or_else(|| {
3190 ::treesitter_types::ParseError::missing_field("condition", node)
3191 })?;
3192 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3193 },
3194 children: {
3195 #[allow(clippy::suspicious_else_formatting)]
3196 let non_field_children = {
3197 let mut cursor = node.walk();
3198 let mut result = ::std::vec::Vec::new();
3199 if cursor.goto_first_child() {
3200 loop {
3201 if cursor.field_name().is_none()
3202 && cursor.node().is_named()
3203 && !cursor.node().is_extra()
3204 {
3205 result.push(cursor.node());
3206 }
3207 if !cursor.goto_next_sibling() {
3208 break;
3209 }
3210 }
3211 }
3212 result
3213 };
3214 let child = if let Some(&c) = non_field_children.first() {
3215 c
3216 } else {
3217 let mut fallback_cursor = node.walk();
3218 let mut fallback_child = None;
3219 if fallback_cursor.goto_first_child() {
3220 loop {
3221 if fallback_cursor.field_name().is_none()
3222 && !fallback_cursor.node().is_extra()
3223 {
3224 let candidate = fallback_cursor.node();
3225 #[allow(clippy::needless_question_mark)]
3226 if (|| -> ::core::result::Result<
3227 _,
3228 ::treesitter_types::ParseError,
3229 > {
3230 let child = candidate;
3231 Ok(
3232 <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3233 child,
3234 src,
3235 )?,
3236 )
3237 })()
3238 .is_ok()
3239 {
3240 fallback_child = Some(candidate);
3241 break;
3242 }
3243 }
3244 if !fallback_cursor.goto_next_sibling() {
3245 break;
3246 }
3247 }
3248 }
3249 if fallback_child.is_none() {
3250 let mut cursor2 = node.walk();
3251 if cursor2.goto_first_child() {
3252 loop {
3253 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3254 let candidate = cursor2.node();
3255 #[allow(clippy::needless_question_mark)]
3256 if (|| -> ::core::result::Result<
3257 _,
3258 ::treesitter_types::ParseError,
3259 > {
3260 let child = candidate;
3261 Ok(
3262 <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3263 child,
3264 src,
3265 )?,
3266 )
3267 })()
3268 .is_ok()
3269 {
3270 fallback_child = Some(candidate);
3271 break;
3272 }
3273 }
3274 if !cursor2.goto_next_sibling() {
3275 break;
3276 }
3277 }
3278 }
3279 }
3280 fallback_child.ok_or_else(|| {
3281 ::treesitter_types::ParseError::missing_field("children", node)
3282 })?
3283 };
3284 <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3285 child, src,
3286 )?
3287 },
3288 })
3289 }
3290}
3291impl ::treesitter_types::Spanned for ConditionalAccessExpression<'_> {
3292 fn span(&self) -> ::treesitter_types::Span {
3293 self.span
3294 }
3295}
3296#[derive(Debug, Clone, PartialEq, Eq)]
3297pub struct ConditionalExpression<'tree> {
3298 pub span: ::treesitter_types::Span,
3299 pub alternative: Expression<'tree>,
3300 pub condition: Expression<'tree>,
3301 pub consequence: Expression<'tree>,
3302}
3303impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
3304 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3305 fn from_node(
3306 node: ::tree_sitter::Node<'tree>,
3307 src: &'tree [u8],
3308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3309 debug_assert_eq!(node.kind(), "conditional_expression");
3310 Ok(Self {
3311 span: ::treesitter_types::Span::from(node),
3312 alternative: {
3313 let child = node.child_by_field_name("alternative").ok_or_else(|| {
3314 ::treesitter_types::ParseError::missing_field("alternative", node)
3315 })?;
3316 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3317 },
3318 condition: {
3319 let child = node.child_by_field_name("condition").ok_or_else(|| {
3320 ::treesitter_types::ParseError::missing_field("condition", node)
3321 })?;
3322 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3323 },
3324 consequence: {
3325 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3326 ::treesitter_types::ParseError::missing_field("consequence", node)
3327 })?;
3328 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3329 },
3330 })
3331 }
3332}
3333impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
3334 fn span(&self) -> ::treesitter_types::Span {
3335 self.span
3336 }
3337}
3338#[derive(Debug, Clone, PartialEq, Eq)]
3339pub struct ConstantPattern<'tree> {
3340 pub span: ::treesitter_types::Span,
3341 pub children: ConstantPatternChildren<'tree>,
3342}
3343impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPattern<'tree> {
3344 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3345 fn from_node(
3346 node: ::tree_sitter::Node<'tree>,
3347 src: &'tree [u8],
3348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3349 debug_assert_eq!(node.kind(), "constant_pattern");
3350 Ok(Self {
3351 span: ::treesitter_types::Span::from(node),
3352 children: {
3353 #[allow(clippy::suspicious_else_formatting)]
3354 let non_field_children = {
3355 let mut cursor = node.walk();
3356 let mut result = ::std::vec::Vec::new();
3357 if cursor.goto_first_child() {
3358 loop {
3359 if cursor.field_name().is_none()
3360 && cursor.node().is_named()
3361 && !cursor.node().is_extra()
3362 {
3363 result.push(cursor.node());
3364 }
3365 if !cursor.goto_next_sibling() {
3366 break;
3367 }
3368 }
3369 }
3370 result
3371 };
3372 let child = if let Some(&c) = non_field_children.first() {
3373 c
3374 } else {
3375 let mut fallback_cursor = node.walk();
3376 let mut fallback_child = None;
3377 if fallback_cursor.goto_first_child() {
3378 loop {
3379 if fallback_cursor.field_name().is_none()
3380 && !fallback_cursor.node().is_extra()
3381 {
3382 let candidate = fallback_cursor.node();
3383 #[allow(clippy::needless_question_mark)]
3384 if (|| -> ::core::result::Result<
3385 _,
3386 ::treesitter_types::ParseError,
3387 > {
3388 let child = candidate;
3389 Ok(
3390 <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3391 child,
3392 src,
3393 )?,
3394 )
3395 })()
3396 .is_ok()
3397 {
3398 fallback_child = Some(candidate);
3399 break;
3400 }
3401 }
3402 if !fallback_cursor.goto_next_sibling() {
3403 break;
3404 }
3405 }
3406 }
3407 if fallback_child.is_none() {
3408 let mut cursor2 = node.walk();
3409 if cursor2.goto_first_child() {
3410 loop {
3411 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3412 let candidate = cursor2.node();
3413 #[allow(clippy::needless_question_mark)]
3414 if (|| -> ::core::result::Result<
3415 _,
3416 ::treesitter_types::ParseError,
3417 > {
3418 let child = candidate;
3419 Ok(
3420 <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3421 child,
3422 src,
3423 )?,
3424 )
3425 })()
3426 .is_ok()
3427 {
3428 fallback_child = Some(candidate);
3429 break;
3430 }
3431 }
3432 if !cursor2.goto_next_sibling() {
3433 break;
3434 }
3435 }
3436 }
3437 }
3438 fallback_child.ok_or_else(|| {
3439 ::treesitter_types::ParseError::missing_field("children", node)
3440 })?
3441 };
3442 <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3443 },
3444 })
3445 }
3446}
3447impl ::treesitter_types::Spanned for ConstantPattern<'_> {
3448 fn span(&self) -> ::treesitter_types::Span {
3449 self.span
3450 }
3451}
3452#[derive(Debug, Clone, PartialEq, Eq)]
3453pub struct ConstructorConstraint<'tree> {
3454 pub span: ::treesitter_types::Span,
3455 text: &'tree str,
3456}
3457impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorConstraint<'tree> {
3458 fn from_node(
3459 node: ::tree_sitter::Node<'tree>,
3460 src: &'tree [u8],
3461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3462 debug_assert_eq!(node.kind(), "constructor_constraint");
3463 Ok(Self {
3464 span: ::treesitter_types::Span::from(node),
3465 text: node.utf8_text(src)?,
3466 })
3467 }
3468}
3469impl<'tree> ::treesitter_types::LeafNode<'tree> for ConstructorConstraint<'tree> {
3470 fn text(&self) -> &'tree str {
3471 self.text
3472 }
3473}
3474impl ::treesitter_types::Spanned for ConstructorConstraint<'_> {
3475 fn span(&self) -> ::treesitter_types::Span {
3476 self.span
3477 }
3478}
3479#[derive(Debug, Clone, PartialEq, Eq)]
3480pub struct ConstructorDeclaration<'tree> {
3481 pub span: ::treesitter_types::Span,
3482 pub body: ::core::option::Option<ConstructorDeclarationBody<'tree>>,
3483 pub name: Identifier<'tree>,
3484 pub parameters: ParameterList<'tree>,
3485 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
3486}
3487impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
3488 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3489 fn from_node(
3490 node: ::tree_sitter::Node<'tree>,
3491 src: &'tree [u8],
3492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3493 debug_assert_eq!(node.kind(), "constructor_declaration");
3494 Ok(Self {
3495 span: ::treesitter_types::Span::from(node),
3496 body: match node.child_by_field_name("body") {
3497 Some(child) => Some(
3498 <ConstructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
3499 child, src,
3500 )?,
3501 ),
3502 None => None,
3503 },
3504 name: {
3505 let child = node
3506 .child_by_field_name("name")
3507 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3508 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3509 },
3510 parameters: {
3511 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3512 ::treesitter_types::ParseError::missing_field("parameters", node)
3513 })?;
3514 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
3515 },
3516 children: {
3517 #[allow(clippy::suspicious_else_formatting)]
3518 let non_field_children = {
3519 let mut cursor = node.walk();
3520 let mut result = ::std::vec::Vec::new();
3521 if cursor.goto_first_child() {
3522 loop {
3523 if cursor.field_name().is_none()
3524 && cursor.node().is_named()
3525 && !cursor.node().is_extra()
3526 {
3527 result.push(cursor.node());
3528 }
3529 if !cursor.goto_next_sibling() {
3530 break;
3531 }
3532 }
3533 }
3534 result
3535 };
3536 let mut items = ::std::vec::Vec::new();
3537 for child in non_field_children {
3538 items
3539 .push(
3540 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3541 child,
3542 src,
3543 )?,
3544 );
3545 }
3546 items
3547 },
3548 })
3549 }
3550}
3551impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
3552 fn span(&self) -> ::treesitter_types::Span {
3553 self.span
3554 }
3555}
3556#[derive(Debug, Clone, PartialEq, Eq)]
3557pub struct ConstructorInitializer<'tree> {
3558 pub span: ::treesitter_types::Span,
3559 pub children: ArgumentList<'tree>,
3560}
3561impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorInitializer<'tree> {
3562 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3563 fn from_node(
3564 node: ::tree_sitter::Node<'tree>,
3565 src: &'tree [u8],
3566 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3567 debug_assert_eq!(node.kind(), "constructor_initializer");
3568 Ok(Self {
3569 span: ::treesitter_types::Span::from(node),
3570 children: {
3571 #[allow(clippy::suspicious_else_formatting)]
3572 let non_field_children = {
3573 let mut cursor = node.walk();
3574 let mut result = ::std::vec::Vec::new();
3575 if cursor.goto_first_child() {
3576 loop {
3577 if cursor.field_name().is_none()
3578 && cursor.node().is_named()
3579 && !cursor.node().is_extra()
3580 {
3581 result.push(cursor.node());
3582 }
3583 if !cursor.goto_next_sibling() {
3584 break;
3585 }
3586 }
3587 }
3588 result
3589 };
3590 let child = if let Some(&c) = non_field_children.first() {
3591 c
3592 } else {
3593 let mut fallback_cursor = node.walk();
3594 let mut fallback_child = None;
3595 if fallback_cursor.goto_first_child() {
3596 loop {
3597 if fallback_cursor.field_name().is_none()
3598 && !fallback_cursor.node().is_extra()
3599 {
3600 let candidate = fallback_cursor.node();
3601 #[allow(clippy::needless_question_mark)]
3602 if (|| -> ::core::result::Result<
3603 _,
3604 ::treesitter_types::ParseError,
3605 > {
3606 let child = candidate;
3607 Ok(
3608 <ArgumentList as ::treesitter_types::FromNode>::from_node(
3609 child,
3610 src,
3611 )?,
3612 )
3613 })()
3614 .is_ok()
3615 {
3616 fallback_child = Some(candidate);
3617 break;
3618 }
3619 }
3620 if !fallback_cursor.goto_next_sibling() {
3621 break;
3622 }
3623 }
3624 }
3625 if fallback_child.is_none() {
3626 let mut cursor2 = node.walk();
3627 if cursor2.goto_first_child() {
3628 loop {
3629 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3630 let candidate = cursor2.node();
3631 #[allow(clippy::needless_question_mark)]
3632 if (|| -> ::core::result::Result<
3633 _,
3634 ::treesitter_types::ParseError,
3635 > {
3636 let child = candidate;
3637 Ok(
3638 <ArgumentList as ::treesitter_types::FromNode>::from_node(
3639 child,
3640 src,
3641 )?,
3642 )
3643 })()
3644 .is_ok()
3645 {
3646 fallback_child = Some(candidate);
3647 break;
3648 }
3649 }
3650 if !cursor2.goto_next_sibling() {
3651 break;
3652 }
3653 }
3654 }
3655 }
3656 fallback_child.ok_or_else(|| {
3657 ::treesitter_types::ParseError::missing_field("children", node)
3658 })?
3659 };
3660 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
3661 },
3662 })
3663 }
3664}
3665impl ::treesitter_types::Spanned for ConstructorInitializer<'_> {
3666 fn span(&self) -> ::treesitter_types::Span {
3667 self.span
3668 }
3669}
3670#[derive(Debug, Clone, PartialEq, Eq)]
3671pub struct ContinueStatement<'tree> {
3672 pub span: ::treesitter_types::Span,
3673 text: &'tree str,
3674}
3675impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
3676 fn from_node(
3677 node: ::tree_sitter::Node<'tree>,
3678 src: &'tree [u8],
3679 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3680 debug_assert_eq!(node.kind(), "continue_statement");
3681 Ok(Self {
3682 span: ::treesitter_types::Span::from(node),
3683 text: node.utf8_text(src)?,
3684 })
3685 }
3686}
3687impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
3688 fn text(&self) -> &'tree str {
3689 self.text
3690 }
3691}
3692impl ::treesitter_types::Spanned for ContinueStatement<'_> {
3693 fn span(&self) -> ::treesitter_types::Span {
3694 self.span
3695 }
3696}
3697#[derive(Debug, Clone, PartialEq, Eq)]
3698pub struct ConversionOperatorDeclaration<'tree> {
3699 pub span: ::treesitter_types::Span,
3700 pub body: ::core::option::Option<ConversionOperatorDeclarationBody<'tree>>,
3701 pub parameters: ParameterList<'tree>,
3702 pub r#type: Type<'tree>,
3703 pub children: ::std::vec::Vec<ConversionOperatorDeclarationChildren<'tree>>,
3704}
3705impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclaration<'tree> {
3706 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3707 fn from_node(
3708 node: ::tree_sitter::Node<'tree>,
3709 src: &'tree [u8],
3710 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3711 debug_assert_eq!(node.kind(), "conversion_operator_declaration");
3712 Ok(Self {
3713 span: ::treesitter_types::Span::from(node),
3714 body: match node.child_by_field_name("body") {
3715 Some(child) => Some(
3716 <ConversionOperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(
3717 child, src,
3718 )?,
3719 ),
3720 None => None,
3721 },
3722 parameters: {
3723 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3724 ::treesitter_types::ParseError::missing_field("parameters", node)
3725 })?;
3726 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
3727 },
3728 r#type: {
3729 let child = node
3730 .child_by_field_name("type")
3731 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3732 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3733 },
3734 children: {
3735 #[allow(clippy::suspicious_else_formatting)]
3736 let non_field_children = {
3737 let mut cursor = node.walk();
3738 let mut result = ::std::vec::Vec::new();
3739 if cursor.goto_first_child() {
3740 loop {
3741 if cursor.field_name().is_none()
3742 && cursor.node().is_named()
3743 && !cursor.node().is_extra()
3744 {
3745 result.push(cursor.node());
3746 }
3747 if !cursor.goto_next_sibling() {
3748 break;
3749 }
3750 }
3751 }
3752 result
3753 };
3754 let mut items = ::std::vec::Vec::new();
3755 for child in non_field_children {
3756 items
3757 .push(
3758 <ConversionOperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3759 child,
3760 src,
3761 )?,
3762 );
3763 }
3764 items
3765 },
3766 })
3767 }
3768}
3769impl ::treesitter_types::Spanned for ConversionOperatorDeclaration<'_> {
3770 fn span(&self) -> ::treesitter_types::Span {
3771 self.span
3772 }
3773}
3774#[derive(Debug, Clone, PartialEq, Eq)]
3775pub struct DeclarationExpression<'tree> {
3776 pub span: ::treesitter_types::Span,
3777 pub name: Identifier<'tree>,
3778 pub r#type: Type<'tree>,
3779}
3780impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationExpression<'tree> {
3781 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3782 fn from_node(
3783 node: ::tree_sitter::Node<'tree>,
3784 src: &'tree [u8],
3785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3786 debug_assert_eq!(node.kind(), "declaration_expression");
3787 Ok(Self {
3788 span: ::treesitter_types::Span::from(node),
3789 name: {
3790 let child = node
3791 .child_by_field_name("name")
3792 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3793 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3794 },
3795 r#type: {
3796 let child = node
3797 .child_by_field_name("type")
3798 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3799 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3800 },
3801 })
3802 }
3803}
3804impl ::treesitter_types::Spanned for DeclarationExpression<'_> {
3805 fn span(&self) -> ::treesitter_types::Span {
3806 self.span
3807 }
3808}
3809#[derive(Debug, Clone, PartialEq, Eq)]
3810pub struct DeclarationList<'tree> {
3811 pub span: ::treesitter_types::Span,
3812 pub children: ::std::vec::Vec<Declaration<'tree>>,
3813}
3814impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
3815 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3816 fn from_node(
3817 node: ::tree_sitter::Node<'tree>,
3818 src: &'tree [u8],
3819 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3820 debug_assert_eq!(node.kind(), "declaration_list");
3821 Ok(Self {
3822 span: ::treesitter_types::Span::from(node),
3823 children: {
3824 #[allow(clippy::suspicious_else_formatting)]
3825 let non_field_children = {
3826 let mut cursor = node.walk();
3827 let mut result = ::std::vec::Vec::new();
3828 if cursor.goto_first_child() {
3829 loop {
3830 if cursor.field_name().is_none()
3831 && cursor.node().is_named()
3832 && !cursor.node().is_extra()
3833 {
3834 result.push(cursor.node());
3835 }
3836 if !cursor.goto_next_sibling() {
3837 break;
3838 }
3839 }
3840 }
3841 result
3842 };
3843 let mut items = ::std::vec::Vec::new();
3844 for child in non_field_children {
3845 items.push(<Declaration as ::treesitter_types::FromNode>::from_node(
3846 child, src,
3847 )?);
3848 }
3849 items
3850 },
3851 })
3852 }
3853}
3854impl ::treesitter_types::Spanned for DeclarationList<'_> {
3855 fn span(&self) -> ::treesitter_types::Span {
3856 self.span
3857 }
3858}
3859#[derive(Debug, Clone, PartialEq, Eq)]
3860pub struct DeclarationPattern<'tree> {
3861 pub span: ::treesitter_types::Span,
3862 pub name: ::core::option::Option<Identifier<'tree>>,
3863 pub r#type: Type<'tree>,
3864 pub children: ::core::option::Option<DeclarationPatternChildren<'tree>>,
3865}
3866impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPattern<'tree> {
3867 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3868 fn from_node(
3869 node: ::tree_sitter::Node<'tree>,
3870 src: &'tree [u8],
3871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3872 debug_assert_eq!(node.kind(), "declaration_pattern");
3873 Ok(Self {
3874 span: ::treesitter_types::Span::from(node),
3875 name: match node.child_by_field_name("name") {
3876 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
3877 child, src,
3878 )?),
3879 None => None,
3880 },
3881 r#type: {
3882 let child = node
3883 .child_by_field_name("type")
3884 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3885 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3886 },
3887 children: {
3888 #[allow(clippy::suspicious_else_formatting)]
3889 let non_field_children = {
3890 let mut cursor = node.walk();
3891 let mut result = ::std::vec::Vec::new();
3892 if cursor.goto_first_child() {
3893 loop {
3894 if cursor.field_name().is_none()
3895 && cursor.node().is_named()
3896 && !cursor.node().is_extra()
3897 {
3898 result.push(cursor.node());
3899 }
3900 if !cursor.goto_next_sibling() {
3901 break;
3902 }
3903 }
3904 }
3905 result
3906 };
3907 match non_field_children.first() {
3908 Some(&child) => Some(
3909 <DeclarationPatternChildren as ::treesitter_types::FromNode>::from_node(
3910 child, src,
3911 )?,
3912 ),
3913 None => None,
3914 }
3915 },
3916 })
3917 }
3918}
3919impl ::treesitter_types::Spanned for DeclarationPattern<'_> {
3920 fn span(&self) -> ::treesitter_types::Span {
3921 self.span
3922 }
3923}
3924#[derive(Debug, Clone, PartialEq, Eq)]
3925pub struct DefaultExpression<'tree> {
3926 pub span: ::treesitter_types::Span,
3927 pub r#type: ::core::option::Option<Type<'tree>>,
3928}
3929impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultExpression<'tree> {
3930 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3931 fn from_node(
3932 node: ::tree_sitter::Node<'tree>,
3933 src: &'tree [u8],
3934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3935 debug_assert_eq!(node.kind(), "default_expression");
3936 Ok(Self {
3937 span: ::treesitter_types::Span::from(node),
3938 r#type: match node.child_by_field_name("type") {
3939 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3940 child, src,
3941 )?),
3942 None => None,
3943 },
3944 })
3945 }
3946}
3947impl ::treesitter_types::Spanned for DefaultExpression<'_> {
3948 fn span(&self) -> ::treesitter_types::Span {
3949 self.span
3950 }
3951}
3952#[derive(Debug, Clone, PartialEq, Eq)]
3953pub struct DelegateDeclaration<'tree> {
3954 pub span: ::treesitter_types::Span,
3955 pub name: Identifier<'tree>,
3956 pub parameters: ParameterList<'tree>,
3957 pub r#type: Type<'tree>,
3958 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
3959 pub children: ::std::vec::Vec<DelegateDeclarationChildren<'tree>>,
3960}
3961impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclaration<'tree> {
3962 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3963 fn from_node(
3964 node: ::tree_sitter::Node<'tree>,
3965 src: &'tree [u8],
3966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3967 debug_assert_eq!(node.kind(), "delegate_declaration");
3968 Ok(Self {
3969 span: ::treesitter_types::Span::from(node),
3970 name: {
3971 let child = node
3972 .child_by_field_name("name")
3973 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3974 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3975 },
3976 parameters: {
3977 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3978 ::treesitter_types::ParseError::missing_field("parameters", node)
3979 })?;
3980 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
3981 },
3982 r#type: {
3983 let child = node
3984 .child_by_field_name("type")
3985 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3986 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3987 },
3988 type_parameters: match node.child_by_field_name("type_parameters") {
3989 Some(child) => Some(
3990 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)?,
3991 ),
3992 None => None,
3993 },
3994 children: {
3995 #[allow(clippy::suspicious_else_formatting)]
3996 let non_field_children = {
3997 let mut cursor = node.walk();
3998 let mut result = ::std::vec::Vec::new();
3999 if cursor.goto_first_child() {
4000 loop {
4001 if cursor.field_name().is_none()
4002 && cursor.node().is_named()
4003 && !cursor.node().is_extra()
4004 {
4005 result.push(cursor.node());
4006 }
4007 if !cursor.goto_next_sibling() {
4008 break;
4009 }
4010 }
4011 }
4012 result
4013 };
4014 let mut items = ::std::vec::Vec::new();
4015 for child in non_field_children {
4016 items.push(
4017 <DelegateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4018 child, src,
4019 )?,
4020 );
4021 }
4022 items
4023 },
4024 })
4025 }
4026}
4027impl ::treesitter_types::Spanned for DelegateDeclaration<'_> {
4028 fn span(&self) -> ::treesitter_types::Span {
4029 self.span
4030 }
4031}
4032#[derive(Debug, Clone, PartialEq, Eq)]
4033pub struct DestructorDeclaration<'tree> {
4034 pub span: ::treesitter_types::Span,
4035 pub body: ::core::option::Option<DestructorDeclarationBody<'tree>>,
4036 pub name: Identifier<'tree>,
4037 pub parameters: ParameterList<'tree>,
4038 pub children: ::std::vec::Vec<AttributeList<'tree>>,
4039}
4040impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclaration<'tree> {
4041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4042 fn from_node(
4043 node: ::tree_sitter::Node<'tree>,
4044 src: &'tree [u8],
4045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4046 debug_assert_eq!(node.kind(), "destructor_declaration");
4047 Ok(Self {
4048 span: ::treesitter_types::Span::from(node),
4049 body: match node.child_by_field_name("body") {
4050 Some(child) => Some(
4051 <DestructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4052 child, src,
4053 )?,
4054 ),
4055 None => None,
4056 },
4057 name: {
4058 let child = node
4059 .child_by_field_name("name")
4060 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4061 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4062 },
4063 parameters: {
4064 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4065 ::treesitter_types::ParseError::missing_field("parameters", node)
4066 })?;
4067 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
4068 },
4069 children: {
4070 #[allow(clippy::suspicious_else_formatting)]
4071 let non_field_children = {
4072 let mut cursor = node.walk();
4073 let mut result = ::std::vec::Vec::new();
4074 if cursor.goto_first_child() {
4075 loop {
4076 if cursor.field_name().is_none()
4077 && cursor.node().is_named()
4078 && !cursor.node().is_extra()
4079 {
4080 result.push(cursor.node());
4081 }
4082 if !cursor.goto_next_sibling() {
4083 break;
4084 }
4085 }
4086 }
4087 result
4088 };
4089 let mut items = ::std::vec::Vec::new();
4090 for child in non_field_children {
4091 items.push(<AttributeList as ::treesitter_types::FromNode>::from_node(
4092 child, src,
4093 )?);
4094 }
4095 items
4096 },
4097 })
4098 }
4099}
4100impl ::treesitter_types::Spanned for DestructorDeclaration<'_> {
4101 fn span(&self) -> ::treesitter_types::Span {
4102 self.span
4103 }
4104}
4105#[derive(Debug, Clone, PartialEq, Eq)]
4106pub struct DoStatement<'tree> {
4107 pub span: ::treesitter_types::Span,
4108 pub body: Statement<'tree>,
4109 pub condition: Expression<'tree>,
4110}
4111impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
4112 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4113 fn from_node(
4114 node: ::tree_sitter::Node<'tree>,
4115 src: &'tree [u8],
4116 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4117 debug_assert_eq!(node.kind(), "do_statement");
4118 Ok(Self {
4119 span: ::treesitter_types::Span::from(node),
4120 body: {
4121 let child = node
4122 .child_by_field_name("body")
4123 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4124 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
4125 },
4126 condition: {
4127 let child = node.child_by_field_name("condition").ok_or_else(|| {
4128 ::treesitter_types::ParseError::missing_field("condition", node)
4129 })?;
4130 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4131 },
4132 })
4133 }
4134}
4135impl ::treesitter_types::Spanned for DoStatement<'_> {
4136 fn span(&self) -> ::treesitter_types::Span {
4137 self.span
4138 }
4139}
4140#[derive(Debug, Clone, PartialEq, Eq)]
4141pub struct ElementAccessExpression<'tree> {
4142 pub span: ::treesitter_types::Span,
4143 pub expression: Expression<'tree>,
4144 pub subscript: BracketedArgumentList<'tree>,
4145}
4146impl<'tree> ::treesitter_types::FromNode<'tree> for ElementAccessExpression<'tree> {
4147 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4148 fn from_node(
4149 node: ::tree_sitter::Node<'tree>,
4150 src: &'tree [u8],
4151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4152 debug_assert_eq!(node.kind(), "element_access_expression");
4153 Ok(Self {
4154 span: ::treesitter_types::Span::from(node),
4155 expression: {
4156 let child = node.child_by_field_name("expression").ok_or_else(|| {
4157 ::treesitter_types::ParseError::missing_field("expression", node)
4158 })?;
4159 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4160 },
4161 subscript: {
4162 let child = node.child_by_field_name("subscript").ok_or_else(|| {
4163 ::treesitter_types::ParseError::missing_field("subscript", node)
4164 })?;
4165 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
4166 },
4167 })
4168 }
4169}
4170impl ::treesitter_types::Spanned for ElementAccessExpression<'_> {
4171 fn span(&self) -> ::treesitter_types::Span {
4172 self.span
4173 }
4174}
4175#[derive(Debug, Clone, PartialEq, Eq)]
4176pub struct ElementBindingExpression<'tree> {
4177 pub span: ::treesitter_types::Span,
4178 pub children: ::std::vec::Vec<Argument<'tree>>,
4179}
4180impl<'tree> ::treesitter_types::FromNode<'tree> for ElementBindingExpression<'tree> {
4181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4182 fn from_node(
4183 node: ::tree_sitter::Node<'tree>,
4184 src: &'tree [u8],
4185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4186 debug_assert_eq!(node.kind(), "element_binding_expression");
4187 Ok(Self {
4188 span: ::treesitter_types::Span::from(node),
4189 children: {
4190 #[allow(clippy::suspicious_else_formatting)]
4191 let non_field_children = {
4192 let mut cursor = node.walk();
4193 let mut result = ::std::vec::Vec::new();
4194 if cursor.goto_first_child() {
4195 loop {
4196 if cursor.field_name().is_none()
4197 && cursor.node().is_named()
4198 && !cursor.node().is_extra()
4199 {
4200 result.push(cursor.node());
4201 }
4202 if !cursor.goto_next_sibling() {
4203 break;
4204 }
4205 }
4206 }
4207 result
4208 };
4209 let mut items = ::std::vec::Vec::new();
4210 for child in non_field_children {
4211 items.push(<Argument as ::treesitter_types::FromNode>::from_node(
4212 child, src,
4213 )?);
4214 }
4215 items
4216 },
4217 })
4218 }
4219}
4220impl ::treesitter_types::Spanned for ElementBindingExpression<'_> {
4221 fn span(&self) -> ::treesitter_types::Span {
4222 self.span
4223 }
4224}
4225#[derive(Debug, Clone, PartialEq, Eq)]
4226pub struct EmptyStatement<'tree> {
4227 pub span: ::treesitter_types::Span,
4228 text: &'tree str,
4229}
4230impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
4231 fn from_node(
4232 node: ::tree_sitter::Node<'tree>,
4233 src: &'tree [u8],
4234 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4235 debug_assert_eq!(node.kind(), "empty_statement");
4236 Ok(Self {
4237 span: ::treesitter_types::Span::from(node),
4238 text: node.utf8_text(src)?,
4239 })
4240 }
4241}
4242impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
4243 fn text(&self) -> &'tree str {
4244 self.text
4245 }
4246}
4247impl ::treesitter_types::Spanned for EmptyStatement<'_> {
4248 fn span(&self) -> ::treesitter_types::Span {
4249 self.span
4250 }
4251}
4252#[derive(Debug, Clone, PartialEq, Eq)]
4253pub struct EnumDeclaration<'tree> {
4254 pub span: ::treesitter_types::Span,
4255 pub body: EnumMemberDeclarationList<'tree>,
4256 pub name: Identifier<'tree>,
4257 pub children: ::std::vec::Vec<EnumDeclarationChildren<'tree>>,
4258}
4259impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'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(), "enum_declaration");
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 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
4273 },
4274 name: {
4275 let child = node
4276 .child_by_field_name("name")
4277 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4278 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4279 },
4280 children: {
4281 #[allow(clippy::suspicious_else_formatting)]
4282 let non_field_children = {
4283 let mut cursor = node.walk();
4284 let mut result = ::std::vec::Vec::new();
4285 if cursor.goto_first_child() {
4286 loop {
4287 if cursor.field_name().is_none()
4288 && cursor.node().is_named()
4289 && !cursor.node().is_extra()
4290 {
4291 result.push(cursor.node());
4292 }
4293 if !cursor.goto_next_sibling() {
4294 break;
4295 }
4296 }
4297 }
4298 result
4299 };
4300 let mut items = ::std::vec::Vec::new();
4301 for child in non_field_children {
4302 items.push(
4303 <EnumDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4304 child, src,
4305 )?,
4306 );
4307 }
4308 items
4309 },
4310 })
4311 }
4312}
4313impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
4314 fn span(&self) -> ::treesitter_types::Span {
4315 self.span
4316 }
4317}
4318#[derive(Debug, Clone, PartialEq, Eq)]
4319pub struct EnumMemberDeclaration<'tree> {
4320 pub span: ::treesitter_types::Span,
4321 pub name: Identifier<'tree>,
4322 pub value: ::core::option::Option<Expression<'tree>>,
4323 pub children: ::std::vec::Vec<AttributeList<'tree>>,
4324}
4325impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclaration<'tree> {
4326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4327 fn from_node(
4328 node: ::tree_sitter::Node<'tree>,
4329 src: &'tree [u8],
4330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4331 debug_assert_eq!(node.kind(), "enum_member_declaration");
4332 Ok(Self {
4333 span: ::treesitter_types::Span::from(node),
4334 name: {
4335 let child = node
4336 .child_by_field_name("name")
4337 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4338 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4339 },
4340 value: match node.child_by_field_name("value") {
4341 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4342 child, src,
4343 )?),
4344 None => None,
4345 },
4346 children: {
4347 #[allow(clippy::suspicious_else_formatting)]
4348 let non_field_children = {
4349 let mut cursor = node.walk();
4350 let mut result = ::std::vec::Vec::new();
4351 if cursor.goto_first_child() {
4352 loop {
4353 if cursor.field_name().is_none()
4354 && cursor.node().is_named()
4355 && !cursor.node().is_extra()
4356 {
4357 result.push(cursor.node());
4358 }
4359 if !cursor.goto_next_sibling() {
4360 break;
4361 }
4362 }
4363 }
4364 result
4365 };
4366 let mut items = ::std::vec::Vec::new();
4367 for child in non_field_children {
4368 items.push(<AttributeList as ::treesitter_types::FromNode>::from_node(
4369 child, src,
4370 )?);
4371 }
4372 items
4373 },
4374 })
4375 }
4376}
4377impl ::treesitter_types::Spanned for EnumMemberDeclaration<'_> {
4378 fn span(&self) -> ::treesitter_types::Span {
4379 self.span
4380 }
4381}
4382#[derive(Debug, Clone, PartialEq, Eq)]
4383pub struct EnumMemberDeclarationList<'tree> {
4384 pub span: ::treesitter_types::Span,
4385 pub children: ::std::vec::Vec<EnumMemberDeclarationListChildren<'tree>>,
4386}
4387impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationList<'tree> {
4388 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4389 fn from_node(
4390 node: ::tree_sitter::Node<'tree>,
4391 src: &'tree [u8],
4392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4393 debug_assert_eq!(node.kind(), "enum_member_declaration_list");
4394 Ok(Self {
4395 span: ::treesitter_types::Span::from(node),
4396 children: {
4397 #[allow(clippy::suspicious_else_formatting)]
4398 let non_field_children = {
4399 let mut cursor = node.walk();
4400 let mut result = ::std::vec::Vec::new();
4401 if cursor.goto_first_child() {
4402 loop {
4403 if cursor.field_name().is_none()
4404 && cursor.node().is_named()
4405 && !cursor.node().is_extra()
4406 {
4407 result.push(cursor.node());
4408 }
4409 if !cursor.goto_next_sibling() {
4410 break;
4411 }
4412 }
4413 }
4414 result
4415 };
4416 let mut items = ::std::vec::Vec::new();
4417 for child in non_field_children {
4418 items
4419 .push(
4420 <EnumMemberDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
4421 child,
4422 src,
4423 )?,
4424 );
4425 }
4426 items
4427 },
4428 })
4429 }
4430}
4431impl ::treesitter_types::Spanned for EnumMemberDeclarationList<'_> {
4432 fn span(&self) -> ::treesitter_types::Span {
4433 self.span
4434 }
4435}
4436#[derive(Debug, Clone, PartialEq, Eq)]
4437pub struct EventDeclaration<'tree> {
4438 pub span: ::treesitter_types::Span,
4439 pub accessors: ::core::option::Option<AccessorList<'tree>>,
4440 pub name: Identifier<'tree>,
4441 pub r#type: Type<'tree>,
4442 pub children: ::std::vec::Vec<EventDeclarationChildren<'tree>>,
4443}
4444impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclaration<'tree> {
4445 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4446 fn from_node(
4447 node: ::tree_sitter::Node<'tree>,
4448 src: &'tree [u8],
4449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4450 debug_assert_eq!(node.kind(), "event_declaration");
4451 Ok(Self {
4452 span: ::treesitter_types::Span::from(node),
4453 accessors: match node.child_by_field_name("accessors") {
4454 Some(child) => Some(<AccessorList as ::treesitter_types::FromNode>::from_node(
4455 child, src,
4456 )?),
4457 None => None,
4458 },
4459 name: {
4460 let child = node
4461 .child_by_field_name("name")
4462 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4463 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4464 },
4465 r#type: {
4466 let child = node
4467 .child_by_field_name("type")
4468 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4469 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
4470 },
4471 children: {
4472 #[allow(clippy::suspicious_else_formatting)]
4473 let non_field_children = {
4474 let mut cursor = node.walk();
4475 let mut result = ::std::vec::Vec::new();
4476 if cursor.goto_first_child() {
4477 loop {
4478 if cursor.field_name().is_none()
4479 && cursor.node().is_named()
4480 && !cursor.node().is_extra()
4481 {
4482 result.push(cursor.node());
4483 }
4484 if !cursor.goto_next_sibling() {
4485 break;
4486 }
4487 }
4488 }
4489 result
4490 };
4491 let mut items = ::std::vec::Vec::new();
4492 for child in non_field_children {
4493 items.push(
4494 <EventDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4495 child, src,
4496 )?,
4497 );
4498 }
4499 items
4500 },
4501 })
4502 }
4503}
4504impl ::treesitter_types::Spanned for EventDeclaration<'_> {
4505 fn span(&self) -> ::treesitter_types::Span {
4506 self.span
4507 }
4508}
4509#[derive(Debug, Clone, PartialEq, Eq)]
4510pub struct EventFieldDeclaration<'tree> {
4511 pub span: ::treesitter_types::Span,
4512 pub children: ::std::vec::Vec<EventFieldDeclarationChildren<'tree>>,
4513}
4514impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclaration<'tree> {
4515 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4516 fn from_node(
4517 node: ::tree_sitter::Node<'tree>,
4518 src: &'tree [u8],
4519 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4520 debug_assert_eq!(node.kind(), "event_field_declaration");
4521 Ok(Self {
4522 span: ::treesitter_types::Span::from(node),
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 let mut items = ::std::vec::Vec::new();
4544 for child in non_field_children {
4545 items.push(
4546 <EventFieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4547 child, src,
4548 )?,
4549 );
4550 }
4551 items
4552 },
4553 })
4554 }
4555}
4556impl ::treesitter_types::Spanned for EventFieldDeclaration<'_> {
4557 fn span(&self) -> ::treesitter_types::Span {
4558 self.span
4559 }
4560}
4561#[derive(Debug, Clone, PartialEq, Eq)]
4562pub struct ExplicitInterfaceSpecifier<'tree> {
4563 pub span: ::treesitter_types::Span,
4564 pub children: ExplicitInterfaceSpecifierChildren<'tree>,
4565}
4566impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifier<'tree> {
4567 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4568 fn from_node(
4569 node: ::tree_sitter::Node<'tree>,
4570 src: &'tree [u8],
4571 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4572 debug_assert_eq!(node.kind(), "explicit_interface_specifier");
4573 Ok(Self {
4574 span: ::treesitter_types::Span::from(node),
4575 children: {
4576 #[allow(clippy::suspicious_else_formatting)]
4577 let non_field_children = {
4578 let mut cursor = node.walk();
4579 let mut result = ::std::vec::Vec::new();
4580 if cursor.goto_first_child() {
4581 loop {
4582 if cursor.field_name().is_none()
4583 && cursor.node().is_named()
4584 && !cursor.node().is_extra()
4585 {
4586 result.push(cursor.node());
4587 }
4588 if !cursor.goto_next_sibling() {
4589 break;
4590 }
4591 }
4592 }
4593 result
4594 };
4595 let child = if let Some(&c) = non_field_children.first() {
4596 c
4597 } else {
4598 let mut fallback_cursor = node.walk();
4599 let mut fallback_child = None;
4600 if fallback_cursor.goto_first_child() {
4601 loop {
4602 if fallback_cursor.field_name().is_none()
4603 && !fallback_cursor.node().is_extra()
4604 {
4605 let candidate = fallback_cursor.node();
4606 #[allow(clippy::needless_question_mark)]
4607 if (|| -> ::core::result::Result<
4608 _,
4609 ::treesitter_types::ParseError,
4610 > {
4611 let child = candidate;
4612 Ok(
4613 <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
4614 child,
4615 src,
4616 )?,
4617 )
4618 })()
4619 .is_ok()
4620 {
4621 fallback_child = Some(candidate);
4622 break;
4623 }
4624 }
4625 if !fallback_cursor.goto_next_sibling() {
4626 break;
4627 }
4628 }
4629 }
4630 if fallback_child.is_none() {
4631 let mut cursor2 = node.walk();
4632 if cursor2.goto_first_child() {
4633 loop {
4634 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4635 let candidate = cursor2.node();
4636 #[allow(clippy::needless_question_mark)]
4637 if (|| -> ::core::result::Result<
4638 _,
4639 ::treesitter_types::ParseError,
4640 > {
4641 let child = candidate;
4642 Ok(
4643 <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
4644 child,
4645 src,
4646 )?,
4647 )
4648 })()
4649 .is_ok()
4650 {
4651 fallback_child = Some(candidate);
4652 break;
4653 }
4654 }
4655 if !cursor2.goto_next_sibling() {
4656 break;
4657 }
4658 }
4659 }
4660 }
4661 fallback_child.ok_or_else(|| {
4662 ::treesitter_types::ParseError::missing_field("children", node)
4663 })?
4664 };
4665 <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
4666 child, src,
4667 )?
4668 },
4669 })
4670 }
4671}
4672impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifier<'_> {
4673 fn span(&self) -> ::treesitter_types::Span {
4674 self.span
4675 }
4676}
4677#[derive(Debug, Clone, PartialEq, Eq)]
4678pub struct ExpressionStatement<'tree> {
4679 pub span: ::treesitter_types::Span,
4680 pub children: ExpressionStatementChildren<'tree>,
4681}
4682impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
4683 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4684 fn from_node(
4685 node: ::tree_sitter::Node<'tree>,
4686 src: &'tree [u8],
4687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4688 debug_assert_eq!(node.kind(), "expression_statement");
4689 Ok(Self {
4690 span: ::treesitter_types::Span::from(node),
4691 children: {
4692 #[allow(clippy::suspicious_else_formatting)]
4693 let non_field_children = {
4694 let mut cursor = node.walk();
4695 let mut result = ::std::vec::Vec::new();
4696 if cursor.goto_first_child() {
4697 loop {
4698 if cursor.field_name().is_none()
4699 && cursor.node().is_named()
4700 && !cursor.node().is_extra()
4701 {
4702 result.push(cursor.node());
4703 }
4704 if !cursor.goto_next_sibling() {
4705 break;
4706 }
4707 }
4708 }
4709 result
4710 };
4711 let child = if let Some(&c) = non_field_children.first() {
4712 c
4713 } else {
4714 let mut fallback_cursor = node.walk();
4715 let mut fallback_child = None;
4716 if fallback_cursor.goto_first_child() {
4717 loop {
4718 if fallback_cursor.field_name().is_none()
4719 && !fallback_cursor.node().is_extra()
4720 {
4721 let candidate = fallback_cursor.node();
4722 #[allow(clippy::needless_question_mark)]
4723 if (|| -> ::core::result::Result<
4724 _,
4725 ::treesitter_types::ParseError,
4726 > {
4727 let child = candidate;
4728 Ok(
4729 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
4730 child,
4731 src,
4732 )?,
4733 )
4734 })()
4735 .is_ok()
4736 {
4737 fallback_child = Some(candidate);
4738 break;
4739 }
4740 }
4741 if !fallback_cursor.goto_next_sibling() {
4742 break;
4743 }
4744 }
4745 }
4746 if fallback_child.is_none() {
4747 let mut cursor2 = node.walk();
4748 if cursor2.goto_first_child() {
4749 loop {
4750 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4751 let candidate = cursor2.node();
4752 #[allow(clippy::needless_question_mark)]
4753 if (|| -> ::core::result::Result<
4754 _,
4755 ::treesitter_types::ParseError,
4756 > {
4757 let child = candidate;
4758 Ok(
4759 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
4760 child,
4761 src,
4762 )?,
4763 )
4764 })()
4765 .is_ok()
4766 {
4767 fallback_child = Some(candidate);
4768 break;
4769 }
4770 }
4771 if !cursor2.goto_next_sibling() {
4772 break;
4773 }
4774 }
4775 }
4776 }
4777 fallback_child.ok_or_else(|| {
4778 ::treesitter_types::ParseError::missing_field("children", node)
4779 })?
4780 };
4781 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
4782 child, src,
4783 )?
4784 },
4785 })
4786 }
4787}
4788impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
4789 fn span(&self) -> ::treesitter_types::Span {
4790 self.span
4791 }
4792}
4793#[derive(Debug, Clone, PartialEq, Eq)]
4794pub struct ExternAliasDirective<'tree> {
4795 pub span: ::treesitter_types::Span,
4796 pub name: Identifier<'tree>,
4797}
4798impl<'tree> ::treesitter_types::FromNode<'tree> for ExternAliasDirective<'tree> {
4799 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4800 fn from_node(
4801 node: ::tree_sitter::Node<'tree>,
4802 src: &'tree [u8],
4803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4804 debug_assert_eq!(node.kind(), "extern_alias_directive");
4805 Ok(Self {
4806 span: ::treesitter_types::Span::from(node),
4807 name: {
4808 let child = node
4809 .child_by_field_name("name")
4810 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4811 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4812 },
4813 })
4814 }
4815}
4816impl ::treesitter_types::Spanned for ExternAliasDirective<'_> {
4817 fn span(&self) -> ::treesitter_types::Span {
4818 self.span
4819 }
4820}
4821#[derive(Debug, Clone, PartialEq, Eq)]
4822pub struct FieldDeclaration<'tree> {
4823 pub span: ::treesitter_types::Span,
4824 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
4825}
4826impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
4827 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4828 fn from_node(
4829 node: ::tree_sitter::Node<'tree>,
4830 src: &'tree [u8],
4831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4832 debug_assert_eq!(node.kind(), "field_declaration");
4833 Ok(Self {
4834 span: ::treesitter_types::Span::from(node),
4835 children: {
4836 #[allow(clippy::suspicious_else_formatting)]
4837 let non_field_children = {
4838 let mut cursor = node.walk();
4839 let mut result = ::std::vec::Vec::new();
4840 if cursor.goto_first_child() {
4841 loop {
4842 if cursor.field_name().is_none()
4843 && cursor.node().is_named()
4844 && !cursor.node().is_extra()
4845 {
4846 result.push(cursor.node());
4847 }
4848 if !cursor.goto_next_sibling() {
4849 break;
4850 }
4851 }
4852 }
4853 result
4854 };
4855 let mut items = ::std::vec::Vec::new();
4856 for child in non_field_children {
4857 items.push(
4858 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4859 child, src,
4860 )?,
4861 );
4862 }
4863 items
4864 },
4865 })
4866 }
4867}
4868impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
4869 fn span(&self) -> ::treesitter_types::Span {
4870 self.span
4871 }
4872}
4873#[derive(Debug, Clone, PartialEq, Eq)]
4874pub struct FileScopedNamespaceDeclaration<'tree> {
4875 pub span: ::treesitter_types::Span,
4876 pub name: FileScopedNamespaceDeclarationName<'tree>,
4877}
4878impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclaration<'tree> {
4879 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4880 fn from_node(
4881 node: ::tree_sitter::Node<'tree>,
4882 src: &'tree [u8],
4883 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4884 debug_assert_eq!(node.kind(), "file_scoped_namespace_declaration");
4885 Ok(Self {
4886 span: ::treesitter_types::Span::from(node),
4887 name: {
4888 let child = node
4889 .child_by_field_name("name")
4890 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4891 <FileScopedNamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(
4892 child, src,
4893 )?
4894 },
4895 })
4896 }
4897}
4898impl ::treesitter_types::Spanned for FileScopedNamespaceDeclaration<'_> {
4899 fn span(&self) -> ::treesitter_types::Span {
4900 self.span
4901 }
4902}
4903#[derive(Debug, Clone, PartialEq, Eq)]
4904pub struct FinallyClause<'tree> {
4905 pub span: ::treesitter_types::Span,
4906 pub children: Block<'tree>,
4907}
4908impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
4909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4910 fn from_node(
4911 node: ::tree_sitter::Node<'tree>,
4912 src: &'tree [u8],
4913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4914 debug_assert_eq!(node.kind(), "finally_clause");
4915 Ok(Self {
4916 span: ::treesitter_types::Span::from(node),
4917 children: {
4918 #[allow(clippy::suspicious_else_formatting)]
4919 let non_field_children = {
4920 let mut cursor = node.walk();
4921 let mut result = ::std::vec::Vec::new();
4922 if cursor.goto_first_child() {
4923 loop {
4924 if cursor.field_name().is_none()
4925 && cursor.node().is_named()
4926 && !cursor.node().is_extra()
4927 {
4928 result.push(cursor.node());
4929 }
4930 if !cursor.goto_next_sibling() {
4931 break;
4932 }
4933 }
4934 }
4935 result
4936 };
4937 let child = if let Some(&c) = non_field_children.first() {
4938 c
4939 } else {
4940 let mut fallback_cursor = node.walk();
4941 let mut fallback_child = None;
4942 if fallback_cursor.goto_first_child() {
4943 loop {
4944 if fallback_cursor.field_name().is_none()
4945 && !fallback_cursor.node().is_extra()
4946 {
4947 let candidate = fallback_cursor.node();
4948 #[allow(clippy::needless_question_mark)]
4949 if (|| -> ::core::result::Result<
4950 _,
4951 ::treesitter_types::ParseError,
4952 > {
4953 let child = candidate;
4954 Ok(
4955 <Block as ::treesitter_types::FromNode>::from_node(
4956 child,
4957 src,
4958 )?,
4959 )
4960 })()
4961 .is_ok()
4962 {
4963 fallback_child = Some(candidate);
4964 break;
4965 }
4966 }
4967 if !fallback_cursor.goto_next_sibling() {
4968 break;
4969 }
4970 }
4971 }
4972 if fallback_child.is_none() {
4973 let mut cursor2 = node.walk();
4974 if cursor2.goto_first_child() {
4975 loop {
4976 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4977 let candidate = cursor2.node();
4978 #[allow(clippy::needless_question_mark)]
4979 if (|| -> ::core::result::Result<
4980 _,
4981 ::treesitter_types::ParseError,
4982 > {
4983 let child = candidate;
4984 Ok(
4985 <Block as ::treesitter_types::FromNode>::from_node(
4986 child,
4987 src,
4988 )?,
4989 )
4990 })()
4991 .is_ok()
4992 {
4993 fallback_child = Some(candidate);
4994 break;
4995 }
4996 }
4997 if !cursor2.goto_next_sibling() {
4998 break;
4999 }
5000 }
5001 }
5002 }
5003 fallback_child.ok_or_else(|| {
5004 ::treesitter_types::ParseError::missing_field("children", node)
5005 })?
5006 };
5007 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
5008 },
5009 })
5010 }
5011}
5012impl ::treesitter_types::Spanned for FinallyClause<'_> {
5013 fn span(&self) -> ::treesitter_types::Span {
5014 self.span
5015 }
5016}
5017#[derive(Debug, Clone, PartialEq, Eq)]
5018pub struct FixedStatement<'tree> {
5019 pub span: ::treesitter_types::Span,
5020 pub children: ::std::vec::Vec<FixedStatementChildren<'tree>>,
5021}
5022impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatement<'tree> {
5023 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5024 fn from_node(
5025 node: ::tree_sitter::Node<'tree>,
5026 src: &'tree [u8],
5027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5028 debug_assert_eq!(node.kind(), "fixed_statement");
5029 Ok(Self {
5030 span: ::treesitter_types::Span::from(node),
5031 children: {
5032 #[allow(clippy::suspicious_else_formatting)]
5033 let non_field_children = {
5034 let mut cursor = node.walk();
5035 let mut result = ::std::vec::Vec::new();
5036 if cursor.goto_first_child() {
5037 loop {
5038 if cursor.field_name().is_none()
5039 && cursor.node().is_named()
5040 && !cursor.node().is_extra()
5041 {
5042 result.push(cursor.node());
5043 }
5044 if !cursor.goto_next_sibling() {
5045 break;
5046 }
5047 }
5048 }
5049 result
5050 };
5051 let mut items = ::std::vec::Vec::new();
5052 for child in non_field_children {
5053 items.push(
5054 <FixedStatementChildren as ::treesitter_types::FromNode>::from_node(
5055 child, src,
5056 )?,
5057 );
5058 }
5059 items
5060 },
5061 })
5062 }
5063}
5064impl ::treesitter_types::Spanned for FixedStatement<'_> {
5065 fn span(&self) -> ::treesitter_types::Span {
5066 self.span
5067 }
5068}
5069#[derive(Debug, Clone, PartialEq, Eq)]
5070pub struct ForStatement<'tree> {
5071 pub span: ::treesitter_types::Span,
5072 pub body: Statement<'tree>,
5073 pub condition: ::core::option::Option<Expression<'tree>>,
5074 pub initializer: ::std::vec::Vec<ForStatementInitializer<'tree>>,
5075 pub update: ::std::vec::Vec<ForStatementUpdate<'tree>>,
5076}
5077impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
5078 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5079 fn from_node(
5080 node: ::tree_sitter::Node<'tree>,
5081 src: &'tree [u8],
5082 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5083 debug_assert_eq!(node.kind(), "for_statement");
5084 Ok(Self {
5085 span: ::treesitter_types::Span::from(node),
5086 body: {
5087 let child = node
5088 .child_by_field_name("body")
5089 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5090 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5091 },
5092 condition: match node.child_by_field_name("condition") {
5093 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5094 child, src,
5095 )?),
5096 None => None,
5097 },
5098 initializer: {
5099 let mut cursor = node.walk();
5100 let mut items = ::std::vec::Vec::new();
5101 for child in node.children_by_field_name("initializer", &mut cursor) {
5102 items.push(
5103 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(
5104 child, src,
5105 )?,
5106 );
5107 }
5108 items
5109 },
5110 update: {
5111 let mut cursor = node.walk();
5112 let mut items = ::std::vec::Vec::new();
5113 for child in node.children_by_field_name("update", &mut cursor) {
5114 items.push(
5115 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(
5116 child, src,
5117 )?,
5118 );
5119 }
5120 items
5121 },
5122 })
5123 }
5124}
5125impl ::treesitter_types::Spanned for ForStatement<'_> {
5126 fn span(&self) -> ::treesitter_types::Span {
5127 self.span
5128 }
5129}
5130#[derive(Debug, Clone, PartialEq, Eq)]
5131pub struct ForeachStatement<'tree> {
5132 pub span: ::treesitter_types::Span,
5133 pub body: Statement<'tree>,
5134 pub left: ForeachStatementLeft<'tree>,
5135 pub right: Expression<'tree>,
5136 pub r#type: ::core::option::Option<Type<'tree>>,
5137}
5138impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatement<'tree> {
5139 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5140 fn from_node(
5141 node: ::tree_sitter::Node<'tree>,
5142 src: &'tree [u8],
5143 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5144 debug_assert_eq!(node.kind(), "foreach_statement");
5145 Ok(Self {
5146 span: ::treesitter_types::Span::from(node),
5147 body: {
5148 let child = node
5149 .child_by_field_name("body")
5150 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5151 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5152 },
5153 left: {
5154 let child = node
5155 .child_by_field_name("left")
5156 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5157 <ForeachStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)?
5158 },
5159 right: {
5160 let child = node
5161 .child_by_field_name("right")
5162 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5163 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5164 },
5165 r#type: match node.child_by_field_name("type") {
5166 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
5167 child, src,
5168 )?),
5169 None => None,
5170 },
5171 })
5172 }
5173}
5174impl ::treesitter_types::Spanned for ForeachStatement<'_> {
5175 fn span(&self) -> ::treesitter_types::Span {
5176 self.span
5177 }
5178}
5179#[derive(Debug, Clone, PartialEq, Eq)]
5180pub struct FromClause<'tree> {
5181 pub span: ::treesitter_types::Span,
5182 pub name: Identifier<'tree>,
5183 pub r#type: ::core::option::Option<Type<'tree>>,
5184 pub children: Expression<'tree>,
5185}
5186impl<'tree> ::treesitter_types::FromNode<'tree> for FromClause<'tree> {
5187 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5188 fn from_node(
5189 node: ::tree_sitter::Node<'tree>,
5190 src: &'tree [u8],
5191 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5192 debug_assert_eq!(node.kind(), "from_clause");
5193 Ok(Self {
5194 span: ::treesitter_types::Span::from(node),
5195 name: {
5196 let child = node
5197 .child_by_field_name("name")
5198 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5199 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5200 },
5201 r#type: match node.child_by_field_name("type") {
5202 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
5203 child, src,
5204 )?),
5205 None => None,
5206 },
5207 children: {
5208 #[allow(clippy::suspicious_else_formatting)]
5209 let non_field_children = {
5210 let mut cursor = node.walk();
5211 let mut result = ::std::vec::Vec::new();
5212 if cursor.goto_first_child() {
5213 loop {
5214 if cursor.field_name().is_none()
5215 && cursor.node().is_named()
5216 && !cursor.node().is_extra()
5217 {
5218 result.push(cursor.node());
5219 }
5220 if !cursor.goto_next_sibling() {
5221 break;
5222 }
5223 }
5224 }
5225 result
5226 };
5227 let child = if let Some(&c) = non_field_children.first() {
5228 c
5229 } else {
5230 let mut fallback_cursor = node.walk();
5231 let mut fallback_child = None;
5232 if fallback_cursor.goto_first_child() {
5233 loop {
5234 if fallback_cursor.field_name().is_none()
5235 && !fallback_cursor.node().is_extra()
5236 {
5237 let candidate = fallback_cursor.node();
5238 #[allow(clippy::needless_question_mark)]
5239 if (|| -> ::core::result::Result<
5240 _,
5241 ::treesitter_types::ParseError,
5242 > {
5243 let child = candidate;
5244 Ok(
5245 <Expression as ::treesitter_types::FromNode>::from_node(
5246 child,
5247 src,
5248 )?,
5249 )
5250 })()
5251 .is_ok()
5252 {
5253 fallback_child = Some(candidate);
5254 break;
5255 }
5256 }
5257 if !fallback_cursor.goto_next_sibling() {
5258 break;
5259 }
5260 }
5261 }
5262 if fallback_child.is_none() {
5263 let mut cursor2 = node.walk();
5264 if cursor2.goto_first_child() {
5265 loop {
5266 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5267 let candidate = cursor2.node();
5268 #[allow(clippy::needless_question_mark)]
5269 if (|| -> ::core::result::Result<
5270 _,
5271 ::treesitter_types::ParseError,
5272 > {
5273 let child = candidate;
5274 Ok(
5275 <Expression as ::treesitter_types::FromNode>::from_node(
5276 child,
5277 src,
5278 )?,
5279 )
5280 })()
5281 .is_ok()
5282 {
5283 fallback_child = Some(candidate);
5284 break;
5285 }
5286 }
5287 if !cursor2.goto_next_sibling() {
5288 break;
5289 }
5290 }
5291 }
5292 }
5293 fallback_child.ok_or_else(|| {
5294 ::treesitter_types::ParseError::missing_field("children", node)
5295 })?
5296 };
5297 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5298 },
5299 })
5300 }
5301}
5302impl ::treesitter_types::Spanned for FromClause<'_> {
5303 fn span(&self) -> ::treesitter_types::Span {
5304 self.span
5305 }
5306}
5307#[derive(Debug, Clone, PartialEq, Eq)]
5308pub struct FunctionPointerParameter<'tree> {
5309 pub span: ::treesitter_types::Span,
5310 pub r#type: FunctionPointerParameterType<'tree>,
5311}
5312impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameter<'tree> {
5313 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5314 fn from_node(
5315 node: ::tree_sitter::Node<'tree>,
5316 src: &'tree [u8],
5317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5318 debug_assert_eq!(node.kind(), "function_pointer_parameter");
5319 Ok(Self {
5320 span: ::treesitter_types::Span::from(node),
5321 r#type: {
5322 let child = node
5323 .child_by_field_name("type")
5324 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5325 <FunctionPointerParameterType as ::treesitter_types::FromNode>::from_node(
5326 child, src,
5327 )?
5328 },
5329 })
5330 }
5331}
5332impl ::treesitter_types::Spanned for FunctionPointerParameter<'_> {
5333 fn span(&self) -> ::treesitter_types::Span {
5334 self.span
5335 }
5336}
5337#[derive(Debug, Clone, PartialEq, Eq)]
5338pub struct FunctionPointerType<'tree> {
5339 pub span: ::treesitter_types::Span,
5340 pub returns: Type<'tree>,
5341 pub children: ::std::vec::Vec<FunctionPointerTypeChildren<'tree>>,
5342}
5343impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerType<'tree> {
5344 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5345 fn from_node(
5346 node: ::tree_sitter::Node<'tree>,
5347 src: &'tree [u8],
5348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5349 debug_assert_eq!(node.kind(), "function_pointer_type");
5350 Ok(Self {
5351 span: ::treesitter_types::Span::from(node),
5352 returns: {
5353 let child = node.child_by_field_name("returns").ok_or_else(|| {
5354 ::treesitter_types::ParseError::missing_field("returns", node)
5355 })?;
5356 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5357 },
5358 children: {
5359 #[allow(clippy::suspicious_else_formatting)]
5360 let non_field_children = {
5361 let mut cursor = node.walk();
5362 let mut result = ::std::vec::Vec::new();
5363 if cursor.goto_first_child() {
5364 loop {
5365 if cursor.field_name().is_none()
5366 && cursor.node().is_named()
5367 && !cursor.node().is_extra()
5368 {
5369 result.push(cursor.node());
5370 }
5371 if !cursor.goto_next_sibling() {
5372 break;
5373 }
5374 }
5375 }
5376 result
5377 };
5378 let mut items = ::std::vec::Vec::new();
5379 for child in non_field_children {
5380 items.push(
5381 <FunctionPointerTypeChildren as ::treesitter_types::FromNode>::from_node(
5382 child, src,
5383 )?,
5384 );
5385 }
5386 items
5387 },
5388 })
5389 }
5390}
5391impl ::treesitter_types::Spanned for FunctionPointerType<'_> {
5392 fn span(&self) -> ::treesitter_types::Span {
5393 self.span
5394 }
5395}
5396#[derive(Debug, Clone, PartialEq, Eq)]
5397pub struct GenericName<'tree> {
5398 pub span: ::treesitter_types::Span,
5399 pub children: ::std::vec::Vec<GenericNameChildren<'tree>>,
5400}
5401impl<'tree> ::treesitter_types::FromNode<'tree> for GenericName<'tree> {
5402 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5403 fn from_node(
5404 node: ::tree_sitter::Node<'tree>,
5405 src: &'tree [u8],
5406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5407 debug_assert_eq!(node.kind(), "generic_name");
5408 Ok(Self {
5409 span: ::treesitter_types::Span::from(node),
5410 children: {
5411 #[allow(clippy::suspicious_else_formatting)]
5412 let non_field_children = {
5413 let mut cursor = node.walk();
5414 let mut result = ::std::vec::Vec::new();
5415 if cursor.goto_first_child() {
5416 loop {
5417 if cursor.field_name().is_none()
5418 && cursor.node().is_named()
5419 && !cursor.node().is_extra()
5420 {
5421 result.push(cursor.node());
5422 }
5423 if !cursor.goto_next_sibling() {
5424 break;
5425 }
5426 }
5427 }
5428 result
5429 };
5430 let mut items = ::std::vec::Vec::new();
5431 for child in non_field_children {
5432 items.push(
5433 <GenericNameChildren as ::treesitter_types::FromNode>::from_node(
5434 child, src,
5435 )?,
5436 );
5437 }
5438 items
5439 },
5440 })
5441 }
5442}
5443impl ::treesitter_types::Spanned for GenericName<'_> {
5444 fn span(&self) -> ::treesitter_types::Span {
5445 self.span
5446 }
5447}
5448#[derive(Debug, Clone, PartialEq, Eq)]
5449pub struct GlobalAttribute<'tree> {
5450 pub span: ::treesitter_types::Span,
5451 pub children: ::std::vec::Vec<Attribute<'tree>>,
5452}
5453impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalAttribute<'tree> {
5454 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5455 fn from_node(
5456 node: ::tree_sitter::Node<'tree>,
5457 src: &'tree [u8],
5458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5459 debug_assert_eq!(node.kind(), "global_attribute");
5460 Ok(Self {
5461 span: ::treesitter_types::Span::from(node),
5462 children: {
5463 #[allow(clippy::suspicious_else_formatting)]
5464 let non_field_children = {
5465 let mut cursor = node.walk();
5466 let mut result = ::std::vec::Vec::new();
5467 if cursor.goto_first_child() {
5468 loop {
5469 if cursor.field_name().is_none()
5470 && cursor.node().is_named()
5471 && !cursor.node().is_extra()
5472 {
5473 result.push(cursor.node());
5474 }
5475 if !cursor.goto_next_sibling() {
5476 break;
5477 }
5478 }
5479 }
5480 result
5481 };
5482 let mut items = ::std::vec::Vec::new();
5483 for child in non_field_children {
5484 items.push(<Attribute as ::treesitter_types::FromNode>::from_node(
5485 child, src,
5486 )?);
5487 }
5488 items
5489 },
5490 })
5491 }
5492}
5493impl ::treesitter_types::Spanned for GlobalAttribute<'_> {
5494 fn span(&self) -> ::treesitter_types::Span {
5495 self.span
5496 }
5497}
5498#[derive(Debug, Clone, PartialEq, Eq)]
5499pub struct GlobalStatement<'tree> {
5500 pub span: ::treesitter_types::Span,
5501 pub children: Statement<'tree>,
5502}
5503impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalStatement<'tree> {
5504 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5505 fn from_node(
5506 node: ::tree_sitter::Node<'tree>,
5507 src: &'tree [u8],
5508 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5509 debug_assert_eq!(node.kind(), "global_statement");
5510 Ok(Self {
5511 span: ::treesitter_types::Span::from(node),
5512 children: {
5513 #[allow(clippy::suspicious_else_formatting)]
5514 let non_field_children = {
5515 let mut cursor = node.walk();
5516 let mut result = ::std::vec::Vec::new();
5517 if cursor.goto_first_child() {
5518 loop {
5519 if cursor.field_name().is_none()
5520 && cursor.node().is_named()
5521 && !cursor.node().is_extra()
5522 {
5523 result.push(cursor.node());
5524 }
5525 if !cursor.goto_next_sibling() {
5526 break;
5527 }
5528 }
5529 }
5530 result
5531 };
5532 let child = if let Some(&c) = non_field_children.first() {
5533 c
5534 } else {
5535 let mut fallback_cursor = node.walk();
5536 let mut fallback_child = None;
5537 if fallback_cursor.goto_first_child() {
5538 loop {
5539 if fallback_cursor.field_name().is_none()
5540 && !fallback_cursor.node().is_extra()
5541 {
5542 let candidate = fallback_cursor.node();
5543 #[allow(clippy::needless_question_mark)]
5544 if (|| -> ::core::result::Result<
5545 _,
5546 ::treesitter_types::ParseError,
5547 > {
5548 let child = candidate;
5549 Ok(
5550 <Statement as ::treesitter_types::FromNode>::from_node(
5551 child,
5552 src,
5553 )?,
5554 )
5555 })()
5556 .is_ok()
5557 {
5558 fallback_child = Some(candidate);
5559 break;
5560 }
5561 }
5562 if !fallback_cursor.goto_next_sibling() {
5563 break;
5564 }
5565 }
5566 }
5567 if fallback_child.is_none() {
5568 let mut cursor2 = node.walk();
5569 if cursor2.goto_first_child() {
5570 loop {
5571 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5572 let candidate = cursor2.node();
5573 #[allow(clippy::needless_question_mark)]
5574 if (|| -> ::core::result::Result<
5575 _,
5576 ::treesitter_types::ParseError,
5577 > {
5578 let child = candidate;
5579 Ok(
5580 <Statement as ::treesitter_types::FromNode>::from_node(
5581 child,
5582 src,
5583 )?,
5584 )
5585 })()
5586 .is_ok()
5587 {
5588 fallback_child = Some(candidate);
5589 break;
5590 }
5591 }
5592 if !cursor2.goto_next_sibling() {
5593 break;
5594 }
5595 }
5596 }
5597 }
5598 fallback_child.ok_or_else(|| {
5599 ::treesitter_types::ParseError::missing_field("children", node)
5600 })?
5601 };
5602 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5603 },
5604 })
5605 }
5606}
5607impl ::treesitter_types::Spanned for GlobalStatement<'_> {
5608 fn span(&self) -> ::treesitter_types::Span {
5609 self.span
5610 }
5611}
5612#[derive(Debug, Clone, PartialEq, Eq)]
5613pub struct GotoStatement<'tree> {
5614 pub span: ::treesitter_types::Span,
5615 pub children: ::core::option::Option<Expression<'tree>>,
5616}
5617impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
5618 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5619 fn from_node(
5620 node: ::tree_sitter::Node<'tree>,
5621 src: &'tree [u8],
5622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5623 debug_assert_eq!(node.kind(), "goto_statement");
5624 Ok(Self {
5625 span: ::treesitter_types::Span::from(node),
5626 children: {
5627 #[allow(clippy::suspicious_else_formatting)]
5628 let non_field_children = {
5629 let mut cursor = node.walk();
5630 let mut result = ::std::vec::Vec::new();
5631 if cursor.goto_first_child() {
5632 loop {
5633 if cursor.field_name().is_none()
5634 && cursor.node().is_named()
5635 && !cursor.node().is_extra()
5636 {
5637 result.push(cursor.node());
5638 }
5639 if !cursor.goto_next_sibling() {
5640 break;
5641 }
5642 }
5643 }
5644 result
5645 };
5646 match non_field_children.first() {
5647 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5648 child, src,
5649 )?),
5650 None => None,
5651 }
5652 },
5653 })
5654 }
5655}
5656impl ::treesitter_types::Spanned for GotoStatement<'_> {
5657 fn span(&self) -> ::treesitter_types::Span {
5658 self.span
5659 }
5660}
5661#[derive(Debug, Clone, PartialEq, Eq)]
5662pub struct GroupClause<'tree> {
5663 pub span: ::treesitter_types::Span,
5664 pub children: ::std::vec::Vec<Expression<'tree>>,
5665}
5666impl<'tree> ::treesitter_types::FromNode<'tree> for GroupClause<'tree> {
5667 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5668 fn from_node(
5669 node: ::tree_sitter::Node<'tree>,
5670 src: &'tree [u8],
5671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5672 debug_assert_eq!(node.kind(), "group_clause");
5673 Ok(Self {
5674 span: ::treesitter_types::Span::from(node),
5675 children: {
5676 #[allow(clippy::suspicious_else_formatting)]
5677 let non_field_children = {
5678 let mut cursor = node.walk();
5679 let mut result = ::std::vec::Vec::new();
5680 if cursor.goto_first_child() {
5681 loop {
5682 if cursor.field_name().is_none()
5683 && cursor.node().is_named()
5684 && !cursor.node().is_extra()
5685 {
5686 result.push(cursor.node());
5687 }
5688 if !cursor.goto_next_sibling() {
5689 break;
5690 }
5691 }
5692 }
5693 result
5694 };
5695 let mut items = ::std::vec::Vec::new();
5696 for child in non_field_children {
5697 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
5698 child, src,
5699 )?);
5700 }
5701 items
5702 },
5703 })
5704 }
5705}
5706impl ::treesitter_types::Spanned for GroupClause<'_> {
5707 fn span(&self) -> ::treesitter_types::Span {
5708 self.span
5709 }
5710}
5711#[derive(Debug, Clone, PartialEq, Eq)]
5712pub struct Identifier<'tree> {
5713 pub span: ::treesitter_types::Span,
5714 text: &'tree str,
5715}
5716impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
5717 fn from_node(
5718 node: ::tree_sitter::Node<'tree>,
5719 src: &'tree [u8],
5720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5721 debug_assert_eq!(node.kind(), "identifier");
5722 Ok(Self {
5723 span: ::treesitter_types::Span::from(node),
5724 text: node.utf8_text(src)?,
5725 })
5726 }
5727}
5728impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
5729 fn text(&self) -> &'tree str {
5730 self.text
5731 }
5732}
5733impl ::treesitter_types::Spanned for Identifier<'_> {
5734 fn span(&self) -> ::treesitter_types::Span {
5735 self.span
5736 }
5737}
5738#[derive(Debug, Clone, PartialEq, Eq)]
5739pub struct IfStatement<'tree> {
5740 pub span: ::treesitter_types::Span,
5741 pub alternative: ::core::option::Option<Statement<'tree>>,
5742 pub condition: Expression<'tree>,
5743 pub consequence: Statement<'tree>,
5744}
5745impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
5746 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5747 fn from_node(
5748 node: ::tree_sitter::Node<'tree>,
5749 src: &'tree [u8],
5750 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5751 debug_assert_eq!(node.kind(), "if_statement");
5752 Ok(Self {
5753 span: ::treesitter_types::Span::from(node),
5754 alternative: match node.child_by_field_name("alternative") {
5755 Some(child) => Some(<Statement as ::treesitter_types::FromNode>::from_node(
5756 child, src,
5757 )?),
5758 None => None,
5759 },
5760 condition: {
5761 let child = node.child_by_field_name("condition").ok_or_else(|| {
5762 ::treesitter_types::ParseError::missing_field("condition", node)
5763 })?;
5764 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5765 },
5766 consequence: {
5767 let child = node.child_by_field_name("consequence").ok_or_else(|| {
5768 ::treesitter_types::ParseError::missing_field("consequence", node)
5769 })?;
5770 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5771 },
5772 })
5773 }
5774}
5775impl ::treesitter_types::Spanned for IfStatement<'_> {
5776 fn span(&self) -> ::treesitter_types::Span {
5777 self.span
5778 }
5779}
5780#[derive(Debug, Clone, PartialEq, Eq)]
5781pub struct ImplicitArrayCreationExpression<'tree> {
5782 pub span: ::treesitter_types::Span,
5783 pub children: InitializerExpression<'tree>,
5784}
5785impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitArrayCreationExpression<'tree> {
5786 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5787 fn from_node(
5788 node: ::tree_sitter::Node<'tree>,
5789 src: &'tree [u8],
5790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5791 debug_assert_eq!(node.kind(), "implicit_array_creation_expression");
5792 Ok(Self {
5793 span: ::treesitter_types::Span::from(node),
5794 children: {
5795 #[allow(clippy::suspicious_else_formatting)]
5796 let non_field_children = {
5797 let mut cursor = node.walk();
5798 let mut result = ::std::vec::Vec::new();
5799 if cursor.goto_first_child() {
5800 loop {
5801 if cursor.field_name().is_none()
5802 && cursor.node().is_named()
5803 && !cursor.node().is_extra()
5804 {
5805 result.push(cursor.node());
5806 }
5807 if !cursor.goto_next_sibling() {
5808 break;
5809 }
5810 }
5811 }
5812 result
5813 };
5814 let child = if let Some(&c) = non_field_children.first() {
5815 c
5816 } else {
5817 let mut fallback_cursor = node.walk();
5818 let mut fallback_child = None;
5819 if fallback_cursor.goto_first_child() {
5820 loop {
5821 if fallback_cursor.field_name().is_none()
5822 && !fallback_cursor.node().is_extra()
5823 {
5824 let candidate = fallback_cursor.node();
5825 #[allow(clippy::needless_question_mark)]
5826 if (|| -> ::core::result::Result<
5827 _,
5828 ::treesitter_types::ParseError,
5829 > {
5830 let child = candidate;
5831 Ok(
5832 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
5833 child,
5834 src,
5835 )?,
5836 )
5837 })()
5838 .is_ok()
5839 {
5840 fallback_child = Some(candidate);
5841 break;
5842 }
5843 }
5844 if !fallback_cursor.goto_next_sibling() {
5845 break;
5846 }
5847 }
5848 }
5849 if fallback_child.is_none() {
5850 let mut cursor2 = node.walk();
5851 if cursor2.goto_first_child() {
5852 loop {
5853 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5854 let candidate = cursor2.node();
5855 #[allow(clippy::needless_question_mark)]
5856 if (|| -> ::core::result::Result<
5857 _,
5858 ::treesitter_types::ParseError,
5859 > {
5860 let child = candidate;
5861 Ok(
5862 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
5863 child,
5864 src,
5865 )?,
5866 )
5867 })()
5868 .is_ok()
5869 {
5870 fallback_child = Some(candidate);
5871 break;
5872 }
5873 }
5874 if !cursor2.goto_next_sibling() {
5875 break;
5876 }
5877 }
5878 }
5879 }
5880 fallback_child.ok_or_else(|| {
5881 ::treesitter_types::ParseError::missing_field("children", node)
5882 })?
5883 };
5884 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5885 },
5886 })
5887 }
5888}
5889impl ::treesitter_types::Spanned for ImplicitArrayCreationExpression<'_> {
5890 fn span(&self) -> ::treesitter_types::Span {
5891 self.span
5892 }
5893}
5894#[derive(Debug, Clone, PartialEq, Eq)]
5895pub struct ImplicitObjectCreationExpression<'tree> {
5896 pub span: ::treesitter_types::Span,
5897 pub children: ::std::vec::Vec<ImplicitObjectCreationExpressionChildren<'tree>>,
5898}
5899impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitObjectCreationExpression<'tree> {
5900 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5901 fn from_node(
5902 node: ::tree_sitter::Node<'tree>,
5903 src: &'tree [u8],
5904 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5905 debug_assert_eq!(node.kind(), "implicit_object_creation_expression");
5906 Ok(Self {
5907 span: ::treesitter_types::Span::from(node),
5908 children: {
5909 #[allow(clippy::suspicious_else_formatting)]
5910 let non_field_children = {
5911 let mut cursor = node.walk();
5912 let mut result = ::std::vec::Vec::new();
5913 if cursor.goto_first_child() {
5914 loop {
5915 if cursor.field_name().is_none()
5916 && cursor.node().is_named()
5917 && !cursor.node().is_extra()
5918 {
5919 result.push(cursor.node());
5920 }
5921 if !cursor.goto_next_sibling() {
5922 break;
5923 }
5924 }
5925 }
5926 result
5927 };
5928 let mut items = ::std::vec::Vec::new();
5929 for child in non_field_children {
5930 items
5931 .push(
5932 <ImplicitObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
5933 child,
5934 src,
5935 )?,
5936 );
5937 }
5938 items
5939 },
5940 })
5941 }
5942}
5943impl ::treesitter_types::Spanned for ImplicitObjectCreationExpression<'_> {
5944 fn span(&self) -> ::treesitter_types::Span {
5945 self.span
5946 }
5947}
5948#[derive(Debug, Clone, PartialEq, Eq)]
5949pub struct ImplicitParameter<'tree> {
5950 pub span: ::treesitter_types::Span,
5951 text: &'tree str,
5952}
5953impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitParameter<'tree> {
5954 fn from_node(
5955 node: ::tree_sitter::Node<'tree>,
5956 src: &'tree [u8],
5957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5958 debug_assert_eq!(node.kind(), "implicit_parameter");
5959 Ok(Self {
5960 span: ::treesitter_types::Span::from(node),
5961 text: node.utf8_text(src)?,
5962 })
5963 }
5964}
5965impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitParameter<'tree> {
5966 fn text(&self) -> &'tree str {
5967 self.text
5968 }
5969}
5970impl ::treesitter_types::Spanned for ImplicitParameter<'_> {
5971 fn span(&self) -> ::treesitter_types::Span {
5972 self.span
5973 }
5974}
5975#[derive(Debug, Clone, PartialEq, Eq)]
5976pub struct ImplicitStackallocExpression<'tree> {
5977 pub span: ::treesitter_types::Span,
5978 pub children: InitializerExpression<'tree>,
5979}
5980impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitStackallocExpression<'tree> {
5981 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5982 fn from_node(
5983 node: ::tree_sitter::Node<'tree>,
5984 src: &'tree [u8],
5985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5986 debug_assert_eq!(node.kind(), "implicit_stackalloc_expression");
5987 Ok(Self {
5988 span: ::treesitter_types::Span::from(node),
5989 children: {
5990 #[allow(clippy::suspicious_else_formatting)]
5991 let non_field_children = {
5992 let mut cursor = node.walk();
5993 let mut result = ::std::vec::Vec::new();
5994 if cursor.goto_first_child() {
5995 loop {
5996 if cursor.field_name().is_none()
5997 && cursor.node().is_named()
5998 && !cursor.node().is_extra()
5999 {
6000 result.push(cursor.node());
6001 }
6002 if !cursor.goto_next_sibling() {
6003 break;
6004 }
6005 }
6006 }
6007 result
6008 };
6009 let child = if let Some(&c) = non_field_children.first() {
6010 c
6011 } else {
6012 let mut fallback_cursor = node.walk();
6013 let mut fallback_child = None;
6014 if fallback_cursor.goto_first_child() {
6015 loop {
6016 if fallback_cursor.field_name().is_none()
6017 && !fallback_cursor.node().is_extra()
6018 {
6019 let candidate = fallback_cursor.node();
6020 #[allow(clippy::needless_question_mark)]
6021 if (|| -> ::core::result::Result<
6022 _,
6023 ::treesitter_types::ParseError,
6024 > {
6025 let child = candidate;
6026 Ok(
6027 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6028 child,
6029 src,
6030 )?,
6031 )
6032 })()
6033 .is_ok()
6034 {
6035 fallback_child = Some(candidate);
6036 break;
6037 }
6038 }
6039 if !fallback_cursor.goto_next_sibling() {
6040 break;
6041 }
6042 }
6043 }
6044 if fallback_child.is_none() {
6045 let mut cursor2 = node.walk();
6046 if cursor2.goto_first_child() {
6047 loop {
6048 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6049 let candidate = cursor2.node();
6050 #[allow(clippy::needless_question_mark)]
6051 if (|| -> ::core::result::Result<
6052 _,
6053 ::treesitter_types::ParseError,
6054 > {
6055 let child = candidate;
6056 Ok(
6057 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6058 child,
6059 src,
6060 )?,
6061 )
6062 })()
6063 .is_ok()
6064 {
6065 fallback_child = Some(candidate);
6066 break;
6067 }
6068 }
6069 if !cursor2.goto_next_sibling() {
6070 break;
6071 }
6072 }
6073 }
6074 }
6075 fallback_child.ok_or_else(|| {
6076 ::treesitter_types::ParseError::missing_field("children", node)
6077 })?
6078 };
6079 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6080 },
6081 })
6082 }
6083}
6084impl ::treesitter_types::Spanned for ImplicitStackallocExpression<'_> {
6085 fn span(&self) -> ::treesitter_types::Span {
6086 self.span
6087 }
6088}
6089#[derive(Debug, Clone, PartialEq, Eq)]
6090pub struct ImplicitType<'tree> {
6091 pub span: ::treesitter_types::Span,
6092 text: &'tree str,
6093}
6094impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitType<'tree> {
6095 fn from_node(
6096 node: ::tree_sitter::Node<'tree>,
6097 src: &'tree [u8],
6098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6099 debug_assert_eq!(node.kind(), "implicit_type");
6100 Ok(Self {
6101 span: ::treesitter_types::Span::from(node),
6102 text: node.utf8_text(src)?,
6103 })
6104 }
6105}
6106impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitType<'tree> {
6107 fn text(&self) -> &'tree str {
6108 self.text
6109 }
6110}
6111impl ::treesitter_types::Spanned for ImplicitType<'_> {
6112 fn span(&self) -> ::treesitter_types::Span {
6113 self.span
6114 }
6115}
6116#[derive(Debug, Clone, PartialEq, Eq)]
6117pub struct IndexerDeclaration<'tree> {
6118 pub span: ::treesitter_types::Span,
6119 pub accessors: ::core::option::Option<AccessorList<'tree>>,
6120 pub parameters: BracketedParameterList<'tree>,
6121 pub r#type: Type<'tree>,
6122 pub value: ::core::option::Option<ArrowExpressionClause<'tree>>,
6123 pub children: ::std::vec::Vec<IndexerDeclarationChildren<'tree>>,
6124}
6125impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclaration<'tree> {
6126 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6127 fn from_node(
6128 node: ::tree_sitter::Node<'tree>,
6129 src: &'tree [u8],
6130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6131 debug_assert_eq!(node.kind(), "indexer_declaration");
6132 Ok(Self {
6133 span: ::treesitter_types::Span::from(node),
6134 accessors: match node.child_by_field_name("accessors") {
6135 Some(child) => Some(<AccessorList as ::treesitter_types::FromNode>::from_node(
6136 child, src,
6137 )?),
6138 None => None,
6139 },
6140 parameters: {
6141 let child = node.child_by_field_name("parameters").ok_or_else(|| {
6142 ::treesitter_types::ParseError::missing_field("parameters", node)
6143 })?;
6144 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
6145 },
6146 r#type: {
6147 let child = node
6148 .child_by_field_name("type")
6149 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6150 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6151 },
6152 value: match node.child_by_field_name("value") {
6153 Some(child) => Some(
6154 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(child, src)?,
6155 ),
6156 None => None,
6157 },
6158 children: {
6159 #[allow(clippy::suspicious_else_formatting)]
6160 let non_field_children = {
6161 let mut cursor = node.walk();
6162 let mut result = ::std::vec::Vec::new();
6163 if cursor.goto_first_child() {
6164 loop {
6165 if cursor.field_name().is_none()
6166 && cursor.node().is_named()
6167 && !cursor.node().is_extra()
6168 {
6169 result.push(cursor.node());
6170 }
6171 if !cursor.goto_next_sibling() {
6172 break;
6173 }
6174 }
6175 }
6176 result
6177 };
6178 let mut items = ::std::vec::Vec::new();
6179 for child in non_field_children {
6180 items.push(
6181 <IndexerDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6182 child, src,
6183 )?,
6184 );
6185 }
6186 items
6187 },
6188 })
6189 }
6190}
6191impl ::treesitter_types::Spanned for IndexerDeclaration<'_> {
6192 fn span(&self) -> ::treesitter_types::Span {
6193 self.span
6194 }
6195}
6196#[derive(Debug, Clone, PartialEq, Eq)]
6197pub struct InitializerExpression<'tree> {
6198 pub span: ::treesitter_types::Span,
6199 pub children: ::std::vec::Vec<Expression<'tree>>,
6200}
6201impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerExpression<'tree> {
6202 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6203 fn from_node(
6204 node: ::tree_sitter::Node<'tree>,
6205 src: &'tree [u8],
6206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6207 debug_assert_eq!(node.kind(), "initializer_expression");
6208 Ok(Self {
6209 span: ::treesitter_types::Span::from(node),
6210 children: {
6211 #[allow(clippy::suspicious_else_formatting)]
6212 let non_field_children = {
6213 let mut cursor = node.walk();
6214 let mut result = ::std::vec::Vec::new();
6215 if cursor.goto_first_child() {
6216 loop {
6217 if cursor.field_name().is_none()
6218 && cursor.node().is_named()
6219 && !cursor.node().is_extra()
6220 {
6221 result.push(cursor.node());
6222 }
6223 if !cursor.goto_next_sibling() {
6224 break;
6225 }
6226 }
6227 }
6228 result
6229 };
6230 let mut items = ::std::vec::Vec::new();
6231 for child in non_field_children {
6232 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
6233 child, src,
6234 )?);
6235 }
6236 items
6237 },
6238 })
6239 }
6240}
6241impl ::treesitter_types::Spanned for InitializerExpression<'_> {
6242 fn span(&self) -> ::treesitter_types::Span {
6243 self.span
6244 }
6245}
6246#[derive(Debug, Clone, PartialEq, Eq)]
6247pub struct InterfaceDeclaration<'tree> {
6248 pub span: ::treesitter_types::Span,
6249 pub body: DeclarationList<'tree>,
6250 pub name: Identifier<'tree>,
6251 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
6252 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
6253}
6254impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
6255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6256 fn from_node(
6257 node: ::tree_sitter::Node<'tree>,
6258 src: &'tree [u8],
6259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6260 debug_assert_eq!(node.kind(), "interface_declaration");
6261 Ok(Self {
6262 span: ::treesitter_types::Span::from(node),
6263 body: {
6264 let child = node
6265 .child_by_field_name("body")
6266 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6267 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
6268 },
6269 name: {
6270 let child = node
6271 .child_by_field_name("name")
6272 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6273 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
6274 },
6275 type_parameters: match node.child_by_field_name("type_parameters") {
6276 Some(child) => Some(
6277 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)?,
6278 ),
6279 None => None,
6280 },
6281 children: {
6282 #[allow(clippy::suspicious_else_formatting)]
6283 let non_field_children = {
6284 let mut cursor = node.walk();
6285 let mut result = ::std::vec::Vec::new();
6286 if cursor.goto_first_child() {
6287 loop {
6288 if cursor.field_name().is_none()
6289 && cursor.node().is_named()
6290 && !cursor.node().is_extra()
6291 {
6292 result.push(cursor.node());
6293 }
6294 if !cursor.goto_next_sibling() {
6295 break;
6296 }
6297 }
6298 }
6299 result
6300 };
6301 let mut items = ::std::vec::Vec::new();
6302 for child in non_field_children {
6303 items.push(
6304 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6305 child, src,
6306 )?,
6307 );
6308 }
6309 items
6310 },
6311 })
6312 }
6313}
6314impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
6315 fn span(&self) -> ::treesitter_types::Span {
6316 self.span
6317 }
6318}
6319#[derive(Debug, Clone, PartialEq, Eq)]
6320pub struct InterpolatedStringExpression<'tree> {
6321 pub span: ::treesitter_types::Span,
6322 pub children: ::std::vec::Vec<InterpolatedStringExpressionChildren<'tree>>,
6323}
6324impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpression<'tree> {
6325 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6326 fn from_node(
6327 node: ::tree_sitter::Node<'tree>,
6328 src: &'tree [u8],
6329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6330 debug_assert_eq!(node.kind(), "interpolated_string_expression");
6331 Ok(Self {
6332 span: ::treesitter_types::Span::from(node),
6333 children: {
6334 #[allow(clippy::suspicious_else_formatting)]
6335 let non_field_children = {
6336 let mut cursor = node.walk();
6337 let mut result = ::std::vec::Vec::new();
6338 if cursor.goto_first_child() {
6339 loop {
6340 if cursor.field_name().is_none()
6341 && cursor.node().is_named()
6342 && !cursor.node().is_extra()
6343 {
6344 result.push(cursor.node());
6345 }
6346 if !cursor.goto_next_sibling() {
6347 break;
6348 }
6349 }
6350 }
6351 result
6352 };
6353 let mut items = ::std::vec::Vec::new();
6354 for child in non_field_children {
6355 items
6356 .push(
6357 <InterpolatedStringExpressionChildren as ::treesitter_types::FromNode>::from_node(
6358 child,
6359 src,
6360 )?,
6361 );
6362 }
6363 items
6364 },
6365 })
6366 }
6367}
6368impl ::treesitter_types::Spanned for InterpolatedStringExpression<'_> {
6369 fn span(&self) -> ::treesitter_types::Span {
6370 self.span
6371 }
6372}
6373#[derive(Debug, Clone, PartialEq, Eq)]
6374pub struct Interpolation<'tree> {
6375 pub span: ::treesitter_types::Span,
6376 pub children: ::std::vec::Vec<InterpolationChildren<'tree>>,
6377}
6378impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
6379 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6380 fn from_node(
6381 node: ::tree_sitter::Node<'tree>,
6382 src: &'tree [u8],
6383 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6384 debug_assert_eq!(node.kind(), "interpolation");
6385 Ok(Self {
6386 span: ::treesitter_types::Span::from(node),
6387 children: {
6388 #[allow(clippy::suspicious_else_formatting)]
6389 let non_field_children = {
6390 let mut cursor = node.walk();
6391 let mut result = ::std::vec::Vec::new();
6392 if cursor.goto_first_child() {
6393 loop {
6394 if cursor.field_name().is_none()
6395 && cursor.node().is_named()
6396 && !cursor.node().is_extra()
6397 {
6398 result.push(cursor.node());
6399 }
6400 if !cursor.goto_next_sibling() {
6401 break;
6402 }
6403 }
6404 }
6405 result
6406 };
6407 let mut items = ::std::vec::Vec::new();
6408 for child in non_field_children {
6409 items.push(
6410 <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
6411 child, src,
6412 )?,
6413 );
6414 }
6415 items
6416 },
6417 })
6418 }
6419}
6420impl ::treesitter_types::Spanned for Interpolation<'_> {
6421 fn span(&self) -> ::treesitter_types::Span {
6422 self.span
6423 }
6424}
6425#[derive(Debug, Clone, PartialEq, Eq)]
6426pub struct InterpolationAlignmentClause<'tree> {
6427 pub span: ::treesitter_types::Span,
6428 pub children: Expression<'tree>,
6429}
6430impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationAlignmentClause<'tree> {
6431 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6432 fn from_node(
6433 node: ::tree_sitter::Node<'tree>,
6434 src: &'tree [u8],
6435 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6436 debug_assert_eq!(node.kind(), "interpolation_alignment_clause");
6437 Ok(Self {
6438 span: ::treesitter_types::Span::from(node),
6439 children: {
6440 #[allow(clippy::suspicious_else_formatting)]
6441 let non_field_children = {
6442 let mut cursor = node.walk();
6443 let mut result = ::std::vec::Vec::new();
6444 if cursor.goto_first_child() {
6445 loop {
6446 if cursor.field_name().is_none()
6447 && cursor.node().is_named()
6448 && !cursor.node().is_extra()
6449 {
6450 result.push(cursor.node());
6451 }
6452 if !cursor.goto_next_sibling() {
6453 break;
6454 }
6455 }
6456 }
6457 result
6458 };
6459 let child = if let Some(&c) = non_field_children.first() {
6460 c
6461 } else {
6462 let mut fallback_cursor = node.walk();
6463 let mut fallback_child = None;
6464 if fallback_cursor.goto_first_child() {
6465 loop {
6466 if fallback_cursor.field_name().is_none()
6467 && !fallback_cursor.node().is_extra()
6468 {
6469 let candidate = fallback_cursor.node();
6470 #[allow(clippy::needless_question_mark)]
6471 if (|| -> ::core::result::Result<
6472 _,
6473 ::treesitter_types::ParseError,
6474 > {
6475 let child = candidate;
6476 Ok(
6477 <Expression as ::treesitter_types::FromNode>::from_node(
6478 child,
6479 src,
6480 )?,
6481 )
6482 })()
6483 .is_ok()
6484 {
6485 fallback_child = Some(candidate);
6486 break;
6487 }
6488 }
6489 if !fallback_cursor.goto_next_sibling() {
6490 break;
6491 }
6492 }
6493 }
6494 if fallback_child.is_none() {
6495 let mut cursor2 = node.walk();
6496 if cursor2.goto_first_child() {
6497 loop {
6498 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6499 let candidate = cursor2.node();
6500 #[allow(clippy::needless_question_mark)]
6501 if (|| -> ::core::result::Result<
6502 _,
6503 ::treesitter_types::ParseError,
6504 > {
6505 let child = candidate;
6506 Ok(
6507 <Expression as ::treesitter_types::FromNode>::from_node(
6508 child,
6509 src,
6510 )?,
6511 )
6512 })()
6513 .is_ok()
6514 {
6515 fallback_child = Some(candidate);
6516 break;
6517 }
6518 }
6519 if !cursor2.goto_next_sibling() {
6520 break;
6521 }
6522 }
6523 }
6524 }
6525 fallback_child.ok_or_else(|| {
6526 ::treesitter_types::ParseError::missing_field("children", node)
6527 })?
6528 };
6529 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6530 },
6531 })
6532 }
6533}
6534impl ::treesitter_types::Spanned for InterpolationAlignmentClause<'_> {
6535 fn span(&self) -> ::treesitter_types::Span {
6536 self.span
6537 }
6538}
6539#[derive(Debug, Clone, PartialEq, Eq)]
6540pub struct InterpolationFormatClause<'tree> {
6541 pub span: ::treesitter_types::Span,
6542 text: &'tree str,
6543}
6544impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationFormatClause<'tree> {
6545 fn from_node(
6546 node: ::tree_sitter::Node<'tree>,
6547 src: &'tree [u8],
6548 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6549 debug_assert_eq!(node.kind(), "interpolation_format_clause");
6550 Ok(Self {
6551 span: ::treesitter_types::Span::from(node),
6552 text: node.utf8_text(src)?,
6553 })
6554 }
6555}
6556impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationFormatClause<'tree> {
6557 fn text(&self) -> &'tree str {
6558 self.text
6559 }
6560}
6561impl ::treesitter_types::Spanned for InterpolationFormatClause<'_> {
6562 fn span(&self) -> ::treesitter_types::Span {
6563 self.span
6564 }
6565}
6566#[derive(Debug, Clone, PartialEq, Eq)]
6567pub struct InvocationExpression<'tree> {
6568 pub span: ::treesitter_types::Span,
6569 pub arguments: ArgumentList<'tree>,
6570 pub function: Expression<'tree>,
6571}
6572impl<'tree> ::treesitter_types::FromNode<'tree> for InvocationExpression<'tree> {
6573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6574 fn from_node(
6575 node: ::tree_sitter::Node<'tree>,
6576 src: &'tree [u8],
6577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6578 debug_assert_eq!(node.kind(), "invocation_expression");
6579 Ok(Self {
6580 span: ::treesitter_types::Span::from(node),
6581 arguments: {
6582 let child = node.child_by_field_name("arguments").ok_or_else(|| {
6583 ::treesitter_types::ParseError::missing_field("arguments", node)
6584 })?;
6585 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
6586 },
6587 function: {
6588 let child = node.child_by_field_name("function").ok_or_else(|| {
6589 ::treesitter_types::ParseError::missing_field("function", node)
6590 })?;
6591 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6592 },
6593 })
6594 }
6595}
6596impl ::treesitter_types::Spanned for InvocationExpression<'_> {
6597 fn span(&self) -> ::treesitter_types::Span {
6598 self.span
6599 }
6600}
6601#[derive(Debug, Clone, PartialEq, Eq)]
6602pub struct IsExpression<'tree> {
6603 pub span: ::treesitter_types::Span,
6604 pub left: Expression<'tree>,
6605 pub operator: IsExpressionOperator,
6606 pub right: Type<'tree>,
6607}
6608impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpression<'tree> {
6609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6610 fn from_node(
6611 node: ::tree_sitter::Node<'tree>,
6612 src: &'tree [u8],
6613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6614 debug_assert_eq!(node.kind(), "is_expression");
6615 Ok(Self {
6616 span: ::treesitter_types::Span::from(node),
6617 left: {
6618 let child = node
6619 .child_by_field_name("left")
6620 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
6621 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6622 },
6623 operator: {
6624 let child = node.child_by_field_name("operator").ok_or_else(|| {
6625 ::treesitter_types::ParseError::missing_field("operator", node)
6626 })?;
6627 <IsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
6628 },
6629 right: {
6630 let child = node
6631 .child_by_field_name("right")
6632 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
6633 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6634 },
6635 })
6636 }
6637}
6638impl ::treesitter_types::Spanned for IsExpression<'_> {
6639 fn span(&self) -> ::treesitter_types::Span {
6640 self.span
6641 }
6642}
6643#[derive(Debug, Clone, PartialEq, Eq)]
6644pub struct IsPatternExpression<'tree> {
6645 pub span: ::treesitter_types::Span,
6646 pub expression: Expression<'tree>,
6647 pub pattern: Pattern<'tree>,
6648}
6649impl<'tree> ::treesitter_types::FromNode<'tree> for IsPatternExpression<'tree> {
6650 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6651 fn from_node(
6652 node: ::tree_sitter::Node<'tree>,
6653 src: &'tree [u8],
6654 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6655 debug_assert_eq!(node.kind(), "is_pattern_expression");
6656 Ok(Self {
6657 span: ::treesitter_types::Span::from(node),
6658 expression: {
6659 let child = node.child_by_field_name("expression").ok_or_else(|| {
6660 ::treesitter_types::ParseError::missing_field("expression", node)
6661 })?;
6662 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6663 },
6664 pattern: {
6665 let child = node.child_by_field_name("pattern").ok_or_else(|| {
6666 ::treesitter_types::ParseError::missing_field("pattern", node)
6667 })?;
6668 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
6669 },
6670 })
6671 }
6672}
6673impl ::treesitter_types::Spanned for IsPatternExpression<'_> {
6674 fn span(&self) -> ::treesitter_types::Span {
6675 self.span
6676 }
6677}
6678#[derive(Debug, Clone, PartialEq, Eq)]
6679pub struct JoinClause<'tree> {
6680 pub span: ::treesitter_types::Span,
6681 pub r#type: ::core::option::Option<Type<'tree>>,
6682 pub children: ::std::vec::Vec<JoinClauseChildren<'tree>>,
6683}
6684impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClause<'tree> {
6685 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6686 fn from_node(
6687 node: ::tree_sitter::Node<'tree>,
6688 src: &'tree [u8],
6689 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6690 debug_assert_eq!(node.kind(), "join_clause");
6691 Ok(Self {
6692 span: ::treesitter_types::Span::from(node),
6693 r#type: match node.child_by_field_name("type") {
6694 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
6695 child, src,
6696 )?),
6697 None => None,
6698 },
6699 children: {
6700 #[allow(clippy::suspicious_else_formatting)]
6701 let non_field_children = {
6702 let mut cursor = node.walk();
6703 let mut result = ::std::vec::Vec::new();
6704 if cursor.goto_first_child() {
6705 loop {
6706 if cursor.field_name().is_none()
6707 && cursor.node().is_named()
6708 && !cursor.node().is_extra()
6709 {
6710 result.push(cursor.node());
6711 }
6712 if !cursor.goto_next_sibling() {
6713 break;
6714 }
6715 }
6716 }
6717 result
6718 };
6719 let mut items = ::std::vec::Vec::new();
6720 for child in non_field_children {
6721 items.push(
6722 <JoinClauseChildren as ::treesitter_types::FromNode>::from_node(
6723 child, src,
6724 )?,
6725 );
6726 }
6727 items
6728 },
6729 })
6730 }
6731}
6732impl ::treesitter_types::Spanned for JoinClause<'_> {
6733 fn span(&self) -> ::treesitter_types::Span {
6734 self.span
6735 }
6736}
6737#[derive(Debug, Clone, PartialEq, Eq)]
6738pub struct JoinIntoClause<'tree> {
6739 pub span: ::treesitter_types::Span,
6740 pub children: Identifier<'tree>,
6741}
6742impl<'tree> ::treesitter_types::FromNode<'tree> for JoinIntoClause<'tree> {
6743 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6744 fn from_node(
6745 node: ::tree_sitter::Node<'tree>,
6746 src: &'tree [u8],
6747 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6748 debug_assert_eq!(node.kind(), "join_into_clause");
6749 Ok(Self {
6750 span: ::treesitter_types::Span::from(node),
6751 children: {
6752 #[allow(clippy::suspicious_else_formatting)]
6753 let non_field_children = {
6754 let mut cursor = node.walk();
6755 let mut result = ::std::vec::Vec::new();
6756 if cursor.goto_first_child() {
6757 loop {
6758 if cursor.field_name().is_none()
6759 && cursor.node().is_named()
6760 && !cursor.node().is_extra()
6761 {
6762 result.push(cursor.node());
6763 }
6764 if !cursor.goto_next_sibling() {
6765 break;
6766 }
6767 }
6768 }
6769 result
6770 };
6771 let child = if let Some(&c) = non_field_children.first() {
6772 c
6773 } else {
6774 let mut fallback_cursor = node.walk();
6775 let mut fallback_child = None;
6776 if fallback_cursor.goto_first_child() {
6777 loop {
6778 if fallback_cursor.field_name().is_none()
6779 && !fallback_cursor.node().is_extra()
6780 {
6781 let candidate = fallback_cursor.node();
6782 #[allow(clippy::needless_question_mark)]
6783 if (|| -> ::core::result::Result<
6784 _,
6785 ::treesitter_types::ParseError,
6786 > {
6787 let child = candidate;
6788 Ok(
6789 <Identifier as ::treesitter_types::FromNode>::from_node(
6790 child,
6791 src,
6792 )?,
6793 )
6794 })()
6795 .is_ok()
6796 {
6797 fallback_child = Some(candidate);
6798 break;
6799 }
6800 }
6801 if !fallback_cursor.goto_next_sibling() {
6802 break;
6803 }
6804 }
6805 }
6806 if fallback_child.is_none() {
6807 let mut cursor2 = node.walk();
6808 if cursor2.goto_first_child() {
6809 loop {
6810 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6811 let candidate = cursor2.node();
6812 #[allow(clippy::needless_question_mark)]
6813 if (|| -> ::core::result::Result<
6814 _,
6815 ::treesitter_types::ParseError,
6816 > {
6817 let child = candidate;
6818 Ok(
6819 <Identifier as ::treesitter_types::FromNode>::from_node(
6820 child,
6821 src,
6822 )?,
6823 )
6824 })()
6825 .is_ok()
6826 {
6827 fallback_child = Some(candidate);
6828 break;
6829 }
6830 }
6831 if !cursor2.goto_next_sibling() {
6832 break;
6833 }
6834 }
6835 }
6836 }
6837 fallback_child.ok_or_else(|| {
6838 ::treesitter_types::ParseError::missing_field("children", node)
6839 })?
6840 };
6841 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
6842 },
6843 })
6844 }
6845}
6846impl ::treesitter_types::Spanned for JoinIntoClause<'_> {
6847 fn span(&self) -> ::treesitter_types::Span {
6848 self.span
6849 }
6850}
6851#[derive(Debug, Clone, PartialEq, Eq)]
6852pub struct LabeledStatement<'tree> {
6853 pub span: ::treesitter_types::Span,
6854 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
6855}
6856impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
6857 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6858 fn from_node(
6859 node: ::tree_sitter::Node<'tree>,
6860 src: &'tree [u8],
6861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6862 debug_assert_eq!(node.kind(), "labeled_statement");
6863 Ok(Self {
6864 span: ::treesitter_types::Span::from(node),
6865 children: {
6866 #[allow(clippy::suspicious_else_formatting)]
6867 let non_field_children = {
6868 let mut cursor = node.walk();
6869 let mut result = ::std::vec::Vec::new();
6870 if cursor.goto_first_child() {
6871 loop {
6872 if cursor.field_name().is_none()
6873 && cursor.node().is_named()
6874 && !cursor.node().is_extra()
6875 {
6876 result.push(cursor.node());
6877 }
6878 if !cursor.goto_next_sibling() {
6879 break;
6880 }
6881 }
6882 }
6883 result
6884 };
6885 let mut items = ::std::vec::Vec::new();
6886 for child in non_field_children {
6887 items.push(
6888 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
6889 child, src,
6890 )?,
6891 );
6892 }
6893 items
6894 },
6895 })
6896 }
6897}
6898impl ::treesitter_types::Spanned for LabeledStatement<'_> {
6899 fn span(&self) -> ::treesitter_types::Span {
6900 self.span
6901 }
6902}
6903#[derive(Debug, Clone, PartialEq, Eq)]
6904pub struct LambdaExpression<'tree> {
6905 pub span: ::treesitter_types::Span,
6906 pub body: LambdaExpressionBody<'tree>,
6907 pub parameters: LambdaExpressionParameters<'tree>,
6908 pub r#type: ::core::option::Option<Type<'tree>>,
6909 pub children: ::std::vec::Vec<LambdaExpressionChildren<'tree>>,
6910}
6911impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
6912 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6913 fn from_node(
6914 node: ::tree_sitter::Node<'tree>,
6915 src: &'tree [u8],
6916 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6917 debug_assert_eq!(node.kind(), "lambda_expression");
6918 Ok(Self {
6919 span: ::treesitter_types::Span::from(node),
6920 body: {
6921 let child = node
6922 .child_by_field_name("body")
6923 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6924 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)?
6925 },
6926 parameters: {
6927 let child = node.child_by_field_name("parameters").ok_or_else(|| {
6928 ::treesitter_types::ParseError::missing_field("parameters", node)
6929 })?;
6930 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(child, src)?
6931 },
6932 r#type: match node.child_by_field_name("type") {
6933 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
6934 child, src,
6935 )?),
6936 None => None,
6937 },
6938 children: {
6939 #[allow(clippy::suspicious_else_formatting)]
6940 let non_field_children = {
6941 let mut cursor = node.walk();
6942 let mut result = ::std::vec::Vec::new();
6943 if cursor.goto_first_child() {
6944 loop {
6945 if cursor.field_name().is_none()
6946 && cursor.node().is_named()
6947 && !cursor.node().is_extra()
6948 {
6949 result.push(cursor.node());
6950 }
6951 if !cursor.goto_next_sibling() {
6952 break;
6953 }
6954 }
6955 }
6956 result
6957 };
6958 let mut items = ::std::vec::Vec::new();
6959 for child in non_field_children {
6960 items.push(
6961 <LambdaExpressionChildren as ::treesitter_types::FromNode>::from_node(
6962 child, src,
6963 )?,
6964 );
6965 }
6966 items
6967 },
6968 })
6969 }
6970}
6971impl ::treesitter_types::Spanned for LambdaExpression<'_> {
6972 fn span(&self) -> ::treesitter_types::Span {
6973 self.span
6974 }
6975}
6976#[derive(Debug, Clone, PartialEq, Eq)]
6977pub struct LetClause<'tree> {
6978 pub span: ::treesitter_types::Span,
6979 pub children: ::std::vec::Vec<LetClauseChildren<'tree>>,
6980}
6981impl<'tree> ::treesitter_types::FromNode<'tree> for LetClause<'tree> {
6982 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6983 fn from_node(
6984 node: ::tree_sitter::Node<'tree>,
6985 src: &'tree [u8],
6986 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6987 debug_assert_eq!(node.kind(), "let_clause");
6988 Ok(Self {
6989 span: ::treesitter_types::Span::from(node),
6990 children: {
6991 #[allow(clippy::suspicious_else_formatting)]
6992 let non_field_children = {
6993 let mut cursor = node.walk();
6994 let mut result = ::std::vec::Vec::new();
6995 if cursor.goto_first_child() {
6996 loop {
6997 if cursor.field_name().is_none()
6998 && cursor.node().is_named()
6999 && !cursor.node().is_extra()
7000 {
7001 result.push(cursor.node());
7002 }
7003 if !cursor.goto_next_sibling() {
7004 break;
7005 }
7006 }
7007 }
7008 result
7009 };
7010 let mut items = ::std::vec::Vec::new();
7011 for child in non_field_children {
7012 items.push(
7013 <LetClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7014 );
7015 }
7016 items
7017 },
7018 })
7019 }
7020}
7021impl ::treesitter_types::Spanned for LetClause<'_> {
7022 fn span(&self) -> ::treesitter_types::Span {
7023 self.span
7024 }
7025}
7026#[derive(Debug, Clone, PartialEq, Eq)]
7027pub struct ListPattern<'tree> {
7028 pub span: ::treesitter_types::Span,
7029 pub children: ::std::vec::Vec<Pattern<'tree>>,
7030}
7031impl<'tree> ::treesitter_types::FromNode<'tree> for ListPattern<'tree> {
7032 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7033 fn from_node(
7034 node: ::tree_sitter::Node<'tree>,
7035 src: &'tree [u8],
7036 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7037 debug_assert_eq!(node.kind(), "list_pattern");
7038 Ok(Self {
7039 span: ::treesitter_types::Span::from(node),
7040 children: {
7041 #[allow(clippy::suspicious_else_formatting)]
7042 let non_field_children = {
7043 let mut cursor = node.walk();
7044 let mut result = ::std::vec::Vec::new();
7045 if cursor.goto_first_child() {
7046 loop {
7047 if cursor.field_name().is_none()
7048 && cursor.node().is_named()
7049 && !cursor.node().is_extra()
7050 {
7051 result.push(cursor.node());
7052 }
7053 if !cursor.goto_next_sibling() {
7054 break;
7055 }
7056 }
7057 }
7058 result
7059 };
7060 let mut items = ::std::vec::Vec::new();
7061 for child in non_field_children {
7062 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
7063 child, src,
7064 )?);
7065 }
7066 items
7067 },
7068 })
7069 }
7070}
7071impl ::treesitter_types::Spanned for ListPattern<'_> {
7072 fn span(&self) -> ::treesitter_types::Span {
7073 self.span
7074 }
7075}
7076#[derive(Debug, Clone, PartialEq, Eq)]
7077pub struct LocalDeclarationStatement<'tree> {
7078 pub span: ::treesitter_types::Span,
7079 pub children: ::std::vec::Vec<LocalDeclarationStatementChildren<'tree>>,
7080}
7081impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatement<'tree> {
7082 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7083 fn from_node(
7084 node: ::tree_sitter::Node<'tree>,
7085 src: &'tree [u8],
7086 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7087 debug_assert_eq!(node.kind(), "local_declaration_statement");
7088 Ok(Self {
7089 span: ::treesitter_types::Span::from(node),
7090 children: {
7091 #[allow(clippy::suspicious_else_formatting)]
7092 let non_field_children = {
7093 let mut cursor = node.walk();
7094 let mut result = ::std::vec::Vec::new();
7095 if cursor.goto_first_child() {
7096 loop {
7097 if cursor.field_name().is_none()
7098 && cursor.node().is_named()
7099 && !cursor.node().is_extra()
7100 {
7101 result.push(cursor.node());
7102 }
7103 if !cursor.goto_next_sibling() {
7104 break;
7105 }
7106 }
7107 }
7108 result
7109 };
7110 let mut items = ::std::vec::Vec::new();
7111 for child in non_field_children {
7112 items
7113 .push(
7114 <LocalDeclarationStatementChildren as ::treesitter_types::FromNode>::from_node(
7115 child,
7116 src,
7117 )?,
7118 );
7119 }
7120 items
7121 },
7122 })
7123 }
7124}
7125impl ::treesitter_types::Spanned for LocalDeclarationStatement<'_> {
7126 fn span(&self) -> ::treesitter_types::Span {
7127 self.span
7128 }
7129}
7130#[derive(Debug, Clone, PartialEq, Eq)]
7131pub struct LocalFunctionStatement<'tree> {
7132 pub span: ::treesitter_types::Span,
7133 pub body: ::core::option::Option<LocalFunctionStatementBody<'tree>>,
7134 pub name: Identifier<'tree>,
7135 pub parameters: ParameterList<'tree>,
7136 pub r#type: Type<'tree>,
7137 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
7138 pub children: ::std::vec::Vec<LocalFunctionStatementChildren<'tree>>,
7139}
7140impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatement<'tree> {
7141 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7142 fn from_node(
7143 node: ::tree_sitter::Node<'tree>,
7144 src: &'tree [u8],
7145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7146 debug_assert_eq!(node.kind(), "local_function_statement");
7147 Ok(Self {
7148 span: ::treesitter_types::Span::from(node),
7149 body: match node.child_by_field_name("body") {
7150 Some(child) => Some(
7151 <LocalFunctionStatementBody as ::treesitter_types::FromNode>::from_node(
7152 child, src,
7153 )?,
7154 ),
7155 None => None,
7156 },
7157 name: {
7158 let child = node
7159 .child_by_field_name("name")
7160 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7161 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7162 },
7163 parameters: {
7164 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7165 ::treesitter_types::ParseError::missing_field("parameters", node)
7166 })?;
7167 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
7168 },
7169 r#type: {
7170 let child = node
7171 .child_by_field_name("type")
7172 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7173 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7174 },
7175 type_parameters: match node.child_by_field_name("type_parameters") {
7176 Some(child) => Some(
7177 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)?,
7178 ),
7179 None => None,
7180 },
7181 children: {
7182 #[allow(clippy::suspicious_else_formatting)]
7183 let non_field_children = {
7184 let mut cursor = node.walk();
7185 let mut result = ::std::vec::Vec::new();
7186 if cursor.goto_first_child() {
7187 loop {
7188 if cursor.field_name().is_none()
7189 && cursor.node().is_named()
7190 && !cursor.node().is_extra()
7191 {
7192 result.push(cursor.node());
7193 }
7194 if !cursor.goto_next_sibling() {
7195 break;
7196 }
7197 }
7198 }
7199 result
7200 };
7201 let mut items = ::std::vec::Vec::new();
7202 for child in non_field_children {
7203 items
7204 .push(
7205 <LocalFunctionStatementChildren as ::treesitter_types::FromNode>::from_node(
7206 child,
7207 src,
7208 )?,
7209 );
7210 }
7211 items
7212 },
7213 })
7214 }
7215}
7216impl ::treesitter_types::Spanned for LocalFunctionStatement<'_> {
7217 fn span(&self) -> ::treesitter_types::Span {
7218 self.span
7219 }
7220}
7221#[derive(Debug, Clone, PartialEq, Eq)]
7222pub struct LockStatement<'tree> {
7223 pub span: ::treesitter_types::Span,
7224 pub children: ::std::vec::Vec<LockStatementChildren<'tree>>,
7225}
7226impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatement<'tree> {
7227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7228 fn from_node(
7229 node: ::tree_sitter::Node<'tree>,
7230 src: &'tree [u8],
7231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7232 debug_assert_eq!(node.kind(), "lock_statement");
7233 Ok(Self {
7234 span: ::treesitter_types::Span::from(node),
7235 children: {
7236 #[allow(clippy::suspicious_else_formatting)]
7237 let non_field_children = {
7238 let mut cursor = node.walk();
7239 let mut result = ::std::vec::Vec::new();
7240 if cursor.goto_first_child() {
7241 loop {
7242 if cursor.field_name().is_none()
7243 && cursor.node().is_named()
7244 && !cursor.node().is_extra()
7245 {
7246 result.push(cursor.node());
7247 }
7248 if !cursor.goto_next_sibling() {
7249 break;
7250 }
7251 }
7252 }
7253 result
7254 };
7255 let mut items = ::std::vec::Vec::new();
7256 for child in non_field_children {
7257 items.push(
7258 <LockStatementChildren as ::treesitter_types::FromNode>::from_node(
7259 child, src,
7260 )?,
7261 );
7262 }
7263 items
7264 },
7265 })
7266 }
7267}
7268impl ::treesitter_types::Spanned for LockStatement<'_> {
7269 fn span(&self) -> ::treesitter_types::Span {
7270 self.span
7271 }
7272}
7273#[derive(Debug, Clone, PartialEq, Eq)]
7274pub struct MakerefExpression<'tree> {
7275 pub span: ::treesitter_types::Span,
7276 pub children: Expression<'tree>,
7277}
7278impl<'tree> ::treesitter_types::FromNode<'tree> for MakerefExpression<'tree> {
7279 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7280 fn from_node(
7281 node: ::tree_sitter::Node<'tree>,
7282 src: &'tree [u8],
7283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7284 debug_assert_eq!(node.kind(), "makeref_expression");
7285 Ok(Self {
7286 span: ::treesitter_types::Span::from(node),
7287 children: {
7288 #[allow(clippy::suspicious_else_formatting)]
7289 let non_field_children = {
7290 let mut cursor = node.walk();
7291 let mut result = ::std::vec::Vec::new();
7292 if cursor.goto_first_child() {
7293 loop {
7294 if cursor.field_name().is_none()
7295 && cursor.node().is_named()
7296 && !cursor.node().is_extra()
7297 {
7298 result.push(cursor.node());
7299 }
7300 if !cursor.goto_next_sibling() {
7301 break;
7302 }
7303 }
7304 }
7305 result
7306 };
7307 let child = if let Some(&c) = non_field_children.first() {
7308 c
7309 } else {
7310 let mut fallback_cursor = node.walk();
7311 let mut fallback_child = None;
7312 if fallback_cursor.goto_first_child() {
7313 loop {
7314 if fallback_cursor.field_name().is_none()
7315 && !fallback_cursor.node().is_extra()
7316 {
7317 let candidate = fallback_cursor.node();
7318 #[allow(clippy::needless_question_mark)]
7319 if (|| -> ::core::result::Result<
7320 _,
7321 ::treesitter_types::ParseError,
7322 > {
7323 let child = candidate;
7324 Ok(
7325 <Expression as ::treesitter_types::FromNode>::from_node(
7326 child,
7327 src,
7328 )?,
7329 )
7330 })()
7331 .is_ok()
7332 {
7333 fallback_child = Some(candidate);
7334 break;
7335 }
7336 }
7337 if !fallback_cursor.goto_next_sibling() {
7338 break;
7339 }
7340 }
7341 }
7342 if fallback_child.is_none() {
7343 let mut cursor2 = node.walk();
7344 if cursor2.goto_first_child() {
7345 loop {
7346 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7347 let candidate = cursor2.node();
7348 #[allow(clippy::needless_question_mark)]
7349 if (|| -> ::core::result::Result<
7350 _,
7351 ::treesitter_types::ParseError,
7352 > {
7353 let child = candidate;
7354 Ok(
7355 <Expression as ::treesitter_types::FromNode>::from_node(
7356 child,
7357 src,
7358 )?,
7359 )
7360 })()
7361 .is_ok()
7362 {
7363 fallback_child = Some(candidate);
7364 break;
7365 }
7366 }
7367 if !cursor2.goto_next_sibling() {
7368 break;
7369 }
7370 }
7371 }
7372 }
7373 fallback_child.ok_or_else(|| {
7374 ::treesitter_types::ParseError::missing_field("children", node)
7375 })?
7376 };
7377 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7378 },
7379 })
7380 }
7381}
7382impl ::treesitter_types::Spanned for MakerefExpression<'_> {
7383 fn span(&self) -> ::treesitter_types::Span {
7384 self.span
7385 }
7386}
7387#[derive(Debug, Clone, PartialEq, Eq)]
7388pub struct MemberAccessExpression<'tree> {
7389 pub span: ::treesitter_types::Span,
7390 pub expression: MemberAccessExpressionExpression<'tree>,
7391 pub name: MemberAccessExpressionName<'tree>,
7392}
7393impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpression<'tree> {
7394 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7395 fn from_node(
7396 node: ::tree_sitter::Node<'tree>,
7397 src: &'tree [u8],
7398 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7399 debug_assert_eq!(node.kind(), "member_access_expression");
7400 Ok(Self {
7401 span: ::treesitter_types::Span::from(node),
7402 expression: {
7403 let child = node.child_by_field_name("expression").ok_or_else(|| {
7404 ::treesitter_types::ParseError::missing_field("expression", node)
7405 })?;
7406 <MemberAccessExpressionExpression as ::treesitter_types::FromNode>::from_node(
7407 child, src,
7408 )?
7409 },
7410 name: {
7411 let child = node
7412 .child_by_field_name("name")
7413 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7414 <MemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
7415 },
7416 })
7417 }
7418}
7419impl ::treesitter_types::Spanned for MemberAccessExpression<'_> {
7420 fn span(&self) -> ::treesitter_types::Span {
7421 self.span
7422 }
7423}
7424#[derive(Debug, Clone, PartialEq, Eq)]
7425pub struct MemberBindingExpression<'tree> {
7426 pub span: ::treesitter_types::Span,
7427 pub name: MemberBindingExpressionName<'tree>,
7428}
7429impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpression<'tree> {
7430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7431 fn from_node(
7432 node: ::tree_sitter::Node<'tree>,
7433 src: &'tree [u8],
7434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7435 debug_assert_eq!(node.kind(), "member_binding_expression");
7436 Ok(Self {
7437 span: ::treesitter_types::Span::from(node),
7438 name: {
7439 let child = node
7440 .child_by_field_name("name")
7441 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7442 <MemberBindingExpressionName as ::treesitter_types::FromNode>::from_node(
7443 child, src,
7444 )?
7445 },
7446 })
7447 }
7448}
7449impl ::treesitter_types::Spanned for MemberBindingExpression<'_> {
7450 fn span(&self) -> ::treesitter_types::Span {
7451 self.span
7452 }
7453}
7454#[derive(Debug, Clone, PartialEq, Eq)]
7455pub struct MethodDeclaration<'tree> {
7456 pub span: ::treesitter_types::Span,
7457 pub body: ::core::option::Option<MethodDeclarationBody<'tree>>,
7458 pub name: Identifier<'tree>,
7459 pub parameters: ParameterList<'tree>,
7460 pub returns: Type<'tree>,
7461 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
7462 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
7463}
7464impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
7465 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7466 fn from_node(
7467 node: ::tree_sitter::Node<'tree>,
7468 src: &'tree [u8],
7469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7470 debug_assert_eq!(node.kind(), "method_declaration");
7471 Ok(Self {
7472 span: ::treesitter_types::Span::from(node),
7473 body: match node.child_by_field_name("body") {
7474 Some(child) => Some(
7475 <MethodDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)?,
7476 ),
7477 None => None,
7478 },
7479 name: {
7480 let child = node
7481 .child_by_field_name("name")
7482 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7483 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7484 },
7485 parameters: {
7486 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7487 ::treesitter_types::ParseError::missing_field("parameters", node)
7488 })?;
7489 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
7490 },
7491 returns: {
7492 let child = node.child_by_field_name("returns").ok_or_else(|| {
7493 ::treesitter_types::ParseError::missing_field("returns", node)
7494 })?;
7495 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7496 },
7497 type_parameters: match node.child_by_field_name("type_parameters") {
7498 Some(child) => Some(
7499 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)?,
7500 ),
7501 None => None,
7502 },
7503 children: {
7504 #[allow(clippy::suspicious_else_formatting)]
7505 let non_field_children = {
7506 let mut cursor = node.walk();
7507 let mut result = ::std::vec::Vec::new();
7508 if cursor.goto_first_child() {
7509 loop {
7510 if cursor.field_name().is_none()
7511 && cursor.node().is_named()
7512 && !cursor.node().is_extra()
7513 {
7514 result.push(cursor.node());
7515 }
7516 if !cursor.goto_next_sibling() {
7517 break;
7518 }
7519 }
7520 }
7521 result
7522 };
7523 let mut items = ::std::vec::Vec::new();
7524 for child in non_field_children {
7525 items.push(
7526 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7527 child, src,
7528 )?,
7529 );
7530 }
7531 items
7532 },
7533 })
7534 }
7535}
7536impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
7537 fn span(&self) -> ::treesitter_types::Span {
7538 self.span
7539 }
7540}
7541#[derive(Debug, Clone, PartialEq, Eq)]
7542pub struct Modifier<'tree> {
7543 pub span: ::treesitter_types::Span,
7544 text: &'tree str,
7545}
7546impl<'tree> ::treesitter_types::FromNode<'tree> for Modifier<'tree> {
7547 fn from_node(
7548 node: ::tree_sitter::Node<'tree>,
7549 src: &'tree [u8],
7550 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7551 debug_assert_eq!(node.kind(), "modifier");
7552 Ok(Self {
7553 span: ::treesitter_types::Span::from(node),
7554 text: node.utf8_text(src)?,
7555 })
7556 }
7557}
7558impl<'tree> ::treesitter_types::LeafNode<'tree> for Modifier<'tree> {
7559 fn text(&self) -> &'tree str {
7560 self.text
7561 }
7562}
7563impl ::treesitter_types::Spanned for Modifier<'_> {
7564 fn span(&self) -> ::treesitter_types::Span {
7565 self.span
7566 }
7567}
7568#[derive(Debug, Clone, PartialEq, Eq)]
7569pub struct NamespaceDeclaration<'tree> {
7570 pub span: ::treesitter_types::Span,
7571 pub body: DeclarationList<'tree>,
7572 pub name: NamespaceDeclarationName<'tree>,
7573}
7574impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclaration<'tree> {
7575 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7576 fn from_node(
7577 node: ::tree_sitter::Node<'tree>,
7578 src: &'tree [u8],
7579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7580 debug_assert_eq!(node.kind(), "namespace_declaration");
7581 Ok(Self {
7582 span: ::treesitter_types::Span::from(node),
7583 body: {
7584 let child = node
7585 .child_by_field_name("body")
7586 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7587 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
7588 },
7589 name: {
7590 let child = node
7591 .child_by_field_name("name")
7592 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7593 <NamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)?
7594 },
7595 })
7596 }
7597}
7598impl ::treesitter_types::Spanned for NamespaceDeclaration<'_> {
7599 fn span(&self) -> ::treesitter_types::Span {
7600 self.span
7601 }
7602}
7603#[derive(Debug, Clone, PartialEq, Eq)]
7604pub struct NegatedPattern<'tree> {
7605 pub span: ::treesitter_types::Span,
7606 pub children: Pattern<'tree>,
7607}
7608impl<'tree> ::treesitter_types::FromNode<'tree> for NegatedPattern<'tree> {
7609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7610 fn from_node(
7611 node: ::tree_sitter::Node<'tree>,
7612 src: &'tree [u8],
7613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7614 debug_assert_eq!(node.kind(), "negated_pattern");
7615 Ok(Self {
7616 span: ::treesitter_types::Span::from(node),
7617 children: {
7618 #[allow(clippy::suspicious_else_formatting)]
7619 let non_field_children = {
7620 let mut cursor = node.walk();
7621 let mut result = ::std::vec::Vec::new();
7622 if cursor.goto_first_child() {
7623 loop {
7624 if cursor.field_name().is_none()
7625 && cursor.node().is_named()
7626 && !cursor.node().is_extra()
7627 {
7628 result.push(cursor.node());
7629 }
7630 if !cursor.goto_next_sibling() {
7631 break;
7632 }
7633 }
7634 }
7635 result
7636 };
7637 let child = if let Some(&c) = non_field_children.first() {
7638 c
7639 } else {
7640 let mut fallback_cursor = node.walk();
7641 let mut fallback_child = None;
7642 if fallback_cursor.goto_first_child() {
7643 loop {
7644 if fallback_cursor.field_name().is_none()
7645 && !fallback_cursor.node().is_extra()
7646 {
7647 let candidate = fallback_cursor.node();
7648 #[allow(clippy::needless_question_mark)]
7649 if (|| -> ::core::result::Result<
7650 _,
7651 ::treesitter_types::ParseError,
7652 > {
7653 let child = candidate;
7654 Ok(
7655 <Pattern as ::treesitter_types::FromNode>::from_node(
7656 child,
7657 src,
7658 )?,
7659 )
7660 })()
7661 .is_ok()
7662 {
7663 fallback_child = Some(candidate);
7664 break;
7665 }
7666 }
7667 if !fallback_cursor.goto_next_sibling() {
7668 break;
7669 }
7670 }
7671 }
7672 if fallback_child.is_none() {
7673 let mut cursor2 = node.walk();
7674 if cursor2.goto_first_child() {
7675 loop {
7676 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7677 let candidate = cursor2.node();
7678 #[allow(clippy::needless_question_mark)]
7679 if (|| -> ::core::result::Result<
7680 _,
7681 ::treesitter_types::ParseError,
7682 > {
7683 let child = candidate;
7684 Ok(
7685 <Pattern as ::treesitter_types::FromNode>::from_node(
7686 child,
7687 src,
7688 )?,
7689 )
7690 })()
7691 .is_ok()
7692 {
7693 fallback_child = Some(candidate);
7694 break;
7695 }
7696 }
7697 if !cursor2.goto_next_sibling() {
7698 break;
7699 }
7700 }
7701 }
7702 }
7703 fallback_child.ok_or_else(|| {
7704 ::treesitter_types::ParseError::missing_field("children", node)
7705 })?
7706 };
7707 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
7708 },
7709 })
7710 }
7711}
7712impl ::treesitter_types::Spanned for NegatedPattern<'_> {
7713 fn span(&self) -> ::treesitter_types::Span {
7714 self.span
7715 }
7716}
7717#[derive(Debug, Clone, PartialEq, Eq)]
7718pub struct NullableType<'tree> {
7719 pub span: ::treesitter_types::Span,
7720 pub r#type: NullableTypeType<'tree>,
7721}
7722impl<'tree> ::treesitter_types::FromNode<'tree> for NullableType<'tree> {
7723 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7724 fn from_node(
7725 node: ::tree_sitter::Node<'tree>,
7726 src: &'tree [u8],
7727 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7728 debug_assert_eq!(node.kind(), "nullable_type");
7729 Ok(Self {
7730 span: ::treesitter_types::Span::from(node),
7731 r#type: {
7732 let child = node
7733 .child_by_field_name("type")
7734 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7735 <NullableTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
7736 },
7737 })
7738 }
7739}
7740impl ::treesitter_types::Spanned for NullableType<'_> {
7741 fn span(&self) -> ::treesitter_types::Span {
7742 self.span
7743 }
7744}
7745#[derive(Debug, Clone, PartialEq, Eq)]
7746pub struct ObjectCreationExpression<'tree> {
7747 pub span: ::treesitter_types::Span,
7748 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
7749 pub initializer: ::core::option::Option<InitializerExpression<'tree>>,
7750 pub r#type: Type<'tree>,
7751}
7752impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
7753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7754 fn from_node(
7755 node: ::tree_sitter::Node<'tree>,
7756 src: &'tree [u8],
7757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7758 debug_assert_eq!(node.kind(), "object_creation_expression");
7759 Ok(Self {
7760 span: ::treesitter_types::Span::from(node),
7761 arguments: match node.child_by_field_name("arguments") {
7762 Some(child) => Some(<ArgumentList as ::treesitter_types::FromNode>::from_node(
7763 child, src,
7764 )?),
7765 None => None,
7766 },
7767 initializer: match node.child_by_field_name("initializer") {
7768 Some(child) => Some(
7769 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)?,
7770 ),
7771 None => None,
7772 },
7773 r#type: {
7774 let child = node
7775 .child_by_field_name("type")
7776 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7777 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7778 },
7779 })
7780 }
7781}
7782impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
7783 fn span(&self) -> ::treesitter_types::Span {
7784 self.span
7785 }
7786}
7787#[derive(Debug, Clone, PartialEq, Eq)]
7788pub struct OperatorDeclaration<'tree> {
7789 pub span: ::treesitter_types::Span,
7790 pub body: ::core::option::Option<OperatorDeclarationBody<'tree>>,
7791 pub operator: OperatorDeclarationOperator,
7792 pub parameters: ParameterList<'tree>,
7793 pub r#type: Type<'tree>,
7794 pub children: ::std::vec::Vec<OperatorDeclarationChildren<'tree>>,
7795}
7796impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclaration<'tree> {
7797 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7798 fn from_node(
7799 node: ::tree_sitter::Node<'tree>,
7800 src: &'tree [u8],
7801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7802 debug_assert_eq!(node.kind(), "operator_declaration");
7803 Ok(Self {
7804 span: ::treesitter_types::Span::from(node),
7805 body: match node.child_by_field_name("body") {
7806 Some(child) => Some(
7807 <OperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(
7808 child, src,
7809 )?,
7810 ),
7811 None => None,
7812 },
7813 operator: {
7814 let child = node.child_by_field_name("operator").ok_or_else(|| {
7815 ::treesitter_types::ParseError::missing_field("operator", node)
7816 })?;
7817 <OperatorDeclarationOperator as ::treesitter_types::FromNode>::from_node(
7818 child, src,
7819 )?
7820 },
7821 parameters: {
7822 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7823 ::treesitter_types::ParseError::missing_field("parameters", node)
7824 })?;
7825 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
7826 },
7827 r#type: {
7828 let child = node
7829 .child_by_field_name("type")
7830 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7831 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7832 },
7833 children: {
7834 #[allow(clippy::suspicious_else_formatting)]
7835 let non_field_children = {
7836 let mut cursor = node.walk();
7837 let mut result = ::std::vec::Vec::new();
7838 if cursor.goto_first_child() {
7839 loop {
7840 if cursor.field_name().is_none()
7841 && cursor.node().is_named()
7842 && !cursor.node().is_extra()
7843 {
7844 result.push(cursor.node());
7845 }
7846 if !cursor.goto_next_sibling() {
7847 break;
7848 }
7849 }
7850 }
7851 result
7852 };
7853 let mut items = ::std::vec::Vec::new();
7854 for child in non_field_children {
7855 items.push(
7856 <OperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7857 child, src,
7858 )?,
7859 );
7860 }
7861 items
7862 },
7863 })
7864 }
7865}
7866impl ::treesitter_types::Spanned for OperatorDeclaration<'_> {
7867 fn span(&self) -> ::treesitter_types::Span {
7868 self.span
7869 }
7870}
7871#[derive(Debug, Clone, PartialEq, Eq)]
7872pub struct OrPattern<'tree> {
7873 pub span: ::treesitter_types::Span,
7874 pub left: Pattern<'tree>,
7875 pub operator: OrPatternOperator,
7876 pub right: Pattern<'tree>,
7877}
7878impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
7879 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7880 fn from_node(
7881 node: ::tree_sitter::Node<'tree>,
7882 src: &'tree [u8],
7883 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7884 debug_assert_eq!(node.kind(), "or_pattern");
7885 Ok(Self {
7886 span: ::treesitter_types::Span::from(node),
7887 left: {
7888 let child = node
7889 .child_by_field_name("left")
7890 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
7891 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
7892 },
7893 operator: {
7894 let child = node.child_by_field_name("operator").ok_or_else(|| {
7895 ::treesitter_types::ParseError::missing_field("operator", node)
7896 })?;
7897 <OrPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)?
7898 },
7899 right: {
7900 let child = node
7901 .child_by_field_name("right")
7902 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
7903 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
7904 },
7905 })
7906 }
7907}
7908impl ::treesitter_types::Spanned for OrPattern<'_> {
7909 fn span(&self) -> ::treesitter_types::Span {
7910 self.span
7911 }
7912}
7913#[derive(Debug, Clone, PartialEq, Eq)]
7914pub struct OrderByClause<'tree> {
7915 pub span: ::treesitter_types::Span,
7916 pub children: ::std::vec::Vec<Expression<'tree>>,
7917}
7918impl<'tree> ::treesitter_types::FromNode<'tree> for OrderByClause<'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(), "order_by_clause");
7925 Ok(Self {
7926 span: ::treesitter_types::Span::from(node),
7927 children: {
7928 #[allow(clippy::suspicious_else_formatting)]
7929 let non_field_children = {
7930 let mut cursor = node.walk();
7931 let mut result = ::std::vec::Vec::new();
7932 if cursor.goto_first_child() {
7933 loop {
7934 if cursor.field_name().is_none()
7935 && cursor.node().is_named()
7936 && !cursor.node().is_extra()
7937 {
7938 result.push(cursor.node());
7939 }
7940 if !cursor.goto_next_sibling() {
7941 break;
7942 }
7943 }
7944 }
7945 result
7946 };
7947 let mut items = ::std::vec::Vec::new();
7948 for child in non_field_children {
7949 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
7950 child, src,
7951 )?);
7952 }
7953 items
7954 },
7955 })
7956 }
7957}
7958impl ::treesitter_types::Spanned for OrderByClause<'_> {
7959 fn span(&self) -> ::treesitter_types::Span {
7960 self.span
7961 }
7962}
7963#[derive(Debug, Clone, PartialEq, Eq)]
7964pub struct Parameter<'tree> {
7965 pub span: ::treesitter_types::Span,
7966 pub name: Identifier<'tree>,
7967 pub r#type: ::core::option::Option<Type<'tree>>,
7968 pub children: ::std::vec::Vec<ParameterChildren<'tree>>,
7969}
7970impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
7971 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7972 fn from_node(
7973 node: ::tree_sitter::Node<'tree>,
7974 src: &'tree [u8],
7975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7976 debug_assert_eq!(node.kind(), "parameter");
7977 Ok(Self {
7978 span: ::treesitter_types::Span::from(node),
7979 name: {
7980 let child = node
7981 .child_by_field_name("name")
7982 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7983 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7984 },
7985 r#type: match node.child_by_field_name("type") {
7986 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
7987 child, src,
7988 )?),
7989 None => None,
7990 },
7991 children: {
7992 #[allow(clippy::suspicious_else_formatting)]
7993 let non_field_children = {
7994 let mut cursor = node.walk();
7995 let mut result = ::std::vec::Vec::new();
7996 if cursor.goto_first_child() {
7997 loop {
7998 if cursor.field_name().is_none()
7999 && cursor.node().is_named()
8000 && !cursor.node().is_extra()
8001 {
8002 result.push(cursor.node());
8003 }
8004 if !cursor.goto_next_sibling() {
8005 break;
8006 }
8007 }
8008 }
8009 result
8010 };
8011 let mut items = ::std::vec::Vec::new();
8012 for child in non_field_children {
8013 items.push(
8014 <ParameterChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8015 );
8016 }
8017 items
8018 },
8019 })
8020 }
8021}
8022impl ::treesitter_types::Spanned for Parameter<'_> {
8023 fn span(&self) -> ::treesitter_types::Span {
8024 self.span
8025 }
8026}
8027#[derive(Debug, Clone, PartialEq, Eq)]
8028pub struct ParameterList<'tree> {
8029 pub span: ::treesitter_types::Span,
8030 pub name: ::std::vec::Vec<Identifier<'tree>>,
8031 pub r#type: ::std::vec::Vec<ParameterListType<'tree>>,
8032 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
8033}
8034impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
8035 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8036 fn from_node(
8037 node: ::tree_sitter::Node<'tree>,
8038 src: &'tree [u8],
8039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8040 debug_assert_eq!(node.kind(), "parameter_list");
8041 Ok(Self {
8042 span: ::treesitter_types::Span::from(node),
8043 name: {
8044 let mut cursor = node.walk();
8045 let mut items = ::std::vec::Vec::new();
8046 for child in node.children_by_field_name("name", &mut cursor) {
8047 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
8048 child, src,
8049 )?);
8050 }
8051 items
8052 },
8053 r#type: {
8054 let mut cursor = node.walk();
8055 let mut items = ::std::vec::Vec::new();
8056 for child in node.children_by_field_name("type", &mut cursor) {
8057 items.push(
8058 <ParameterListType as ::treesitter_types::FromNode>::from_node(child, src)?,
8059 );
8060 }
8061 items
8062 },
8063 children: {
8064 #[allow(clippy::suspicious_else_formatting)]
8065 let non_field_children = {
8066 let mut cursor = node.walk();
8067 let mut result = ::std::vec::Vec::new();
8068 if cursor.goto_first_child() {
8069 loop {
8070 if cursor.field_name().is_none()
8071 && cursor.node().is_named()
8072 && !cursor.node().is_extra()
8073 {
8074 result.push(cursor.node());
8075 }
8076 if !cursor.goto_next_sibling() {
8077 break;
8078 }
8079 }
8080 }
8081 result
8082 };
8083 let mut items = ::std::vec::Vec::new();
8084 for child in non_field_children {
8085 items.push(
8086 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
8087 child, src,
8088 )?,
8089 );
8090 }
8091 items
8092 },
8093 })
8094 }
8095}
8096impl ::treesitter_types::Spanned for ParameterList<'_> {
8097 fn span(&self) -> ::treesitter_types::Span {
8098 self.span
8099 }
8100}
8101#[derive(Debug, Clone, PartialEq, Eq)]
8102pub struct ParenthesizedExpression<'tree> {
8103 pub span: ::treesitter_types::Span,
8104 pub children: ParenthesizedExpressionChildren<'tree>,
8105}
8106impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
8107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8108 fn from_node(
8109 node: ::tree_sitter::Node<'tree>,
8110 src: &'tree [u8],
8111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8112 debug_assert_eq!(node.kind(), "parenthesized_expression");
8113 Ok(Self {
8114 span: ::treesitter_types::Span::from(node),
8115 children: {
8116 #[allow(clippy::suspicious_else_formatting)]
8117 let non_field_children = {
8118 let mut cursor = node.walk();
8119 let mut result = ::std::vec::Vec::new();
8120 if cursor.goto_first_child() {
8121 loop {
8122 if cursor.field_name().is_none()
8123 && cursor.node().is_named()
8124 && !cursor.node().is_extra()
8125 {
8126 result.push(cursor.node());
8127 }
8128 if !cursor.goto_next_sibling() {
8129 break;
8130 }
8131 }
8132 }
8133 result
8134 };
8135 let child = if let Some(&c) = non_field_children.first() {
8136 c
8137 } else {
8138 let mut fallback_cursor = node.walk();
8139 let mut fallback_child = None;
8140 if fallback_cursor.goto_first_child() {
8141 loop {
8142 if fallback_cursor.field_name().is_none()
8143 && !fallback_cursor.node().is_extra()
8144 {
8145 let candidate = fallback_cursor.node();
8146 #[allow(clippy::needless_question_mark)]
8147 if (|| -> ::core::result::Result<
8148 _,
8149 ::treesitter_types::ParseError,
8150 > {
8151 let child = candidate;
8152 Ok(
8153 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8154 child,
8155 src,
8156 )?,
8157 )
8158 })()
8159 .is_ok()
8160 {
8161 fallback_child = Some(candidate);
8162 break;
8163 }
8164 }
8165 if !fallback_cursor.goto_next_sibling() {
8166 break;
8167 }
8168 }
8169 }
8170 if fallback_child.is_none() {
8171 let mut cursor2 = node.walk();
8172 if cursor2.goto_first_child() {
8173 loop {
8174 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8175 let candidate = cursor2.node();
8176 #[allow(clippy::needless_question_mark)]
8177 if (|| -> ::core::result::Result<
8178 _,
8179 ::treesitter_types::ParseError,
8180 > {
8181 let child = candidate;
8182 Ok(
8183 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8184 child,
8185 src,
8186 )?,
8187 )
8188 })()
8189 .is_ok()
8190 {
8191 fallback_child = Some(candidate);
8192 break;
8193 }
8194 }
8195 if !cursor2.goto_next_sibling() {
8196 break;
8197 }
8198 }
8199 }
8200 }
8201 fallback_child.ok_or_else(|| {
8202 ::treesitter_types::ParseError::missing_field("children", node)
8203 })?
8204 };
8205 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8206 child, src,
8207 )?
8208 },
8209 })
8210 }
8211}
8212impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
8213 fn span(&self) -> ::treesitter_types::Span {
8214 self.span
8215 }
8216}
8217#[derive(Debug, Clone, PartialEq, Eq)]
8218pub struct ParenthesizedPattern<'tree> {
8219 pub span: ::treesitter_types::Span,
8220 pub children: Pattern<'tree>,
8221}
8222impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedPattern<'tree> {
8223 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8224 fn from_node(
8225 node: ::tree_sitter::Node<'tree>,
8226 src: &'tree [u8],
8227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8228 debug_assert_eq!(node.kind(), "parenthesized_pattern");
8229 Ok(Self {
8230 span: ::treesitter_types::Span::from(node),
8231 children: {
8232 #[allow(clippy::suspicious_else_formatting)]
8233 let non_field_children = {
8234 let mut cursor = node.walk();
8235 let mut result = ::std::vec::Vec::new();
8236 if cursor.goto_first_child() {
8237 loop {
8238 if cursor.field_name().is_none()
8239 && cursor.node().is_named()
8240 && !cursor.node().is_extra()
8241 {
8242 result.push(cursor.node());
8243 }
8244 if !cursor.goto_next_sibling() {
8245 break;
8246 }
8247 }
8248 }
8249 result
8250 };
8251 let child = if let Some(&c) = non_field_children.first() {
8252 c
8253 } else {
8254 let mut fallback_cursor = node.walk();
8255 let mut fallback_child = None;
8256 if fallback_cursor.goto_first_child() {
8257 loop {
8258 if fallback_cursor.field_name().is_none()
8259 && !fallback_cursor.node().is_extra()
8260 {
8261 let candidate = fallback_cursor.node();
8262 #[allow(clippy::needless_question_mark)]
8263 if (|| -> ::core::result::Result<
8264 _,
8265 ::treesitter_types::ParseError,
8266 > {
8267 let child = candidate;
8268 Ok(
8269 <Pattern as ::treesitter_types::FromNode>::from_node(
8270 child,
8271 src,
8272 )?,
8273 )
8274 })()
8275 .is_ok()
8276 {
8277 fallback_child = Some(candidate);
8278 break;
8279 }
8280 }
8281 if !fallback_cursor.goto_next_sibling() {
8282 break;
8283 }
8284 }
8285 }
8286 if fallback_child.is_none() {
8287 let mut cursor2 = node.walk();
8288 if cursor2.goto_first_child() {
8289 loop {
8290 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8291 let candidate = cursor2.node();
8292 #[allow(clippy::needless_question_mark)]
8293 if (|| -> ::core::result::Result<
8294 _,
8295 ::treesitter_types::ParseError,
8296 > {
8297 let child = candidate;
8298 Ok(
8299 <Pattern as ::treesitter_types::FromNode>::from_node(
8300 child,
8301 src,
8302 )?,
8303 )
8304 })()
8305 .is_ok()
8306 {
8307 fallback_child = Some(candidate);
8308 break;
8309 }
8310 }
8311 if !cursor2.goto_next_sibling() {
8312 break;
8313 }
8314 }
8315 }
8316 }
8317 fallback_child.ok_or_else(|| {
8318 ::treesitter_types::ParseError::missing_field("children", node)
8319 })?
8320 };
8321 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
8322 },
8323 })
8324 }
8325}
8326impl ::treesitter_types::Spanned for ParenthesizedPattern<'_> {
8327 fn span(&self) -> ::treesitter_types::Span {
8328 self.span
8329 }
8330}
8331#[derive(Debug, Clone, PartialEq, Eq)]
8332pub struct ParenthesizedVariableDesignation<'tree> {
8333 pub span: ::treesitter_types::Span,
8334 pub name: ::std::vec::Vec<Identifier<'tree>>,
8335 pub children: ::std::vec::Vec<ParenthesizedVariableDesignationChildren<'tree>>,
8336}
8337impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedVariableDesignation<'tree> {
8338 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8339 fn from_node(
8340 node: ::tree_sitter::Node<'tree>,
8341 src: &'tree [u8],
8342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8343 debug_assert_eq!(node.kind(), "parenthesized_variable_designation");
8344 Ok(Self {
8345 span: ::treesitter_types::Span::from(node),
8346 name: {
8347 let mut cursor = node.walk();
8348 let mut items = ::std::vec::Vec::new();
8349 for child in node.children_by_field_name("name", &mut cursor) {
8350 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
8351 child, src,
8352 )?);
8353 }
8354 items
8355 },
8356 children: {
8357 #[allow(clippy::suspicious_else_formatting)]
8358 let non_field_children = {
8359 let mut cursor = node.walk();
8360 let mut result = ::std::vec::Vec::new();
8361 if cursor.goto_first_child() {
8362 loop {
8363 if cursor.field_name().is_none()
8364 && cursor.node().is_named()
8365 && !cursor.node().is_extra()
8366 {
8367 result.push(cursor.node());
8368 }
8369 if !cursor.goto_next_sibling() {
8370 break;
8371 }
8372 }
8373 }
8374 result
8375 };
8376 let mut items = ::std::vec::Vec::new();
8377 for child in non_field_children {
8378 items
8379 .push(
8380 <ParenthesizedVariableDesignationChildren as ::treesitter_types::FromNode>::from_node(
8381 child,
8382 src,
8383 )?,
8384 );
8385 }
8386 items
8387 },
8388 })
8389 }
8390}
8391impl ::treesitter_types::Spanned for ParenthesizedVariableDesignation<'_> {
8392 fn span(&self) -> ::treesitter_types::Span {
8393 self.span
8394 }
8395}
8396#[derive(Debug, Clone, PartialEq, Eq)]
8397pub struct PointerType<'tree> {
8398 pub span: ::treesitter_types::Span,
8399 pub r#type: PointerTypeType<'tree>,
8400}
8401impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
8402 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
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(), "pointer_type");
8408 Ok(Self {
8409 span: ::treesitter_types::Span::from(node),
8410 r#type: {
8411 let child = node
8412 .child_by_field_name("type")
8413 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8414 <PointerTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
8415 },
8416 })
8417 }
8418}
8419impl ::treesitter_types::Spanned for PointerType<'_> {
8420 fn span(&self) -> ::treesitter_types::Span {
8421 self.span
8422 }
8423}
8424#[derive(Debug, Clone, PartialEq, Eq)]
8425pub struct PositionalPatternClause<'tree> {
8426 pub span: ::treesitter_types::Span,
8427 pub children: ::std::vec::Vec<Subpattern<'tree>>,
8428}
8429impl<'tree> ::treesitter_types::FromNode<'tree> for PositionalPatternClause<'tree> {
8430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8431 fn from_node(
8432 node: ::tree_sitter::Node<'tree>,
8433 src: &'tree [u8],
8434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8435 debug_assert_eq!(node.kind(), "positional_pattern_clause");
8436 Ok(Self {
8437 span: ::treesitter_types::Span::from(node),
8438 children: {
8439 #[allow(clippy::suspicious_else_formatting)]
8440 let non_field_children = {
8441 let mut cursor = node.walk();
8442 let mut result = ::std::vec::Vec::new();
8443 if cursor.goto_first_child() {
8444 loop {
8445 if cursor.field_name().is_none()
8446 && cursor.node().is_named()
8447 && !cursor.node().is_extra()
8448 {
8449 result.push(cursor.node());
8450 }
8451 if !cursor.goto_next_sibling() {
8452 break;
8453 }
8454 }
8455 }
8456 result
8457 };
8458 let mut items = ::std::vec::Vec::new();
8459 for child in non_field_children {
8460 items.push(<Subpattern as ::treesitter_types::FromNode>::from_node(
8461 child, src,
8462 )?);
8463 }
8464 items
8465 },
8466 })
8467 }
8468}
8469impl ::treesitter_types::Spanned for PositionalPatternClause<'_> {
8470 fn span(&self) -> ::treesitter_types::Span {
8471 self.span
8472 }
8473}
8474#[derive(Debug, Clone, PartialEq, Eq)]
8475pub struct PostfixUnaryExpression<'tree> {
8476 pub span: ::treesitter_types::Span,
8477 pub children: Expression<'tree>,
8478}
8479impl<'tree> ::treesitter_types::FromNode<'tree> for PostfixUnaryExpression<'tree> {
8480 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8481 fn from_node(
8482 node: ::tree_sitter::Node<'tree>,
8483 src: &'tree [u8],
8484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8485 debug_assert_eq!(node.kind(), "postfix_unary_expression");
8486 Ok(Self {
8487 span: ::treesitter_types::Span::from(node),
8488 children: {
8489 #[allow(clippy::suspicious_else_formatting)]
8490 let non_field_children = {
8491 let mut cursor = node.walk();
8492 let mut result = ::std::vec::Vec::new();
8493 if cursor.goto_first_child() {
8494 loop {
8495 if cursor.field_name().is_none()
8496 && cursor.node().is_named()
8497 && !cursor.node().is_extra()
8498 {
8499 result.push(cursor.node());
8500 }
8501 if !cursor.goto_next_sibling() {
8502 break;
8503 }
8504 }
8505 }
8506 result
8507 };
8508 let child = if let Some(&c) = non_field_children.first() {
8509 c
8510 } else {
8511 let mut fallback_cursor = node.walk();
8512 let mut fallback_child = None;
8513 if fallback_cursor.goto_first_child() {
8514 loop {
8515 if fallback_cursor.field_name().is_none()
8516 && !fallback_cursor.node().is_extra()
8517 {
8518 let candidate = fallback_cursor.node();
8519 #[allow(clippy::needless_question_mark)]
8520 if (|| -> ::core::result::Result<
8521 _,
8522 ::treesitter_types::ParseError,
8523 > {
8524 let child = candidate;
8525 Ok(
8526 <Expression as ::treesitter_types::FromNode>::from_node(
8527 child,
8528 src,
8529 )?,
8530 )
8531 })()
8532 .is_ok()
8533 {
8534 fallback_child = Some(candidate);
8535 break;
8536 }
8537 }
8538 if !fallback_cursor.goto_next_sibling() {
8539 break;
8540 }
8541 }
8542 }
8543 if fallback_child.is_none() {
8544 let mut cursor2 = node.walk();
8545 if cursor2.goto_first_child() {
8546 loop {
8547 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8548 let candidate = cursor2.node();
8549 #[allow(clippy::needless_question_mark)]
8550 if (|| -> ::core::result::Result<
8551 _,
8552 ::treesitter_types::ParseError,
8553 > {
8554 let child = candidate;
8555 Ok(
8556 <Expression as ::treesitter_types::FromNode>::from_node(
8557 child,
8558 src,
8559 )?,
8560 )
8561 })()
8562 .is_ok()
8563 {
8564 fallback_child = Some(candidate);
8565 break;
8566 }
8567 }
8568 if !cursor2.goto_next_sibling() {
8569 break;
8570 }
8571 }
8572 }
8573 }
8574 fallback_child.ok_or_else(|| {
8575 ::treesitter_types::ParseError::missing_field("children", node)
8576 })?
8577 };
8578 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8579 },
8580 })
8581 }
8582}
8583impl ::treesitter_types::Spanned for PostfixUnaryExpression<'_> {
8584 fn span(&self) -> ::treesitter_types::Span {
8585 self.span
8586 }
8587}
8588#[derive(Debug, Clone, PartialEq, Eq)]
8589pub struct PrefixUnaryExpression<'tree> {
8590 pub span: ::treesitter_types::Span,
8591 pub children: Expression<'tree>,
8592}
8593impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnaryExpression<'tree> {
8594 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8595 fn from_node(
8596 node: ::tree_sitter::Node<'tree>,
8597 src: &'tree [u8],
8598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8599 debug_assert_eq!(node.kind(), "prefix_unary_expression");
8600 Ok(Self {
8601 span: ::treesitter_types::Span::from(node),
8602 children: {
8603 #[allow(clippy::suspicious_else_formatting)]
8604 let non_field_children = {
8605 let mut cursor = node.walk();
8606 let mut result = ::std::vec::Vec::new();
8607 if cursor.goto_first_child() {
8608 loop {
8609 if cursor.field_name().is_none()
8610 && cursor.node().is_named()
8611 && !cursor.node().is_extra()
8612 {
8613 result.push(cursor.node());
8614 }
8615 if !cursor.goto_next_sibling() {
8616 break;
8617 }
8618 }
8619 }
8620 result
8621 };
8622 let child = if let Some(&c) = non_field_children.first() {
8623 c
8624 } else {
8625 let mut fallback_cursor = node.walk();
8626 let mut fallback_child = None;
8627 if fallback_cursor.goto_first_child() {
8628 loop {
8629 if fallback_cursor.field_name().is_none()
8630 && !fallback_cursor.node().is_extra()
8631 {
8632 let candidate = fallback_cursor.node();
8633 #[allow(clippy::needless_question_mark)]
8634 if (|| -> ::core::result::Result<
8635 _,
8636 ::treesitter_types::ParseError,
8637 > {
8638 let child = candidate;
8639 Ok(
8640 <Expression as ::treesitter_types::FromNode>::from_node(
8641 child,
8642 src,
8643 )?,
8644 )
8645 })()
8646 .is_ok()
8647 {
8648 fallback_child = Some(candidate);
8649 break;
8650 }
8651 }
8652 if !fallback_cursor.goto_next_sibling() {
8653 break;
8654 }
8655 }
8656 }
8657 if fallback_child.is_none() {
8658 let mut cursor2 = node.walk();
8659 if cursor2.goto_first_child() {
8660 loop {
8661 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8662 let candidate = cursor2.node();
8663 #[allow(clippy::needless_question_mark)]
8664 if (|| -> ::core::result::Result<
8665 _,
8666 ::treesitter_types::ParseError,
8667 > {
8668 let child = candidate;
8669 Ok(
8670 <Expression as ::treesitter_types::FromNode>::from_node(
8671 child,
8672 src,
8673 )?,
8674 )
8675 })()
8676 .is_ok()
8677 {
8678 fallback_child = Some(candidate);
8679 break;
8680 }
8681 }
8682 if !cursor2.goto_next_sibling() {
8683 break;
8684 }
8685 }
8686 }
8687 }
8688 fallback_child.ok_or_else(|| {
8689 ::treesitter_types::ParseError::missing_field("children", node)
8690 })?
8691 };
8692 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8693 },
8694 })
8695 }
8696}
8697impl ::treesitter_types::Spanned for PrefixUnaryExpression<'_> {
8698 fn span(&self) -> ::treesitter_types::Span {
8699 self.span
8700 }
8701}
8702#[derive(Debug, Clone, PartialEq, Eq)]
8703pub struct PreprocDefine<'tree> {
8704 pub span: ::treesitter_types::Span,
8705 pub children: PreprocArg<'tree>,
8706}
8707impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefine<'tree> {
8708 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8709 fn from_node(
8710 node: ::tree_sitter::Node<'tree>,
8711 src: &'tree [u8],
8712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8713 debug_assert_eq!(node.kind(), "preproc_define");
8714 Ok(Self {
8715 span: ::treesitter_types::Span::from(node),
8716 children: {
8717 #[allow(clippy::suspicious_else_formatting)]
8718 let non_field_children = {
8719 let mut cursor = node.walk();
8720 let mut result = ::std::vec::Vec::new();
8721 if cursor.goto_first_child() {
8722 loop {
8723 if cursor.field_name().is_none()
8724 && cursor.node().is_named()
8725 && !cursor.node().is_extra()
8726 {
8727 result.push(cursor.node());
8728 }
8729 if !cursor.goto_next_sibling() {
8730 break;
8731 }
8732 }
8733 }
8734 result
8735 };
8736 let child = if let Some(&c) = non_field_children.first() {
8737 c
8738 } else {
8739 let mut fallback_cursor = node.walk();
8740 let mut fallback_child = None;
8741 if fallback_cursor.goto_first_child() {
8742 loop {
8743 if fallback_cursor.field_name().is_none()
8744 && !fallback_cursor.node().is_extra()
8745 {
8746 let candidate = fallback_cursor.node();
8747 #[allow(clippy::needless_question_mark)]
8748 if (|| -> ::core::result::Result<
8749 _,
8750 ::treesitter_types::ParseError,
8751 > {
8752 let child = candidate;
8753 Ok(
8754 <PreprocArg as ::treesitter_types::FromNode>::from_node(
8755 child,
8756 src,
8757 )?,
8758 )
8759 })()
8760 .is_ok()
8761 {
8762 fallback_child = Some(candidate);
8763 break;
8764 }
8765 }
8766 if !fallback_cursor.goto_next_sibling() {
8767 break;
8768 }
8769 }
8770 }
8771 if fallback_child.is_none() {
8772 let mut cursor2 = node.walk();
8773 if cursor2.goto_first_child() {
8774 loop {
8775 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8776 let candidate = cursor2.node();
8777 #[allow(clippy::needless_question_mark)]
8778 if (|| -> ::core::result::Result<
8779 _,
8780 ::treesitter_types::ParseError,
8781 > {
8782 let child = candidate;
8783 Ok(
8784 <PreprocArg as ::treesitter_types::FromNode>::from_node(
8785 child,
8786 src,
8787 )?,
8788 )
8789 })()
8790 .is_ok()
8791 {
8792 fallback_child = Some(candidate);
8793 break;
8794 }
8795 }
8796 if !cursor2.goto_next_sibling() {
8797 break;
8798 }
8799 }
8800 }
8801 }
8802 fallback_child.ok_or_else(|| {
8803 ::treesitter_types::ParseError::missing_field("children", node)
8804 })?
8805 };
8806 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)?
8807 },
8808 })
8809 }
8810}
8811impl ::treesitter_types::Spanned for PreprocDefine<'_> {
8812 fn span(&self) -> ::treesitter_types::Span {
8813 self.span
8814 }
8815}
8816#[derive(Debug, Clone, PartialEq, Eq)]
8817pub struct PreprocElif<'tree> {
8818 pub span: ::treesitter_types::Span,
8819 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
8820 pub condition: PreprocElifCondition<'tree>,
8821 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
8822}
8823impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
8824 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8825 fn from_node(
8826 node: ::tree_sitter::Node<'tree>,
8827 src: &'tree [u8],
8828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8829 debug_assert_eq!(node.kind(), "preproc_elif");
8830 Ok(Self {
8831 span: ::treesitter_types::Span::from(node),
8832 alternative: match node.child_by_field_name("alternative") {
8833 Some(child) => Some(
8834 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(
8835 child, src,
8836 )?,
8837 ),
8838 None => None,
8839 },
8840 condition: {
8841 let child = node.child_by_field_name("condition").ok_or_else(|| {
8842 ::treesitter_types::ParseError::missing_field("condition", node)
8843 })?;
8844 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)?
8845 },
8846 children: {
8847 #[allow(clippy::suspicious_else_formatting)]
8848 let non_field_children = {
8849 let mut cursor = node.walk();
8850 let mut result = ::std::vec::Vec::new();
8851 if cursor.goto_first_child() {
8852 loop {
8853 if cursor.field_name().is_none()
8854 && cursor.node().is_named()
8855 && !cursor.node().is_extra()
8856 {
8857 result.push(cursor.node());
8858 }
8859 if !cursor.goto_next_sibling() {
8860 break;
8861 }
8862 }
8863 }
8864 result
8865 };
8866 let mut items = ::std::vec::Vec::new();
8867 for child in non_field_children {
8868 items.push(
8869 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(
8870 child, src,
8871 )?,
8872 );
8873 }
8874 items
8875 },
8876 })
8877 }
8878}
8879impl ::treesitter_types::Spanned for PreprocElif<'_> {
8880 fn span(&self) -> ::treesitter_types::Span {
8881 self.span
8882 }
8883}
8884#[derive(Debug, Clone, PartialEq, Eq)]
8885pub struct PreprocElse<'tree> {
8886 pub span: ::treesitter_types::Span,
8887 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
8888}
8889impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
8890 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8891 fn from_node(
8892 node: ::tree_sitter::Node<'tree>,
8893 src: &'tree [u8],
8894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8895 debug_assert_eq!(node.kind(), "preproc_else");
8896 Ok(Self {
8897 span: ::treesitter_types::Span::from(node),
8898 children: {
8899 #[allow(clippy::suspicious_else_formatting)]
8900 let non_field_children = {
8901 let mut cursor = node.walk();
8902 let mut result = ::std::vec::Vec::new();
8903 if cursor.goto_first_child() {
8904 loop {
8905 if cursor.field_name().is_none()
8906 && cursor.node().is_named()
8907 && !cursor.node().is_extra()
8908 {
8909 result.push(cursor.node());
8910 }
8911 if !cursor.goto_next_sibling() {
8912 break;
8913 }
8914 }
8915 }
8916 result
8917 };
8918 let mut items = ::std::vec::Vec::new();
8919 for child in non_field_children {
8920 items.push(
8921 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(
8922 child, src,
8923 )?,
8924 );
8925 }
8926 items
8927 },
8928 })
8929 }
8930}
8931impl ::treesitter_types::Spanned for PreprocElse<'_> {
8932 fn span(&self) -> ::treesitter_types::Span {
8933 self.span
8934 }
8935}
8936#[derive(Debug, Clone, PartialEq, Eq)]
8937pub struct PreprocEndregion<'tree> {
8938 pub span: ::treesitter_types::Span,
8939 pub content: ::core::option::Option<PreprocArg<'tree>>,
8940}
8941impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocEndregion<'tree> {
8942 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8943 fn from_node(
8944 node: ::tree_sitter::Node<'tree>,
8945 src: &'tree [u8],
8946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8947 debug_assert_eq!(node.kind(), "preproc_endregion");
8948 Ok(Self {
8949 span: ::treesitter_types::Span::from(node),
8950 content: match node.child_by_field_name("content") {
8951 Some(child) => Some(<PreprocArg as ::treesitter_types::FromNode>::from_node(
8952 child, src,
8953 )?),
8954 None => None,
8955 },
8956 })
8957 }
8958}
8959impl ::treesitter_types::Spanned for PreprocEndregion<'_> {
8960 fn span(&self) -> ::treesitter_types::Span {
8961 self.span
8962 }
8963}
8964#[derive(Debug, Clone, PartialEq, Eq)]
8965pub struct PreprocError<'tree> {
8966 pub span: ::treesitter_types::Span,
8967 pub children: PreprocArg<'tree>,
8968}
8969impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocError<'tree> {
8970 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8971 fn from_node(
8972 node: ::tree_sitter::Node<'tree>,
8973 src: &'tree [u8],
8974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8975 debug_assert_eq!(node.kind(), "preproc_error");
8976 Ok(Self {
8977 span: ::treesitter_types::Span::from(node),
8978 children: {
8979 #[allow(clippy::suspicious_else_formatting)]
8980 let non_field_children = {
8981 let mut cursor = node.walk();
8982 let mut result = ::std::vec::Vec::new();
8983 if cursor.goto_first_child() {
8984 loop {
8985 if cursor.field_name().is_none()
8986 && cursor.node().is_named()
8987 && !cursor.node().is_extra()
8988 {
8989 result.push(cursor.node());
8990 }
8991 if !cursor.goto_next_sibling() {
8992 break;
8993 }
8994 }
8995 }
8996 result
8997 };
8998 let child = if let Some(&c) = non_field_children.first() {
8999 c
9000 } else {
9001 let mut fallback_cursor = node.walk();
9002 let mut fallback_child = None;
9003 if fallback_cursor.goto_first_child() {
9004 loop {
9005 if fallback_cursor.field_name().is_none()
9006 && !fallback_cursor.node().is_extra()
9007 {
9008 let candidate = fallback_cursor.node();
9009 #[allow(clippy::needless_question_mark)]
9010 if (|| -> ::core::result::Result<
9011 _,
9012 ::treesitter_types::ParseError,
9013 > {
9014 let child = candidate;
9015 Ok(
9016 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9017 child,
9018 src,
9019 )?,
9020 )
9021 })()
9022 .is_ok()
9023 {
9024 fallback_child = Some(candidate);
9025 break;
9026 }
9027 }
9028 if !fallback_cursor.goto_next_sibling() {
9029 break;
9030 }
9031 }
9032 }
9033 if fallback_child.is_none() {
9034 let mut cursor2 = node.walk();
9035 if cursor2.goto_first_child() {
9036 loop {
9037 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9038 let candidate = cursor2.node();
9039 #[allow(clippy::needless_question_mark)]
9040 if (|| -> ::core::result::Result<
9041 _,
9042 ::treesitter_types::ParseError,
9043 > {
9044 let child = candidate;
9045 Ok(
9046 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9047 child,
9048 src,
9049 )?,
9050 )
9051 })()
9052 .is_ok()
9053 {
9054 fallback_child = Some(candidate);
9055 break;
9056 }
9057 }
9058 if !cursor2.goto_next_sibling() {
9059 break;
9060 }
9061 }
9062 }
9063 }
9064 fallback_child.ok_or_else(|| {
9065 ::treesitter_types::ParseError::missing_field("children", node)
9066 })?
9067 };
9068 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)?
9069 },
9070 })
9071 }
9072}
9073impl ::treesitter_types::Spanned for PreprocError<'_> {
9074 fn span(&self) -> ::treesitter_types::Span {
9075 self.span
9076 }
9077}
9078#[derive(Debug, Clone, PartialEq, Eq)]
9079pub struct PreprocIf<'tree> {
9080 pub span: ::treesitter_types::Span,
9081 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
9082 pub condition: PreprocIfCondition<'tree>,
9083 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
9084}
9085impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
9086 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9087 fn from_node(
9088 node: ::tree_sitter::Node<'tree>,
9089 src: &'tree [u8],
9090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9091 debug_assert_eq!(node.kind(), "preproc_if");
9092 Ok(Self {
9093 span: ::treesitter_types::Span::from(node),
9094 alternative: match node.child_by_field_name("alternative") {
9095 Some(child) => Some(
9096 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)?,
9097 ),
9098 None => None,
9099 },
9100 condition: {
9101 let child = node.child_by_field_name("condition").ok_or_else(|| {
9102 ::treesitter_types::ParseError::missing_field("condition", node)
9103 })?;
9104 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)?
9105 },
9106 children: {
9107 #[allow(clippy::suspicious_else_formatting)]
9108 let non_field_children = {
9109 let mut cursor = node.walk();
9110 let mut result = ::std::vec::Vec::new();
9111 if cursor.goto_first_child() {
9112 loop {
9113 if cursor.field_name().is_none()
9114 && cursor.node().is_named()
9115 && !cursor.node().is_extra()
9116 {
9117 result.push(cursor.node());
9118 }
9119 if !cursor.goto_next_sibling() {
9120 break;
9121 }
9122 }
9123 }
9124 result
9125 };
9126 let mut items = ::std::vec::Vec::new();
9127 for child in non_field_children {
9128 items.push(
9129 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
9130 );
9131 }
9132 items
9133 },
9134 })
9135 }
9136}
9137impl ::treesitter_types::Spanned for PreprocIf<'_> {
9138 fn span(&self) -> ::treesitter_types::Span {
9139 self.span
9140 }
9141}
9142#[derive(Debug, Clone, PartialEq, Eq)]
9143pub struct PreprocLine<'tree> {
9144 pub span: ::treesitter_types::Span,
9145 pub children: ::std::vec::Vec<PreprocLineChildren<'tree>>,
9146}
9147impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLine<'tree> {
9148 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9149 fn from_node(
9150 node: ::tree_sitter::Node<'tree>,
9151 src: &'tree [u8],
9152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9153 debug_assert_eq!(node.kind(), "preproc_line");
9154 Ok(Self {
9155 span: ::treesitter_types::Span::from(node),
9156 children: {
9157 #[allow(clippy::suspicious_else_formatting)]
9158 let non_field_children = {
9159 let mut cursor = node.walk();
9160 let mut result = ::std::vec::Vec::new();
9161 if cursor.goto_first_child() {
9162 loop {
9163 if cursor.field_name().is_none()
9164 && cursor.node().is_named()
9165 && !cursor.node().is_extra()
9166 {
9167 result.push(cursor.node());
9168 }
9169 if !cursor.goto_next_sibling() {
9170 break;
9171 }
9172 }
9173 }
9174 result
9175 };
9176 let mut items = ::std::vec::Vec::new();
9177 for child in non_field_children {
9178 items.push(
9179 <PreprocLineChildren as ::treesitter_types::FromNode>::from_node(
9180 child, src,
9181 )?,
9182 );
9183 }
9184 items
9185 },
9186 })
9187 }
9188}
9189impl ::treesitter_types::Spanned for PreprocLine<'_> {
9190 fn span(&self) -> ::treesitter_types::Span {
9191 self.span
9192 }
9193}
9194#[derive(Debug, Clone, PartialEq, Eq)]
9195pub struct PreprocNullable<'tree> {
9196 pub span: ::treesitter_types::Span,
9197 text: &'tree str,
9198}
9199impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocNullable<'tree> {
9200 fn from_node(
9201 node: ::tree_sitter::Node<'tree>,
9202 src: &'tree [u8],
9203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9204 debug_assert_eq!(node.kind(), "preproc_nullable");
9205 Ok(Self {
9206 span: ::treesitter_types::Span::from(node),
9207 text: node.utf8_text(src)?,
9208 })
9209 }
9210}
9211impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocNullable<'tree> {
9212 fn text(&self) -> &'tree str {
9213 self.text
9214 }
9215}
9216impl ::treesitter_types::Spanned for PreprocNullable<'_> {
9217 fn span(&self) -> ::treesitter_types::Span {
9218 self.span
9219 }
9220}
9221#[derive(Debug, Clone, PartialEq, Eq)]
9222pub struct PreprocPragma<'tree> {
9223 pub span: ::treesitter_types::Span,
9224 pub children: ::std::vec::Vec<PreprocPragmaChildren<'tree>>,
9225}
9226impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragma<'tree> {
9227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9228 fn from_node(
9229 node: ::tree_sitter::Node<'tree>,
9230 src: &'tree [u8],
9231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9232 debug_assert_eq!(node.kind(), "preproc_pragma");
9233 Ok(Self {
9234 span: ::treesitter_types::Span::from(node),
9235 children: {
9236 #[allow(clippy::suspicious_else_formatting)]
9237 let non_field_children = {
9238 let mut cursor = node.walk();
9239 let mut result = ::std::vec::Vec::new();
9240 if cursor.goto_first_child() {
9241 loop {
9242 if cursor.field_name().is_none()
9243 && cursor.node().is_named()
9244 && !cursor.node().is_extra()
9245 {
9246 result.push(cursor.node());
9247 }
9248 if !cursor.goto_next_sibling() {
9249 break;
9250 }
9251 }
9252 }
9253 result
9254 };
9255 let mut items = ::std::vec::Vec::new();
9256 for child in non_field_children {
9257 items.push(
9258 <PreprocPragmaChildren as ::treesitter_types::FromNode>::from_node(
9259 child, src,
9260 )?,
9261 );
9262 }
9263 items
9264 },
9265 })
9266 }
9267}
9268impl ::treesitter_types::Spanned for PreprocPragma<'_> {
9269 fn span(&self) -> ::treesitter_types::Span {
9270 self.span
9271 }
9272}
9273#[derive(Debug, Clone, PartialEq, Eq)]
9274pub struct PreprocRegion<'tree> {
9275 pub span: ::treesitter_types::Span,
9276 pub content: ::core::option::Option<PreprocArg<'tree>>,
9277}
9278impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocRegion<'tree> {
9279 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9280 fn from_node(
9281 node: ::tree_sitter::Node<'tree>,
9282 src: &'tree [u8],
9283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9284 debug_assert_eq!(node.kind(), "preproc_region");
9285 Ok(Self {
9286 span: ::treesitter_types::Span::from(node),
9287 content: match node.child_by_field_name("content") {
9288 Some(child) => Some(<PreprocArg as ::treesitter_types::FromNode>::from_node(
9289 child, src,
9290 )?),
9291 None => None,
9292 },
9293 })
9294 }
9295}
9296impl ::treesitter_types::Spanned for PreprocRegion<'_> {
9297 fn span(&self) -> ::treesitter_types::Span {
9298 self.span
9299 }
9300}
9301#[derive(Debug, Clone, PartialEq, Eq)]
9302pub struct PreprocUndef<'tree> {
9303 pub span: ::treesitter_types::Span,
9304 pub children: PreprocArg<'tree>,
9305}
9306impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocUndef<'tree> {
9307 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9308 fn from_node(
9309 node: ::tree_sitter::Node<'tree>,
9310 src: &'tree [u8],
9311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9312 debug_assert_eq!(node.kind(), "preproc_undef");
9313 Ok(Self {
9314 span: ::treesitter_types::Span::from(node),
9315 children: {
9316 #[allow(clippy::suspicious_else_formatting)]
9317 let non_field_children = {
9318 let mut cursor = node.walk();
9319 let mut result = ::std::vec::Vec::new();
9320 if cursor.goto_first_child() {
9321 loop {
9322 if cursor.field_name().is_none()
9323 && cursor.node().is_named()
9324 && !cursor.node().is_extra()
9325 {
9326 result.push(cursor.node());
9327 }
9328 if !cursor.goto_next_sibling() {
9329 break;
9330 }
9331 }
9332 }
9333 result
9334 };
9335 let child = if let Some(&c) = non_field_children.first() {
9336 c
9337 } else {
9338 let mut fallback_cursor = node.walk();
9339 let mut fallback_child = None;
9340 if fallback_cursor.goto_first_child() {
9341 loop {
9342 if fallback_cursor.field_name().is_none()
9343 && !fallback_cursor.node().is_extra()
9344 {
9345 let candidate = fallback_cursor.node();
9346 #[allow(clippy::needless_question_mark)]
9347 if (|| -> ::core::result::Result<
9348 _,
9349 ::treesitter_types::ParseError,
9350 > {
9351 let child = candidate;
9352 Ok(
9353 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9354 child,
9355 src,
9356 )?,
9357 )
9358 })()
9359 .is_ok()
9360 {
9361 fallback_child = Some(candidate);
9362 break;
9363 }
9364 }
9365 if !fallback_cursor.goto_next_sibling() {
9366 break;
9367 }
9368 }
9369 }
9370 if fallback_child.is_none() {
9371 let mut cursor2 = node.walk();
9372 if cursor2.goto_first_child() {
9373 loop {
9374 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9375 let candidate = cursor2.node();
9376 #[allow(clippy::needless_question_mark)]
9377 if (|| -> ::core::result::Result<
9378 _,
9379 ::treesitter_types::ParseError,
9380 > {
9381 let child = candidate;
9382 Ok(
9383 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9384 child,
9385 src,
9386 )?,
9387 )
9388 })()
9389 .is_ok()
9390 {
9391 fallback_child = Some(candidate);
9392 break;
9393 }
9394 }
9395 if !cursor2.goto_next_sibling() {
9396 break;
9397 }
9398 }
9399 }
9400 }
9401 fallback_child.ok_or_else(|| {
9402 ::treesitter_types::ParseError::missing_field("children", node)
9403 })?
9404 };
9405 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)?
9406 },
9407 })
9408 }
9409}
9410impl ::treesitter_types::Spanned for PreprocUndef<'_> {
9411 fn span(&self) -> ::treesitter_types::Span {
9412 self.span
9413 }
9414}
9415#[derive(Debug, Clone, PartialEq, Eq)]
9416pub struct PreprocWarning<'tree> {
9417 pub span: ::treesitter_types::Span,
9418 pub children: PreprocArg<'tree>,
9419}
9420impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocWarning<'tree> {
9421 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9422 fn from_node(
9423 node: ::tree_sitter::Node<'tree>,
9424 src: &'tree [u8],
9425 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9426 debug_assert_eq!(node.kind(), "preproc_warning");
9427 Ok(Self {
9428 span: ::treesitter_types::Span::from(node),
9429 children: {
9430 #[allow(clippy::suspicious_else_formatting)]
9431 let non_field_children = {
9432 let mut cursor = node.walk();
9433 let mut result = ::std::vec::Vec::new();
9434 if cursor.goto_first_child() {
9435 loop {
9436 if cursor.field_name().is_none()
9437 && cursor.node().is_named()
9438 && !cursor.node().is_extra()
9439 {
9440 result.push(cursor.node());
9441 }
9442 if !cursor.goto_next_sibling() {
9443 break;
9444 }
9445 }
9446 }
9447 result
9448 };
9449 let child = if let Some(&c) = non_field_children.first() {
9450 c
9451 } else {
9452 let mut fallback_cursor = node.walk();
9453 let mut fallback_child = None;
9454 if fallback_cursor.goto_first_child() {
9455 loop {
9456 if fallback_cursor.field_name().is_none()
9457 && !fallback_cursor.node().is_extra()
9458 {
9459 let candidate = fallback_cursor.node();
9460 #[allow(clippy::needless_question_mark)]
9461 if (|| -> ::core::result::Result<
9462 _,
9463 ::treesitter_types::ParseError,
9464 > {
9465 let child = candidate;
9466 Ok(
9467 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9468 child,
9469 src,
9470 )?,
9471 )
9472 })()
9473 .is_ok()
9474 {
9475 fallback_child = Some(candidate);
9476 break;
9477 }
9478 }
9479 if !fallback_cursor.goto_next_sibling() {
9480 break;
9481 }
9482 }
9483 }
9484 if fallback_child.is_none() {
9485 let mut cursor2 = node.walk();
9486 if cursor2.goto_first_child() {
9487 loop {
9488 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9489 let candidate = cursor2.node();
9490 #[allow(clippy::needless_question_mark)]
9491 if (|| -> ::core::result::Result<
9492 _,
9493 ::treesitter_types::ParseError,
9494 > {
9495 let child = candidate;
9496 Ok(
9497 <PreprocArg as ::treesitter_types::FromNode>::from_node(
9498 child,
9499 src,
9500 )?,
9501 )
9502 })()
9503 .is_ok()
9504 {
9505 fallback_child = Some(candidate);
9506 break;
9507 }
9508 }
9509 if !cursor2.goto_next_sibling() {
9510 break;
9511 }
9512 }
9513 }
9514 }
9515 fallback_child.ok_or_else(|| {
9516 ::treesitter_types::ParseError::missing_field("children", node)
9517 })?
9518 };
9519 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)?
9520 },
9521 })
9522 }
9523}
9524impl ::treesitter_types::Spanned for PreprocWarning<'_> {
9525 fn span(&self) -> ::treesitter_types::Span {
9526 self.span
9527 }
9528}
9529#[derive(Debug, Clone, PartialEq, Eq)]
9530pub struct PrimaryConstructorBaseType<'tree> {
9531 pub span: ::treesitter_types::Span,
9532 pub r#type: PrimaryConstructorBaseTypeType<'tree>,
9533 pub children: ArgumentList<'tree>,
9534}
9535impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseType<'tree> {
9536 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9537 fn from_node(
9538 node: ::tree_sitter::Node<'tree>,
9539 src: &'tree [u8],
9540 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9541 debug_assert_eq!(node.kind(), "primary_constructor_base_type");
9542 Ok(Self {
9543 span: ::treesitter_types::Span::from(node),
9544 r#type: {
9545 let child = node
9546 .child_by_field_name("type")
9547 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9548 <PrimaryConstructorBaseTypeType as ::treesitter_types::FromNode>::from_node(
9549 child, src,
9550 )?
9551 },
9552 children: {
9553 #[allow(clippy::suspicious_else_formatting)]
9554 let non_field_children = {
9555 let mut cursor = node.walk();
9556 let mut result = ::std::vec::Vec::new();
9557 if cursor.goto_first_child() {
9558 loop {
9559 if cursor.field_name().is_none()
9560 && cursor.node().is_named()
9561 && !cursor.node().is_extra()
9562 {
9563 result.push(cursor.node());
9564 }
9565 if !cursor.goto_next_sibling() {
9566 break;
9567 }
9568 }
9569 }
9570 result
9571 };
9572 let child = if let Some(&c) = non_field_children.first() {
9573 c
9574 } else {
9575 let mut fallback_cursor = node.walk();
9576 let mut fallback_child = None;
9577 if fallback_cursor.goto_first_child() {
9578 loop {
9579 if fallback_cursor.field_name().is_none()
9580 && !fallback_cursor.node().is_extra()
9581 {
9582 let candidate = fallback_cursor.node();
9583 #[allow(clippy::needless_question_mark)]
9584 if (|| -> ::core::result::Result<
9585 _,
9586 ::treesitter_types::ParseError,
9587 > {
9588 let child = candidate;
9589 Ok(
9590 <ArgumentList as ::treesitter_types::FromNode>::from_node(
9591 child,
9592 src,
9593 )?,
9594 )
9595 })()
9596 .is_ok()
9597 {
9598 fallback_child = Some(candidate);
9599 break;
9600 }
9601 }
9602 if !fallback_cursor.goto_next_sibling() {
9603 break;
9604 }
9605 }
9606 }
9607 if fallback_child.is_none() {
9608 let mut cursor2 = node.walk();
9609 if cursor2.goto_first_child() {
9610 loop {
9611 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9612 let candidate = cursor2.node();
9613 #[allow(clippy::needless_question_mark)]
9614 if (|| -> ::core::result::Result<
9615 _,
9616 ::treesitter_types::ParseError,
9617 > {
9618 let child = candidate;
9619 Ok(
9620 <ArgumentList as ::treesitter_types::FromNode>::from_node(
9621 child,
9622 src,
9623 )?,
9624 )
9625 })()
9626 .is_ok()
9627 {
9628 fallback_child = Some(candidate);
9629 break;
9630 }
9631 }
9632 if !cursor2.goto_next_sibling() {
9633 break;
9634 }
9635 }
9636 }
9637 }
9638 fallback_child.ok_or_else(|| {
9639 ::treesitter_types::ParseError::missing_field("children", node)
9640 })?
9641 };
9642 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
9643 },
9644 })
9645 }
9646}
9647impl ::treesitter_types::Spanned for PrimaryConstructorBaseType<'_> {
9648 fn span(&self) -> ::treesitter_types::Span {
9649 self.span
9650 }
9651}
9652#[derive(Debug, Clone, PartialEq, Eq)]
9653pub struct PropertyDeclaration<'tree> {
9654 pub span: ::treesitter_types::Span,
9655 pub accessors: ::core::option::Option<AccessorList<'tree>>,
9656 pub name: Identifier<'tree>,
9657 pub r#type: Type<'tree>,
9658 pub value: ::core::option::Option<PropertyDeclarationValue<'tree>>,
9659 pub children: ::std::vec::Vec<PropertyDeclarationChildren<'tree>>,
9660}
9661impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclaration<'tree> {
9662 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9663 fn from_node(
9664 node: ::tree_sitter::Node<'tree>,
9665 src: &'tree [u8],
9666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9667 debug_assert_eq!(node.kind(), "property_declaration");
9668 Ok(Self {
9669 span: ::treesitter_types::Span::from(node),
9670 accessors: match node.child_by_field_name("accessors") {
9671 Some(child) => Some(<AccessorList as ::treesitter_types::FromNode>::from_node(
9672 child, src,
9673 )?),
9674 None => None,
9675 },
9676 name: {
9677 let child = node
9678 .child_by_field_name("name")
9679 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9680 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
9681 },
9682 r#type: {
9683 let child = node
9684 .child_by_field_name("type")
9685 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9686 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
9687 },
9688 value: match node.child_by_field_name("value") {
9689 Some(child) => Some(
9690 <PropertyDeclarationValue as ::treesitter_types::FromNode>::from_node(
9691 child, src,
9692 )?,
9693 ),
9694 None => None,
9695 },
9696 children: {
9697 #[allow(clippy::suspicious_else_formatting)]
9698 let non_field_children = {
9699 let mut cursor = node.walk();
9700 let mut result = ::std::vec::Vec::new();
9701 if cursor.goto_first_child() {
9702 loop {
9703 if cursor.field_name().is_none()
9704 && cursor.node().is_named()
9705 && !cursor.node().is_extra()
9706 {
9707 result.push(cursor.node());
9708 }
9709 if !cursor.goto_next_sibling() {
9710 break;
9711 }
9712 }
9713 }
9714 result
9715 };
9716 let mut items = ::std::vec::Vec::new();
9717 for child in non_field_children {
9718 items.push(
9719 <PropertyDeclarationChildren as ::treesitter_types::FromNode>::from_node(
9720 child, src,
9721 )?,
9722 );
9723 }
9724 items
9725 },
9726 })
9727 }
9728}
9729impl ::treesitter_types::Spanned for PropertyDeclaration<'_> {
9730 fn span(&self) -> ::treesitter_types::Span {
9731 self.span
9732 }
9733}
9734#[derive(Debug, Clone, PartialEq, Eq)]
9735pub struct PropertyPatternClause<'tree> {
9736 pub span: ::treesitter_types::Span,
9737 pub children: ::std::vec::Vec<Subpattern<'tree>>,
9738}
9739impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPatternClause<'tree> {
9740 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9741 fn from_node(
9742 node: ::tree_sitter::Node<'tree>,
9743 src: &'tree [u8],
9744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9745 debug_assert_eq!(node.kind(), "property_pattern_clause");
9746 Ok(Self {
9747 span: ::treesitter_types::Span::from(node),
9748 children: {
9749 #[allow(clippy::suspicious_else_formatting)]
9750 let non_field_children = {
9751 let mut cursor = node.walk();
9752 let mut result = ::std::vec::Vec::new();
9753 if cursor.goto_first_child() {
9754 loop {
9755 if cursor.field_name().is_none()
9756 && cursor.node().is_named()
9757 && !cursor.node().is_extra()
9758 {
9759 result.push(cursor.node());
9760 }
9761 if !cursor.goto_next_sibling() {
9762 break;
9763 }
9764 }
9765 }
9766 result
9767 };
9768 let mut items = ::std::vec::Vec::new();
9769 for child in non_field_children {
9770 items.push(<Subpattern as ::treesitter_types::FromNode>::from_node(
9771 child, src,
9772 )?);
9773 }
9774 items
9775 },
9776 })
9777 }
9778}
9779impl ::treesitter_types::Spanned for PropertyPatternClause<'_> {
9780 fn span(&self) -> ::treesitter_types::Span {
9781 self.span
9782 }
9783}
9784#[derive(Debug, Clone, PartialEq, Eq)]
9785pub struct QualifiedName<'tree> {
9786 pub span: ::treesitter_types::Span,
9787 pub name: QualifiedNameName<'tree>,
9788 pub qualifier: QualifiedNameQualifier<'tree>,
9789}
9790impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedName<'tree> {
9791 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9792 fn from_node(
9793 node: ::tree_sitter::Node<'tree>,
9794 src: &'tree [u8],
9795 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9796 debug_assert_eq!(node.kind(), "qualified_name");
9797 Ok(Self {
9798 span: ::treesitter_types::Span::from(node),
9799 name: {
9800 let child = node
9801 .child_by_field_name("name")
9802 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9803 <QualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)?
9804 },
9805 qualifier: {
9806 let child = node.child_by_field_name("qualifier").ok_or_else(|| {
9807 ::treesitter_types::ParseError::missing_field("qualifier", node)
9808 })?;
9809 <QualifiedNameQualifier as ::treesitter_types::FromNode>::from_node(child, src)?
9810 },
9811 })
9812 }
9813}
9814impl ::treesitter_types::Spanned for QualifiedName<'_> {
9815 fn span(&self) -> ::treesitter_types::Span {
9816 self.span
9817 }
9818}
9819#[derive(Debug, Clone, PartialEq, Eq)]
9820pub struct QueryExpression<'tree> {
9821 pub span: ::treesitter_types::Span,
9822 pub children: ::std::vec::Vec<QueryExpressionChildren<'tree>>,
9823}
9824impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpression<'tree> {
9825 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9826 fn from_node(
9827 node: ::tree_sitter::Node<'tree>,
9828 src: &'tree [u8],
9829 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9830 debug_assert_eq!(node.kind(), "query_expression");
9831 Ok(Self {
9832 span: ::treesitter_types::Span::from(node),
9833 children: {
9834 #[allow(clippy::suspicious_else_formatting)]
9835 let non_field_children = {
9836 let mut cursor = node.walk();
9837 let mut result = ::std::vec::Vec::new();
9838 if cursor.goto_first_child() {
9839 loop {
9840 if cursor.field_name().is_none()
9841 && cursor.node().is_named()
9842 && !cursor.node().is_extra()
9843 {
9844 result.push(cursor.node());
9845 }
9846 if !cursor.goto_next_sibling() {
9847 break;
9848 }
9849 }
9850 }
9851 result
9852 };
9853 let mut items = ::std::vec::Vec::new();
9854 for child in non_field_children {
9855 items.push(
9856 <QueryExpressionChildren as ::treesitter_types::FromNode>::from_node(
9857 child, src,
9858 )?,
9859 );
9860 }
9861 items
9862 },
9863 })
9864 }
9865}
9866impl ::treesitter_types::Spanned for QueryExpression<'_> {
9867 fn span(&self) -> ::treesitter_types::Span {
9868 self.span
9869 }
9870}
9871#[derive(Debug, Clone, PartialEq, Eq)]
9872pub struct RangeExpression<'tree> {
9873 pub span: ::treesitter_types::Span,
9874 pub children: ::std::vec::Vec<Expression<'tree>>,
9875}
9876impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
9877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9878 fn from_node(
9879 node: ::tree_sitter::Node<'tree>,
9880 src: &'tree [u8],
9881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9882 debug_assert_eq!(node.kind(), "range_expression");
9883 Ok(Self {
9884 span: ::treesitter_types::Span::from(node),
9885 children: {
9886 #[allow(clippy::suspicious_else_formatting)]
9887 let non_field_children = {
9888 let mut cursor = node.walk();
9889 let mut result = ::std::vec::Vec::new();
9890 if cursor.goto_first_child() {
9891 loop {
9892 if cursor.field_name().is_none()
9893 && cursor.node().is_named()
9894 && !cursor.node().is_extra()
9895 {
9896 result.push(cursor.node());
9897 }
9898 if !cursor.goto_next_sibling() {
9899 break;
9900 }
9901 }
9902 }
9903 result
9904 };
9905 let mut items = ::std::vec::Vec::new();
9906 for child in non_field_children {
9907 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
9908 child, src,
9909 )?);
9910 }
9911 items
9912 },
9913 })
9914 }
9915}
9916impl ::treesitter_types::Spanned for RangeExpression<'_> {
9917 fn span(&self) -> ::treesitter_types::Span {
9918 self.span
9919 }
9920}
9921#[derive(Debug, Clone, PartialEq, Eq)]
9922pub struct RawStringLiteral<'tree> {
9923 pub span: ::treesitter_types::Span,
9924 pub children: ::std::vec::Vec<RawStringLiteralChildren<'tree>>,
9925}
9926impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
9927 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9928 fn from_node(
9929 node: ::tree_sitter::Node<'tree>,
9930 src: &'tree [u8],
9931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9932 debug_assert_eq!(node.kind(), "raw_string_literal");
9933 Ok(Self {
9934 span: ::treesitter_types::Span::from(node),
9935 children: {
9936 #[allow(clippy::suspicious_else_formatting)]
9937 let non_field_children = {
9938 let mut cursor = node.walk();
9939 let mut result = ::std::vec::Vec::new();
9940 if cursor.goto_first_child() {
9941 loop {
9942 if cursor.field_name().is_none()
9943 && cursor.node().is_named()
9944 && !cursor.node().is_extra()
9945 {
9946 result.push(cursor.node());
9947 }
9948 if !cursor.goto_next_sibling() {
9949 break;
9950 }
9951 }
9952 }
9953 result
9954 };
9955 let mut items = ::std::vec::Vec::new();
9956 for child in non_field_children {
9957 items.push(
9958 <RawStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
9959 child, src,
9960 )?,
9961 );
9962 }
9963 items
9964 },
9965 })
9966 }
9967}
9968impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
9969 fn span(&self) -> ::treesitter_types::Span {
9970 self.span
9971 }
9972}
9973#[derive(Debug, Clone, PartialEq, Eq)]
9974pub struct RecordDeclaration<'tree> {
9975 pub span: ::treesitter_types::Span,
9976 pub body: ::core::option::Option<DeclarationList<'tree>>,
9977 pub name: Identifier<'tree>,
9978 pub children: ::std::vec::Vec<RecordDeclarationChildren<'tree>>,
9979}
9980impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
9981 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9982 fn from_node(
9983 node: ::tree_sitter::Node<'tree>,
9984 src: &'tree [u8],
9985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9986 debug_assert_eq!(node.kind(), "record_declaration");
9987 Ok(Self {
9988 span: ::treesitter_types::Span::from(node),
9989 body: match node.child_by_field_name("body") {
9990 Some(child) => {
9991 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
9992 }
9993 None => None,
9994 },
9995 name: {
9996 let child = node
9997 .child_by_field_name("name")
9998 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9999 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
10000 },
10001 children: {
10002 #[allow(clippy::suspicious_else_formatting)]
10003 let non_field_children = {
10004 let mut cursor = node.walk();
10005 let mut result = ::std::vec::Vec::new();
10006 if cursor.goto_first_child() {
10007 loop {
10008 if cursor.field_name().is_none()
10009 && cursor.node().is_named()
10010 && !cursor.node().is_extra()
10011 {
10012 result.push(cursor.node());
10013 }
10014 if !cursor.goto_next_sibling() {
10015 break;
10016 }
10017 }
10018 }
10019 result
10020 };
10021 let mut items = ::std::vec::Vec::new();
10022 for child in non_field_children {
10023 items.push(
10024 <RecordDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10025 child, src,
10026 )?,
10027 );
10028 }
10029 items
10030 },
10031 })
10032 }
10033}
10034impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
10035 fn span(&self) -> ::treesitter_types::Span {
10036 self.span
10037 }
10038}
10039#[derive(Debug, Clone, PartialEq, Eq)]
10040pub struct RecursivePattern<'tree> {
10041 pub span: ::treesitter_types::Span,
10042 pub name: ::core::option::Option<Identifier<'tree>>,
10043 pub r#type: ::core::option::Option<Type<'tree>>,
10044 pub children: ::std::vec::Vec<RecursivePatternChildren<'tree>>,
10045}
10046impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePattern<'tree> {
10047 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10048 fn from_node(
10049 node: ::tree_sitter::Node<'tree>,
10050 src: &'tree [u8],
10051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10052 debug_assert_eq!(node.kind(), "recursive_pattern");
10053 Ok(Self {
10054 span: ::treesitter_types::Span::from(node),
10055 name: match node.child_by_field_name("name") {
10056 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
10057 child, src,
10058 )?),
10059 None => None,
10060 },
10061 r#type: match node.child_by_field_name("type") {
10062 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
10063 child, src,
10064 )?),
10065 None => None,
10066 },
10067 children: {
10068 #[allow(clippy::suspicious_else_formatting)]
10069 let non_field_children = {
10070 let mut cursor = node.walk();
10071 let mut result = ::std::vec::Vec::new();
10072 if cursor.goto_first_child() {
10073 loop {
10074 if cursor.field_name().is_none()
10075 && cursor.node().is_named()
10076 && !cursor.node().is_extra()
10077 {
10078 result.push(cursor.node());
10079 }
10080 if !cursor.goto_next_sibling() {
10081 break;
10082 }
10083 }
10084 }
10085 result
10086 };
10087 let mut items = ::std::vec::Vec::new();
10088 for child in non_field_children {
10089 items.push(
10090 <RecursivePatternChildren as ::treesitter_types::FromNode>::from_node(
10091 child, src,
10092 )?,
10093 );
10094 }
10095 items
10096 },
10097 })
10098 }
10099}
10100impl ::treesitter_types::Spanned for RecursivePattern<'_> {
10101 fn span(&self) -> ::treesitter_types::Span {
10102 self.span
10103 }
10104}
10105#[derive(Debug, Clone, PartialEq, Eq)]
10106pub struct RefExpression<'tree> {
10107 pub span: ::treesitter_types::Span,
10108 pub children: Expression<'tree>,
10109}
10110impl<'tree> ::treesitter_types::FromNode<'tree> for RefExpression<'tree> {
10111 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10112 fn from_node(
10113 node: ::tree_sitter::Node<'tree>,
10114 src: &'tree [u8],
10115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10116 debug_assert_eq!(node.kind(), "ref_expression");
10117 Ok(Self {
10118 span: ::treesitter_types::Span::from(node),
10119 children: {
10120 #[allow(clippy::suspicious_else_formatting)]
10121 let non_field_children = {
10122 let mut cursor = node.walk();
10123 let mut result = ::std::vec::Vec::new();
10124 if cursor.goto_first_child() {
10125 loop {
10126 if cursor.field_name().is_none()
10127 && cursor.node().is_named()
10128 && !cursor.node().is_extra()
10129 {
10130 result.push(cursor.node());
10131 }
10132 if !cursor.goto_next_sibling() {
10133 break;
10134 }
10135 }
10136 }
10137 result
10138 };
10139 let child = if let Some(&c) = non_field_children.first() {
10140 c
10141 } else {
10142 let mut fallback_cursor = node.walk();
10143 let mut fallback_child = None;
10144 if fallback_cursor.goto_first_child() {
10145 loop {
10146 if fallback_cursor.field_name().is_none()
10147 && !fallback_cursor.node().is_extra()
10148 {
10149 let candidate = fallback_cursor.node();
10150 #[allow(clippy::needless_question_mark)]
10151 if (|| -> ::core::result::Result<
10152 _,
10153 ::treesitter_types::ParseError,
10154 > {
10155 let child = candidate;
10156 Ok(
10157 <Expression as ::treesitter_types::FromNode>::from_node(
10158 child,
10159 src,
10160 )?,
10161 )
10162 })()
10163 .is_ok()
10164 {
10165 fallback_child = Some(candidate);
10166 break;
10167 }
10168 }
10169 if !fallback_cursor.goto_next_sibling() {
10170 break;
10171 }
10172 }
10173 }
10174 if fallback_child.is_none() {
10175 let mut cursor2 = node.walk();
10176 if cursor2.goto_first_child() {
10177 loop {
10178 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10179 let candidate = cursor2.node();
10180 #[allow(clippy::needless_question_mark)]
10181 if (|| -> ::core::result::Result<
10182 _,
10183 ::treesitter_types::ParseError,
10184 > {
10185 let child = candidate;
10186 Ok(
10187 <Expression as ::treesitter_types::FromNode>::from_node(
10188 child,
10189 src,
10190 )?,
10191 )
10192 })()
10193 .is_ok()
10194 {
10195 fallback_child = Some(candidate);
10196 break;
10197 }
10198 }
10199 if !cursor2.goto_next_sibling() {
10200 break;
10201 }
10202 }
10203 }
10204 }
10205 fallback_child.ok_or_else(|| {
10206 ::treesitter_types::ParseError::missing_field("children", node)
10207 })?
10208 };
10209 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
10210 },
10211 })
10212 }
10213}
10214impl ::treesitter_types::Spanned for RefExpression<'_> {
10215 fn span(&self) -> ::treesitter_types::Span {
10216 self.span
10217 }
10218}
10219#[derive(Debug, Clone, PartialEq, Eq)]
10220pub struct RefType<'tree> {
10221 pub span: ::treesitter_types::Span,
10222 pub r#type: Type<'tree>,
10223}
10224impl<'tree> ::treesitter_types::FromNode<'tree> for RefType<'tree> {
10225 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10226 fn from_node(
10227 node: ::tree_sitter::Node<'tree>,
10228 src: &'tree [u8],
10229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10230 debug_assert_eq!(node.kind(), "ref_type");
10231 Ok(Self {
10232 span: ::treesitter_types::Span::from(node),
10233 r#type: {
10234 let child = node
10235 .child_by_field_name("type")
10236 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10237 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
10238 },
10239 })
10240 }
10241}
10242impl ::treesitter_types::Spanned for RefType<'_> {
10243 fn span(&self) -> ::treesitter_types::Span {
10244 self.span
10245 }
10246}
10247#[derive(Debug, Clone, PartialEq, Eq)]
10248pub struct ReftypeExpression<'tree> {
10249 pub span: ::treesitter_types::Span,
10250 pub children: Expression<'tree>,
10251}
10252impl<'tree> ::treesitter_types::FromNode<'tree> for ReftypeExpression<'tree> {
10253 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10254 fn from_node(
10255 node: ::tree_sitter::Node<'tree>,
10256 src: &'tree [u8],
10257 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10258 debug_assert_eq!(node.kind(), "reftype_expression");
10259 Ok(Self {
10260 span: ::treesitter_types::Span::from(node),
10261 children: {
10262 #[allow(clippy::suspicious_else_formatting)]
10263 let non_field_children = {
10264 let mut cursor = node.walk();
10265 let mut result = ::std::vec::Vec::new();
10266 if cursor.goto_first_child() {
10267 loop {
10268 if cursor.field_name().is_none()
10269 && cursor.node().is_named()
10270 && !cursor.node().is_extra()
10271 {
10272 result.push(cursor.node());
10273 }
10274 if !cursor.goto_next_sibling() {
10275 break;
10276 }
10277 }
10278 }
10279 result
10280 };
10281 let child = if let Some(&c) = non_field_children.first() {
10282 c
10283 } else {
10284 let mut fallback_cursor = node.walk();
10285 let mut fallback_child = None;
10286 if fallback_cursor.goto_first_child() {
10287 loop {
10288 if fallback_cursor.field_name().is_none()
10289 && !fallback_cursor.node().is_extra()
10290 {
10291 let candidate = fallback_cursor.node();
10292 #[allow(clippy::needless_question_mark)]
10293 if (|| -> ::core::result::Result<
10294 _,
10295 ::treesitter_types::ParseError,
10296 > {
10297 let child = candidate;
10298 Ok(
10299 <Expression as ::treesitter_types::FromNode>::from_node(
10300 child,
10301 src,
10302 )?,
10303 )
10304 })()
10305 .is_ok()
10306 {
10307 fallback_child = Some(candidate);
10308 break;
10309 }
10310 }
10311 if !fallback_cursor.goto_next_sibling() {
10312 break;
10313 }
10314 }
10315 }
10316 if fallback_child.is_none() {
10317 let mut cursor2 = node.walk();
10318 if cursor2.goto_first_child() {
10319 loop {
10320 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10321 let candidate = cursor2.node();
10322 #[allow(clippy::needless_question_mark)]
10323 if (|| -> ::core::result::Result<
10324 _,
10325 ::treesitter_types::ParseError,
10326 > {
10327 let child = candidate;
10328 Ok(
10329 <Expression as ::treesitter_types::FromNode>::from_node(
10330 child,
10331 src,
10332 )?,
10333 )
10334 })()
10335 .is_ok()
10336 {
10337 fallback_child = Some(candidate);
10338 break;
10339 }
10340 }
10341 if !cursor2.goto_next_sibling() {
10342 break;
10343 }
10344 }
10345 }
10346 }
10347 fallback_child.ok_or_else(|| {
10348 ::treesitter_types::ParseError::missing_field("children", node)
10349 })?
10350 };
10351 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
10352 },
10353 })
10354 }
10355}
10356impl ::treesitter_types::Spanned for ReftypeExpression<'_> {
10357 fn span(&self) -> ::treesitter_types::Span {
10358 self.span
10359 }
10360}
10361#[derive(Debug, Clone, PartialEq, Eq)]
10362pub struct RefvalueExpression<'tree> {
10363 pub span: ::treesitter_types::Span,
10364 pub r#type: Type<'tree>,
10365 pub value: Expression<'tree>,
10366}
10367impl<'tree> ::treesitter_types::FromNode<'tree> for RefvalueExpression<'tree> {
10368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10369 fn from_node(
10370 node: ::tree_sitter::Node<'tree>,
10371 src: &'tree [u8],
10372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10373 debug_assert_eq!(node.kind(), "refvalue_expression");
10374 Ok(Self {
10375 span: ::treesitter_types::Span::from(node),
10376 r#type: {
10377 let child = node
10378 .child_by_field_name("type")
10379 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10380 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
10381 },
10382 value: {
10383 let child = node
10384 .child_by_field_name("value")
10385 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
10386 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
10387 },
10388 })
10389 }
10390}
10391impl ::treesitter_types::Spanned for RefvalueExpression<'_> {
10392 fn span(&self) -> ::treesitter_types::Span {
10393 self.span
10394 }
10395}
10396#[derive(Debug, Clone, PartialEq, Eq)]
10397pub struct RelationalPattern<'tree> {
10398 pub span: ::treesitter_types::Span,
10399 pub children: Expression<'tree>,
10400}
10401impl<'tree> ::treesitter_types::FromNode<'tree> for RelationalPattern<'tree> {
10402 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10403 fn from_node(
10404 node: ::tree_sitter::Node<'tree>,
10405 src: &'tree [u8],
10406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10407 debug_assert_eq!(node.kind(), "relational_pattern");
10408 Ok(Self {
10409 span: ::treesitter_types::Span::from(node),
10410 children: {
10411 #[allow(clippy::suspicious_else_formatting)]
10412 let non_field_children = {
10413 let mut cursor = node.walk();
10414 let mut result = ::std::vec::Vec::new();
10415 if cursor.goto_first_child() {
10416 loop {
10417 if cursor.field_name().is_none()
10418 && cursor.node().is_named()
10419 && !cursor.node().is_extra()
10420 {
10421 result.push(cursor.node());
10422 }
10423 if !cursor.goto_next_sibling() {
10424 break;
10425 }
10426 }
10427 }
10428 result
10429 };
10430 let child = if let Some(&c) = non_field_children.first() {
10431 c
10432 } else {
10433 let mut fallback_cursor = node.walk();
10434 let mut fallback_child = None;
10435 if fallback_cursor.goto_first_child() {
10436 loop {
10437 if fallback_cursor.field_name().is_none()
10438 && !fallback_cursor.node().is_extra()
10439 {
10440 let candidate = fallback_cursor.node();
10441 #[allow(clippy::needless_question_mark)]
10442 if (|| -> ::core::result::Result<
10443 _,
10444 ::treesitter_types::ParseError,
10445 > {
10446 let child = candidate;
10447 Ok(
10448 <Expression as ::treesitter_types::FromNode>::from_node(
10449 child,
10450 src,
10451 )?,
10452 )
10453 })()
10454 .is_ok()
10455 {
10456 fallback_child = Some(candidate);
10457 break;
10458 }
10459 }
10460 if !fallback_cursor.goto_next_sibling() {
10461 break;
10462 }
10463 }
10464 }
10465 if fallback_child.is_none() {
10466 let mut cursor2 = node.walk();
10467 if cursor2.goto_first_child() {
10468 loop {
10469 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10470 let candidate = cursor2.node();
10471 #[allow(clippy::needless_question_mark)]
10472 if (|| -> ::core::result::Result<
10473 _,
10474 ::treesitter_types::ParseError,
10475 > {
10476 let child = candidate;
10477 Ok(
10478 <Expression as ::treesitter_types::FromNode>::from_node(
10479 child,
10480 src,
10481 )?,
10482 )
10483 })()
10484 .is_ok()
10485 {
10486 fallback_child = Some(candidate);
10487 break;
10488 }
10489 }
10490 if !cursor2.goto_next_sibling() {
10491 break;
10492 }
10493 }
10494 }
10495 }
10496 fallback_child.ok_or_else(|| {
10497 ::treesitter_types::ParseError::missing_field("children", node)
10498 })?
10499 };
10500 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
10501 },
10502 })
10503 }
10504}
10505impl ::treesitter_types::Spanned for RelationalPattern<'_> {
10506 fn span(&self) -> ::treesitter_types::Span {
10507 self.span
10508 }
10509}
10510#[derive(Debug, Clone, PartialEq, Eq)]
10511pub struct ReturnStatement<'tree> {
10512 pub span: ::treesitter_types::Span,
10513 pub children: ::core::option::Option<Expression<'tree>>,
10514}
10515impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
10516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10517 fn from_node(
10518 node: ::tree_sitter::Node<'tree>,
10519 src: &'tree [u8],
10520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10521 debug_assert_eq!(node.kind(), "return_statement");
10522 Ok(Self {
10523 span: ::treesitter_types::Span::from(node),
10524 children: {
10525 #[allow(clippy::suspicious_else_formatting)]
10526 let non_field_children = {
10527 let mut cursor = node.walk();
10528 let mut result = ::std::vec::Vec::new();
10529 if cursor.goto_first_child() {
10530 loop {
10531 if cursor.field_name().is_none()
10532 && cursor.node().is_named()
10533 && !cursor.node().is_extra()
10534 {
10535 result.push(cursor.node());
10536 }
10537 if !cursor.goto_next_sibling() {
10538 break;
10539 }
10540 }
10541 }
10542 result
10543 };
10544 match non_field_children.first() {
10545 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
10546 child, src,
10547 )?),
10548 None => None,
10549 }
10550 },
10551 })
10552 }
10553}
10554impl ::treesitter_types::Spanned for ReturnStatement<'_> {
10555 fn span(&self) -> ::treesitter_types::Span {
10556 self.span
10557 }
10558}
10559#[derive(Debug, Clone, PartialEq, Eq)]
10560pub struct ScopedType<'tree> {
10561 pub span: ::treesitter_types::Span,
10562 pub r#type: ScopedTypeType<'tree>,
10563}
10564impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedType<'tree> {
10565 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10566 fn from_node(
10567 node: ::tree_sitter::Node<'tree>,
10568 src: &'tree [u8],
10569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10570 debug_assert_eq!(node.kind(), "scoped_type");
10571 Ok(Self {
10572 span: ::treesitter_types::Span::from(node),
10573 r#type: {
10574 let child = node
10575 .child_by_field_name("type")
10576 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10577 <ScopedTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
10578 },
10579 })
10580 }
10581}
10582impl ::treesitter_types::Spanned for ScopedType<'_> {
10583 fn span(&self) -> ::treesitter_types::Span {
10584 self.span
10585 }
10586}
10587#[derive(Debug, Clone, PartialEq, Eq)]
10588pub struct SelectClause<'tree> {
10589 pub span: ::treesitter_types::Span,
10590 pub children: Expression<'tree>,
10591}
10592impl<'tree> ::treesitter_types::FromNode<'tree> for SelectClause<'tree> {
10593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10594 fn from_node(
10595 node: ::tree_sitter::Node<'tree>,
10596 src: &'tree [u8],
10597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10598 debug_assert_eq!(node.kind(), "select_clause");
10599 Ok(Self {
10600 span: ::treesitter_types::Span::from(node),
10601 children: {
10602 #[allow(clippy::suspicious_else_formatting)]
10603 let non_field_children = {
10604 let mut cursor = node.walk();
10605 let mut result = ::std::vec::Vec::new();
10606 if cursor.goto_first_child() {
10607 loop {
10608 if cursor.field_name().is_none()
10609 && cursor.node().is_named()
10610 && !cursor.node().is_extra()
10611 {
10612 result.push(cursor.node());
10613 }
10614 if !cursor.goto_next_sibling() {
10615 break;
10616 }
10617 }
10618 }
10619 result
10620 };
10621 let child = if let Some(&c) = non_field_children.first() {
10622 c
10623 } else {
10624 let mut fallback_cursor = node.walk();
10625 let mut fallback_child = None;
10626 if fallback_cursor.goto_first_child() {
10627 loop {
10628 if fallback_cursor.field_name().is_none()
10629 && !fallback_cursor.node().is_extra()
10630 {
10631 let candidate = fallback_cursor.node();
10632 #[allow(clippy::needless_question_mark)]
10633 if (|| -> ::core::result::Result<
10634 _,
10635 ::treesitter_types::ParseError,
10636 > {
10637 let child = candidate;
10638 Ok(
10639 <Expression as ::treesitter_types::FromNode>::from_node(
10640 child,
10641 src,
10642 )?,
10643 )
10644 })()
10645 .is_ok()
10646 {
10647 fallback_child = Some(candidate);
10648 break;
10649 }
10650 }
10651 if !fallback_cursor.goto_next_sibling() {
10652 break;
10653 }
10654 }
10655 }
10656 if fallback_child.is_none() {
10657 let mut cursor2 = node.walk();
10658 if cursor2.goto_first_child() {
10659 loop {
10660 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10661 let candidate = cursor2.node();
10662 #[allow(clippy::needless_question_mark)]
10663 if (|| -> ::core::result::Result<
10664 _,
10665 ::treesitter_types::ParseError,
10666 > {
10667 let child = candidate;
10668 Ok(
10669 <Expression as ::treesitter_types::FromNode>::from_node(
10670 child,
10671 src,
10672 )?,
10673 )
10674 })()
10675 .is_ok()
10676 {
10677 fallback_child = Some(candidate);
10678 break;
10679 }
10680 }
10681 if !cursor2.goto_next_sibling() {
10682 break;
10683 }
10684 }
10685 }
10686 }
10687 fallback_child.ok_or_else(|| {
10688 ::treesitter_types::ParseError::missing_field("children", node)
10689 })?
10690 };
10691 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
10692 },
10693 })
10694 }
10695}
10696impl ::treesitter_types::Spanned for SelectClause<'_> {
10697 fn span(&self) -> ::treesitter_types::Span {
10698 self.span
10699 }
10700}
10701#[derive(Debug, Clone, PartialEq, Eq)]
10702pub struct SizeofExpression<'tree> {
10703 pub span: ::treesitter_types::Span,
10704 pub r#type: Type<'tree>,
10705}
10706impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
10707 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10708 fn from_node(
10709 node: ::tree_sitter::Node<'tree>,
10710 src: &'tree [u8],
10711 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10712 debug_assert_eq!(node.kind(), "sizeof_expression");
10713 Ok(Self {
10714 span: ::treesitter_types::Span::from(node),
10715 r#type: {
10716 let child = node
10717 .child_by_field_name("type")
10718 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10719 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
10720 },
10721 })
10722 }
10723}
10724impl ::treesitter_types::Spanned for SizeofExpression<'_> {
10725 fn span(&self) -> ::treesitter_types::Span {
10726 self.span
10727 }
10728}
10729#[derive(Debug, Clone, PartialEq, Eq)]
10730pub struct StackallocExpression<'tree> {
10731 pub span: ::treesitter_types::Span,
10732 pub r#type: ArrayType<'tree>,
10733 pub children: ::core::option::Option<InitializerExpression<'tree>>,
10734}
10735impl<'tree> ::treesitter_types::FromNode<'tree> for StackallocExpression<'tree> {
10736 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10737 fn from_node(
10738 node: ::tree_sitter::Node<'tree>,
10739 src: &'tree [u8],
10740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10741 debug_assert_eq!(node.kind(), "stackalloc_expression");
10742 Ok(Self {
10743 span: ::treesitter_types::Span::from(node),
10744 r#type: {
10745 let child = node
10746 .child_by_field_name("type")
10747 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10748 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)?
10749 },
10750 children: {
10751 #[allow(clippy::suspicious_else_formatting)]
10752 let non_field_children = {
10753 let mut cursor = node.walk();
10754 let mut result = ::std::vec::Vec::new();
10755 if cursor.goto_first_child() {
10756 loop {
10757 if cursor.field_name().is_none()
10758 && cursor.node().is_named()
10759 && !cursor.node().is_extra()
10760 {
10761 result.push(cursor.node());
10762 }
10763 if !cursor.goto_next_sibling() {
10764 break;
10765 }
10766 }
10767 }
10768 result
10769 };
10770 match non_field_children.first() {
10771 Some(&child) => Some(
10772 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
10773 child, src,
10774 )?,
10775 ),
10776 None => None,
10777 }
10778 },
10779 })
10780 }
10781}
10782impl ::treesitter_types::Spanned for StackallocExpression<'_> {
10783 fn span(&self) -> ::treesitter_types::Span {
10784 self.span
10785 }
10786}
10787#[derive(Debug, Clone, PartialEq, Eq)]
10788pub struct StringLiteral<'tree> {
10789 pub span: ::treesitter_types::Span,
10790 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
10791}
10792impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
10793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10794 fn from_node(
10795 node: ::tree_sitter::Node<'tree>,
10796 src: &'tree [u8],
10797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10798 debug_assert_eq!(node.kind(), "string_literal");
10799 Ok(Self {
10800 span: ::treesitter_types::Span::from(node),
10801 children: {
10802 #[allow(clippy::suspicious_else_formatting)]
10803 let non_field_children = {
10804 let mut cursor = node.walk();
10805 let mut result = ::std::vec::Vec::new();
10806 if cursor.goto_first_child() {
10807 loop {
10808 if cursor.field_name().is_none()
10809 && cursor.node().is_named()
10810 && !cursor.node().is_extra()
10811 {
10812 result.push(cursor.node());
10813 }
10814 if !cursor.goto_next_sibling() {
10815 break;
10816 }
10817 }
10818 }
10819 result
10820 };
10821 let mut items = ::std::vec::Vec::new();
10822 for child in non_field_children {
10823 items.push(
10824 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
10825 child, src,
10826 )?,
10827 );
10828 }
10829 items
10830 },
10831 })
10832 }
10833}
10834impl ::treesitter_types::Spanned for StringLiteral<'_> {
10835 fn span(&self) -> ::treesitter_types::Span {
10836 self.span
10837 }
10838}
10839#[derive(Debug, Clone, PartialEq, Eq)]
10840pub struct StringLiteralContent<'tree> {
10841 pub span: ::treesitter_types::Span,
10842 text: &'tree str,
10843}
10844impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralContent<'tree> {
10845 fn from_node(
10846 node: ::tree_sitter::Node<'tree>,
10847 src: &'tree [u8],
10848 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10849 debug_assert_eq!(node.kind(), "string_literal_content");
10850 Ok(Self {
10851 span: ::treesitter_types::Span::from(node),
10852 text: node.utf8_text(src)?,
10853 })
10854 }
10855}
10856impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralContent<'tree> {
10857 fn text(&self) -> &'tree str {
10858 self.text
10859 }
10860}
10861impl ::treesitter_types::Spanned for StringLiteralContent<'_> {
10862 fn span(&self) -> ::treesitter_types::Span {
10863 self.span
10864 }
10865}
10866#[derive(Debug, Clone, PartialEq, Eq)]
10867pub struct StructDeclaration<'tree> {
10868 pub span: ::treesitter_types::Span,
10869 pub body: DeclarationList<'tree>,
10870 pub name: Identifier<'tree>,
10871 pub children: ::std::vec::Vec<StructDeclarationChildren<'tree>>,
10872}
10873impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclaration<'tree> {
10874 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10875 fn from_node(
10876 node: ::tree_sitter::Node<'tree>,
10877 src: &'tree [u8],
10878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10879 debug_assert_eq!(node.kind(), "struct_declaration");
10880 Ok(Self {
10881 span: ::treesitter_types::Span::from(node),
10882 body: {
10883 let child = node
10884 .child_by_field_name("body")
10885 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
10886 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
10887 },
10888 name: {
10889 let child = node
10890 .child_by_field_name("name")
10891 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10892 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
10893 },
10894 children: {
10895 #[allow(clippy::suspicious_else_formatting)]
10896 let non_field_children = {
10897 let mut cursor = node.walk();
10898 let mut result = ::std::vec::Vec::new();
10899 if cursor.goto_first_child() {
10900 loop {
10901 if cursor.field_name().is_none()
10902 && cursor.node().is_named()
10903 && !cursor.node().is_extra()
10904 {
10905 result.push(cursor.node());
10906 }
10907 if !cursor.goto_next_sibling() {
10908 break;
10909 }
10910 }
10911 }
10912 result
10913 };
10914 let mut items = ::std::vec::Vec::new();
10915 for child in non_field_children {
10916 items.push(
10917 <StructDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10918 child, src,
10919 )?,
10920 );
10921 }
10922 items
10923 },
10924 })
10925 }
10926}
10927impl ::treesitter_types::Spanned for StructDeclaration<'_> {
10928 fn span(&self) -> ::treesitter_types::Span {
10929 self.span
10930 }
10931}
10932#[derive(Debug, Clone, PartialEq, Eq)]
10933pub struct Subpattern<'tree> {
10934 pub span: ::treesitter_types::Span,
10935 pub children: ::std::vec::Vec<SubpatternChildren<'tree>>,
10936}
10937impl<'tree> ::treesitter_types::FromNode<'tree> for Subpattern<'tree> {
10938 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10939 fn from_node(
10940 node: ::tree_sitter::Node<'tree>,
10941 src: &'tree [u8],
10942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10943 debug_assert_eq!(node.kind(), "subpattern");
10944 Ok(Self {
10945 span: ::treesitter_types::Span::from(node),
10946 children: {
10947 #[allow(clippy::suspicious_else_formatting)]
10948 let non_field_children = {
10949 let mut cursor = node.walk();
10950 let mut result = ::std::vec::Vec::new();
10951 if cursor.goto_first_child() {
10952 loop {
10953 if cursor.field_name().is_none()
10954 && cursor.node().is_named()
10955 && !cursor.node().is_extra()
10956 {
10957 result.push(cursor.node());
10958 }
10959 if !cursor.goto_next_sibling() {
10960 break;
10961 }
10962 }
10963 }
10964 result
10965 };
10966 let mut items = ::std::vec::Vec::new();
10967 for child in non_field_children {
10968 items.push(
10969 <SubpatternChildren as ::treesitter_types::FromNode>::from_node(
10970 child, src,
10971 )?,
10972 );
10973 }
10974 items
10975 },
10976 })
10977 }
10978}
10979impl ::treesitter_types::Spanned for Subpattern<'_> {
10980 fn span(&self) -> ::treesitter_types::Span {
10981 self.span
10982 }
10983}
10984#[derive(Debug, Clone, PartialEq, Eq)]
10985pub struct SwitchBody<'tree> {
10986 pub span: ::treesitter_types::Span,
10987 pub children: ::std::vec::Vec<SwitchSection<'tree>>,
10988}
10989impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
10990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10991 fn from_node(
10992 node: ::tree_sitter::Node<'tree>,
10993 src: &'tree [u8],
10994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10995 debug_assert_eq!(node.kind(), "switch_body");
10996 Ok(Self {
10997 span: ::treesitter_types::Span::from(node),
10998 children: {
10999 #[allow(clippy::suspicious_else_formatting)]
11000 let non_field_children = {
11001 let mut cursor = node.walk();
11002 let mut result = ::std::vec::Vec::new();
11003 if cursor.goto_first_child() {
11004 loop {
11005 if cursor.field_name().is_none()
11006 && cursor.node().is_named()
11007 && !cursor.node().is_extra()
11008 {
11009 result.push(cursor.node());
11010 }
11011 if !cursor.goto_next_sibling() {
11012 break;
11013 }
11014 }
11015 }
11016 result
11017 };
11018 let mut items = ::std::vec::Vec::new();
11019 for child in non_field_children {
11020 items.push(<SwitchSection as ::treesitter_types::FromNode>::from_node(
11021 child, src,
11022 )?);
11023 }
11024 items
11025 },
11026 })
11027 }
11028}
11029impl ::treesitter_types::Spanned for SwitchBody<'_> {
11030 fn span(&self) -> ::treesitter_types::Span {
11031 self.span
11032 }
11033}
11034#[derive(Debug, Clone, PartialEq, Eq)]
11035pub struct SwitchExpression<'tree> {
11036 pub span: ::treesitter_types::Span,
11037 pub children: ::std::vec::Vec<SwitchExpressionChildren<'tree>>,
11038}
11039impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
11040 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11041 fn from_node(
11042 node: ::tree_sitter::Node<'tree>,
11043 src: &'tree [u8],
11044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11045 debug_assert_eq!(node.kind(), "switch_expression");
11046 Ok(Self {
11047 span: ::treesitter_types::Span::from(node),
11048 children: {
11049 #[allow(clippy::suspicious_else_formatting)]
11050 let non_field_children = {
11051 let mut cursor = node.walk();
11052 let mut result = ::std::vec::Vec::new();
11053 if cursor.goto_first_child() {
11054 loop {
11055 if cursor.field_name().is_none()
11056 && cursor.node().is_named()
11057 && !cursor.node().is_extra()
11058 {
11059 result.push(cursor.node());
11060 }
11061 if !cursor.goto_next_sibling() {
11062 break;
11063 }
11064 }
11065 }
11066 result
11067 };
11068 let mut items = ::std::vec::Vec::new();
11069 for child in non_field_children {
11070 items.push(
11071 <SwitchExpressionChildren as ::treesitter_types::FromNode>::from_node(
11072 child, src,
11073 )?,
11074 );
11075 }
11076 items
11077 },
11078 })
11079 }
11080}
11081impl ::treesitter_types::Spanned for SwitchExpression<'_> {
11082 fn span(&self) -> ::treesitter_types::Span {
11083 self.span
11084 }
11085}
11086#[derive(Debug, Clone, PartialEq, Eq)]
11087pub struct SwitchExpressionArm<'tree> {
11088 pub span: ::treesitter_types::Span,
11089 pub children: ::std::vec::Vec<SwitchExpressionArmChildren<'tree>>,
11090}
11091impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArm<'tree> {
11092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11093 fn from_node(
11094 node: ::tree_sitter::Node<'tree>,
11095 src: &'tree [u8],
11096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11097 debug_assert_eq!(node.kind(), "switch_expression_arm");
11098 Ok(Self {
11099 span: ::treesitter_types::Span::from(node),
11100 children: {
11101 #[allow(clippy::suspicious_else_formatting)]
11102 let non_field_children = {
11103 let mut cursor = node.walk();
11104 let mut result = ::std::vec::Vec::new();
11105 if cursor.goto_first_child() {
11106 loop {
11107 if cursor.field_name().is_none()
11108 && cursor.node().is_named()
11109 && !cursor.node().is_extra()
11110 {
11111 result.push(cursor.node());
11112 }
11113 if !cursor.goto_next_sibling() {
11114 break;
11115 }
11116 }
11117 }
11118 result
11119 };
11120 let mut items = ::std::vec::Vec::new();
11121 for child in non_field_children {
11122 items.push(
11123 <SwitchExpressionArmChildren as ::treesitter_types::FromNode>::from_node(
11124 child, src,
11125 )?,
11126 );
11127 }
11128 items
11129 },
11130 })
11131 }
11132}
11133impl ::treesitter_types::Spanned for SwitchExpressionArm<'_> {
11134 fn span(&self) -> ::treesitter_types::Span {
11135 self.span
11136 }
11137}
11138#[derive(Debug, Clone, PartialEq, Eq)]
11139pub struct SwitchSection<'tree> {
11140 pub span: ::treesitter_types::Span,
11141 pub children: ::std::vec::Vec<SwitchSectionChildren<'tree>>,
11142}
11143impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSection<'tree> {
11144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11145 fn from_node(
11146 node: ::tree_sitter::Node<'tree>,
11147 src: &'tree [u8],
11148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11149 debug_assert_eq!(node.kind(), "switch_section");
11150 Ok(Self {
11151 span: ::treesitter_types::Span::from(node),
11152 children: {
11153 #[allow(clippy::suspicious_else_formatting)]
11154 let non_field_children = {
11155 let mut cursor = node.walk();
11156 let mut result = ::std::vec::Vec::new();
11157 if cursor.goto_first_child() {
11158 loop {
11159 if cursor.field_name().is_none()
11160 && cursor.node().is_named()
11161 && !cursor.node().is_extra()
11162 {
11163 result.push(cursor.node());
11164 }
11165 if !cursor.goto_next_sibling() {
11166 break;
11167 }
11168 }
11169 }
11170 result
11171 };
11172 let mut items = ::std::vec::Vec::new();
11173 for child in non_field_children {
11174 items.push(
11175 <SwitchSectionChildren as ::treesitter_types::FromNode>::from_node(
11176 child, src,
11177 )?,
11178 );
11179 }
11180 items
11181 },
11182 })
11183 }
11184}
11185impl ::treesitter_types::Spanned for SwitchSection<'_> {
11186 fn span(&self) -> ::treesitter_types::Span {
11187 self.span
11188 }
11189}
11190#[derive(Debug, Clone, PartialEq, Eq)]
11191pub struct SwitchStatement<'tree> {
11192 pub span: ::treesitter_types::Span,
11193 pub body: SwitchBody<'tree>,
11194 pub value: SwitchStatementValue<'tree>,
11195}
11196impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
11197 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11198 fn from_node(
11199 node: ::tree_sitter::Node<'tree>,
11200 src: &'tree [u8],
11201 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11202 debug_assert_eq!(node.kind(), "switch_statement");
11203 Ok(Self {
11204 span: ::treesitter_types::Span::from(node),
11205 body: {
11206 let child = node
11207 .child_by_field_name("body")
11208 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11209 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)?
11210 },
11211 value: {
11212 let child = node
11213 .child_by_field_name("value")
11214 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
11215 <SwitchStatementValue as ::treesitter_types::FromNode>::from_node(child, src)?
11216 },
11217 })
11218 }
11219}
11220impl ::treesitter_types::Spanned for SwitchStatement<'_> {
11221 fn span(&self) -> ::treesitter_types::Span {
11222 self.span
11223 }
11224}
11225#[derive(Debug, Clone, PartialEq, Eq)]
11226pub struct ThrowExpression<'tree> {
11227 pub span: ::treesitter_types::Span,
11228 pub children: Expression<'tree>,
11229}
11230impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowExpression<'tree> {
11231 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11232 fn from_node(
11233 node: ::tree_sitter::Node<'tree>,
11234 src: &'tree [u8],
11235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11236 debug_assert_eq!(node.kind(), "throw_expression");
11237 Ok(Self {
11238 span: ::treesitter_types::Span::from(node),
11239 children: {
11240 #[allow(clippy::suspicious_else_formatting)]
11241 let non_field_children = {
11242 let mut cursor = node.walk();
11243 let mut result = ::std::vec::Vec::new();
11244 if cursor.goto_first_child() {
11245 loop {
11246 if cursor.field_name().is_none()
11247 && cursor.node().is_named()
11248 && !cursor.node().is_extra()
11249 {
11250 result.push(cursor.node());
11251 }
11252 if !cursor.goto_next_sibling() {
11253 break;
11254 }
11255 }
11256 }
11257 result
11258 };
11259 let child = if let Some(&c) = non_field_children.first() {
11260 c
11261 } else {
11262 let mut fallback_cursor = node.walk();
11263 let mut fallback_child = None;
11264 if fallback_cursor.goto_first_child() {
11265 loop {
11266 if fallback_cursor.field_name().is_none()
11267 && !fallback_cursor.node().is_extra()
11268 {
11269 let candidate = fallback_cursor.node();
11270 #[allow(clippy::needless_question_mark)]
11271 if (|| -> ::core::result::Result<
11272 _,
11273 ::treesitter_types::ParseError,
11274 > {
11275 let child = candidate;
11276 Ok(
11277 <Expression as ::treesitter_types::FromNode>::from_node(
11278 child,
11279 src,
11280 )?,
11281 )
11282 })()
11283 .is_ok()
11284 {
11285 fallback_child = Some(candidate);
11286 break;
11287 }
11288 }
11289 if !fallback_cursor.goto_next_sibling() {
11290 break;
11291 }
11292 }
11293 }
11294 if fallback_child.is_none() {
11295 let mut cursor2 = node.walk();
11296 if cursor2.goto_first_child() {
11297 loop {
11298 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11299 let candidate = cursor2.node();
11300 #[allow(clippy::needless_question_mark)]
11301 if (|| -> ::core::result::Result<
11302 _,
11303 ::treesitter_types::ParseError,
11304 > {
11305 let child = candidate;
11306 Ok(
11307 <Expression as ::treesitter_types::FromNode>::from_node(
11308 child,
11309 src,
11310 )?,
11311 )
11312 })()
11313 .is_ok()
11314 {
11315 fallback_child = Some(candidate);
11316 break;
11317 }
11318 }
11319 if !cursor2.goto_next_sibling() {
11320 break;
11321 }
11322 }
11323 }
11324 }
11325 fallback_child.ok_or_else(|| {
11326 ::treesitter_types::ParseError::missing_field("children", node)
11327 })?
11328 };
11329 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
11330 },
11331 })
11332 }
11333}
11334impl ::treesitter_types::Spanned for ThrowExpression<'_> {
11335 fn span(&self) -> ::treesitter_types::Span {
11336 self.span
11337 }
11338}
11339#[derive(Debug, Clone, PartialEq, Eq)]
11340pub struct ThrowStatement<'tree> {
11341 pub span: ::treesitter_types::Span,
11342 pub children: ::core::option::Option<Expression<'tree>>,
11343}
11344impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
11345 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11346 fn from_node(
11347 node: ::tree_sitter::Node<'tree>,
11348 src: &'tree [u8],
11349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11350 debug_assert_eq!(node.kind(), "throw_statement");
11351 Ok(Self {
11352 span: ::treesitter_types::Span::from(node),
11353 children: {
11354 #[allow(clippy::suspicious_else_formatting)]
11355 let non_field_children = {
11356 let mut cursor = node.walk();
11357 let mut result = ::std::vec::Vec::new();
11358 if cursor.goto_first_child() {
11359 loop {
11360 if cursor.field_name().is_none()
11361 && cursor.node().is_named()
11362 && !cursor.node().is_extra()
11363 {
11364 result.push(cursor.node());
11365 }
11366 if !cursor.goto_next_sibling() {
11367 break;
11368 }
11369 }
11370 }
11371 result
11372 };
11373 match non_field_children.first() {
11374 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
11375 child, src,
11376 )?),
11377 None => None,
11378 }
11379 },
11380 })
11381 }
11382}
11383impl ::treesitter_types::Spanned for ThrowStatement<'_> {
11384 fn span(&self) -> ::treesitter_types::Span {
11385 self.span
11386 }
11387}
11388#[derive(Debug, Clone, PartialEq, Eq)]
11389pub struct TryStatement<'tree> {
11390 pub span: ::treesitter_types::Span,
11391 pub body: Block<'tree>,
11392 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
11393}
11394impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
11395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11396 fn from_node(
11397 node: ::tree_sitter::Node<'tree>,
11398 src: &'tree [u8],
11399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11400 debug_assert_eq!(node.kind(), "try_statement");
11401 Ok(Self {
11402 span: ::treesitter_types::Span::from(node),
11403 body: {
11404 let child = node
11405 .child_by_field_name("body")
11406 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11407 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
11408 },
11409 children: {
11410 #[allow(clippy::suspicious_else_formatting)]
11411 let non_field_children = {
11412 let mut cursor = node.walk();
11413 let mut result = ::std::vec::Vec::new();
11414 if cursor.goto_first_child() {
11415 loop {
11416 if cursor.field_name().is_none()
11417 && cursor.node().is_named()
11418 && !cursor.node().is_extra()
11419 {
11420 result.push(cursor.node());
11421 }
11422 if !cursor.goto_next_sibling() {
11423 break;
11424 }
11425 }
11426 }
11427 result
11428 };
11429 let mut items = ::std::vec::Vec::new();
11430 for child in non_field_children {
11431 items.push(
11432 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
11433 child, src,
11434 )?,
11435 );
11436 }
11437 items
11438 },
11439 })
11440 }
11441}
11442impl ::treesitter_types::Spanned for TryStatement<'_> {
11443 fn span(&self) -> ::treesitter_types::Span {
11444 self.span
11445 }
11446}
11447#[derive(Debug, Clone, PartialEq, Eq)]
11448pub struct TupleElement<'tree> {
11449 pub span: ::treesitter_types::Span,
11450 pub name: ::core::option::Option<Identifier<'tree>>,
11451 pub r#type: Type<'tree>,
11452}
11453impl<'tree> ::treesitter_types::FromNode<'tree> for TupleElement<'tree> {
11454 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11455 fn from_node(
11456 node: ::tree_sitter::Node<'tree>,
11457 src: &'tree [u8],
11458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11459 debug_assert_eq!(node.kind(), "tuple_element");
11460 Ok(Self {
11461 span: ::treesitter_types::Span::from(node),
11462 name: match node.child_by_field_name("name") {
11463 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
11464 child, src,
11465 )?),
11466 None => None,
11467 },
11468 r#type: {
11469 let child = node
11470 .child_by_field_name("type")
11471 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11472 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
11473 },
11474 })
11475 }
11476}
11477impl ::treesitter_types::Spanned for TupleElement<'_> {
11478 fn span(&self) -> ::treesitter_types::Span {
11479 self.span
11480 }
11481}
11482#[derive(Debug, Clone, PartialEq, Eq)]
11483pub struct TupleExpression<'tree> {
11484 pub span: ::treesitter_types::Span,
11485 pub children: ::std::vec::Vec<Argument<'tree>>,
11486}
11487impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
11488 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11489 fn from_node(
11490 node: ::tree_sitter::Node<'tree>,
11491 src: &'tree [u8],
11492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11493 debug_assert_eq!(node.kind(), "tuple_expression");
11494 Ok(Self {
11495 span: ::treesitter_types::Span::from(node),
11496 children: {
11497 #[allow(clippy::suspicious_else_formatting)]
11498 let non_field_children = {
11499 let mut cursor = node.walk();
11500 let mut result = ::std::vec::Vec::new();
11501 if cursor.goto_first_child() {
11502 loop {
11503 if cursor.field_name().is_none()
11504 && cursor.node().is_named()
11505 && !cursor.node().is_extra()
11506 {
11507 result.push(cursor.node());
11508 }
11509 if !cursor.goto_next_sibling() {
11510 break;
11511 }
11512 }
11513 }
11514 result
11515 };
11516 let mut items = ::std::vec::Vec::new();
11517 for child in non_field_children {
11518 items.push(<Argument as ::treesitter_types::FromNode>::from_node(
11519 child, src,
11520 )?);
11521 }
11522 items
11523 },
11524 })
11525 }
11526}
11527impl ::treesitter_types::Spanned for TupleExpression<'_> {
11528 fn span(&self) -> ::treesitter_types::Span {
11529 self.span
11530 }
11531}
11532#[derive(Debug, Clone, PartialEq, Eq)]
11533pub struct TuplePattern<'tree> {
11534 pub span: ::treesitter_types::Span,
11535 pub name: ::std::vec::Vec<Identifier<'tree>>,
11536 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
11537}
11538impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
11539 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11540 fn from_node(
11541 node: ::tree_sitter::Node<'tree>,
11542 src: &'tree [u8],
11543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11544 debug_assert_eq!(node.kind(), "tuple_pattern");
11545 Ok(Self {
11546 span: ::treesitter_types::Span::from(node),
11547 name: {
11548 let mut cursor = node.walk();
11549 let mut items = ::std::vec::Vec::new();
11550 for child in node.children_by_field_name("name", &mut cursor) {
11551 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
11552 child, src,
11553 )?);
11554 }
11555 items
11556 },
11557 children: {
11558 #[allow(clippy::suspicious_else_formatting)]
11559 let non_field_children = {
11560 let mut cursor = node.walk();
11561 let mut result = ::std::vec::Vec::new();
11562 if cursor.goto_first_child() {
11563 loop {
11564 if cursor.field_name().is_none()
11565 && cursor.node().is_named()
11566 && !cursor.node().is_extra()
11567 {
11568 result.push(cursor.node());
11569 }
11570 if !cursor.goto_next_sibling() {
11571 break;
11572 }
11573 }
11574 }
11575 result
11576 };
11577 let mut items = ::std::vec::Vec::new();
11578 for child in non_field_children {
11579 items.push(
11580 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
11581 child, src,
11582 )?,
11583 );
11584 }
11585 items
11586 },
11587 })
11588 }
11589}
11590impl ::treesitter_types::Spanned for TuplePattern<'_> {
11591 fn span(&self) -> ::treesitter_types::Span {
11592 self.span
11593 }
11594}
11595#[derive(Debug, Clone, PartialEq, Eq)]
11596pub struct TupleType<'tree> {
11597 pub span: ::treesitter_types::Span,
11598 pub children: ::std::vec::Vec<TupleElement<'tree>>,
11599}
11600impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
11601 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11602 fn from_node(
11603 node: ::tree_sitter::Node<'tree>,
11604 src: &'tree [u8],
11605 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11606 debug_assert_eq!(node.kind(), "tuple_type");
11607 Ok(Self {
11608 span: ::treesitter_types::Span::from(node),
11609 children: {
11610 #[allow(clippy::suspicious_else_formatting)]
11611 let non_field_children = {
11612 let mut cursor = node.walk();
11613 let mut result = ::std::vec::Vec::new();
11614 if cursor.goto_first_child() {
11615 loop {
11616 if cursor.field_name().is_none()
11617 && cursor.node().is_named()
11618 && !cursor.node().is_extra()
11619 {
11620 result.push(cursor.node());
11621 }
11622 if !cursor.goto_next_sibling() {
11623 break;
11624 }
11625 }
11626 }
11627 result
11628 };
11629 let mut items = ::std::vec::Vec::new();
11630 for child in non_field_children {
11631 items.push(<TupleElement as ::treesitter_types::FromNode>::from_node(
11632 child, src,
11633 )?);
11634 }
11635 items
11636 },
11637 })
11638 }
11639}
11640impl ::treesitter_types::Spanned for TupleType<'_> {
11641 fn span(&self) -> ::treesitter_types::Span {
11642 self.span
11643 }
11644}
11645#[derive(Debug, Clone, PartialEq, Eq)]
11646pub struct TypeArgumentList<'tree> {
11647 pub span: ::treesitter_types::Span,
11648 pub children: ::std::vec::Vec<Type<'tree>>,
11649}
11650impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentList<'tree> {
11651 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11652 fn from_node(
11653 node: ::tree_sitter::Node<'tree>,
11654 src: &'tree [u8],
11655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11656 debug_assert_eq!(node.kind(), "type_argument_list");
11657 Ok(Self {
11658 span: ::treesitter_types::Span::from(node),
11659 children: {
11660 #[allow(clippy::suspicious_else_formatting)]
11661 let non_field_children = {
11662 let mut cursor = node.walk();
11663 let mut result = ::std::vec::Vec::new();
11664 if cursor.goto_first_child() {
11665 loop {
11666 if cursor.field_name().is_none()
11667 && cursor.node().is_named()
11668 && !cursor.node().is_extra()
11669 {
11670 result.push(cursor.node());
11671 }
11672 if !cursor.goto_next_sibling() {
11673 break;
11674 }
11675 }
11676 }
11677 result
11678 };
11679 let mut items = ::std::vec::Vec::new();
11680 for child in non_field_children {
11681 items.push(<Type as ::treesitter_types::FromNode>::from_node(
11682 child, src,
11683 )?);
11684 }
11685 items
11686 },
11687 })
11688 }
11689}
11690impl ::treesitter_types::Spanned for TypeArgumentList<'_> {
11691 fn span(&self) -> ::treesitter_types::Span {
11692 self.span
11693 }
11694}
11695#[derive(Debug, Clone, PartialEq, Eq)]
11696pub struct TypeParameter<'tree> {
11697 pub span: ::treesitter_types::Span,
11698 pub name: Identifier<'tree>,
11699 pub children: ::std::vec::Vec<AttributeList<'tree>>,
11700}
11701impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
11702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11703 fn from_node(
11704 node: ::tree_sitter::Node<'tree>,
11705 src: &'tree [u8],
11706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11707 debug_assert_eq!(node.kind(), "type_parameter");
11708 Ok(Self {
11709 span: ::treesitter_types::Span::from(node),
11710 name: {
11711 let child = node
11712 .child_by_field_name("name")
11713 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
11714 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
11715 },
11716 children: {
11717 #[allow(clippy::suspicious_else_formatting)]
11718 let non_field_children = {
11719 let mut cursor = node.walk();
11720 let mut result = ::std::vec::Vec::new();
11721 if cursor.goto_first_child() {
11722 loop {
11723 if cursor.field_name().is_none()
11724 && cursor.node().is_named()
11725 && !cursor.node().is_extra()
11726 {
11727 result.push(cursor.node());
11728 }
11729 if !cursor.goto_next_sibling() {
11730 break;
11731 }
11732 }
11733 }
11734 result
11735 };
11736 let mut items = ::std::vec::Vec::new();
11737 for child in non_field_children {
11738 items.push(<AttributeList as ::treesitter_types::FromNode>::from_node(
11739 child, src,
11740 )?);
11741 }
11742 items
11743 },
11744 })
11745 }
11746}
11747impl ::treesitter_types::Spanned for TypeParameter<'_> {
11748 fn span(&self) -> ::treesitter_types::Span {
11749 self.span
11750 }
11751}
11752#[derive(Debug, Clone, PartialEq, Eq)]
11753pub struct TypeParameterConstraint<'tree> {
11754 pub span: ::treesitter_types::Span,
11755 pub r#type: ::core::option::Option<Type<'tree>>,
11756 pub children: ::core::option::Option<ConstructorConstraint<'tree>>,
11757}
11758impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraint<'tree> {
11759 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11760 fn from_node(
11761 node: ::tree_sitter::Node<'tree>,
11762 src: &'tree [u8],
11763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11764 debug_assert_eq!(node.kind(), "type_parameter_constraint");
11765 Ok(Self {
11766 span: ::treesitter_types::Span::from(node),
11767 r#type: match node.child_by_field_name("type") {
11768 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
11769 child, src,
11770 )?),
11771 None => None,
11772 },
11773 children: {
11774 #[allow(clippy::suspicious_else_formatting)]
11775 let non_field_children = {
11776 let mut cursor = node.walk();
11777 let mut result = ::std::vec::Vec::new();
11778 if cursor.goto_first_child() {
11779 loop {
11780 if cursor.field_name().is_none()
11781 && cursor.node().is_named()
11782 && !cursor.node().is_extra()
11783 {
11784 result.push(cursor.node());
11785 }
11786 if !cursor.goto_next_sibling() {
11787 break;
11788 }
11789 }
11790 }
11791 result
11792 };
11793 match non_field_children.first() {
11794 Some(&child) => Some(
11795 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(
11796 child, src,
11797 )?,
11798 ),
11799 None => None,
11800 }
11801 },
11802 })
11803 }
11804}
11805impl ::treesitter_types::Spanned for TypeParameterConstraint<'_> {
11806 fn span(&self) -> ::treesitter_types::Span {
11807 self.span
11808 }
11809}
11810#[derive(Debug, Clone, PartialEq, Eq)]
11811pub struct TypeParameterConstraintsClause<'tree> {
11812 pub span: ::treesitter_types::Span,
11813 pub children: ::std::vec::Vec<TypeParameterConstraintsClauseChildren<'tree>>,
11814}
11815impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClause<'tree> {
11816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11817 fn from_node(
11818 node: ::tree_sitter::Node<'tree>,
11819 src: &'tree [u8],
11820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11821 debug_assert_eq!(node.kind(), "type_parameter_constraints_clause");
11822 Ok(Self {
11823 span: ::treesitter_types::Span::from(node),
11824 children: {
11825 #[allow(clippy::suspicious_else_formatting)]
11826 let non_field_children = {
11827 let mut cursor = node.walk();
11828 let mut result = ::std::vec::Vec::new();
11829 if cursor.goto_first_child() {
11830 loop {
11831 if cursor.field_name().is_none()
11832 && cursor.node().is_named()
11833 && !cursor.node().is_extra()
11834 {
11835 result.push(cursor.node());
11836 }
11837 if !cursor.goto_next_sibling() {
11838 break;
11839 }
11840 }
11841 }
11842 result
11843 };
11844 let mut items = ::std::vec::Vec::new();
11845 for child in non_field_children {
11846 items
11847 .push(
11848 <TypeParameterConstraintsClauseChildren as ::treesitter_types::FromNode>::from_node(
11849 child,
11850 src,
11851 )?,
11852 );
11853 }
11854 items
11855 },
11856 })
11857 }
11858}
11859impl ::treesitter_types::Spanned for TypeParameterConstraintsClause<'_> {
11860 fn span(&self) -> ::treesitter_types::Span {
11861 self.span
11862 }
11863}
11864#[derive(Debug, Clone, PartialEq, Eq)]
11865pub struct TypeParameterList<'tree> {
11866 pub span: ::treesitter_types::Span,
11867 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
11868}
11869impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterList<'tree> {
11870 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11871 fn from_node(
11872 node: ::tree_sitter::Node<'tree>,
11873 src: &'tree [u8],
11874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11875 debug_assert_eq!(node.kind(), "type_parameter_list");
11876 Ok(Self {
11877 span: ::treesitter_types::Span::from(node),
11878 children: {
11879 #[allow(clippy::suspicious_else_formatting)]
11880 let non_field_children = {
11881 let mut cursor = node.walk();
11882 let mut result = ::std::vec::Vec::new();
11883 if cursor.goto_first_child() {
11884 loop {
11885 if cursor.field_name().is_none()
11886 && cursor.node().is_named()
11887 && !cursor.node().is_extra()
11888 {
11889 result.push(cursor.node());
11890 }
11891 if !cursor.goto_next_sibling() {
11892 break;
11893 }
11894 }
11895 }
11896 result
11897 };
11898 let mut items = ::std::vec::Vec::new();
11899 for child in non_field_children {
11900 items.push(<TypeParameter as ::treesitter_types::FromNode>::from_node(
11901 child, src,
11902 )?);
11903 }
11904 items
11905 },
11906 })
11907 }
11908}
11909impl ::treesitter_types::Spanned for TypeParameterList<'_> {
11910 fn span(&self) -> ::treesitter_types::Span {
11911 self.span
11912 }
11913}
11914#[derive(Debug, Clone, PartialEq, Eq)]
11915pub struct TypePattern<'tree> {
11916 pub span: ::treesitter_types::Span,
11917 pub r#type: Type<'tree>,
11918}
11919impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
11920 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11921 fn from_node(
11922 node: ::tree_sitter::Node<'tree>,
11923 src: &'tree [u8],
11924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11925 debug_assert_eq!(node.kind(), "type_pattern");
11926 Ok(Self {
11927 span: ::treesitter_types::Span::from(node),
11928 r#type: {
11929 let child = node
11930 .child_by_field_name("type")
11931 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11932 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
11933 },
11934 })
11935 }
11936}
11937impl ::treesitter_types::Spanned for TypePattern<'_> {
11938 fn span(&self) -> ::treesitter_types::Span {
11939 self.span
11940 }
11941}
11942#[derive(Debug, Clone, PartialEq, Eq)]
11943pub struct TypeofExpression<'tree> {
11944 pub span: ::treesitter_types::Span,
11945 pub r#type: Type<'tree>,
11946}
11947impl<'tree> ::treesitter_types::FromNode<'tree> for TypeofExpression<'tree> {
11948 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11949 fn from_node(
11950 node: ::tree_sitter::Node<'tree>,
11951 src: &'tree [u8],
11952 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11953 debug_assert_eq!(node.kind(), "typeof_expression");
11954 Ok(Self {
11955 span: ::treesitter_types::Span::from(node),
11956 r#type: {
11957 let child = node
11958 .child_by_field_name("type")
11959 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11960 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
11961 },
11962 })
11963 }
11964}
11965impl ::treesitter_types::Spanned for TypeofExpression<'_> {
11966 fn span(&self) -> ::treesitter_types::Span {
11967 self.span
11968 }
11969}
11970#[derive(Debug, Clone, PartialEq, Eq)]
11971pub struct UnaryExpression<'tree> {
11972 pub span: ::treesitter_types::Span,
11973 pub argument: UnaryExpressionArgument<'tree>,
11974 pub operator: UnaryExpressionOperator,
11975}
11976impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
11977 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11978 fn from_node(
11979 node: ::tree_sitter::Node<'tree>,
11980 src: &'tree [u8],
11981 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11982 debug_assert_eq!(node.kind(), "unary_expression");
11983 Ok(Self {
11984 span: ::treesitter_types::Span::from(node),
11985 argument: {
11986 let child = node.child_by_field_name("argument").ok_or_else(|| {
11987 ::treesitter_types::ParseError::missing_field("argument", node)
11988 })?;
11989 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)?
11990 },
11991 operator: {
11992 let child = node.child_by_field_name("operator").ok_or_else(|| {
11993 ::treesitter_types::ParseError::missing_field("operator", node)
11994 })?;
11995 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
11996 },
11997 })
11998 }
11999}
12000impl ::treesitter_types::Spanned for UnaryExpression<'_> {
12001 fn span(&self) -> ::treesitter_types::Span {
12002 self.span
12003 }
12004}
12005#[derive(Debug, Clone, PartialEq, Eq)]
12006pub struct UnsafeStatement<'tree> {
12007 pub span: ::treesitter_types::Span,
12008 pub children: Block<'tree>,
12009}
12010impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeStatement<'tree> {
12011 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12012 fn from_node(
12013 node: ::tree_sitter::Node<'tree>,
12014 src: &'tree [u8],
12015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12016 debug_assert_eq!(node.kind(), "unsafe_statement");
12017 Ok(Self {
12018 span: ::treesitter_types::Span::from(node),
12019 children: {
12020 #[allow(clippy::suspicious_else_formatting)]
12021 let non_field_children = {
12022 let mut cursor = node.walk();
12023 let mut result = ::std::vec::Vec::new();
12024 if cursor.goto_first_child() {
12025 loop {
12026 if cursor.field_name().is_none()
12027 && cursor.node().is_named()
12028 && !cursor.node().is_extra()
12029 {
12030 result.push(cursor.node());
12031 }
12032 if !cursor.goto_next_sibling() {
12033 break;
12034 }
12035 }
12036 }
12037 result
12038 };
12039 let child = if let Some(&c) = non_field_children.first() {
12040 c
12041 } else {
12042 let mut fallback_cursor = node.walk();
12043 let mut fallback_child = None;
12044 if fallback_cursor.goto_first_child() {
12045 loop {
12046 if fallback_cursor.field_name().is_none()
12047 && !fallback_cursor.node().is_extra()
12048 {
12049 let candidate = fallback_cursor.node();
12050 #[allow(clippy::needless_question_mark)]
12051 if (|| -> ::core::result::Result<
12052 _,
12053 ::treesitter_types::ParseError,
12054 > {
12055 let child = candidate;
12056 Ok(
12057 <Block as ::treesitter_types::FromNode>::from_node(
12058 child,
12059 src,
12060 )?,
12061 )
12062 })()
12063 .is_ok()
12064 {
12065 fallback_child = Some(candidate);
12066 break;
12067 }
12068 }
12069 if !fallback_cursor.goto_next_sibling() {
12070 break;
12071 }
12072 }
12073 }
12074 if fallback_child.is_none() {
12075 let mut cursor2 = node.walk();
12076 if cursor2.goto_first_child() {
12077 loop {
12078 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12079 let candidate = cursor2.node();
12080 #[allow(clippy::needless_question_mark)]
12081 if (|| -> ::core::result::Result<
12082 _,
12083 ::treesitter_types::ParseError,
12084 > {
12085 let child = candidate;
12086 Ok(
12087 <Block as ::treesitter_types::FromNode>::from_node(
12088 child,
12089 src,
12090 )?,
12091 )
12092 })()
12093 .is_ok()
12094 {
12095 fallback_child = Some(candidate);
12096 break;
12097 }
12098 }
12099 if !cursor2.goto_next_sibling() {
12100 break;
12101 }
12102 }
12103 }
12104 }
12105 fallback_child.ok_or_else(|| {
12106 ::treesitter_types::ParseError::missing_field("children", node)
12107 })?
12108 };
12109 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
12110 },
12111 })
12112 }
12113}
12114impl ::treesitter_types::Spanned for UnsafeStatement<'_> {
12115 fn span(&self) -> ::treesitter_types::Span {
12116 self.span
12117 }
12118}
12119#[derive(Debug, Clone, PartialEq, Eq)]
12120pub struct UsingDirective<'tree> {
12121 pub span: ::treesitter_types::Span,
12122 pub name: ::core::option::Option<Identifier<'tree>>,
12123 pub children: Type<'tree>,
12124}
12125impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDirective<'tree> {
12126 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12127 fn from_node(
12128 node: ::tree_sitter::Node<'tree>,
12129 src: &'tree [u8],
12130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12131 debug_assert_eq!(node.kind(), "using_directive");
12132 Ok(Self {
12133 span: ::treesitter_types::Span::from(node),
12134 name: match node.child_by_field_name("name") {
12135 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
12136 child, src,
12137 )?),
12138 None => None,
12139 },
12140 children: {
12141 #[allow(clippy::suspicious_else_formatting)]
12142 let non_field_children = {
12143 let mut cursor = node.walk();
12144 let mut result = ::std::vec::Vec::new();
12145 if cursor.goto_first_child() {
12146 loop {
12147 if cursor.field_name().is_none()
12148 && cursor.node().is_named()
12149 && !cursor.node().is_extra()
12150 {
12151 result.push(cursor.node());
12152 }
12153 if !cursor.goto_next_sibling() {
12154 break;
12155 }
12156 }
12157 }
12158 result
12159 };
12160 let child = if let Some(&c) = non_field_children.first() {
12161 c
12162 } else {
12163 let mut fallback_cursor = node.walk();
12164 let mut fallback_child = None;
12165 if fallback_cursor.goto_first_child() {
12166 loop {
12167 if fallback_cursor.field_name().is_none()
12168 && !fallback_cursor.node().is_extra()
12169 {
12170 let candidate = fallback_cursor.node();
12171 #[allow(clippy::needless_question_mark)]
12172 if (|| -> ::core::result::Result<
12173 _,
12174 ::treesitter_types::ParseError,
12175 > {
12176 let child = candidate;
12177 Ok(
12178 <Type as ::treesitter_types::FromNode>::from_node(
12179 child,
12180 src,
12181 )?,
12182 )
12183 })()
12184 .is_ok()
12185 {
12186 fallback_child = Some(candidate);
12187 break;
12188 }
12189 }
12190 if !fallback_cursor.goto_next_sibling() {
12191 break;
12192 }
12193 }
12194 }
12195 if fallback_child.is_none() {
12196 let mut cursor2 = node.walk();
12197 if cursor2.goto_first_child() {
12198 loop {
12199 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12200 let candidate = cursor2.node();
12201 #[allow(clippy::needless_question_mark)]
12202 if (|| -> ::core::result::Result<
12203 _,
12204 ::treesitter_types::ParseError,
12205 > {
12206 let child = candidate;
12207 Ok(
12208 <Type as ::treesitter_types::FromNode>::from_node(
12209 child,
12210 src,
12211 )?,
12212 )
12213 })()
12214 .is_ok()
12215 {
12216 fallback_child = Some(candidate);
12217 break;
12218 }
12219 }
12220 if !cursor2.goto_next_sibling() {
12221 break;
12222 }
12223 }
12224 }
12225 }
12226 fallback_child.ok_or_else(|| {
12227 ::treesitter_types::ParseError::missing_field("children", node)
12228 })?
12229 };
12230 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
12231 },
12232 })
12233 }
12234}
12235impl ::treesitter_types::Spanned for UsingDirective<'_> {
12236 fn span(&self) -> ::treesitter_types::Span {
12237 self.span
12238 }
12239}
12240#[derive(Debug, Clone, PartialEq, Eq)]
12241pub struct UsingStatement<'tree> {
12242 pub span: ::treesitter_types::Span,
12243 pub body: Statement<'tree>,
12244 pub children: UsingStatementChildren<'tree>,
12245}
12246impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatement<'tree> {
12247 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12248 fn from_node(
12249 node: ::tree_sitter::Node<'tree>,
12250 src: &'tree [u8],
12251 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12252 debug_assert_eq!(node.kind(), "using_statement");
12253 Ok(Self {
12254 span: ::treesitter_types::Span::from(node),
12255 body: {
12256 let child = node
12257 .child_by_field_name("body")
12258 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
12259 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
12260 },
12261 children: {
12262 #[allow(clippy::suspicious_else_formatting)]
12263 let non_field_children = {
12264 let mut cursor = node.walk();
12265 let mut result = ::std::vec::Vec::new();
12266 if cursor.goto_first_child() {
12267 loop {
12268 if cursor.field_name().is_none()
12269 && cursor.node().is_named()
12270 && !cursor.node().is_extra()
12271 {
12272 result.push(cursor.node());
12273 }
12274 if !cursor.goto_next_sibling() {
12275 break;
12276 }
12277 }
12278 }
12279 result
12280 };
12281 let child = if let Some(&c) = non_field_children.first() {
12282 c
12283 } else {
12284 let mut fallback_cursor = node.walk();
12285 let mut fallback_child = None;
12286 if fallback_cursor.goto_first_child() {
12287 loop {
12288 if fallback_cursor.field_name().is_none()
12289 && !fallback_cursor.node().is_extra()
12290 {
12291 let candidate = fallback_cursor.node();
12292 #[allow(clippy::needless_question_mark)]
12293 if (|| -> ::core::result::Result<
12294 _,
12295 ::treesitter_types::ParseError,
12296 > {
12297 let child = candidate;
12298 Ok(
12299 <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
12300 child,
12301 src,
12302 )?,
12303 )
12304 })()
12305 .is_ok()
12306 {
12307 fallback_child = Some(candidate);
12308 break;
12309 }
12310 }
12311 if !fallback_cursor.goto_next_sibling() {
12312 break;
12313 }
12314 }
12315 }
12316 if fallback_child.is_none() {
12317 let mut cursor2 = node.walk();
12318 if cursor2.goto_first_child() {
12319 loop {
12320 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12321 let candidate = cursor2.node();
12322 #[allow(clippy::needless_question_mark)]
12323 if (|| -> ::core::result::Result<
12324 _,
12325 ::treesitter_types::ParseError,
12326 > {
12327 let child = candidate;
12328 Ok(
12329 <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
12330 child,
12331 src,
12332 )?,
12333 )
12334 })()
12335 .is_ok()
12336 {
12337 fallback_child = Some(candidate);
12338 break;
12339 }
12340 }
12341 if !cursor2.goto_next_sibling() {
12342 break;
12343 }
12344 }
12345 }
12346 }
12347 fallback_child.ok_or_else(|| {
12348 ::treesitter_types::ParseError::missing_field("children", node)
12349 })?
12350 };
12351 <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
12352 },
12353 })
12354 }
12355}
12356impl ::treesitter_types::Spanned for UsingStatement<'_> {
12357 fn span(&self) -> ::treesitter_types::Span {
12358 self.span
12359 }
12360}
12361#[derive(Debug, Clone, PartialEq, Eq)]
12362pub struct VarPattern<'tree> {
12363 pub span: ::treesitter_types::Span,
12364 pub name: ::core::option::Option<Identifier<'tree>>,
12365 pub children: ::core::option::Option<VarPatternChildren<'tree>>,
12366}
12367impl<'tree> ::treesitter_types::FromNode<'tree> for VarPattern<'tree> {
12368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12369 fn from_node(
12370 node: ::tree_sitter::Node<'tree>,
12371 src: &'tree [u8],
12372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12373 debug_assert_eq!(node.kind(), "var_pattern");
12374 Ok(Self {
12375 span: ::treesitter_types::Span::from(node),
12376 name: match node.child_by_field_name("name") {
12377 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
12378 child, src,
12379 )?),
12380 None => None,
12381 },
12382 children: {
12383 #[allow(clippy::suspicious_else_formatting)]
12384 let non_field_children = {
12385 let mut cursor = node.walk();
12386 let mut result = ::std::vec::Vec::new();
12387 if cursor.goto_first_child() {
12388 loop {
12389 if cursor.field_name().is_none()
12390 && cursor.node().is_named()
12391 && !cursor.node().is_extra()
12392 {
12393 result.push(cursor.node());
12394 }
12395 if !cursor.goto_next_sibling() {
12396 break;
12397 }
12398 }
12399 }
12400 result
12401 };
12402 match non_field_children.first() {
12403 Some(&child) => Some(
12404 <VarPatternChildren as ::treesitter_types::FromNode>::from_node(
12405 child, src,
12406 )?,
12407 ),
12408 None => None,
12409 }
12410 },
12411 })
12412 }
12413}
12414impl ::treesitter_types::Spanned for VarPattern<'_> {
12415 fn span(&self) -> ::treesitter_types::Span {
12416 self.span
12417 }
12418}
12419#[derive(Debug, Clone, PartialEq, Eq)]
12420pub struct VariableDeclaration<'tree> {
12421 pub span: ::treesitter_types::Span,
12422 pub r#type: Type<'tree>,
12423 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
12424}
12425impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
12426 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12427 fn from_node(
12428 node: ::tree_sitter::Node<'tree>,
12429 src: &'tree [u8],
12430 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12431 debug_assert_eq!(node.kind(), "variable_declaration");
12432 Ok(Self {
12433 span: ::treesitter_types::Span::from(node),
12434 r#type: {
12435 let child = node
12436 .child_by_field_name("type")
12437 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12438 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
12439 },
12440 children: {
12441 #[allow(clippy::suspicious_else_formatting)]
12442 let non_field_children = {
12443 let mut cursor = node.walk();
12444 let mut result = ::std::vec::Vec::new();
12445 if cursor.goto_first_child() {
12446 loop {
12447 if cursor.field_name().is_none()
12448 && cursor.node().is_named()
12449 && !cursor.node().is_extra()
12450 {
12451 result.push(cursor.node());
12452 }
12453 if !cursor.goto_next_sibling() {
12454 break;
12455 }
12456 }
12457 }
12458 result
12459 };
12460 let mut items = ::std::vec::Vec::new();
12461 for child in non_field_children {
12462 items.push(
12463 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
12464 child, src,
12465 )?,
12466 );
12467 }
12468 items
12469 },
12470 })
12471 }
12472}
12473impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
12474 fn span(&self) -> ::treesitter_types::Span {
12475 self.span
12476 }
12477}
12478#[derive(Debug, Clone, PartialEq, Eq)]
12479pub struct VariableDeclarator<'tree> {
12480 pub span: ::treesitter_types::Span,
12481 pub name: ::core::option::Option<Identifier<'tree>>,
12482 pub children: ::std::vec::Vec<VariableDeclaratorChildren<'tree>>,
12483}
12484impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
12485 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12486 fn from_node(
12487 node: ::tree_sitter::Node<'tree>,
12488 src: &'tree [u8],
12489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12490 debug_assert_eq!(node.kind(), "variable_declarator");
12491 Ok(Self {
12492 span: ::treesitter_types::Span::from(node),
12493 name: match node.child_by_field_name("name") {
12494 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
12495 child, src,
12496 )?),
12497 None => None,
12498 },
12499 children: {
12500 #[allow(clippy::suspicious_else_formatting)]
12501 let non_field_children = {
12502 let mut cursor = node.walk();
12503 let mut result = ::std::vec::Vec::new();
12504 if cursor.goto_first_child() {
12505 loop {
12506 if cursor.field_name().is_none()
12507 && cursor.node().is_named()
12508 && !cursor.node().is_extra()
12509 {
12510 result.push(cursor.node());
12511 }
12512 if !cursor.goto_next_sibling() {
12513 break;
12514 }
12515 }
12516 }
12517 result
12518 };
12519 let mut items = ::std::vec::Vec::new();
12520 for child in non_field_children {
12521 items.push(
12522 <VariableDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
12523 child, src,
12524 )?,
12525 );
12526 }
12527 items
12528 },
12529 })
12530 }
12531}
12532impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
12533 fn span(&self) -> ::treesitter_types::Span {
12534 self.span
12535 }
12536}
12537#[derive(Debug, Clone, PartialEq, Eq)]
12538pub struct WhenClause<'tree> {
12539 pub span: ::treesitter_types::Span,
12540 pub children: Expression<'tree>,
12541}
12542impl<'tree> ::treesitter_types::FromNode<'tree> for WhenClause<'tree> {
12543 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12544 fn from_node(
12545 node: ::tree_sitter::Node<'tree>,
12546 src: &'tree [u8],
12547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12548 debug_assert_eq!(node.kind(), "when_clause");
12549 Ok(Self {
12550 span: ::treesitter_types::Span::from(node),
12551 children: {
12552 #[allow(clippy::suspicious_else_formatting)]
12553 let non_field_children = {
12554 let mut cursor = node.walk();
12555 let mut result = ::std::vec::Vec::new();
12556 if cursor.goto_first_child() {
12557 loop {
12558 if cursor.field_name().is_none()
12559 && cursor.node().is_named()
12560 && !cursor.node().is_extra()
12561 {
12562 result.push(cursor.node());
12563 }
12564 if !cursor.goto_next_sibling() {
12565 break;
12566 }
12567 }
12568 }
12569 result
12570 };
12571 let child = if let Some(&c) = non_field_children.first() {
12572 c
12573 } else {
12574 let mut fallback_cursor = node.walk();
12575 let mut fallback_child = None;
12576 if fallback_cursor.goto_first_child() {
12577 loop {
12578 if fallback_cursor.field_name().is_none()
12579 && !fallback_cursor.node().is_extra()
12580 {
12581 let candidate = fallback_cursor.node();
12582 #[allow(clippy::needless_question_mark)]
12583 if (|| -> ::core::result::Result<
12584 _,
12585 ::treesitter_types::ParseError,
12586 > {
12587 let child = candidate;
12588 Ok(
12589 <Expression as ::treesitter_types::FromNode>::from_node(
12590 child,
12591 src,
12592 )?,
12593 )
12594 })()
12595 .is_ok()
12596 {
12597 fallback_child = Some(candidate);
12598 break;
12599 }
12600 }
12601 if !fallback_cursor.goto_next_sibling() {
12602 break;
12603 }
12604 }
12605 }
12606 if fallback_child.is_none() {
12607 let mut cursor2 = node.walk();
12608 if cursor2.goto_first_child() {
12609 loop {
12610 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12611 let candidate = cursor2.node();
12612 #[allow(clippy::needless_question_mark)]
12613 if (|| -> ::core::result::Result<
12614 _,
12615 ::treesitter_types::ParseError,
12616 > {
12617 let child = candidate;
12618 Ok(
12619 <Expression as ::treesitter_types::FromNode>::from_node(
12620 child,
12621 src,
12622 )?,
12623 )
12624 })()
12625 .is_ok()
12626 {
12627 fallback_child = Some(candidate);
12628 break;
12629 }
12630 }
12631 if !cursor2.goto_next_sibling() {
12632 break;
12633 }
12634 }
12635 }
12636 }
12637 fallback_child.ok_or_else(|| {
12638 ::treesitter_types::ParseError::missing_field("children", node)
12639 })?
12640 };
12641 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
12642 },
12643 })
12644 }
12645}
12646impl ::treesitter_types::Spanned for WhenClause<'_> {
12647 fn span(&self) -> ::treesitter_types::Span {
12648 self.span
12649 }
12650}
12651#[derive(Debug, Clone, PartialEq, Eq)]
12652pub struct WhereClause<'tree> {
12653 pub span: ::treesitter_types::Span,
12654 pub children: Expression<'tree>,
12655}
12656impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
12657 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12658 fn from_node(
12659 node: ::tree_sitter::Node<'tree>,
12660 src: &'tree [u8],
12661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12662 debug_assert_eq!(node.kind(), "where_clause");
12663 Ok(Self {
12664 span: ::treesitter_types::Span::from(node),
12665 children: {
12666 #[allow(clippy::suspicious_else_formatting)]
12667 let non_field_children = {
12668 let mut cursor = node.walk();
12669 let mut result = ::std::vec::Vec::new();
12670 if cursor.goto_first_child() {
12671 loop {
12672 if cursor.field_name().is_none()
12673 && cursor.node().is_named()
12674 && !cursor.node().is_extra()
12675 {
12676 result.push(cursor.node());
12677 }
12678 if !cursor.goto_next_sibling() {
12679 break;
12680 }
12681 }
12682 }
12683 result
12684 };
12685 let child = if let Some(&c) = non_field_children.first() {
12686 c
12687 } else {
12688 let mut fallback_cursor = node.walk();
12689 let mut fallback_child = None;
12690 if fallback_cursor.goto_first_child() {
12691 loop {
12692 if fallback_cursor.field_name().is_none()
12693 && !fallback_cursor.node().is_extra()
12694 {
12695 let candidate = fallback_cursor.node();
12696 #[allow(clippy::needless_question_mark)]
12697 if (|| -> ::core::result::Result<
12698 _,
12699 ::treesitter_types::ParseError,
12700 > {
12701 let child = candidate;
12702 Ok(
12703 <Expression as ::treesitter_types::FromNode>::from_node(
12704 child,
12705 src,
12706 )?,
12707 )
12708 })()
12709 .is_ok()
12710 {
12711 fallback_child = Some(candidate);
12712 break;
12713 }
12714 }
12715 if !fallback_cursor.goto_next_sibling() {
12716 break;
12717 }
12718 }
12719 }
12720 if fallback_child.is_none() {
12721 let mut cursor2 = node.walk();
12722 if cursor2.goto_first_child() {
12723 loop {
12724 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12725 let candidate = cursor2.node();
12726 #[allow(clippy::needless_question_mark)]
12727 if (|| -> ::core::result::Result<
12728 _,
12729 ::treesitter_types::ParseError,
12730 > {
12731 let child = candidate;
12732 Ok(
12733 <Expression as ::treesitter_types::FromNode>::from_node(
12734 child,
12735 src,
12736 )?,
12737 )
12738 })()
12739 .is_ok()
12740 {
12741 fallback_child = Some(candidate);
12742 break;
12743 }
12744 }
12745 if !cursor2.goto_next_sibling() {
12746 break;
12747 }
12748 }
12749 }
12750 }
12751 fallback_child.ok_or_else(|| {
12752 ::treesitter_types::ParseError::missing_field("children", node)
12753 })?
12754 };
12755 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
12756 },
12757 })
12758 }
12759}
12760impl ::treesitter_types::Spanned for WhereClause<'_> {
12761 fn span(&self) -> ::treesitter_types::Span {
12762 self.span
12763 }
12764}
12765#[derive(Debug, Clone, PartialEq, Eq)]
12766pub struct WhileStatement<'tree> {
12767 pub span: ::treesitter_types::Span,
12768 pub body: Statement<'tree>,
12769 pub condition: Expression<'tree>,
12770}
12771impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
12772 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12773 fn from_node(
12774 node: ::tree_sitter::Node<'tree>,
12775 src: &'tree [u8],
12776 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12777 debug_assert_eq!(node.kind(), "while_statement");
12778 Ok(Self {
12779 span: ::treesitter_types::Span::from(node),
12780 body: {
12781 let child = node
12782 .child_by_field_name("body")
12783 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
12784 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
12785 },
12786 condition: {
12787 let child = node.child_by_field_name("condition").ok_or_else(|| {
12788 ::treesitter_types::ParseError::missing_field("condition", node)
12789 })?;
12790 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
12791 },
12792 })
12793 }
12794}
12795impl ::treesitter_types::Spanned for WhileStatement<'_> {
12796 fn span(&self) -> ::treesitter_types::Span {
12797 self.span
12798 }
12799}
12800#[derive(Debug, Clone, PartialEq, Eq)]
12801pub struct WithExpression<'tree> {
12802 pub span: ::treesitter_types::Span,
12803 pub children: ::std::vec::Vec<WithExpressionChildren<'tree>>,
12804}
12805impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpression<'tree> {
12806 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12807 fn from_node(
12808 node: ::tree_sitter::Node<'tree>,
12809 src: &'tree [u8],
12810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12811 debug_assert_eq!(node.kind(), "with_expression");
12812 Ok(Self {
12813 span: ::treesitter_types::Span::from(node),
12814 children: {
12815 #[allow(clippy::suspicious_else_formatting)]
12816 let non_field_children = {
12817 let mut cursor = node.walk();
12818 let mut result = ::std::vec::Vec::new();
12819 if cursor.goto_first_child() {
12820 loop {
12821 if cursor.field_name().is_none()
12822 && cursor.node().is_named()
12823 && !cursor.node().is_extra()
12824 {
12825 result.push(cursor.node());
12826 }
12827 if !cursor.goto_next_sibling() {
12828 break;
12829 }
12830 }
12831 }
12832 result
12833 };
12834 let mut items = ::std::vec::Vec::new();
12835 for child in non_field_children {
12836 items.push(
12837 <WithExpressionChildren as ::treesitter_types::FromNode>::from_node(
12838 child, src,
12839 )?,
12840 );
12841 }
12842 items
12843 },
12844 })
12845 }
12846}
12847impl ::treesitter_types::Spanned for WithExpression<'_> {
12848 fn span(&self) -> ::treesitter_types::Span {
12849 self.span
12850 }
12851}
12852#[derive(Debug, Clone, PartialEq, Eq)]
12853pub struct WithInitializer<'tree> {
12854 pub span: ::treesitter_types::Span,
12855 pub children: ::std::vec::Vec<WithInitializerChildren<'tree>>,
12856}
12857impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializer<'tree> {
12858 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12859 fn from_node(
12860 node: ::tree_sitter::Node<'tree>,
12861 src: &'tree [u8],
12862 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12863 debug_assert_eq!(node.kind(), "with_initializer");
12864 Ok(Self {
12865 span: ::treesitter_types::Span::from(node),
12866 children: {
12867 #[allow(clippy::suspicious_else_formatting)]
12868 let non_field_children = {
12869 let mut cursor = node.walk();
12870 let mut result = ::std::vec::Vec::new();
12871 if cursor.goto_first_child() {
12872 loop {
12873 if cursor.field_name().is_none()
12874 && cursor.node().is_named()
12875 && !cursor.node().is_extra()
12876 {
12877 result.push(cursor.node());
12878 }
12879 if !cursor.goto_next_sibling() {
12880 break;
12881 }
12882 }
12883 }
12884 result
12885 };
12886 let mut items = ::std::vec::Vec::new();
12887 for child in non_field_children {
12888 items.push(
12889 <WithInitializerChildren as ::treesitter_types::FromNode>::from_node(
12890 child, src,
12891 )?,
12892 );
12893 }
12894 items
12895 },
12896 })
12897 }
12898}
12899impl ::treesitter_types::Spanned for WithInitializer<'_> {
12900 fn span(&self) -> ::treesitter_types::Span {
12901 self.span
12902 }
12903}
12904#[derive(Debug, Clone, PartialEq, Eq)]
12905pub struct YieldStatement<'tree> {
12906 pub span: ::treesitter_types::Span,
12907 pub children: ::core::option::Option<Expression<'tree>>,
12908}
12909impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
12910 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12911 fn from_node(
12912 node: ::tree_sitter::Node<'tree>,
12913 src: &'tree [u8],
12914 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12915 debug_assert_eq!(node.kind(), "yield_statement");
12916 Ok(Self {
12917 span: ::treesitter_types::Span::from(node),
12918 children: {
12919 #[allow(clippy::suspicious_else_formatting)]
12920 let non_field_children = {
12921 let mut cursor = node.walk();
12922 let mut result = ::std::vec::Vec::new();
12923 if cursor.goto_first_child() {
12924 loop {
12925 if cursor.field_name().is_none()
12926 && cursor.node().is_named()
12927 && !cursor.node().is_extra()
12928 {
12929 result.push(cursor.node());
12930 }
12931 if !cursor.goto_next_sibling() {
12932 break;
12933 }
12934 }
12935 }
12936 result
12937 };
12938 match non_field_children.first() {
12939 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
12940 child, src,
12941 )?),
12942 None => None,
12943 }
12944 },
12945 })
12946 }
12947}
12948impl ::treesitter_types::Spanned for YieldStatement<'_> {
12949 fn span(&self) -> ::treesitter_types::Span {
12950 self.span
12951 }
12952}
12953#[derive(Debug, Clone, PartialEq, Eq)]
12954pub struct CharacterLiteralContent<'tree> {
12955 pub span: ::treesitter_types::Span,
12956 text: &'tree str,
12957}
12958impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralContent<'tree> {
12959 fn from_node(
12960 node: ::tree_sitter::Node<'tree>,
12961 src: &'tree [u8],
12962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12963 debug_assert_eq!(node.kind(), "character_literal_content");
12964 Ok(Self {
12965 span: ::treesitter_types::Span::from(node),
12966 text: node.utf8_text(src)?,
12967 })
12968 }
12969}
12970impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteralContent<'tree> {
12971 fn text(&self) -> &'tree str {
12972 self.text
12973 }
12974}
12975impl ::treesitter_types::Spanned for CharacterLiteralContent<'_> {
12976 fn span(&self) -> ::treesitter_types::Span {
12977 self.span
12978 }
12979}
12980#[derive(Debug, Clone, PartialEq, Eq)]
12981pub struct Comment<'tree> {
12982 pub span: ::treesitter_types::Span,
12983 text: &'tree str,
12984}
12985impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
12986 fn from_node(
12987 node: ::tree_sitter::Node<'tree>,
12988 src: &'tree [u8],
12989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12990 debug_assert_eq!(node.kind(), "comment");
12991 Ok(Self {
12992 span: ::treesitter_types::Span::from(node),
12993 text: node.utf8_text(src)?,
12994 })
12995 }
12996}
12997impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
12998 fn text(&self) -> &'tree str {
12999 self.text
13000 }
13001}
13002impl ::treesitter_types::Spanned for Comment<'_> {
13003 fn span(&self) -> ::treesitter_types::Span {
13004 self.span
13005 }
13006}
13007#[derive(Debug, Clone, PartialEq, Eq)]
13008pub struct Discard<'tree> {
13009 pub span: ::treesitter_types::Span,
13010 text: &'tree str,
13011}
13012impl<'tree> ::treesitter_types::FromNode<'tree> for Discard<'tree> {
13013 fn from_node(
13014 node: ::tree_sitter::Node<'tree>,
13015 src: &'tree [u8],
13016 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13017 debug_assert_eq!(node.kind(), "discard");
13018 Ok(Self {
13019 span: ::treesitter_types::Span::from(node),
13020 text: node.utf8_text(src)?,
13021 })
13022 }
13023}
13024impl<'tree> ::treesitter_types::LeafNode<'tree> for Discard<'tree> {
13025 fn text(&self) -> &'tree str {
13026 self.text
13027 }
13028}
13029impl ::treesitter_types::Spanned for Discard<'_> {
13030 fn span(&self) -> ::treesitter_types::Span {
13031 self.span
13032 }
13033}
13034#[derive(Debug, Clone, PartialEq, Eq)]
13035pub struct EscapeSequence<'tree> {
13036 pub span: ::treesitter_types::Span,
13037 text: &'tree str,
13038}
13039impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
13040 fn from_node(
13041 node: ::tree_sitter::Node<'tree>,
13042 src: &'tree [u8],
13043 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13044 debug_assert_eq!(node.kind(), "escape_sequence");
13045 Ok(Self {
13046 span: ::treesitter_types::Span::from(node),
13047 text: node.utf8_text(src)?,
13048 })
13049 }
13050}
13051impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
13052 fn text(&self) -> &'tree str {
13053 self.text
13054 }
13055}
13056impl ::treesitter_types::Spanned for EscapeSequence<'_> {
13057 fn span(&self) -> ::treesitter_types::Span {
13058 self.span
13059 }
13060}
13061#[derive(Debug, Clone, PartialEq, Eq)]
13062pub struct IntegerLiteral<'tree> {
13063 pub span: ::treesitter_types::Span,
13064 text: &'tree str,
13065}
13066impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
13067 fn from_node(
13068 node: ::tree_sitter::Node<'tree>,
13069 src: &'tree [u8],
13070 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13071 debug_assert_eq!(node.kind(), "integer_literal");
13072 Ok(Self {
13073 span: ::treesitter_types::Span::from(node),
13074 text: node.utf8_text(src)?,
13075 })
13076 }
13077}
13078impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
13079 fn text(&self) -> &'tree str {
13080 self.text
13081 }
13082}
13083impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
13084 fn span(&self) -> ::treesitter_types::Span {
13085 self.span
13086 }
13087}
13088#[derive(Debug, Clone, PartialEq, Eq)]
13089pub struct InterpolationBrace<'tree> {
13090 pub span: ::treesitter_types::Span,
13091 text: &'tree str,
13092}
13093impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationBrace<'tree> {
13094 fn from_node(
13095 node: ::tree_sitter::Node<'tree>,
13096 src: &'tree [u8],
13097 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13098 debug_assert_eq!(node.kind(), "interpolation_brace");
13099 Ok(Self {
13100 span: ::treesitter_types::Span::from(node),
13101 text: node.utf8_text(src)?,
13102 })
13103 }
13104}
13105impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationBrace<'tree> {
13106 fn text(&self) -> &'tree str {
13107 self.text
13108 }
13109}
13110impl ::treesitter_types::Spanned for InterpolationBrace<'_> {
13111 fn span(&self) -> ::treesitter_types::Span {
13112 self.span
13113 }
13114}
13115#[derive(Debug, Clone, PartialEq, Eq)]
13116pub struct InterpolationQuote<'tree> {
13117 pub span: ::treesitter_types::Span,
13118 text: &'tree str,
13119}
13120impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationQuote<'tree> {
13121 fn from_node(
13122 node: ::tree_sitter::Node<'tree>,
13123 src: &'tree [u8],
13124 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13125 debug_assert_eq!(node.kind(), "interpolation_quote");
13126 Ok(Self {
13127 span: ::treesitter_types::Span::from(node),
13128 text: node.utf8_text(src)?,
13129 })
13130 }
13131}
13132impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationQuote<'tree> {
13133 fn text(&self) -> &'tree str {
13134 self.text
13135 }
13136}
13137impl ::treesitter_types::Spanned for InterpolationQuote<'_> {
13138 fn span(&self) -> ::treesitter_types::Span {
13139 self.span
13140 }
13141}
13142#[derive(Debug, Clone, PartialEq, Eq)]
13143pub struct InterpolationStart<'tree> {
13144 pub span: ::treesitter_types::Span,
13145 text: &'tree str,
13146}
13147impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationStart<'tree> {
13148 fn from_node(
13149 node: ::tree_sitter::Node<'tree>,
13150 src: &'tree [u8],
13151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13152 debug_assert_eq!(node.kind(), "interpolation_start");
13153 Ok(Self {
13154 span: ::treesitter_types::Span::from(node),
13155 text: node.utf8_text(src)?,
13156 })
13157 }
13158}
13159impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationStart<'tree> {
13160 fn text(&self) -> &'tree str {
13161 self.text
13162 }
13163}
13164impl ::treesitter_types::Spanned for InterpolationStart<'_> {
13165 fn span(&self) -> ::treesitter_types::Span {
13166 self.span
13167 }
13168}
13169#[derive(Debug, Clone, PartialEq, Eq)]
13170pub struct NullLiteral<'tree> {
13171 pub span: ::treesitter_types::Span,
13172 text: &'tree str,
13173}
13174impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
13175 fn from_node(
13176 node: ::tree_sitter::Node<'tree>,
13177 src: &'tree [u8],
13178 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13179 debug_assert_eq!(node.kind(), "null_literal");
13180 Ok(Self {
13181 span: ::treesitter_types::Span::from(node),
13182 text: node.utf8_text(src)?,
13183 })
13184 }
13185}
13186impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
13187 fn text(&self) -> &'tree str {
13188 self.text
13189 }
13190}
13191impl ::treesitter_types::Spanned for NullLiteral<'_> {
13192 fn span(&self) -> ::treesitter_types::Span {
13193 self.span
13194 }
13195}
13196#[derive(Debug, Clone, PartialEq, Eq)]
13197pub struct PredefinedType<'tree> {
13198 pub span: ::treesitter_types::Span,
13199 text: &'tree str,
13200}
13201impl<'tree> ::treesitter_types::FromNode<'tree> for PredefinedType<'tree> {
13202 fn from_node(
13203 node: ::tree_sitter::Node<'tree>,
13204 src: &'tree [u8],
13205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13206 debug_assert_eq!(node.kind(), "predefined_type");
13207 Ok(Self {
13208 span: ::treesitter_types::Span::from(node),
13209 text: node.utf8_text(src)?,
13210 })
13211 }
13212}
13213impl<'tree> ::treesitter_types::LeafNode<'tree> for PredefinedType<'tree> {
13214 fn text(&self) -> &'tree str {
13215 self.text
13216 }
13217}
13218impl ::treesitter_types::Spanned for PredefinedType<'_> {
13219 fn span(&self) -> ::treesitter_types::Span {
13220 self.span
13221 }
13222}
13223#[derive(Debug, Clone, PartialEq, Eq)]
13224pub struct PreprocArg<'tree> {
13225 pub span: ::treesitter_types::Span,
13226 text: &'tree str,
13227}
13228impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
13229 fn from_node(
13230 node: ::tree_sitter::Node<'tree>,
13231 src: &'tree [u8],
13232 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13233 debug_assert_eq!(node.kind(), "preproc_arg");
13234 Ok(Self {
13235 span: ::treesitter_types::Span::from(node),
13236 text: node.utf8_text(src)?,
13237 })
13238 }
13239}
13240impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
13241 fn text(&self) -> &'tree str {
13242 self.text
13243 }
13244}
13245impl ::treesitter_types::Spanned for PreprocArg<'_> {
13246 fn span(&self) -> ::treesitter_types::Span {
13247 self.span
13248 }
13249}
13250#[derive(Debug, Clone, PartialEq, Eq)]
13251pub struct RawStringContent<'tree> {
13252 pub span: ::treesitter_types::Span,
13253 text: &'tree str,
13254}
13255impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringContent<'tree> {
13256 fn from_node(
13257 node: ::tree_sitter::Node<'tree>,
13258 src: &'tree [u8],
13259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13260 debug_assert_eq!(node.kind(), "raw_string_content");
13261 Ok(Self {
13262 span: ::treesitter_types::Span::from(node),
13263 text: node.utf8_text(src)?,
13264 })
13265 }
13266}
13267impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringContent<'tree> {
13268 fn text(&self) -> &'tree str {
13269 self.text
13270 }
13271}
13272impl ::treesitter_types::Spanned for RawStringContent<'_> {
13273 fn span(&self) -> ::treesitter_types::Span {
13274 self.span
13275 }
13276}
13277#[derive(Debug, Clone, PartialEq, Eq)]
13278pub struct RawStringEnd<'tree> {
13279 pub span: ::treesitter_types::Span,
13280 text: &'tree str,
13281}
13282impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringEnd<'tree> {
13283 fn from_node(
13284 node: ::tree_sitter::Node<'tree>,
13285 src: &'tree [u8],
13286 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13287 debug_assert_eq!(node.kind(), "raw_string_end");
13288 Ok(Self {
13289 span: ::treesitter_types::Span::from(node),
13290 text: node.utf8_text(src)?,
13291 })
13292 }
13293}
13294impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringEnd<'tree> {
13295 fn text(&self) -> &'tree str {
13296 self.text
13297 }
13298}
13299impl ::treesitter_types::Spanned for RawStringEnd<'_> {
13300 fn span(&self) -> ::treesitter_types::Span {
13301 self.span
13302 }
13303}
13304#[derive(Debug, Clone, PartialEq, Eq)]
13305pub struct RawStringStart<'tree> {
13306 pub span: ::treesitter_types::Span,
13307 text: &'tree str,
13308}
13309impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringStart<'tree> {
13310 fn from_node(
13311 node: ::tree_sitter::Node<'tree>,
13312 src: &'tree [u8],
13313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13314 debug_assert_eq!(node.kind(), "raw_string_start");
13315 Ok(Self {
13316 span: ::treesitter_types::Span::from(node),
13317 text: node.utf8_text(src)?,
13318 })
13319 }
13320}
13321impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringStart<'tree> {
13322 fn text(&self) -> &'tree str {
13323 self.text
13324 }
13325}
13326impl ::treesitter_types::Spanned for RawStringStart<'_> {
13327 fn span(&self) -> ::treesitter_types::Span {
13328 self.span
13329 }
13330}
13331#[derive(Debug, Clone, PartialEq, Eq)]
13332pub struct RealLiteral<'tree> {
13333 pub span: ::treesitter_types::Span,
13334 text: &'tree str,
13335}
13336impl<'tree> ::treesitter_types::FromNode<'tree> for RealLiteral<'tree> {
13337 fn from_node(
13338 node: ::tree_sitter::Node<'tree>,
13339 src: &'tree [u8],
13340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13341 debug_assert_eq!(node.kind(), "real_literal");
13342 Ok(Self {
13343 span: ::treesitter_types::Span::from(node),
13344 text: node.utf8_text(src)?,
13345 })
13346 }
13347}
13348impl<'tree> ::treesitter_types::LeafNode<'tree> for RealLiteral<'tree> {
13349 fn text(&self) -> &'tree str {
13350 self.text
13351 }
13352}
13353impl ::treesitter_types::Spanned for RealLiteral<'_> {
13354 fn span(&self) -> ::treesitter_types::Span {
13355 self.span
13356 }
13357}
13358#[derive(Debug, Clone, PartialEq, Eq)]
13359pub struct ShebangDirective<'tree> {
13360 pub span: ::treesitter_types::Span,
13361 text: &'tree str,
13362}
13363impl<'tree> ::treesitter_types::FromNode<'tree> for ShebangDirective<'tree> {
13364 fn from_node(
13365 node: ::tree_sitter::Node<'tree>,
13366 src: &'tree [u8],
13367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13368 debug_assert_eq!(node.kind(), "shebang_directive");
13369 Ok(Self {
13370 span: ::treesitter_types::Span::from(node),
13371 text: node.utf8_text(src)?,
13372 })
13373 }
13374}
13375impl<'tree> ::treesitter_types::LeafNode<'tree> for ShebangDirective<'tree> {
13376 fn text(&self) -> &'tree str {
13377 self.text
13378 }
13379}
13380impl ::treesitter_types::Spanned for ShebangDirective<'_> {
13381 fn span(&self) -> ::treesitter_types::Span {
13382 self.span
13383 }
13384}
13385#[derive(Debug, Clone, PartialEq, Eq)]
13386pub struct StringContent<'tree> {
13387 pub span: ::treesitter_types::Span,
13388 text: &'tree str,
13389}
13390impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
13391 fn from_node(
13392 node: ::tree_sitter::Node<'tree>,
13393 src: &'tree [u8],
13394 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13395 debug_assert_eq!(node.kind(), "string_content");
13396 Ok(Self {
13397 span: ::treesitter_types::Span::from(node),
13398 text: node.utf8_text(src)?,
13399 })
13400 }
13401}
13402impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
13403 fn text(&self) -> &'tree str {
13404 self.text
13405 }
13406}
13407impl ::treesitter_types::Spanned for StringContent<'_> {
13408 fn span(&self) -> ::treesitter_types::Span {
13409 self.span
13410 }
13411}
13412#[derive(Debug, Clone, PartialEq, Eq)]
13413pub struct StringLiteralEncoding<'tree> {
13414 pub span: ::treesitter_types::Span,
13415 text: &'tree str,
13416}
13417impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralEncoding<'tree> {
13418 fn from_node(
13419 node: ::tree_sitter::Node<'tree>,
13420 src: &'tree [u8],
13421 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13422 debug_assert_eq!(node.kind(), "string_literal_encoding");
13423 Ok(Self {
13424 span: ::treesitter_types::Span::from(node),
13425 text: node.utf8_text(src)?,
13426 })
13427 }
13428}
13429impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralEncoding<'tree> {
13430 fn text(&self) -> &'tree str {
13431 self.text
13432 }
13433}
13434impl ::treesitter_types::Spanned for StringLiteralEncoding<'_> {
13435 fn span(&self) -> ::treesitter_types::Span {
13436 self.span
13437 }
13438}
13439#[derive(Debug, Clone, PartialEq, Eq)]
13440pub struct VerbatimStringLiteral<'tree> {
13441 pub span: ::treesitter_types::Span,
13442 text: &'tree str,
13443}
13444impl<'tree> ::treesitter_types::FromNode<'tree> for VerbatimStringLiteral<'tree> {
13445 fn from_node(
13446 node: ::tree_sitter::Node<'tree>,
13447 src: &'tree [u8],
13448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13449 debug_assert_eq!(node.kind(), "verbatim_string_literal");
13450 Ok(Self {
13451 span: ::treesitter_types::Span::from(node),
13452 text: node.utf8_text(src)?,
13453 })
13454 }
13455}
13456impl<'tree> ::treesitter_types::LeafNode<'tree> for VerbatimStringLiteral<'tree> {
13457 fn text(&self) -> &'tree str {
13458 self.text
13459 }
13460}
13461impl ::treesitter_types::Spanned for VerbatimStringLiteral<'_> {
13462 fn span(&self) -> ::treesitter_types::Span {
13463 self.span
13464 }
13465}
13466#[derive(Debug, Clone, PartialEq, Eq)]
13467pub enum AccessorDeclarationBody<'tree> {
13468 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
13469 Block(::std::boxed::Box<Block<'tree>>),
13470}
13471impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationBody<'tree> {
13472 #[allow(clippy::collapsible_else_if)]
13473 fn from_node(
13474 node: ::tree_sitter::Node<'tree>,
13475 src: &'tree [u8],
13476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13477 match node.kind() {
13478 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
13479 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13480 ))),
13481 "block" => Ok(Self::Block(::std::boxed::Box::new(
13482 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
13483 ))),
13484 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13485 }
13486 }
13487}
13488impl ::treesitter_types::Spanned for AccessorDeclarationBody<'_> {
13489 fn span(&self) -> ::treesitter_types::Span {
13490 match self {
13491 Self::ArrowExpressionClause(inner) => inner.span(),
13492 Self::Block(inner) => inner.span(),
13493 }
13494 }
13495}
13496#[derive(Debug, Clone, PartialEq, Eq)]
13497pub enum AccessorDeclarationName<'tree> {
13498 Add(::treesitter_types::Span),
13499 Get(::treesitter_types::Span),
13500 Identifier(::std::boxed::Box<Identifier<'tree>>),
13501 Init(::treesitter_types::Span),
13502 Remove(::treesitter_types::Span),
13503 Set(::treesitter_types::Span),
13504}
13505impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationName<'tree> {
13506 #[allow(clippy::collapsible_else_if)]
13507 fn from_node(
13508 node: ::tree_sitter::Node<'tree>,
13509 src: &'tree [u8],
13510 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13511 match node.kind() {
13512 "add" => Ok(Self::Add(::treesitter_types::Span::from(node))),
13513 "get" => Ok(Self::Get(::treesitter_types::Span::from(node))),
13514 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13515 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13516 ))),
13517 "init" => Ok(Self::Init(::treesitter_types::Span::from(node))),
13518 "remove" => Ok(Self::Remove(::treesitter_types::Span::from(node))),
13519 "set" => Ok(Self::Set(::treesitter_types::Span::from(node))),
13520 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13521 }
13522 }
13523}
13524impl ::treesitter_types::Spanned for AccessorDeclarationName<'_> {
13525 fn span(&self) -> ::treesitter_types::Span {
13526 match self {
13527 Self::Add(span) => *span,
13528 Self::Get(span) => *span,
13529 Self::Identifier(inner) => inner.span(),
13530 Self::Init(span) => *span,
13531 Self::Remove(span) => *span,
13532 Self::Set(span) => *span,
13533 }
13534 }
13535}
13536#[derive(Debug, Clone, PartialEq, Eq)]
13537pub enum AccessorDeclarationChildren<'tree> {
13538 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
13539 Modifier(::std::boxed::Box<Modifier<'tree>>),
13540}
13541impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationChildren<'tree> {
13542 #[allow(clippy::collapsible_else_if)]
13543 fn from_node(
13544 node: ::tree_sitter::Node<'tree>,
13545 src: &'tree [u8],
13546 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13547 match node.kind() {
13548 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
13549 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
13550 ))),
13551 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
13552 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13553 ))),
13554 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13555 }
13556 }
13557}
13558impl ::treesitter_types::Spanned for AccessorDeclarationChildren<'_> {
13559 fn span(&self) -> ::treesitter_types::Span {
13560 match self {
13561 Self::AttributeList(inner) => inner.span(),
13562 Self::Modifier(inner) => inner.span(),
13563 }
13564 }
13565}
13566#[derive(Debug, Clone, PartialEq, Eq)]
13567pub enum AliasQualifiedNameName<'tree> {
13568 GenericName(::std::boxed::Box<GenericName<'tree>>),
13569 Identifier(::std::boxed::Box<Identifier<'tree>>),
13570}
13571impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedNameName<'tree> {
13572 #[allow(clippy::collapsible_else_if)]
13573 fn from_node(
13574 node: ::tree_sitter::Node<'tree>,
13575 src: &'tree [u8],
13576 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13577 match node.kind() {
13578 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
13579 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
13580 ))),
13581 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13582 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13583 ))),
13584 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13585 }
13586 }
13587}
13588impl ::treesitter_types::Spanned for AliasQualifiedNameName<'_> {
13589 fn span(&self) -> ::treesitter_types::Span {
13590 match self {
13591 Self::GenericName(inner) => inner.span(),
13592 Self::Identifier(inner) => inner.span(),
13593 }
13594 }
13595}
13596#[derive(Debug, Clone, PartialEq, Eq)]
13597pub enum AndPatternOperator {
13598 And(::treesitter_types::Span),
13599}
13600impl<'tree> ::treesitter_types::FromNode<'tree> for AndPatternOperator {
13601 #[allow(clippy::collapsible_else_if)]
13602 fn from_node(
13603 node: ::tree_sitter::Node<'tree>,
13604 _src: &'tree [u8],
13605 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13606 match node.kind() {
13607 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
13608 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13609 }
13610 }
13611}
13612impl ::treesitter_types::Spanned for AndPatternOperator {
13613 fn span(&self) -> ::treesitter_types::Span {
13614 match self {
13615 Self::And(span) => *span,
13616 }
13617 }
13618}
13619#[derive(Debug, Clone, PartialEq, Eq)]
13620pub enum AnonymousMethodExpressionChildren<'tree> {
13621 Block(::std::boxed::Box<Block<'tree>>),
13622 Modifier(::std::boxed::Box<Modifier<'tree>>),
13623}
13624impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpressionChildren<'tree> {
13625 #[allow(clippy::collapsible_else_if)]
13626 fn from_node(
13627 node: ::tree_sitter::Node<'tree>,
13628 src: &'tree [u8],
13629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13630 match node.kind() {
13631 "block" => Ok(Self::Block(::std::boxed::Box::new(
13632 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
13633 ))),
13634 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
13635 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13636 ))),
13637 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13638 }
13639 }
13640}
13641impl ::treesitter_types::Spanned for AnonymousMethodExpressionChildren<'_> {
13642 fn span(&self) -> ::treesitter_types::Span {
13643 match self {
13644 Self::Block(inner) => inner.span(),
13645 Self::Modifier(inner) => inner.span(),
13646 }
13647 }
13648}
13649#[derive(Debug, Clone, PartialEq, Eq)]
13650pub enum AnonymousObjectCreationExpressionChildren<'tree> {
13651 Expression(::std::boxed::Box<Expression<'tree>>),
13652 Identifier(::std::boxed::Box<Identifier<'tree>>),
13653}
13654impl<'tree> ::treesitter_types::FromNode<'tree>
13655 for AnonymousObjectCreationExpressionChildren<'tree>
13656{
13657 #[allow(clippy::collapsible_else_if)]
13658 fn from_node(
13659 node: ::tree_sitter::Node<'tree>,
13660 src: &'tree [u8],
13661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13662 match node.kind() {
13663 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13664 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13665 ))),
13666 _other => {
13667 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13668 Ok(Self::Expression(::std::boxed::Box::new(v)))
13669 } else {
13670 Err(::treesitter_types::ParseError::unexpected_kind(
13671 _other, node,
13672 ))
13673 }
13674 }
13675 }
13676 }
13677}
13678impl ::treesitter_types::Spanned for AnonymousObjectCreationExpressionChildren<'_> {
13679 fn span(&self) -> ::treesitter_types::Span {
13680 match self {
13681 Self::Expression(inner) => inner.span(),
13682 Self::Identifier(inner) => inner.span(),
13683 }
13684 }
13685}
13686#[derive(Debug, Clone, PartialEq, Eq)]
13687pub enum ArgumentChildren<'tree> {
13688 DeclarationExpression(::std::boxed::Box<DeclarationExpression<'tree>>),
13689 Expression(::std::boxed::Box<Expression<'tree>>),
13690}
13691impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentChildren<'tree> {
13692 #[allow(clippy::collapsible_else_if)]
13693 fn from_node(
13694 node: ::tree_sitter::Node<'tree>,
13695 src: &'tree [u8],
13696 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13697 match node.kind() {
13698 "declaration_expression" => Ok(Self::DeclarationExpression(::std::boxed::Box::new(
13699 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13700 ))),
13701 _other => {
13702 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13703 Ok(Self::Expression(::std::boxed::Box::new(v)))
13704 } else {
13705 Err(::treesitter_types::ParseError::unexpected_kind(
13706 _other, node,
13707 ))
13708 }
13709 }
13710 }
13711 }
13712}
13713impl ::treesitter_types::Spanned for ArgumentChildren<'_> {
13714 fn span(&self) -> ::treesitter_types::Span {
13715 match self {
13716 Self::DeclarationExpression(inner) => inner.span(),
13717 Self::Expression(inner) => inner.span(),
13718 }
13719 }
13720}
13721#[derive(Debug, Clone, PartialEq, Eq)]
13722pub enum ArrayTypeType<'tree> {
13723 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
13724 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
13725 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
13726 GenericName(::std::boxed::Box<GenericName<'tree>>),
13727 Identifier(::std::boxed::Box<Identifier<'tree>>),
13728 NullableType(::std::boxed::Box<NullableType<'tree>>),
13729 PointerType(::std::boxed::Box<PointerType<'tree>>),
13730 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
13731 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13732 TupleType(::std::boxed::Box<TupleType<'tree>>),
13733}
13734impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayTypeType<'tree> {
13735 #[allow(clippy::collapsible_else_if)]
13736 fn from_node(
13737 node: ::tree_sitter::Node<'tree>,
13738 src: &'tree [u8],
13739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13740 match node.kind() {
13741 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
13742 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13743 ))),
13744 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
13745 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
13746 ))),
13747 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
13748 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
13749 ))),
13750 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
13751 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
13752 ))),
13753 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13754 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13755 ))),
13756 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
13757 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
13758 ))),
13759 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
13760 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
13761 ))),
13762 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
13763 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
13764 ))),
13765 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13766 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13767 ))),
13768 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
13769 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
13770 ))),
13771 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13772 }
13773 }
13774}
13775impl ::treesitter_types::Spanned for ArrayTypeType<'_> {
13776 fn span(&self) -> ::treesitter_types::Span {
13777 match self {
13778 Self::AliasQualifiedName(inner) => inner.span(),
13779 Self::ArrayType(inner) => inner.span(),
13780 Self::FunctionPointerType(inner) => inner.span(),
13781 Self::GenericName(inner) => inner.span(),
13782 Self::Identifier(inner) => inner.span(),
13783 Self::NullableType(inner) => inner.span(),
13784 Self::PointerType(inner) => inner.span(),
13785 Self::PredefinedType(inner) => inner.span(),
13786 Self::QualifiedName(inner) => inner.span(),
13787 Self::TupleType(inner) => inner.span(),
13788 }
13789 }
13790}
13791#[derive(Debug, Clone, PartialEq, Eq)]
13792pub enum AsExpressionOperator {
13793 As(::treesitter_types::Span),
13794}
13795impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpressionOperator {
13796 #[allow(clippy::collapsible_else_if)]
13797 fn from_node(
13798 node: ::tree_sitter::Node<'tree>,
13799 _src: &'tree [u8],
13800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13801 match node.kind() {
13802 "as" => Ok(Self::As(::treesitter_types::Span::from(node))),
13803 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13804 }
13805 }
13806}
13807impl ::treesitter_types::Spanned for AsExpressionOperator {
13808 fn span(&self) -> ::treesitter_types::Span {
13809 match self {
13810 Self::As(span) => *span,
13811 }
13812 }
13813}
13814#[derive(Debug, Clone, PartialEq, Eq)]
13815pub enum AssignmentExpressionOperator {
13816 PercentEq(::treesitter_types::Span),
13817 AmpEq(::treesitter_types::Span),
13818 StarEq(::treesitter_types::Span),
13819 PlusEq(::treesitter_types::Span),
13820 MinusEq(::treesitter_types::Span),
13821 SlashEq(::treesitter_types::Span),
13822 ShlEq(::treesitter_types::Span),
13823 Eq(::treesitter_types::Span),
13824 ShrEq(::treesitter_types::Span),
13825 GtGtGtEq(::treesitter_types::Span),
13826 QuestionQuestionEq(::treesitter_types::Span),
13827 CaretEq(::treesitter_types::Span),
13828 PipeEq(::treesitter_types::Span),
13829}
13830impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
13831 #[allow(clippy::collapsible_else_if)]
13832 fn from_node(
13833 node: ::tree_sitter::Node<'tree>,
13834 _src: &'tree [u8],
13835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13836 match node.kind() {
13837 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
13838 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
13839 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
13840 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
13841 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
13842 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
13843 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
13844 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
13845 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
13846 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
13847 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
13848 node,
13849 ))),
13850 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
13851 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
13852 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13853 }
13854 }
13855}
13856impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
13857 fn span(&self) -> ::treesitter_types::Span {
13858 match self {
13859 Self::PercentEq(span) => *span,
13860 Self::AmpEq(span) => *span,
13861 Self::StarEq(span) => *span,
13862 Self::PlusEq(span) => *span,
13863 Self::MinusEq(span) => *span,
13864 Self::SlashEq(span) => *span,
13865 Self::ShlEq(span) => *span,
13866 Self::Eq(span) => *span,
13867 Self::ShrEq(span) => *span,
13868 Self::GtGtGtEq(span) => *span,
13869 Self::QuestionQuestionEq(span) => *span,
13870 Self::CaretEq(span) => *span,
13871 Self::PipeEq(span) => *span,
13872 }
13873 }
13874}
13875#[derive(Debug, Clone, PartialEq, Eq)]
13876pub enum AttributeName<'tree> {
13877 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
13878 GenericName(::std::boxed::Box<GenericName<'tree>>),
13879 Identifier(::std::boxed::Box<Identifier<'tree>>),
13880 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13881}
13882impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeName<'tree> {
13883 #[allow(clippy::collapsible_else_if)]
13884 fn from_node(
13885 node: ::tree_sitter::Node<'tree>,
13886 src: &'tree [u8],
13887 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13888 match node.kind() {
13889 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
13890 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13891 ))),
13892 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
13893 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
13894 ))),
13895 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13896 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13897 ))),
13898 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13899 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13900 ))),
13901 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13902 }
13903 }
13904}
13905impl ::treesitter_types::Spanned for AttributeName<'_> {
13906 fn span(&self) -> ::treesitter_types::Span {
13907 match self {
13908 Self::AliasQualifiedName(inner) => inner.span(),
13909 Self::GenericName(inner) => inner.span(),
13910 Self::Identifier(inner) => inner.span(),
13911 Self::QualifiedName(inner) => inner.span(),
13912 }
13913 }
13914}
13915#[derive(Debug, Clone, PartialEq, Eq)]
13916pub enum AttributeArgumentChildren<'tree> {
13917 Expression(::std::boxed::Box<Expression<'tree>>),
13918 Identifier(::std::boxed::Box<Identifier<'tree>>),
13919}
13920impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgumentChildren<'tree> {
13921 #[allow(clippy::collapsible_else_if)]
13922 fn from_node(
13923 node: ::tree_sitter::Node<'tree>,
13924 src: &'tree [u8],
13925 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13926 match node.kind() {
13927 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13928 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13929 ))),
13930 _other => {
13931 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13932 Ok(Self::Expression(::std::boxed::Box::new(v)))
13933 } else {
13934 Err(::treesitter_types::ParseError::unexpected_kind(
13935 _other, node,
13936 ))
13937 }
13938 }
13939 }
13940 }
13941}
13942impl ::treesitter_types::Spanned for AttributeArgumentChildren<'_> {
13943 fn span(&self) -> ::treesitter_types::Span {
13944 match self {
13945 Self::Expression(inner) => inner.span(),
13946 Self::Identifier(inner) => inner.span(),
13947 }
13948 }
13949}
13950#[derive(Debug, Clone, PartialEq, Eq)]
13951pub enum AttributeListChildren<'tree> {
13952 Attribute(::std::boxed::Box<Attribute<'tree>>),
13953 AttributeTargetSpecifier(::std::boxed::Box<AttributeTargetSpecifier<'tree>>),
13954}
13955impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeListChildren<'tree> {
13956 #[allow(clippy::collapsible_else_if)]
13957 fn from_node(
13958 node: ::tree_sitter::Node<'tree>,
13959 src: &'tree [u8],
13960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13961 match node.kind() {
13962 "attribute" => Ok(Self::Attribute(::std::boxed::Box::new(
13963 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)?,
13964 ))),
13965 "attribute_target_specifier" => {
13966 Ok(Self::AttributeTargetSpecifier(::std::boxed::Box::new(
13967 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(
13968 node, src,
13969 )?,
13970 )))
13971 }
13972 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13973 }
13974 }
13975}
13976impl ::treesitter_types::Spanned for AttributeListChildren<'_> {
13977 fn span(&self) -> ::treesitter_types::Span {
13978 match self {
13979 Self::Attribute(inner) => inner.span(),
13980 Self::AttributeTargetSpecifier(inner) => inner.span(),
13981 }
13982 }
13983}
13984#[derive(Debug, Clone, PartialEq, Eq)]
13985pub enum BaseListChildren<'tree> {
13986 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
13987 PrimaryConstructorBaseType(::std::boxed::Box<PrimaryConstructorBaseType<'tree>>),
13988 Type(::std::boxed::Box<Type<'tree>>),
13989}
13990impl<'tree> ::treesitter_types::FromNode<'tree> for BaseListChildren<'tree> {
13991 #[allow(clippy::collapsible_else_if)]
13992 fn from_node(
13993 node: ::tree_sitter::Node<'tree>,
13994 src: &'tree [u8],
13995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13996 match node.kind() {
13997 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
13998 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
13999 ))),
14000 "primary_constructor_base_type" => {
14001 Ok(Self::PrimaryConstructorBaseType(::std::boxed::Box::new(
14002 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(
14003 node, src,
14004 )?,
14005 )))
14006 }
14007 _other => {
14008 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
14009 Ok(Self::Type(::std::boxed::Box::new(v)))
14010 } else {
14011 Err(::treesitter_types::ParseError::unexpected_kind(
14012 _other, node,
14013 ))
14014 }
14015 }
14016 }
14017 }
14018}
14019impl ::treesitter_types::Spanned for BaseListChildren<'_> {
14020 fn span(&self) -> ::treesitter_types::Span {
14021 match self {
14022 Self::ArgumentList(inner) => inner.span(),
14023 Self::PrimaryConstructorBaseType(inner) => inner.span(),
14024 Self::Type(inner) => inner.span(),
14025 }
14026 }
14027}
14028#[derive(Debug, Clone, PartialEq, Eq)]
14029pub enum BinaryExpressionLeft<'tree> {
14030 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
14031 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
14032 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
14033 Expression(::std::boxed::Box<Expression<'tree>>),
14034 Identifier(::std::boxed::Box<Identifier<'tree>>),
14035 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
14036 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14037 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
14038}
14039impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
14040 #[allow(clippy::collapsible_else_if)]
14041 fn from_node(
14042 node: ::tree_sitter::Node<'tree>,
14043 src: &'tree [u8],
14044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14045 match node.kind() {
14046 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
14047 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14048 ))),
14049 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
14050 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14051 ))),
14052 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
14053 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14054 ))),
14055 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14056 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14057 ))),
14058 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
14059 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14060 ))),
14061 "parenthesized_expression" => {
14062 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
14063 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
14064 node, src,
14065 )?,
14066 )))
14067 }
14068 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
14069 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14070 ))),
14071 _other => {
14072 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14073 Ok(Self::Expression(::std::boxed::Box::new(v)))
14074 } else {
14075 Err(::treesitter_types::ParseError::unexpected_kind(
14076 _other, node,
14077 ))
14078 }
14079 }
14080 }
14081 }
14082}
14083impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
14084 fn span(&self) -> ::treesitter_types::Span {
14085 match self {
14086 Self::BinaryExpression(inner) => inner.span(),
14087 Self::BooleanLiteral(inner) => inner.span(),
14088 Self::CharacterLiteral(inner) => inner.span(),
14089 Self::Expression(inner) => inner.span(),
14090 Self::Identifier(inner) => inner.span(),
14091 Self::IntegerLiteral(inner) => inner.span(),
14092 Self::ParenthesizedExpression(inner) => inner.span(),
14093 Self::UnaryExpression(inner) => inner.span(),
14094 }
14095 }
14096}
14097#[derive(Debug, Clone, PartialEq, Eq)]
14098pub enum BinaryExpressionOperator {
14099 NotEq(::treesitter_types::Span),
14100 Percent(::treesitter_types::Span),
14101 Amp(::treesitter_types::Span),
14102 AmpAmp(::treesitter_types::Span),
14103 Star(::treesitter_types::Span),
14104 Plus(::treesitter_types::Span),
14105 Minus(::treesitter_types::Span),
14106 Slash(::treesitter_types::Span),
14107 Lt(::treesitter_types::Span),
14108 Shl(::treesitter_types::Span),
14109 LtEq(::treesitter_types::Span),
14110 EqEq(::treesitter_types::Span),
14111 Gt(::treesitter_types::Span),
14112 GtEq(::treesitter_types::Span),
14113 Shr(::treesitter_types::Span),
14114 GtGtGt(::treesitter_types::Span),
14115 QuestionQuestion(::treesitter_types::Span),
14116 Caret(::treesitter_types::Span),
14117 Pipe(::treesitter_types::Span),
14118 PipePipe(::treesitter_types::Span),
14119}
14120impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
14121 #[allow(clippy::collapsible_else_if)]
14122 fn from_node(
14123 node: ::tree_sitter::Node<'tree>,
14124 _src: &'tree [u8],
14125 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14126 match node.kind() {
14127 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
14128 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
14129 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
14130 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
14131 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
14132 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
14133 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
14134 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
14135 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
14136 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
14137 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
14138 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
14139 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
14140 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
14141 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
14142 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
14143 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
14144 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
14145 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
14146 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
14147 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14148 }
14149 }
14150}
14151impl ::treesitter_types::Spanned for BinaryExpressionOperator {
14152 fn span(&self) -> ::treesitter_types::Span {
14153 match self {
14154 Self::NotEq(span) => *span,
14155 Self::Percent(span) => *span,
14156 Self::Amp(span) => *span,
14157 Self::AmpAmp(span) => *span,
14158 Self::Star(span) => *span,
14159 Self::Plus(span) => *span,
14160 Self::Minus(span) => *span,
14161 Self::Slash(span) => *span,
14162 Self::Lt(span) => *span,
14163 Self::Shl(span) => *span,
14164 Self::LtEq(span) => *span,
14165 Self::EqEq(span) => *span,
14166 Self::Gt(span) => *span,
14167 Self::GtEq(span) => *span,
14168 Self::Shr(span) => *span,
14169 Self::GtGtGt(span) => *span,
14170 Self::QuestionQuestion(span) => *span,
14171 Self::Caret(span) => *span,
14172 Self::Pipe(span) => *span,
14173 Self::PipePipe(span) => *span,
14174 }
14175 }
14176}
14177#[derive(Debug, Clone, PartialEq, Eq)]
14178pub enum BinaryExpressionRight<'tree> {
14179 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
14180 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
14181 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
14182 Expression(::std::boxed::Box<Expression<'tree>>),
14183 Identifier(::std::boxed::Box<Identifier<'tree>>),
14184 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
14185 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14186 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
14187}
14188impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
14189 #[allow(clippy::collapsible_else_if)]
14190 fn from_node(
14191 node: ::tree_sitter::Node<'tree>,
14192 src: &'tree [u8],
14193 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14194 match node.kind() {
14195 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
14196 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14197 ))),
14198 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
14199 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14200 ))),
14201 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
14202 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14203 ))),
14204 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14205 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14206 ))),
14207 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
14208 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
14209 ))),
14210 "parenthesized_expression" => {
14211 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
14212 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
14213 node, src,
14214 )?,
14215 )))
14216 }
14217 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
14218 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14219 ))),
14220 _other => {
14221 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14222 Ok(Self::Expression(::std::boxed::Box::new(v)))
14223 } else {
14224 Err(::treesitter_types::ParseError::unexpected_kind(
14225 _other, node,
14226 ))
14227 }
14228 }
14229 }
14230 }
14231}
14232impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
14233 fn span(&self) -> ::treesitter_types::Span {
14234 match self {
14235 Self::BinaryExpression(inner) => inner.span(),
14236 Self::BooleanLiteral(inner) => inner.span(),
14237 Self::CharacterLiteral(inner) => inner.span(),
14238 Self::Expression(inner) => inner.span(),
14239 Self::Identifier(inner) => inner.span(),
14240 Self::IntegerLiteral(inner) => inner.span(),
14241 Self::ParenthesizedExpression(inner) => inner.span(),
14242 Self::UnaryExpression(inner) => inner.span(),
14243 }
14244 }
14245}
14246#[derive(Debug, Clone, PartialEq, Eq)]
14247pub enum BracketedParameterListType<'tree> {
14248 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
14249 NullableType(::std::boxed::Box<NullableType<'tree>>),
14250}
14251impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterListType<'tree> {
14252 #[allow(clippy::collapsible_else_if)]
14253 fn from_node(
14254 node: ::tree_sitter::Node<'tree>,
14255 src: &'tree [u8],
14256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14257 match node.kind() {
14258 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
14259 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
14260 ))),
14261 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
14262 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
14263 ))),
14264 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14265 }
14266 }
14267}
14268impl ::treesitter_types::Spanned for BracketedParameterListType<'_> {
14269 fn span(&self) -> ::treesitter_types::Span {
14270 match self {
14271 Self::ArrayType(inner) => inner.span(),
14272 Self::NullableType(inner) => inner.span(),
14273 }
14274 }
14275}
14276#[derive(Debug, Clone, PartialEq, Eq)]
14277pub enum BracketedParameterListChildren<'tree> {
14278 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14279 Parameter(::std::boxed::Box<Parameter<'tree>>),
14280}
14281impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterListChildren<'tree> {
14282 #[allow(clippy::collapsible_else_if)]
14283 fn from_node(
14284 node: ::tree_sitter::Node<'tree>,
14285 src: &'tree [u8],
14286 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14287 match node.kind() {
14288 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14289 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14290 ))),
14291 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
14292 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
14293 ))),
14294 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14295 }
14296 }
14297}
14298impl ::treesitter_types::Spanned for BracketedParameterListChildren<'_> {
14299 fn span(&self) -> ::treesitter_types::Span {
14300 match self {
14301 Self::AttributeList(inner) => inner.span(),
14302 Self::Parameter(inner) => inner.span(),
14303 }
14304 }
14305}
14306#[derive(Debug, Clone, PartialEq, Eq)]
14307pub enum CatchClauseChildren<'tree> {
14308 CatchDeclaration(::std::boxed::Box<CatchDeclaration<'tree>>),
14309 CatchFilterClause(::std::boxed::Box<CatchFilterClause<'tree>>),
14310}
14311impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseChildren<'tree> {
14312 #[allow(clippy::collapsible_else_if)]
14313 fn from_node(
14314 node: ::tree_sitter::Node<'tree>,
14315 src: &'tree [u8],
14316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14317 match node.kind() {
14318 "catch_declaration" => Ok(Self::CatchDeclaration(::std::boxed::Box::new(
14319 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14320 ))),
14321 "catch_filter_clause" => Ok(Self::CatchFilterClause(::std::boxed::Box::new(
14322 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14323 ))),
14324 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14325 }
14326 }
14327}
14328impl ::treesitter_types::Spanned for CatchClauseChildren<'_> {
14329 fn span(&self) -> ::treesitter_types::Span {
14330 match self {
14331 Self::CatchDeclaration(inner) => inner.span(),
14332 Self::CatchFilterClause(inner) => inner.span(),
14333 }
14334 }
14335}
14336#[derive(Debug, Clone, PartialEq, Eq)]
14337pub enum CharacterLiteralChildren<'tree> {
14338 CharacterLiteralContent(::std::boxed::Box<CharacterLiteralContent<'tree>>),
14339 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
14340}
14341impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralChildren<'tree> {
14342 #[allow(clippy::collapsible_else_if)]
14343 fn from_node(
14344 node: ::tree_sitter::Node<'tree>,
14345 src: &'tree [u8],
14346 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14347 match node.kind() {
14348 "character_literal_content" => {
14349 Ok(Self::CharacterLiteralContent(::std::boxed::Box::new(
14350 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(
14351 node, src,
14352 )?,
14353 )))
14354 }
14355 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
14356 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
14357 ))),
14358 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14359 }
14360 }
14361}
14362impl ::treesitter_types::Spanned for CharacterLiteralChildren<'_> {
14363 fn span(&self) -> ::treesitter_types::Span {
14364 match self {
14365 Self::CharacterLiteralContent(inner) => inner.span(),
14366 Self::EscapeSequence(inner) => inner.span(),
14367 }
14368 }
14369}
14370#[derive(Debug, Clone, PartialEq, Eq)]
14371pub enum ClassDeclarationChildren<'tree> {
14372 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14373 BaseList(::std::boxed::Box<BaseList<'tree>>),
14374 Modifier(::std::boxed::Box<Modifier<'tree>>),
14375 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
14376 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
14377 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
14378}
14379impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarationChildren<'tree> {
14380 #[allow(clippy::collapsible_else_if)]
14381 fn from_node(
14382 node: ::tree_sitter::Node<'tree>,
14383 src: &'tree [u8],
14384 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14385 match node.kind() {
14386 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14387 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14388 ))),
14389 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
14390 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)?,
14391 ))),
14392 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14393 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14394 ))),
14395 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
14396 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
14397 ))),
14398 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
14399 ::std::boxed::Box::new(
14400 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
14401 node, src,
14402 )?,
14403 ),
14404 )),
14405 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
14406 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
14407 ))),
14408 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14409 }
14410 }
14411}
14412impl ::treesitter_types::Spanned for ClassDeclarationChildren<'_> {
14413 fn span(&self) -> ::treesitter_types::Span {
14414 match self {
14415 Self::AttributeList(inner) => inner.span(),
14416 Self::BaseList(inner) => inner.span(),
14417 Self::Modifier(inner) => inner.span(),
14418 Self::ParameterList(inner) => inner.span(),
14419 Self::TypeParameterConstraintsClause(inner) => inner.span(),
14420 Self::TypeParameterList(inner) => inner.span(),
14421 }
14422 }
14423}
14424#[derive(Debug, Clone, PartialEq, Eq)]
14425pub enum CompilationUnitChildren<'tree> {
14426 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
14427 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
14428 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
14429 GlobalStatement(::std::boxed::Box<GlobalStatement<'tree>>),
14430 NamespaceDeclaration(::std::boxed::Box<NamespaceDeclaration<'tree>>),
14431 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14432 ShebangDirective(::std::boxed::Box<ShebangDirective<'tree>>),
14433 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
14434 UsingDirective(::std::boxed::Box<UsingDirective<'tree>>),
14435}
14436impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnitChildren<'tree> {
14437 #[allow(clippy::collapsible_else_if)]
14438 fn from_node(
14439 node: ::tree_sitter::Node<'tree>,
14440 src: &'tree [u8],
14441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14442 match node.kind() {
14443 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
14444 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
14445 ))),
14446 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
14447 ::std::boxed::Box::new(
14448 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
14449 node, src,
14450 )?,
14451 ),
14452 )),
14453 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
14454 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
14455 ))),
14456 "global_statement" => Ok(Self::GlobalStatement(::std::boxed::Box::new(
14457 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
14458 ))),
14459 "namespace_declaration" => Ok(Self::NamespaceDeclaration(::std::boxed::Box::new(
14460 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14461 ))),
14462 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14463 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
14464 ))),
14465 "shebang_directive" => Ok(Self::ShebangDirective(::std::boxed::Box::new(
14466 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
14467 ))),
14468 "using_directive" => Ok(Self::UsingDirective(::std::boxed::Box::new(
14469 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
14470 ))),
14471 _other => {
14472 if let Ok(v) =
14473 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14474 {
14475 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
14476 } else {
14477 Err(::treesitter_types::ParseError::unexpected_kind(
14478 _other, node,
14479 ))
14480 }
14481 }
14482 }
14483 }
14484}
14485impl ::treesitter_types::Spanned for CompilationUnitChildren<'_> {
14486 fn span(&self) -> ::treesitter_types::Span {
14487 match self {
14488 Self::ExternAliasDirective(inner) => inner.span(),
14489 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
14490 Self::GlobalAttribute(inner) => inner.span(),
14491 Self::GlobalStatement(inner) => inner.span(),
14492 Self::NamespaceDeclaration(inner) => inner.span(),
14493 Self::PreprocIf(inner) => inner.span(),
14494 Self::ShebangDirective(inner) => inner.span(),
14495 Self::TypeDeclaration(inner) => inner.span(),
14496 Self::UsingDirective(inner) => inner.span(),
14497 }
14498 }
14499}
14500#[derive(Debug, Clone, PartialEq, Eq)]
14501pub enum ConditionalAccessExpressionChildren<'tree> {
14502 ElementBindingExpression(::std::boxed::Box<ElementBindingExpression<'tree>>),
14503 MemberBindingExpression(::std::boxed::Box<MemberBindingExpression<'tree>>),
14504}
14505impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpressionChildren<'tree> {
14506 #[allow(clippy::collapsible_else_if)]
14507 fn from_node(
14508 node: ::tree_sitter::Node<'tree>,
14509 src: &'tree [u8],
14510 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14511 match node.kind() {
14512 "element_binding_expression" => {
14513 Ok(Self::ElementBindingExpression(::std::boxed::Box::new(
14514 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(
14515 node, src,
14516 )?,
14517 )))
14518 }
14519 "member_binding_expression" => {
14520 Ok(Self::MemberBindingExpression(::std::boxed::Box::new(
14521 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(
14522 node, src,
14523 )?,
14524 )))
14525 }
14526 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14527 }
14528 }
14529}
14530impl ::treesitter_types::Spanned for ConditionalAccessExpressionChildren<'_> {
14531 fn span(&self) -> ::treesitter_types::Span {
14532 match self {
14533 Self::ElementBindingExpression(inner) => inner.span(),
14534 Self::MemberBindingExpression(inner) => inner.span(),
14535 }
14536 }
14537}
14538#[derive(Debug, Clone, PartialEq, Eq)]
14539pub enum ConstantPatternChildren<'tree> {
14540 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
14541 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14542 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
14543 GenericName(::std::boxed::Box<GenericName<'tree>>),
14544 Identifier(::std::boxed::Box<Identifier<'tree>>),
14545 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
14546 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
14547 Literal(::std::boxed::Box<Literal<'tree>>),
14548 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14549 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14550 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
14551 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
14552 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
14553 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
14554 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
14555}
14556impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPatternChildren<'tree> {
14557 #[allow(clippy::collapsible_else_if)]
14558 fn from_node(
14559 node: ::tree_sitter::Node<'tree>,
14560 src: &'tree [u8],
14561 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14562 match node.kind() {
14563 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
14564 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14565 ))),
14566 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14567 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14568 ))),
14569 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
14570 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14571 ))),
14572 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14573 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
14574 ))),
14575 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14576 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14577 ))),
14578 "interpolated_string_expression" => {
14579 Ok(Self::InterpolatedStringExpression(::std::boxed::Box::new(
14580 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
14581 node, src,
14582 )?,
14583 )))
14584 }
14585 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
14586 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14587 ))),
14588 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14589 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14590 ))),
14591 "parenthesized_expression" => {
14592 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
14593 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
14594 node, src,
14595 )?,
14596 )))
14597 }
14598 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
14599 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14600 ))),
14601 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
14602 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14603 ))),
14604 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
14605 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14606 ))),
14607 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
14608 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14609 ))),
14610 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
14611 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14612 ))),
14613 _other => {
14614 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
14615 Ok(Self::Literal(::std::boxed::Box::new(v)))
14616 } else {
14617 Err(::treesitter_types::ParseError::unexpected_kind(
14618 _other, node,
14619 ))
14620 }
14621 }
14622 }
14623 }
14624}
14625impl ::treesitter_types::Spanned for ConstantPatternChildren<'_> {
14626 fn span(&self) -> ::treesitter_types::Span {
14627 match self {
14628 Self::BinaryExpression(inner) => inner.span(),
14629 Self::CastExpression(inner) => inner.span(),
14630 Self::DefaultExpression(inner) => inner.span(),
14631 Self::GenericName(inner) => inner.span(),
14632 Self::Identifier(inner) => inner.span(),
14633 Self::InterpolatedStringExpression(inner) => inner.span(),
14634 Self::InvocationExpression(inner) => inner.span(),
14635 Self::Literal(inner) => inner.span(),
14636 Self::MemberAccessExpression(inner) => inner.span(),
14637 Self::ParenthesizedExpression(inner) => inner.span(),
14638 Self::PostfixUnaryExpression(inner) => inner.span(),
14639 Self::PrefixUnaryExpression(inner) => inner.span(),
14640 Self::SizeofExpression(inner) => inner.span(),
14641 Self::TupleExpression(inner) => inner.span(),
14642 Self::TypeofExpression(inner) => inner.span(),
14643 }
14644 }
14645}
14646#[derive(Debug, Clone, PartialEq, Eq)]
14647pub enum ConstructorDeclarationBody<'tree> {
14648 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
14649 Block(::std::boxed::Box<Block<'tree>>),
14650}
14651impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationBody<'tree> {
14652 #[allow(clippy::collapsible_else_if)]
14653 fn from_node(
14654 node: ::tree_sitter::Node<'tree>,
14655 src: &'tree [u8],
14656 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14657 match node.kind() {
14658 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
14659 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14660 ))),
14661 "block" => Ok(Self::Block(::std::boxed::Box::new(
14662 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
14663 ))),
14664 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14665 }
14666 }
14667}
14668impl ::treesitter_types::Spanned for ConstructorDeclarationBody<'_> {
14669 fn span(&self) -> ::treesitter_types::Span {
14670 match self {
14671 Self::ArrowExpressionClause(inner) => inner.span(),
14672 Self::Block(inner) => inner.span(),
14673 }
14674 }
14675}
14676#[derive(Debug, Clone, PartialEq, Eq)]
14677pub enum ConstructorDeclarationChildren<'tree> {
14678 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14679 ConstructorInitializer(::std::boxed::Box<ConstructorInitializer<'tree>>),
14680 Modifier(::std::boxed::Box<Modifier<'tree>>),
14681}
14682impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
14683 #[allow(clippy::collapsible_else_if)]
14684 fn from_node(
14685 node: ::tree_sitter::Node<'tree>,
14686 src: &'tree [u8],
14687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14688 match node.kind() {
14689 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14690 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14691 ))),
14692 "constructor_initializer" => Ok(Self::ConstructorInitializer(::std::boxed::Box::new(
14693 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
14694 ))),
14695 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14696 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14697 ))),
14698 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14699 }
14700 }
14701}
14702impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
14703 fn span(&self) -> ::treesitter_types::Span {
14704 match self {
14705 Self::AttributeList(inner) => inner.span(),
14706 Self::ConstructorInitializer(inner) => inner.span(),
14707 Self::Modifier(inner) => inner.span(),
14708 }
14709 }
14710}
14711#[derive(Debug, Clone, PartialEq, Eq)]
14712pub enum ConversionOperatorDeclarationBody<'tree> {
14713 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
14714 Block(::std::boxed::Box<Block<'tree>>),
14715}
14716impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationBody<'tree> {
14717 #[allow(clippy::collapsible_else_if)]
14718 fn from_node(
14719 node: ::tree_sitter::Node<'tree>,
14720 src: &'tree [u8],
14721 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14722 match node.kind() {
14723 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
14724 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14725 ))),
14726 "block" => Ok(Self::Block(::std::boxed::Box::new(
14727 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
14728 ))),
14729 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14730 }
14731 }
14732}
14733impl ::treesitter_types::Spanned for ConversionOperatorDeclarationBody<'_> {
14734 fn span(&self) -> ::treesitter_types::Span {
14735 match self {
14736 Self::ArrowExpressionClause(inner) => inner.span(),
14737 Self::Block(inner) => inner.span(),
14738 }
14739 }
14740}
14741#[derive(Debug, Clone, PartialEq, Eq)]
14742pub enum ConversionOperatorDeclarationChildren<'tree> {
14743 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14744 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
14745 Modifier(::std::boxed::Box<Modifier<'tree>>),
14746}
14747impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationChildren<'tree> {
14748 #[allow(clippy::collapsible_else_if)]
14749 fn from_node(
14750 node: ::tree_sitter::Node<'tree>,
14751 src: &'tree [u8],
14752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14753 match node.kind() {
14754 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14755 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14756 ))),
14757 "explicit_interface_specifier" => {
14758 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
14759 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
14760 node, src,
14761 )?,
14762 )))
14763 }
14764 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14765 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14766 ))),
14767 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14768 }
14769 }
14770}
14771impl ::treesitter_types::Spanned for ConversionOperatorDeclarationChildren<'_> {
14772 fn span(&self) -> ::treesitter_types::Span {
14773 match self {
14774 Self::AttributeList(inner) => inner.span(),
14775 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
14776 Self::Modifier(inner) => inner.span(),
14777 }
14778 }
14779}
14780#[derive(Debug, Clone, PartialEq, Eq)]
14781pub enum DeclarationPatternChildren<'tree> {
14782 Discard(::std::boxed::Box<Discard<'tree>>),
14783 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
14784}
14785impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPatternChildren<'tree> {
14786 #[allow(clippy::collapsible_else_if)]
14787 fn from_node(
14788 node: ::tree_sitter::Node<'tree>,
14789 src: &'tree [u8],
14790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14791 match node.kind() {
14792 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
14793 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
14794 ))),
14795 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
14796 ::std::boxed::Box::new(
14797 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
14798 node, src,
14799 )?,
14800 ),
14801 )),
14802 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14803 }
14804 }
14805}
14806impl ::treesitter_types::Spanned for DeclarationPatternChildren<'_> {
14807 fn span(&self) -> ::treesitter_types::Span {
14808 match self {
14809 Self::Discard(inner) => inner.span(),
14810 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
14811 }
14812 }
14813}
14814#[derive(Debug, Clone, PartialEq, Eq)]
14815pub enum DelegateDeclarationChildren<'tree> {
14816 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14817 Modifier(::std::boxed::Box<Modifier<'tree>>),
14818 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
14819}
14820impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclarationChildren<'tree> {
14821 #[allow(clippy::collapsible_else_if)]
14822 fn from_node(
14823 node: ::tree_sitter::Node<'tree>,
14824 src: &'tree [u8],
14825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14826 match node.kind() {
14827 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14828 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14829 ))),
14830 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14831 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14832 ))),
14833 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
14834 ::std::boxed::Box::new(
14835 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
14836 node, src,
14837 )?,
14838 ),
14839 )),
14840 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14841 }
14842 }
14843}
14844impl ::treesitter_types::Spanned for DelegateDeclarationChildren<'_> {
14845 fn span(&self) -> ::treesitter_types::Span {
14846 match self {
14847 Self::AttributeList(inner) => inner.span(),
14848 Self::Modifier(inner) => inner.span(),
14849 Self::TypeParameterConstraintsClause(inner) => inner.span(),
14850 }
14851 }
14852}
14853#[derive(Debug, Clone, PartialEq, Eq)]
14854pub enum DestructorDeclarationBody<'tree> {
14855 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
14856 Block(::std::boxed::Box<Block<'tree>>),
14857}
14858impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclarationBody<'tree> {
14859 #[allow(clippy::collapsible_else_if)]
14860 fn from_node(
14861 node: ::tree_sitter::Node<'tree>,
14862 src: &'tree [u8],
14863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14864 match node.kind() {
14865 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
14866 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14867 ))),
14868 "block" => Ok(Self::Block(::std::boxed::Box::new(
14869 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
14870 ))),
14871 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14872 }
14873 }
14874}
14875impl ::treesitter_types::Spanned for DestructorDeclarationBody<'_> {
14876 fn span(&self) -> ::treesitter_types::Span {
14877 match self {
14878 Self::ArrowExpressionClause(inner) => inner.span(),
14879 Self::Block(inner) => inner.span(),
14880 }
14881 }
14882}
14883#[derive(Debug, Clone, PartialEq, Eq)]
14884pub enum EnumDeclarationChildren<'tree> {
14885 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14886 BaseList(::std::boxed::Box<BaseList<'tree>>),
14887 Modifier(::std::boxed::Box<Modifier<'tree>>),
14888}
14889impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationChildren<'tree> {
14890 #[allow(clippy::collapsible_else_if)]
14891 fn from_node(
14892 node: ::tree_sitter::Node<'tree>,
14893 src: &'tree [u8],
14894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14895 match node.kind() {
14896 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14897 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14898 ))),
14899 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
14900 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)?,
14901 ))),
14902 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14903 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14904 ))),
14905 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14906 }
14907 }
14908}
14909impl ::treesitter_types::Spanned for EnumDeclarationChildren<'_> {
14910 fn span(&self) -> ::treesitter_types::Span {
14911 match self {
14912 Self::AttributeList(inner) => inner.span(),
14913 Self::BaseList(inner) => inner.span(),
14914 Self::Modifier(inner) => inner.span(),
14915 }
14916 }
14917}
14918#[derive(Debug, Clone, PartialEq, Eq)]
14919pub enum EnumMemberDeclarationListChildren<'tree> {
14920 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
14921 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14922}
14923impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationListChildren<'tree> {
14924 #[allow(clippy::collapsible_else_if)]
14925 fn from_node(
14926 node: ::tree_sitter::Node<'tree>,
14927 src: &'tree [u8],
14928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14929 match node.kind() {
14930 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
14931 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14932 ))),
14933 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14934 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
14935 ))),
14936 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14937 }
14938 }
14939}
14940impl ::treesitter_types::Spanned for EnumMemberDeclarationListChildren<'_> {
14941 fn span(&self) -> ::treesitter_types::Span {
14942 match self {
14943 Self::EnumMemberDeclaration(inner) => inner.span(),
14944 Self::PreprocIf(inner) => inner.span(),
14945 }
14946 }
14947}
14948#[derive(Debug, Clone, PartialEq, Eq)]
14949pub enum EventDeclarationChildren<'tree> {
14950 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14951 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
14952 Modifier(::std::boxed::Box<Modifier<'tree>>),
14953}
14954impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclarationChildren<'tree> {
14955 #[allow(clippy::collapsible_else_if)]
14956 fn from_node(
14957 node: ::tree_sitter::Node<'tree>,
14958 src: &'tree [u8],
14959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14960 match node.kind() {
14961 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14962 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
14963 ))),
14964 "explicit_interface_specifier" => {
14965 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
14966 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
14967 node, src,
14968 )?,
14969 )))
14970 }
14971 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14972 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14973 ))),
14974 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14975 }
14976 }
14977}
14978impl ::treesitter_types::Spanned for EventDeclarationChildren<'_> {
14979 fn span(&self) -> ::treesitter_types::Span {
14980 match self {
14981 Self::AttributeList(inner) => inner.span(),
14982 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
14983 Self::Modifier(inner) => inner.span(),
14984 }
14985 }
14986}
14987#[derive(Debug, Clone, PartialEq, Eq)]
14988pub enum EventFieldDeclarationChildren<'tree> {
14989 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14990 Modifier(::std::boxed::Box<Modifier<'tree>>),
14991 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
14992}
14993impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclarationChildren<'tree> {
14994 #[allow(clippy::collapsible_else_if)]
14995 fn from_node(
14996 node: ::tree_sitter::Node<'tree>,
14997 src: &'tree [u8],
14998 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14999 match node.kind() {
15000 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15001 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
15002 ))),
15003 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15004 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15005 ))),
15006 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15007 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15008 ))),
15009 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15010 }
15011 }
15012}
15013impl ::treesitter_types::Spanned for EventFieldDeclarationChildren<'_> {
15014 fn span(&self) -> ::treesitter_types::Span {
15015 match self {
15016 Self::AttributeList(inner) => inner.span(),
15017 Self::Modifier(inner) => inner.span(),
15018 Self::VariableDeclaration(inner) => inner.span(),
15019 }
15020 }
15021}
15022#[derive(Debug, Clone, PartialEq, Eq)]
15023pub enum ExplicitInterfaceSpecifierChildren<'tree> {
15024 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15025 GenericName(::std::boxed::Box<GenericName<'tree>>),
15026 Identifier(::std::boxed::Box<Identifier<'tree>>),
15027 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15028}
15029impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifierChildren<'tree> {
15030 #[allow(clippy::collapsible_else_if)]
15031 fn from_node(
15032 node: ::tree_sitter::Node<'tree>,
15033 src: &'tree [u8],
15034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15035 match node.kind() {
15036 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15037 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15038 ))),
15039 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15040 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
15041 ))),
15042 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15043 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15044 ))),
15045 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15046 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15047 ))),
15048 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15049 }
15050 }
15051}
15052impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifierChildren<'_> {
15053 fn span(&self) -> ::treesitter_types::Span {
15054 match self {
15055 Self::AliasQualifiedName(inner) => inner.span(),
15056 Self::GenericName(inner) => inner.span(),
15057 Self::Identifier(inner) => inner.span(),
15058 Self::QualifiedName(inner) => inner.span(),
15059 }
15060 }
15061}
15062#[derive(Debug, Clone, PartialEq, Eq)]
15063pub enum ExpressionStatementChildren<'tree> {
15064 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
15065 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
15066 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
15067 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
15068 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15069 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
15070 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
15071}
15072impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
15073 #[allow(clippy::collapsible_else_if)]
15074 fn from_node(
15075 node: ::tree_sitter::Node<'tree>,
15076 src: &'tree [u8],
15077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15078 match node.kind() {
15079 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
15080 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15081 ))),
15082 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
15083 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15084 ))),
15085 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
15086 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15087 ))),
15088 "object_creation_expression" => {
15089 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
15090 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
15091 node, src,
15092 )?,
15093 )))
15094 }
15095 "parenthesized_expression" => {
15096 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
15097 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
15098 node, src,
15099 )?,
15100 )))
15101 }
15102 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
15103 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15104 ))),
15105 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
15106 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15107 ))),
15108 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15109 }
15110 }
15111}
15112impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
15113 fn span(&self) -> ::treesitter_types::Span {
15114 match self {
15115 Self::AssignmentExpression(inner) => inner.span(),
15116 Self::AwaitExpression(inner) => inner.span(),
15117 Self::InvocationExpression(inner) => inner.span(),
15118 Self::ObjectCreationExpression(inner) => inner.span(),
15119 Self::ParenthesizedExpression(inner) => inner.span(),
15120 Self::PostfixUnaryExpression(inner) => inner.span(),
15121 Self::PrefixUnaryExpression(inner) => inner.span(),
15122 }
15123 }
15124}
15125#[derive(Debug, Clone, PartialEq, Eq)]
15126pub enum FieldDeclarationChildren<'tree> {
15127 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15128 Modifier(::std::boxed::Box<Modifier<'tree>>),
15129 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15130}
15131impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
15132 #[allow(clippy::collapsible_else_if)]
15133 fn from_node(
15134 node: ::tree_sitter::Node<'tree>,
15135 src: &'tree [u8],
15136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15137 match node.kind() {
15138 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15139 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
15140 ))),
15141 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15142 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15143 ))),
15144 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15145 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15146 ))),
15147 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15148 }
15149 }
15150}
15151impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
15152 fn span(&self) -> ::treesitter_types::Span {
15153 match self {
15154 Self::AttributeList(inner) => inner.span(),
15155 Self::Modifier(inner) => inner.span(),
15156 Self::VariableDeclaration(inner) => inner.span(),
15157 }
15158 }
15159}
15160#[derive(Debug, Clone, PartialEq, Eq)]
15161pub enum FileScopedNamespaceDeclarationName<'tree> {
15162 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15163 GenericName(::std::boxed::Box<GenericName<'tree>>),
15164 Identifier(::std::boxed::Box<Identifier<'tree>>),
15165 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15166}
15167impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclarationName<'tree> {
15168 #[allow(clippy::collapsible_else_if)]
15169 fn from_node(
15170 node: ::tree_sitter::Node<'tree>,
15171 src: &'tree [u8],
15172 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15173 match node.kind() {
15174 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15175 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15176 ))),
15177 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15178 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
15179 ))),
15180 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15181 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15182 ))),
15183 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15184 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15185 ))),
15186 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15187 }
15188 }
15189}
15190impl ::treesitter_types::Spanned for FileScopedNamespaceDeclarationName<'_> {
15191 fn span(&self) -> ::treesitter_types::Span {
15192 match self {
15193 Self::AliasQualifiedName(inner) => inner.span(),
15194 Self::GenericName(inner) => inner.span(),
15195 Self::Identifier(inner) => inner.span(),
15196 Self::QualifiedName(inner) => inner.span(),
15197 }
15198 }
15199}
15200#[derive(Debug, Clone, PartialEq, Eq)]
15201pub enum FixedStatementChildren<'tree> {
15202 Statement(::std::boxed::Box<Statement<'tree>>),
15203 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15204}
15205impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatementChildren<'tree> {
15206 #[allow(clippy::collapsible_else_if)]
15207 fn from_node(
15208 node: ::tree_sitter::Node<'tree>,
15209 src: &'tree [u8],
15210 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15211 match node.kind() {
15212 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15213 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15214 ))),
15215 _other => {
15216 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
15217 Ok(Self::Statement(::std::boxed::Box::new(v)))
15218 } else {
15219 Err(::treesitter_types::ParseError::unexpected_kind(
15220 _other, node,
15221 ))
15222 }
15223 }
15224 }
15225 }
15226}
15227impl ::treesitter_types::Spanned for FixedStatementChildren<'_> {
15228 fn span(&self) -> ::treesitter_types::Span {
15229 match self {
15230 Self::Statement(inner) => inner.span(),
15231 Self::VariableDeclaration(inner) => inner.span(),
15232 }
15233 }
15234}
15235#[derive(Debug, Clone, PartialEq, Eq)]
15236pub enum ForStatementInitializer<'tree> {
15237 Comma(::treesitter_types::Span),
15238 Expression(::std::boxed::Box<Expression<'tree>>),
15239 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15240}
15241impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
15242 #[allow(clippy::collapsible_else_if)]
15243 fn from_node(
15244 node: ::tree_sitter::Node<'tree>,
15245 src: &'tree [u8],
15246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15247 match node.kind() {
15248 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
15249 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15250 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15251 ))),
15252 _other => {
15253 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15254 Ok(Self::Expression(::std::boxed::Box::new(v)))
15255 } else {
15256 Err(::treesitter_types::ParseError::unexpected_kind(
15257 _other, node,
15258 ))
15259 }
15260 }
15261 }
15262 }
15263}
15264impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
15265 fn span(&self) -> ::treesitter_types::Span {
15266 match self {
15267 Self::Comma(span) => *span,
15268 Self::Expression(inner) => inner.span(),
15269 Self::VariableDeclaration(inner) => inner.span(),
15270 }
15271 }
15272}
15273#[derive(Debug, Clone, PartialEq, Eq)]
15274pub enum ForStatementUpdate<'tree> {
15275 Comma(::treesitter_types::Span),
15276 Expression(::std::boxed::Box<Expression<'tree>>),
15277}
15278impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
15279 #[allow(clippy::collapsible_else_if)]
15280 fn from_node(
15281 node: ::tree_sitter::Node<'tree>,
15282 src: &'tree [u8],
15283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15284 match node.kind() {
15285 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
15286 _other => {
15287 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15288 Ok(Self::Expression(::std::boxed::Box::new(v)))
15289 } else {
15290 Err(::treesitter_types::ParseError::unexpected_kind(
15291 _other, node,
15292 ))
15293 }
15294 }
15295 }
15296 }
15297}
15298impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
15299 fn span(&self) -> ::treesitter_types::Span {
15300 match self {
15301 Self::Comma(span) => *span,
15302 Self::Expression(inner) => inner.span(),
15303 }
15304 }
15305}
15306#[derive(Debug, Clone, PartialEq, Eq)]
15307pub enum ForeachStatementLeft<'tree> {
15308 Expression(::std::boxed::Box<Expression<'tree>>),
15309 Identifier(::std::boxed::Box<Identifier<'tree>>),
15310 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
15311}
15312impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementLeft<'tree> {
15313 #[allow(clippy::collapsible_else_if)]
15314 fn from_node(
15315 node: ::tree_sitter::Node<'tree>,
15316 src: &'tree [u8],
15317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15318 match node.kind() {
15319 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15320 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15321 ))),
15322 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
15323 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
15324 ))),
15325 _other => {
15326 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15327 Ok(Self::Expression(::std::boxed::Box::new(v)))
15328 } else {
15329 Err(::treesitter_types::ParseError::unexpected_kind(
15330 _other, node,
15331 ))
15332 }
15333 }
15334 }
15335 }
15336}
15337impl ::treesitter_types::Spanned for ForeachStatementLeft<'_> {
15338 fn span(&self) -> ::treesitter_types::Span {
15339 match self {
15340 Self::Expression(inner) => inner.span(),
15341 Self::Identifier(inner) => inner.span(),
15342 Self::TuplePattern(inner) => inner.span(),
15343 }
15344 }
15345}
15346#[derive(Debug, Clone, PartialEq, Eq)]
15347pub enum FunctionPointerParameterType<'tree> {
15348 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15349 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
15350 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
15351 GenericName(::std::boxed::Box<GenericName<'tree>>),
15352 Identifier(::std::boxed::Box<Identifier<'tree>>),
15353 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
15354 NullableType(::std::boxed::Box<NullableType<'tree>>),
15355 PointerType(::std::boxed::Box<PointerType<'tree>>),
15356 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
15357 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15358 TupleType(::std::boxed::Box<TupleType<'tree>>),
15359}
15360impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameterType<'tree> {
15361 #[allow(clippy::collapsible_else_if)]
15362 fn from_node(
15363 node: ::tree_sitter::Node<'tree>,
15364 src: &'tree [u8],
15365 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15366 match node.kind() {
15367 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15368 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15369 ))),
15370 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
15371 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
15372 ))),
15373 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
15374 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
15375 ))),
15376 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15377 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
15378 ))),
15379 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15380 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15381 ))),
15382 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
15383 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)?,
15384 ))),
15385 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
15386 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
15387 ))),
15388 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
15389 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
15390 ))),
15391 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
15392 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
15393 ))),
15394 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15395 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
15396 ))),
15397 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
15398 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
15399 ))),
15400 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15401 }
15402 }
15403}
15404impl ::treesitter_types::Spanned for FunctionPointerParameterType<'_> {
15405 fn span(&self) -> ::treesitter_types::Span {
15406 match self {
15407 Self::AliasQualifiedName(inner) => inner.span(),
15408 Self::ArrayType(inner) => inner.span(),
15409 Self::FunctionPointerType(inner) => inner.span(),
15410 Self::GenericName(inner) => inner.span(),
15411 Self::Identifier(inner) => inner.span(),
15412 Self::ImplicitType(inner) => inner.span(),
15413 Self::NullableType(inner) => inner.span(),
15414 Self::PointerType(inner) => inner.span(),
15415 Self::PredefinedType(inner) => inner.span(),
15416 Self::QualifiedName(inner) => inner.span(),
15417 Self::TupleType(inner) => inner.span(),
15418 }
15419 }
15420}
15421#[derive(Debug, Clone, PartialEq, Eq)]
15422pub enum FunctionPointerTypeChildren<'tree> {
15423 CallingConvention(::std::boxed::Box<CallingConvention<'tree>>),
15424 FunctionPointerParameter(::std::boxed::Box<FunctionPointerParameter<'tree>>),
15425}
15426impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerTypeChildren<'tree> {
15427 #[allow(clippy::collapsible_else_if)]
15428 fn from_node(
15429 node: ::tree_sitter::Node<'tree>,
15430 src: &'tree [u8],
15431 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15432 match node.kind() {
15433 "calling_convention" => Ok(Self::CallingConvention(::std::boxed::Box::new(
15434 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)?,
15435 ))),
15436 "function_pointer_parameter" => {
15437 Ok(Self::FunctionPointerParameter(::std::boxed::Box::new(
15438 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(
15439 node, src,
15440 )?,
15441 )))
15442 }
15443 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15444 }
15445 }
15446}
15447impl ::treesitter_types::Spanned for FunctionPointerTypeChildren<'_> {
15448 fn span(&self) -> ::treesitter_types::Span {
15449 match self {
15450 Self::CallingConvention(inner) => inner.span(),
15451 Self::FunctionPointerParameter(inner) => inner.span(),
15452 }
15453 }
15454}
15455#[derive(Debug, Clone, PartialEq, Eq)]
15456pub enum GenericNameChildren<'tree> {
15457 Identifier(::std::boxed::Box<Identifier<'tree>>),
15458 TypeArgumentList(::std::boxed::Box<TypeArgumentList<'tree>>),
15459}
15460impl<'tree> ::treesitter_types::FromNode<'tree> for GenericNameChildren<'tree> {
15461 #[allow(clippy::collapsible_else_if)]
15462 fn from_node(
15463 node: ::tree_sitter::Node<'tree>,
15464 src: &'tree [u8],
15465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15466 match node.kind() {
15467 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15468 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15469 ))),
15470 "type_argument_list" => Ok(Self::TypeArgumentList(::std::boxed::Box::new(
15471 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
15472 ))),
15473 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15474 }
15475 }
15476}
15477impl ::treesitter_types::Spanned for GenericNameChildren<'_> {
15478 fn span(&self) -> ::treesitter_types::Span {
15479 match self {
15480 Self::Identifier(inner) => inner.span(),
15481 Self::TypeArgumentList(inner) => inner.span(),
15482 }
15483 }
15484}
15485#[derive(Debug, Clone, PartialEq, Eq)]
15486pub enum ImplicitObjectCreationExpressionChildren<'tree> {
15487 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
15488 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
15489}
15490impl<'tree> ::treesitter_types::FromNode<'tree>
15491 for ImplicitObjectCreationExpressionChildren<'tree>
15492{
15493 #[allow(clippy::collapsible_else_if)]
15494 fn from_node(
15495 node: ::tree_sitter::Node<'tree>,
15496 src: &'tree [u8],
15497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15498 match node.kind() {
15499 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
15500 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
15501 ))),
15502 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
15503 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15504 ))),
15505 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15506 }
15507 }
15508}
15509impl ::treesitter_types::Spanned for ImplicitObjectCreationExpressionChildren<'_> {
15510 fn span(&self) -> ::treesitter_types::Span {
15511 match self {
15512 Self::ArgumentList(inner) => inner.span(),
15513 Self::InitializerExpression(inner) => inner.span(),
15514 }
15515 }
15516}
15517#[derive(Debug, Clone, PartialEq, Eq)]
15518pub enum IndexerDeclarationChildren<'tree> {
15519 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15520 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
15521 Modifier(::std::boxed::Box<Modifier<'tree>>),
15522}
15523impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclarationChildren<'tree> {
15524 #[allow(clippy::collapsible_else_if)]
15525 fn from_node(
15526 node: ::tree_sitter::Node<'tree>,
15527 src: &'tree [u8],
15528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15529 match node.kind() {
15530 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15531 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
15532 ))),
15533 "explicit_interface_specifier" => {
15534 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
15535 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
15536 node, src,
15537 )?,
15538 )))
15539 }
15540 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15541 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15542 ))),
15543 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15544 }
15545 }
15546}
15547impl ::treesitter_types::Spanned for IndexerDeclarationChildren<'_> {
15548 fn span(&self) -> ::treesitter_types::Span {
15549 match self {
15550 Self::AttributeList(inner) => inner.span(),
15551 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
15552 Self::Modifier(inner) => inner.span(),
15553 }
15554 }
15555}
15556#[derive(Debug, Clone, PartialEq, Eq)]
15557pub enum InterfaceDeclarationChildren<'tree> {
15558 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15559 BaseList(::std::boxed::Box<BaseList<'tree>>),
15560 Modifier(::std::boxed::Box<Modifier<'tree>>),
15561 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
15562}
15563impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
15564 #[allow(clippy::collapsible_else_if)]
15565 fn from_node(
15566 node: ::tree_sitter::Node<'tree>,
15567 src: &'tree [u8],
15568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15569 match node.kind() {
15570 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15571 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
15572 ))),
15573 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
15574 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)?,
15575 ))),
15576 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15577 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15578 ))),
15579 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
15580 ::std::boxed::Box::new(
15581 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
15582 node, src,
15583 )?,
15584 ),
15585 )),
15586 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15587 }
15588 }
15589}
15590impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
15591 fn span(&self) -> ::treesitter_types::Span {
15592 match self {
15593 Self::AttributeList(inner) => inner.span(),
15594 Self::BaseList(inner) => inner.span(),
15595 Self::Modifier(inner) => inner.span(),
15596 Self::TypeParameterConstraintsClause(inner) => inner.span(),
15597 }
15598 }
15599}
15600#[derive(Debug, Clone, PartialEq, Eq)]
15601pub enum InterpolatedStringExpressionChildren<'tree> {
15602 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
15603 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
15604 InterpolationQuote(::std::boxed::Box<InterpolationQuote<'tree>>),
15605 InterpolationStart(::std::boxed::Box<InterpolationStart<'tree>>),
15606 StringContent(::std::boxed::Box<StringContent<'tree>>),
15607}
15608impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpressionChildren<'tree> {
15609 #[allow(clippy::collapsible_else_if)]
15610 fn from_node(
15611 node: ::tree_sitter::Node<'tree>,
15612 src: &'tree [u8],
15613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15614 match node.kind() {
15615 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
15616 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
15617 ))),
15618 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
15619 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
15620 ))),
15621 "interpolation_quote" => Ok(Self::InterpolationQuote(::std::boxed::Box::new(
15622 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)?,
15623 ))),
15624 "interpolation_start" => Ok(Self::InterpolationStart(::std::boxed::Box::new(
15625 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)?,
15626 ))),
15627 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
15628 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
15629 ))),
15630 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15631 }
15632 }
15633}
15634impl ::treesitter_types::Spanned for InterpolatedStringExpressionChildren<'_> {
15635 fn span(&self) -> ::treesitter_types::Span {
15636 match self {
15637 Self::EscapeSequence(inner) => inner.span(),
15638 Self::Interpolation(inner) => inner.span(),
15639 Self::InterpolationQuote(inner) => inner.span(),
15640 Self::InterpolationStart(inner) => inner.span(),
15641 Self::StringContent(inner) => inner.span(),
15642 }
15643 }
15644}
15645#[derive(Debug, Clone, PartialEq, Eq)]
15646pub enum InterpolationChildren<'tree> {
15647 Expression(::std::boxed::Box<Expression<'tree>>),
15648 InterpolationAlignmentClause(::std::boxed::Box<InterpolationAlignmentClause<'tree>>),
15649 InterpolationBrace(::std::boxed::Box<InterpolationBrace<'tree>>),
15650 InterpolationFormatClause(::std::boxed::Box<InterpolationFormatClause<'tree>>),
15651}
15652impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
15653 #[allow(clippy::collapsible_else_if)]
15654 fn from_node(
15655 node: ::tree_sitter::Node<'tree>,
15656 src: &'tree [u8],
15657 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15658 match node.kind() {
15659 "interpolation_alignment_clause" => {
15660 Ok(Self::InterpolationAlignmentClause(::std::boxed::Box::new(
15661 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(
15662 node, src,
15663 )?,
15664 )))
15665 }
15666 "interpolation_brace" => Ok(Self::InterpolationBrace(::std::boxed::Box::new(
15667 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)?,
15668 ))),
15669 "interpolation_format_clause" => {
15670 Ok(Self::InterpolationFormatClause(::std::boxed::Box::new(
15671 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(
15672 node, src,
15673 )?,
15674 )))
15675 }
15676 _other => {
15677 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15678 Ok(Self::Expression(::std::boxed::Box::new(v)))
15679 } else {
15680 Err(::treesitter_types::ParseError::unexpected_kind(
15681 _other, node,
15682 ))
15683 }
15684 }
15685 }
15686 }
15687}
15688impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
15689 fn span(&self) -> ::treesitter_types::Span {
15690 match self {
15691 Self::Expression(inner) => inner.span(),
15692 Self::InterpolationAlignmentClause(inner) => inner.span(),
15693 Self::InterpolationBrace(inner) => inner.span(),
15694 Self::InterpolationFormatClause(inner) => inner.span(),
15695 }
15696 }
15697}
15698#[derive(Debug, Clone, PartialEq, Eq)]
15699pub enum IsExpressionOperator {
15700 Is(::treesitter_types::Span),
15701}
15702impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpressionOperator {
15703 #[allow(clippy::collapsible_else_if)]
15704 fn from_node(
15705 node: ::tree_sitter::Node<'tree>,
15706 _src: &'tree [u8],
15707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15708 match node.kind() {
15709 "is" => Ok(Self::Is(::treesitter_types::Span::from(node))),
15710 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15711 }
15712 }
15713}
15714impl ::treesitter_types::Spanned for IsExpressionOperator {
15715 fn span(&self) -> ::treesitter_types::Span {
15716 match self {
15717 Self::Is(span) => *span,
15718 }
15719 }
15720}
15721#[derive(Debug, Clone, PartialEq, Eq)]
15722pub enum JoinClauseChildren<'tree> {
15723 Expression(::std::boxed::Box<Expression<'tree>>),
15724 Identifier(::std::boxed::Box<Identifier<'tree>>),
15725 JoinIntoClause(::std::boxed::Box<JoinIntoClause<'tree>>),
15726}
15727impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClauseChildren<'tree> {
15728 #[allow(clippy::collapsible_else_if)]
15729 fn from_node(
15730 node: ::tree_sitter::Node<'tree>,
15731 src: &'tree [u8],
15732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15733 match node.kind() {
15734 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15735 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15736 ))),
15737 "join_into_clause" => Ok(Self::JoinIntoClause(::std::boxed::Box::new(
15738 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15739 ))),
15740 _other => {
15741 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15742 Ok(Self::Expression(::std::boxed::Box::new(v)))
15743 } else {
15744 Err(::treesitter_types::ParseError::unexpected_kind(
15745 _other, node,
15746 ))
15747 }
15748 }
15749 }
15750 }
15751}
15752impl ::treesitter_types::Spanned for JoinClauseChildren<'_> {
15753 fn span(&self) -> ::treesitter_types::Span {
15754 match self {
15755 Self::Expression(inner) => inner.span(),
15756 Self::Identifier(inner) => inner.span(),
15757 Self::JoinIntoClause(inner) => inner.span(),
15758 }
15759 }
15760}
15761#[derive(Debug, Clone, PartialEq, Eq)]
15762pub enum LabeledStatementChildren<'tree> {
15763 Identifier(::std::boxed::Box<Identifier<'tree>>),
15764 Statement(::std::boxed::Box<Statement<'tree>>),
15765}
15766impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
15767 #[allow(clippy::collapsible_else_if)]
15768 fn from_node(
15769 node: ::tree_sitter::Node<'tree>,
15770 src: &'tree [u8],
15771 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15772 match node.kind() {
15773 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15774 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15775 ))),
15776 _other => {
15777 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
15778 Ok(Self::Statement(::std::boxed::Box::new(v)))
15779 } else {
15780 Err(::treesitter_types::ParseError::unexpected_kind(
15781 _other, node,
15782 ))
15783 }
15784 }
15785 }
15786 }
15787}
15788impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
15789 fn span(&self) -> ::treesitter_types::Span {
15790 match self {
15791 Self::Identifier(inner) => inner.span(),
15792 Self::Statement(inner) => inner.span(),
15793 }
15794 }
15795}
15796#[derive(Debug, Clone, PartialEq, Eq)]
15797pub enum LambdaExpressionBody<'tree> {
15798 Block(::std::boxed::Box<Block<'tree>>),
15799 Expression(::std::boxed::Box<Expression<'tree>>),
15800}
15801impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
15802 #[allow(clippy::collapsible_else_if)]
15803 fn from_node(
15804 node: ::tree_sitter::Node<'tree>,
15805 src: &'tree [u8],
15806 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15807 match node.kind() {
15808 "block" => Ok(Self::Block(::std::boxed::Box::new(
15809 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
15810 ))),
15811 _other => {
15812 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15813 Ok(Self::Expression(::std::boxed::Box::new(v)))
15814 } else {
15815 Err(::treesitter_types::ParseError::unexpected_kind(
15816 _other, node,
15817 ))
15818 }
15819 }
15820 }
15821 }
15822}
15823impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
15824 fn span(&self) -> ::treesitter_types::Span {
15825 match self {
15826 Self::Block(inner) => inner.span(),
15827 Self::Expression(inner) => inner.span(),
15828 }
15829 }
15830}
15831#[derive(Debug, Clone, PartialEq, Eq)]
15832pub enum LambdaExpressionParameters<'tree> {
15833 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
15834 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
15835}
15836impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
15837 #[allow(clippy::collapsible_else_if)]
15838 fn from_node(
15839 node: ::tree_sitter::Node<'tree>,
15840 src: &'tree [u8],
15841 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15842 match node.kind() {
15843 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
15844 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
15845 ))),
15846 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
15847 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
15848 ))),
15849 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15850 }
15851 }
15852}
15853impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
15854 fn span(&self) -> ::treesitter_types::Span {
15855 match self {
15856 Self::ImplicitParameter(inner) => inner.span(),
15857 Self::ParameterList(inner) => inner.span(),
15858 }
15859 }
15860}
15861#[derive(Debug, Clone, PartialEq, Eq)]
15862pub enum LambdaExpressionChildren<'tree> {
15863 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15864 Modifier(::std::boxed::Box<Modifier<'tree>>),
15865}
15866impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionChildren<'tree> {
15867 #[allow(clippy::collapsible_else_if)]
15868 fn from_node(
15869 node: ::tree_sitter::Node<'tree>,
15870 src: &'tree [u8],
15871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15872 match node.kind() {
15873 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15874 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
15875 ))),
15876 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15877 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15878 ))),
15879 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15880 }
15881 }
15882}
15883impl ::treesitter_types::Spanned for LambdaExpressionChildren<'_> {
15884 fn span(&self) -> ::treesitter_types::Span {
15885 match self {
15886 Self::AttributeList(inner) => inner.span(),
15887 Self::Modifier(inner) => inner.span(),
15888 }
15889 }
15890}
15891#[derive(Debug, Clone, PartialEq, Eq)]
15892pub enum LetClauseChildren<'tree> {
15893 Expression(::std::boxed::Box<Expression<'tree>>),
15894 Identifier(::std::boxed::Box<Identifier<'tree>>),
15895}
15896impl<'tree> ::treesitter_types::FromNode<'tree> for LetClauseChildren<'tree> {
15897 #[allow(clippy::collapsible_else_if)]
15898 fn from_node(
15899 node: ::tree_sitter::Node<'tree>,
15900 src: &'tree [u8],
15901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15902 match node.kind() {
15903 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15904 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15905 ))),
15906 _other => {
15907 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15908 Ok(Self::Expression(::std::boxed::Box::new(v)))
15909 } else {
15910 Err(::treesitter_types::ParseError::unexpected_kind(
15911 _other, node,
15912 ))
15913 }
15914 }
15915 }
15916 }
15917}
15918impl ::treesitter_types::Spanned for LetClauseChildren<'_> {
15919 fn span(&self) -> ::treesitter_types::Span {
15920 match self {
15921 Self::Expression(inner) => inner.span(),
15922 Self::Identifier(inner) => inner.span(),
15923 }
15924 }
15925}
15926#[derive(Debug, Clone, PartialEq, Eq)]
15927pub enum LocalDeclarationStatementChildren<'tree> {
15928 Modifier(::std::boxed::Box<Modifier<'tree>>),
15929 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15930}
15931impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatementChildren<'tree> {
15932 #[allow(clippy::collapsible_else_if)]
15933 fn from_node(
15934 node: ::tree_sitter::Node<'tree>,
15935 src: &'tree [u8],
15936 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15937 match node.kind() {
15938 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15939 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15940 ))),
15941 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15942 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15943 ))),
15944 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15945 }
15946 }
15947}
15948impl ::treesitter_types::Spanned for LocalDeclarationStatementChildren<'_> {
15949 fn span(&self) -> ::treesitter_types::Span {
15950 match self {
15951 Self::Modifier(inner) => inner.span(),
15952 Self::VariableDeclaration(inner) => inner.span(),
15953 }
15954 }
15955}
15956#[derive(Debug, Clone, PartialEq, Eq)]
15957pub enum LocalFunctionStatementBody<'tree> {
15958 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15959 Block(::std::boxed::Box<Block<'tree>>),
15960}
15961impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementBody<'tree> {
15962 #[allow(clippy::collapsible_else_if)]
15963 fn from_node(
15964 node: ::tree_sitter::Node<'tree>,
15965 src: &'tree [u8],
15966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15967 match node.kind() {
15968 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15969 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15970 ))),
15971 "block" => Ok(Self::Block(::std::boxed::Box::new(
15972 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
15973 ))),
15974 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15975 }
15976 }
15977}
15978impl ::treesitter_types::Spanned for LocalFunctionStatementBody<'_> {
15979 fn span(&self) -> ::treesitter_types::Span {
15980 match self {
15981 Self::ArrowExpressionClause(inner) => inner.span(),
15982 Self::Block(inner) => inner.span(),
15983 }
15984 }
15985}
15986#[derive(Debug, Clone, PartialEq, Eq)]
15987pub enum LocalFunctionStatementChildren<'tree> {
15988 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15989 Modifier(::std::boxed::Box<Modifier<'tree>>),
15990 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
15991}
15992impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementChildren<'tree> {
15993 #[allow(clippy::collapsible_else_if)]
15994 fn from_node(
15995 node: ::tree_sitter::Node<'tree>,
15996 src: &'tree [u8],
15997 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15998 match node.kind() {
15999 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16000 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
16001 ))),
16002 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16003 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16004 ))),
16005 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
16006 ::std::boxed::Box::new(
16007 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
16008 node, src,
16009 )?,
16010 ),
16011 )),
16012 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16013 }
16014 }
16015}
16016impl ::treesitter_types::Spanned for LocalFunctionStatementChildren<'_> {
16017 fn span(&self) -> ::treesitter_types::Span {
16018 match self {
16019 Self::AttributeList(inner) => inner.span(),
16020 Self::Modifier(inner) => inner.span(),
16021 Self::TypeParameterConstraintsClause(inner) => inner.span(),
16022 }
16023 }
16024}
16025#[derive(Debug, Clone, PartialEq, Eq)]
16026pub enum LockStatementChildren<'tree> {
16027 Expression(::std::boxed::Box<Expression<'tree>>),
16028 Statement(::std::boxed::Box<Statement<'tree>>),
16029}
16030impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatementChildren<'tree> {
16031 #[allow(clippy::collapsible_else_if)]
16032 fn from_node(
16033 node: ::tree_sitter::Node<'tree>,
16034 src: &'tree [u8],
16035 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16036 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
16037 Ok(Self::Expression(::std::boxed::Box::new(v)))
16038 } else {
16039 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
16040 Ok(Self::Statement(::std::boxed::Box::new(v)))
16041 } else {
16042 Err(::treesitter_types::ParseError::unexpected_kind(
16043 node.kind(),
16044 node,
16045 ))
16046 }
16047 }
16048 }
16049}
16050impl ::treesitter_types::Spanned for LockStatementChildren<'_> {
16051 fn span(&self) -> ::treesitter_types::Span {
16052 match self {
16053 Self::Expression(inner) => inner.span(),
16054 Self::Statement(inner) => inner.span(),
16055 }
16056 }
16057}
16058#[derive(Debug, Clone, PartialEq, Eq)]
16059pub enum MemberAccessExpressionExpression<'tree> {
16060 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16061 Expression(::std::boxed::Box<Expression<'tree>>),
16062 GenericName(::std::boxed::Box<GenericName<'tree>>),
16063 Identifier(::std::boxed::Box<Identifier<'tree>>),
16064 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16065 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16066}
16067impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionExpression<'tree> {
16068 #[allow(clippy::collapsible_else_if)]
16069 fn from_node(
16070 node: ::tree_sitter::Node<'tree>,
16071 src: &'tree [u8],
16072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16073 match node.kind() {
16074 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16075 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16076 ))),
16077 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16078 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16079 ))),
16080 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16081 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16082 ))),
16083 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16084 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
16085 ))),
16086 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16087 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16088 ))),
16089 _other => {
16090 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
16091 Ok(Self::Expression(::std::boxed::Box::new(v)))
16092 } else {
16093 Err(::treesitter_types::ParseError::unexpected_kind(
16094 _other, node,
16095 ))
16096 }
16097 }
16098 }
16099 }
16100}
16101impl ::treesitter_types::Spanned for MemberAccessExpressionExpression<'_> {
16102 fn span(&self) -> ::treesitter_types::Span {
16103 match self {
16104 Self::AliasQualifiedName(inner) => inner.span(),
16105 Self::Expression(inner) => inner.span(),
16106 Self::GenericName(inner) => inner.span(),
16107 Self::Identifier(inner) => inner.span(),
16108 Self::PredefinedType(inner) => inner.span(),
16109 Self::QualifiedName(inner) => inner.span(),
16110 }
16111 }
16112}
16113#[derive(Debug, Clone, PartialEq, Eq)]
16114pub enum MemberAccessExpressionName<'tree> {
16115 GenericName(::std::boxed::Box<GenericName<'tree>>),
16116 Identifier(::std::boxed::Box<Identifier<'tree>>),
16117}
16118impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionName<'tree> {
16119 #[allow(clippy::collapsible_else_if)]
16120 fn from_node(
16121 node: ::tree_sitter::Node<'tree>,
16122 src: &'tree [u8],
16123 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16124 match node.kind() {
16125 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16126 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16127 ))),
16128 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16129 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16130 ))),
16131 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16132 }
16133 }
16134}
16135impl ::treesitter_types::Spanned for MemberAccessExpressionName<'_> {
16136 fn span(&self) -> ::treesitter_types::Span {
16137 match self {
16138 Self::GenericName(inner) => inner.span(),
16139 Self::Identifier(inner) => inner.span(),
16140 }
16141 }
16142}
16143#[derive(Debug, Clone, PartialEq, Eq)]
16144pub enum MemberBindingExpressionName<'tree> {
16145 GenericName(::std::boxed::Box<GenericName<'tree>>),
16146 Identifier(::std::boxed::Box<Identifier<'tree>>),
16147}
16148impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpressionName<'tree> {
16149 #[allow(clippy::collapsible_else_if)]
16150 fn from_node(
16151 node: ::tree_sitter::Node<'tree>,
16152 src: &'tree [u8],
16153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16154 match node.kind() {
16155 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16156 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16157 ))),
16158 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16159 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16160 ))),
16161 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16162 }
16163 }
16164}
16165impl ::treesitter_types::Spanned for MemberBindingExpressionName<'_> {
16166 fn span(&self) -> ::treesitter_types::Span {
16167 match self {
16168 Self::GenericName(inner) => inner.span(),
16169 Self::Identifier(inner) => inner.span(),
16170 }
16171 }
16172}
16173#[derive(Debug, Clone, PartialEq, Eq)]
16174pub enum MethodDeclarationBody<'tree> {
16175 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
16176 Block(::std::boxed::Box<Block<'tree>>),
16177}
16178impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationBody<'tree> {
16179 #[allow(clippy::collapsible_else_if)]
16180 fn from_node(
16181 node: ::tree_sitter::Node<'tree>,
16182 src: &'tree [u8],
16183 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16184 match node.kind() {
16185 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
16186 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
16187 ))),
16188 "block" => Ok(Self::Block(::std::boxed::Box::new(
16189 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
16190 ))),
16191 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16192 }
16193 }
16194}
16195impl ::treesitter_types::Spanned for MethodDeclarationBody<'_> {
16196 fn span(&self) -> ::treesitter_types::Span {
16197 match self {
16198 Self::ArrowExpressionClause(inner) => inner.span(),
16199 Self::Block(inner) => inner.span(),
16200 }
16201 }
16202}
16203#[derive(Debug, Clone, PartialEq, Eq)]
16204pub enum MethodDeclarationChildren<'tree> {
16205 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16206 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
16207 Modifier(::std::boxed::Box<Modifier<'tree>>),
16208 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
16209}
16210impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
16211 #[allow(clippy::collapsible_else_if)]
16212 fn from_node(
16213 node: ::tree_sitter::Node<'tree>,
16214 src: &'tree [u8],
16215 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16216 match node.kind() {
16217 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16218 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
16219 ))),
16220 "explicit_interface_specifier" => {
16221 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
16222 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
16223 node, src,
16224 )?,
16225 )))
16226 }
16227 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16228 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16229 ))),
16230 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
16231 ::std::boxed::Box::new(
16232 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
16233 node, src,
16234 )?,
16235 ),
16236 )),
16237 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16238 }
16239 }
16240}
16241impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
16242 fn span(&self) -> ::treesitter_types::Span {
16243 match self {
16244 Self::AttributeList(inner) => inner.span(),
16245 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
16246 Self::Modifier(inner) => inner.span(),
16247 Self::TypeParameterConstraintsClause(inner) => inner.span(),
16248 }
16249 }
16250}
16251#[derive(Debug, Clone, PartialEq, Eq)]
16252pub enum NamespaceDeclarationName<'tree> {
16253 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16254 GenericName(::std::boxed::Box<GenericName<'tree>>),
16255 Identifier(::std::boxed::Box<Identifier<'tree>>),
16256 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16257}
16258impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclarationName<'tree> {
16259 #[allow(clippy::collapsible_else_if)]
16260 fn from_node(
16261 node: ::tree_sitter::Node<'tree>,
16262 src: &'tree [u8],
16263 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16264 match node.kind() {
16265 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16266 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16267 ))),
16268 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16269 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16270 ))),
16271 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16272 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16273 ))),
16274 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16275 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16276 ))),
16277 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16278 }
16279 }
16280}
16281impl ::treesitter_types::Spanned for NamespaceDeclarationName<'_> {
16282 fn span(&self) -> ::treesitter_types::Span {
16283 match self {
16284 Self::AliasQualifiedName(inner) => inner.span(),
16285 Self::GenericName(inner) => inner.span(),
16286 Self::Identifier(inner) => inner.span(),
16287 Self::QualifiedName(inner) => inner.span(),
16288 }
16289 }
16290}
16291#[derive(Debug, Clone, PartialEq, Eq)]
16292pub enum NullableTypeType<'tree> {
16293 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16294 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
16295 GenericName(::std::boxed::Box<GenericName<'tree>>),
16296 Identifier(::std::boxed::Box<Identifier<'tree>>),
16297 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16298 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16299 TupleType(::std::boxed::Box<TupleType<'tree>>),
16300}
16301impl<'tree> ::treesitter_types::FromNode<'tree> for NullableTypeType<'tree> {
16302 #[allow(clippy::collapsible_else_if)]
16303 fn from_node(
16304 node: ::tree_sitter::Node<'tree>,
16305 src: &'tree [u8],
16306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16307 match node.kind() {
16308 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16309 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16310 ))),
16311 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
16312 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
16313 ))),
16314 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16315 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16316 ))),
16317 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16318 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16319 ))),
16320 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16321 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
16322 ))),
16323 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16324 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16325 ))),
16326 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
16327 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
16328 ))),
16329 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16330 }
16331 }
16332}
16333impl ::treesitter_types::Spanned for NullableTypeType<'_> {
16334 fn span(&self) -> ::treesitter_types::Span {
16335 match self {
16336 Self::AliasQualifiedName(inner) => inner.span(),
16337 Self::ArrayType(inner) => inner.span(),
16338 Self::GenericName(inner) => inner.span(),
16339 Self::Identifier(inner) => inner.span(),
16340 Self::PredefinedType(inner) => inner.span(),
16341 Self::QualifiedName(inner) => inner.span(),
16342 Self::TupleType(inner) => inner.span(),
16343 }
16344 }
16345}
16346#[derive(Debug, Clone, PartialEq, Eq)]
16347pub enum OperatorDeclarationBody<'tree> {
16348 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
16349 Block(::std::boxed::Box<Block<'tree>>),
16350}
16351impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationBody<'tree> {
16352 #[allow(clippy::collapsible_else_if)]
16353 fn from_node(
16354 node: ::tree_sitter::Node<'tree>,
16355 src: &'tree [u8],
16356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16357 match node.kind() {
16358 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
16359 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
16360 ))),
16361 "block" => Ok(Self::Block(::std::boxed::Box::new(
16362 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
16363 ))),
16364 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16365 }
16366 }
16367}
16368impl ::treesitter_types::Spanned for OperatorDeclarationBody<'_> {
16369 fn span(&self) -> ::treesitter_types::Span {
16370 match self {
16371 Self::ArrowExpressionClause(inner) => inner.span(),
16372 Self::Block(inner) => inner.span(),
16373 }
16374 }
16375}
16376#[derive(Debug, Clone, PartialEq, Eq)]
16377pub enum OperatorDeclarationOperator {
16378 Bang(::treesitter_types::Span),
16379 NotEq(::treesitter_types::Span),
16380 Percent(::treesitter_types::Span),
16381 Amp(::treesitter_types::Span),
16382 Star(::treesitter_types::Span),
16383 Plus(::treesitter_types::Span),
16384 PlusPlus(::treesitter_types::Span),
16385 Minus(::treesitter_types::Span),
16386 MinusMinus(::treesitter_types::Span),
16387 Slash(::treesitter_types::Span),
16388 Lt(::treesitter_types::Span),
16389 Shl(::treesitter_types::Span),
16390 LtEq(::treesitter_types::Span),
16391 EqEq(::treesitter_types::Span),
16392 Gt(::treesitter_types::Span),
16393 GtEq(::treesitter_types::Span),
16394 Shr(::treesitter_types::Span),
16395 GtGtGt(::treesitter_types::Span),
16396 Caret(::treesitter_types::Span),
16397 False(::treesitter_types::Span),
16398 True(::treesitter_types::Span),
16399 Pipe(::treesitter_types::Span),
16400 Tilde(::treesitter_types::Span),
16401}
16402impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationOperator {
16403 #[allow(clippy::collapsible_else_if)]
16404 fn from_node(
16405 node: ::tree_sitter::Node<'tree>,
16406 _src: &'tree [u8],
16407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16408 match node.kind() {
16409 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
16410 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
16411 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
16412 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
16413 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
16414 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
16415 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
16416 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
16417 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
16418 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
16419 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
16420 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
16421 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
16422 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
16423 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
16424 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
16425 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
16426 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
16427 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
16428 "false" => Ok(Self::False(::treesitter_types::Span::from(node))),
16429 "true" => Ok(Self::True(::treesitter_types::Span::from(node))),
16430 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
16431 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
16432 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16433 }
16434 }
16435}
16436impl ::treesitter_types::Spanned for OperatorDeclarationOperator {
16437 fn span(&self) -> ::treesitter_types::Span {
16438 match self {
16439 Self::Bang(span) => *span,
16440 Self::NotEq(span) => *span,
16441 Self::Percent(span) => *span,
16442 Self::Amp(span) => *span,
16443 Self::Star(span) => *span,
16444 Self::Plus(span) => *span,
16445 Self::PlusPlus(span) => *span,
16446 Self::Minus(span) => *span,
16447 Self::MinusMinus(span) => *span,
16448 Self::Slash(span) => *span,
16449 Self::Lt(span) => *span,
16450 Self::Shl(span) => *span,
16451 Self::LtEq(span) => *span,
16452 Self::EqEq(span) => *span,
16453 Self::Gt(span) => *span,
16454 Self::GtEq(span) => *span,
16455 Self::Shr(span) => *span,
16456 Self::GtGtGt(span) => *span,
16457 Self::Caret(span) => *span,
16458 Self::False(span) => *span,
16459 Self::True(span) => *span,
16460 Self::Pipe(span) => *span,
16461 Self::Tilde(span) => *span,
16462 }
16463 }
16464}
16465#[derive(Debug, Clone, PartialEq, Eq)]
16466pub enum OperatorDeclarationChildren<'tree> {
16467 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16468 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
16469 Modifier(::std::boxed::Box<Modifier<'tree>>),
16470}
16471impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationChildren<'tree> {
16472 #[allow(clippy::collapsible_else_if)]
16473 fn from_node(
16474 node: ::tree_sitter::Node<'tree>,
16475 src: &'tree [u8],
16476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16477 match node.kind() {
16478 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16479 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
16480 ))),
16481 "explicit_interface_specifier" => {
16482 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
16483 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
16484 node, src,
16485 )?,
16486 )))
16487 }
16488 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16489 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16490 ))),
16491 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16492 }
16493 }
16494}
16495impl ::treesitter_types::Spanned for OperatorDeclarationChildren<'_> {
16496 fn span(&self) -> ::treesitter_types::Span {
16497 match self {
16498 Self::AttributeList(inner) => inner.span(),
16499 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
16500 Self::Modifier(inner) => inner.span(),
16501 }
16502 }
16503}
16504#[derive(Debug, Clone, PartialEq, Eq)]
16505pub enum OrPatternOperator {
16506 Or(::treesitter_types::Span),
16507}
16508impl<'tree> ::treesitter_types::FromNode<'tree> for OrPatternOperator {
16509 #[allow(clippy::collapsible_else_if)]
16510 fn from_node(
16511 node: ::tree_sitter::Node<'tree>,
16512 _src: &'tree [u8],
16513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16514 match node.kind() {
16515 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
16516 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16517 }
16518 }
16519}
16520impl ::treesitter_types::Spanned for OrPatternOperator {
16521 fn span(&self) -> ::treesitter_types::Span {
16522 match self {
16523 Self::Or(span) => *span,
16524 }
16525 }
16526}
16527#[derive(Debug, Clone, PartialEq, Eq)]
16528pub enum ParameterChildren<'tree> {
16529 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16530 Expression(::std::boxed::Box<Expression<'tree>>),
16531 Modifier(::std::boxed::Box<Modifier<'tree>>),
16532}
16533impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterChildren<'tree> {
16534 #[allow(clippy::collapsible_else_if)]
16535 fn from_node(
16536 node: ::tree_sitter::Node<'tree>,
16537 src: &'tree [u8],
16538 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16539 match node.kind() {
16540 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16541 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
16542 ))),
16543 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16544 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16545 ))),
16546 _other => {
16547 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
16548 Ok(Self::Expression(::std::boxed::Box::new(v)))
16549 } else {
16550 Err(::treesitter_types::ParseError::unexpected_kind(
16551 _other, node,
16552 ))
16553 }
16554 }
16555 }
16556 }
16557}
16558impl ::treesitter_types::Spanned for ParameterChildren<'_> {
16559 fn span(&self) -> ::treesitter_types::Span {
16560 match self {
16561 Self::AttributeList(inner) => inner.span(),
16562 Self::Expression(inner) => inner.span(),
16563 Self::Modifier(inner) => inner.span(),
16564 }
16565 }
16566}
16567#[derive(Debug, Clone, PartialEq, Eq)]
16568pub enum ParameterListType<'tree> {
16569 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
16570 NullableType(::std::boxed::Box<NullableType<'tree>>),
16571}
16572impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListType<'tree> {
16573 #[allow(clippy::collapsible_else_if)]
16574 fn from_node(
16575 node: ::tree_sitter::Node<'tree>,
16576 src: &'tree [u8],
16577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16578 match node.kind() {
16579 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
16580 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
16581 ))),
16582 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
16583 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
16584 ))),
16585 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16586 }
16587 }
16588}
16589impl ::treesitter_types::Spanned for ParameterListType<'_> {
16590 fn span(&self) -> ::treesitter_types::Span {
16591 match self {
16592 Self::ArrayType(inner) => inner.span(),
16593 Self::NullableType(inner) => inner.span(),
16594 }
16595 }
16596}
16597#[derive(Debug, Clone, PartialEq, Eq)]
16598pub enum ParameterListChildren<'tree> {
16599 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16600 Parameter(::std::boxed::Box<Parameter<'tree>>),
16601}
16602impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
16603 #[allow(clippy::collapsible_else_if)]
16604 fn from_node(
16605 node: ::tree_sitter::Node<'tree>,
16606 src: &'tree [u8],
16607 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16608 match node.kind() {
16609 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16610 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
16611 ))),
16612 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
16613 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
16614 ))),
16615 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16616 }
16617 }
16618}
16619impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
16620 fn span(&self) -> ::treesitter_types::Span {
16621 match self {
16622 Self::AttributeList(inner) => inner.span(),
16623 Self::Parameter(inner) => inner.span(),
16624 }
16625 }
16626}
16627#[derive(Debug, Clone, PartialEq, Eq)]
16628pub enum ParenthesizedExpressionChildren<'tree> {
16629 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
16630 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
16631 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
16632 LvalueExpression(::std::boxed::Box<LvalueExpression<'tree>>),
16633 NonLvalueExpression(::std::boxed::Box<NonLvalueExpression<'tree>>),
16634 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
16635}
16636impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
16637 #[allow(clippy::collapsible_else_if)]
16638 fn from_node(
16639 node: ::tree_sitter::Node<'tree>,
16640 src: &'tree [u8],
16641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16642 match node.kind() {
16643 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
16644 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16645 ))),
16646 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
16647 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16648 ))),
16649 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
16650 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16651 ))),
16652 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
16653 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16654 ))),
16655 _other => {
16656 if let Ok(v) =
16657 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
16658 {
16659 Ok(Self::LvalueExpression(::std::boxed::Box::new(v)))
16660 } else {
16661 if let Ok(v) =
16662 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
16663 {
16664 Ok(Self::NonLvalueExpression(::std::boxed::Box::new(v)))
16665 } else {
16666 Err(::treesitter_types::ParseError::unexpected_kind(
16667 _other, node,
16668 ))
16669 }
16670 }
16671 }
16672 }
16673 }
16674}
16675impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
16676 fn span(&self) -> ::treesitter_types::Span {
16677 match self {
16678 Self::BooleanLiteral(inner) => inner.span(),
16679 Self::CharacterLiteral(inner) => inner.span(),
16680 Self::IntegerLiteral(inner) => inner.span(),
16681 Self::LvalueExpression(inner) => inner.span(),
16682 Self::NonLvalueExpression(inner) => inner.span(),
16683 Self::UnaryExpression(inner) => inner.span(),
16684 }
16685 }
16686}
16687#[derive(Debug, Clone, PartialEq, Eq)]
16688pub enum ParenthesizedVariableDesignationChildren<'tree> {
16689 Discard(::std::boxed::Box<Discard<'tree>>),
16690 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
16691}
16692impl<'tree> ::treesitter_types::FromNode<'tree>
16693 for ParenthesizedVariableDesignationChildren<'tree>
16694{
16695 #[allow(clippy::collapsible_else_if)]
16696 fn from_node(
16697 node: ::tree_sitter::Node<'tree>,
16698 src: &'tree [u8],
16699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16700 match node.kind() {
16701 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
16702 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
16703 ))),
16704 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
16705 ::std::boxed::Box::new(
16706 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
16707 node, src,
16708 )?,
16709 ),
16710 )),
16711 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16712 }
16713 }
16714}
16715impl ::treesitter_types::Spanned for ParenthesizedVariableDesignationChildren<'_> {
16716 fn span(&self) -> ::treesitter_types::Span {
16717 match self {
16718 Self::Discard(inner) => inner.span(),
16719 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
16720 }
16721 }
16722}
16723#[derive(Debug, Clone, PartialEq, Eq)]
16724pub enum PointerTypeType<'tree> {
16725 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16726 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
16727 GenericName(::std::boxed::Box<GenericName<'tree>>),
16728 Identifier(::std::boxed::Box<Identifier<'tree>>),
16729 NullableType(::std::boxed::Box<NullableType<'tree>>),
16730 PointerType(::std::boxed::Box<PointerType<'tree>>),
16731 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16732 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16733 TupleType(::std::boxed::Box<TupleType<'tree>>),
16734}
16735impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeType<'tree> {
16736 #[allow(clippy::collapsible_else_if)]
16737 fn from_node(
16738 node: ::tree_sitter::Node<'tree>,
16739 src: &'tree [u8],
16740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16741 match node.kind() {
16742 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16743 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16744 ))),
16745 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
16746 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
16747 ))),
16748 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16749 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
16750 ))),
16751 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16752 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16753 ))),
16754 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
16755 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)?,
16756 ))),
16757 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
16758 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
16759 ))),
16760 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16761 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
16762 ))),
16763 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16764 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
16765 ))),
16766 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
16767 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
16768 ))),
16769 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16770 }
16771 }
16772}
16773impl ::treesitter_types::Spanned for PointerTypeType<'_> {
16774 fn span(&self) -> ::treesitter_types::Span {
16775 match self {
16776 Self::AliasQualifiedName(inner) => inner.span(),
16777 Self::FunctionPointerType(inner) => inner.span(),
16778 Self::GenericName(inner) => inner.span(),
16779 Self::Identifier(inner) => inner.span(),
16780 Self::NullableType(inner) => inner.span(),
16781 Self::PointerType(inner) => inner.span(),
16782 Self::PredefinedType(inner) => inner.span(),
16783 Self::QualifiedName(inner) => inner.span(),
16784 Self::TupleType(inner) => inner.span(),
16785 }
16786 }
16787}
16788#[derive(Debug, Clone, PartialEq, Eq)]
16789pub enum PreprocElifAlternative<'tree> {
16790 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
16791 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
16792}
16793impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
16794 #[allow(clippy::collapsible_else_if)]
16795 fn from_node(
16796 node: ::tree_sitter::Node<'tree>,
16797 src: &'tree [u8],
16798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16799 match node.kind() {
16800 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
16801 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
16802 ))),
16803 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
16804 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
16805 ))),
16806 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16807 }
16808 }
16809}
16810impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
16811 fn span(&self) -> ::treesitter_types::Span {
16812 match self {
16813 Self::PreprocElif(inner) => inner.span(),
16814 Self::PreprocElse(inner) => inner.span(),
16815 }
16816 }
16817}
16818#[derive(Debug, Clone, PartialEq, Eq)]
16819pub enum PreprocElifCondition<'tree> {
16820 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
16821 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
16822 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
16823 Identifier(::std::boxed::Box<Identifier<'tree>>),
16824 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
16825 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
16826 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
16827}
16828impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
16829 #[allow(clippy::collapsible_else_if)]
16830 fn from_node(
16831 node: ::tree_sitter::Node<'tree>,
16832 src: &'tree [u8],
16833 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16834 match node.kind() {
16835 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
16836 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16837 ))),
16838 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
16839 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16840 ))),
16841 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
16842 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16843 ))),
16844 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16845 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16846 ))),
16847 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
16848 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16849 ))),
16850 "parenthesized_expression" => {
16851 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
16852 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
16853 node, src,
16854 )?,
16855 )))
16856 }
16857 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
16858 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16859 ))),
16860 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16861 }
16862 }
16863}
16864impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
16865 fn span(&self) -> ::treesitter_types::Span {
16866 match self {
16867 Self::BinaryExpression(inner) => inner.span(),
16868 Self::BooleanLiteral(inner) => inner.span(),
16869 Self::CharacterLiteral(inner) => inner.span(),
16870 Self::Identifier(inner) => inner.span(),
16871 Self::IntegerLiteral(inner) => inner.span(),
16872 Self::ParenthesizedExpression(inner) => inner.span(),
16873 Self::UnaryExpression(inner) => inner.span(),
16874 }
16875 }
16876}
16877#[derive(Debug, Clone, PartialEq, Eq)]
16878pub enum PreprocElifChildren<'tree> {
16879 Declaration(::std::boxed::Box<Declaration<'tree>>),
16880 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
16881 Expression(::std::boxed::Box<Expression<'tree>>),
16882 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
16883 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
16884 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
16885 Statement(::std::boxed::Box<Statement<'tree>>),
16886 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
16887}
16888impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
16889 #[allow(clippy::collapsible_else_if)]
16890 fn from_node(
16891 node: ::tree_sitter::Node<'tree>,
16892 src: &'tree [u8],
16893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16894 match node.kind() {
16895 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
16896 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16897 ))),
16898 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
16899 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
16900 ))),
16901 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
16902 ::std::boxed::Box::new(
16903 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
16904 node, src,
16905 )?,
16906 ),
16907 )),
16908 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
16909 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
16910 ))),
16911 _other => {
16912 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
16913 Ok(Self::Declaration(::std::boxed::Box::new(v)))
16914 } else {
16915 if let Ok(v) =
16916 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16917 {
16918 Ok(Self::Expression(::std::boxed::Box::new(v)))
16919 } else {
16920 if let Ok(v) =
16921 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16922 {
16923 Ok(Self::Statement(::std::boxed::Box::new(v)))
16924 } else {
16925 if let Ok(v) =
16926 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
16927 node, src,
16928 )
16929 {
16930 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
16931 } else {
16932 Err(::treesitter_types::ParseError::unexpected_kind(
16933 _other, node,
16934 ))
16935 }
16936 }
16937 }
16938 }
16939 }
16940 }
16941 }
16942}
16943impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
16944 fn span(&self) -> ::treesitter_types::Span {
16945 match self {
16946 Self::Declaration(inner) => inner.span(),
16947 Self::EnumMemberDeclaration(inner) => inner.span(),
16948 Self::Expression(inner) => inner.span(),
16949 Self::ExternAliasDirective(inner) => inner.span(),
16950 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
16951 Self::GlobalAttribute(inner) => inner.span(),
16952 Self::Statement(inner) => inner.span(),
16953 Self::TypeDeclaration(inner) => inner.span(),
16954 }
16955 }
16956}
16957#[derive(Debug, Clone, PartialEq, Eq)]
16958pub enum PreprocElseChildren<'tree> {
16959 Declaration(::std::boxed::Box<Declaration<'tree>>),
16960 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
16961 Expression(::std::boxed::Box<Expression<'tree>>),
16962 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
16963 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
16964 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
16965 Statement(::std::boxed::Box<Statement<'tree>>),
16966 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
16967}
16968impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
16969 #[allow(clippy::collapsible_else_if)]
16970 fn from_node(
16971 node: ::tree_sitter::Node<'tree>,
16972 src: &'tree [u8],
16973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16974 match node.kind() {
16975 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
16976 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16977 ))),
16978 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
16979 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
16980 ))),
16981 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
16982 ::std::boxed::Box::new(
16983 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
16984 node, src,
16985 )?,
16986 ),
16987 )),
16988 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
16989 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
16990 ))),
16991 _other => {
16992 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
16993 Ok(Self::Declaration(::std::boxed::Box::new(v)))
16994 } else {
16995 if let Ok(v) =
16996 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16997 {
16998 Ok(Self::Expression(::std::boxed::Box::new(v)))
16999 } else {
17000 if let Ok(v) =
17001 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17002 {
17003 Ok(Self::Statement(::std::boxed::Box::new(v)))
17004 } else {
17005 if let Ok(v) =
17006 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
17007 node, src,
17008 )
17009 {
17010 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
17011 } else {
17012 Err(::treesitter_types::ParseError::unexpected_kind(
17013 _other, node,
17014 ))
17015 }
17016 }
17017 }
17018 }
17019 }
17020 }
17021 }
17022}
17023impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
17024 fn span(&self) -> ::treesitter_types::Span {
17025 match self {
17026 Self::Declaration(inner) => inner.span(),
17027 Self::EnumMemberDeclaration(inner) => inner.span(),
17028 Self::Expression(inner) => inner.span(),
17029 Self::ExternAliasDirective(inner) => inner.span(),
17030 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
17031 Self::GlobalAttribute(inner) => inner.span(),
17032 Self::Statement(inner) => inner.span(),
17033 Self::TypeDeclaration(inner) => inner.span(),
17034 }
17035 }
17036}
17037#[derive(Debug, Clone, PartialEq, Eq)]
17038pub enum PreprocIfAlternative<'tree> {
17039 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17040 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17041}
17042impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
17043 #[allow(clippy::collapsible_else_if)]
17044 fn from_node(
17045 node: ::tree_sitter::Node<'tree>,
17046 src: &'tree [u8],
17047 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17048 match node.kind() {
17049 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17050 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
17051 ))),
17052 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17053 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
17054 ))),
17055 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17056 }
17057 }
17058}
17059impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
17060 fn span(&self) -> ::treesitter_types::Span {
17061 match self {
17062 Self::PreprocElif(inner) => inner.span(),
17063 Self::PreprocElse(inner) => inner.span(),
17064 }
17065 }
17066}
17067#[derive(Debug, Clone, PartialEq, Eq)]
17068pub enum PreprocIfCondition<'tree> {
17069 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
17070 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
17071 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
17072 Identifier(::std::boxed::Box<Identifier<'tree>>),
17073 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
17074 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17075 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
17076}
17077impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
17078 #[allow(clippy::collapsible_else_if)]
17079 fn from_node(
17080 node: ::tree_sitter::Node<'tree>,
17081 src: &'tree [u8],
17082 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17083 match node.kind() {
17084 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
17085 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17086 ))),
17087 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
17088 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17089 ))),
17090 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
17091 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17092 ))),
17093 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17094 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17095 ))),
17096 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
17097 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17098 ))),
17099 "parenthesized_expression" => {
17100 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
17101 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
17102 node, src,
17103 )?,
17104 )))
17105 }
17106 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
17107 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17108 ))),
17109 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17110 }
17111 }
17112}
17113impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
17114 fn span(&self) -> ::treesitter_types::Span {
17115 match self {
17116 Self::BinaryExpression(inner) => inner.span(),
17117 Self::BooleanLiteral(inner) => inner.span(),
17118 Self::CharacterLiteral(inner) => inner.span(),
17119 Self::Identifier(inner) => inner.span(),
17120 Self::IntegerLiteral(inner) => inner.span(),
17121 Self::ParenthesizedExpression(inner) => inner.span(),
17122 Self::UnaryExpression(inner) => inner.span(),
17123 }
17124 }
17125}
17126#[derive(Debug, Clone, PartialEq, Eq)]
17127pub enum PreprocIfChildren<'tree> {
17128 Declaration(::std::boxed::Box<Declaration<'tree>>),
17129 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
17130 Expression(::std::boxed::Box<Expression<'tree>>),
17131 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
17132 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
17133 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
17134 Statement(::std::boxed::Box<Statement<'tree>>),
17135 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
17136}
17137impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
17138 #[allow(clippy::collapsible_else_if)]
17139 fn from_node(
17140 node: ::tree_sitter::Node<'tree>,
17141 src: &'tree [u8],
17142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17143 match node.kind() {
17144 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
17145 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17146 ))),
17147 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
17148 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
17149 ))),
17150 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
17151 ::std::boxed::Box::new(
17152 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
17153 node, src,
17154 )?,
17155 ),
17156 )),
17157 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
17158 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
17159 ))),
17160 _other => {
17161 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
17162 Ok(Self::Declaration(::std::boxed::Box::new(v)))
17163 } else {
17164 if let Ok(v) =
17165 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17166 {
17167 Ok(Self::Expression(::std::boxed::Box::new(v)))
17168 } else {
17169 if let Ok(v) =
17170 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17171 {
17172 Ok(Self::Statement(::std::boxed::Box::new(v)))
17173 } else {
17174 if let Ok(v) =
17175 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
17176 node, src,
17177 )
17178 {
17179 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
17180 } else {
17181 Err(::treesitter_types::ParseError::unexpected_kind(
17182 _other, node,
17183 ))
17184 }
17185 }
17186 }
17187 }
17188 }
17189 }
17190 }
17191}
17192impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
17193 fn span(&self) -> ::treesitter_types::Span {
17194 match self {
17195 Self::Declaration(inner) => inner.span(),
17196 Self::EnumMemberDeclaration(inner) => inner.span(),
17197 Self::Expression(inner) => inner.span(),
17198 Self::ExternAliasDirective(inner) => inner.span(),
17199 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
17200 Self::GlobalAttribute(inner) => inner.span(),
17201 Self::Statement(inner) => inner.span(),
17202 Self::TypeDeclaration(inner) => inner.span(),
17203 }
17204 }
17205}
17206#[derive(Debug, Clone, PartialEq, Eq)]
17207pub enum PreprocLineChildren<'tree> {
17208 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
17209 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
17210}
17211impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLineChildren<'tree> {
17212 #[allow(clippy::collapsible_else_if)]
17213 fn from_node(
17214 node: ::tree_sitter::Node<'tree>,
17215 src: &'tree [u8],
17216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17217 match node.kind() {
17218 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
17219 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17220 ))),
17221 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
17222 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17223 ))),
17224 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17225 }
17226 }
17227}
17228impl ::treesitter_types::Spanned for PreprocLineChildren<'_> {
17229 fn span(&self) -> ::treesitter_types::Span {
17230 match self {
17231 Self::IntegerLiteral(inner) => inner.span(),
17232 Self::StringLiteral(inner) => inner.span(),
17233 }
17234 }
17235}
17236#[derive(Debug, Clone, PartialEq, Eq)]
17237pub enum PreprocPragmaChildren<'tree> {
17238 Identifier(::std::boxed::Box<Identifier<'tree>>),
17239 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
17240 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
17241}
17242impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragmaChildren<'tree> {
17243 #[allow(clippy::collapsible_else_if)]
17244 fn from_node(
17245 node: ::tree_sitter::Node<'tree>,
17246 src: &'tree [u8],
17247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17248 match node.kind() {
17249 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17250 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17251 ))),
17252 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
17253 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17254 ))),
17255 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
17256 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17257 ))),
17258 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17259 }
17260 }
17261}
17262impl ::treesitter_types::Spanned for PreprocPragmaChildren<'_> {
17263 fn span(&self) -> ::treesitter_types::Span {
17264 match self {
17265 Self::Identifier(inner) => inner.span(),
17266 Self::IntegerLiteral(inner) => inner.span(),
17267 Self::StringLiteral(inner) => inner.span(),
17268 }
17269 }
17270}
17271#[derive(Debug, Clone, PartialEq, Eq)]
17272pub enum PrimaryConstructorBaseTypeType<'tree> {
17273 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17274 GenericName(::std::boxed::Box<GenericName<'tree>>),
17275 Identifier(::std::boxed::Box<Identifier<'tree>>),
17276 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17277}
17278impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseTypeType<'tree> {
17279 #[allow(clippy::collapsible_else_if)]
17280 fn from_node(
17281 node: ::tree_sitter::Node<'tree>,
17282 src: &'tree [u8],
17283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17284 match node.kind() {
17285 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17286 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17287 ))),
17288 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17289 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
17290 ))),
17291 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17292 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17293 ))),
17294 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17295 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17296 ))),
17297 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17298 }
17299 }
17300}
17301impl ::treesitter_types::Spanned for PrimaryConstructorBaseTypeType<'_> {
17302 fn span(&self) -> ::treesitter_types::Span {
17303 match self {
17304 Self::AliasQualifiedName(inner) => inner.span(),
17305 Self::GenericName(inner) => inner.span(),
17306 Self::Identifier(inner) => inner.span(),
17307 Self::QualifiedName(inner) => inner.span(),
17308 }
17309 }
17310}
17311#[derive(Debug, Clone, PartialEq, Eq)]
17312pub enum PropertyDeclarationValue<'tree> {
17313 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
17314 Expression(::std::boxed::Box<Expression<'tree>>),
17315}
17316impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationValue<'tree> {
17317 #[allow(clippy::collapsible_else_if)]
17318 fn from_node(
17319 node: ::tree_sitter::Node<'tree>,
17320 src: &'tree [u8],
17321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17322 match node.kind() {
17323 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
17324 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17325 ))),
17326 _other => {
17327 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17328 Ok(Self::Expression(::std::boxed::Box::new(v)))
17329 } else {
17330 Err(::treesitter_types::ParseError::unexpected_kind(
17331 _other, node,
17332 ))
17333 }
17334 }
17335 }
17336 }
17337}
17338impl ::treesitter_types::Spanned for PropertyDeclarationValue<'_> {
17339 fn span(&self) -> ::treesitter_types::Span {
17340 match self {
17341 Self::ArrowExpressionClause(inner) => inner.span(),
17342 Self::Expression(inner) => inner.span(),
17343 }
17344 }
17345}
17346#[derive(Debug, Clone, PartialEq, Eq)]
17347pub enum PropertyDeclarationChildren<'tree> {
17348 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17349 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
17350 Modifier(::std::boxed::Box<Modifier<'tree>>),
17351}
17352impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationChildren<'tree> {
17353 #[allow(clippy::collapsible_else_if)]
17354 fn from_node(
17355 node: ::tree_sitter::Node<'tree>,
17356 src: &'tree [u8],
17357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17358 match node.kind() {
17359 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17360 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
17361 ))),
17362 "explicit_interface_specifier" => {
17363 Ok(Self::ExplicitInterfaceSpecifier(::std::boxed::Box::new(
17364 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
17365 node, src,
17366 )?,
17367 )))
17368 }
17369 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17370 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17371 ))),
17372 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17373 }
17374 }
17375}
17376impl ::treesitter_types::Spanned for PropertyDeclarationChildren<'_> {
17377 fn span(&self) -> ::treesitter_types::Span {
17378 match self {
17379 Self::AttributeList(inner) => inner.span(),
17380 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
17381 Self::Modifier(inner) => inner.span(),
17382 }
17383 }
17384}
17385#[derive(Debug, Clone, PartialEq, Eq)]
17386pub enum QualifiedNameName<'tree> {
17387 GenericName(::std::boxed::Box<GenericName<'tree>>),
17388 Identifier(::std::boxed::Box<Identifier<'tree>>),
17389}
17390impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameName<'tree> {
17391 #[allow(clippy::collapsible_else_if)]
17392 fn from_node(
17393 node: ::tree_sitter::Node<'tree>,
17394 src: &'tree [u8],
17395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17396 match node.kind() {
17397 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17398 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
17399 ))),
17400 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17401 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17402 ))),
17403 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17404 }
17405 }
17406}
17407impl ::treesitter_types::Spanned for QualifiedNameName<'_> {
17408 fn span(&self) -> ::treesitter_types::Span {
17409 match self {
17410 Self::GenericName(inner) => inner.span(),
17411 Self::Identifier(inner) => inner.span(),
17412 }
17413 }
17414}
17415#[derive(Debug, Clone, PartialEq, Eq)]
17416pub enum QualifiedNameQualifier<'tree> {
17417 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17418 GenericName(::std::boxed::Box<GenericName<'tree>>),
17419 Identifier(::std::boxed::Box<Identifier<'tree>>),
17420 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17421}
17422impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameQualifier<'tree> {
17423 #[allow(clippy::collapsible_else_if)]
17424 fn from_node(
17425 node: ::tree_sitter::Node<'tree>,
17426 src: &'tree [u8],
17427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17428 match node.kind() {
17429 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17430 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17431 ))),
17432 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17433 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
17434 ))),
17435 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17436 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17437 ))),
17438 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17439 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17440 ))),
17441 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17442 }
17443 }
17444}
17445impl ::treesitter_types::Spanned for QualifiedNameQualifier<'_> {
17446 fn span(&self) -> ::treesitter_types::Span {
17447 match self {
17448 Self::AliasQualifiedName(inner) => inner.span(),
17449 Self::GenericName(inner) => inner.span(),
17450 Self::Identifier(inner) => inner.span(),
17451 Self::QualifiedName(inner) => inner.span(),
17452 }
17453 }
17454}
17455#[derive(Debug, Clone, PartialEq, Eq)]
17456pub enum QueryExpressionChildren<'tree> {
17457 FromClause(::std::boxed::Box<FromClause<'tree>>),
17458 GroupClause(::std::boxed::Box<GroupClause<'tree>>),
17459 Identifier(::std::boxed::Box<Identifier<'tree>>),
17460 JoinClause(::std::boxed::Box<JoinClause<'tree>>),
17461 LetClause(::std::boxed::Box<LetClause<'tree>>),
17462 OrderByClause(::std::boxed::Box<OrderByClause<'tree>>),
17463 SelectClause(::std::boxed::Box<SelectClause<'tree>>),
17464 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
17465}
17466impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpressionChildren<'tree> {
17467 #[allow(clippy::collapsible_else_if)]
17468 fn from_node(
17469 node: ::tree_sitter::Node<'tree>,
17470 src: &'tree [u8],
17471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17472 match node.kind() {
17473 "from_clause" => Ok(Self::FromClause(::std::boxed::Box::new(
17474 <FromClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17475 ))),
17476 "group_clause" => Ok(Self::GroupClause(::std::boxed::Box::new(
17477 <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17478 ))),
17479 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17480 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17481 ))),
17482 "join_clause" => Ok(Self::JoinClause(::std::boxed::Box::new(
17483 <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17484 ))),
17485 "let_clause" => Ok(Self::LetClause(::std::boxed::Box::new(
17486 <LetClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17487 ))),
17488 "order_by_clause" => Ok(Self::OrderByClause(::std::boxed::Box::new(
17489 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17490 ))),
17491 "select_clause" => Ok(Self::SelectClause(::std::boxed::Box::new(
17492 <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17493 ))),
17494 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
17495 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17496 ))),
17497 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17498 }
17499 }
17500}
17501impl ::treesitter_types::Spanned for QueryExpressionChildren<'_> {
17502 fn span(&self) -> ::treesitter_types::Span {
17503 match self {
17504 Self::FromClause(inner) => inner.span(),
17505 Self::GroupClause(inner) => inner.span(),
17506 Self::Identifier(inner) => inner.span(),
17507 Self::JoinClause(inner) => inner.span(),
17508 Self::LetClause(inner) => inner.span(),
17509 Self::OrderByClause(inner) => inner.span(),
17510 Self::SelectClause(inner) => inner.span(),
17511 Self::WhereClause(inner) => inner.span(),
17512 }
17513 }
17514}
17515#[derive(Debug, Clone, PartialEq, Eq)]
17516pub enum RawStringLiteralChildren<'tree> {
17517 RawStringContent(::std::boxed::Box<RawStringContent<'tree>>),
17518 RawStringEnd(::std::boxed::Box<RawStringEnd<'tree>>),
17519 RawStringStart(::std::boxed::Box<RawStringStart<'tree>>),
17520}
17521impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralChildren<'tree> {
17522 #[allow(clippy::collapsible_else_if)]
17523 fn from_node(
17524 node: ::tree_sitter::Node<'tree>,
17525 src: &'tree [u8],
17526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17527 match node.kind() {
17528 "raw_string_content" => Ok(Self::RawStringContent(::std::boxed::Box::new(
17529 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
17530 ))),
17531 "raw_string_end" => Ok(Self::RawStringEnd(::std::boxed::Box::new(
17532 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)?,
17533 ))),
17534 "raw_string_start" => Ok(Self::RawStringStart(::std::boxed::Box::new(
17535 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)?,
17536 ))),
17537 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17538 }
17539 }
17540}
17541impl ::treesitter_types::Spanned for RawStringLiteralChildren<'_> {
17542 fn span(&self) -> ::treesitter_types::Span {
17543 match self {
17544 Self::RawStringContent(inner) => inner.span(),
17545 Self::RawStringEnd(inner) => inner.span(),
17546 Self::RawStringStart(inner) => inner.span(),
17547 }
17548 }
17549}
17550#[derive(Debug, Clone, PartialEq, Eq)]
17551pub enum RecordDeclarationChildren<'tree> {
17552 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17553 BaseList(::std::boxed::Box<BaseList<'tree>>),
17554 Modifier(::std::boxed::Box<Modifier<'tree>>),
17555 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
17556 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17557 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
17558}
17559impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclarationChildren<'tree> {
17560 #[allow(clippy::collapsible_else_if)]
17561 fn from_node(
17562 node: ::tree_sitter::Node<'tree>,
17563 src: &'tree [u8],
17564 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17565 match node.kind() {
17566 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17567 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
17568 ))),
17569 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
17570 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)?,
17571 ))),
17572 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17573 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17574 ))),
17575 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
17576 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
17577 ))),
17578 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17579 ::std::boxed::Box::new(
17580 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17581 node, src,
17582 )?,
17583 ),
17584 )),
17585 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
17586 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
17587 ))),
17588 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17589 }
17590 }
17591}
17592impl ::treesitter_types::Spanned for RecordDeclarationChildren<'_> {
17593 fn span(&self) -> ::treesitter_types::Span {
17594 match self {
17595 Self::AttributeList(inner) => inner.span(),
17596 Self::BaseList(inner) => inner.span(),
17597 Self::Modifier(inner) => inner.span(),
17598 Self::ParameterList(inner) => inner.span(),
17599 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17600 Self::TypeParameterList(inner) => inner.span(),
17601 }
17602 }
17603}
17604#[derive(Debug, Clone, PartialEq, Eq)]
17605pub enum RecursivePatternChildren<'tree> {
17606 Discard(::std::boxed::Box<Discard<'tree>>),
17607 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
17608 PositionalPatternClause(::std::boxed::Box<PositionalPatternClause<'tree>>),
17609 PropertyPatternClause(::std::boxed::Box<PropertyPatternClause<'tree>>),
17610}
17611impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePatternChildren<'tree> {
17612 #[allow(clippy::collapsible_else_if)]
17613 fn from_node(
17614 node: ::tree_sitter::Node<'tree>,
17615 src: &'tree [u8],
17616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17617 match node.kind() {
17618 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
17619 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
17620 ))),
17621 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
17622 ::std::boxed::Box::new(
17623 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
17624 node, src,
17625 )?,
17626 ),
17627 )),
17628 "positional_pattern_clause" => {
17629 Ok(Self::PositionalPatternClause(::std::boxed::Box::new(
17630 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(
17631 node, src,
17632 )?,
17633 )))
17634 }
17635 "property_pattern_clause" => Ok(Self::PropertyPatternClause(::std::boxed::Box::new(
17636 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17637 ))),
17638 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17639 }
17640 }
17641}
17642impl ::treesitter_types::Spanned for RecursivePatternChildren<'_> {
17643 fn span(&self) -> ::treesitter_types::Span {
17644 match self {
17645 Self::Discard(inner) => inner.span(),
17646 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
17647 Self::PositionalPatternClause(inner) => inner.span(),
17648 Self::PropertyPatternClause(inner) => inner.span(),
17649 }
17650 }
17651}
17652#[derive(Debug, Clone, PartialEq, Eq)]
17653pub enum ScopedTypeType<'tree> {
17654 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17655 GenericName(::std::boxed::Box<GenericName<'tree>>),
17656 Identifier(::std::boxed::Box<Identifier<'tree>>),
17657 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17658 RefType(::std::boxed::Box<RefType<'tree>>),
17659}
17660impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeType<'tree> {
17661 #[allow(clippy::collapsible_else_if)]
17662 fn from_node(
17663 node: ::tree_sitter::Node<'tree>,
17664 src: &'tree [u8],
17665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17666 match node.kind() {
17667 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17668 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17669 ))),
17670 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17671 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)?,
17672 ))),
17673 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17674 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17675 ))),
17676 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17677 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
17678 ))),
17679 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
17680 <RefType as ::treesitter_types::FromNode>::from_node(node, src)?,
17681 ))),
17682 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17683 }
17684 }
17685}
17686impl ::treesitter_types::Spanned for ScopedTypeType<'_> {
17687 fn span(&self) -> ::treesitter_types::Span {
17688 match self {
17689 Self::AliasQualifiedName(inner) => inner.span(),
17690 Self::GenericName(inner) => inner.span(),
17691 Self::Identifier(inner) => inner.span(),
17692 Self::QualifiedName(inner) => inner.span(),
17693 Self::RefType(inner) => inner.span(),
17694 }
17695 }
17696}
17697#[derive(Debug, Clone, PartialEq, Eq)]
17698pub enum StringLiteralChildren<'tree> {
17699 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
17700 StringLiteralContent(::std::boxed::Box<StringLiteralContent<'tree>>),
17701 StringLiteralEncoding(::std::boxed::Box<StringLiteralEncoding<'tree>>),
17702}
17703impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
17704 #[allow(clippy::collapsible_else_if)]
17705 fn from_node(
17706 node: ::tree_sitter::Node<'tree>,
17707 src: &'tree [u8],
17708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17709 match node.kind() {
17710 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
17711 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
17712 ))),
17713 "string_literal_content" => Ok(Self::StringLiteralContent(::std::boxed::Box::new(
17714 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)?,
17715 ))),
17716 "string_literal_encoding" => Ok(Self::StringLiteralEncoding(::std::boxed::Box::new(
17717 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)?,
17718 ))),
17719 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17720 }
17721 }
17722}
17723impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
17724 fn span(&self) -> ::treesitter_types::Span {
17725 match self {
17726 Self::EscapeSequence(inner) => inner.span(),
17727 Self::StringLiteralContent(inner) => inner.span(),
17728 Self::StringLiteralEncoding(inner) => inner.span(),
17729 }
17730 }
17731}
17732#[derive(Debug, Clone, PartialEq, Eq)]
17733pub enum StructDeclarationChildren<'tree> {
17734 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17735 BaseList(::std::boxed::Box<BaseList<'tree>>),
17736 Modifier(::std::boxed::Box<Modifier<'tree>>),
17737 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
17738 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17739 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
17740}
17741impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclarationChildren<'tree> {
17742 #[allow(clippy::collapsible_else_if)]
17743 fn from_node(
17744 node: ::tree_sitter::Node<'tree>,
17745 src: &'tree [u8],
17746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17747 match node.kind() {
17748 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17749 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)?,
17750 ))),
17751 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
17752 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)?,
17753 ))),
17754 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17755 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17756 ))),
17757 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
17758 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
17759 ))),
17760 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17761 ::std::boxed::Box::new(
17762 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17763 node, src,
17764 )?,
17765 ),
17766 )),
17767 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
17768 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)?,
17769 ))),
17770 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17771 }
17772 }
17773}
17774impl ::treesitter_types::Spanned for StructDeclarationChildren<'_> {
17775 fn span(&self) -> ::treesitter_types::Span {
17776 match self {
17777 Self::AttributeList(inner) => inner.span(),
17778 Self::BaseList(inner) => inner.span(),
17779 Self::Modifier(inner) => inner.span(),
17780 Self::ParameterList(inner) => inner.span(),
17781 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17782 Self::TypeParameterList(inner) => inner.span(),
17783 }
17784 }
17785}
17786#[derive(Debug, Clone, PartialEq, Eq)]
17787pub enum SubpatternChildren<'tree> {
17788 Expression(::std::boxed::Box<Expression<'tree>>),
17789 Pattern(::std::boxed::Box<Pattern<'tree>>),
17790}
17791impl<'tree> ::treesitter_types::FromNode<'tree> for SubpatternChildren<'tree> {
17792 #[allow(clippy::collapsible_else_if)]
17793 fn from_node(
17794 node: ::tree_sitter::Node<'tree>,
17795 src: &'tree [u8],
17796 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17797 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17798 Ok(Self::Expression(::std::boxed::Box::new(v)))
17799 } else {
17800 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
17801 Ok(Self::Pattern(::std::boxed::Box::new(v)))
17802 } else {
17803 Err(::treesitter_types::ParseError::unexpected_kind(
17804 node.kind(),
17805 node,
17806 ))
17807 }
17808 }
17809 }
17810}
17811impl ::treesitter_types::Spanned for SubpatternChildren<'_> {
17812 fn span(&self) -> ::treesitter_types::Span {
17813 match self {
17814 Self::Expression(inner) => inner.span(),
17815 Self::Pattern(inner) => inner.span(),
17816 }
17817 }
17818}
17819#[derive(Debug, Clone, PartialEq, Eq)]
17820pub enum SwitchExpressionChildren<'tree> {
17821 Expression(::std::boxed::Box<Expression<'tree>>),
17822 SwitchExpressionArm(::std::boxed::Box<SwitchExpressionArm<'tree>>),
17823}
17824impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionChildren<'tree> {
17825 #[allow(clippy::collapsible_else_if)]
17826 fn from_node(
17827 node: ::tree_sitter::Node<'tree>,
17828 src: &'tree [u8],
17829 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17830 match node.kind() {
17831 "switch_expression_arm" => Ok(Self::SwitchExpressionArm(::std::boxed::Box::new(
17832 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)?,
17833 ))),
17834 _other => {
17835 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17836 Ok(Self::Expression(::std::boxed::Box::new(v)))
17837 } else {
17838 Err(::treesitter_types::ParseError::unexpected_kind(
17839 _other, node,
17840 ))
17841 }
17842 }
17843 }
17844 }
17845}
17846impl ::treesitter_types::Spanned for SwitchExpressionChildren<'_> {
17847 fn span(&self) -> ::treesitter_types::Span {
17848 match self {
17849 Self::Expression(inner) => inner.span(),
17850 Self::SwitchExpressionArm(inner) => inner.span(),
17851 }
17852 }
17853}
17854#[derive(Debug, Clone, PartialEq, Eq)]
17855pub enum SwitchExpressionArmChildren<'tree> {
17856 Expression(::std::boxed::Box<Expression<'tree>>),
17857 Pattern(::std::boxed::Box<Pattern<'tree>>),
17858 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
17859}
17860impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArmChildren<'tree> {
17861 #[allow(clippy::collapsible_else_if)]
17862 fn from_node(
17863 node: ::tree_sitter::Node<'tree>,
17864 src: &'tree [u8],
17865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17866 match node.kind() {
17867 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
17868 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17869 ))),
17870 _other => {
17871 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17872 Ok(Self::Expression(::std::boxed::Box::new(v)))
17873 } else {
17874 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
17875 Ok(Self::Pattern(::std::boxed::Box::new(v)))
17876 } else {
17877 Err(::treesitter_types::ParseError::unexpected_kind(
17878 _other, node,
17879 ))
17880 }
17881 }
17882 }
17883 }
17884 }
17885}
17886impl ::treesitter_types::Spanned for SwitchExpressionArmChildren<'_> {
17887 fn span(&self) -> ::treesitter_types::Span {
17888 match self {
17889 Self::Expression(inner) => inner.span(),
17890 Self::Pattern(inner) => inner.span(),
17891 Self::WhenClause(inner) => inner.span(),
17892 }
17893 }
17894}
17895#[derive(Debug, Clone, PartialEq, Eq)]
17896pub enum SwitchSectionChildren<'tree> {
17897 Expression(::std::boxed::Box<Expression<'tree>>),
17898 Pattern(::std::boxed::Box<Pattern<'tree>>),
17899 Statement(::std::boxed::Box<Statement<'tree>>),
17900 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
17901}
17902impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSectionChildren<'tree> {
17903 #[allow(clippy::collapsible_else_if)]
17904 fn from_node(
17905 node: ::tree_sitter::Node<'tree>,
17906 src: &'tree [u8],
17907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17908 match node.kind() {
17909 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
17910 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17911 ))),
17912 _other => {
17913 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17914 Ok(Self::Expression(::std::boxed::Box::new(v)))
17915 } else {
17916 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
17917 Ok(Self::Pattern(::std::boxed::Box::new(v)))
17918 } else {
17919 if let Ok(v) =
17920 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17921 {
17922 Ok(Self::Statement(::std::boxed::Box::new(v)))
17923 } else {
17924 Err(::treesitter_types::ParseError::unexpected_kind(
17925 _other, node,
17926 ))
17927 }
17928 }
17929 }
17930 }
17931 }
17932 }
17933}
17934impl ::treesitter_types::Spanned for SwitchSectionChildren<'_> {
17935 fn span(&self) -> ::treesitter_types::Span {
17936 match self {
17937 Self::Expression(inner) => inner.span(),
17938 Self::Pattern(inner) => inner.span(),
17939 Self::Statement(inner) => inner.span(),
17940 Self::WhenClause(inner) => inner.span(),
17941 }
17942 }
17943}
17944#[derive(Debug, Clone, PartialEq, Eq)]
17945pub enum SwitchStatementValue<'tree> {
17946 Expression(::std::boxed::Box<Expression<'tree>>),
17947 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
17948}
17949impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatementValue<'tree> {
17950 #[allow(clippy::collapsible_else_if)]
17951 fn from_node(
17952 node: ::tree_sitter::Node<'tree>,
17953 src: &'tree [u8],
17954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17955 match node.kind() {
17956 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
17957 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17958 ))),
17959 _other => {
17960 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17961 Ok(Self::Expression(::std::boxed::Box::new(v)))
17962 } else {
17963 Err(::treesitter_types::ParseError::unexpected_kind(
17964 _other, node,
17965 ))
17966 }
17967 }
17968 }
17969 }
17970}
17971impl ::treesitter_types::Spanned for SwitchStatementValue<'_> {
17972 fn span(&self) -> ::treesitter_types::Span {
17973 match self {
17974 Self::Expression(inner) => inner.span(),
17975 Self::TupleExpression(inner) => inner.span(),
17976 }
17977 }
17978}
17979#[derive(Debug, Clone, PartialEq, Eq)]
17980pub enum TryStatementChildren<'tree> {
17981 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
17982 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
17983}
17984impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
17985 #[allow(clippy::collapsible_else_if)]
17986 fn from_node(
17987 node: ::tree_sitter::Node<'tree>,
17988 src: &'tree [u8],
17989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17990 match node.kind() {
17991 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
17992 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17993 ))),
17994 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
17995 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17996 ))),
17997 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17998 }
17999 }
18000}
18001impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
18002 fn span(&self) -> ::treesitter_types::Span {
18003 match self {
18004 Self::CatchClause(inner) => inner.span(),
18005 Self::FinallyClause(inner) => inner.span(),
18006 }
18007 }
18008}
18009#[derive(Debug, Clone, PartialEq, Eq)]
18010pub enum TuplePatternChildren<'tree> {
18011 Discard(::std::boxed::Box<Discard<'tree>>),
18012 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
18013}
18014impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
18015 #[allow(clippy::collapsible_else_if)]
18016 fn from_node(
18017 node: ::tree_sitter::Node<'tree>,
18018 src: &'tree [u8],
18019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18020 match node.kind() {
18021 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
18022 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
18023 ))),
18024 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
18025 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
18026 ))),
18027 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18028 }
18029 }
18030}
18031impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
18032 fn span(&self) -> ::treesitter_types::Span {
18033 match self {
18034 Self::Discard(inner) => inner.span(),
18035 Self::TuplePattern(inner) => inner.span(),
18036 }
18037 }
18038}
18039#[derive(Debug, Clone, PartialEq, Eq)]
18040pub enum TypeParameterConstraintsClauseChildren<'tree> {
18041 Identifier(::std::boxed::Box<Identifier<'tree>>),
18042 TypeParameterConstraint(::std::boxed::Box<TypeParameterConstraint<'tree>>),
18043}
18044impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClauseChildren<'tree> {
18045 #[allow(clippy::collapsible_else_if)]
18046 fn from_node(
18047 node: ::tree_sitter::Node<'tree>,
18048 src: &'tree [u8],
18049 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18050 match node.kind() {
18051 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18052 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18053 ))),
18054 "type_parameter_constraint" => {
18055 Ok(Self::TypeParameterConstraint(::std::boxed::Box::new(
18056 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(
18057 node, src,
18058 )?,
18059 )))
18060 }
18061 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18062 }
18063 }
18064}
18065impl ::treesitter_types::Spanned for TypeParameterConstraintsClauseChildren<'_> {
18066 fn span(&self) -> ::treesitter_types::Span {
18067 match self {
18068 Self::Identifier(inner) => inner.span(),
18069 Self::TypeParameterConstraint(inner) => inner.span(),
18070 }
18071 }
18072}
18073#[derive(Debug, Clone, PartialEq, Eq)]
18074pub enum UnaryExpressionArgument<'tree> {
18075 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
18076 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
18077 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
18078 Identifier(::std::boxed::Box<Identifier<'tree>>),
18079 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18080 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
18081 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18082}
18083impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
18084 #[allow(clippy::collapsible_else_if)]
18085 fn from_node(
18086 node: ::tree_sitter::Node<'tree>,
18087 src: &'tree [u8],
18088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18089 match node.kind() {
18090 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
18091 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
18092 ))),
18093 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
18094 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18095 ))),
18096 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
18097 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18098 ))),
18099 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18100 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18101 ))),
18102 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18103 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18104 ))),
18105 "parenthesized_expression" => {
18106 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
18107 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
18108 node, src,
18109 )?,
18110 )))
18111 }
18112 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18113 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
18114 ))),
18115 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18116 }
18117 }
18118}
18119impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
18120 fn span(&self) -> ::treesitter_types::Span {
18121 match self {
18122 Self::BinaryExpression(inner) => inner.span(),
18123 Self::BooleanLiteral(inner) => inner.span(),
18124 Self::CharacterLiteral(inner) => inner.span(),
18125 Self::Identifier(inner) => inner.span(),
18126 Self::IntegerLiteral(inner) => inner.span(),
18127 Self::ParenthesizedExpression(inner) => inner.span(),
18128 Self::UnaryExpression(inner) => inner.span(),
18129 }
18130 }
18131}
18132#[derive(Debug, Clone, PartialEq, Eq)]
18133pub enum UnaryExpressionOperator {
18134 Bang(::treesitter_types::Span),
18135}
18136impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
18137 #[allow(clippy::collapsible_else_if)]
18138 fn from_node(
18139 node: ::tree_sitter::Node<'tree>,
18140 _src: &'tree [u8],
18141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18142 match node.kind() {
18143 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
18144 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18145 }
18146 }
18147}
18148impl ::treesitter_types::Spanned for UnaryExpressionOperator {
18149 fn span(&self) -> ::treesitter_types::Span {
18150 match self {
18151 Self::Bang(span) => *span,
18152 }
18153 }
18154}
18155#[derive(Debug, Clone, PartialEq, Eq)]
18156pub enum UsingStatementChildren<'tree> {
18157 Expression(::std::boxed::Box<Expression<'tree>>),
18158 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
18159}
18160impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatementChildren<'tree> {
18161 #[allow(clippy::collapsible_else_if)]
18162 fn from_node(
18163 node: ::tree_sitter::Node<'tree>,
18164 src: &'tree [u8],
18165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18166 match node.kind() {
18167 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
18168 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18169 ))),
18170 _other => {
18171 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18172 Ok(Self::Expression(::std::boxed::Box::new(v)))
18173 } else {
18174 Err(::treesitter_types::ParseError::unexpected_kind(
18175 _other, node,
18176 ))
18177 }
18178 }
18179 }
18180 }
18181}
18182impl ::treesitter_types::Spanned for UsingStatementChildren<'_> {
18183 fn span(&self) -> ::treesitter_types::Span {
18184 match self {
18185 Self::Expression(inner) => inner.span(),
18186 Self::VariableDeclaration(inner) => inner.span(),
18187 }
18188 }
18189}
18190#[derive(Debug, Clone, PartialEq, Eq)]
18191pub enum VarPatternChildren<'tree> {
18192 Discard(::std::boxed::Box<Discard<'tree>>),
18193 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
18194}
18195impl<'tree> ::treesitter_types::FromNode<'tree> for VarPatternChildren<'tree> {
18196 #[allow(clippy::collapsible_else_if)]
18197 fn from_node(
18198 node: ::tree_sitter::Node<'tree>,
18199 src: &'tree [u8],
18200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18201 match node.kind() {
18202 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
18203 <Discard as ::treesitter_types::FromNode>::from_node(node, src)?,
18204 ))),
18205 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
18206 ::std::boxed::Box::new(
18207 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
18208 node, src,
18209 )?,
18210 ),
18211 )),
18212 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18213 }
18214 }
18215}
18216impl ::treesitter_types::Spanned for VarPatternChildren<'_> {
18217 fn span(&self) -> ::treesitter_types::Span {
18218 match self {
18219 Self::Discard(inner) => inner.span(),
18220 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
18221 }
18222 }
18223}
18224#[derive(Debug, Clone, PartialEq, Eq)]
18225pub enum VariableDeclaratorChildren<'tree> {
18226 BracketedArgumentList(::std::boxed::Box<BracketedArgumentList<'tree>>),
18227 Expression(::std::boxed::Box<Expression<'tree>>),
18228 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
18229}
18230impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorChildren<'tree> {
18231 #[allow(clippy::collapsible_else_if)]
18232 fn from_node(
18233 node: ::tree_sitter::Node<'tree>,
18234 src: &'tree [u8],
18235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18236 match node.kind() {
18237 "bracketed_argument_list" => Ok(Self::BracketedArgumentList(::std::boxed::Box::new(
18238 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
18239 ))),
18240 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
18241 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
18242 ))),
18243 _other => {
18244 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18245 Ok(Self::Expression(::std::boxed::Box::new(v)))
18246 } else {
18247 Err(::treesitter_types::ParseError::unexpected_kind(
18248 _other, node,
18249 ))
18250 }
18251 }
18252 }
18253 }
18254}
18255impl ::treesitter_types::Spanned for VariableDeclaratorChildren<'_> {
18256 fn span(&self) -> ::treesitter_types::Span {
18257 match self {
18258 Self::BracketedArgumentList(inner) => inner.span(),
18259 Self::Expression(inner) => inner.span(),
18260 Self::TuplePattern(inner) => inner.span(),
18261 }
18262 }
18263}
18264#[derive(Debug, Clone, PartialEq, Eq)]
18265pub enum WithExpressionChildren<'tree> {
18266 Expression(::std::boxed::Box<Expression<'tree>>),
18267 WithInitializer(::std::boxed::Box<WithInitializer<'tree>>),
18268}
18269impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpressionChildren<'tree> {
18270 #[allow(clippy::collapsible_else_if)]
18271 fn from_node(
18272 node: ::tree_sitter::Node<'tree>,
18273 src: &'tree [u8],
18274 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18275 match node.kind() {
18276 "with_initializer" => Ok(Self::WithInitializer(::std::boxed::Box::new(
18277 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
18278 ))),
18279 _other => {
18280 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18281 Ok(Self::Expression(::std::boxed::Box::new(v)))
18282 } else {
18283 Err(::treesitter_types::ParseError::unexpected_kind(
18284 _other, node,
18285 ))
18286 }
18287 }
18288 }
18289 }
18290}
18291impl ::treesitter_types::Spanned for WithExpressionChildren<'_> {
18292 fn span(&self) -> ::treesitter_types::Span {
18293 match self {
18294 Self::Expression(inner) => inner.span(),
18295 Self::WithInitializer(inner) => inner.span(),
18296 }
18297 }
18298}
18299#[derive(Debug, Clone, PartialEq, Eq)]
18300pub enum WithInitializerChildren<'tree> {
18301 Expression(::std::boxed::Box<Expression<'tree>>),
18302 Identifier(::std::boxed::Box<Identifier<'tree>>),
18303}
18304impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializerChildren<'tree> {
18305 #[allow(clippy::collapsible_else_if)]
18306 fn from_node(
18307 node: ::tree_sitter::Node<'tree>,
18308 src: &'tree [u8],
18309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18310 match node.kind() {
18311 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18312 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18313 ))),
18314 _other => {
18315 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18316 Ok(Self::Expression(::std::boxed::Box::new(v)))
18317 } else {
18318 Err(::treesitter_types::ParseError::unexpected_kind(
18319 _other, node,
18320 ))
18321 }
18322 }
18323 }
18324 }
18325}
18326impl ::treesitter_types::Spanned for WithInitializerChildren<'_> {
18327 fn span(&self) -> ::treesitter_types::Span {
18328 match self {
18329 Self::Expression(inner) => inner.span(),
18330 Self::Identifier(inner) => inner.span(),
18331 }
18332 }
18333}
18334#[derive(Debug, Clone, PartialEq, Eq)]
18335pub enum AnyNode<'tree> {
18336 Declaration(Declaration<'tree>),
18337 Expression(Expression<'tree>),
18338 Literal(Literal<'tree>),
18339 LvalueExpression(LvalueExpression<'tree>),
18340 NonLvalueExpression(NonLvalueExpression<'tree>),
18341 Pattern(Pattern<'tree>),
18342 Statement(Statement<'tree>),
18343 Type(Type<'tree>),
18344 TypeDeclaration(TypeDeclaration<'tree>),
18345 AccessorDeclaration(AccessorDeclaration<'tree>),
18346 AccessorList(AccessorList<'tree>),
18347 AliasQualifiedName(AliasQualifiedName<'tree>),
18348 AndPattern(AndPattern<'tree>),
18349 AnonymousMethodExpression(AnonymousMethodExpression<'tree>),
18350 AnonymousObjectCreationExpression(AnonymousObjectCreationExpression<'tree>),
18351 Argument(Argument<'tree>),
18352 ArgumentList(ArgumentList<'tree>),
18353 ArrayCreationExpression(ArrayCreationExpression<'tree>),
18354 ArrayRankSpecifier(ArrayRankSpecifier<'tree>),
18355 ArrayType(ArrayType<'tree>),
18356 ArrowExpressionClause(ArrowExpressionClause<'tree>),
18357 AsExpression(AsExpression<'tree>),
18358 AssignmentExpression(AssignmentExpression<'tree>),
18359 Attribute(Attribute<'tree>),
18360 AttributeArgument(AttributeArgument<'tree>),
18361 AttributeArgumentList(AttributeArgumentList<'tree>),
18362 AttributeList(AttributeList<'tree>),
18363 AttributeTargetSpecifier(AttributeTargetSpecifier<'tree>),
18364 AwaitExpression(AwaitExpression<'tree>),
18365 BaseList(BaseList<'tree>),
18366 BinaryExpression(BinaryExpression<'tree>),
18367 Block(Block<'tree>),
18368 BooleanLiteral(BooleanLiteral<'tree>),
18369 BracketedArgumentList(BracketedArgumentList<'tree>),
18370 BracketedParameterList(BracketedParameterList<'tree>),
18371 BreakStatement(BreakStatement<'tree>),
18372 CallingConvention(CallingConvention<'tree>),
18373 CastExpression(CastExpression<'tree>),
18374 CatchClause(CatchClause<'tree>),
18375 CatchDeclaration(CatchDeclaration<'tree>),
18376 CatchFilterClause(CatchFilterClause<'tree>),
18377 CharacterLiteral(CharacterLiteral<'tree>),
18378 CheckedExpression(CheckedExpression<'tree>),
18379 CheckedStatement(CheckedStatement<'tree>),
18380 ClassDeclaration(ClassDeclaration<'tree>),
18381 CompilationUnit(CompilationUnit<'tree>),
18382 ConditionalAccessExpression(ConditionalAccessExpression<'tree>),
18383 ConditionalExpression(ConditionalExpression<'tree>),
18384 ConstantPattern(ConstantPattern<'tree>),
18385 ConstructorConstraint(ConstructorConstraint<'tree>),
18386 ConstructorDeclaration(ConstructorDeclaration<'tree>),
18387 ConstructorInitializer(ConstructorInitializer<'tree>),
18388 ContinueStatement(ContinueStatement<'tree>),
18389 ConversionOperatorDeclaration(ConversionOperatorDeclaration<'tree>),
18390 DeclarationExpression(DeclarationExpression<'tree>),
18391 DeclarationList(DeclarationList<'tree>),
18392 DeclarationPattern(DeclarationPattern<'tree>),
18393 DefaultExpression(DefaultExpression<'tree>),
18394 DelegateDeclaration(DelegateDeclaration<'tree>),
18395 DestructorDeclaration(DestructorDeclaration<'tree>),
18396 DoStatement(DoStatement<'tree>),
18397 ElementAccessExpression(ElementAccessExpression<'tree>),
18398 ElementBindingExpression(ElementBindingExpression<'tree>),
18399 EmptyStatement(EmptyStatement<'tree>),
18400 EnumDeclaration(EnumDeclaration<'tree>),
18401 EnumMemberDeclaration(EnumMemberDeclaration<'tree>),
18402 EnumMemberDeclarationList(EnumMemberDeclarationList<'tree>),
18403 EventDeclaration(EventDeclaration<'tree>),
18404 EventFieldDeclaration(EventFieldDeclaration<'tree>),
18405 ExplicitInterfaceSpecifier(ExplicitInterfaceSpecifier<'tree>),
18406 ExpressionStatement(ExpressionStatement<'tree>),
18407 ExternAliasDirective(ExternAliasDirective<'tree>),
18408 FieldDeclaration(FieldDeclaration<'tree>),
18409 FileScopedNamespaceDeclaration(FileScopedNamespaceDeclaration<'tree>),
18410 FinallyClause(FinallyClause<'tree>),
18411 FixedStatement(FixedStatement<'tree>),
18412 ForStatement(ForStatement<'tree>),
18413 ForeachStatement(ForeachStatement<'tree>),
18414 FromClause(FromClause<'tree>),
18415 FunctionPointerParameter(FunctionPointerParameter<'tree>),
18416 FunctionPointerType(FunctionPointerType<'tree>),
18417 GenericName(GenericName<'tree>),
18418 GlobalAttribute(GlobalAttribute<'tree>),
18419 GlobalStatement(GlobalStatement<'tree>),
18420 GotoStatement(GotoStatement<'tree>),
18421 GroupClause(GroupClause<'tree>),
18422 Identifier(Identifier<'tree>),
18423 IfStatement(IfStatement<'tree>),
18424 ImplicitArrayCreationExpression(ImplicitArrayCreationExpression<'tree>),
18425 ImplicitObjectCreationExpression(ImplicitObjectCreationExpression<'tree>),
18426 ImplicitParameter(ImplicitParameter<'tree>),
18427 ImplicitStackallocExpression(ImplicitStackallocExpression<'tree>),
18428 ImplicitType(ImplicitType<'tree>),
18429 IndexerDeclaration(IndexerDeclaration<'tree>),
18430 InitializerExpression(InitializerExpression<'tree>),
18431 InterfaceDeclaration(InterfaceDeclaration<'tree>),
18432 InterpolatedStringExpression(InterpolatedStringExpression<'tree>),
18433 Interpolation(Interpolation<'tree>),
18434 InterpolationAlignmentClause(InterpolationAlignmentClause<'tree>),
18435 InterpolationFormatClause(InterpolationFormatClause<'tree>),
18436 InvocationExpression(InvocationExpression<'tree>),
18437 IsExpression(IsExpression<'tree>),
18438 IsPatternExpression(IsPatternExpression<'tree>),
18439 JoinClause(JoinClause<'tree>),
18440 JoinIntoClause(JoinIntoClause<'tree>),
18441 LabeledStatement(LabeledStatement<'tree>),
18442 LambdaExpression(LambdaExpression<'tree>),
18443 LetClause(LetClause<'tree>),
18444 ListPattern(ListPattern<'tree>),
18445 LocalDeclarationStatement(LocalDeclarationStatement<'tree>),
18446 LocalFunctionStatement(LocalFunctionStatement<'tree>),
18447 LockStatement(LockStatement<'tree>),
18448 MakerefExpression(MakerefExpression<'tree>),
18449 MemberAccessExpression(MemberAccessExpression<'tree>),
18450 MemberBindingExpression(MemberBindingExpression<'tree>),
18451 MethodDeclaration(MethodDeclaration<'tree>),
18452 Modifier(Modifier<'tree>),
18453 NamespaceDeclaration(NamespaceDeclaration<'tree>),
18454 NegatedPattern(NegatedPattern<'tree>),
18455 NullableType(NullableType<'tree>),
18456 ObjectCreationExpression(ObjectCreationExpression<'tree>),
18457 OperatorDeclaration(OperatorDeclaration<'tree>),
18458 OrPattern(OrPattern<'tree>),
18459 OrderByClause(OrderByClause<'tree>),
18460 Parameter(Parameter<'tree>),
18461 ParameterList(ParameterList<'tree>),
18462 ParenthesizedExpression(ParenthesizedExpression<'tree>),
18463 ParenthesizedPattern(ParenthesizedPattern<'tree>),
18464 ParenthesizedVariableDesignation(ParenthesizedVariableDesignation<'tree>),
18465 PointerType(PointerType<'tree>),
18466 PositionalPatternClause(PositionalPatternClause<'tree>),
18467 PostfixUnaryExpression(PostfixUnaryExpression<'tree>),
18468 PrefixUnaryExpression(PrefixUnaryExpression<'tree>),
18469 PreprocDefine(PreprocDefine<'tree>),
18470 PreprocElif(PreprocElif<'tree>),
18471 PreprocElse(PreprocElse<'tree>),
18472 PreprocEndregion(PreprocEndregion<'tree>),
18473 PreprocError(PreprocError<'tree>),
18474 PreprocIf(PreprocIf<'tree>),
18475 PreprocLine(PreprocLine<'tree>),
18476 PreprocNullable(PreprocNullable<'tree>),
18477 PreprocPragma(PreprocPragma<'tree>),
18478 PreprocRegion(PreprocRegion<'tree>),
18479 PreprocUndef(PreprocUndef<'tree>),
18480 PreprocWarning(PreprocWarning<'tree>),
18481 PrimaryConstructorBaseType(PrimaryConstructorBaseType<'tree>),
18482 PropertyDeclaration(PropertyDeclaration<'tree>),
18483 PropertyPatternClause(PropertyPatternClause<'tree>),
18484 QualifiedName(QualifiedName<'tree>),
18485 QueryExpression(QueryExpression<'tree>),
18486 RangeExpression(RangeExpression<'tree>),
18487 RawStringLiteral(RawStringLiteral<'tree>),
18488 RecordDeclaration(RecordDeclaration<'tree>),
18489 RecursivePattern(RecursivePattern<'tree>),
18490 RefExpression(RefExpression<'tree>),
18491 RefType(RefType<'tree>),
18492 ReftypeExpression(ReftypeExpression<'tree>),
18493 RefvalueExpression(RefvalueExpression<'tree>),
18494 RelationalPattern(RelationalPattern<'tree>),
18495 ReturnStatement(ReturnStatement<'tree>),
18496 ScopedType(ScopedType<'tree>),
18497 SelectClause(SelectClause<'tree>),
18498 SizeofExpression(SizeofExpression<'tree>),
18499 StackallocExpression(StackallocExpression<'tree>),
18500 StringLiteral(StringLiteral<'tree>),
18501 StringLiteralContent(StringLiteralContent<'tree>),
18502 StructDeclaration(StructDeclaration<'tree>),
18503 Subpattern(Subpattern<'tree>),
18504 SwitchBody(SwitchBody<'tree>),
18505 SwitchExpression(SwitchExpression<'tree>),
18506 SwitchExpressionArm(SwitchExpressionArm<'tree>),
18507 SwitchSection(SwitchSection<'tree>),
18508 SwitchStatement(SwitchStatement<'tree>),
18509 ThrowExpression(ThrowExpression<'tree>),
18510 ThrowStatement(ThrowStatement<'tree>),
18511 TryStatement(TryStatement<'tree>),
18512 TupleElement(TupleElement<'tree>),
18513 TupleExpression(TupleExpression<'tree>),
18514 TuplePattern(TuplePattern<'tree>),
18515 TupleType(TupleType<'tree>),
18516 TypeArgumentList(TypeArgumentList<'tree>),
18517 TypeParameter(TypeParameter<'tree>),
18518 TypeParameterConstraint(TypeParameterConstraint<'tree>),
18519 TypeParameterConstraintsClause(TypeParameterConstraintsClause<'tree>),
18520 TypeParameterList(TypeParameterList<'tree>),
18521 TypePattern(TypePattern<'tree>),
18522 TypeofExpression(TypeofExpression<'tree>),
18523 UnaryExpression(UnaryExpression<'tree>),
18524 UnsafeStatement(UnsafeStatement<'tree>),
18525 UsingDirective(UsingDirective<'tree>),
18526 UsingStatement(UsingStatement<'tree>),
18527 VarPattern(VarPattern<'tree>),
18528 VariableDeclaration(VariableDeclaration<'tree>),
18529 VariableDeclarator(VariableDeclarator<'tree>),
18530 WhenClause(WhenClause<'tree>),
18531 WhereClause(WhereClause<'tree>),
18532 WhileStatement(WhileStatement<'tree>),
18533 WithExpression(WithExpression<'tree>),
18534 WithInitializer(WithInitializer<'tree>),
18535 YieldStatement(YieldStatement<'tree>),
18536 CharacterLiteralContent(CharacterLiteralContent<'tree>),
18537 Comment(Comment<'tree>),
18538 Discard(Discard<'tree>),
18539 EscapeSequence(EscapeSequence<'tree>),
18540 IntegerLiteral(IntegerLiteral<'tree>),
18541 InterpolationBrace(InterpolationBrace<'tree>),
18542 InterpolationQuote(InterpolationQuote<'tree>),
18543 InterpolationStart(InterpolationStart<'tree>),
18544 NullLiteral(NullLiteral<'tree>),
18545 PredefinedType(PredefinedType<'tree>),
18546 PreprocArg(PreprocArg<'tree>),
18547 RawStringContent(RawStringContent<'tree>),
18548 RawStringEnd(RawStringEnd<'tree>),
18549 RawStringStart(RawStringStart<'tree>),
18550 RealLiteral(RealLiteral<'tree>),
18551 ShebangDirective(ShebangDirective<'tree>),
18552 StringContent(StringContent<'tree>),
18553 StringLiteralEncoding(StringLiteralEncoding<'tree>),
18554 VerbatimStringLiteral(VerbatimStringLiteral<'tree>),
18555 Unknown(::tree_sitter::Node<'tree>),
18556}
18557impl<'tree> AnyNode<'tree> {
18558 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
18559 match node.kind() {
18560 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18561 .map(Self::Declaration)
18562 .unwrap_or(Self::Unknown(node)),
18563 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18564 .map(Self::Expression)
18565 .unwrap_or(Self::Unknown(node)),
18566 "literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
18567 .map(Self::Literal)
18568 .unwrap_or(Self::Unknown(node)),
18569 "lvalue_expression" => {
18570 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
18571 .map(Self::LvalueExpression)
18572 .unwrap_or(Self::Unknown(node))
18573 }
18574 "non_lvalue_expression" => {
18575 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
18576 .map(Self::NonLvalueExpression)
18577 .unwrap_or(Self::Unknown(node))
18578 }
18579 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
18580 .map(Self::Pattern)
18581 .unwrap_or(Self::Unknown(node)),
18582 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18583 .map(Self::Statement)
18584 .unwrap_or(Self::Unknown(node)),
18585 "type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
18586 .map(Self::Type)
18587 .unwrap_or(Self::Unknown(node)),
18588 "type_declaration" => {
18589 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18590 .map(Self::TypeDeclaration)
18591 .unwrap_or(Self::Unknown(node))
18592 }
18593 "accessor_declaration" => {
18594 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18595 .map(Self::AccessorDeclaration)
18596 .unwrap_or(Self::Unknown(node))
18597 }
18598 "accessor_list" => <AccessorList as ::treesitter_types::FromNode>::from_node(node, src)
18599 .map(Self::AccessorList)
18600 .unwrap_or(Self::Unknown(node)),
18601 "alias_qualified_name" => {
18602 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18603 .map(Self::AliasQualifiedName)
18604 .unwrap_or(Self::Unknown(node))
18605 }
18606 "and_pattern" => <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)
18607 .map(Self::AndPattern)
18608 .unwrap_or(Self::Unknown(node)),
18609 "anonymous_method_expression" => {
18610 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(node, src)
18611 .map(Self::AnonymousMethodExpression)
18612 .unwrap_or(Self::Unknown(node))
18613 }
18614 "anonymous_object_creation_expression" => {
18615 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
18616 node, src,
18617 )
18618 .map(Self::AnonymousObjectCreationExpression)
18619 .unwrap_or(Self::Unknown(node))
18620 }
18621 "argument" => <Argument as ::treesitter_types::FromNode>::from_node(node, src)
18622 .map(Self::Argument)
18623 .unwrap_or(Self::Unknown(node)),
18624 "argument_list" => <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
18625 .map(Self::ArgumentList)
18626 .unwrap_or(Self::Unknown(node)),
18627 "array_creation_expression" => {
18628 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
18629 .map(Self::ArrayCreationExpression)
18630 .unwrap_or(Self::Unknown(node))
18631 }
18632 "array_rank_specifier" => {
18633 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18634 .map(Self::ArrayRankSpecifier)
18635 .unwrap_or(Self::Unknown(node))
18636 }
18637 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
18638 .map(Self::ArrayType)
18639 .unwrap_or(Self::Unknown(node)),
18640 "arrow_expression_clause" => {
18641 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
18642 .map(Self::ArrowExpressionClause)
18643 .unwrap_or(Self::Unknown(node))
18644 }
18645 "as_expression" => <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
18646 .map(Self::AsExpression)
18647 .unwrap_or(Self::Unknown(node)),
18648 "assignment_expression" => {
18649 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
18650 .map(Self::AssignmentExpression)
18651 .unwrap_or(Self::Unknown(node))
18652 }
18653 "attribute" => <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
18654 .map(Self::Attribute)
18655 .unwrap_or(Self::Unknown(node)),
18656 "attribute_argument" => {
18657 <AttributeArgument as ::treesitter_types::FromNode>::from_node(node, src)
18658 .map(Self::AttributeArgument)
18659 .unwrap_or(Self::Unknown(node))
18660 }
18661 "attribute_argument_list" => {
18662 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
18663 .map(Self::AttributeArgumentList)
18664 .unwrap_or(Self::Unknown(node))
18665 }
18666 "attribute_list" => {
18667 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18668 .map(Self::AttributeList)
18669 .unwrap_or(Self::Unknown(node))
18670 }
18671 "attribute_target_specifier" => {
18672 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18673 .map(Self::AttributeTargetSpecifier)
18674 .unwrap_or(Self::Unknown(node))
18675 }
18676 "await_expression" => {
18677 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
18678 .map(Self::AwaitExpression)
18679 .unwrap_or(Self::Unknown(node))
18680 }
18681 "base_list" => <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
18682 .map(Self::BaseList)
18683 .unwrap_or(Self::Unknown(node)),
18684 "binary_expression" => {
18685 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18686 .map(Self::BinaryExpression)
18687 .unwrap_or(Self::Unknown(node))
18688 }
18689 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
18690 .map(Self::Block)
18691 .unwrap_or(Self::Unknown(node)),
18692 "boolean_literal" => {
18693 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18694 .map(Self::BooleanLiteral)
18695 .unwrap_or(Self::Unknown(node))
18696 }
18697 "bracketed_argument_list" => {
18698 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
18699 .map(Self::BracketedArgumentList)
18700 .unwrap_or(Self::Unknown(node))
18701 }
18702 "bracketed_parameter_list" => {
18703 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(node, src)
18704 .map(Self::BracketedParameterList)
18705 .unwrap_or(Self::Unknown(node))
18706 }
18707 "break_statement" => {
18708 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
18709 .map(Self::BreakStatement)
18710 .unwrap_or(Self::Unknown(node))
18711 }
18712 "calling_convention" => {
18713 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
18714 .map(Self::CallingConvention)
18715 .unwrap_or(Self::Unknown(node))
18716 }
18717 "cast_expression" => {
18718 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
18719 .map(Self::CastExpression)
18720 .unwrap_or(Self::Unknown(node))
18721 }
18722 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
18723 .map(Self::CatchClause)
18724 .unwrap_or(Self::Unknown(node)),
18725 "catch_declaration" => {
18726 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18727 .map(Self::CatchDeclaration)
18728 .unwrap_or(Self::Unknown(node))
18729 }
18730 "catch_filter_clause" => {
18731 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)
18732 .map(Self::CatchFilterClause)
18733 .unwrap_or(Self::Unknown(node))
18734 }
18735 "character_literal" => {
18736 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18737 .map(Self::CharacterLiteral)
18738 .unwrap_or(Self::Unknown(node))
18739 }
18740 "checked_expression" => {
18741 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)
18742 .map(Self::CheckedExpression)
18743 .unwrap_or(Self::Unknown(node))
18744 }
18745 "checked_statement" => {
18746 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)
18747 .map(Self::CheckedStatement)
18748 .unwrap_or(Self::Unknown(node))
18749 }
18750 "class_declaration" => {
18751 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18752 .map(Self::ClassDeclaration)
18753 .unwrap_or(Self::Unknown(node))
18754 }
18755 "compilation_unit" => {
18756 <CompilationUnit as ::treesitter_types::FromNode>::from_node(node, src)
18757 .map(Self::CompilationUnit)
18758 .unwrap_or(Self::Unknown(node))
18759 }
18760 "conditional_access_expression" => {
18761 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
18762 .map(Self::ConditionalAccessExpression)
18763 .unwrap_or(Self::Unknown(node))
18764 }
18765 "conditional_expression" => {
18766 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
18767 .map(Self::ConditionalExpression)
18768 .unwrap_or(Self::Unknown(node))
18769 }
18770 "constant_pattern" => {
18771 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)
18772 .map(Self::ConstantPattern)
18773 .unwrap_or(Self::Unknown(node))
18774 }
18775 "constructor_constraint" => {
18776 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(node, src)
18777 .map(Self::ConstructorConstraint)
18778 .unwrap_or(Self::Unknown(node))
18779 }
18780 "constructor_declaration" => {
18781 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18782 .map(Self::ConstructorDeclaration)
18783 .unwrap_or(Self::Unknown(node))
18784 }
18785 "constructor_initializer" => {
18786 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)
18787 .map(Self::ConstructorInitializer)
18788 .unwrap_or(Self::Unknown(node))
18789 }
18790 "continue_statement" => {
18791 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
18792 .map(Self::ContinueStatement)
18793 .unwrap_or(Self::Unknown(node))
18794 }
18795 "conversion_operator_declaration" => {
18796 <ConversionOperatorDeclaration as ::treesitter_types::FromNode>::from_node(
18797 node, src,
18798 )
18799 .map(Self::ConversionOperatorDeclaration)
18800 .unwrap_or(Self::Unknown(node))
18801 }
18802 "declaration_expression" => {
18803 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)
18804 .map(Self::DeclarationExpression)
18805 .unwrap_or(Self::Unknown(node))
18806 }
18807 "declaration_list" => {
18808 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
18809 .map(Self::DeclarationList)
18810 .unwrap_or(Self::Unknown(node))
18811 }
18812 "declaration_pattern" => {
18813 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)
18814 .map(Self::DeclarationPattern)
18815 .unwrap_or(Self::Unknown(node))
18816 }
18817 "default_expression" => {
18818 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
18819 .map(Self::DefaultExpression)
18820 .unwrap_or(Self::Unknown(node))
18821 }
18822 "delegate_declaration" => {
18823 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18824 .map(Self::DelegateDeclaration)
18825 .unwrap_or(Self::Unknown(node))
18826 }
18827 "destructor_declaration" => {
18828 <DestructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18829 .map(Self::DestructorDeclaration)
18830 .unwrap_or(Self::Unknown(node))
18831 }
18832 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
18833 .map(Self::DoStatement)
18834 .unwrap_or(Self::Unknown(node)),
18835 "element_access_expression" => {
18836 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
18837 .map(Self::ElementAccessExpression)
18838 .unwrap_or(Self::Unknown(node))
18839 }
18840 "element_binding_expression" => {
18841 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
18842 .map(Self::ElementBindingExpression)
18843 .unwrap_or(Self::Unknown(node))
18844 }
18845 "empty_statement" => {
18846 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
18847 .map(Self::EmptyStatement)
18848 .unwrap_or(Self::Unknown(node))
18849 }
18850 "enum_declaration" => {
18851 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18852 .map(Self::EnumDeclaration)
18853 .unwrap_or(Self::Unknown(node))
18854 }
18855 "enum_member_declaration" => {
18856 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18857 .map(Self::EnumMemberDeclaration)
18858 .unwrap_or(Self::Unknown(node))
18859 }
18860 "enum_member_declaration_list" => {
18861 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
18862 .map(Self::EnumMemberDeclarationList)
18863 .unwrap_or(Self::Unknown(node))
18864 }
18865 "event_declaration" => {
18866 <EventDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18867 .map(Self::EventDeclaration)
18868 .unwrap_or(Self::Unknown(node))
18869 }
18870 "event_field_declaration" => {
18871 <EventFieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18872 .map(Self::EventFieldDeclaration)
18873 .unwrap_or(Self::Unknown(node))
18874 }
18875 "explicit_interface_specifier" => {
18876 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18877 .map(Self::ExplicitInterfaceSpecifier)
18878 .unwrap_or(Self::Unknown(node))
18879 }
18880 "expression_statement" => {
18881 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
18882 .map(Self::ExpressionStatement)
18883 .unwrap_or(Self::Unknown(node))
18884 }
18885 "extern_alias_directive" => {
18886 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
18887 .map(Self::ExternAliasDirective)
18888 .unwrap_or(Self::Unknown(node))
18889 }
18890 "field_declaration" => {
18891 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18892 .map(Self::FieldDeclaration)
18893 .unwrap_or(Self::Unknown(node))
18894 }
18895 "file_scoped_namespace_declaration" => {
18896 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
18897 node, src,
18898 )
18899 .map(Self::FileScopedNamespaceDeclaration)
18900 .unwrap_or(Self::Unknown(node))
18901 }
18902 "finally_clause" => {
18903 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
18904 .map(Self::FinallyClause)
18905 .unwrap_or(Self::Unknown(node))
18906 }
18907 "fixed_statement" => {
18908 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)
18909 .map(Self::FixedStatement)
18910 .unwrap_or(Self::Unknown(node))
18911 }
18912 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
18913 .map(Self::ForStatement)
18914 .unwrap_or(Self::Unknown(node)),
18915 "foreach_statement" => {
18916 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
18917 .map(Self::ForeachStatement)
18918 .unwrap_or(Self::Unknown(node))
18919 }
18920 "from_clause" => <FromClause as ::treesitter_types::FromNode>::from_node(node, src)
18921 .map(Self::FromClause)
18922 .unwrap_or(Self::Unknown(node)),
18923 "function_pointer_parameter" => {
18924 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(node, src)
18925 .map(Self::FunctionPointerParameter)
18926 .unwrap_or(Self::Unknown(node))
18927 }
18928 "function_pointer_type" => {
18929 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
18930 .map(Self::FunctionPointerType)
18931 .unwrap_or(Self::Unknown(node))
18932 }
18933 "generic_name" => <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18934 .map(Self::GenericName)
18935 .unwrap_or(Self::Unknown(node)),
18936 "global_attribute" => {
18937 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
18938 .map(Self::GlobalAttribute)
18939 .unwrap_or(Self::Unknown(node))
18940 }
18941 "global_statement" => {
18942 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)
18943 .map(Self::GlobalStatement)
18944 .unwrap_or(Self::Unknown(node))
18945 }
18946 "goto_statement" => {
18947 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
18948 .map(Self::GotoStatement)
18949 .unwrap_or(Self::Unknown(node))
18950 }
18951 "group_clause" => <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)
18952 .map(Self::GroupClause)
18953 .unwrap_or(Self::Unknown(node)),
18954 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18955 .map(Self::Identifier)
18956 .unwrap_or(Self::Unknown(node)),
18957 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
18958 .map(Self::IfStatement)
18959 .unwrap_or(Self::Unknown(node)),
18960 "implicit_array_creation_expression" => {
18961 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
18962 node, src,
18963 )
18964 .map(Self::ImplicitArrayCreationExpression)
18965 .unwrap_or(Self::Unknown(node))
18966 }
18967 "implicit_object_creation_expression" => {
18968 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
18969 node, src,
18970 )
18971 .map(Self::ImplicitObjectCreationExpression)
18972 .unwrap_or(Self::Unknown(node))
18973 }
18974 "implicit_parameter" => {
18975 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
18976 .map(Self::ImplicitParameter)
18977 .unwrap_or(Self::Unknown(node))
18978 }
18979 "implicit_stackalloc_expression" => {
18980 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
18981 .map(Self::ImplicitStackallocExpression)
18982 .unwrap_or(Self::Unknown(node))
18983 }
18984 "implicit_type" => <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
18985 .map(Self::ImplicitType)
18986 .unwrap_or(Self::Unknown(node)),
18987 "indexer_declaration" => {
18988 <IndexerDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18989 .map(Self::IndexerDeclaration)
18990 .unwrap_or(Self::Unknown(node))
18991 }
18992 "initializer_expression" => {
18993 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
18994 .map(Self::InitializerExpression)
18995 .unwrap_or(Self::Unknown(node))
18996 }
18997 "interface_declaration" => {
18998 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18999 .map(Self::InterfaceDeclaration)
19000 .unwrap_or(Self::Unknown(node))
19001 }
19002 "interpolated_string_expression" => {
19003 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(node, src)
19004 .map(Self::InterpolatedStringExpression)
19005 .unwrap_or(Self::Unknown(node))
19006 }
19007 "interpolation" => {
19008 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
19009 .map(Self::Interpolation)
19010 .unwrap_or(Self::Unknown(node))
19011 }
19012 "interpolation_alignment_clause" => {
19013 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(node, src)
19014 .map(Self::InterpolationAlignmentClause)
19015 .unwrap_or(Self::Unknown(node))
19016 }
19017 "interpolation_format_clause" => {
19018 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(node, src)
19019 .map(Self::InterpolationFormatClause)
19020 .unwrap_or(Self::Unknown(node))
19021 }
19022 "invocation_expression" => {
19023 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
19024 .map(Self::InvocationExpression)
19025 .unwrap_or(Self::Unknown(node))
19026 }
19027 "is_expression" => <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)
19028 .map(Self::IsExpression)
19029 .unwrap_or(Self::Unknown(node)),
19030 "is_pattern_expression" => {
19031 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)
19032 .map(Self::IsPatternExpression)
19033 .unwrap_or(Self::Unknown(node))
19034 }
19035 "join_clause" => <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)
19036 .map(Self::JoinClause)
19037 .unwrap_or(Self::Unknown(node)),
19038 "join_into_clause" => {
19039 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)
19040 .map(Self::JoinIntoClause)
19041 .unwrap_or(Self::Unknown(node))
19042 }
19043 "labeled_statement" => {
19044 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
19045 .map(Self::LabeledStatement)
19046 .unwrap_or(Self::Unknown(node))
19047 }
19048 "lambda_expression" => {
19049 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
19050 .map(Self::LambdaExpression)
19051 .unwrap_or(Self::Unknown(node))
19052 }
19053 "let_clause" => <LetClause as ::treesitter_types::FromNode>::from_node(node, src)
19054 .map(Self::LetClause)
19055 .unwrap_or(Self::Unknown(node)),
19056 "list_pattern" => <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)
19057 .map(Self::ListPattern)
19058 .unwrap_or(Self::Unknown(node)),
19059 "local_declaration_statement" => {
19060 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
19061 .map(Self::LocalDeclarationStatement)
19062 .unwrap_or(Self::Unknown(node))
19063 }
19064 "local_function_statement" => {
19065 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)
19066 .map(Self::LocalFunctionStatement)
19067 .unwrap_or(Self::Unknown(node))
19068 }
19069 "lock_statement" => {
19070 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)
19071 .map(Self::LockStatement)
19072 .unwrap_or(Self::Unknown(node))
19073 }
19074 "makeref_expression" => {
19075 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)
19076 .map(Self::MakerefExpression)
19077 .unwrap_or(Self::Unknown(node))
19078 }
19079 "member_access_expression" => {
19080 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
19081 .map(Self::MemberAccessExpression)
19082 .unwrap_or(Self::Unknown(node))
19083 }
19084 "member_binding_expression" => {
19085 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
19086 .map(Self::MemberBindingExpression)
19087 .unwrap_or(Self::Unknown(node))
19088 }
19089 "method_declaration" => {
19090 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19091 .map(Self::MethodDeclaration)
19092 .unwrap_or(Self::Unknown(node))
19093 }
19094 "modifier" => <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
19095 .map(Self::Modifier)
19096 .unwrap_or(Self::Unknown(node)),
19097 "namespace_declaration" => {
19098 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19099 .map(Self::NamespaceDeclaration)
19100 .unwrap_or(Self::Unknown(node))
19101 }
19102 "negated_pattern" => {
19103 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)
19104 .map(Self::NegatedPattern)
19105 .unwrap_or(Self::Unknown(node))
19106 }
19107 "nullable_type" => <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
19108 .map(Self::NullableType)
19109 .unwrap_or(Self::Unknown(node)),
19110 "object_creation_expression" => {
19111 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
19112 .map(Self::ObjectCreationExpression)
19113 .unwrap_or(Self::Unknown(node))
19114 }
19115 "operator_declaration" => {
19116 <OperatorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19117 .map(Self::OperatorDeclaration)
19118 .unwrap_or(Self::Unknown(node))
19119 }
19120 "or_pattern" => <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
19121 .map(Self::OrPattern)
19122 .unwrap_or(Self::Unknown(node)),
19123 "order_by_clause" => {
19124 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)
19125 .map(Self::OrderByClause)
19126 .unwrap_or(Self::Unknown(node))
19127 }
19128 "parameter" => <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
19129 .map(Self::Parameter)
19130 .unwrap_or(Self::Unknown(node)),
19131 "parameter_list" => {
19132 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19133 .map(Self::ParameterList)
19134 .unwrap_or(Self::Unknown(node))
19135 }
19136 "parenthesized_expression" => {
19137 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
19138 .map(Self::ParenthesizedExpression)
19139 .unwrap_or(Self::Unknown(node))
19140 }
19141 "parenthesized_pattern" => {
19142 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
19143 .map(Self::ParenthesizedPattern)
19144 .unwrap_or(Self::Unknown(node))
19145 }
19146 "parenthesized_variable_designation" => {
19147 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
19148 node, src,
19149 )
19150 .map(Self::ParenthesizedVariableDesignation)
19151 .unwrap_or(Self::Unknown(node))
19152 }
19153 "pointer_type" => <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
19154 .map(Self::PointerType)
19155 .unwrap_or(Self::Unknown(node)),
19156 "positional_pattern_clause" => {
19157 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
19158 .map(Self::PositionalPatternClause)
19159 .unwrap_or(Self::Unknown(node))
19160 }
19161 "postfix_unary_expression" => {
19162 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19163 .map(Self::PostfixUnaryExpression)
19164 .unwrap_or(Self::Unknown(node))
19165 }
19166 "prefix_unary_expression" => {
19167 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19168 .map(Self::PrefixUnaryExpression)
19169 .unwrap_or(Self::Unknown(node))
19170 }
19171 "preproc_define" => {
19172 <PreprocDefine as ::treesitter_types::FromNode>::from_node(node, src)
19173 .map(Self::PreprocDefine)
19174 .unwrap_or(Self::Unknown(node))
19175 }
19176 "preproc_elif" => <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
19177 .map(Self::PreprocElif)
19178 .unwrap_or(Self::Unknown(node)),
19179 "preproc_else" => <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
19180 .map(Self::PreprocElse)
19181 .unwrap_or(Self::Unknown(node)),
19182 "preproc_endregion" => {
19183 <PreprocEndregion as ::treesitter_types::FromNode>::from_node(node, src)
19184 .map(Self::PreprocEndregion)
19185 .unwrap_or(Self::Unknown(node))
19186 }
19187 "preproc_error" => <PreprocError as ::treesitter_types::FromNode>::from_node(node, src)
19188 .map(Self::PreprocError)
19189 .unwrap_or(Self::Unknown(node)),
19190 "preproc_if" => <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
19191 .map(Self::PreprocIf)
19192 .unwrap_or(Self::Unknown(node)),
19193 "preproc_line" => <PreprocLine as ::treesitter_types::FromNode>::from_node(node, src)
19194 .map(Self::PreprocLine)
19195 .unwrap_or(Self::Unknown(node)),
19196 "preproc_nullable" => {
19197 <PreprocNullable as ::treesitter_types::FromNode>::from_node(node, src)
19198 .map(Self::PreprocNullable)
19199 .unwrap_or(Self::Unknown(node))
19200 }
19201 "preproc_pragma" => {
19202 <PreprocPragma as ::treesitter_types::FromNode>::from_node(node, src)
19203 .map(Self::PreprocPragma)
19204 .unwrap_or(Self::Unknown(node))
19205 }
19206 "preproc_region" => {
19207 <PreprocRegion as ::treesitter_types::FromNode>::from_node(node, src)
19208 .map(Self::PreprocRegion)
19209 .unwrap_or(Self::Unknown(node))
19210 }
19211 "preproc_undef" => <PreprocUndef as ::treesitter_types::FromNode>::from_node(node, src)
19212 .map(Self::PreprocUndef)
19213 .unwrap_or(Self::Unknown(node)),
19214 "preproc_warning" => {
19215 <PreprocWarning as ::treesitter_types::FromNode>::from_node(node, src)
19216 .map(Self::PreprocWarning)
19217 .unwrap_or(Self::Unknown(node))
19218 }
19219 "primary_constructor_base_type" => {
19220 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(node, src)
19221 .map(Self::PrimaryConstructorBaseType)
19222 .unwrap_or(Self::Unknown(node))
19223 }
19224 "property_declaration" => {
19225 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19226 .map(Self::PropertyDeclaration)
19227 .unwrap_or(Self::Unknown(node))
19228 }
19229 "property_pattern_clause" => {
19230 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
19231 .map(Self::PropertyPatternClause)
19232 .unwrap_or(Self::Unknown(node))
19233 }
19234 "qualified_name" => {
19235 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19236 .map(Self::QualifiedName)
19237 .unwrap_or(Self::Unknown(node))
19238 }
19239 "query_expression" => {
19240 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19241 .map(Self::QueryExpression)
19242 .unwrap_or(Self::Unknown(node))
19243 }
19244 "range_expression" => {
19245 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
19246 .map(Self::RangeExpression)
19247 .unwrap_or(Self::Unknown(node))
19248 }
19249 "raw_string_literal" => {
19250 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19251 .map(Self::RawStringLiteral)
19252 .unwrap_or(Self::Unknown(node))
19253 }
19254 "record_declaration" => {
19255 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19256 .map(Self::RecordDeclaration)
19257 .unwrap_or(Self::Unknown(node))
19258 }
19259 "recursive_pattern" => {
19260 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)
19261 .map(Self::RecursivePattern)
19262 .unwrap_or(Self::Unknown(node))
19263 }
19264 "ref_expression" => {
19265 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)
19266 .map(Self::RefExpression)
19267 .unwrap_or(Self::Unknown(node))
19268 }
19269 "ref_type" => <RefType as ::treesitter_types::FromNode>::from_node(node, src)
19270 .map(Self::RefType)
19271 .unwrap_or(Self::Unknown(node)),
19272 "reftype_expression" => {
19273 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)
19274 .map(Self::ReftypeExpression)
19275 .unwrap_or(Self::Unknown(node))
19276 }
19277 "refvalue_expression" => {
19278 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
19279 .map(Self::RefvalueExpression)
19280 .unwrap_or(Self::Unknown(node))
19281 }
19282 "relational_pattern" => {
19283 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)
19284 .map(Self::RelationalPattern)
19285 .unwrap_or(Self::Unknown(node))
19286 }
19287 "return_statement" => {
19288 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
19289 .map(Self::ReturnStatement)
19290 .unwrap_or(Self::Unknown(node))
19291 }
19292 "scoped_type" => <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)
19293 .map(Self::ScopedType)
19294 .unwrap_or(Self::Unknown(node)),
19295 "select_clause" => <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)
19296 .map(Self::SelectClause)
19297 .unwrap_or(Self::Unknown(node)),
19298 "sizeof_expression" => {
19299 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
19300 .map(Self::SizeofExpression)
19301 .unwrap_or(Self::Unknown(node))
19302 }
19303 "stackalloc_expression" => {
19304 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
19305 .map(Self::StackallocExpression)
19306 .unwrap_or(Self::Unknown(node))
19307 }
19308 "string_literal" => {
19309 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19310 .map(Self::StringLiteral)
19311 .unwrap_or(Self::Unknown(node))
19312 }
19313 "string_literal_content" => {
19314 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
19315 .map(Self::StringLiteralContent)
19316 .unwrap_or(Self::Unknown(node))
19317 }
19318 "struct_declaration" => {
19319 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19320 .map(Self::StructDeclaration)
19321 .unwrap_or(Self::Unknown(node))
19322 }
19323 "subpattern" => <Subpattern as ::treesitter_types::FromNode>::from_node(node, src)
19324 .map(Self::Subpattern)
19325 .unwrap_or(Self::Unknown(node)),
19326 "switch_body" => <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
19327 .map(Self::SwitchBody)
19328 .unwrap_or(Self::Unknown(node)),
19329 "switch_expression" => {
19330 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
19331 .map(Self::SwitchExpression)
19332 .unwrap_or(Self::Unknown(node))
19333 }
19334 "switch_expression_arm" => {
19335 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)
19336 .map(Self::SwitchExpressionArm)
19337 .unwrap_or(Self::Unknown(node))
19338 }
19339 "switch_section" => {
19340 <SwitchSection as ::treesitter_types::FromNode>::from_node(node, src)
19341 .map(Self::SwitchSection)
19342 .unwrap_or(Self::Unknown(node))
19343 }
19344 "switch_statement" => {
19345 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
19346 .map(Self::SwitchStatement)
19347 .unwrap_or(Self::Unknown(node))
19348 }
19349 "throw_expression" => {
19350 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
19351 .map(Self::ThrowExpression)
19352 .unwrap_or(Self::Unknown(node))
19353 }
19354 "throw_statement" => {
19355 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
19356 .map(Self::ThrowStatement)
19357 .unwrap_or(Self::Unknown(node))
19358 }
19359 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
19360 .map(Self::TryStatement)
19361 .unwrap_or(Self::Unknown(node)),
19362 "tuple_element" => <TupleElement as ::treesitter_types::FromNode>::from_node(node, src)
19363 .map(Self::TupleElement)
19364 .unwrap_or(Self::Unknown(node)),
19365 "tuple_expression" => {
19366 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
19367 .map(Self::TupleExpression)
19368 .unwrap_or(Self::Unknown(node))
19369 }
19370 "tuple_pattern" => <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
19371 .map(Self::TuplePattern)
19372 .unwrap_or(Self::Unknown(node)),
19373 "tuple_type" => <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
19374 .map(Self::TupleType)
19375 .unwrap_or(Self::Unknown(node)),
19376 "type_argument_list" => {
19377 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19378 .map(Self::TypeArgumentList)
19379 .unwrap_or(Self::Unknown(node))
19380 }
19381 "type_parameter" => {
19382 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
19383 .map(Self::TypeParameter)
19384 .unwrap_or(Self::Unknown(node))
19385 }
19386 "type_parameter_constraint" => {
19387 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(node, src)
19388 .map(Self::TypeParameterConstraint)
19389 .unwrap_or(Self::Unknown(node))
19390 }
19391 "type_parameter_constraints_clause" => {
19392 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
19393 node, src,
19394 )
19395 .map(Self::TypeParameterConstraintsClause)
19396 .unwrap_or(Self::Unknown(node))
19397 }
19398 "type_parameter_list" => {
19399 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19400 .map(Self::TypeParameterList)
19401 .unwrap_or(Self::Unknown(node))
19402 }
19403 "type_pattern" => <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
19404 .map(Self::TypePattern)
19405 .unwrap_or(Self::Unknown(node)),
19406 "typeof_expression" => {
19407 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
19408 .map(Self::TypeofExpression)
19409 .unwrap_or(Self::Unknown(node))
19410 }
19411 "unary_expression" => {
19412 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19413 .map(Self::UnaryExpression)
19414 .unwrap_or(Self::Unknown(node))
19415 }
19416 "unsafe_statement" => {
19417 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)
19418 .map(Self::UnsafeStatement)
19419 .unwrap_or(Self::Unknown(node))
19420 }
19421 "using_directive" => {
19422 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
19423 .map(Self::UsingDirective)
19424 .unwrap_or(Self::Unknown(node))
19425 }
19426 "using_statement" => {
19427 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)
19428 .map(Self::UsingStatement)
19429 .unwrap_or(Self::Unknown(node))
19430 }
19431 "var_pattern" => <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)
19432 .map(Self::VarPattern)
19433 .unwrap_or(Self::Unknown(node)),
19434 "variable_declaration" => {
19435 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19436 .map(Self::VariableDeclaration)
19437 .unwrap_or(Self::Unknown(node))
19438 }
19439 "variable_declarator" => {
19440 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19441 .map(Self::VariableDeclarator)
19442 .unwrap_or(Self::Unknown(node))
19443 }
19444 "when_clause" => <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
19445 .map(Self::WhenClause)
19446 .unwrap_or(Self::Unknown(node)),
19447 "where_clause" => <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
19448 .map(Self::WhereClause)
19449 .unwrap_or(Self::Unknown(node)),
19450 "while_statement" => {
19451 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
19452 .map(Self::WhileStatement)
19453 .unwrap_or(Self::Unknown(node))
19454 }
19455 "with_expression" => {
19456 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)
19457 .map(Self::WithExpression)
19458 .unwrap_or(Self::Unknown(node))
19459 }
19460 "with_initializer" => {
19461 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)
19462 .map(Self::WithInitializer)
19463 .unwrap_or(Self::Unknown(node))
19464 }
19465 "yield_statement" => {
19466 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
19467 .map(Self::YieldStatement)
19468 .unwrap_or(Self::Unknown(node))
19469 }
19470 "character_literal_content" => {
19471 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
19472 .map(Self::CharacterLiteralContent)
19473 .unwrap_or(Self::Unknown(node))
19474 }
19475 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
19476 .map(Self::Comment)
19477 .unwrap_or(Self::Unknown(node)),
19478 "discard" => <Discard as ::treesitter_types::FromNode>::from_node(node, src)
19479 .map(Self::Discard)
19480 .unwrap_or(Self::Unknown(node)),
19481 "escape_sequence" => {
19482 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
19483 .map(Self::EscapeSequence)
19484 .unwrap_or(Self::Unknown(node))
19485 }
19486 "integer_literal" => {
19487 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19488 .map(Self::IntegerLiteral)
19489 .unwrap_or(Self::Unknown(node))
19490 }
19491 "interpolation_brace" => {
19492 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)
19493 .map(Self::InterpolationBrace)
19494 .unwrap_or(Self::Unknown(node))
19495 }
19496 "interpolation_quote" => {
19497 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)
19498 .map(Self::InterpolationQuote)
19499 .unwrap_or(Self::Unknown(node))
19500 }
19501 "interpolation_start" => {
19502 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)
19503 .map(Self::InterpolationStart)
19504 .unwrap_or(Self::Unknown(node))
19505 }
19506 "null_literal" => <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19507 .map(Self::NullLiteral)
19508 .unwrap_or(Self::Unknown(node)),
19509 "predefined_type" => {
19510 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
19511 .map(Self::PredefinedType)
19512 .unwrap_or(Self::Unknown(node))
19513 }
19514 "preproc_arg" => <PreprocArg as ::treesitter_types::FromNode>::from_node(node, src)
19515 .map(Self::PreprocArg)
19516 .unwrap_or(Self::Unknown(node)),
19517 "raw_string_content" => {
19518 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
19519 .map(Self::RawStringContent)
19520 .unwrap_or(Self::Unknown(node))
19521 }
19522 "raw_string_end" => {
19523 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)
19524 .map(Self::RawStringEnd)
19525 .unwrap_or(Self::Unknown(node))
19526 }
19527 "raw_string_start" => {
19528 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)
19529 .map(Self::RawStringStart)
19530 .unwrap_or(Self::Unknown(node))
19531 }
19532 "real_literal" => <RealLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19533 .map(Self::RealLiteral)
19534 .unwrap_or(Self::Unknown(node)),
19535 "shebang_directive" => {
19536 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)
19537 .map(Self::ShebangDirective)
19538 .unwrap_or(Self::Unknown(node))
19539 }
19540 "string_content" => {
19541 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
19542 .map(Self::StringContent)
19543 .unwrap_or(Self::Unknown(node))
19544 }
19545 "string_literal_encoding" => {
19546 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)
19547 .map(Self::StringLiteralEncoding)
19548 .unwrap_or(Self::Unknown(node))
19549 }
19550 "verbatim_string_literal" => {
19551 <VerbatimStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19552 .map(Self::VerbatimStringLiteral)
19553 .unwrap_or(Self::Unknown(node))
19554 }
19555 _ => Self::Unknown(node),
19556 }
19557 }
19558}
19559impl ::treesitter_types::Spanned for AnyNode<'_> {
19560 fn span(&self) -> ::treesitter_types::Span {
19561 match self {
19562 Self::Declaration(inner) => inner.span(),
19563 Self::Expression(inner) => inner.span(),
19564 Self::Literal(inner) => inner.span(),
19565 Self::LvalueExpression(inner) => inner.span(),
19566 Self::NonLvalueExpression(inner) => inner.span(),
19567 Self::Pattern(inner) => inner.span(),
19568 Self::Statement(inner) => inner.span(),
19569 Self::Type(inner) => inner.span(),
19570 Self::TypeDeclaration(inner) => inner.span(),
19571 Self::AccessorDeclaration(inner) => inner.span(),
19572 Self::AccessorList(inner) => inner.span(),
19573 Self::AliasQualifiedName(inner) => inner.span(),
19574 Self::AndPattern(inner) => inner.span(),
19575 Self::AnonymousMethodExpression(inner) => inner.span(),
19576 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
19577 Self::Argument(inner) => inner.span(),
19578 Self::ArgumentList(inner) => inner.span(),
19579 Self::ArrayCreationExpression(inner) => inner.span(),
19580 Self::ArrayRankSpecifier(inner) => inner.span(),
19581 Self::ArrayType(inner) => inner.span(),
19582 Self::ArrowExpressionClause(inner) => inner.span(),
19583 Self::AsExpression(inner) => inner.span(),
19584 Self::AssignmentExpression(inner) => inner.span(),
19585 Self::Attribute(inner) => inner.span(),
19586 Self::AttributeArgument(inner) => inner.span(),
19587 Self::AttributeArgumentList(inner) => inner.span(),
19588 Self::AttributeList(inner) => inner.span(),
19589 Self::AttributeTargetSpecifier(inner) => inner.span(),
19590 Self::AwaitExpression(inner) => inner.span(),
19591 Self::BaseList(inner) => inner.span(),
19592 Self::BinaryExpression(inner) => inner.span(),
19593 Self::Block(inner) => inner.span(),
19594 Self::BooleanLiteral(inner) => inner.span(),
19595 Self::BracketedArgumentList(inner) => inner.span(),
19596 Self::BracketedParameterList(inner) => inner.span(),
19597 Self::BreakStatement(inner) => inner.span(),
19598 Self::CallingConvention(inner) => inner.span(),
19599 Self::CastExpression(inner) => inner.span(),
19600 Self::CatchClause(inner) => inner.span(),
19601 Self::CatchDeclaration(inner) => inner.span(),
19602 Self::CatchFilterClause(inner) => inner.span(),
19603 Self::CharacterLiteral(inner) => inner.span(),
19604 Self::CheckedExpression(inner) => inner.span(),
19605 Self::CheckedStatement(inner) => inner.span(),
19606 Self::ClassDeclaration(inner) => inner.span(),
19607 Self::CompilationUnit(inner) => inner.span(),
19608 Self::ConditionalAccessExpression(inner) => inner.span(),
19609 Self::ConditionalExpression(inner) => inner.span(),
19610 Self::ConstantPattern(inner) => inner.span(),
19611 Self::ConstructorConstraint(inner) => inner.span(),
19612 Self::ConstructorDeclaration(inner) => inner.span(),
19613 Self::ConstructorInitializer(inner) => inner.span(),
19614 Self::ContinueStatement(inner) => inner.span(),
19615 Self::ConversionOperatorDeclaration(inner) => inner.span(),
19616 Self::DeclarationExpression(inner) => inner.span(),
19617 Self::DeclarationList(inner) => inner.span(),
19618 Self::DeclarationPattern(inner) => inner.span(),
19619 Self::DefaultExpression(inner) => inner.span(),
19620 Self::DelegateDeclaration(inner) => inner.span(),
19621 Self::DestructorDeclaration(inner) => inner.span(),
19622 Self::DoStatement(inner) => inner.span(),
19623 Self::ElementAccessExpression(inner) => inner.span(),
19624 Self::ElementBindingExpression(inner) => inner.span(),
19625 Self::EmptyStatement(inner) => inner.span(),
19626 Self::EnumDeclaration(inner) => inner.span(),
19627 Self::EnumMemberDeclaration(inner) => inner.span(),
19628 Self::EnumMemberDeclarationList(inner) => inner.span(),
19629 Self::EventDeclaration(inner) => inner.span(),
19630 Self::EventFieldDeclaration(inner) => inner.span(),
19631 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
19632 Self::ExpressionStatement(inner) => inner.span(),
19633 Self::ExternAliasDirective(inner) => inner.span(),
19634 Self::FieldDeclaration(inner) => inner.span(),
19635 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
19636 Self::FinallyClause(inner) => inner.span(),
19637 Self::FixedStatement(inner) => inner.span(),
19638 Self::ForStatement(inner) => inner.span(),
19639 Self::ForeachStatement(inner) => inner.span(),
19640 Self::FromClause(inner) => inner.span(),
19641 Self::FunctionPointerParameter(inner) => inner.span(),
19642 Self::FunctionPointerType(inner) => inner.span(),
19643 Self::GenericName(inner) => inner.span(),
19644 Self::GlobalAttribute(inner) => inner.span(),
19645 Self::GlobalStatement(inner) => inner.span(),
19646 Self::GotoStatement(inner) => inner.span(),
19647 Self::GroupClause(inner) => inner.span(),
19648 Self::Identifier(inner) => inner.span(),
19649 Self::IfStatement(inner) => inner.span(),
19650 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
19651 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
19652 Self::ImplicitParameter(inner) => inner.span(),
19653 Self::ImplicitStackallocExpression(inner) => inner.span(),
19654 Self::ImplicitType(inner) => inner.span(),
19655 Self::IndexerDeclaration(inner) => inner.span(),
19656 Self::InitializerExpression(inner) => inner.span(),
19657 Self::InterfaceDeclaration(inner) => inner.span(),
19658 Self::InterpolatedStringExpression(inner) => inner.span(),
19659 Self::Interpolation(inner) => inner.span(),
19660 Self::InterpolationAlignmentClause(inner) => inner.span(),
19661 Self::InterpolationFormatClause(inner) => inner.span(),
19662 Self::InvocationExpression(inner) => inner.span(),
19663 Self::IsExpression(inner) => inner.span(),
19664 Self::IsPatternExpression(inner) => inner.span(),
19665 Self::JoinClause(inner) => inner.span(),
19666 Self::JoinIntoClause(inner) => inner.span(),
19667 Self::LabeledStatement(inner) => inner.span(),
19668 Self::LambdaExpression(inner) => inner.span(),
19669 Self::LetClause(inner) => inner.span(),
19670 Self::ListPattern(inner) => inner.span(),
19671 Self::LocalDeclarationStatement(inner) => inner.span(),
19672 Self::LocalFunctionStatement(inner) => inner.span(),
19673 Self::LockStatement(inner) => inner.span(),
19674 Self::MakerefExpression(inner) => inner.span(),
19675 Self::MemberAccessExpression(inner) => inner.span(),
19676 Self::MemberBindingExpression(inner) => inner.span(),
19677 Self::MethodDeclaration(inner) => inner.span(),
19678 Self::Modifier(inner) => inner.span(),
19679 Self::NamespaceDeclaration(inner) => inner.span(),
19680 Self::NegatedPattern(inner) => inner.span(),
19681 Self::NullableType(inner) => inner.span(),
19682 Self::ObjectCreationExpression(inner) => inner.span(),
19683 Self::OperatorDeclaration(inner) => inner.span(),
19684 Self::OrPattern(inner) => inner.span(),
19685 Self::OrderByClause(inner) => inner.span(),
19686 Self::Parameter(inner) => inner.span(),
19687 Self::ParameterList(inner) => inner.span(),
19688 Self::ParenthesizedExpression(inner) => inner.span(),
19689 Self::ParenthesizedPattern(inner) => inner.span(),
19690 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
19691 Self::PointerType(inner) => inner.span(),
19692 Self::PositionalPatternClause(inner) => inner.span(),
19693 Self::PostfixUnaryExpression(inner) => inner.span(),
19694 Self::PrefixUnaryExpression(inner) => inner.span(),
19695 Self::PreprocDefine(inner) => inner.span(),
19696 Self::PreprocElif(inner) => inner.span(),
19697 Self::PreprocElse(inner) => inner.span(),
19698 Self::PreprocEndregion(inner) => inner.span(),
19699 Self::PreprocError(inner) => inner.span(),
19700 Self::PreprocIf(inner) => inner.span(),
19701 Self::PreprocLine(inner) => inner.span(),
19702 Self::PreprocNullable(inner) => inner.span(),
19703 Self::PreprocPragma(inner) => inner.span(),
19704 Self::PreprocRegion(inner) => inner.span(),
19705 Self::PreprocUndef(inner) => inner.span(),
19706 Self::PreprocWarning(inner) => inner.span(),
19707 Self::PrimaryConstructorBaseType(inner) => inner.span(),
19708 Self::PropertyDeclaration(inner) => inner.span(),
19709 Self::PropertyPatternClause(inner) => inner.span(),
19710 Self::QualifiedName(inner) => inner.span(),
19711 Self::QueryExpression(inner) => inner.span(),
19712 Self::RangeExpression(inner) => inner.span(),
19713 Self::RawStringLiteral(inner) => inner.span(),
19714 Self::RecordDeclaration(inner) => inner.span(),
19715 Self::RecursivePattern(inner) => inner.span(),
19716 Self::RefExpression(inner) => inner.span(),
19717 Self::RefType(inner) => inner.span(),
19718 Self::ReftypeExpression(inner) => inner.span(),
19719 Self::RefvalueExpression(inner) => inner.span(),
19720 Self::RelationalPattern(inner) => inner.span(),
19721 Self::ReturnStatement(inner) => inner.span(),
19722 Self::ScopedType(inner) => inner.span(),
19723 Self::SelectClause(inner) => inner.span(),
19724 Self::SizeofExpression(inner) => inner.span(),
19725 Self::StackallocExpression(inner) => inner.span(),
19726 Self::StringLiteral(inner) => inner.span(),
19727 Self::StringLiteralContent(inner) => inner.span(),
19728 Self::StructDeclaration(inner) => inner.span(),
19729 Self::Subpattern(inner) => inner.span(),
19730 Self::SwitchBody(inner) => inner.span(),
19731 Self::SwitchExpression(inner) => inner.span(),
19732 Self::SwitchExpressionArm(inner) => inner.span(),
19733 Self::SwitchSection(inner) => inner.span(),
19734 Self::SwitchStatement(inner) => inner.span(),
19735 Self::ThrowExpression(inner) => inner.span(),
19736 Self::ThrowStatement(inner) => inner.span(),
19737 Self::TryStatement(inner) => inner.span(),
19738 Self::TupleElement(inner) => inner.span(),
19739 Self::TupleExpression(inner) => inner.span(),
19740 Self::TuplePattern(inner) => inner.span(),
19741 Self::TupleType(inner) => inner.span(),
19742 Self::TypeArgumentList(inner) => inner.span(),
19743 Self::TypeParameter(inner) => inner.span(),
19744 Self::TypeParameterConstraint(inner) => inner.span(),
19745 Self::TypeParameterConstraintsClause(inner) => inner.span(),
19746 Self::TypeParameterList(inner) => inner.span(),
19747 Self::TypePattern(inner) => inner.span(),
19748 Self::TypeofExpression(inner) => inner.span(),
19749 Self::UnaryExpression(inner) => inner.span(),
19750 Self::UnsafeStatement(inner) => inner.span(),
19751 Self::UsingDirective(inner) => inner.span(),
19752 Self::UsingStatement(inner) => inner.span(),
19753 Self::VarPattern(inner) => inner.span(),
19754 Self::VariableDeclaration(inner) => inner.span(),
19755 Self::VariableDeclarator(inner) => inner.span(),
19756 Self::WhenClause(inner) => inner.span(),
19757 Self::WhereClause(inner) => inner.span(),
19758 Self::WhileStatement(inner) => inner.span(),
19759 Self::WithExpression(inner) => inner.span(),
19760 Self::WithInitializer(inner) => inner.span(),
19761 Self::YieldStatement(inner) => inner.span(),
19762 Self::CharacterLiteralContent(inner) => inner.span(),
19763 Self::Comment(inner) => inner.span(),
19764 Self::Discard(inner) => inner.span(),
19765 Self::EscapeSequence(inner) => inner.span(),
19766 Self::IntegerLiteral(inner) => inner.span(),
19767 Self::InterpolationBrace(inner) => inner.span(),
19768 Self::InterpolationQuote(inner) => inner.span(),
19769 Self::InterpolationStart(inner) => inner.span(),
19770 Self::NullLiteral(inner) => inner.span(),
19771 Self::PredefinedType(inner) => inner.span(),
19772 Self::PreprocArg(inner) => inner.span(),
19773 Self::RawStringContent(inner) => inner.span(),
19774 Self::RawStringEnd(inner) => inner.span(),
19775 Self::RawStringStart(inner) => inner.span(),
19776 Self::RealLiteral(inner) => inner.span(),
19777 Self::ShebangDirective(inner) => inner.span(),
19778 Self::StringContent(inner) => inner.span(),
19779 Self::StringLiteralEncoding(inner) => inner.span(),
19780 Self::VerbatimStringLiteral(inner) => inner.span(),
19781 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
19782 }
19783 }
19784}