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: ::treesitter_types::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 ::treesitter_types::runtime::maybe_grow_stack(|| {
32 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
33 })?,
34 ))),
35 "constructor_declaration" => Ok(Self::ConstructorDeclaration(::std::boxed::Box::new(
36 ::treesitter_types::runtime::maybe_grow_stack(|| {
37 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
38 })?,
39 ))),
40 "conversion_operator_declaration" => Ok(Self::ConversionOperatorDeclaration(
41 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
42 <ConversionOperatorDeclaration as ::treesitter_types::FromNode>::from_node(
43 node, src,
44 )
45 })?),
46 )),
47 "delegate_declaration" => Ok(Self::DelegateDeclaration(::std::boxed::Box::new(
48 ::treesitter_types::runtime::maybe_grow_stack(|| {
49 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
50 })?,
51 ))),
52 "destructor_declaration" => Ok(Self::DestructorDeclaration(::std::boxed::Box::new(
53 ::treesitter_types::runtime::maybe_grow_stack(|| {
54 <DestructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
55 })?,
56 ))),
57 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
58 ::treesitter_types::runtime::maybe_grow_stack(|| {
59 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
60 })?,
61 ))),
62 "event_declaration" => Ok(Self::EventDeclaration(::std::boxed::Box::new(
63 ::treesitter_types::runtime::maybe_grow_stack(|| {
64 <EventDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
65 })?,
66 ))),
67 "event_field_declaration" => Ok(Self::EventFieldDeclaration(::std::boxed::Box::new(
68 ::treesitter_types::runtime::maybe_grow_stack(|| {
69 <EventFieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
70 })?,
71 ))),
72 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
73 ::treesitter_types::runtime::maybe_grow_stack(|| {
74 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
75 })?,
76 ))),
77 "indexer_declaration" => Ok(Self::IndexerDeclaration(::std::boxed::Box::new(
78 ::treesitter_types::runtime::maybe_grow_stack(|| {
79 <IndexerDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
80 })?,
81 ))),
82 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
83 ::treesitter_types::runtime::maybe_grow_stack(|| {
84 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
85 })?,
86 ))),
87 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
88 ::treesitter_types::runtime::maybe_grow_stack(|| {
89 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
90 })?,
91 ))),
92 "namespace_declaration" => Ok(Self::NamespaceDeclaration(::std::boxed::Box::new(
93 ::treesitter_types::runtime::maybe_grow_stack(|| {
94 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
95 })?,
96 ))),
97 "operator_declaration" => Ok(Self::OperatorDeclaration(::std::boxed::Box::new(
98 ::treesitter_types::runtime::maybe_grow_stack(|| {
99 <OperatorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
100 })?,
101 ))),
102 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
103 ::treesitter_types::runtime::maybe_grow_stack(|| {
104 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
105 })?,
106 ))),
107 "property_declaration" => Ok(Self::PropertyDeclaration(::std::boxed::Box::new(
108 ::treesitter_types::runtime::maybe_grow_stack(|| {
109 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
110 })?,
111 ))),
112 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
113 ::treesitter_types::runtime::maybe_grow_stack(|| {
114 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
115 })?,
116 ))),
117 "struct_declaration" => Ok(Self::StructDeclaration(::std::boxed::Box::new(
118 ::treesitter_types::runtime::maybe_grow_stack(|| {
119 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
120 })?,
121 ))),
122 "using_directive" => Ok(Self::UsingDirective(::std::boxed::Box::new(
123 ::treesitter_types::runtime::maybe_grow_stack(|| {
124 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
125 })?,
126 ))),
127 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
128 }
129 }
130}
131impl ::treesitter_types::Spanned for Declaration<'_> {
132 fn span(&self) -> ::treesitter_types::Span {
133 match self {
134 Self::ClassDeclaration(inner) => inner.span(),
135 Self::ConstructorDeclaration(inner) => inner.span(),
136 Self::ConversionOperatorDeclaration(inner) => inner.span(),
137 Self::DelegateDeclaration(inner) => inner.span(),
138 Self::DestructorDeclaration(inner) => inner.span(),
139 Self::EnumDeclaration(inner) => inner.span(),
140 Self::EventDeclaration(inner) => inner.span(),
141 Self::EventFieldDeclaration(inner) => inner.span(),
142 Self::FieldDeclaration(inner) => inner.span(),
143 Self::IndexerDeclaration(inner) => inner.span(),
144 Self::InterfaceDeclaration(inner) => inner.span(),
145 Self::MethodDeclaration(inner) => inner.span(),
146 Self::NamespaceDeclaration(inner) => inner.span(),
147 Self::OperatorDeclaration(inner) => inner.span(),
148 Self::PreprocIf(inner) => inner.span(),
149 Self::PropertyDeclaration(inner) => inner.span(),
150 Self::RecordDeclaration(inner) => inner.span(),
151 Self::StructDeclaration(inner) => inner.span(),
152 Self::UsingDirective(inner) => inner.span(),
153 }
154 }
155}
156#[derive(Debug, Clone, PartialEq, Eq)]
157pub enum Expression<'tree> {
158 LvalueExpression(::std::boxed::Box<LvalueExpression<'tree>>),
159 NonLvalueExpression(::std::boxed::Box<NonLvalueExpression<'tree>>),
160}
161impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
162 #[allow(clippy::collapsible_else_if)]
163 fn from_node(
164 node: ::treesitter_types::tree_sitter::Node<'tree>,
165 src: &'tree [u8],
166 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
167 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
168 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
169 }) {
170 Ok(Self::LvalueExpression(::std::boxed::Box::new(v)))
171 } else {
172 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
173 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
174 }) {
175 Ok(Self::NonLvalueExpression(::std::boxed::Box::new(v)))
176 } else {
177 Err(::treesitter_types::ParseError::unexpected_kind(
178 node.kind(),
179 node,
180 ))
181 }
182 }
183 }
184}
185impl ::treesitter_types::Spanned for Expression<'_> {
186 fn span(&self) -> ::treesitter_types::Span {
187 match self {
188 Self::LvalueExpression(inner) => inner.span(),
189 Self::NonLvalueExpression(inner) => inner.span(),
190 }
191 }
192}
193#[derive(Debug, Clone, PartialEq, Eq)]
194pub enum Literal<'tree> {
195 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
196 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
197 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
198 NullLiteral(::std::boxed::Box<NullLiteral<'tree>>),
199 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
200 RealLiteral(::std::boxed::Box<RealLiteral<'tree>>),
201 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
202 VerbatimStringLiteral(::std::boxed::Box<VerbatimStringLiteral<'tree>>),
203}
204impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
205 #[allow(clippy::collapsible_else_if)]
206 fn from_node(
207 node: ::treesitter_types::tree_sitter::Node<'tree>,
208 src: &'tree [u8],
209 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
210 match node.kind() {
211 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
212 ::treesitter_types::runtime::maybe_grow_stack(|| {
213 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
214 })?,
215 ))),
216 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
217 ::treesitter_types::runtime::maybe_grow_stack(|| {
218 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
219 })?,
220 ))),
221 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
222 ::treesitter_types::runtime::maybe_grow_stack(|| {
223 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
224 })?,
225 ))),
226 "null_literal" => Ok(Self::NullLiteral(::std::boxed::Box::new(
227 ::treesitter_types::runtime::maybe_grow_stack(|| {
228 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
229 })?,
230 ))),
231 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
232 ::treesitter_types::runtime::maybe_grow_stack(|| {
233 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
234 })?,
235 ))),
236 "real_literal" => Ok(Self::RealLiteral(::std::boxed::Box::new(
237 ::treesitter_types::runtime::maybe_grow_stack(|| {
238 <RealLiteral as ::treesitter_types::FromNode>::from_node(node, src)
239 })?,
240 ))),
241 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
242 ::treesitter_types::runtime::maybe_grow_stack(|| {
243 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
244 })?,
245 ))),
246 "verbatim_string_literal" => Ok(Self::VerbatimStringLiteral(::std::boxed::Box::new(
247 ::treesitter_types::runtime::maybe_grow_stack(|| {
248 <VerbatimStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
249 })?,
250 ))),
251 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
252 }
253 }
254}
255impl ::treesitter_types::Spanned for Literal<'_> {
256 fn span(&self) -> ::treesitter_types::Span {
257 match self {
258 Self::BooleanLiteral(inner) => inner.span(),
259 Self::CharacterLiteral(inner) => inner.span(),
260 Self::IntegerLiteral(inner) => inner.span(),
261 Self::NullLiteral(inner) => inner.span(),
262 Self::RawStringLiteral(inner) => inner.span(),
263 Self::RealLiteral(inner) => inner.span(),
264 Self::StringLiteral(inner) => inner.span(),
265 Self::VerbatimStringLiteral(inner) => inner.span(),
266 }
267 }
268}
269#[derive(Debug, Clone, PartialEq, Eq)]
270pub enum LvalueExpression<'tree> {
271 ElementAccessExpression(::std::boxed::Box<ElementAccessExpression<'tree>>),
272 ElementBindingExpression(::std::boxed::Box<ElementBindingExpression<'tree>>),
273 GenericName(::std::boxed::Box<GenericName<'tree>>),
274 Identifier(::std::boxed::Box<Identifier<'tree>>),
275 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
276 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
277 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
278 This(::treesitter_types::Span),
279 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
280}
281impl<'tree> ::treesitter_types::FromNode<'tree> for LvalueExpression<'tree> {
282 #[allow(clippy::collapsible_else_if)]
283 fn from_node(
284 node: ::treesitter_types::tree_sitter::Node<'tree>,
285 src: &'tree [u8],
286 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
287 match node.kind() {
288 "element_access_expression" => Ok(Self::ElementAccessExpression(
289 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
290 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
291 })?),
292 )),
293 "element_binding_expression" => Ok(Self::ElementBindingExpression(
294 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
295 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
296 })?),
297 )),
298 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
299 ::treesitter_types::runtime::maybe_grow_stack(|| {
300 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
301 })?,
302 ))),
303 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
304 ::treesitter_types::runtime::maybe_grow_stack(|| {
305 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
306 })?,
307 ))),
308 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
309 ::treesitter_types::runtime::maybe_grow_stack(|| {
310 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
311 })?,
312 ))),
313 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
314 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
315 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
316 })?),
317 )),
318 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
319 ::treesitter_types::runtime::maybe_grow_stack(|| {
320 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
321 })?,
322 ))),
323 "this" => Ok(Self::This(::treesitter_types::Span::from(node))),
324 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
325 ::treesitter_types::runtime::maybe_grow_stack(|| {
326 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
327 })?,
328 ))),
329 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
330 }
331 }
332}
333impl ::treesitter_types::Spanned for LvalueExpression<'_> {
334 fn span(&self) -> ::treesitter_types::Span {
335 match self {
336 Self::ElementAccessExpression(inner) => inner.span(),
337 Self::ElementBindingExpression(inner) => inner.span(),
338 Self::GenericName(inner) => inner.span(),
339 Self::Identifier(inner) => inner.span(),
340 Self::MemberAccessExpression(inner) => inner.span(),
341 Self::ParenthesizedExpression(inner) => inner.span(),
342 Self::PrefixUnaryExpression(inner) => inner.span(),
343 Self::This(span) => *span,
344 Self::TupleExpression(inner) => inner.span(),
345 }
346 }
347}
348#[derive(Debug, Clone, PartialEq, Eq)]
349pub enum NonLvalueExpression<'tree> {
350 AnonymousMethodExpression(::std::boxed::Box<AnonymousMethodExpression<'tree>>),
351 AnonymousObjectCreationExpression(::std::boxed::Box<AnonymousObjectCreationExpression<'tree>>),
352 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
353 AsExpression(::std::boxed::Box<AsExpression<'tree>>),
354 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
355 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
356 Base(::treesitter_types::Span),
357 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
358 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
359 CheckedExpression(::std::boxed::Box<CheckedExpression<'tree>>),
360 ConditionalAccessExpression(::std::boxed::Box<ConditionalAccessExpression<'tree>>),
361 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
362 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
363 ImplicitArrayCreationExpression(::std::boxed::Box<ImplicitArrayCreationExpression<'tree>>),
364 ImplicitObjectCreationExpression(::std::boxed::Box<ImplicitObjectCreationExpression<'tree>>),
365 ImplicitStackallocExpression(::std::boxed::Box<ImplicitStackallocExpression<'tree>>),
366 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
367 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
368 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
369 IsExpression(::std::boxed::Box<IsExpression<'tree>>),
370 IsPatternExpression(::std::boxed::Box<IsPatternExpression<'tree>>),
371 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
372 Literal(::std::boxed::Box<Literal<'tree>>),
373 MakerefExpression(::std::boxed::Box<MakerefExpression<'tree>>),
374 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
375 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
376 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
377 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
378 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
379 QueryExpression(::std::boxed::Box<QueryExpression<'tree>>),
380 RangeExpression(::std::boxed::Box<RangeExpression<'tree>>),
381 RefExpression(::std::boxed::Box<RefExpression<'tree>>),
382 ReftypeExpression(::std::boxed::Box<ReftypeExpression<'tree>>),
383 RefvalueExpression(::std::boxed::Box<RefvalueExpression<'tree>>),
384 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
385 StackallocExpression(::std::boxed::Box<StackallocExpression<'tree>>),
386 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
387 ThrowExpression(::std::boxed::Box<ThrowExpression<'tree>>),
388 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
389 WithExpression(::std::boxed::Box<WithExpression<'tree>>),
390}
391impl<'tree> ::treesitter_types::FromNode<'tree> for NonLvalueExpression<'tree> {
392 #[allow(clippy::collapsible_else_if)]
393 fn from_node(
394 node: ::treesitter_types::tree_sitter::Node<'tree>,
395 src: &'tree [u8],
396 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
397 match node.kind() {
398 "anonymous_method_expression" => Ok(Self::AnonymousMethodExpression(
399 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
400 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(
401 node, src,
402 )
403 })?),
404 )),
405 "anonymous_object_creation_expression" => Ok(Self::AnonymousObjectCreationExpression(
406 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
407 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
408 node, src,
409 )
410 })?),
411 )),
412 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
413 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
414 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
415 })?),
416 )),
417 "as_expression" => Ok(Self::AsExpression(::std::boxed::Box::new(
418 ::treesitter_types::runtime::maybe_grow_stack(|| {
419 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
420 })?,
421 ))),
422 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
423 ::treesitter_types::runtime::maybe_grow_stack(|| {
424 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
425 })?,
426 ))),
427 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
428 ::treesitter_types::runtime::maybe_grow_stack(|| {
429 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
430 })?,
431 ))),
432 "base" => Ok(Self::Base(::treesitter_types::Span::from(node))),
433 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
434 ::treesitter_types::runtime::maybe_grow_stack(|| {
435 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
436 })?,
437 ))),
438 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
439 ::treesitter_types::runtime::maybe_grow_stack(|| {
440 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
441 })?,
442 ))),
443 "checked_expression" => Ok(Self::CheckedExpression(::std::boxed::Box::new(
444 ::treesitter_types::runtime::maybe_grow_stack(|| {
445 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)
446 })?,
447 ))),
448 "conditional_access_expression" => Ok(Self::ConditionalAccessExpression(
449 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
450 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
451 node, src,
452 )
453 })?),
454 )),
455 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
456 ::treesitter_types::runtime::maybe_grow_stack(|| {
457 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
458 })?,
459 ))),
460 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
461 ::treesitter_types::runtime::maybe_grow_stack(|| {
462 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
463 })?,
464 ))),
465 "implicit_array_creation_expression" => Ok(Self::ImplicitArrayCreationExpression(
466 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
467 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
468 node, src,
469 )
470 })?),
471 )),
472 "implicit_object_creation_expression" => Ok(Self::ImplicitObjectCreationExpression(
473 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
474 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
475 node, src,
476 )
477 })?),
478 )),
479 "implicit_stackalloc_expression" => Ok(Self::ImplicitStackallocExpression(
480 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
481 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(
482 node, src,
483 )
484 })?),
485 )),
486 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
487 ::treesitter_types::runtime::maybe_grow_stack(|| {
488 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
489 })?,
490 ))),
491 "interpolated_string_expression" => Ok(Self::InterpolatedStringExpression(
492 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
493 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
494 node, src,
495 )
496 })?),
497 )),
498 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
499 ::treesitter_types::runtime::maybe_grow_stack(|| {
500 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
501 })?,
502 ))),
503 "is_expression" => Ok(Self::IsExpression(::std::boxed::Box::new(
504 ::treesitter_types::runtime::maybe_grow_stack(|| {
505 <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)
506 })?,
507 ))),
508 "is_pattern_expression" => Ok(Self::IsPatternExpression(::std::boxed::Box::new(
509 ::treesitter_types::runtime::maybe_grow_stack(|| {
510 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)
511 })?,
512 ))),
513 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
514 ::treesitter_types::runtime::maybe_grow_stack(|| {
515 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
516 })?,
517 ))),
518 "makeref_expression" => Ok(Self::MakerefExpression(::std::boxed::Box::new(
519 ::treesitter_types::runtime::maybe_grow_stack(|| {
520 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)
521 })?,
522 ))),
523 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
524 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
525 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
526 })?),
527 )),
528 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
529 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
530 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
531 })?),
532 )),
533 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
534 ::treesitter_types::runtime::maybe_grow_stack(|| {
535 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
536 })?,
537 ))),
538 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
539 ::treesitter_types::runtime::maybe_grow_stack(|| {
540 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
541 })?,
542 ))),
543 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
544 ::treesitter_types::runtime::maybe_grow_stack(|| {
545 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
546 })?,
547 ))),
548 "query_expression" => Ok(Self::QueryExpression(::std::boxed::Box::new(
549 ::treesitter_types::runtime::maybe_grow_stack(|| {
550 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)
551 })?,
552 ))),
553 "range_expression" => Ok(Self::RangeExpression(::std::boxed::Box::new(
554 ::treesitter_types::runtime::maybe_grow_stack(|| {
555 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
556 })?,
557 ))),
558 "ref_expression" => Ok(Self::RefExpression(::std::boxed::Box::new(
559 ::treesitter_types::runtime::maybe_grow_stack(|| {
560 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)
561 })?,
562 ))),
563 "reftype_expression" => Ok(Self::ReftypeExpression(::std::boxed::Box::new(
564 ::treesitter_types::runtime::maybe_grow_stack(|| {
565 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)
566 })?,
567 ))),
568 "refvalue_expression" => Ok(Self::RefvalueExpression(::std::boxed::Box::new(
569 ::treesitter_types::runtime::maybe_grow_stack(|| {
570 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
571 })?,
572 ))),
573 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
574 ::treesitter_types::runtime::maybe_grow_stack(|| {
575 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
576 })?,
577 ))),
578 "stackalloc_expression" => Ok(Self::StackallocExpression(::std::boxed::Box::new(
579 ::treesitter_types::runtime::maybe_grow_stack(|| {
580 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
581 })?,
582 ))),
583 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
584 ::treesitter_types::runtime::maybe_grow_stack(|| {
585 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
586 })?,
587 ))),
588 "throw_expression" => Ok(Self::ThrowExpression(::std::boxed::Box::new(
589 ::treesitter_types::runtime::maybe_grow_stack(|| {
590 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
591 })?,
592 ))),
593 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
594 ::treesitter_types::runtime::maybe_grow_stack(|| {
595 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
596 })?,
597 ))),
598 "with_expression" => Ok(Self::WithExpression(::std::boxed::Box::new(
599 ::treesitter_types::runtime::maybe_grow_stack(|| {
600 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)
601 })?,
602 ))),
603 _other => {
604 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
605 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
606 }) {
607 Ok(Self::Literal(::std::boxed::Box::new(v)))
608 } else {
609 Err(::treesitter_types::ParseError::unexpected_kind(
610 _other, node,
611 ))
612 }
613 }
614 }
615 }
616}
617impl ::treesitter_types::Spanned for NonLvalueExpression<'_> {
618 fn span(&self) -> ::treesitter_types::Span {
619 match self {
620 Self::AnonymousMethodExpression(inner) => inner.span(),
621 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
622 Self::ArrayCreationExpression(inner) => inner.span(),
623 Self::AsExpression(inner) => inner.span(),
624 Self::AssignmentExpression(inner) => inner.span(),
625 Self::AwaitExpression(inner) => inner.span(),
626 Self::Base(span) => *span,
627 Self::BinaryExpression(inner) => inner.span(),
628 Self::CastExpression(inner) => inner.span(),
629 Self::CheckedExpression(inner) => inner.span(),
630 Self::ConditionalAccessExpression(inner) => inner.span(),
631 Self::ConditionalExpression(inner) => inner.span(),
632 Self::DefaultExpression(inner) => inner.span(),
633 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
634 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
635 Self::ImplicitStackallocExpression(inner) => inner.span(),
636 Self::InitializerExpression(inner) => inner.span(),
637 Self::InterpolatedStringExpression(inner) => inner.span(),
638 Self::InvocationExpression(inner) => inner.span(),
639 Self::IsExpression(inner) => inner.span(),
640 Self::IsPatternExpression(inner) => inner.span(),
641 Self::LambdaExpression(inner) => inner.span(),
642 Self::Literal(inner) => inner.span(),
643 Self::MakerefExpression(inner) => inner.span(),
644 Self::ObjectCreationExpression(inner) => inner.span(),
645 Self::ParenthesizedExpression(inner) => inner.span(),
646 Self::PostfixUnaryExpression(inner) => inner.span(),
647 Self::PrefixUnaryExpression(inner) => inner.span(),
648 Self::PreprocIf(inner) => inner.span(),
649 Self::QueryExpression(inner) => inner.span(),
650 Self::RangeExpression(inner) => inner.span(),
651 Self::RefExpression(inner) => inner.span(),
652 Self::ReftypeExpression(inner) => inner.span(),
653 Self::RefvalueExpression(inner) => inner.span(),
654 Self::SizeofExpression(inner) => inner.span(),
655 Self::StackallocExpression(inner) => inner.span(),
656 Self::SwitchExpression(inner) => inner.span(),
657 Self::ThrowExpression(inner) => inner.span(),
658 Self::TypeofExpression(inner) => inner.span(),
659 Self::WithExpression(inner) => inner.span(),
660 }
661 }
662}
663#[derive(Debug, Clone, PartialEq, Eq)]
664pub enum Pattern<'tree> {
665 AndPattern(::std::boxed::Box<AndPattern<'tree>>),
666 ConstantPattern(::std::boxed::Box<ConstantPattern<'tree>>),
667 DeclarationPattern(::std::boxed::Box<DeclarationPattern<'tree>>),
668 Discard(::std::boxed::Box<Discard<'tree>>),
669 ListPattern(::std::boxed::Box<ListPattern<'tree>>),
670 NegatedPattern(::std::boxed::Box<NegatedPattern<'tree>>),
671 OrPattern(::std::boxed::Box<OrPattern<'tree>>),
672 ParenthesizedPattern(::std::boxed::Box<ParenthesizedPattern<'tree>>),
673 RecursivePattern(::std::boxed::Box<RecursivePattern<'tree>>),
674 RelationalPattern(::std::boxed::Box<RelationalPattern<'tree>>),
675 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
676 VarPattern(::std::boxed::Box<VarPattern<'tree>>),
677}
678impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
679 #[allow(clippy::collapsible_else_if)]
680 fn from_node(
681 node: ::treesitter_types::tree_sitter::Node<'tree>,
682 src: &'tree [u8],
683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
684 match node.kind() {
685 "and_pattern" => Ok(Self::AndPattern(::std::boxed::Box::new(
686 ::treesitter_types::runtime::maybe_grow_stack(|| {
687 <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)
688 })?,
689 ))),
690 "constant_pattern" => Ok(Self::ConstantPattern(::std::boxed::Box::new(
691 ::treesitter_types::runtime::maybe_grow_stack(|| {
692 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)
693 })?,
694 ))),
695 "declaration_pattern" => Ok(Self::DeclarationPattern(::std::boxed::Box::new(
696 ::treesitter_types::runtime::maybe_grow_stack(|| {
697 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)
698 })?,
699 ))),
700 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
701 ::treesitter_types::runtime::maybe_grow_stack(|| {
702 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
703 })?,
704 ))),
705 "list_pattern" => Ok(Self::ListPattern(::std::boxed::Box::new(
706 ::treesitter_types::runtime::maybe_grow_stack(|| {
707 <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)
708 })?,
709 ))),
710 "negated_pattern" => Ok(Self::NegatedPattern(::std::boxed::Box::new(
711 ::treesitter_types::runtime::maybe_grow_stack(|| {
712 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)
713 })?,
714 ))),
715 "or_pattern" => Ok(Self::OrPattern(::std::boxed::Box::new(
716 ::treesitter_types::runtime::maybe_grow_stack(|| {
717 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
718 })?,
719 ))),
720 "parenthesized_pattern" => Ok(Self::ParenthesizedPattern(::std::boxed::Box::new(
721 ::treesitter_types::runtime::maybe_grow_stack(|| {
722 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
723 })?,
724 ))),
725 "recursive_pattern" => Ok(Self::RecursivePattern(::std::boxed::Box::new(
726 ::treesitter_types::runtime::maybe_grow_stack(|| {
727 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)
728 })?,
729 ))),
730 "relational_pattern" => Ok(Self::RelationalPattern(::std::boxed::Box::new(
731 ::treesitter_types::runtime::maybe_grow_stack(|| {
732 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)
733 })?,
734 ))),
735 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
736 ::treesitter_types::runtime::maybe_grow_stack(|| {
737 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
738 })?,
739 ))),
740 "var_pattern" => Ok(Self::VarPattern(::std::boxed::Box::new(
741 ::treesitter_types::runtime::maybe_grow_stack(|| {
742 <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)
743 })?,
744 ))),
745 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
746 }
747 }
748}
749impl ::treesitter_types::Spanned for Pattern<'_> {
750 fn span(&self) -> ::treesitter_types::Span {
751 match self {
752 Self::AndPattern(inner) => inner.span(),
753 Self::ConstantPattern(inner) => inner.span(),
754 Self::DeclarationPattern(inner) => inner.span(),
755 Self::Discard(inner) => inner.span(),
756 Self::ListPattern(inner) => inner.span(),
757 Self::NegatedPattern(inner) => inner.span(),
758 Self::OrPattern(inner) => inner.span(),
759 Self::ParenthesizedPattern(inner) => inner.span(),
760 Self::RecursivePattern(inner) => inner.span(),
761 Self::RelationalPattern(inner) => inner.span(),
762 Self::TypePattern(inner) => inner.span(),
763 Self::VarPattern(inner) => inner.span(),
764 }
765 }
766}
767#[derive(Debug, Clone, PartialEq, Eq)]
768pub enum Statement<'tree> {
769 Block(::std::boxed::Box<Block<'tree>>),
770 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
771 CheckedStatement(::std::boxed::Box<CheckedStatement<'tree>>),
772 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
773 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
774 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
775 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
776 FixedStatement(::std::boxed::Box<FixedStatement<'tree>>),
777 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
778 ForeachStatement(::std::boxed::Box<ForeachStatement<'tree>>),
779 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
780 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
781 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
782 LocalDeclarationStatement(::std::boxed::Box<LocalDeclarationStatement<'tree>>),
783 LocalFunctionStatement(::std::boxed::Box<LocalFunctionStatement<'tree>>),
784 LockStatement(::std::boxed::Box<LockStatement<'tree>>),
785 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
786 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
787 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
788 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
789 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
790 UnsafeStatement(::std::boxed::Box<UnsafeStatement<'tree>>),
791 UsingStatement(::std::boxed::Box<UsingStatement<'tree>>),
792 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
793 YieldStatement(::std::boxed::Box<YieldStatement<'tree>>),
794}
795impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
796 #[allow(clippy::collapsible_else_if)]
797 fn from_node(
798 node: ::treesitter_types::tree_sitter::Node<'tree>,
799 src: &'tree [u8],
800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
801 match node.kind() {
802 "block" => Ok(Self::Block(::std::boxed::Box::new(
803 ::treesitter_types::runtime::maybe_grow_stack(|| {
804 <Block as ::treesitter_types::FromNode>::from_node(node, src)
805 })?,
806 ))),
807 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
808 ::treesitter_types::runtime::maybe_grow_stack(|| {
809 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
810 })?,
811 ))),
812 "checked_statement" => Ok(Self::CheckedStatement(::std::boxed::Box::new(
813 ::treesitter_types::runtime::maybe_grow_stack(|| {
814 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)
815 })?,
816 ))),
817 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
818 ::treesitter_types::runtime::maybe_grow_stack(|| {
819 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
820 })?,
821 ))),
822 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
823 ::treesitter_types::runtime::maybe_grow_stack(|| {
824 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
825 })?,
826 ))),
827 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
828 ::treesitter_types::runtime::maybe_grow_stack(|| {
829 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
830 })?,
831 ))),
832 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
833 ::treesitter_types::runtime::maybe_grow_stack(|| {
834 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
835 })?,
836 ))),
837 "fixed_statement" => Ok(Self::FixedStatement(::std::boxed::Box::new(
838 ::treesitter_types::runtime::maybe_grow_stack(|| {
839 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)
840 })?,
841 ))),
842 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
843 ::treesitter_types::runtime::maybe_grow_stack(|| {
844 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
845 })?,
846 ))),
847 "foreach_statement" => Ok(Self::ForeachStatement(::std::boxed::Box::new(
848 ::treesitter_types::runtime::maybe_grow_stack(|| {
849 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
850 })?,
851 ))),
852 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
853 ::treesitter_types::runtime::maybe_grow_stack(|| {
854 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
855 })?,
856 ))),
857 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
858 ::treesitter_types::runtime::maybe_grow_stack(|| {
859 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
860 })?,
861 ))),
862 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
863 ::treesitter_types::runtime::maybe_grow_stack(|| {
864 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
865 })?,
866 ))),
867 "local_declaration_statement" => Ok(Self::LocalDeclarationStatement(
868 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
869 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(
870 node, src,
871 )
872 })?),
873 )),
874 "local_function_statement" => Ok(Self::LocalFunctionStatement(::std::boxed::Box::new(
875 ::treesitter_types::runtime::maybe_grow_stack(|| {
876 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)
877 })?,
878 ))),
879 "lock_statement" => Ok(Self::LockStatement(::std::boxed::Box::new(
880 ::treesitter_types::runtime::maybe_grow_stack(|| {
881 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)
882 })?,
883 ))),
884 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
885 ::treesitter_types::runtime::maybe_grow_stack(|| {
886 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
887 })?,
888 ))),
889 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
890 ::treesitter_types::runtime::maybe_grow_stack(|| {
891 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
892 })?,
893 ))),
894 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
895 ::treesitter_types::runtime::maybe_grow_stack(|| {
896 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
897 })?,
898 ))),
899 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
900 ::treesitter_types::runtime::maybe_grow_stack(|| {
901 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
902 })?,
903 ))),
904 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
905 ::treesitter_types::runtime::maybe_grow_stack(|| {
906 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
907 })?,
908 ))),
909 "unsafe_statement" => Ok(Self::UnsafeStatement(::std::boxed::Box::new(
910 ::treesitter_types::runtime::maybe_grow_stack(|| {
911 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)
912 })?,
913 ))),
914 "using_statement" => Ok(Self::UsingStatement(::std::boxed::Box::new(
915 ::treesitter_types::runtime::maybe_grow_stack(|| {
916 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)
917 })?,
918 ))),
919 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
920 ::treesitter_types::runtime::maybe_grow_stack(|| {
921 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
922 })?,
923 ))),
924 "yield_statement" => Ok(Self::YieldStatement(::std::boxed::Box::new(
925 ::treesitter_types::runtime::maybe_grow_stack(|| {
926 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
927 })?,
928 ))),
929 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
930 }
931 }
932}
933impl ::treesitter_types::Spanned for Statement<'_> {
934 fn span(&self) -> ::treesitter_types::Span {
935 match self {
936 Self::Block(inner) => inner.span(),
937 Self::BreakStatement(inner) => inner.span(),
938 Self::CheckedStatement(inner) => inner.span(),
939 Self::ContinueStatement(inner) => inner.span(),
940 Self::DoStatement(inner) => inner.span(),
941 Self::EmptyStatement(inner) => inner.span(),
942 Self::ExpressionStatement(inner) => inner.span(),
943 Self::FixedStatement(inner) => inner.span(),
944 Self::ForStatement(inner) => inner.span(),
945 Self::ForeachStatement(inner) => inner.span(),
946 Self::GotoStatement(inner) => inner.span(),
947 Self::IfStatement(inner) => inner.span(),
948 Self::LabeledStatement(inner) => inner.span(),
949 Self::LocalDeclarationStatement(inner) => inner.span(),
950 Self::LocalFunctionStatement(inner) => inner.span(),
951 Self::LockStatement(inner) => inner.span(),
952 Self::PreprocIf(inner) => inner.span(),
953 Self::ReturnStatement(inner) => inner.span(),
954 Self::SwitchStatement(inner) => inner.span(),
955 Self::ThrowStatement(inner) => inner.span(),
956 Self::TryStatement(inner) => inner.span(),
957 Self::UnsafeStatement(inner) => inner.span(),
958 Self::UsingStatement(inner) => inner.span(),
959 Self::WhileStatement(inner) => inner.span(),
960 Self::YieldStatement(inner) => inner.span(),
961 }
962 }
963}
964#[derive(Debug, Clone, PartialEq, Eq)]
965pub enum Type<'tree> {
966 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
967 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
968 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
969 GenericName(::std::boxed::Box<GenericName<'tree>>),
970 Identifier(::std::boxed::Box<Identifier<'tree>>),
971 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
972 NullableType(::std::boxed::Box<NullableType<'tree>>),
973 PointerType(::std::boxed::Box<PointerType<'tree>>),
974 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
975 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
976 RefType(::std::boxed::Box<RefType<'tree>>),
977 ScopedType(::std::boxed::Box<ScopedType<'tree>>),
978 TupleType(::std::boxed::Box<TupleType<'tree>>),
979}
980impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
981 #[allow(clippy::collapsible_else_if)]
982 fn from_node(
983 node: ::treesitter_types::tree_sitter::Node<'tree>,
984 src: &'tree [u8],
985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
986 match node.kind() {
987 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
988 ::treesitter_types::runtime::maybe_grow_stack(|| {
989 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
990 })?,
991 ))),
992 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
993 ::treesitter_types::runtime::maybe_grow_stack(|| {
994 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
995 })?,
996 ))),
997 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
998 ::treesitter_types::runtime::maybe_grow_stack(|| {
999 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
1000 })?,
1001 ))),
1002 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
1003 ::treesitter_types::runtime::maybe_grow_stack(|| {
1004 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
1005 })?,
1006 ))),
1007 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
1008 ::treesitter_types::runtime::maybe_grow_stack(|| {
1009 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
1010 })?,
1011 ))),
1012 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
1013 ::treesitter_types::runtime::maybe_grow_stack(|| {
1014 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
1015 })?,
1016 ))),
1017 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
1018 ::treesitter_types::runtime::maybe_grow_stack(|| {
1019 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
1020 })?,
1021 ))),
1022 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
1023 ::treesitter_types::runtime::maybe_grow_stack(|| {
1024 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
1025 })?,
1026 ))),
1027 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
1028 ::treesitter_types::runtime::maybe_grow_stack(|| {
1029 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
1030 })?,
1031 ))),
1032 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
1033 ::treesitter_types::runtime::maybe_grow_stack(|| {
1034 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
1035 })?,
1036 ))),
1037 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
1038 ::treesitter_types::runtime::maybe_grow_stack(|| {
1039 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
1040 })?,
1041 ))),
1042 "scoped_type" => Ok(Self::ScopedType(::std::boxed::Box::new(
1043 ::treesitter_types::runtime::maybe_grow_stack(|| {
1044 <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)
1045 })?,
1046 ))),
1047 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
1048 ::treesitter_types::runtime::maybe_grow_stack(|| {
1049 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
1050 })?,
1051 ))),
1052 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1053 }
1054 }
1055}
1056impl ::treesitter_types::Spanned for Type<'_> {
1057 fn span(&self) -> ::treesitter_types::Span {
1058 match self {
1059 Self::AliasQualifiedName(inner) => inner.span(),
1060 Self::ArrayType(inner) => inner.span(),
1061 Self::FunctionPointerType(inner) => inner.span(),
1062 Self::GenericName(inner) => inner.span(),
1063 Self::Identifier(inner) => inner.span(),
1064 Self::ImplicitType(inner) => inner.span(),
1065 Self::NullableType(inner) => inner.span(),
1066 Self::PointerType(inner) => inner.span(),
1067 Self::PredefinedType(inner) => inner.span(),
1068 Self::QualifiedName(inner) => inner.span(),
1069 Self::RefType(inner) => inner.span(),
1070 Self::ScopedType(inner) => inner.span(),
1071 Self::TupleType(inner) => inner.span(),
1072 }
1073 }
1074}
1075#[derive(Debug, Clone, PartialEq, Eq)]
1076pub enum TypeDeclaration<'tree> {
1077 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
1078 DelegateDeclaration(::std::boxed::Box<DelegateDeclaration<'tree>>),
1079 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
1080 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
1081 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
1082 StructDeclaration(::std::boxed::Box<StructDeclaration<'tree>>),
1083}
1084impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclaration<'tree> {
1085 #[allow(clippy::collapsible_else_if)]
1086 fn from_node(
1087 node: ::treesitter_types::tree_sitter::Node<'tree>,
1088 src: &'tree [u8],
1089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1090 match node.kind() {
1091 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
1092 ::treesitter_types::runtime::maybe_grow_stack(|| {
1093 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1094 })?,
1095 ))),
1096 "delegate_declaration" => Ok(Self::DelegateDeclaration(::std::boxed::Box::new(
1097 ::treesitter_types::runtime::maybe_grow_stack(|| {
1098 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1099 })?,
1100 ))),
1101 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
1102 ::treesitter_types::runtime::maybe_grow_stack(|| {
1103 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1104 })?,
1105 ))),
1106 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
1107 ::treesitter_types::runtime::maybe_grow_stack(|| {
1108 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1109 })?,
1110 ))),
1111 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
1112 ::treesitter_types::runtime::maybe_grow_stack(|| {
1113 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1114 })?,
1115 ))),
1116 "struct_declaration" => Ok(Self::StructDeclaration(::std::boxed::Box::new(
1117 ::treesitter_types::runtime::maybe_grow_stack(|| {
1118 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1119 })?,
1120 ))),
1121 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1122 }
1123 }
1124}
1125impl ::treesitter_types::Spanned for TypeDeclaration<'_> {
1126 fn span(&self) -> ::treesitter_types::Span {
1127 match self {
1128 Self::ClassDeclaration(inner) => inner.span(),
1129 Self::DelegateDeclaration(inner) => inner.span(),
1130 Self::EnumDeclaration(inner) => inner.span(),
1131 Self::InterfaceDeclaration(inner) => inner.span(),
1132 Self::RecordDeclaration(inner) => inner.span(),
1133 Self::StructDeclaration(inner) => inner.span(),
1134 }
1135 }
1136}
1137#[derive(Debug, Clone, PartialEq, Eq)]
1138pub struct AccessorDeclaration<'tree> {
1139 pub span: ::treesitter_types::Span,
1140 pub body: ::core::option::Option<AccessorDeclarationBody<'tree>>,
1141 pub name: AccessorDeclarationName<'tree>,
1142 pub children: ::std::vec::Vec<AccessorDeclarationChildren<'tree>>,
1143}
1144impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclaration<'tree> {
1145 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1146 fn from_node(
1147 node: ::treesitter_types::tree_sitter::Node<'tree>,
1148 src: &'tree [u8],
1149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1150 debug_assert_eq!(node.kind(), "accessor_declaration");
1151 Ok(Self {
1152 span: ::treesitter_types::Span::from(node),
1153 body: match node.child_by_field_name("body") {
1154 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1155 <AccessorDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
1156 })?),
1157 None => None,
1158 },
1159 name: {
1160 let child = node
1161 .child_by_field_name("name")
1162 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1163 ::treesitter_types::runtime::maybe_grow_stack(|| {
1164 <AccessorDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)
1165 })?
1166 },
1167 children: {
1168 #[allow(clippy::suspicious_else_formatting)]
1169 let non_field_children = {
1170 let mut cursor = node.walk();
1171 let mut result = ::std::vec::Vec::new();
1172 if cursor.goto_first_child() {
1173 loop {
1174 if cursor.field_name().is_none()
1175 && cursor.node().is_named()
1176 && !cursor.node().is_extra()
1177 {
1178 result.push(cursor.node());
1179 }
1180 if !cursor.goto_next_sibling() {
1181 break;
1182 }
1183 }
1184 }
1185 result
1186 };
1187 let mut items = ::std::vec::Vec::new();
1188 for child in non_field_children {
1189 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1190 <AccessorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
1191 child, src,
1192 )
1193 })?);
1194 }
1195 items
1196 },
1197 })
1198 }
1199}
1200impl ::treesitter_types::Spanned for AccessorDeclaration<'_> {
1201 fn span(&self) -> ::treesitter_types::Span {
1202 self.span
1203 }
1204}
1205#[derive(Debug, Clone, PartialEq, Eq)]
1206pub struct AccessorList<'tree> {
1207 pub span: ::treesitter_types::Span,
1208 pub children: ::std::vec::Vec<AccessorDeclaration<'tree>>,
1209}
1210impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorList<'tree> {
1211 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1212 fn from_node(
1213 node: ::treesitter_types::tree_sitter::Node<'tree>,
1214 src: &'tree [u8],
1215 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1216 debug_assert_eq!(node.kind(), "accessor_list");
1217 Ok(Self {
1218 span: ::treesitter_types::Span::from(node),
1219 children: {
1220 #[allow(clippy::suspicious_else_formatting)]
1221 let non_field_children = {
1222 let mut cursor = node.walk();
1223 let mut result = ::std::vec::Vec::new();
1224 if cursor.goto_first_child() {
1225 loop {
1226 if cursor.field_name().is_none()
1227 && cursor.node().is_named()
1228 && !cursor.node().is_extra()
1229 {
1230 result.push(cursor.node());
1231 }
1232 if !cursor.goto_next_sibling() {
1233 break;
1234 }
1235 }
1236 }
1237 result
1238 };
1239 let mut items = ::std::vec::Vec::new();
1240 for child in non_field_children {
1241 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1242 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(child, src)
1243 })?);
1244 }
1245 items
1246 },
1247 })
1248 }
1249}
1250impl ::treesitter_types::Spanned for AccessorList<'_> {
1251 fn span(&self) -> ::treesitter_types::Span {
1252 self.span
1253 }
1254}
1255#[derive(Debug, Clone, PartialEq, Eq)]
1256pub struct AliasQualifiedName<'tree> {
1257 pub span: ::treesitter_types::Span,
1258 pub alias: Identifier<'tree>,
1259 pub name: AliasQualifiedNameName<'tree>,
1260}
1261impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedName<'tree> {
1262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1263 fn from_node(
1264 node: ::treesitter_types::tree_sitter::Node<'tree>,
1265 src: &'tree [u8],
1266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1267 debug_assert_eq!(node.kind(), "alias_qualified_name");
1268 Ok(Self {
1269 span: ::treesitter_types::Span::from(node),
1270 alias: {
1271 let child = node
1272 .child_by_field_name("alias")
1273 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
1274 ::treesitter_types::runtime::maybe_grow_stack(|| {
1275 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1276 })?
1277 },
1278 name: {
1279 let child = node
1280 .child_by_field_name("name")
1281 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1282 ::treesitter_types::runtime::maybe_grow_stack(|| {
1283 <AliasQualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)
1284 })?
1285 },
1286 })
1287 }
1288}
1289impl ::treesitter_types::Spanned for AliasQualifiedName<'_> {
1290 fn span(&self) -> ::treesitter_types::Span {
1291 self.span
1292 }
1293}
1294#[derive(Debug, Clone, PartialEq, Eq)]
1295pub struct AndPattern<'tree> {
1296 pub span: ::treesitter_types::Span,
1297 pub left: Pattern<'tree>,
1298 pub operator: AndPatternOperator,
1299 pub right: Pattern<'tree>,
1300}
1301impl<'tree> ::treesitter_types::FromNode<'tree> for AndPattern<'tree> {
1302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1303 fn from_node(
1304 node: ::treesitter_types::tree_sitter::Node<'tree>,
1305 src: &'tree [u8],
1306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1307 debug_assert_eq!(node.kind(), "and_pattern");
1308 Ok(Self {
1309 span: ::treesitter_types::Span::from(node),
1310 left: {
1311 let child = node
1312 .child_by_field_name("left")
1313 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1314 ::treesitter_types::runtime::maybe_grow_stack(|| {
1315 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
1316 })?
1317 },
1318 operator: {
1319 let child = node.child_by_field_name("operator").ok_or_else(|| {
1320 ::treesitter_types::ParseError::missing_field("operator", node)
1321 })?;
1322 ::treesitter_types::runtime::maybe_grow_stack(|| {
1323 <AndPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)
1324 })?
1325 },
1326 right: {
1327 let child = node
1328 .child_by_field_name("right")
1329 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1330 ::treesitter_types::runtime::maybe_grow_stack(|| {
1331 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
1332 })?
1333 },
1334 })
1335 }
1336}
1337impl ::treesitter_types::Spanned for AndPattern<'_> {
1338 fn span(&self) -> ::treesitter_types::Span {
1339 self.span
1340 }
1341}
1342#[derive(Debug, Clone, PartialEq, Eq)]
1343pub struct AnonymousMethodExpression<'tree> {
1344 pub span: ::treesitter_types::Span,
1345 pub parameters: ::core::option::Option<ParameterList<'tree>>,
1346 pub children: ::std::vec::Vec<AnonymousMethodExpressionChildren<'tree>>,
1347}
1348impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpression<'tree> {
1349 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1350 fn from_node(
1351 node: ::treesitter_types::tree_sitter::Node<'tree>,
1352 src: &'tree [u8],
1353 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1354 debug_assert_eq!(node.kind(), "anonymous_method_expression");
1355 Ok(Self {
1356 span: ::treesitter_types::Span::from(node),
1357 parameters: match node.child_by_field_name("parameters") {
1358 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1359 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
1360 })?),
1361 None => None,
1362 },
1363 children: {
1364 #[allow(clippy::suspicious_else_formatting)]
1365 let non_field_children = {
1366 let mut cursor = node.walk();
1367 let mut result = ::std::vec::Vec::new();
1368 if cursor.goto_first_child() {
1369 loop {
1370 if cursor.field_name().is_none()
1371 && cursor.node().is_named()
1372 && !cursor.node().is_extra()
1373 {
1374 result.push(cursor.node());
1375 }
1376 if !cursor.goto_next_sibling() {
1377 break;
1378 }
1379 }
1380 }
1381 result
1382 };
1383 let mut items = ::std::vec::Vec::new();
1384 for child in non_field_children {
1385 items
1386 .push(
1387 ::treesitter_types::runtime::maybe_grow_stack(|| <AnonymousMethodExpressionChildren as ::treesitter_types::FromNode>::from_node(
1388 child,
1389 src,
1390 ))?,
1391 );
1392 }
1393 items
1394 },
1395 })
1396 }
1397}
1398impl ::treesitter_types::Spanned for AnonymousMethodExpression<'_> {
1399 fn span(&self) -> ::treesitter_types::Span {
1400 self.span
1401 }
1402}
1403#[derive(Debug, Clone, PartialEq, Eq)]
1404pub struct AnonymousObjectCreationExpression<'tree> {
1405 pub span: ::treesitter_types::Span,
1406 pub children: ::std::vec::Vec<AnonymousObjectCreationExpressionChildren<'tree>>,
1407}
1408impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousObjectCreationExpression<'tree> {
1409 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1410 fn from_node(
1411 node: ::treesitter_types::tree_sitter::Node<'tree>,
1412 src: &'tree [u8],
1413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1414 debug_assert_eq!(node.kind(), "anonymous_object_creation_expression");
1415 Ok(Self {
1416 span: ::treesitter_types::Span::from(node),
1417 children: {
1418 #[allow(clippy::suspicious_else_formatting)]
1419 let non_field_children = {
1420 let mut cursor = node.walk();
1421 let mut result = ::std::vec::Vec::new();
1422 if cursor.goto_first_child() {
1423 loop {
1424 if cursor.field_name().is_none()
1425 && cursor.node().is_named()
1426 && !cursor.node().is_extra()
1427 {
1428 result.push(cursor.node());
1429 }
1430 if !cursor.goto_next_sibling() {
1431 break;
1432 }
1433 }
1434 }
1435 result
1436 };
1437 let mut items = ::std::vec::Vec::new();
1438 for child in non_field_children {
1439 items
1440 .push(
1441 ::treesitter_types::runtime::maybe_grow_stack(|| <AnonymousObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
1442 child,
1443 src,
1444 ))?,
1445 );
1446 }
1447 items
1448 },
1449 })
1450 }
1451}
1452impl ::treesitter_types::Spanned for AnonymousObjectCreationExpression<'_> {
1453 fn span(&self) -> ::treesitter_types::Span {
1454 self.span
1455 }
1456}
1457#[derive(Debug, Clone, PartialEq, Eq)]
1458pub struct Argument<'tree> {
1459 pub span: ::treesitter_types::Span,
1460 pub name: ::core::option::Option<Identifier<'tree>>,
1461 pub children: ArgumentChildren<'tree>,
1462}
1463impl<'tree> ::treesitter_types::FromNode<'tree> for Argument<'tree> {
1464 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1465 fn from_node(
1466 node: ::treesitter_types::tree_sitter::Node<'tree>,
1467 src: &'tree [u8],
1468 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1469 debug_assert_eq!(node.kind(), "argument");
1470 Ok(Self {
1471 span: ::treesitter_types::Span::from(node),
1472 name: match node.child_by_field_name("name") {
1473 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1474 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1475 })?),
1476 None => None,
1477 },
1478 children: {
1479 #[allow(clippy::suspicious_else_formatting)]
1480 let non_field_children = {
1481 let mut cursor = node.walk();
1482 let mut result = ::std::vec::Vec::new();
1483 if cursor.goto_first_child() {
1484 loop {
1485 if cursor.field_name().is_none()
1486 && cursor.node().is_named()
1487 && !cursor.node().is_extra()
1488 {
1489 result.push(cursor.node());
1490 }
1491 if !cursor.goto_next_sibling() {
1492 break;
1493 }
1494 }
1495 }
1496 result
1497 };
1498 let child = if let Some(&c) = non_field_children.first() {
1499 c
1500 } else {
1501 let mut fallback_cursor = node.walk();
1502 let mut fallback_child = None;
1503 if fallback_cursor.goto_first_child() {
1504 loop {
1505 if fallback_cursor.field_name().is_none()
1506 && !fallback_cursor.node().is_extra()
1507 {
1508 let candidate = fallback_cursor.node();
1509 #[allow(clippy::needless_question_mark)]
1510 if (|| -> ::core::result::Result<
1511 _,
1512 ::treesitter_types::ParseError,
1513 > {
1514 let child = candidate;
1515 Ok(
1516 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1517 child,
1518 src,
1519 ))?,
1520 )
1521 })()
1522 .is_ok()
1523 {
1524 fallback_child = Some(candidate);
1525 break;
1526 }
1527 }
1528 if !fallback_cursor.goto_next_sibling() {
1529 break;
1530 }
1531 }
1532 }
1533 if fallback_child.is_none() {
1534 let mut cursor2 = node.walk();
1535 if cursor2.goto_first_child() {
1536 loop {
1537 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1538 let candidate = cursor2.node();
1539 #[allow(clippy::needless_question_mark)]
1540 if (|| -> ::core::result::Result<
1541 _,
1542 ::treesitter_types::ParseError,
1543 > {
1544 let child = candidate;
1545 Ok(
1546 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1547 child,
1548 src,
1549 ))?,
1550 )
1551 })()
1552 .is_ok()
1553 {
1554 fallback_child = Some(candidate);
1555 break;
1556 }
1557 }
1558 if !cursor2.goto_next_sibling() {
1559 break;
1560 }
1561 }
1562 }
1563 }
1564 fallback_child.ok_or_else(|| {
1565 ::treesitter_types::ParseError::missing_field("children", node)
1566 })?
1567 };
1568 ::treesitter_types::runtime::maybe_grow_stack(|| {
1569 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(child, src)
1570 })?
1571 },
1572 })
1573 }
1574}
1575impl ::treesitter_types::Spanned for Argument<'_> {
1576 fn span(&self) -> ::treesitter_types::Span {
1577 self.span
1578 }
1579}
1580#[derive(Debug, Clone, PartialEq, Eq)]
1581pub struct ArgumentList<'tree> {
1582 pub span: ::treesitter_types::Span,
1583 pub children: ::std::vec::Vec<Argument<'tree>>,
1584}
1585impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1586 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1587 fn from_node(
1588 node: ::treesitter_types::tree_sitter::Node<'tree>,
1589 src: &'tree [u8],
1590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1591 debug_assert_eq!(node.kind(), "argument_list");
1592 Ok(Self {
1593 span: ::treesitter_types::Span::from(node),
1594 children: {
1595 #[allow(clippy::suspicious_else_formatting)]
1596 let non_field_children = {
1597 let mut cursor = node.walk();
1598 let mut result = ::std::vec::Vec::new();
1599 if cursor.goto_first_child() {
1600 loop {
1601 if cursor.field_name().is_none()
1602 && cursor.node().is_named()
1603 && !cursor.node().is_extra()
1604 {
1605 result.push(cursor.node());
1606 }
1607 if !cursor.goto_next_sibling() {
1608 break;
1609 }
1610 }
1611 }
1612 result
1613 };
1614 let mut items = ::std::vec::Vec::new();
1615 for child in non_field_children {
1616 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1617 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
1618 })?);
1619 }
1620 items
1621 },
1622 })
1623 }
1624}
1625impl ::treesitter_types::Spanned for ArgumentList<'_> {
1626 fn span(&self) -> ::treesitter_types::Span {
1627 self.span
1628 }
1629}
1630#[derive(Debug, Clone, PartialEq, Eq)]
1631pub struct ArrayCreationExpression<'tree> {
1632 pub span: ::treesitter_types::Span,
1633 pub r#type: ArrayType<'tree>,
1634 pub children: ::core::option::Option<InitializerExpression<'tree>>,
1635}
1636impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1637 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1638 fn from_node(
1639 node: ::treesitter_types::tree_sitter::Node<'tree>,
1640 src: &'tree [u8],
1641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1642 debug_assert_eq!(node.kind(), "array_creation_expression");
1643 Ok(Self {
1644 span: ::treesitter_types::Span::from(node),
1645 r#type: {
1646 let child = node
1647 .child_by_field_name("type")
1648 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1649 ::treesitter_types::runtime::maybe_grow_stack(|| {
1650 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)
1651 })?
1652 },
1653 children: {
1654 #[allow(clippy::suspicious_else_formatting)]
1655 let non_field_children = {
1656 let mut cursor = node.walk();
1657 let mut result = ::std::vec::Vec::new();
1658 if cursor.goto_first_child() {
1659 loop {
1660 if cursor.field_name().is_none()
1661 && cursor.node().is_named()
1662 && !cursor.node().is_extra()
1663 {
1664 result.push(cursor.node());
1665 }
1666 if !cursor.goto_next_sibling() {
1667 break;
1668 }
1669 }
1670 }
1671 result
1672 };
1673 match non_field_children.first() {
1674 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1675 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
1676 child, src,
1677 )
1678 })?),
1679 None => None,
1680 }
1681 },
1682 })
1683 }
1684}
1685impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1686 fn span(&self) -> ::treesitter_types::Span {
1687 self.span
1688 }
1689}
1690#[derive(Debug, Clone, PartialEq, Eq)]
1691pub struct ArrayRankSpecifier<'tree> {
1692 pub span: ::treesitter_types::Span,
1693 pub children: ::std::vec::Vec<Expression<'tree>>,
1694}
1695impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayRankSpecifier<'tree> {
1696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1697 fn from_node(
1698 node: ::treesitter_types::tree_sitter::Node<'tree>,
1699 src: &'tree [u8],
1700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1701 debug_assert_eq!(node.kind(), "array_rank_specifier");
1702 Ok(Self {
1703 span: ::treesitter_types::Span::from(node),
1704 children: {
1705 #[allow(clippy::suspicious_else_formatting)]
1706 let non_field_children = {
1707 let mut cursor = node.walk();
1708 let mut result = ::std::vec::Vec::new();
1709 if cursor.goto_first_child() {
1710 loop {
1711 if cursor.field_name().is_none()
1712 && cursor.node().is_named()
1713 && !cursor.node().is_extra()
1714 {
1715 result.push(cursor.node());
1716 }
1717 if !cursor.goto_next_sibling() {
1718 break;
1719 }
1720 }
1721 }
1722 result
1723 };
1724 let mut items = ::std::vec::Vec::new();
1725 for child in non_field_children {
1726 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1727 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1728 })?);
1729 }
1730 items
1731 },
1732 })
1733 }
1734}
1735impl ::treesitter_types::Spanned for ArrayRankSpecifier<'_> {
1736 fn span(&self) -> ::treesitter_types::Span {
1737 self.span
1738 }
1739}
1740#[derive(Debug, Clone, PartialEq, Eq)]
1741pub struct ArrayType<'tree> {
1742 pub span: ::treesitter_types::Span,
1743 pub rank: ArrayRankSpecifier<'tree>,
1744 pub r#type: ArrayTypeType<'tree>,
1745}
1746impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1747 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1748 fn from_node(
1749 node: ::treesitter_types::tree_sitter::Node<'tree>,
1750 src: &'tree [u8],
1751 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1752 debug_assert_eq!(node.kind(), "array_type");
1753 Ok(Self {
1754 span: ::treesitter_types::Span::from(node),
1755 rank: {
1756 let child = node
1757 .child_by_field_name("rank")
1758 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("rank", node))?;
1759 ::treesitter_types::runtime::maybe_grow_stack(|| {
1760 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
1761 })?
1762 },
1763 r#type: {
1764 let child = node
1765 .child_by_field_name("type")
1766 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1767 ::treesitter_types::runtime::maybe_grow_stack(|| {
1768 <ArrayTypeType as ::treesitter_types::FromNode>::from_node(child, src)
1769 })?
1770 },
1771 })
1772 }
1773}
1774impl ::treesitter_types::Spanned for ArrayType<'_> {
1775 fn span(&self) -> ::treesitter_types::Span {
1776 self.span
1777 }
1778}
1779#[derive(Debug, Clone, PartialEq, Eq)]
1780pub struct ArrowExpressionClause<'tree> {
1781 pub span: ::treesitter_types::Span,
1782 pub children: Expression<'tree>,
1783}
1784impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowExpressionClause<'tree> {
1785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1786 fn from_node(
1787 node: ::treesitter_types::tree_sitter::Node<'tree>,
1788 src: &'tree [u8],
1789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1790 debug_assert_eq!(node.kind(), "arrow_expression_clause");
1791 Ok(Self {
1792 span: ::treesitter_types::Span::from(node),
1793 children: {
1794 #[allow(clippy::suspicious_else_formatting)]
1795 let non_field_children = {
1796 let mut cursor = node.walk();
1797 let mut result = ::std::vec::Vec::new();
1798 if cursor.goto_first_child() {
1799 loop {
1800 if cursor.field_name().is_none()
1801 && cursor.node().is_named()
1802 && !cursor.node().is_extra()
1803 {
1804 result.push(cursor.node());
1805 }
1806 if !cursor.goto_next_sibling() {
1807 break;
1808 }
1809 }
1810 }
1811 result
1812 };
1813 let child = if let Some(&c) = non_field_children.first() {
1814 c
1815 } else {
1816 let mut fallback_cursor = node.walk();
1817 let mut fallback_child = None;
1818 if fallback_cursor.goto_first_child() {
1819 loop {
1820 if fallback_cursor.field_name().is_none()
1821 && !fallback_cursor.node().is_extra()
1822 {
1823 let candidate = fallback_cursor.node();
1824 #[allow(clippy::needless_question_mark)]
1825 if (|| -> ::core::result::Result<
1826 _,
1827 ::treesitter_types::ParseError,
1828 > {
1829 let child = candidate;
1830 Ok(
1831 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1832 child,
1833 src,
1834 ))?,
1835 )
1836 })()
1837 .is_ok()
1838 {
1839 fallback_child = Some(candidate);
1840 break;
1841 }
1842 }
1843 if !fallback_cursor.goto_next_sibling() {
1844 break;
1845 }
1846 }
1847 }
1848 if fallback_child.is_none() {
1849 let mut cursor2 = node.walk();
1850 if cursor2.goto_first_child() {
1851 loop {
1852 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1853 let candidate = cursor2.node();
1854 #[allow(clippy::needless_question_mark)]
1855 if (|| -> ::core::result::Result<
1856 _,
1857 ::treesitter_types::ParseError,
1858 > {
1859 let child = candidate;
1860 Ok(
1861 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1862 child,
1863 src,
1864 ))?,
1865 )
1866 })()
1867 .is_ok()
1868 {
1869 fallback_child = Some(candidate);
1870 break;
1871 }
1872 }
1873 if !cursor2.goto_next_sibling() {
1874 break;
1875 }
1876 }
1877 }
1878 }
1879 fallback_child.ok_or_else(|| {
1880 ::treesitter_types::ParseError::missing_field("children", node)
1881 })?
1882 };
1883 ::treesitter_types::runtime::maybe_grow_stack(|| {
1884 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1885 })?
1886 },
1887 })
1888 }
1889}
1890impl ::treesitter_types::Spanned for ArrowExpressionClause<'_> {
1891 fn span(&self) -> ::treesitter_types::Span {
1892 self.span
1893 }
1894}
1895#[derive(Debug, Clone, PartialEq, Eq)]
1896pub struct AsExpression<'tree> {
1897 pub span: ::treesitter_types::Span,
1898 pub left: Expression<'tree>,
1899 pub operator: AsExpressionOperator,
1900 pub right: Type<'tree>,
1901}
1902impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpression<'tree> {
1903 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1904 fn from_node(
1905 node: ::treesitter_types::tree_sitter::Node<'tree>,
1906 src: &'tree [u8],
1907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1908 debug_assert_eq!(node.kind(), "as_expression");
1909 Ok(Self {
1910 span: ::treesitter_types::Span::from(node),
1911 left: {
1912 let child = node
1913 .child_by_field_name("left")
1914 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1915 ::treesitter_types::runtime::maybe_grow_stack(|| {
1916 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1917 })?
1918 },
1919 operator: {
1920 let child = node.child_by_field_name("operator").ok_or_else(|| {
1921 ::treesitter_types::ParseError::missing_field("operator", node)
1922 })?;
1923 ::treesitter_types::runtime::maybe_grow_stack(|| {
1924 <AsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
1925 })?
1926 },
1927 right: {
1928 let child = node
1929 .child_by_field_name("right")
1930 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1931 ::treesitter_types::runtime::maybe_grow_stack(|| {
1932 <Type as ::treesitter_types::FromNode>::from_node(child, src)
1933 })?
1934 },
1935 })
1936 }
1937}
1938impl ::treesitter_types::Spanned for AsExpression<'_> {
1939 fn span(&self) -> ::treesitter_types::Span {
1940 self.span
1941 }
1942}
1943#[derive(Debug, Clone, PartialEq, Eq)]
1944pub struct AssignmentExpression<'tree> {
1945 pub span: ::treesitter_types::Span,
1946 pub left: LvalueExpression<'tree>,
1947 pub operator: AssignmentExpressionOperator,
1948 pub right: Expression<'tree>,
1949}
1950impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1951 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1952 fn from_node(
1953 node: ::treesitter_types::tree_sitter::Node<'tree>,
1954 src: &'tree [u8],
1955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1956 debug_assert_eq!(node.kind(), "assignment_expression");
1957 Ok(Self {
1958 span: ::treesitter_types::Span::from(node),
1959 left: {
1960 let child = node
1961 .child_by_field_name("left")
1962 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1963 ::treesitter_types::runtime::maybe_grow_stack(|| {
1964 <LvalueExpression as ::treesitter_types::FromNode>::from_node(child, src)
1965 })?
1966 },
1967 operator: {
1968 let child = node.child_by_field_name("operator").ok_or_else(|| {
1969 ::treesitter_types::ParseError::missing_field("operator", node)
1970 })?;
1971 ::treesitter_types::runtime::maybe_grow_stack(|| {
1972 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1973 child, src,
1974 )
1975 })?
1976 },
1977 right: {
1978 let child = node
1979 .child_by_field_name("right")
1980 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1981 ::treesitter_types::runtime::maybe_grow_stack(|| {
1982 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1983 })?
1984 },
1985 })
1986 }
1987}
1988impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1989 fn span(&self) -> ::treesitter_types::Span {
1990 self.span
1991 }
1992}
1993#[derive(Debug, Clone, PartialEq, Eq)]
1994pub struct Attribute<'tree> {
1995 pub span: ::treesitter_types::Span,
1996 pub name: AttributeName<'tree>,
1997 pub children: ::core::option::Option<AttributeArgumentList<'tree>>,
1998}
1999impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
2000 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2001 fn from_node(
2002 node: ::treesitter_types::tree_sitter::Node<'tree>,
2003 src: &'tree [u8],
2004 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2005 debug_assert_eq!(node.kind(), "attribute");
2006 Ok(Self {
2007 span: ::treesitter_types::Span::from(node),
2008 name: {
2009 let child = node
2010 .child_by_field_name("name")
2011 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2012 ::treesitter_types::runtime::maybe_grow_stack(|| {
2013 <AttributeName as ::treesitter_types::FromNode>::from_node(child, src)
2014 })?
2015 },
2016 children: {
2017 #[allow(clippy::suspicious_else_formatting)]
2018 let non_field_children = {
2019 let mut cursor = node.walk();
2020 let mut result = ::std::vec::Vec::new();
2021 if cursor.goto_first_child() {
2022 loop {
2023 if cursor.field_name().is_none()
2024 && cursor.node().is_named()
2025 && !cursor.node().is_extra()
2026 {
2027 result.push(cursor.node());
2028 }
2029 if !cursor.goto_next_sibling() {
2030 break;
2031 }
2032 }
2033 }
2034 result
2035 };
2036 match non_field_children.first() {
2037 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2038 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(
2039 child, src,
2040 )
2041 })?),
2042 None => None,
2043 }
2044 },
2045 })
2046 }
2047}
2048impl ::treesitter_types::Spanned for Attribute<'_> {
2049 fn span(&self) -> ::treesitter_types::Span {
2050 self.span
2051 }
2052}
2053#[derive(Debug, Clone, PartialEq, Eq)]
2054pub struct AttributeArgument<'tree> {
2055 pub span: ::treesitter_types::Span,
2056 pub children: ::std::vec::Vec<AttributeArgumentChildren<'tree>>,
2057}
2058impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgument<'tree> {
2059 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2060 fn from_node(
2061 node: ::treesitter_types::tree_sitter::Node<'tree>,
2062 src: &'tree [u8],
2063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2064 debug_assert_eq!(node.kind(), "attribute_argument");
2065 Ok(Self {
2066 span: ::treesitter_types::Span::from(node),
2067 children: {
2068 #[allow(clippy::suspicious_else_formatting)]
2069 let non_field_children = {
2070 let mut cursor = node.walk();
2071 let mut result = ::std::vec::Vec::new();
2072 if cursor.goto_first_child() {
2073 loop {
2074 if cursor.field_name().is_none()
2075 && cursor.node().is_named()
2076 && !cursor.node().is_extra()
2077 {
2078 result.push(cursor.node());
2079 }
2080 if !cursor.goto_next_sibling() {
2081 break;
2082 }
2083 }
2084 }
2085 result
2086 };
2087 let mut items = ::std::vec::Vec::new();
2088 for child in non_field_children {
2089 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2090 <AttributeArgumentChildren as ::treesitter_types::FromNode>::from_node(
2091 child, src,
2092 )
2093 })?);
2094 }
2095 items
2096 },
2097 })
2098 }
2099}
2100impl ::treesitter_types::Spanned for AttributeArgument<'_> {
2101 fn span(&self) -> ::treesitter_types::Span {
2102 self.span
2103 }
2104}
2105#[derive(Debug, Clone, PartialEq, Eq)]
2106pub struct AttributeArgumentList<'tree> {
2107 pub span: ::treesitter_types::Span,
2108 pub children: ::std::vec::Vec<AttributeArgument<'tree>>,
2109}
2110impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgumentList<'tree> {
2111 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2112 fn from_node(
2113 node: ::treesitter_types::tree_sitter::Node<'tree>,
2114 src: &'tree [u8],
2115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2116 debug_assert_eq!(node.kind(), "attribute_argument_list");
2117 Ok(Self {
2118 span: ::treesitter_types::Span::from(node),
2119 children: {
2120 #[allow(clippy::suspicious_else_formatting)]
2121 let non_field_children = {
2122 let mut cursor = node.walk();
2123 let mut result = ::std::vec::Vec::new();
2124 if cursor.goto_first_child() {
2125 loop {
2126 if cursor.field_name().is_none()
2127 && cursor.node().is_named()
2128 && !cursor.node().is_extra()
2129 {
2130 result.push(cursor.node());
2131 }
2132 if !cursor.goto_next_sibling() {
2133 break;
2134 }
2135 }
2136 }
2137 result
2138 };
2139 let mut items = ::std::vec::Vec::new();
2140 for child in non_field_children {
2141 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2142 <AttributeArgument as ::treesitter_types::FromNode>::from_node(child, src)
2143 })?);
2144 }
2145 items
2146 },
2147 })
2148 }
2149}
2150impl ::treesitter_types::Spanned for AttributeArgumentList<'_> {
2151 fn span(&self) -> ::treesitter_types::Span {
2152 self.span
2153 }
2154}
2155#[derive(Debug, Clone, PartialEq, Eq)]
2156pub struct AttributeList<'tree> {
2157 pub span: ::treesitter_types::Span,
2158 pub children: ::std::vec::Vec<AttributeListChildren<'tree>>,
2159}
2160impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeList<'tree> {
2161 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2162 fn from_node(
2163 node: ::treesitter_types::tree_sitter::Node<'tree>,
2164 src: &'tree [u8],
2165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2166 debug_assert_eq!(node.kind(), "attribute_list");
2167 Ok(Self {
2168 span: ::treesitter_types::Span::from(node),
2169 children: {
2170 #[allow(clippy::suspicious_else_formatting)]
2171 let non_field_children = {
2172 let mut cursor = node.walk();
2173 let mut result = ::std::vec::Vec::new();
2174 if cursor.goto_first_child() {
2175 loop {
2176 if cursor.field_name().is_none()
2177 && cursor.node().is_named()
2178 && !cursor.node().is_extra()
2179 {
2180 result.push(cursor.node());
2181 }
2182 if !cursor.goto_next_sibling() {
2183 break;
2184 }
2185 }
2186 }
2187 result
2188 };
2189 let mut items = ::std::vec::Vec::new();
2190 for child in non_field_children {
2191 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2192 <AttributeListChildren as ::treesitter_types::FromNode>::from_node(
2193 child, src,
2194 )
2195 })?);
2196 }
2197 items
2198 },
2199 })
2200 }
2201}
2202impl ::treesitter_types::Spanned for AttributeList<'_> {
2203 fn span(&self) -> ::treesitter_types::Span {
2204 self.span
2205 }
2206}
2207#[derive(Debug, Clone, PartialEq, Eq)]
2208pub struct AttributeTargetSpecifier<'tree> {
2209 pub span: ::treesitter_types::Span,
2210 text: &'tree str,
2211}
2212impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeTargetSpecifier<'tree> {
2213 fn from_node(
2214 node: ::treesitter_types::tree_sitter::Node<'tree>,
2215 src: &'tree [u8],
2216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2217 debug_assert_eq!(node.kind(), "attribute_target_specifier");
2218 Ok(Self {
2219 span: ::treesitter_types::Span::from(node),
2220 text: node.utf8_text(src)?,
2221 })
2222 }
2223}
2224impl<'tree> ::treesitter_types::LeafNode<'tree> for AttributeTargetSpecifier<'tree> {
2225 fn text(&self) -> &'tree str {
2226 self.text
2227 }
2228}
2229impl ::treesitter_types::Spanned for AttributeTargetSpecifier<'_> {
2230 fn span(&self) -> ::treesitter_types::Span {
2231 self.span
2232 }
2233}
2234#[derive(Debug, Clone, PartialEq, Eq)]
2235pub struct AwaitExpression<'tree> {
2236 pub span: ::treesitter_types::Span,
2237 pub children: Expression<'tree>,
2238}
2239impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
2240 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2241 fn from_node(
2242 node: ::treesitter_types::tree_sitter::Node<'tree>,
2243 src: &'tree [u8],
2244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2245 debug_assert_eq!(node.kind(), "await_expression");
2246 Ok(Self {
2247 span: ::treesitter_types::Span::from(node),
2248 children: {
2249 #[allow(clippy::suspicious_else_formatting)]
2250 let non_field_children = {
2251 let mut cursor = node.walk();
2252 let mut result = ::std::vec::Vec::new();
2253 if cursor.goto_first_child() {
2254 loop {
2255 if cursor.field_name().is_none()
2256 && cursor.node().is_named()
2257 && !cursor.node().is_extra()
2258 {
2259 result.push(cursor.node());
2260 }
2261 if !cursor.goto_next_sibling() {
2262 break;
2263 }
2264 }
2265 }
2266 result
2267 };
2268 let child = if let Some(&c) = non_field_children.first() {
2269 c
2270 } else {
2271 let mut fallback_cursor = node.walk();
2272 let mut fallback_child = None;
2273 if fallback_cursor.goto_first_child() {
2274 loop {
2275 if fallback_cursor.field_name().is_none()
2276 && !fallback_cursor.node().is_extra()
2277 {
2278 let candidate = fallback_cursor.node();
2279 #[allow(clippy::needless_question_mark)]
2280 if (|| -> ::core::result::Result<
2281 _,
2282 ::treesitter_types::ParseError,
2283 > {
2284 let child = candidate;
2285 Ok(
2286 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2287 child,
2288 src,
2289 ))?,
2290 )
2291 })()
2292 .is_ok()
2293 {
2294 fallback_child = Some(candidate);
2295 break;
2296 }
2297 }
2298 if !fallback_cursor.goto_next_sibling() {
2299 break;
2300 }
2301 }
2302 }
2303 if fallback_child.is_none() {
2304 let mut cursor2 = node.walk();
2305 if cursor2.goto_first_child() {
2306 loop {
2307 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2308 let candidate = cursor2.node();
2309 #[allow(clippy::needless_question_mark)]
2310 if (|| -> ::core::result::Result<
2311 _,
2312 ::treesitter_types::ParseError,
2313 > {
2314 let child = candidate;
2315 Ok(
2316 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2317 child,
2318 src,
2319 ))?,
2320 )
2321 })()
2322 .is_ok()
2323 {
2324 fallback_child = Some(candidate);
2325 break;
2326 }
2327 }
2328 if !cursor2.goto_next_sibling() {
2329 break;
2330 }
2331 }
2332 }
2333 }
2334 fallback_child.ok_or_else(|| {
2335 ::treesitter_types::ParseError::missing_field("children", node)
2336 })?
2337 };
2338 ::treesitter_types::runtime::maybe_grow_stack(|| {
2339 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2340 })?
2341 },
2342 })
2343 }
2344}
2345impl ::treesitter_types::Spanned for AwaitExpression<'_> {
2346 fn span(&self) -> ::treesitter_types::Span {
2347 self.span
2348 }
2349}
2350#[derive(Debug, Clone, PartialEq, Eq)]
2351pub struct BaseList<'tree> {
2352 pub span: ::treesitter_types::Span,
2353 pub children: ::std::vec::Vec<BaseListChildren<'tree>>,
2354}
2355impl<'tree> ::treesitter_types::FromNode<'tree> for BaseList<'tree> {
2356 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2357 fn from_node(
2358 node: ::treesitter_types::tree_sitter::Node<'tree>,
2359 src: &'tree [u8],
2360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2361 debug_assert_eq!(node.kind(), "base_list");
2362 Ok(Self {
2363 span: ::treesitter_types::Span::from(node),
2364 children: {
2365 #[allow(clippy::suspicious_else_formatting)]
2366 let non_field_children = {
2367 let mut cursor = node.walk();
2368 let mut result = ::std::vec::Vec::new();
2369 if cursor.goto_first_child() {
2370 loop {
2371 if cursor.field_name().is_none()
2372 && cursor.node().is_named()
2373 && !cursor.node().is_extra()
2374 {
2375 result.push(cursor.node());
2376 }
2377 if !cursor.goto_next_sibling() {
2378 break;
2379 }
2380 }
2381 }
2382 result
2383 };
2384 let mut items = ::std::vec::Vec::new();
2385 for child in non_field_children {
2386 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2387 <BaseListChildren as ::treesitter_types::FromNode>::from_node(child, src)
2388 })?);
2389 }
2390 items
2391 },
2392 })
2393 }
2394}
2395impl ::treesitter_types::Spanned for BaseList<'_> {
2396 fn span(&self) -> ::treesitter_types::Span {
2397 self.span
2398 }
2399}
2400#[derive(Debug, Clone, PartialEq, Eq)]
2401pub struct BinaryExpression<'tree> {
2402 pub span: ::treesitter_types::Span,
2403 pub left: BinaryExpressionLeft<'tree>,
2404 pub operator: BinaryExpressionOperator,
2405 pub right: BinaryExpressionRight<'tree>,
2406}
2407impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
2408 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2409 fn from_node(
2410 node: ::treesitter_types::tree_sitter::Node<'tree>,
2411 src: &'tree [u8],
2412 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2413 debug_assert_eq!(node.kind(), "binary_expression");
2414 Ok(Self {
2415 span: ::treesitter_types::Span::from(node),
2416 left: {
2417 let child = node
2418 .child_by_field_name("left")
2419 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2420 ::treesitter_types::runtime::maybe_grow_stack(|| {
2421 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
2422 })?
2423 },
2424 operator: {
2425 let child = node.child_by_field_name("operator").ok_or_else(|| {
2426 ::treesitter_types::ParseError::missing_field("operator", node)
2427 })?;
2428 ::treesitter_types::runtime::maybe_grow_stack(|| {
2429 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
2430 child, src,
2431 )
2432 })?
2433 },
2434 right: {
2435 let child = node
2436 .child_by_field_name("right")
2437 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2438 ::treesitter_types::runtime::maybe_grow_stack(|| {
2439 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
2440 })?
2441 },
2442 })
2443 }
2444}
2445impl ::treesitter_types::Spanned for BinaryExpression<'_> {
2446 fn span(&self) -> ::treesitter_types::Span {
2447 self.span
2448 }
2449}
2450#[derive(Debug, Clone, PartialEq, Eq)]
2451pub struct Block<'tree> {
2452 pub span: ::treesitter_types::Span,
2453 pub children: ::std::vec::Vec<Statement<'tree>>,
2454}
2455impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
2456 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2457 fn from_node(
2458 node: ::treesitter_types::tree_sitter::Node<'tree>,
2459 src: &'tree [u8],
2460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2461 debug_assert_eq!(node.kind(), "block");
2462 Ok(Self {
2463 span: ::treesitter_types::Span::from(node),
2464 children: {
2465 #[allow(clippy::suspicious_else_formatting)]
2466 let non_field_children = {
2467 let mut cursor = node.walk();
2468 let mut result = ::std::vec::Vec::new();
2469 if cursor.goto_first_child() {
2470 loop {
2471 if cursor.field_name().is_none()
2472 && cursor.node().is_named()
2473 && !cursor.node().is_extra()
2474 {
2475 result.push(cursor.node());
2476 }
2477 if !cursor.goto_next_sibling() {
2478 break;
2479 }
2480 }
2481 }
2482 result
2483 };
2484 let mut items = ::std::vec::Vec::new();
2485 for child in non_field_children {
2486 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2487 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2488 })?);
2489 }
2490 items
2491 },
2492 })
2493 }
2494}
2495impl ::treesitter_types::Spanned for Block<'_> {
2496 fn span(&self) -> ::treesitter_types::Span {
2497 self.span
2498 }
2499}
2500#[derive(Debug, Clone, PartialEq, Eq)]
2501pub struct BooleanLiteral<'tree> {
2502 pub span: ::treesitter_types::Span,
2503 text: &'tree str,
2504}
2505impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
2506 fn from_node(
2507 node: ::treesitter_types::tree_sitter::Node<'tree>,
2508 src: &'tree [u8],
2509 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2510 debug_assert_eq!(node.kind(), "boolean_literal");
2511 Ok(Self {
2512 span: ::treesitter_types::Span::from(node),
2513 text: node.utf8_text(src)?,
2514 })
2515 }
2516}
2517impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
2518 fn text(&self) -> &'tree str {
2519 self.text
2520 }
2521}
2522impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
2523 fn span(&self) -> ::treesitter_types::Span {
2524 self.span
2525 }
2526}
2527#[derive(Debug, Clone, PartialEq, Eq)]
2528pub struct BracketedArgumentList<'tree> {
2529 pub span: ::treesitter_types::Span,
2530 pub children: ::std::vec::Vec<Argument<'tree>>,
2531}
2532impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedArgumentList<'tree> {
2533 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2534 fn from_node(
2535 node: ::treesitter_types::tree_sitter::Node<'tree>,
2536 src: &'tree [u8],
2537 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2538 debug_assert_eq!(node.kind(), "bracketed_argument_list");
2539 Ok(Self {
2540 span: ::treesitter_types::Span::from(node),
2541 children: {
2542 #[allow(clippy::suspicious_else_formatting)]
2543 let non_field_children = {
2544 let mut cursor = node.walk();
2545 let mut result = ::std::vec::Vec::new();
2546 if cursor.goto_first_child() {
2547 loop {
2548 if cursor.field_name().is_none()
2549 && cursor.node().is_named()
2550 && !cursor.node().is_extra()
2551 {
2552 result.push(cursor.node());
2553 }
2554 if !cursor.goto_next_sibling() {
2555 break;
2556 }
2557 }
2558 }
2559 result
2560 };
2561 let mut items = ::std::vec::Vec::new();
2562 for child in non_field_children {
2563 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2564 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
2565 })?);
2566 }
2567 items
2568 },
2569 })
2570 }
2571}
2572impl ::treesitter_types::Spanned for BracketedArgumentList<'_> {
2573 fn span(&self) -> ::treesitter_types::Span {
2574 self.span
2575 }
2576}
2577#[derive(Debug, Clone, PartialEq, Eq)]
2578pub struct BracketedParameterList<'tree> {
2579 pub span: ::treesitter_types::Span,
2580 pub name: ::std::vec::Vec<Identifier<'tree>>,
2581 pub r#type: ::std::vec::Vec<BracketedParameterListType<'tree>>,
2582 pub children: ::std::vec::Vec<BracketedParameterListChildren<'tree>>,
2583}
2584impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterList<'tree> {
2585 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2586 fn from_node(
2587 node: ::treesitter_types::tree_sitter::Node<'tree>,
2588 src: &'tree [u8],
2589 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2590 debug_assert_eq!(node.kind(), "bracketed_parameter_list");
2591 Ok(Self {
2592 span: ::treesitter_types::Span::from(node),
2593 name: {
2594 let mut cursor = node.walk();
2595 let mut items = ::std::vec::Vec::new();
2596 for child in node.children_by_field_name("name", &mut cursor) {
2597 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2598 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2599 })?);
2600 }
2601 items
2602 },
2603 r#type: {
2604 let mut cursor = node.walk();
2605 let mut items = ::std::vec::Vec::new();
2606 for child in node.children_by_field_name("type", &mut cursor) {
2607 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2608 <BracketedParameterListType as ::treesitter_types::FromNode>::from_node(
2609 child, src,
2610 )
2611 })?);
2612 }
2613 items
2614 },
2615 children: {
2616 #[allow(clippy::suspicious_else_formatting)]
2617 let non_field_children = {
2618 let mut cursor = node.walk();
2619 let mut result = ::std::vec::Vec::new();
2620 if cursor.goto_first_child() {
2621 loop {
2622 if cursor.field_name().is_none()
2623 && cursor.node().is_named()
2624 && !cursor.node().is_extra()
2625 {
2626 result.push(cursor.node());
2627 }
2628 if !cursor.goto_next_sibling() {
2629 break;
2630 }
2631 }
2632 }
2633 result
2634 };
2635 let mut items = ::std::vec::Vec::new();
2636 for child in non_field_children {
2637 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2638 <BracketedParameterListChildren as ::treesitter_types::FromNode>::from_node(
2639 child, src,
2640 )
2641 })?);
2642 }
2643 items
2644 },
2645 })
2646 }
2647}
2648impl ::treesitter_types::Spanned for BracketedParameterList<'_> {
2649 fn span(&self) -> ::treesitter_types::Span {
2650 self.span
2651 }
2652}
2653#[derive(Debug, Clone, PartialEq, Eq)]
2654pub struct BreakStatement<'tree> {
2655 pub span: ::treesitter_types::Span,
2656 text: &'tree str,
2657}
2658impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
2659 fn from_node(
2660 node: ::treesitter_types::tree_sitter::Node<'tree>,
2661 src: &'tree [u8],
2662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2663 debug_assert_eq!(node.kind(), "break_statement");
2664 Ok(Self {
2665 span: ::treesitter_types::Span::from(node),
2666 text: node.utf8_text(src)?,
2667 })
2668 }
2669}
2670impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
2671 fn text(&self) -> &'tree str {
2672 self.text
2673 }
2674}
2675impl ::treesitter_types::Spanned for BreakStatement<'_> {
2676 fn span(&self) -> ::treesitter_types::Span {
2677 self.span
2678 }
2679}
2680#[derive(Debug, Clone, PartialEq, Eq)]
2681pub struct CallingConvention<'tree> {
2682 pub span: ::treesitter_types::Span,
2683 pub children: ::std::vec::Vec<Identifier<'tree>>,
2684}
2685impl<'tree> ::treesitter_types::FromNode<'tree> for CallingConvention<'tree> {
2686 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2687 fn from_node(
2688 node: ::treesitter_types::tree_sitter::Node<'tree>,
2689 src: &'tree [u8],
2690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2691 debug_assert_eq!(node.kind(), "calling_convention");
2692 Ok(Self {
2693 span: ::treesitter_types::Span::from(node),
2694 children: {
2695 #[allow(clippy::suspicious_else_formatting)]
2696 let non_field_children = {
2697 let mut cursor = node.walk();
2698 let mut result = ::std::vec::Vec::new();
2699 if cursor.goto_first_child() {
2700 loop {
2701 if cursor.field_name().is_none()
2702 && cursor.node().is_named()
2703 && !cursor.node().is_extra()
2704 {
2705 result.push(cursor.node());
2706 }
2707 if !cursor.goto_next_sibling() {
2708 break;
2709 }
2710 }
2711 }
2712 result
2713 };
2714 let mut items = ::std::vec::Vec::new();
2715 for child in non_field_children {
2716 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2717 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2718 })?);
2719 }
2720 items
2721 },
2722 })
2723 }
2724}
2725impl ::treesitter_types::Spanned for CallingConvention<'_> {
2726 fn span(&self) -> ::treesitter_types::Span {
2727 self.span
2728 }
2729}
2730#[derive(Debug, Clone, PartialEq, Eq)]
2731pub struct CastExpression<'tree> {
2732 pub span: ::treesitter_types::Span,
2733 pub r#type: Type<'tree>,
2734 pub value: Expression<'tree>,
2735}
2736impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
2737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2738 fn from_node(
2739 node: ::treesitter_types::tree_sitter::Node<'tree>,
2740 src: &'tree [u8],
2741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2742 debug_assert_eq!(node.kind(), "cast_expression");
2743 Ok(Self {
2744 span: ::treesitter_types::Span::from(node),
2745 r#type: {
2746 let child = node
2747 .child_by_field_name("type")
2748 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2749 ::treesitter_types::runtime::maybe_grow_stack(|| {
2750 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2751 })?
2752 },
2753 value: {
2754 let child = node
2755 .child_by_field_name("value")
2756 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2757 ::treesitter_types::runtime::maybe_grow_stack(|| {
2758 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2759 })?
2760 },
2761 })
2762 }
2763}
2764impl ::treesitter_types::Spanned for CastExpression<'_> {
2765 fn span(&self) -> ::treesitter_types::Span {
2766 self.span
2767 }
2768}
2769#[derive(Debug, Clone, PartialEq, Eq)]
2770pub struct CatchClause<'tree> {
2771 pub span: ::treesitter_types::Span,
2772 pub body: Block<'tree>,
2773 pub children: ::std::vec::Vec<CatchClauseChildren<'tree>>,
2774}
2775impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2776 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2777 fn from_node(
2778 node: ::treesitter_types::tree_sitter::Node<'tree>,
2779 src: &'tree [u8],
2780 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2781 debug_assert_eq!(node.kind(), "catch_clause");
2782 Ok(Self {
2783 span: ::treesitter_types::Span::from(node),
2784 body: {
2785 let child = node
2786 .child_by_field_name("body")
2787 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2788 ::treesitter_types::runtime::maybe_grow_stack(|| {
2789 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2790 })?
2791 },
2792 children: {
2793 #[allow(clippy::suspicious_else_formatting)]
2794 let non_field_children = {
2795 let mut cursor = node.walk();
2796 let mut result = ::std::vec::Vec::new();
2797 if cursor.goto_first_child() {
2798 loop {
2799 if cursor.field_name().is_none()
2800 && cursor.node().is_named()
2801 && !cursor.node().is_extra()
2802 {
2803 result.push(cursor.node());
2804 }
2805 if !cursor.goto_next_sibling() {
2806 break;
2807 }
2808 }
2809 }
2810 result
2811 };
2812 let mut items = ::std::vec::Vec::new();
2813 for child in non_field_children {
2814 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2815 <CatchClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2816 })?);
2817 }
2818 items
2819 },
2820 })
2821 }
2822}
2823impl ::treesitter_types::Spanned for CatchClause<'_> {
2824 fn span(&self) -> ::treesitter_types::Span {
2825 self.span
2826 }
2827}
2828#[derive(Debug, Clone, PartialEq, Eq)]
2829pub struct CatchDeclaration<'tree> {
2830 pub span: ::treesitter_types::Span,
2831 pub name: ::core::option::Option<Identifier<'tree>>,
2832 pub r#type: Type<'tree>,
2833}
2834impl<'tree> ::treesitter_types::FromNode<'tree> for CatchDeclaration<'tree> {
2835 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2836 fn from_node(
2837 node: ::treesitter_types::tree_sitter::Node<'tree>,
2838 src: &'tree [u8],
2839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2840 debug_assert_eq!(node.kind(), "catch_declaration");
2841 Ok(Self {
2842 span: ::treesitter_types::Span::from(node),
2843 name: match node.child_by_field_name("name") {
2844 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2845 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2846 })?),
2847 None => None,
2848 },
2849 r#type: {
2850 let child = node
2851 .child_by_field_name("type")
2852 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2853 ::treesitter_types::runtime::maybe_grow_stack(|| {
2854 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2855 })?
2856 },
2857 })
2858 }
2859}
2860impl ::treesitter_types::Spanned for CatchDeclaration<'_> {
2861 fn span(&self) -> ::treesitter_types::Span {
2862 self.span
2863 }
2864}
2865#[derive(Debug, Clone, PartialEq, Eq)]
2866pub struct CatchFilterClause<'tree> {
2867 pub span: ::treesitter_types::Span,
2868 pub children: Expression<'tree>,
2869}
2870impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFilterClause<'tree> {
2871 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2872 fn from_node(
2873 node: ::treesitter_types::tree_sitter::Node<'tree>,
2874 src: &'tree [u8],
2875 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2876 debug_assert_eq!(node.kind(), "catch_filter_clause");
2877 Ok(Self {
2878 span: ::treesitter_types::Span::from(node),
2879 children: {
2880 #[allow(clippy::suspicious_else_formatting)]
2881 let non_field_children = {
2882 let mut cursor = node.walk();
2883 let mut result = ::std::vec::Vec::new();
2884 if cursor.goto_first_child() {
2885 loop {
2886 if cursor.field_name().is_none()
2887 && cursor.node().is_named()
2888 && !cursor.node().is_extra()
2889 {
2890 result.push(cursor.node());
2891 }
2892 if !cursor.goto_next_sibling() {
2893 break;
2894 }
2895 }
2896 }
2897 result
2898 };
2899 let child = if let Some(&c) = non_field_children.first() {
2900 c
2901 } else {
2902 let mut fallback_cursor = node.walk();
2903 let mut fallback_child = None;
2904 if fallback_cursor.goto_first_child() {
2905 loop {
2906 if fallback_cursor.field_name().is_none()
2907 && !fallback_cursor.node().is_extra()
2908 {
2909 let candidate = fallback_cursor.node();
2910 #[allow(clippy::needless_question_mark)]
2911 if (|| -> ::core::result::Result<
2912 _,
2913 ::treesitter_types::ParseError,
2914 > {
2915 let child = candidate;
2916 Ok(
2917 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2918 child,
2919 src,
2920 ))?,
2921 )
2922 })()
2923 .is_ok()
2924 {
2925 fallback_child = Some(candidate);
2926 break;
2927 }
2928 }
2929 if !fallback_cursor.goto_next_sibling() {
2930 break;
2931 }
2932 }
2933 }
2934 if fallback_child.is_none() {
2935 let mut cursor2 = node.walk();
2936 if cursor2.goto_first_child() {
2937 loop {
2938 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2939 let candidate = cursor2.node();
2940 #[allow(clippy::needless_question_mark)]
2941 if (|| -> ::core::result::Result<
2942 _,
2943 ::treesitter_types::ParseError,
2944 > {
2945 let child = candidate;
2946 Ok(
2947 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2948 child,
2949 src,
2950 ))?,
2951 )
2952 })()
2953 .is_ok()
2954 {
2955 fallback_child = Some(candidate);
2956 break;
2957 }
2958 }
2959 if !cursor2.goto_next_sibling() {
2960 break;
2961 }
2962 }
2963 }
2964 }
2965 fallback_child.ok_or_else(|| {
2966 ::treesitter_types::ParseError::missing_field("children", node)
2967 })?
2968 };
2969 ::treesitter_types::runtime::maybe_grow_stack(|| {
2970 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2971 })?
2972 },
2973 })
2974 }
2975}
2976impl ::treesitter_types::Spanned for CatchFilterClause<'_> {
2977 fn span(&self) -> ::treesitter_types::Span {
2978 self.span
2979 }
2980}
2981#[derive(Debug, Clone, PartialEq, Eq)]
2982pub struct CharacterLiteral<'tree> {
2983 pub span: ::treesitter_types::Span,
2984 pub children: CharacterLiteralChildren<'tree>,
2985}
2986impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
2987 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2988 fn from_node(
2989 node: ::treesitter_types::tree_sitter::Node<'tree>,
2990 src: &'tree [u8],
2991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2992 debug_assert_eq!(node.kind(), "character_literal");
2993 Ok(Self {
2994 span: ::treesitter_types::Span::from(node),
2995 children: {
2996 #[allow(clippy::suspicious_else_formatting)]
2997 let non_field_children = {
2998 let mut cursor = node.walk();
2999 let mut result = ::std::vec::Vec::new();
3000 if cursor.goto_first_child() {
3001 loop {
3002 if cursor.field_name().is_none()
3003 && cursor.node().is_named()
3004 && !cursor.node().is_extra()
3005 {
3006 result.push(cursor.node());
3007 }
3008 if !cursor.goto_next_sibling() {
3009 break;
3010 }
3011 }
3012 }
3013 result
3014 };
3015 let child = if let Some(&c) = non_field_children.first() {
3016 c
3017 } else {
3018 let mut fallback_cursor = node.walk();
3019 let mut fallback_child = None;
3020 if fallback_cursor.goto_first_child() {
3021 loop {
3022 if fallback_cursor.field_name().is_none()
3023 && !fallback_cursor.node().is_extra()
3024 {
3025 let candidate = fallback_cursor.node();
3026 #[allow(clippy::needless_question_mark)]
3027 if (|| -> ::core::result::Result<
3028 _,
3029 ::treesitter_types::ParseError,
3030 > {
3031 let child = candidate;
3032 Ok(
3033 ::treesitter_types::runtime::maybe_grow_stack(|| <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3034 child,
3035 src,
3036 ))?,
3037 )
3038 })()
3039 .is_ok()
3040 {
3041 fallback_child = Some(candidate);
3042 break;
3043 }
3044 }
3045 if !fallback_cursor.goto_next_sibling() {
3046 break;
3047 }
3048 }
3049 }
3050 if fallback_child.is_none() {
3051 let mut cursor2 = node.walk();
3052 if cursor2.goto_first_child() {
3053 loop {
3054 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3055 let candidate = cursor2.node();
3056 #[allow(clippy::needless_question_mark)]
3057 if (|| -> ::core::result::Result<
3058 _,
3059 ::treesitter_types::ParseError,
3060 > {
3061 let child = candidate;
3062 Ok(
3063 ::treesitter_types::runtime::maybe_grow_stack(|| <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3064 child,
3065 src,
3066 ))?,
3067 )
3068 })()
3069 .is_ok()
3070 {
3071 fallback_child = Some(candidate);
3072 break;
3073 }
3074 }
3075 if !cursor2.goto_next_sibling() {
3076 break;
3077 }
3078 }
3079 }
3080 }
3081 fallback_child.ok_or_else(|| {
3082 ::treesitter_types::ParseError::missing_field("children", node)
3083 })?
3084 };
3085 ::treesitter_types::runtime::maybe_grow_stack(|| {
3086 <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3087 child, src,
3088 )
3089 })?
3090 },
3091 })
3092 }
3093}
3094impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
3095 fn span(&self) -> ::treesitter_types::Span {
3096 self.span
3097 }
3098}
3099#[derive(Debug, Clone, PartialEq, Eq)]
3100pub struct CheckedExpression<'tree> {
3101 pub span: ::treesitter_types::Span,
3102 pub children: Expression<'tree>,
3103}
3104impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedExpression<'tree> {
3105 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3106 fn from_node(
3107 node: ::treesitter_types::tree_sitter::Node<'tree>,
3108 src: &'tree [u8],
3109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3110 debug_assert_eq!(node.kind(), "checked_expression");
3111 Ok(Self {
3112 span: ::treesitter_types::Span::from(node),
3113 children: {
3114 #[allow(clippy::suspicious_else_formatting)]
3115 let non_field_children = {
3116 let mut cursor = node.walk();
3117 let mut result = ::std::vec::Vec::new();
3118 if cursor.goto_first_child() {
3119 loop {
3120 if cursor.field_name().is_none()
3121 && cursor.node().is_named()
3122 && !cursor.node().is_extra()
3123 {
3124 result.push(cursor.node());
3125 }
3126 if !cursor.goto_next_sibling() {
3127 break;
3128 }
3129 }
3130 }
3131 result
3132 };
3133 let child = if let Some(&c) = non_field_children.first() {
3134 c
3135 } else {
3136 let mut fallback_cursor = node.walk();
3137 let mut fallback_child = None;
3138 if fallback_cursor.goto_first_child() {
3139 loop {
3140 if fallback_cursor.field_name().is_none()
3141 && !fallback_cursor.node().is_extra()
3142 {
3143 let candidate = fallback_cursor.node();
3144 #[allow(clippy::needless_question_mark)]
3145 if (|| -> ::core::result::Result<
3146 _,
3147 ::treesitter_types::ParseError,
3148 > {
3149 let child = candidate;
3150 Ok(
3151 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3152 child,
3153 src,
3154 ))?,
3155 )
3156 })()
3157 .is_ok()
3158 {
3159 fallback_child = Some(candidate);
3160 break;
3161 }
3162 }
3163 if !fallback_cursor.goto_next_sibling() {
3164 break;
3165 }
3166 }
3167 }
3168 if fallback_child.is_none() {
3169 let mut cursor2 = node.walk();
3170 if cursor2.goto_first_child() {
3171 loop {
3172 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3173 let candidate = cursor2.node();
3174 #[allow(clippy::needless_question_mark)]
3175 if (|| -> ::core::result::Result<
3176 _,
3177 ::treesitter_types::ParseError,
3178 > {
3179 let child = candidate;
3180 Ok(
3181 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3182 child,
3183 src,
3184 ))?,
3185 )
3186 })()
3187 .is_ok()
3188 {
3189 fallback_child = Some(candidate);
3190 break;
3191 }
3192 }
3193 if !cursor2.goto_next_sibling() {
3194 break;
3195 }
3196 }
3197 }
3198 }
3199 fallback_child.ok_or_else(|| {
3200 ::treesitter_types::ParseError::missing_field("children", node)
3201 })?
3202 };
3203 ::treesitter_types::runtime::maybe_grow_stack(|| {
3204 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3205 })?
3206 },
3207 })
3208 }
3209}
3210impl ::treesitter_types::Spanned for CheckedExpression<'_> {
3211 fn span(&self) -> ::treesitter_types::Span {
3212 self.span
3213 }
3214}
3215#[derive(Debug, Clone, PartialEq, Eq)]
3216pub struct CheckedStatement<'tree> {
3217 pub span: ::treesitter_types::Span,
3218 pub children: Block<'tree>,
3219}
3220impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedStatement<'tree> {
3221 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3222 fn from_node(
3223 node: ::treesitter_types::tree_sitter::Node<'tree>,
3224 src: &'tree [u8],
3225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3226 debug_assert_eq!(node.kind(), "checked_statement");
3227 Ok(Self {
3228 span: ::treesitter_types::Span::from(node),
3229 children: {
3230 #[allow(clippy::suspicious_else_formatting)]
3231 let non_field_children = {
3232 let mut cursor = node.walk();
3233 let mut result = ::std::vec::Vec::new();
3234 if cursor.goto_first_child() {
3235 loop {
3236 if cursor.field_name().is_none()
3237 && cursor.node().is_named()
3238 && !cursor.node().is_extra()
3239 {
3240 result.push(cursor.node());
3241 }
3242 if !cursor.goto_next_sibling() {
3243 break;
3244 }
3245 }
3246 }
3247 result
3248 };
3249 let child = if let Some(&c) = non_field_children.first() {
3250 c
3251 } else {
3252 let mut fallback_cursor = node.walk();
3253 let mut fallback_child = None;
3254 if fallback_cursor.goto_first_child() {
3255 loop {
3256 if fallback_cursor.field_name().is_none()
3257 && !fallback_cursor.node().is_extra()
3258 {
3259 let candidate = fallback_cursor.node();
3260 #[allow(clippy::needless_question_mark)]
3261 if (|| -> ::core::result::Result<
3262 _,
3263 ::treesitter_types::ParseError,
3264 > {
3265 let child = candidate;
3266 Ok(
3267 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3268 child,
3269 src,
3270 ))?,
3271 )
3272 })()
3273 .is_ok()
3274 {
3275 fallback_child = Some(candidate);
3276 break;
3277 }
3278 }
3279 if !fallback_cursor.goto_next_sibling() {
3280 break;
3281 }
3282 }
3283 }
3284 if fallback_child.is_none() {
3285 let mut cursor2 = node.walk();
3286 if cursor2.goto_first_child() {
3287 loop {
3288 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3289 let candidate = cursor2.node();
3290 #[allow(clippy::needless_question_mark)]
3291 if (|| -> ::core::result::Result<
3292 _,
3293 ::treesitter_types::ParseError,
3294 > {
3295 let child = candidate;
3296 Ok(
3297 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3298 child,
3299 src,
3300 ))?,
3301 )
3302 })()
3303 .is_ok()
3304 {
3305 fallback_child = Some(candidate);
3306 break;
3307 }
3308 }
3309 if !cursor2.goto_next_sibling() {
3310 break;
3311 }
3312 }
3313 }
3314 }
3315 fallback_child.ok_or_else(|| {
3316 ::treesitter_types::ParseError::missing_field("children", node)
3317 })?
3318 };
3319 ::treesitter_types::runtime::maybe_grow_stack(|| {
3320 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3321 })?
3322 },
3323 })
3324 }
3325}
3326impl ::treesitter_types::Spanned for CheckedStatement<'_> {
3327 fn span(&self) -> ::treesitter_types::Span {
3328 self.span
3329 }
3330}
3331#[derive(Debug, Clone, PartialEq, Eq)]
3332pub struct ClassDeclaration<'tree> {
3333 pub span: ::treesitter_types::Span,
3334 pub body: DeclarationList<'tree>,
3335 pub name: Identifier<'tree>,
3336 pub children: ::std::vec::Vec<ClassDeclarationChildren<'tree>>,
3337}
3338impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
3339 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3340 fn from_node(
3341 node: ::treesitter_types::tree_sitter::Node<'tree>,
3342 src: &'tree [u8],
3343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3344 debug_assert_eq!(node.kind(), "class_declaration");
3345 Ok(Self {
3346 span: ::treesitter_types::Span::from(node),
3347 body: {
3348 let child = node
3349 .child_by_field_name("body")
3350 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3351 ::treesitter_types::runtime::maybe_grow_stack(|| {
3352 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
3353 })?
3354 },
3355 name: {
3356 let child = node
3357 .child_by_field_name("name")
3358 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3359 ::treesitter_types::runtime::maybe_grow_stack(|| {
3360 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3361 })?
3362 },
3363 children: {
3364 #[allow(clippy::suspicious_else_formatting)]
3365 let non_field_children = {
3366 let mut cursor = node.walk();
3367 let mut result = ::std::vec::Vec::new();
3368 if cursor.goto_first_child() {
3369 loop {
3370 if cursor.field_name().is_none()
3371 && cursor.node().is_named()
3372 && !cursor.node().is_extra()
3373 {
3374 result.push(cursor.node());
3375 }
3376 if !cursor.goto_next_sibling() {
3377 break;
3378 }
3379 }
3380 }
3381 result
3382 };
3383 let mut items = ::std::vec::Vec::new();
3384 for child in non_field_children {
3385 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3386 <ClassDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3387 child, src,
3388 )
3389 })?);
3390 }
3391 items
3392 },
3393 })
3394 }
3395}
3396impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
3397 fn span(&self) -> ::treesitter_types::Span {
3398 self.span
3399 }
3400}
3401#[derive(Debug, Clone, PartialEq, Eq)]
3402pub struct CompilationUnit<'tree> {
3403 pub span: ::treesitter_types::Span,
3404 pub children: ::std::vec::Vec<CompilationUnitChildren<'tree>>,
3405}
3406impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnit<'tree> {
3407 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3408 fn from_node(
3409 node: ::treesitter_types::tree_sitter::Node<'tree>,
3410 src: &'tree [u8],
3411 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3412 debug_assert_eq!(node.kind(), "compilation_unit");
3413 Ok(Self {
3414 span: ::treesitter_types::Span::from(node),
3415 children: {
3416 #[allow(clippy::suspicious_else_formatting)]
3417 let non_field_children = {
3418 let mut cursor = node.walk();
3419 let mut result = ::std::vec::Vec::new();
3420 if cursor.goto_first_child() {
3421 loop {
3422 if cursor.field_name().is_none()
3423 && cursor.node().is_named()
3424 && !cursor.node().is_extra()
3425 {
3426 result.push(cursor.node());
3427 }
3428 if !cursor.goto_next_sibling() {
3429 break;
3430 }
3431 }
3432 }
3433 result
3434 };
3435 let mut items = ::std::vec::Vec::new();
3436 for child in non_field_children {
3437 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3438 <CompilationUnitChildren as ::treesitter_types::FromNode>::from_node(
3439 child, src,
3440 )
3441 })?);
3442 }
3443 items
3444 },
3445 })
3446 }
3447}
3448impl ::treesitter_types::Spanned for CompilationUnit<'_> {
3449 fn span(&self) -> ::treesitter_types::Span {
3450 self.span
3451 }
3452}
3453#[derive(Debug, Clone, PartialEq, Eq)]
3454pub struct ConditionalAccessExpression<'tree> {
3455 pub span: ::treesitter_types::Span,
3456 pub condition: Expression<'tree>,
3457 pub children: ConditionalAccessExpressionChildren<'tree>,
3458}
3459impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpression<'tree> {
3460 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3461 fn from_node(
3462 node: ::treesitter_types::tree_sitter::Node<'tree>,
3463 src: &'tree [u8],
3464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3465 debug_assert_eq!(node.kind(), "conditional_access_expression");
3466 Ok(Self {
3467 span: ::treesitter_types::Span::from(node),
3468 condition: {
3469 let child = node.child_by_field_name("condition").ok_or_else(|| {
3470 ::treesitter_types::ParseError::missing_field("condition", node)
3471 })?;
3472 ::treesitter_types::runtime::maybe_grow_stack(|| {
3473 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3474 })?
3475 },
3476 children: {
3477 #[allow(clippy::suspicious_else_formatting)]
3478 let non_field_children = {
3479 let mut cursor = node.walk();
3480 let mut result = ::std::vec::Vec::new();
3481 if cursor.goto_first_child() {
3482 loop {
3483 if cursor.field_name().is_none()
3484 && cursor.node().is_named()
3485 && !cursor.node().is_extra()
3486 {
3487 result.push(cursor.node());
3488 }
3489 if !cursor.goto_next_sibling() {
3490 break;
3491 }
3492 }
3493 }
3494 result
3495 };
3496 let child = if let Some(&c) = non_field_children.first() {
3497 c
3498 } else {
3499 let mut fallback_cursor = node.walk();
3500 let mut fallback_child = None;
3501 if fallback_cursor.goto_first_child() {
3502 loop {
3503 if fallback_cursor.field_name().is_none()
3504 && !fallback_cursor.node().is_extra()
3505 {
3506 let candidate = fallback_cursor.node();
3507 #[allow(clippy::needless_question_mark)]
3508 if (|| -> ::core::result::Result<
3509 _,
3510 ::treesitter_types::ParseError,
3511 > {
3512 let child = candidate;
3513 Ok(
3514 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3515 child,
3516 src,
3517 ))?,
3518 )
3519 })()
3520 .is_ok()
3521 {
3522 fallback_child = Some(candidate);
3523 break;
3524 }
3525 }
3526 if !fallback_cursor.goto_next_sibling() {
3527 break;
3528 }
3529 }
3530 }
3531 if fallback_child.is_none() {
3532 let mut cursor2 = node.walk();
3533 if cursor2.goto_first_child() {
3534 loop {
3535 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3536 let candidate = cursor2.node();
3537 #[allow(clippy::needless_question_mark)]
3538 if (|| -> ::core::result::Result<
3539 _,
3540 ::treesitter_types::ParseError,
3541 > {
3542 let child = candidate;
3543 Ok(
3544 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3545 child,
3546 src,
3547 ))?,
3548 )
3549 })()
3550 .is_ok()
3551 {
3552 fallback_child = Some(candidate);
3553 break;
3554 }
3555 }
3556 if !cursor2.goto_next_sibling() {
3557 break;
3558 }
3559 }
3560 }
3561 }
3562 fallback_child.ok_or_else(|| {
3563 ::treesitter_types::ParseError::missing_field("children", node)
3564 })?
3565 };
3566 ::treesitter_types::runtime::maybe_grow_stack(|| {
3567 <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3568 child, src,
3569 )
3570 })?
3571 },
3572 })
3573 }
3574}
3575impl ::treesitter_types::Spanned for ConditionalAccessExpression<'_> {
3576 fn span(&self) -> ::treesitter_types::Span {
3577 self.span
3578 }
3579}
3580#[derive(Debug, Clone, PartialEq, Eq)]
3581pub struct ConditionalExpression<'tree> {
3582 pub span: ::treesitter_types::Span,
3583 pub alternative: Expression<'tree>,
3584 pub condition: Expression<'tree>,
3585 pub consequence: Expression<'tree>,
3586}
3587impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
3588 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3589 fn from_node(
3590 node: ::treesitter_types::tree_sitter::Node<'tree>,
3591 src: &'tree [u8],
3592 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3593 debug_assert_eq!(node.kind(), "conditional_expression");
3594 Ok(Self {
3595 span: ::treesitter_types::Span::from(node),
3596 alternative: {
3597 let child = node.child_by_field_name("alternative").ok_or_else(|| {
3598 ::treesitter_types::ParseError::missing_field("alternative", node)
3599 })?;
3600 ::treesitter_types::runtime::maybe_grow_stack(|| {
3601 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3602 })?
3603 },
3604 condition: {
3605 let child = node.child_by_field_name("condition").ok_or_else(|| {
3606 ::treesitter_types::ParseError::missing_field("condition", node)
3607 })?;
3608 ::treesitter_types::runtime::maybe_grow_stack(|| {
3609 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3610 })?
3611 },
3612 consequence: {
3613 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3614 ::treesitter_types::ParseError::missing_field("consequence", node)
3615 })?;
3616 ::treesitter_types::runtime::maybe_grow_stack(|| {
3617 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3618 })?
3619 },
3620 })
3621 }
3622}
3623impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
3624 fn span(&self) -> ::treesitter_types::Span {
3625 self.span
3626 }
3627}
3628#[derive(Debug, Clone, PartialEq, Eq)]
3629pub struct ConstantPattern<'tree> {
3630 pub span: ::treesitter_types::Span,
3631 pub children: ConstantPatternChildren<'tree>,
3632}
3633impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPattern<'tree> {
3634 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3635 fn from_node(
3636 node: ::treesitter_types::tree_sitter::Node<'tree>,
3637 src: &'tree [u8],
3638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3639 debug_assert_eq!(node.kind(), "constant_pattern");
3640 Ok(Self {
3641 span: ::treesitter_types::Span::from(node),
3642 children: {
3643 #[allow(clippy::suspicious_else_formatting)]
3644 let non_field_children = {
3645 let mut cursor = node.walk();
3646 let mut result = ::std::vec::Vec::new();
3647 if cursor.goto_first_child() {
3648 loop {
3649 if cursor.field_name().is_none()
3650 && cursor.node().is_named()
3651 && !cursor.node().is_extra()
3652 {
3653 result.push(cursor.node());
3654 }
3655 if !cursor.goto_next_sibling() {
3656 break;
3657 }
3658 }
3659 }
3660 result
3661 };
3662 let child = if let Some(&c) = non_field_children.first() {
3663 c
3664 } else {
3665 let mut fallback_cursor = node.walk();
3666 let mut fallback_child = None;
3667 if fallback_cursor.goto_first_child() {
3668 loop {
3669 if fallback_cursor.field_name().is_none()
3670 && !fallback_cursor.node().is_extra()
3671 {
3672 let candidate = fallback_cursor.node();
3673 #[allow(clippy::needless_question_mark)]
3674 if (|| -> ::core::result::Result<
3675 _,
3676 ::treesitter_types::ParseError,
3677 > {
3678 let child = candidate;
3679 Ok(
3680 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3681 child,
3682 src,
3683 ))?,
3684 )
3685 })()
3686 .is_ok()
3687 {
3688 fallback_child = Some(candidate);
3689 break;
3690 }
3691 }
3692 if !fallback_cursor.goto_next_sibling() {
3693 break;
3694 }
3695 }
3696 }
3697 if fallback_child.is_none() {
3698 let mut cursor2 = node.walk();
3699 if cursor2.goto_first_child() {
3700 loop {
3701 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3702 let candidate = cursor2.node();
3703 #[allow(clippy::needless_question_mark)]
3704 if (|| -> ::core::result::Result<
3705 _,
3706 ::treesitter_types::ParseError,
3707 > {
3708 let child = candidate;
3709 Ok(
3710 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3711 child,
3712 src,
3713 ))?,
3714 )
3715 })()
3716 .is_ok()
3717 {
3718 fallback_child = Some(candidate);
3719 break;
3720 }
3721 }
3722 if !cursor2.goto_next_sibling() {
3723 break;
3724 }
3725 }
3726 }
3727 }
3728 fallback_child.ok_or_else(|| {
3729 ::treesitter_types::ParseError::missing_field("children", node)
3730 })?
3731 };
3732 ::treesitter_types::runtime::maybe_grow_stack(|| {
3733 <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
3734 })?
3735 },
3736 })
3737 }
3738}
3739impl ::treesitter_types::Spanned for ConstantPattern<'_> {
3740 fn span(&self) -> ::treesitter_types::Span {
3741 self.span
3742 }
3743}
3744#[derive(Debug, Clone, PartialEq, Eq)]
3745pub struct ConstructorConstraint<'tree> {
3746 pub span: ::treesitter_types::Span,
3747 text: &'tree str,
3748}
3749impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorConstraint<'tree> {
3750 fn from_node(
3751 node: ::treesitter_types::tree_sitter::Node<'tree>,
3752 src: &'tree [u8],
3753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3754 debug_assert_eq!(node.kind(), "constructor_constraint");
3755 Ok(Self {
3756 span: ::treesitter_types::Span::from(node),
3757 text: node.utf8_text(src)?,
3758 })
3759 }
3760}
3761impl<'tree> ::treesitter_types::LeafNode<'tree> for ConstructorConstraint<'tree> {
3762 fn text(&self) -> &'tree str {
3763 self.text
3764 }
3765}
3766impl ::treesitter_types::Spanned for ConstructorConstraint<'_> {
3767 fn span(&self) -> ::treesitter_types::Span {
3768 self.span
3769 }
3770}
3771#[derive(Debug, Clone, PartialEq, Eq)]
3772pub struct ConstructorDeclaration<'tree> {
3773 pub span: ::treesitter_types::Span,
3774 pub body: ::core::option::Option<ConstructorDeclarationBody<'tree>>,
3775 pub name: Identifier<'tree>,
3776 pub parameters: ParameterList<'tree>,
3777 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
3778}
3779impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
3780 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3781 fn from_node(
3782 node: ::treesitter_types::tree_sitter::Node<'tree>,
3783 src: &'tree [u8],
3784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3785 debug_assert_eq!(node.kind(), "constructor_declaration");
3786 Ok(Self {
3787 span: ::treesitter_types::Span::from(node),
3788 body: match node.child_by_field_name("body") {
3789 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3790 <ConstructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
3791 child, src,
3792 )
3793 })?),
3794 None => None,
3795 },
3796 name: {
3797 let child = node
3798 .child_by_field_name("name")
3799 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3800 ::treesitter_types::runtime::maybe_grow_stack(|| {
3801 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3802 })?
3803 },
3804 parameters: {
3805 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3806 ::treesitter_types::ParseError::missing_field("parameters", node)
3807 })?;
3808 ::treesitter_types::runtime::maybe_grow_stack(|| {
3809 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
3810 })?
3811 },
3812 children: {
3813 #[allow(clippy::suspicious_else_formatting)]
3814 let non_field_children = {
3815 let mut cursor = node.walk();
3816 let mut result = ::std::vec::Vec::new();
3817 if cursor.goto_first_child() {
3818 loop {
3819 if cursor.field_name().is_none()
3820 && cursor.node().is_named()
3821 && !cursor.node().is_extra()
3822 {
3823 result.push(cursor.node());
3824 }
3825 if !cursor.goto_next_sibling() {
3826 break;
3827 }
3828 }
3829 }
3830 result
3831 };
3832 let mut items = ::std::vec::Vec::new();
3833 for child in non_field_children {
3834 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3835 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3836 child, src,
3837 )
3838 })?);
3839 }
3840 items
3841 },
3842 })
3843 }
3844}
3845impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
3846 fn span(&self) -> ::treesitter_types::Span {
3847 self.span
3848 }
3849}
3850#[derive(Debug, Clone, PartialEq, Eq)]
3851pub struct ConstructorInitializer<'tree> {
3852 pub span: ::treesitter_types::Span,
3853 pub children: ArgumentList<'tree>,
3854}
3855impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorInitializer<'tree> {
3856 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3857 fn from_node(
3858 node: ::treesitter_types::tree_sitter::Node<'tree>,
3859 src: &'tree [u8],
3860 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3861 debug_assert_eq!(node.kind(), "constructor_initializer");
3862 Ok(Self {
3863 span: ::treesitter_types::Span::from(node),
3864 children: {
3865 #[allow(clippy::suspicious_else_formatting)]
3866 let non_field_children = {
3867 let mut cursor = node.walk();
3868 let mut result = ::std::vec::Vec::new();
3869 if cursor.goto_first_child() {
3870 loop {
3871 if cursor.field_name().is_none()
3872 && cursor.node().is_named()
3873 && !cursor.node().is_extra()
3874 {
3875 result.push(cursor.node());
3876 }
3877 if !cursor.goto_next_sibling() {
3878 break;
3879 }
3880 }
3881 }
3882 result
3883 };
3884 let child = if let Some(&c) = non_field_children.first() {
3885 c
3886 } else {
3887 let mut fallback_cursor = node.walk();
3888 let mut fallback_child = None;
3889 if fallback_cursor.goto_first_child() {
3890 loop {
3891 if fallback_cursor.field_name().is_none()
3892 && !fallback_cursor.node().is_extra()
3893 {
3894 let candidate = fallback_cursor.node();
3895 #[allow(clippy::needless_question_mark)]
3896 if (|| -> ::core::result::Result<
3897 _,
3898 ::treesitter_types::ParseError,
3899 > {
3900 let child = candidate;
3901 Ok(
3902 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
3903 child,
3904 src,
3905 ))?,
3906 )
3907 })()
3908 .is_ok()
3909 {
3910 fallback_child = Some(candidate);
3911 break;
3912 }
3913 }
3914 if !fallback_cursor.goto_next_sibling() {
3915 break;
3916 }
3917 }
3918 }
3919 if fallback_child.is_none() {
3920 let mut cursor2 = node.walk();
3921 if cursor2.goto_first_child() {
3922 loop {
3923 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3924 let candidate = cursor2.node();
3925 #[allow(clippy::needless_question_mark)]
3926 if (|| -> ::core::result::Result<
3927 _,
3928 ::treesitter_types::ParseError,
3929 > {
3930 let child = candidate;
3931 Ok(
3932 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
3933 child,
3934 src,
3935 ))?,
3936 )
3937 })()
3938 .is_ok()
3939 {
3940 fallback_child = Some(candidate);
3941 break;
3942 }
3943 }
3944 if !cursor2.goto_next_sibling() {
3945 break;
3946 }
3947 }
3948 }
3949 }
3950 fallback_child.ok_or_else(|| {
3951 ::treesitter_types::ParseError::missing_field("children", node)
3952 })?
3953 };
3954 ::treesitter_types::runtime::maybe_grow_stack(|| {
3955 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
3956 })?
3957 },
3958 })
3959 }
3960}
3961impl ::treesitter_types::Spanned for ConstructorInitializer<'_> {
3962 fn span(&self) -> ::treesitter_types::Span {
3963 self.span
3964 }
3965}
3966#[derive(Debug, Clone, PartialEq, Eq)]
3967pub struct ContinueStatement<'tree> {
3968 pub span: ::treesitter_types::Span,
3969 text: &'tree str,
3970}
3971impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
3972 fn from_node(
3973 node: ::treesitter_types::tree_sitter::Node<'tree>,
3974 src: &'tree [u8],
3975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3976 debug_assert_eq!(node.kind(), "continue_statement");
3977 Ok(Self {
3978 span: ::treesitter_types::Span::from(node),
3979 text: node.utf8_text(src)?,
3980 })
3981 }
3982}
3983impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
3984 fn text(&self) -> &'tree str {
3985 self.text
3986 }
3987}
3988impl ::treesitter_types::Spanned for ContinueStatement<'_> {
3989 fn span(&self) -> ::treesitter_types::Span {
3990 self.span
3991 }
3992}
3993#[derive(Debug, Clone, PartialEq, Eq)]
3994pub struct ConversionOperatorDeclaration<'tree> {
3995 pub span: ::treesitter_types::Span,
3996 pub body: ::core::option::Option<ConversionOperatorDeclarationBody<'tree>>,
3997 pub parameters: ParameterList<'tree>,
3998 pub r#type: Type<'tree>,
3999 pub children: ::std::vec::Vec<ConversionOperatorDeclarationChildren<'tree>>,
4000}
4001impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclaration<'tree> {
4002 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4003 fn from_node(
4004 node: ::treesitter_types::tree_sitter::Node<'tree>,
4005 src: &'tree [u8],
4006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4007 debug_assert_eq!(node.kind(), "conversion_operator_declaration");
4008 Ok(Self {
4009 span: ::treesitter_types::Span::from(node),
4010 body: match node.child_by_field_name("body") {
4011 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4012 <ConversionOperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4013 child, src,
4014 )
4015 })?),
4016 None => None,
4017 },
4018 parameters: {
4019 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4020 ::treesitter_types::ParseError::missing_field("parameters", node)
4021 })?;
4022 ::treesitter_types::runtime::maybe_grow_stack(|| {
4023 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4024 })?
4025 },
4026 r#type: {
4027 let child = node
4028 .child_by_field_name("type")
4029 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4030 ::treesitter_types::runtime::maybe_grow_stack(|| {
4031 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4032 })?
4033 },
4034 children: {
4035 #[allow(clippy::suspicious_else_formatting)]
4036 let non_field_children = {
4037 let mut cursor = node.walk();
4038 let mut result = ::std::vec::Vec::new();
4039 if cursor.goto_first_child() {
4040 loop {
4041 if cursor.field_name().is_none()
4042 && cursor.node().is_named()
4043 && !cursor.node().is_extra()
4044 {
4045 result.push(cursor.node());
4046 }
4047 if !cursor.goto_next_sibling() {
4048 break;
4049 }
4050 }
4051 }
4052 result
4053 };
4054 let mut items = ::std::vec::Vec::new();
4055 for child in non_field_children {
4056 items
4057 .push(
4058 ::treesitter_types::runtime::maybe_grow_stack(|| <ConversionOperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4059 child,
4060 src,
4061 ))?,
4062 );
4063 }
4064 items
4065 },
4066 })
4067 }
4068}
4069impl ::treesitter_types::Spanned for ConversionOperatorDeclaration<'_> {
4070 fn span(&self) -> ::treesitter_types::Span {
4071 self.span
4072 }
4073}
4074#[derive(Debug, Clone, PartialEq, Eq)]
4075pub struct DeclarationExpression<'tree> {
4076 pub span: ::treesitter_types::Span,
4077 pub name: Identifier<'tree>,
4078 pub r#type: Type<'tree>,
4079}
4080impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationExpression<'tree> {
4081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4082 fn from_node(
4083 node: ::treesitter_types::tree_sitter::Node<'tree>,
4084 src: &'tree [u8],
4085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4086 debug_assert_eq!(node.kind(), "declaration_expression");
4087 Ok(Self {
4088 span: ::treesitter_types::Span::from(node),
4089 name: {
4090 let child = node
4091 .child_by_field_name("name")
4092 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4093 ::treesitter_types::runtime::maybe_grow_stack(|| {
4094 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4095 })?
4096 },
4097 r#type: {
4098 let child = node
4099 .child_by_field_name("type")
4100 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4101 ::treesitter_types::runtime::maybe_grow_stack(|| {
4102 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4103 })?
4104 },
4105 })
4106 }
4107}
4108impl ::treesitter_types::Spanned for DeclarationExpression<'_> {
4109 fn span(&self) -> ::treesitter_types::Span {
4110 self.span
4111 }
4112}
4113#[derive(Debug, Clone, PartialEq, Eq)]
4114pub struct DeclarationList<'tree> {
4115 pub span: ::treesitter_types::Span,
4116 pub children: ::std::vec::Vec<Declaration<'tree>>,
4117}
4118impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
4119 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4120 fn from_node(
4121 node: ::treesitter_types::tree_sitter::Node<'tree>,
4122 src: &'tree [u8],
4123 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4124 debug_assert_eq!(node.kind(), "declaration_list");
4125 Ok(Self {
4126 span: ::treesitter_types::Span::from(node),
4127 children: {
4128 #[allow(clippy::suspicious_else_formatting)]
4129 let non_field_children = {
4130 let mut cursor = node.walk();
4131 let mut result = ::std::vec::Vec::new();
4132 if cursor.goto_first_child() {
4133 loop {
4134 if cursor.field_name().is_none()
4135 && cursor.node().is_named()
4136 && !cursor.node().is_extra()
4137 {
4138 result.push(cursor.node());
4139 }
4140 if !cursor.goto_next_sibling() {
4141 break;
4142 }
4143 }
4144 }
4145 result
4146 };
4147 let mut items = ::std::vec::Vec::new();
4148 for child in non_field_children {
4149 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4150 <Declaration as ::treesitter_types::FromNode>::from_node(child, src)
4151 })?);
4152 }
4153 items
4154 },
4155 })
4156 }
4157}
4158impl ::treesitter_types::Spanned for DeclarationList<'_> {
4159 fn span(&self) -> ::treesitter_types::Span {
4160 self.span
4161 }
4162}
4163#[derive(Debug, Clone, PartialEq, Eq)]
4164pub struct DeclarationPattern<'tree> {
4165 pub span: ::treesitter_types::Span,
4166 pub name: ::core::option::Option<Identifier<'tree>>,
4167 pub r#type: Type<'tree>,
4168 pub children: ::core::option::Option<DeclarationPatternChildren<'tree>>,
4169}
4170impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPattern<'tree> {
4171 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4172 fn from_node(
4173 node: ::treesitter_types::tree_sitter::Node<'tree>,
4174 src: &'tree [u8],
4175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4176 debug_assert_eq!(node.kind(), "declaration_pattern");
4177 Ok(Self {
4178 span: ::treesitter_types::Span::from(node),
4179 name: match node.child_by_field_name("name") {
4180 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4181 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4182 })?),
4183 None => None,
4184 },
4185 r#type: {
4186 let child = node
4187 .child_by_field_name("type")
4188 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4189 ::treesitter_types::runtime::maybe_grow_stack(|| {
4190 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4191 })?
4192 },
4193 children: {
4194 #[allow(clippy::suspicious_else_formatting)]
4195 let non_field_children = {
4196 let mut cursor = node.walk();
4197 let mut result = ::std::vec::Vec::new();
4198 if cursor.goto_first_child() {
4199 loop {
4200 if cursor.field_name().is_none()
4201 && cursor.node().is_named()
4202 && !cursor.node().is_extra()
4203 {
4204 result.push(cursor.node());
4205 }
4206 if !cursor.goto_next_sibling() {
4207 break;
4208 }
4209 }
4210 }
4211 result
4212 };
4213 match non_field_children.first() {
4214 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4215 <DeclarationPatternChildren as ::treesitter_types::FromNode>::from_node(
4216 child, src,
4217 )
4218 })?),
4219 None => None,
4220 }
4221 },
4222 })
4223 }
4224}
4225impl ::treesitter_types::Spanned for DeclarationPattern<'_> {
4226 fn span(&self) -> ::treesitter_types::Span {
4227 self.span
4228 }
4229}
4230#[derive(Debug, Clone, PartialEq, Eq)]
4231pub struct DefaultExpression<'tree> {
4232 pub span: ::treesitter_types::Span,
4233 pub r#type: ::core::option::Option<Type<'tree>>,
4234}
4235impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultExpression<'tree> {
4236 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4237 fn from_node(
4238 node: ::treesitter_types::tree_sitter::Node<'tree>,
4239 src: &'tree [u8],
4240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4241 debug_assert_eq!(node.kind(), "default_expression");
4242 Ok(Self {
4243 span: ::treesitter_types::Span::from(node),
4244 r#type: match node.child_by_field_name("type") {
4245 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4246 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4247 })?),
4248 None => None,
4249 },
4250 })
4251 }
4252}
4253impl ::treesitter_types::Spanned for DefaultExpression<'_> {
4254 fn span(&self) -> ::treesitter_types::Span {
4255 self.span
4256 }
4257}
4258#[derive(Debug, Clone, PartialEq, Eq)]
4259pub struct DelegateDeclaration<'tree> {
4260 pub span: ::treesitter_types::Span,
4261 pub name: Identifier<'tree>,
4262 pub parameters: ParameterList<'tree>,
4263 pub r#type: Type<'tree>,
4264 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
4265 pub children: ::std::vec::Vec<DelegateDeclarationChildren<'tree>>,
4266}
4267impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclaration<'tree> {
4268 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4269 fn from_node(
4270 node: ::treesitter_types::tree_sitter::Node<'tree>,
4271 src: &'tree [u8],
4272 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4273 debug_assert_eq!(node.kind(), "delegate_declaration");
4274 Ok(Self {
4275 span: ::treesitter_types::Span::from(node),
4276 name: {
4277 let child = node
4278 .child_by_field_name("name")
4279 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4280 ::treesitter_types::runtime::maybe_grow_stack(|| {
4281 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4282 })?
4283 },
4284 parameters: {
4285 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4286 ::treesitter_types::ParseError::missing_field("parameters", node)
4287 })?;
4288 ::treesitter_types::runtime::maybe_grow_stack(|| {
4289 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4290 })?
4291 },
4292 r#type: {
4293 let child = node
4294 .child_by_field_name("type")
4295 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4296 ::treesitter_types::runtime::maybe_grow_stack(|| {
4297 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4298 })?
4299 },
4300 type_parameters: match node.child_by_field_name("type_parameters") {
4301 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4302 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4303 })?),
4304 None => None,
4305 },
4306 children: {
4307 #[allow(clippy::suspicious_else_formatting)]
4308 let non_field_children = {
4309 let mut cursor = node.walk();
4310 let mut result = ::std::vec::Vec::new();
4311 if cursor.goto_first_child() {
4312 loop {
4313 if cursor.field_name().is_none()
4314 && cursor.node().is_named()
4315 && !cursor.node().is_extra()
4316 {
4317 result.push(cursor.node());
4318 }
4319 if !cursor.goto_next_sibling() {
4320 break;
4321 }
4322 }
4323 }
4324 result
4325 };
4326 let mut items = ::std::vec::Vec::new();
4327 for child in non_field_children {
4328 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4329 <DelegateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4330 child, src,
4331 )
4332 })?);
4333 }
4334 items
4335 },
4336 })
4337 }
4338}
4339impl ::treesitter_types::Spanned for DelegateDeclaration<'_> {
4340 fn span(&self) -> ::treesitter_types::Span {
4341 self.span
4342 }
4343}
4344#[derive(Debug, Clone, PartialEq, Eq)]
4345pub struct DestructorDeclaration<'tree> {
4346 pub span: ::treesitter_types::Span,
4347 pub body: ::core::option::Option<DestructorDeclarationBody<'tree>>,
4348 pub name: Identifier<'tree>,
4349 pub parameters: ParameterList<'tree>,
4350 pub children: ::std::vec::Vec<AttributeList<'tree>>,
4351}
4352impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclaration<'tree> {
4353 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4354 fn from_node(
4355 node: ::treesitter_types::tree_sitter::Node<'tree>,
4356 src: &'tree [u8],
4357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4358 debug_assert_eq!(node.kind(), "destructor_declaration");
4359 Ok(Self {
4360 span: ::treesitter_types::Span::from(node),
4361 body: match node.child_by_field_name("body") {
4362 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4363 <DestructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4364 child, src,
4365 )
4366 })?),
4367 None => None,
4368 },
4369 name: {
4370 let child = node
4371 .child_by_field_name("name")
4372 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4373 ::treesitter_types::runtime::maybe_grow_stack(|| {
4374 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4375 })?
4376 },
4377 parameters: {
4378 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4379 ::treesitter_types::ParseError::missing_field("parameters", node)
4380 })?;
4381 ::treesitter_types::runtime::maybe_grow_stack(|| {
4382 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4383 })?
4384 },
4385 children: {
4386 #[allow(clippy::suspicious_else_formatting)]
4387 let non_field_children = {
4388 let mut cursor = node.walk();
4389 let mut result = ::std::vec::Vec::new();
4390 if cursor.goto_first_child() {
4391 loop {
4392 if cursor.field_name().is_none()
4393 && cursor.node().is_named()
4394 && !cursor.node().is_extra()
4395 {
4396 result.push(cursor.node());
4397 }
4398 if !cursor.goto_next_sibling() {
4399 break;
4400 }
4401 }
4402 }
4403 result
4404 };
4405 let mut items = ::std::vec::Vec::new();
4406 for child in non_field_children {
4407 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4408 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
4409 })?);
4410 }
4411 items
4412 },
4413 })
4414 }
4415}
4416impl ::treesitter_types::Spanned for DestructorDeclaration<'_> {
4417 fn span(&self) -> ::treesitter_types::Span {
4418 self.span
4419 }
4420}
4421#[derive(Debug, Clone, PartialEq, Eq)]
4422pub struct DoStatement<'tree> {
4423 pub span: ::treesitter_types::Span,
4424 pub body: Statement<'tree>,
4425 pub condition: Expression<'tree>,
4426}
4427impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
4428 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4429 fn from_node(
4430 node: ::treesitter_types::tree_sitter::Node<'tree>,
4431 src: &'tree [u8],
4432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4433 debug_assert_eq!(node.kind(), "do_statement");
4434 Ok(Self {
4435 span: ::treesitter_types::Span::from(node),
4436 body: {
4437 let child = node
4438 .child_by_field_name("body")
4439 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4440 ::treesitter_types::runtime::maybe_grow_stack(|| {
4441 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4442 })?
4443 },
4444 condition: {
4445 let child = node.child_by_field_name("condition").ok_or_else(|| {
4446 ::treesitter_types::ParseError::missing_field("condition", node)
4447 })?;
4448 ::treesitter_types::runtime::maybe_grow_stack(|| {
4449 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4450 })?
4451 },
4452 })
4453 }
4454}
4455impl ::treesitter_types::Spanned for DoStatement<'_> {
4456 fn span(&self) -> ::treesitter_types::Span {
4457 self.span
4458 }
4459}
4460#[derive(Debug, Clone, PartialEq, Eq)]
4461pub struct ElementAccessExpression<'tree> {
4462 pub span: ::treesitter_types::Span,
4463 pub expression: Expression<'tree>,
4464 pub subscript: BracketedArgumentList<'tree>,
4465}
4466impl<'tree> ::treesitter_types::FromNode<'tree> for ElementAccessExpression<'tree> {
4467 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4468 fn from_node(
4469 node: ::treesitter_types::tree_sitter::Node<'tree>,
4470 src: &'tree [u8],
4471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4472 debug_assert_eq!(node.kind(), "element_access_expression");
4473 Ok(Self {
4474 span: ::treesitter_types::Span::from(node),
4475 expression: {
4476 let child = node.child_by_field_name("expression").ok_or_else(|| {
4477 ::treesitter_types::ParseError::missing_field("expression", node)
4478 })?;
4479 ::treesitter_types::runtime::maybe_grow_stack(|| {
4480 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4481 })?
4482 },
4483 subscript: {
4484 let child = node.child_by_field_name("subscript").ok_or_else(|| {
4485 ::treesitter_types::ParseError::missing_field("subscript", node)
4486 })?;
4487 ::treesitter_types::runtime::maybe_grow_stack(|| {
4488 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4489 })?
4490 },
4491 })
4492 }
4493}
4494impl ::treesitter_types::Spanned for ElementAccessExpression<'_> {
4495 fn span(&self) -> ::treesitter_types::Span {
4496 self.span
4497 }
4498}
4499#[derive(Debug, Clone, PartialEq, Eq)]
4500pub struct ElementBindingExpression<'tree> {
4501 pub span: ::treesitter_types::Span,
4502 pub children: ::std::vec::Vec<Argument<'tree>>,
4503}
4504impl<'tree> ::treesitter_types::FromNode<'tree> for ElementBindingExpression<'tree> {
4505 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4506 fn from_node(
4507 node: ::treesitter_types::tree_sitter::Node<'tree>,
4508 src: &'tree [u8],
4509 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4510 debug_assert_eq!(node.kind(), "element_binding_expression");
4511 Ok(Self {
4512 span: ::treesitter_types::Span::from(node),
4513 children: {
4514 #[allow(clippy::suspicious_else_formatting)]
4515 let non_field_children = {
4516 let mut cursor = node.walk();
4517 let mut result = ::std::vec::Vec::new();
4518 if cursor.goto_first_child() {
4519 loop {
4520 if cursor.field_name().is_none()
4521 && cursor.node().is_named()
4522 && !cursor.node().is_extra()
4523 {
4524 result.push(cursor.node());
4525 }
4526 if !cursor.goto_next_sibling() {
4527 break;
4528 }
4529 }
4530 }
4531 result
4532 };
4533 let mut items = ::std::vec::Vec::new();
4534 for child in non_field_children {
4535 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4536 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
4537 })?);
4538 }
4539 items
4540 },
4541 })
4542 }
4543}
4544impl ::treesitter_types::Spanned for ElementBindingExpression<'_> {
4545 fn span(&self) -> ::treesitter_types::Span {
4546 self.span
4547 }
4548}
4549#[derive(Debug, Clone, PartialEq, Eq)]
4550pub struct EmptyStatement<'tree> {
4551 pub span: ::treesitter_types::Span,
4552 text: &'tree str,
4553}
4554impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
4555 fn from_node(
4556 node: ::treesitter_types::tree_sitter::Node<'tree>,
4557 src: &'tree [u8],
4558 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4559 debug_assert_eq!(node.kind(), "empty_statement");
4560 Ok(Self {
4561 span: ::treesitter_types::Span::from(node),
4562 text: node.utf8_text(src)?,
4563 })
4564 }
4565}
4566impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
4567 fn text(&self) -> &'tree str {
4568 self.text
4569 }
4570}
4571impl ::treesitter_types::Spanned for EmptyStatement<'_> {
4572 fn span(&self) -> ::treesitter_types::Span {
4573 self.span
4574 }
4575}
4576#[derive(Debug, Clone, PartialEq, Eq)]
4577pub struct EnumDeclaration<'tree> {
4578 pub span: ::treesitter_types::Span,
4579 pub body: EnumMemberDeclarationList<'tree>,
4580 pub name: Identifier<'tree>,
4581 pub children: ::std::vec::Vec<EnumDeclarationChildren<'tree>>,
4582}
4583impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
4584 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4585 fn from_node(
4586 node: ::treesitter_types::tree_sitter::Node<'tree>,
4587 src: &'tree [u8],
4588 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4589 debug_assert_eq!(node.kind(), "enum_declaration");
4590 Ok(Self {
4591 span: ::treesitter_types::Span::from(node),
4592 body: {
4593 let child = node
4594 .child_by_field_name("body")
4595 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4596 ::treesitter_types::runtime::maybe_grow_stack(|| {
4597 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(
4598 child, src,
4599 )
4600 })?
4601 },
4602 name: {
4603 let child = node
4604 .child_by_field_name("name")
4605 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4606 ::treesitter_types::runtime::maybe_grow_stack(|| {
4607 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4608 })?
4609 },
4610 children: {
4611 #[allow(clippy::suspicious_else_formatting)]
4612 let non_field_children = {
4613 let mut cursor = node.walk();
4614 let mut result = ::std::vec::Vec::new();
4615 if cursor.goto_first_child() {
4616 loop {
4617 if cursor.field_name().is_none()
4618 && cursor.node().is_named()
4619 && !cursor.node().is_extra()
4620 {
4621 result.push(cursor.node());
4622 }
4623 if !cursor.goto_next_sibling() {
4624 break;
4625 }
4626 }
4627 }
4628 result
4629 };
4630 let mut items = ::std::vec::Vec::new();
4631 for child in non_field_children {
4632 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4633 <EnumDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4634 child, src,
4635 )
4636 })?);
4637 }
4638 items
4639 },
4640 })
4641 }
4642}
4643impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
4644 fn span(&self) -> ::treesitter_types::Span {
4645 self.span
4646 }
4647}
4648#[derive(Debug, Clone, PartialEq, Eq)]
4649pub struct EnumMemberDeclaration<'tree> {
4650 pub span: ::treesitter_types::Span,
4651 pub name: Identifier<'tree>,
4652 pub value: ::core::option::Option<Expression<'tree>>,
4653 pub children: ::std::vec::Vec<AttributeList<'tree>>,
4654}
4655impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclaration<'tree> {
4656 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4657 fn from_node(
4658 node: ::treesitter_types::tree_sitter::Node<'tree>,
4659 src: &'tree [u8],
4660 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4661 debug_assert_eq!(node.kind(), "enum_member_declaration");
4662 Ok(Self {
4663 span: ::treesitter_types::Span::from(node),
4664 name: {
4665 let child = node
4666 .child_by_field_name("name")
4667 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4668 ::treesitter_types::runtime::maybe_grow_stack(|| {
4669 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4670 })?
4671 },
4672 value: match node.child_by_field_name("value") {
4673 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4674 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4675 })?),
4676 None => None,
4677 },
4678 children: {
4679 #[allow(clippy::suspicious_else_formatting)]
4680 let non_field_children = {
4681 let mut cursor = node.walk();
4682 let mut result = ::std::vec::Vec::new();
4683 if cursor.goto_first_child() {
4684 loop {
4685 if cursor.field_name().is_none()
4686 && cursor.node().is_named()
4687 && !cursor.node().is_extra()
4688 {
4689 result.push(cursor.node());
4690 }
4691 if !cursor.goto_next_sibling() {
4692 break;
4693 }
4694 }
4695 }
4696 result
4697 };
4698 let mut items = ::std::vec::Vec::new();
4699 for child in non_field_children {
4700 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4701 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
4702 })?);
4703 }
4704 items
4705 },
4706 })
4707 }
4708}
4709impl ::treesitter_types::Spanned for EnumMemberDeclaration<'_> {
4710 fn span(&self) -> ::treesitter_types::Span {
4711 self.span
4712 }
4713}
4714#[derive(Debug, Clone, PartialEq, Eq)]
4715pub struct EnumMemberDeclarationList<'tree> {
4716 pub span: ::treesitter_types::Span,
4717 pub children: ::std::vec::Vec<EnumMemberDeclarationListChildren<'tree>>,
4718}
4719impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationList<'tree> {
4720 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4721 fn from_node(
4722 node: ::treesitter_types::tree_sitter::Node<'tree>,
4723 src: &'tree [u8],
4724 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4725 debug_assert_eq!(node.kind(), "enum_member_declaration_list");
4726 Ok(Self {
4727 span: ::treesitter_types::Span::from(node),
4728 children: {
4729 #[allow(clippy::suspicious_else_formatting)]
4730 let non_field_children = {
4731 let mut cursor = node.walk();
4732 let mut result = ::std::vec::Vec::new();
4733 if cursor.goto_first_child() {
4734 loop {
4735 if cursor.field_name().is_none()
4736 && cursor.node().is_named()
4737 && !cursor.node().is_extra()
4738 {
4739 result.push(cursor.node());
4740 }
4741 if !cursor.goto_next_sibling() {
4742 break;
4743 }
4744 }
4745 }
4746 result
4747 };
4748 let mut items = ::std::vec::Vec::new();
4749 for child in non_field_children {
4750 items
4751 .push(
4752 ::treesitter_types::runtime::maybe_grow_stack(|| <EnumMemberDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
4753 child,
4754 src,
4755 ))?,
4756 );
4757 }
4758 items
4759 },
4760 })
4761 }
4762}
4763impl ::treesitter_types::Spanned for EnumMemberDeclarationList<'_> {
4764 fn span(&self) -> ::treesitter_types::Span {
4765 self.span
4766 }
4767}
4768#[derive(Debug, Clone, PartialEq, Eq)]
4769pub struct EventDeclaration<'tree> {
4770 pub span: ::treesitter_types::Span,
4771 pub accessors: ::core::option::Option<AccessorList<'tree>>,
4772 pub name: Identifier<'tree>,
4773 pub r#type: Type<'tree>,
4774 pub children: ::std::vec::Vec<EventDeclarationChildren<'tree>>,
4775}
4776impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclaration<'tree> {
4777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4778 fn from_node(
4779 node: ::treesitter_types::tree_sitter::Node<'tree>,
4780 src: &'tree [u8],
4781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4782 debug_assert_eq!(node.kind(), "event_declaration");
4783 Ok(Self {
4784 span: ::treesitter_types::Span::from(node),
4785 accessors: match node.child_by_field_name("accessors") {
4786 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4787 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
4788 })?),
4789 None => None,
4790 },
4791 name: {
4792 let child = node
4793 .child_by_field_name("name")
4794 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4795 ::treesitter_types::runtime::maybe_grow_stack(|| {
4796 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4797 })?
4798 },
4799 r#type: {
4800 let child = node
4801 .child_by_field_name("type")
4802 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4803 ::treesitter_types::runtime::maybe_grow_stack(|| {
4804 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4805 })?
4806 },
4807 children: {
4808 #[allow(clippy::suspicious_else_formatting)]
4809 let non_field_children = {
4810 let mut cursor = node.walk();
4811 let mut result = ::std::vec::Vec::new();
4812 if cursor.goto_first_child() {
4813 loop {
4814 if cursor.field_name().is_none()
4815 && cursor.node().is_named()
4816 && !cursor.node().is_extra()
4817 {
4818 result.push(cursor.node());
4819 }
4820 if !cursor.goto_next_sibling() {
4821 break;
4822 }
4823 }
4824 }
4825 result
4826 };
4827 let mut items = ::std::vec::Vec::new();
4828 for child in non_field_children {
4829 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4830 <EventDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4831 child, src,
4832 )
4833 })?);
4834 }
4835 items
4836 },
4837 })
4838 }
4839}
4840impl ::treesitter_types::Spanned for EventDeclaration<'_> {
4841 fn span(&self) -> ::treesitter_types::Span {
4842 self.span
4843 }
4844}
4845#[derive(Debug, Clone, PartialEq, Eq)]
4846pub struct EventFieldDeclaration<'tree> {
4847 pub span: ::treesitter_types::Span,
4848 pub children: ::std::vec::Vec<EventFieldDeclarationChildren<'tree>>,
4849}
4850impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclaration<'tree> {
4851 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4852 fn from_node(
4853 node: ::treesitter_types::tree_sitter::Node<'tree>,
4854 src: &'tree [u8],
4855 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4856 debug_assert_eq!(node.kind(), "event_field_declaration");
4857 Ok(Self {
4858 span: ::treesitter_types::Span::from(node),
4859 children: {
4860 #[allow(clippy::suspicious_else_formatting)]
4861 let non_field_children = {
4862 let mut cursor = node.walk();
4863 let mut result = ::std::vec::Vec::new();
4864 if cursor.goto_first_child() {
4865 loop {
4866 if cursor.field_name().is_none()
4867 && cursor.node().is_named()
4868 && !cursor.node().is_extra()
4869 {
4870 result.push(cursor.node());
4871 }
4872 if !cursor.goto_next_sibling() {
4873 break;
4874 }
4875 }
4876 }
4877 result
4878 };
4879 let mut items = ::std::vec::Vec::new();
4880 for child in non_field_children {
4881 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4882 <EventFieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4883 child, src,
4884 )
4885 })?);
4886 }
4887 items
4888 },
4889 })
4890 }
4891}
4892impl ::treesitter_types::Spanned for EventFieldDeclaration<'_> {
4893 fn span(&self) -> ::treesitter_types::Span {
4894 self.span
4895 }
4896}
4897#[derive(Debug, Clone, PartialEq, Eq)]
4898pub struct ExplicitInterfaceSpecifier<'tree> {
4899 pub span: ::treesitter_types::Span,
4900 pub children: ExplicitInterfaceSpecifierChildren<'tree>,
4901}
4902impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifier<'tree> {
4903 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4904 fn from_node(
4905 node: ::treesitter_types::tree_sitter::Node<'tree>,
4906 src: &'tree [u8],
4907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4908 debug_assert_eq!(node.kind(), "explicit_interface_specifier");
4909 Ok(Self {
4910 span: ::treesitter_types::Span::from(node),
4911 children: {
4912 #[allow(clippy::suspicious_else_formatting)]
4913 let non_field_children = {
4914 let mut cursor = node.walk();
4915 let mut result = ::std::vec::Vec::new();
4916 if cursor.goto_first_child() {
4917 loop {
4918 if cursor.field_name().is_none()
4919 && cursor.node().is_named()
4920 && !cursor.node().is_extra()
4921 {
4922 result.push(cursor.node());
4923 }
4924 if !cursor.goto_next_sibling() {
4925 break;
4926 }
4927 }
4928 }
4929 result
4930 };
4931 let child = if let Some(&c) = non_field_children.first() {
4932 c
4933 } else {
4934 let mut fallback_cursor = node.walk();
4935 let mut fallback_child = None;
4936 if fallback_cursor.goto_first_child() {
4937 loop {
4938 if fallback_cursor.field_name().is_none()
4939 && !fallback_cursor.node().is_extra()
4940 {
4941 let candidate = fallback_cursor.node();
4942 #[allow(clippy::needless_question_mark)]
4943 if (|| -> ::core::result::Result<
4944 _,
4945 ::treesitter_types::ParseError,
4946 > {
4947 let child = candidate;
4948 Ok(
4949 ::treesitter_types::runtime::maybe_grow_stack(|| <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
4950 child,
4951 src,
4952 ))?,
4953 )
4954 })()
4955 .is_ok()
4956 {
4957 fallback_child = Some(candidate);
4958 break;
4959 }
4960 }
4961 if !fallback_cursor.goto_next_sibling() {
4962 break;
4963 }
4964 }
4965 }
4966 if fallback_child.is_none() {
4967 let mut cursor2 = node.walk();
4968 if cursor2.goto_first_child() {
4969 loop {
4970 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4971 let candidate = cursor2.node();
4972 #[allow(clippy::needless_question_mark)]
4973 if (|| -> ::core::result::Result<
4974 _,
4975 ::treesitter_types::ParseError,
4976 > {
4977 let child = candidate;
4978 Ok(
4979 ::treesitter_types::runtime::maybe_grow_stack(|| <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
4980 child,
4981 src,
4982 ))?,
4983 )
4984 })()
4985 .is_ok()
4986 {
4987 fallback_child = Some(candidate);
4988 break;
4989 }
4990 }
4991 if !cursor2.goto_next_sibling() {
4992 break;
4993 }
4994 }
4995 }
4996 }
4997 fallback_child.ok_or_else(|| {
4998 ::treesitter_types::ParseError::missing_field("children", node)
4999 })?
5000 };
5001 ::treesitter_types::runtime::maybe_grow_stack(|| {
5002 <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
5003 child, src,
5004 )
5005 })?
5006 },
5007 })
5008 }
5009}
5010impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifier<'_> {
5011 fn span(&self) -> ::treesitter_types::Span {
5012 self.span
5013 }
5014}
5015#[derive(Debug, Clone, PartialEq, Eq)]
5016pub struct ExpressionStatement<'tree> {
5017 pub span: ::treesitter_types::Span,
5018 pub children: ExpressionStatementChildren<'tree>,
5019}
5020impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
5021 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5022 fn from_node(
5023 node: ::treesitter_types::tree_sitter::Node<'tree>,
5024 src: &'tree [u8],
5025 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5026 debug_assert_eq!(node.kind(), "expression_statement");
5027 Ok(Self {
5028 span: ::treesitter_types::Span::from(node),
5029 children: {
5030 #[allow(clippy::suspicious_else_formatting)]
5031 let non_field_children = {
5032 let mut cursor = node.walk();
5033 let mut result = ::std::vec::Vec::new();
5034 if cursor.goto_first_child() {
5035 loop {
5036 if cursor.field_name().is_none()
5037 && cursor.node().is_named()
5038 && !cursor.node().is_extra()
5039 {
5040 result.push(cursor.node());
5041 }
5042 if !cursor.goto_next_sibling() {
5043 break;
5044 }
5045 }
5046 }
5047 result
5048 };
5049 let child = if let Some(&c) = non_field_children.first() {
5050 c
5051 } else {
5052 let mut fallback_cursor = node.walk();
5053 let mut fallback_child = None;
5054 if fallback_cursor.goto_first_child() {
5055 loop {
5056 if fallback_cursor.field_name().is_none()
5057 && !fallback_cursor.node().is_extra()
5058 {
5059 let candidate = fallback_cursor.node();
5060 #[allow(clippy::needless_question_mark)]
5061 if (|| -> ::core::result::Result<
5062 _,
5063 ::treesitter_types::ParseError,
5064 > {
5065 let child = candidate;
5066 Ok(
5067 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5068 child,
5069 src,
5070 ))?,
5071 )
5072 })()
5073 .is_ok()
5074 {
5075 fallback_child = Some(candidate);
5076 break;
5077 }
5078 }
5079 if !fallback_cursor.goto_next_sibling() {
5080 break;
5081 }
5082 }
5083 }
5084 if fallback_child.is_none() {
5085 let mut cursor2 = node.walk();
5086 if cursor2.goto_first_child() {
5087 loop {
5088 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5089 let candidate = cursor2.node();
5090 #[allow(clippy::needless_question_mark)]
5091 if (|| -> ::core::result::Result<
5092 _,
5093 ::treesitter_types::ParseError,
5094 > {
5095 let child = candidate;
5096 Ok(
5097 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5098 child,
5099 src,
5100 ))?,
5101 )
5102 })()
5103 .is_ok()
5104 {
5105 fallback_child = Some(candidate);
5106 break;
5107 }
5108 }
5109 if !cursor2.goto_next_sibling() {
5110 break;
5111 }
5112 }
5113 }
5114 }
5115 fallback_child.ok_or_else(|| {
5116 ::treesitter_types::ParseError::missing_field("children", node)
5117 })?
5118 };
5119 ::treesitter_types::runtime::maybe_grow_stack(|| {
5120 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5121 child, src,
5122 )
5123 })?
5124 },
5125 })
5126 }
5127}
5128impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
5129 fn span(&self) -> ::treesitter_types::Span {
5130 self.span
5131 }
5132}
5133#[derive(Debug, Clone, PartialEq, Eq)]
5134pub struct ExternAliasDirective<'tree> {
5135 pub span: ::treesitter_types::Span,
5136 pub name: Identifier<'tree>,
5137}
5138impl<'tree> ::treesitter_types::FromNode<'tree> for ExternAliasDirective<'tree> {
5139 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5140 fn from_node(
5141 node: ::treesitter_types::tree_sitter::Node<'tree>,
5142 src: &'tree [u8],
5143 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5144 debug_assert_eq!(node.kind(), "extern_alias_directive");
5145 Ok(Self {
5146 span: ::treesitter_types::Span::from(node),
5147 name: {
5148 let child = node
5149 .child_by_field_name("name")
5150 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5151 ::treesitter_types::runtime::maybe_grow_stack(|| {
5152 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5153 })?
5154 },
5155 })
5156 }
5157}
5158impl ::treesitter_types::Spanned for ExternAliasDirective<'_> {
5159 fn span(&self) -> ::treesitter_types::Span {
5160 self.span
5161 }
5162}
5163#[derive(Debug, Clone, PartialEq, Eq)]
5164pub struct FieldDeclaration<'tree> {
5165 pub span: ::treesitter_types::Span,
5166 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
5167}
5168impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
5169 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5170 fn from_node(
5171 node: ::treesitter_types::tree_sitter::Node<'tree>,
5172 src: &'tree [u8],
5173 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5174 debug_assert_eq!(node.kind(), "field_declaration");
5175 Ok(Self {
5176 span: ::treesitter_types::Span::from(node),
5177 children: {
5178 #[allow(clippy::suspicious_else_formatting)]
5179 let non_field_children = {
5180 let mut cursor = node.walk();
5181 let mut result = ::std::vec::Vec::new();
5182 if cursor.goto_first_child() {
5183 loop {
5184 if cursor.field_name().is_none()
5185 && cursor.node().is_named()
5186 && !cursor.node().is_extra()
5187 {
5188 result.push(cursor.node());
5189 }
5190 if !cursor.goto_next_sibling() {
5191 break;
5192 }
5193 }
5194 }
5195 result
5196 };
5197 let mut items = ::std::vec::Vec::new();
5198 for child in non_field_children {
5199 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5200 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5201 child, src,
5202 )
5203 })?);
5204 }
5205 items
5206 },
5207 })
5208 }
5209}
5210impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
5211 fn span(&self) -> ::treesitter_types::Span {
5212 self.span
5213 }
5214}
5215#[derive(Debug, Clone, PartialEq, Eq)]
5216pub struct FileScopedNamespaceDeclaration<'tree> {
5217 pub span: ::treesitter_types::Span,
5218 pub name: FileScopedNamespaceDeclarationName<'tree>,
5219}
5220impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclaration<'tree> {
5221 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5222 fn from_node(
5223 node: ::treesitter_types::tree_sitter::Node<'tree>,
5224 src: &'tree [u8],
5225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5226 debug_assert_eq!(node.kind(), "file_scoped_namespace_declaration");
5227 Ok(Self {
5228 span: ::treesitter_types::Span::from(node),
5229 name: {
5230 let child = node
5231 .child_by_field_name("name")
5232 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5233 ::treesitter_types::runtime::maybe_grow_stack(|| {
5234 <FileScopedNamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(
5235 child, src,
5236 )
5237 })?
5238 },
5239 })
5240 }
5241}
5242impl ::treesitter_types::Spanned for FileScopedNamespaceDeclaration<'_> {
5243 fn span(&self) -> ::treesitter_types::Span {
5244 self.span
5245 }
5246}
5247#[derive(Debug, Clone, PartialEq, Eq)]
5248pub struct FinallyClause<'tree> {
5249 pub span: ::treesitter_types::Span,
5250 pub children: Block<'tree>,
5251}
5252impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
5253 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5254 fn from_node(
5255 node: ::treesitter_types::tree_sitter::Node<'tree>,
5256 src: &'tree [u8],
5257 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5258 debug_assert_eq!(node.kind(), "finally_clause");
5259 Ok(Self {
5260 span: ::treesitter_types::Span::from(node),
5261 children: {
5262 #[allow(clippy::suspicious_else_formatting)]
5263 let non_field_children = {
5264 let mut cursor = node.walk();
5265 let mut result = ::std::vec::Vec::new();
5266 if cursor.goto_first_child() {
5267 loop {
5268 if cursor.field_name().is_none()
5269 && cursor.node().is_named()
5270 && !cursor.node().is_extra()
5271 {
5272 result.push(cursor.node());
5273 }
5274 if !cursor.goto_next_sibling() {
5275 break;
5276 }
5277 }
5278 }
5279 result
5280 };
5281 let child = if let Some(&c) = non_field_children.first() {
5282 c
5283 } else {
5284 let mut fallback_cursor = node.walk();
5285 let mut fallback_child = None;
5286 if fallback_cursor.goto_first_child() {
5287 loop {
5288 if fallback_cursor.field_name().is_none()
5289 && !fallback_cursor.node().is_extra()
5290 {
5291 let candidate = fallback_cursor.node();
5292 #[allow(clippy::needless_question_mark)]
5293 if (|| -> ::core::result::Result<
5294 _,
5295 ::treesitter_types::ParseError,
5296 > {
5297 let child = candidate;
5298 Ok(
5299 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
5300 child,
5301 src,
5302 ))?,
5303 )
5304 })()
5305 .is_ok()
5306 {
5307 fallback_child = Some(candidate);
5308 break;
5309 }
5310 }
5311 if !fallback_cursor.goto_next_sibling() {
5312 break;
5313 }
5314 }
5315 }
5316 if fallback_child.is_none() {
5317 let mut cursor2 = node.walk();
5318 if cursor2.goto_first_child() {
5319 loop {
5320 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5321 let candidate = cursor2.node();
5322 #[allow(clippy::needless_question_mark)]
5323 if (|| -> ::core::result::Result<
5324 _,
5325 ::treesitter_types::ParseError,
5326 > {
5327 let child = candidate;
5328 Ok(
5329 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
5330 child,
5331 src,
5332 ))?,
5333 )
5334 })()
5335 .is_ok()
5336 {
5337 fallback_child = Some(candidate);
5338 break;
5339 }
5340 }
5341 if !cursor2.goto_next_sibling() {
5342 break;
5343 }
5344 }
5345 }
5346 }
5347 fallback_child.ok_or_else(|| {
5348 ::treesitter_types::ParseError::missing_field("children", node)
5349 })?
5350 };
5351 ::treesitter_types::runtime::maybe_grow_stack(|| {
5352 <Block as ::treesitter_types::FromNode>::from_node(child, src)
5353 })?
5354 },
5355 })
5356 }
5357}
5358impl ::treesitter_types::Spanned for FinallyClause<'_> {
5359 fn span(&self) -> ::treesitter_types::Span {
5360 self.span
5361 }
5362}
5363#[derive(Debug, Clone, PartialEq, Eq)]
5364pub struct FixedStatement<'tree> {
5365 pub span: ::treesitter_types::Span,
5366 pub children: ::std::vec::Vec<FixedStatementChildren<'tree>>,
5367}
5368impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatement<'tree> {
5369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5370 fn from_node(
5371 node: ::treesitter_types::tree_sitter::Node<'tree>,
5372 src: &'tree [u8],
5373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5374 debug_assert_eq!(node.kind(), "fixed_statement");
5375 Ok(Self {
5376 span: ::treesitter_types::Span::from(node),
5377 children: {
5378 #[allow(clippy::suspicious_else_formatting)]
5379 let non_field_children = {
5380 let mut cursor = node.walk();
5381 let mut result = ::std::vec::Vec::new();
5382 if cursor.goto_first_child() {
5383 loop {
5384 if cursor.field_name().is_none()
5385 && cursor.node().is_named()
5386 && !cursor.node().is_extra()
5387 {
5388 result.push(cursor.node());
5389 }
5390 if !cursor.goto_next_sibling() {
5391 break;
5392 }
5393 }
5394 }
5395 result
5396 };
5397 let mut items = ::std::vec::Vec::new();
5398 for child in non_field_children {
5399 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5400 <FixedStatementChildren as ::treesitter_types::FromNode>::from_node(
5401 child, src,
5402 )
5403 })?);
5404 }
5405 items
5406 },
5407 })
5408 }
5409}
5410impl ::treesitter_types::Spanned for FixedStatement<'_> {
5411 fn span(&self) -> ::treesitter_types::Span {
5412 self.span
5413 }
5414}
5415#[derive(Debug, Clone, PartialEq, Eq)]
5416pub struct ForStatement<'tree> {
5417 pub span: ::treesitter_types::Span,
5418 pub body: Statement<'tree>,
5419 pub condition: ::core::option::Option<Expression<'tree>>,
5420 pub initializer: ::std::vec::Vec<ForStatementInitializer<'tree>>,
5421 pub update: ::std::vec::Vec<ForStatementUpdate<'tree>>,
5422}
5423impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
5424 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5425 fn from_node(
5426 node: ::treesitter_types::tree_sitter::Node<'tree>,
5427 src: &'tree [u8],
5428 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5429 debug_assert_eq!(node.kind(), "for_statement");
5430 Ok(Self {
5431 span: ::treesitter_types::Span::from(node),
5432 body: {
5433 let child = node
5434 .child_by_field_name("body")
5435 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5436 ::treesitter_types::runtime::maybe_grow_stack(|| {
5437 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5438 })?
5439 },
5440 condition: match node.child_by_field_name("condition") {
5441 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5442 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5443 })?),
5444 None => None,
5445 },
5446 initializer: {
5447 let mut cursor = node.walk();
5448 let mut items = ::std::vec::Vec::new();
5449 for child in node.children_by_field_name("initializer", &mut cursor) {
5450 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5451 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(
5452 child, src,
5453 )
5454 })?);
5455 }
5456 items
5457 },
5458 update: {
5459 let mut cursor = node.walk();
5460 let mut items = ::std::vec::Vec::new();
5461 for child in node.children_by_field_name("update", &mut cursor) {
5462 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5463 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)
5464 })?);
5465 }
5466 items
5467 },
5468 })
5469 }
5470}
5471impl ::treesitter_types::Spanned for ForStatement<'_> {
5472 fn span(&self) -> ::treesitter_types::Span {
5473 self.span
5474 }
5475}
5476#[derive(Debug, Clone, PartialEq, Eq)]
5477pub struct ForeachStatement<'tree> {
5478 pub span: ::treesitter_types::Span,
5479 pub body: Statement<'tree>,
5480 pub left: ForeachStatementLeft<'tree>,
5481 pub right: Expression<'tree>,
5482 pub r#type: ::core::option::Option<Type<'tree>>,
5483}
5484impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatement<'tree> {
5485 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5486 fn from_node(
5487 node: ::treesitter_types::tree_sitter::Node<'tree>,
5488 src: &'tree [u8],
5489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5490 debug_assert_eq!(node.kind(), "foreach_statement");
5491 Ok(Self {
5492 span: ::treesitter_types::Span::from(node),
5493 body: {
5494 let child = node
5495 .child_by_field_name("body")
5496 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5497 ::treesitter_types::runtime::maybe_grow_stack(|| {
5498 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5499 })?
5500 },
5501 left: {
5502 let child = node
5503 .child_by_field_name("left")
5504 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5505 ::treesitter_types::runtime::maybe_grow_stack(|| {
5506 <ForeachStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)
5507 })?
5508 },
5509 right: {
5510 let child = node
5511 .child_by_field_name("right")
5512 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5513 ::treesitter_types::runtime::maybe_grow_stack(|| {
5514 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5515 })?
5516 },
5517 r#type: match node.child_by_field_name("type") {
5518 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5519 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5520 })?),
5521 None => None,
5522 },
5523 })
5524 }
5525}
5526impl ::treesitter_types::Spanned for ForeachStatement<'_> {
5527 fn span(&self) -> ::treesitter_types::Span {
5528 self.span
5529 }
5530}
5531#[derive(Debug, Clone, PartialEq, Eq)]
5532pub struct FromClause<'tree> {
5533 pub span: ::treesitter_types::Span,
5534 pub name: Identifier<'tree>,
5535 pub r#type: ::core::option::Option<Type<'tree>>,
5536 pub children: Expression<'tree>,
5537}
5538impl<'tree> ::treesitter_types::FromNode<'tree> for FromClause<'tree> {
5539 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5540 fn from_node(
5541 node: ::treesitter_types::tree_sitter::Node<'tree>,
5542 src: &'tree [u8],
5543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5544 debug_assert_eq!(node.kind(), "from_clause");
5545 Ok(Self {
5546 span: ::treesitter_types::Span::from(node),
5547 name: {
5548 let child = node
5549 .child_by_field_name("name")
5550 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5551 ::treesitter_types::runtime::maybe_grow_stack(|| {
5552 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5553 })?
5554 },
5555 r#type: match node.child_by_field_name("type") {
5556 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5557 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5558 })?),
5559 None => None,
5560 },
5561 children: {
5562 #[allow(clippy::suspicious_else_formatting)]
5563 let non_field_children = {
5564 let mut cursor = node.walk();
5565 let mut result = ::std::vec::Vec::new();
5566 if cursor.goto_first_child() {
5567 loop {
5568 if cursor.field_name().is_none()
5569 && cursor.node().is_named()
5570 && !cursor.node().is_extra()
5571 {
5572 result.push(cursor.node());
5573 }
5574 if !cursor.goto_next_sibling() {
5575 break;
5576 }
5577 }
5578 }
5579 result
5580 };
5581 let child = if let Some(&c) = non_field_children.first() {
5582 c
5583 } else {
5584 let mut fallback_cursor = node.walk();
5585 let mut fallback_child = None;
5586 if fallback_cursor.goto_first_child() {
5587 loop {
5588 if fallback_cursor.field_name().is_none()
5589 && !fallback_cursor.node().is_extra()
5590 {
5591 let candidate = fallback_cursor.node();
5592 #[allow(clippy::needless_question_mark)]
5593 if (|| -> ::core::result::Result<
5594 _,
5595 ::treesitter_types::ParseError,
5596 > {
5597 let child = candidate;
5598 Ok(
5599 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5600 child,
5601 src,
5602 ))?,
5603 )
5604 })()
5605 .is_ok()
5606 {
5607 fallback_child = Some(candidate);
5608 break;
5609 }
5610 }
5611 if !fallback_cursor.goto_next_sibling() {
5612 break;
5613 }
5614 }
5615 }
5616 if fallback_child.is_none() {
5617 let mut cursor2 = node.walk();
5618 if cursor2.goto_first_child() {
5619 loop {
5620 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5621 let candidate = cursor2.node();
5622 #[allow(clippy::needless_question_mark)]
5623 if (|| -> ::core::result::Result<
5624 _,
5625 ::treesitter_types::ParseError,
5626 > {
5627 let child = candidate;
5628 Ok(
5629 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5630 child,
5631 src,
5632 ))?,
5633 )
5634 })()
5635 .is_ok()
5636 {
5637 fallback_child = Some(candidate);
5638 break;
5639 }
5640 }
5641 if !cursor2.goto_next_sibling() {
5642 break;
5643 }
5644 }
5645 }
5646 }
5647 fallback_child.ok_or_else(|| {
5648 ::treesitter_types::ParseError::missing_field("children", node)
5649 })?
5650 };
5651 ::treesitter_types::runtime::maybe_grow_stack(|| {
5652 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5653 })?
5654 },
5655 })
5656 }
5657}
5658impl ::treesitter_types::Spanned for FromClause<'_> {
5659 fn span(&self) -> ::treesitter_types::Span {
5660 self.span
5661 }
5662}
5663#[derive(Debug, Clone, PartialEq, Eq)]
5664pub struct FunctionPointerParameter<'tree> {
5665 pub span: ::treesitter_types::Span,
5666 pub r#type: FunctionPointerParameterType<'tree>,
5667}
5668impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameter<'tree> {
5669 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5670 fn from_node(
5671 node: ::treesitter_types::tree_sitter::Node<'tree>,
5672 src: &'tree [u8],
5673 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5674 debug_assert_eq!(node.kind(), "function_pointer_parameter");
5675 Ok(Self {
5676 span: ::treesitter_types::Span::from(node),
5677 r#type: {
5678 let child = node
5679 .child_by_field_name("type")
5680 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5681 ::treesitter_types::runtime::maybe_grow_stack(|| {
5682 <FunctionPointerParameterType as ::treesitter_types::FromNode>::from_node(
5683 child, src,
5684 )
5685 })?
5686 },
5687 })
5688 }
5689}
5690impl ::treesitter_types::Spanned for FunctionPointerParameter<'_> {
5691 fn span(&self) -> ::treesitter_types::Span {
5692 self.span
5693 }
5694}
5695#[derive(Debug, Clone, PartialEq, Eq)]
5696pub struct FunctionPointerType<'tree> {
5697 pub span: ::treesitter_types::Span,
5698 pub returns: Type<'tree>,
5699 pub children: ::std::vec::Vec<FunctionPointerTypeChildren<'tree>>,
5700}
5701impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerType<'tree> {
5702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5703 fn from_node(
5704 node: ::treesitter_types::tree_sitter::Node<'tree>,
5705 src: &'tree [u8],
5706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5707 debug_assert_eq!(node.kind(), "function_pointer_type");
5708 Ok(Self {
5709 span: ::treesitter_types::Span::from(node),
5710 returns: {
5711 let child = node.child_by_field_name("returns").ok_or_else(|| {
5712 ::treesitter_types::ParseError::missing_field("returns", node)
5713 })?;
5714 ::treesitter_types::runtime::maybe_grow_stack(|| {
5715 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5716 })?
5717 },
5718 children: {
5719 #[allow(clippy::suspicious_else_formatting)]
5720 let non_field_children = {
5721 let mut cursor = node.walk();
5722 let mut result = ::std::vec::Vec::new();
5723 if cursor.goto_first_child() {
5724 loop {
5725 if cursor.field_name().is_none()
5726 && cursor.node().is_named()
5727 && !cursor.node().is_extra()
5728 {
5729 result.push(cursor.node());
5730 }
5731 if !cursor.goto_next_sibling() {
5732 break;
5733 }
5734 }
5735 }
5736 result
5737 };
5738 let mut items = ::std::vec::Vec::new();
5739 for child in non_field_children {
5740 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5741 <FunctionPointerTypeChildren as ::treesitter_types::FromNode>::from_node(
5742 child, src,
5743 )
5744 })?);
5745 }
5746 items
5747 },
5748 })
5749 }
5750}
5751impl ::treesitter_types::Spanned for FunctionPointerType<'_> {
5752 fn span(&self) -> ::treesitter_types::Span {
5753 self.span
5754 }
5755}
5756#[derive(Debug, Clone, PartialEq, Eq)]
5757pub struct GenericName<'tree> {
5758 pub span: ::treesitter_types::Span,
5759 pub children: ::std::vec::Vec<GenericNameChildren<'tree>>,
5760}
5761impl<'tree> ::treesitter_types::FromNode<'tree> for GenericName<'tree> {
5762 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5763 fn from_node(
5764 node: ::treesitter_types::tree_sitter::Node<'tree>,
5765 src: &'tree [u8],
5766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5767 debug_assert_eq!(node.kind(), "generic_name");
5768 Ok(Self {
5769 span: ::treesitter_types::Span::from(node),
5770 children: {
5771 #[allow(clippy::suspicious_else_formatting)]
5772 let non_field_children = {
5773 let mut cursor = node.walk();
5774 let mut result = ::std::vec::Vec::new();
5775 if cursor.goto_first_child() {
5776 loop {
5777 if cursor.field_name().is_none()
5778 && cursor.node().is_named()
5779 && !cursor.node().is_extra()
5780 {
5781 result.push(cursor.node());
5782 }
5783 if !cursor.goto_next_sibling() {
5784 break;
5785 }
5786 }
5787 }
5788 result
5789 };
5790 let mut items = ::std::vec::Vec::new();
5791 for child in non_field_children {
5792 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5793 <GenericNameChildren as ::treesitter_types::FromNode>::from_node(child, src)
5794 })?);
5795 }
5796 items
5797 },
5798 })
5799 }
5800}
5801impl ::treesitter_types::Spanned for GenericName<'_> {
5802 fn span(&self) -> ::treesitter_types::Span {
5803 self.span
5804 }
5805}
5806#[derive(Debug, Clone, PartialEq, Eq)]
5807pub struct GlobalAttribute<'tree> {
5808 pub span: ::treesitter_types::Span,
5809 pub children: ::std::vec::Vec<Attribute<'tree>>,
5810}
5811impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalAttribute<'tree> {
5812 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5813 fn from_node(
5814 node: ::treesitter_types::tree_sitter::Node<'tree>,
5815 src: &'tree [u8],
5816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5817 debug_assert_eq!(node.kind(), "global_attribute");
5818 Ok(Self {
5819 span: ::treesitter_types::Span::from(node),
5820 children: {
5821 #[allow(clippy::suspicious_else_formatting)]
5822 let non_field_children = {
5823 let mut cursor = node.walk();
5824 let mut result = ::std::vec::Vec::new();
5825 if cursor.goto_first_child() {
5826 loop {
5827 if cursor.field_name().is_none()
5828 && cursor.node().is_named()
5829 && !cursor.node().is_extra()
5830 {
5831 result.push(cursor.node());
5832 }
5833 if !cursor.goto_next_sibling() {
5834 break;
5835 }
5836 }
5837 }
5838 result
5839 };
5840 let mut items = ::std::vec::Vec::new();
5841 for child in non_field_children {
5842 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5843 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
5844 })?);
5845 }
5846 items
5847 },
5848 })
5849 }
5850}
5851impl ::treesitter_types::Spanned for GlobalAttribute<'_> {
5852 fn span(&self) -> ::treesitter_types::Span {
5853 self.span
5854 }
5855}
5856#[derive(Debug, Clone, PartialEq, Eq)]
5857pub struct GlobalStatement<'tree> {
5858 pub span: ::treesitter_types::Span,
5859 pub children: Statement<'tree>,
5860}
5861impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalStatement<'tree> {
5862 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5863 fn from_node(
5864 node: ::treesitter_types::tree_sitter::Node<'tree>,
5865 src: &'tree [u8],
5866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5867 debug_assert_eq!(node.kind(), "global_statement");
5868 Ok(Self {
5869 span: ::treesitter_types::Span::from(node),
5870 children: {
5871 #[allow(clippy::suspicious_else_formatting)]
5872 let non_field_children = {
5873 let mut cursor = node.walk();
5874 let mut result = ::std::vec::Vec::new();
5875 if cursor.goto_first_child() {
5876 loop {
5877 if cursor.field_name().is_none()
5878 && cursor.node().is_named()
5879 && !cursor.node().is_extra()
5880 {
5881 result.push(cursor.node());
5882 }
5883 if !cursor.goto_next_sibling() {
5884 break;
5885 }
5886 }
5887 }
5888 result
5889 };
5890 let child = if let Some(&c) = non_field_children.first() {
5891 c
5892 } else {
5893 let mut fallback_cursor = node.walk();
5894 let mut fallback_child = None;
5895 if fallback_cursor.goto_first_child() {
5896 loop {
5897 if fallback_cursor.field_name().is_none()
5898 && !fallback_cursor.node().is_extra()
5899 {
5900 let candidate = fallback_cursor.node();
5901 #[allow(clippy::needless_question_mark)]
5902 if (|| -> ::core::result::Result<
5903 _,
5904 ::treesitter_types::ParseError,
5905 > {
5906 let child = candidate;
5907 Ok(
5908 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
5909 child,
5910 src,
5911 ))?,
5912 )
5913 })()
5914 .is_ok()
5915 {
5916 fallback_child = Some(candidate);
5917 break;
5918 }
5919 }
5920 if !fallback_cursor.goto_next_sibling() {
5921 break;
5922 }
5923 }
5924 }
5925 if fallback_child.is_none() {
5926 let mut cursor2 = node.walk();
5927 if cursor2.goto_first_child() {
5928 loop {
5929 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5930 let candidate = cursor2.node();
5931 #[allow(clippy::needless_question_mark)]
5932 if (|| -> ::core::result::Result<
5933 _,
5934 ::treesitter_types::ParseError,
5935 > {
5936 let child = candidate;
5937 Ok(
5938 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
5939 child,
5940 src,
5941 ))?,
5942 )
5943 })()
5944 .is_ok()
5945 {
5946 fallback_child = Some(candidate);
5947 break;
5948 }
5949 }
5950 if !cursor2.goto_next_sibling() {
5951 break;
5952 }
5953 }
5954 }
5955 }
5956 fallback_child.ok_or_else(|| {
5957 ::treesitter_types::ParseError::missing_field("children", node)
5958 })?
5959 };
5960 ::treesitter_types::runtime::maybe_grow_stack(|| {
5961 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5962 })?
5963 },
5964 })
5965 }
5966}
5967impl ::treesitter_types::Spanned for GlobalStatement<'_> {
5968 fn span(&self) -> ::treesitter_types::Span {
5969 self.span
5970 }
5971}
5972#[derive(Debug, Clone, PartialEq, Eq)]
5973pub struct GotoStatement<'tree> {
5974 pub span: ::treesitter_types::Span,
5975 pub children: ::core::option::Option<Expression<'tree>>,
5976}
5977impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
5978 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5979 fn from_node(
5980 node: ::treesitter_types::tree_sitter::Node<'tree>,
5981 src: &'tree [u8],
5982 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5983 debug_assert_eq!(node.kind(), "goto_statement");
5984 Ok(Self {
5985 span: ::treesitter_types::Span::from(node),
5986 children: {
5987 #[allow(clippy::suspicious_else_formatting)]
5988 let non_field_children = {
5989 let mut cursor = node.walk();
5990 let mut result = ::std::vec::Vec::new();
5991 if cursor.goto_first_child() {
5992 loop {
5993 if cursor.field_name().is_none()
5994 && cursor.node().is_named()
5995 && !cursor.node().is_extra()
5996 {
5997 result.push(cursor.node());
5998 }
5999 if !cursor.goto_next_sibling() {
6000 break;
6001 }
6002 }
6003 }
6004 result
6005 };
6006 match non_field_children.first() {
6007 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6008 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6009 })?),
6010 None => None,
6011 }
6012 },
6013 })
6014 }
6015}
6016impl ::treesitter_types::Spanned for GotoStatement<'_> {
6017 fn span(&self) -> ::treesitter_types::Span {
6018 self.span
6019 }
6020}
6021#[derive(Debug, Clone, PartialEq, Eq)]
6022pub struct GroupClause<'tree> {
6023 pub span: ::treesitter_types::Span,
6024 pub children: ::std::vec::Vec<Expression<'tree>>,
6025}
6026impl<'tree> ::treesitter_types::FromNode<'tree> for GroupClause<'tree> {
6027 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6028 fn from_node(
6029 node: ::treesitter_types::tree_sitter::Node<'tree>,
6030 src: &'tree [u8],
6031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6032 debug_assert_eq!(node.kind(), "group_clause");
6033 Ok(Self {
6034 span: ::treesitter_types::Span::from(node),
6035 children: {
6036 #[allow(clippy::suspicious_else_formatting)]
6037 let non_field_children = {
6038 let mut cursor = node.walk();
6039 let mut result = ::std::vec::Vec::new();
6040 if cursor.goto_first_child() {
6041 loop {
6042 if cursor.field_name().is_none()
6043 && cursor.node().is_named()
6044 && !cursor.node().is_extra()
6045 {
6046 result.push(cursor.node());
6047 }
6048 if !cursor.goto_next_sibling() {
6049 break;
6050 }
6051 }
6052 }
6053 result
6054 };
6055 let mut items = ::std::vec::Vec::new();
6056 for child in non_field_children {
6057 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6058 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6059 })?);
6060 }
6061 items
6062 },
6063 })
6064 }
6065}
6066impl ::treesitter_types::Spanned for GroupClause<'_> {
6067 fn span(&self) -> ::treesitter_types::Span {
6068 self.span
6069 }
6070}
6071#[derive(Debug, Clone, PartialEq, Eq)]
6072pub struct Identifier<'tree> {
6073 pub span: ::treesitter_types::Span,
6074 text: &'tree str,
6075}
6076impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
6077 fn from_node(
6078 node: ::treesitter_types::tree_sitter::Node<'tree>,
6079 src: &'tree [u8],
6080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6081 debug_assert_eq!(node.kind(), "identifier");
6082 Ok(Self {
6083 span: ::treesitter_types::Span::from(node),
6084 text: node.utf8_text(src)?,
6085 })
6086 }
6087}
6088impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
6089 fn text(&self) -> &'tree str {
6090 self.text
6091 }
6092}
6093impl ::treesitter_types::Spanned for Identifier<'_> {
6094 fn span(&self) -> ::treesitter_types::Span {
6095 self.span
6096 }
6097}
6098#[derive(Debug, Clone, PartialEq, Eq)]
6099pub struct IfStatement<'tree> {
6100 pub span: ::treesitter_types::Span,
6101 pub alternative: ::core::option::Option<Statement<'tree>>,
6102 pub condition: Expression<'tree>,
6103 pub consequence: Statement<'tree>,
6104}
6105impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
6106 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6107 fn from_node(
6108 node: ::treesitter_types::tree_sitter::Node<'tree>,
6109 src: &'tree [u8],
6110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6111 debug_assert_eq!(node.kind(), "if_statement");
6112 Ok(Self {
6113 span: ::treesitter_types::Span::from(node),
6114 alternative: match node.child_by_field_name("alternative") {
6115 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6116 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6117 })?),
6118 None => None,
6119 },
6120 condition: {
6121 let child = node.child_by_field_name("condition").ok_or_else(|| {
6122 ::treesitter_types::ParseError::missing_field("condition", node)
6123 })?;
6124 ::treesitter_types::runtime::maybe_grow_stack(|| {
6125 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6126 })?
6127 },
6128 consequence: {
6129 let child = node.child_by_field_name("consequence").ok_or_else(|| {
6130 ::treesitter_types::ParseError::missing_field("consequence", node)
6131 })?;
6132 ::treesitter_types::runtime::maybe_grow_stack(|| {
6133 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6134 })?
6135 },
6136 })
6137 }
6138}
6139impl ::treesitter_types::Spanned for IfStatement<'_> {
6140 fn span(&self) -> ::treesitter_types::Span {
6141 self.span
6142 }
6143}
6144#[derive(Debug, Clone, PartialEq, Eq)]
6145pub struct ImplicitArrayCreationExpression<'tree> {
6146 pub span: ::treesitter_types::Span,
6147 pub children: InitializerExpression<'tree>,
6148}
6149impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitArrayCreationExpression<'tree> {
6150 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6151 fn from_node(
6152 node: ::treesitter_types::tree_sitter::Node<'tree>,
6153 src: &'tree [u8],
6154 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6155 debug_assert_eq!(node.kind(), "implicit_array_creation_expression");
6156 Ok(Self {
6157 span: ::treesitter_types::Span::from(node),
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 child = if let Some(&c) = non_field_children.first() {
6179 c
6180 } else {
6181 let mut fallback_cursor = node.walk();
6182 let mut fallback_child = None;
6183 if fallback_cursor.goto_first_child() {
6184 loop {
6185 if fallback_cursor.field_name().is_none()
6186 && !fallback_cursor.node().is_extra()
6187 {
6188 let candidate = fallback_cursor.node();
6189 #[allow(clippy::needless_question_mark)]
6190 if (|| -> ::core::result::Result<
6191 _,
6192 ::treesitter_types::ParseError,
6193 > {
6194 let child = candidate;
6195 Ok(
6196 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6197 child,
6198 src,
6199 ))?,
6200 )
6201 })()
6202 .is_ok()
6203 {
6204 fallback_child = Some(candidate);
6205 break;
6206 }
6207 }
6208 if !fallback_cursor.goto_next_sibling() {
6209 break;
6210 }
6211 }
6212 }
6213 if fallback_child.is_none() {
6214 let mut cursor2 = node.walk();
6215 if cursor2.goto_first_child() {
6216 loop {
6217 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6218 let candidate = cursor2.node();
6219 #[allow(clippy::needless_question_mark)]
6220 if (|| -> ::core::result::Result<
6221 _,
6222 ::treesitter_types::ParseError,
6223 > {
6224 let child = candidate;
6225 Ok(
6226 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6227 child,
6228 src,
6229 ))?,
6230 )
6231 })()
6232 .is_ok()
6233 {
6234 fallback_child = Some(candidate);
6235 break;
6236 }
6237 }
6238 if !cursor2.goto_next_sibling() {
6239 break;
6240 }
6241 }
6242 }
6243 }
6244 fallback_child.ok_or_else(|| {
6245 ::treesitter_types::ParseError::missing_field("children", node)
6246 })?
6247 };
6248 ::treesitter_types::runtime::maybe_grow_stack(|| {
6249 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
6250 })?
6251 },
6252 })
6253 }
6254}
6255impl ::treesitter_types::Spanned for ImplicitArrayCreationExpression<'_> {
6256 fn span(&self) -> ::treesitter_types::Span {
6257 self.span
6258 }
6259}
6260#[derive(Debug, Clone, PartialEq, Eq)]
6261pub struct ImplicitObjectCreationExpression<'tree> {
6262 pub span: ::treesitter_types::Span,
6263 pub children: ::std::vec::Vec<ImplicitObjectCreationExpressionChildren<'tree>>,
6264}
6265impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitObjectCreationExpression<'tree> {
6266 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6267 fn from_node(
6268 node: ::treesitter_types::tree_sitter::Node<'tree>,
6269 src: &'tree [u8],
6270 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6271 debug_assert_eq!(node.kind(), "implicit_object_creation_expression");
6272 Ok(Self {
6273 span: ::treesitter_types::Span::from(node),
6274 children: {
6275 #[allow(clippy::suspicious_else_formatting)]
6276 let non_field_children = {
6277 let mut cursor = node.walk();
6278 let mut result = ::std::vec::Vec::new();
6279 if cursor.goto_first_child() {
6280 loop {
6281 if cursor.field_name().is_none()
6282 && cursor.node().is_named()
6283 && !cursor.node().is_extra()
6284 {
6285 result.push(cursor.node());
6286 }
6287 if !cursor.goto_next_sibling() {
6288 break;
6289 }
6290 }
6291 }
6292 result
6293 };
6294 let mut items = ::std::vec::Vec::new();
6295 for child in non_field_children {
6296 items
6297 .push(
6298 ::treesitter_types::runtime::maybe_grow_stack(|| <ImplicitObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
6299 child,
6300 src,
6301 ))?,
6302 );
6303 }
6304 items
6305 },
6306 })
6307 }
6308}
6309impl ::treesitter_types::Spanned for ImplicitObjectCreationExpression<'_> {
6310 fn span(&self) -> ::treesitter_types::Span {
6311 self.span
6312 }
6313}
6314#[derive(Debug, Clone, PartialEq, Eq)]
6315pub struct ImplicitParameter<'tree> {
6316 pub span: ::treesitter_types::Span,
6317 text: &'tree str,
6318}
6319impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitParameter<'tree> {
6320 fn from_node(
6321 node: ::treesitter_types::tree_sitter::Node<'tree>,
6322 src: &'tree [u8],
6323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6324 debug_assert_eq!(node.kind(), "implicit_parameter");
6325 Ok(Self {
6326 span: ::treesitter_types::Span::from(node),
6327 text: node.utf8_text(src)?,
6328 })
6329 }
6330}
6331impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitParameter<'tree> {
6332 fn text(&self) -> &'tree str {
6333 self.text
6334 }
6335}
6336impl ::treesitter_types::Spanned for ImplicitParameter<'_> {
6337 fn span(&self) -> ::treesitter_types::Span {
6338 self.span
6339 }
6340}
6341#[derive(Debug, Clone, PartialEq, Eq)]
6342pub struct ImplicitStackallocExpression<'tree> {
6343 pub span: ::treesitter_types::Span,
6344 pub children: InitializerExpression<'tree>,
6345}
6346impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitStackallocExpression<'tree> {
6347 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6348 fn from_node(
6349 node: ::treesitter_types::tree_sitter::Node<'tree>,
6350 src: &'tree [u8],
6351 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6352 debug_assert_eq!(node.kind(), "implicit_stackalloc_expression");
6353 Ok(Self {
6354 span: ::treesitter_types::Span::from(node),
6355 children: {
6356 #[allow(clippy::suspicious_else_formatting)]
6357 let non_field_children = {
6358 let mut cursor = node.walk();
6359 let mut result = ::std::vec::Vec::new();
6360 if cursor.goto_first_child() {
6361 loop {
6362 if cursor.field_name().is_none()
6363 && cursor.node().is_named()
6364 && !cursor.node().is_extra()
6365 {
6366 result.push(cursor.node());
6367 }
6368 if !cursor.goto_next_sibling() {
6369 break;
6370 }
6371 }
6372 }
6373 result
6374 };
6375 let child = if let Some(&c) = non_field_children.first() {
6376 c
6377 } else {
6378 let mut fallback_cursor = node.walk();
6379 let mut fallback_child = None;
6380 if fallback_cursor.goto_first_child() {
6381 loop {
6382 if fallback_cursor.field_name().is_none()
6383 && !fallback_cursor.node().is_extra()
6384 {
6385 let candidate = fallback_cursor.node();
6386 #[allow(clippy::needless_question_mark)]
6387 if (|| -> ::core::result::Result<
6388 _,
6389 ::treesitter_types::ParseError,
6390 > {
6391 let child = candidate;
6392 Ok(
6393 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6394 child,
6395 src,
6396 ))?,
6397 )
6398 })()
6399 .is_ok()
6400 {
6401 fallback_child = Some(candidate);
6402 break;
6403 }
6404 }
6405 if !fallback_cursor.goto_next_sibling() {
6406 break;
6407 }
6408 }
6409 }
6410 if fallback_child.is_none() {
6411 let mut cursor2 = node.walk();
6412 if cursor2.goto_first_child() {
6413 loop {
6414 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6415 let candidate = cursor2.node();
6416 #[allow(clippy::needless_question_mark)]
6417 if (|| -> ::core::result::Result<
6418 _,
6419 ::treesitter_types::ParseError,
6420 > {
6421 let child = candidate;
6422 Ok(
6423 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6424 child,
6425 src,
6426 ))?,
6427 )
6428 })()
6429 .is_ok()
6430 {
6431 fallback_child = Some(candidate);
6432 break;
6433 }
6434 }
6435 if !cursor2.goto_next_sibling() {
6436 break;
6437 }
6438 }
6439 }
6440 }
6441 fallback_child.ok_or_else(|| {
6442 ::treesitter_types::ParseError::missing_field("children", node)
6443 })?
6444 };
6445 ::treesitter_types::runtime::maybe_grow_stack(|| {
6446 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
6447 })?
6448 },
6449 })
6450 }
6451}
6452impl ::treesitter_types::Spanned for ImplicitStackallocExpression<'_> {
6453 fn span(&self) -> ::treesitter_types::Span {
6454 self.span
6455 }
6456}
6457#[derive(Debug, Clone, PartialEq, Eq)]
6458pub struct ImplicitType<'tree> {
6459 pub span: ::treesitter_types::Span,
6460 text: &'tree str,
6461}
6462impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitType<'tree> {
6463 fn from_node(
6464 node: ::treesitter_types::tree_sitter::Node<'tree>,
6465 src: &'tree [u8],
6466 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6467 debug_assert_eq!(node.kind(), "implicit_type");
6468 Ok(Self {
6469 span: ::treesitter_types::Span::from(node),
6470 text: node.utf8_text(src)?,
6471 })
6472 }
6473}
6474impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitType<'tree> {
6475 fn text(&self) -> &'tree str {
6476 self.text
6477 }
6478}
6479impl ::treesitter_types::Spanned for ImplicitType<'_> {
6480 fn span(&self) -> ::treesitter_types::Span {
6481 self.span
6482 }
6483}
6484#[derive(Debug, Clone, PartialEq, Eq)]
6485pub struct IndexerDeclaration<'tree> {
6486 pub span: ::treesitter_types::Span,
6487 pub accessors: ::core::option::Option<AccessorList<'tree>>,
6488 pub parameters: BracketedParameterList<'tree>,
6489 pub r#type: Type<'tree>,
6490 pub value: ::core::option::Option<ArrowExpressionClause<'tree>>,
6491 pub children: ::std::vec::Vec<IndexerDeclarationChildren<'tree>>,
6492}
6493impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclaration<'tree> {
6494 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6495 fn from_node(
6496 node: ::treesitter_types::tree_sitter::Node<'tree>,
6497 src: &'tree [u8],
6498 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6499 debug_assert_eq!(node.kind(), "indexer_declaration");
6500 Ok(Self {
6501 span: ::treesitter_types::Span::from(node),
6502 accessors: match node.child_by_field_name("accessors") {
6503 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6504 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
6505 })?),
6506 None => None,
6507 },
6508 parameters: {
6509 let child = node.child_by_field_name("parameters").ok_or_else(|| {
6510 ::treesitter_types::ParseError::missing_field("parameters", node)
6511 })?;
6512 ::treesitter_types::runtime::maybe_grow_stack(|| {
6513 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(child, src)
6514 })?
6515 },
6516 r#type: {
6517 let child = node
6518 .child_by_field_name("type")
6519 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6520 ::treesitter_types::runtime::maybe_grow_stack(|| {
6521 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6522 })?
6523 },
6524 value: match node.child_by_field_name("value") {
6525 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6526 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(child, src)
6527 })?),
6528 None => None,
6529 },
6530 children: {
6531 #[allow(clippy::suspicious_else_formatting)]
6532 let non_field_children = {
6533 let mut cursor = node.walk();
6534 let mut result = ::std::vec::Vec::new();
6535 if cursor.goto_first_child() {
6536 loop {
6537 if cursor.field_name().is_none()
6538 && cursor.node().is_named()
6539 && !cursor.node().is_extra()
6540 {
6541 result.push(cursor.node());
6542 }
6543 if !cursor.goto_next_sibling() {
6544 break;
6545 }
6546 }
6547 }
6548 result
6549 };
6550 let mut items = ::std::vec::Vec::new();
6551 for child in non_field_children {
6552 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6553 <IndexerDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6554 child, src,
6555 )
6556 })?);
6557 }
6558 items
6559 },
6560 })
6561 }
6562}
6563impl ::treesitter_types::Spanned for IndexerDeclaration<'_> {
6564 fn span(&self) -> ::treesitter_types::Span {
6565 self.span
6566 }
6567}
6568#[derive(Debug, Clone, PartialEq, Eq)]
6569pub struct InitializerExpression<'tree> {
6570 pub span: ::treesitter_types::Span,
6571 pub children: ::std::vec::Vec<Expression<'tree>>,
6572}
6573impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerExpression<'tree> {
6574 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6575 fn from_node(
6576 node: ::treesitter_types::tree_sitter::Node<'tree>,
6577 src: &'tree [u8],
6578 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6579 debug_assert_eq!(node.kind(), "initializer_expression");
6580 Ok(Self {
6581 span: ::treesitter_types::Span::from(node),
6582 children: {
6583 #[allow(clippy::suspicious_else_formatting)]
6584 let non_field_children = {
6585 let mut cursor = node.walk();
6586 let mut result = ::std::vec::Vec::new();
6587 if cursor.goto_first_child() {
6588 loop {
6589 if cursor.field_name().is_none()
6590 && cursor.node().is_named()
6591 && !cursor.node().is_extra()
6592 {
6593 result.push(cursor.node());
6594 }
6595 if !cursor.goto_next_sibling() {
6596 break;
6597 }
6598 }
6599 }
6600 result
6601 };
6602 let mut items = ::std::vec::Vec::new();
6603 for child in non_field_children {
6604 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6605 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6606 })?);
6607 }
6608 items
6609 },
6610 })
6611 }
6612}
6613impl ::treesitter_types::Spanned for InitializerExpression<'_> {
6614 fn span(&self) -> ::treesitter_types::Span {
6615 self.span
6616 }
6617}
6618#[derive(Debug, Clone, PartialEq, Eq)]
6619pub struct InterfaceDeclaration<'tree> {
6620 pub span: ::treesitter_types::Span,
6621 pub body: DeclarationList<'tree>,
6622 pub name: Identifier<'tree>,
6623 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
6624 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
6625}
6626impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
6627 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6628 fn from_node(
6629 node: ::treesitter_types::tree_sitter::Node<'tree>,
6630 src: &'tree [u8],
6631 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6632 debug_assert_eq!(node.kind(), "interface_declaration");
6633 Ok(Self {
6634 span: ::treesitter_types::Span::from(node),
6635 body: {
6636 let child = node
6637 .child_by_field_name("body")
6638 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6639 ::treesitter_types::runtime::maybe_grow_stack(|| {
6640 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
6641 })?
6642 },
6643 name: {
6644 let child = node
6645 .child_by_field_name("name")
6646 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6647 ::treesitter_types::runtime::maybe_grow_stack(|| {
6648 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
6649 })?
6650 },
6651 type_parameters: match node.child_by_field_name("type_parameters") {
6652 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6653 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
6654 })?),
6655 None => None,
6656 },
6657 children: {
6658 #[allow(clippy::suspicious_else_formatting)]
6659 let non_field_children = {
6660 let mut cursor = node.walk();
6661 let mut result = ::std::vec::Vec::new();
6662 if cursor.goto_first_child() {
6663 loop {
6664 if cursor.field_name().is_none()
6665 && cursor.node().is_named()
6666 && !cursor.node().is_extra()
6667 {
6668 result.push(cursor.node());
6669 }
6670 if !cursor.goto_next_sibling() {
6671 break;
6672 }
6673 }
6674 }
6675 result
6676 };
6677 let mut items = ::std::vec::Vec::new();
6678 for child in non_field_children {
6679 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6680 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6681 child, src,
6682 )
6683 })?);
6684 }
6685 items
6686 },
6687 })
6688 }
6689}
6690impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
6691 fn span(&self) -> ::treesitter_types::Span {
6692 self.span
6693 }
6694}
6695#[derive(Debug, Clone, PartialEq, Eq)]
6696pub struct InterpolatedStringExpression<'tree> {
6697 pub span: ::treesitter_types::Span,
6698 pub children: ::std::vec::Vec<InterpolatedStringExpressionChildren<'tree>>,
6699}
6700impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpression<'tree> {
6701 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6702 fn from_node(
6703 node: ::treesitter_types::tree_sitter::Node<'tree>,
6704 src: &'tree [u8],
6705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6706 debug_assert_eq!(node.kind(), "interpolated_string_expression");
6707 Ok(Self {
6708 span: ::treesitter_types::Span::from(node),
6709 children: {
6710 #[allow(clippy::suspicious_else_formatting)]
6711 let non_field_children = {
6712 let mut cursor = node.walk();
6713 let mut result = ::std::vec::Vec::new();
6714 if cursor.goto_first_child() {
6715 loop {
6716 if cursor.field_name().is_none()
6717 && cursor.node().is_named()
6718 && !cursor.node().is_extra()
6719 {
6720 result.push(cursor.node());
6721 }
6722 if !cursor.goto_next_sibling() {
6723 break;
6724 }
6725 }
6726 }
6727 result
6728 };
6729 let mut items = ::std::vec::Vec::new();
6730 for child in non_field_children {
6731 items
6732 .push(
6733 ::treesitter_types::runtime::maybe_grow_stack(|| <InterpolatedStringExpressionChildren as ::treesitter_types::FromNode>::from_node(
6734 child,
6735 src,
6736 ))?,
6737 );
6738 }
6739 items
6740 },
6741 })
6742 }
6743}
6744impl ::treesitter_types::Spanned for InterpolatedStringExpression<'_> {
6745 fn span(&self) -> ::treesitter_types::Span {
6746 self.span
6747 }
6748}
6749#[derive(Debug, Clone, PartialEq, Eq)]
6750pub struct Interpolation<'tree> {
6751 pub span: ::treesitter_types::Span,
6752 pub children: ::std::vec::Vec<InterpolationChildren<'tree>>,
6753}
6754impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
6755 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6756 fn from_node(
6757 node: ::treesitter_types::tree_sitter::Node<'tree>,
6758 src: &'tree [u8],
6759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6760 debug_assert_eq!(node.kind(), "interpolation");
6761 Ok(Self {
6762 span: ::treesitter_types::Span::from(node),
6763 children: {
6764 #[allow(clippy::suspicious_else_formatting)]
6765 let non_field_children = {
6766 let mut cursor = node.walk();
6767 let mut result = ::std::vec::Vec::new();
6768 if cursor.goto_first_child() {
6769 loop {
6770 if cursor.field_name().is_none()
6771 && cursor.node().is_named()
6772 && !cursor.node().is_extra()
6773 {
6774 result.push(cursor.node());
6775 }
6776 if !cursor.goto_next_sibling() {
6777 break;
6778 }
6779 }
6780 }
6781 result
6782 };
6783 let mut items = ::std::vec::Vec::new();
6784 for child in non_field_children {
6785 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6786 <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
6787 child, src,
6788 )
6789 })?);
6790 }
6791 items
6792 },
6793 })
6794 }
6795}
6796impl ::treesitter_types::Spanned for Interpolation<'_> {
6797 fn span(&self) -> ::treesitter_types::Span {
6798 self.span
6799 }
6800}
6801#[derive(Debug, Clone, PartialEq, Eq)]
6802pub struct InterpolationAlignmentClause<'tree> {
6803 pub span: ::treesitter_types::Span,
6804 pub children: Expression<'tree>,
6805}
6806impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationAlignmentClause<'tree> {
6807 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6808 fn from_node(
6809 node: ::treesitter_types::tree_sitter::Node<'tree>,
6810 src: &'tree [u8],
6811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6812 debug_assert_eq!(node.kind(), "interpolation_alignment_clause");
6813 Ok(Self {
6814 span: ::treesitter_types::Span::from(node),
6815 children: {
6816 #[allow(clippy::suspicious_else_formatting)]
6817 let non_field_children = {
6818 let mut cursor = node.walk();
6819 let mut result = ::std::vec::Vec::new();
6820 if cursor.goto_first_child() {
6821 loop {
6822 if cursor.field_name().is_none()
6823 && cursor.node().is_named()
6824 && !cursor.node().is_extra()
6825 {
6826 result.push(cursor.node());
6827 }
6828 if !cursor.goto_next_sibling() {
6829 break;
6830 }
6831 }
6832 }
6833 result
6834 };
6835 let child = if let Some(&c) = non_field_children.first() {
6836 c
6837 } else {
6838 let mut fallback_cursor = node.walk();
6839 let mut fallback_child = None;
6840 if fallback_cursor.goto_first_child() {
6841 loop {
6842 if fallback_cursor.field_name().is_none()
6843 && !fallback_cursor.node().is_extra()
6844 {
6845 let candidate = fallback_cursor.node();
6846 #[allow(clippy::needless_question_mark)]
6847 if (|| -> ::core::result::Result<
6848 _,
6849 ::treesitter_types::ParseError,
6850 > {
6851 let child = candidate;
6852 Ok(
6853 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6854 child,
6855 src,
6856 ))?,
6857 )
6858 })()
6859 .is_ok()
6860 {
6861 fallback_child = Some(candidate);
6862 break;
6863 }
6864 }
6865 if !fallback_cursor.goto_next_sibling() {
6866 break;
6867 }
6868 }
6869 }
6870 if fallback_child.is_none() {
6871 let mut cursor2 = node.walk();
6872 if cursor2.goto_first_child() {
6873 loop {
6874 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6875 let candidate = cursor2.node();
6876 #[allow(clippy::needless_question_mark)]
6877 if (|| -> ::core::result::Result<
6878 _,
6879 ::treesitter_types::ParseError,
6880 > {
6881 let child = candidate;
6882 Ok(
6883 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6884 child,
6885 src,
6886 ))?,
6887 )
6888 })()
6889 .is_ok()
6890 {
6891 fallback_child = Some(candidate);
6892 break;
6893 }
6894 }
6895 if !cursor2.goto_next_sibling() {
6896 break;
6897 }
6898 }
6899 }
6900 }
6901 fallback_child.ok_or_else(|| {
6902 ::treesitter_types::ParseError::missing_field("children", node)
6903 })?
6904 };
6905 ::treesitter_types::runtime::maybe_grow_stack(|| {
6906 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6907 })?
6908 },
6909 })
6910 }
6911}
6912impl ::treesitter_types::Spanned for InterpolationAlignmentClause<'_> {
6913 fn span(&self) -> ::treesitter_types::Span {
6914 self.span
6915 }
6916}
6917#[derive(Debug, Clone, PartialEq, Eq)]
6918pub struct InterpolationFormatClause<'tree> {
6919 pub span: ::treesitter_types::Span,
6920 text: &'tree str,
6921}
6922impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationFormatClause<'tree> {
6923 fn from_node(
6924 node: ::treesitter_types::tree_sitter::Node<'tree>,
6925 src: &'tree [u8],
6926 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6927 debug_assert_eq!(node.kind(), "interpolation_format_clause");
6928 Ok(Self {
6929 span: ::treesitter_types::Span::from(node),
6930 text: node.utf8_text(src)?,
6931 })
6932 }
6933}
6934impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationFormatClause<'tree> {
6935 fn text(&self) -> &'tree str {
6936 self.text
6937 }
6938}
6939impl ::treesitter_types::Spanned for InterpolationFormatClause<'_> {
6940 fn span(&self) -> ::treesitter_types::Span {
6941 self.span
6942 }
6943}
6944#[derive(Debug, Clone, PartialEq, Eq)]
6945pub struct InvocationExpression<'tree> {
6946 pub span: ::treesitter_types::Span,
6947 pub arguments: ArgumentList<'tree>,
6948 pub function: Expression<'tree>,
6949}
6950impl<'tree> ::treesitter_types::FromNode<'tree> for InvocationExpression<'tree> {
6951 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6952 fn from_node(
6953 node: ::treesitter_types::tree_sitter::Node<'tree>,
6954 src: &'tree [u8],
6955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6956 debug_assert_eq!(node.kind(), "invocation_expression");
6957 Ok(Self {
6958 span: ::treesitter_types::Span::from(node),
6959 arguments: {
6960 let child = node.child_by_field_name("arguments").ok_or_else(|| {
6961 ::treesitter_types::ParseError::missing_field("arguments", node)
6962 })?;
6963 ::treesitter_types::runtime::maybe_grow_stack(|| {
6964 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
6965 })?
6966 },
6967 function: {
6968 let child = node.child_by_field_name("function").ok_or_else(|| {
6969 ::treesitter_types::ParseError::missing_field("function", node)
6970 })?;
6971 ::treesitter_types::runtime::maybe_grow_stack(|| {
6972 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6973 })?
6974 },
6975 })
6976 }
6977}
6978impl ::treesitter_types::Spanned for InvocationExpression<'_> {
6979 fn span(&self) -> ::treesitter_types::Span {
6980 self.span
6981 }
6982}
6983#[derive(Debug, Clone, PartialEq, Eq)]
6984pub struct IsExpression<'tree> {
6985 pub span: ::treesitter_types::Span,
6986 pub left: Expression<'tree>,
6987 pub operator: IsExpressionOperator,
6988 pub right: Type<'tree>,
6989}
6990impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpression<'tree> {
6991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6992 fn from_node(
6993 node: ::treesitter_types::tree_sitter::Node<'tree>,
6994 src: &'tree [u8],
6995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6996 debug_assert_eq!(node.kind(), "is_expression");
6997 Ok(Self {
6998 span: ::treesitter_types::Span::from(node),
6999 left: {
7000 let child = node
7001 .child_by_field_name("left")
7002 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
7003 ::treesitter_types::runtime::maybe_grow_stack(|| {
7004 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7005 })?
7006 },
7007 operator: {
7008 let child = node.child_by_field_name("operator").ok_or_else(|| {
7009 ::treesitter_types::ParseError::missing_field("operator", node)
7010 })?;
7011 ::treesitter_types::runtime::maybe_grow_stack(|| {
7012 <IsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
7013 })?
7014 },
7015 right: {
7016 let child = node
7017 .child_by_field_name("right")
7018 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
7019 ::treesitter_types::runtime::maybe_grow_stack(|| {
7020 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7021 })?
7022 },
7023 })
7024 }
7025}
7026impl ::treesitter_types::Spanned for IsExpression<'_> {
7027 fn span(&self) -> ::treesitter_types::Span {
7028 self.span
7029 }
7030}
7031#[derive(Debug, Clone, PartialEq, Eq)]
7032pub struct IsPatternExpression<'tree> {
7033 pub span: ::treesitter_types::Span,
7034 pub expression: Expression<'tree>,
7035 pub pattern: Pattern<'tree>,
7036}
7037impl<'tree> ::treesitter_types::FromNode<'tree> for IsPatternExpression<'tree> {
7038 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7039 fn from_node(
7040 node: ::treesitter_types::tree_sitter::Node<'tree>,
7041 src: &'tree [u8],
7042 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7043 debug_assert_eq!(node.kind(), "is_pattern_expression");
7044 Ok(Self {
7045 span: ::treesitter_types::Span::from(node),
7046 expression: {
7047 let child = node.child_by_field_name("expression").ok_or_else(|| {
7048 ::treesitter_types::ParseError::missing_field("expression", node)
7049 })?;
7050 ::treesitter_types::runtime::maybe_grow_stack(|| {
7051 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7052 })?
7053 },
7054 pattern: {
7055 let child = node.child_by_field_name("pattern").ok_or_else(|| {
7056 ::treesitter_types::ParseError::missing_field("pattern", node)
7057 })?;
7058 ::treesitter_types::runtime::maybe_grow_stack(|| {
7059 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
7060 })?
7061 },
7062 })
7063 }
7064}
7065impl ::treesitter_types::Spanned for IsPatternExpression<'_> {
7066 fn span(&self) -> ::treesitter_types::Span {
7067 self.span
7068 }
7069}
7070#[derive(Debug, Clone, PartialEq, Eq)]
7071pub struct JoinClause<'tree> {
7072 pub span: ::treesitter_types::Span,
7073 pub r#type: ::core::option::Option<Type<'tree>>,
7074 pub children: ::std::vec::Vec<JoinClauseChildren<'tree>>,
7075}
7076impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClause<'tree> {
7077 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7078 fn from_node(
7079 node: ::treesitter_types::tree_sitter::Node<'tree>,
7080 src: &'tree [u8],
7081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7082 debug_assert_eq!(node.kind(), "join_clause");
7083 Ok(Self {
7084 span: ::treesitter_types::Span::from(node),
7085 r#type: match node.child_by_field_name("type") {
7086 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7087 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7088 })?),
7089 None => None,
7090 },
7091 children: {
7092 #[allow(clippy::suspicious_else_formatting)]
7093 let non_field_children = {
7094 let mut cursor = node.walk();
7095 let mut result = ::std::vec::Vec::new();
7096 if cursor.goto_first_child() {
7097 loop {
7098 if cursor.field_name().is_none()
7099 && cursor.node().is_named()
7100 && !cursor.node().is_extra()
7101 {
7102 result.push(cursor.node());
7103 }
7104 if !cursor.goto_next_sibling() {
7105 break;
7106 }
7107 }
7108 }
7109 result
7110 };
7111 let mut items = ::std::vec::Vec::new();
7112 for child in non_field_children {
7113 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7114 <JoinClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
7115 })?);
7116 }
7117 items
7118 },
7119 })
7120 }
7121}
7122impl ::treesitter_types::Spanned for JoinClause<'_> {
7123 fn span(&self) -> ::treesitter_types::Span {
7124 self.span
7125 }
7126}
7127#[derive(Debug, Clone, PartialEq, Eq)]
7128pub struct JoinIntoClause<'tree> {
7129 pub span: ::treesitter_types::Span,
7130 pub children: Identifier<'tree>,
7131}
7132impl<'tree> ::treesitter_types::FromNode<'tree> for JoinIntoClause<'tree> {
7133 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7134 fn from_node(
7135 node: ::treesitter_types::tree_sitter::Node<'tree>,
7136 src: &'tree [u8],
7137 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7138 debug_assert_eq!(node.kind(), "join_into_clause");
7139 Ok(Self {
7140 span: ::treesitter_types::Span::from(node),
7141 children: {
7142 #[allow(clippy::suspicious_else_formatting)]
7143 let non_field_children = {
7144 let mut cursor = node.walk();
7145 let mut result = ::std::vec::Vec::new();
7146 if cursor.goto_first_child() {
7147 loop {
7148 if cursor.field_name().is_none()
7149 && cursor.node().is_named()
7150 && !cursor.node().is_extra()
7151 {
7152 result.push(cursor.node());
7153 }
7154 if !cursor.goto_next_sibling() {
7155 break;
7156 }
7157 }
7158 }
7159 result
7160 };
7161 let child = if let Some(&c) = non_field_children.first() {
7162 c
7163 } else {
7164 let mut fallback_cursor = node.walk();
7165 let mut fallback_child = None;
7166 if fallback_cursor.goto_first_child() {
7167 loop {
7168 if fallback_cursor.field_name().is_none()
7169 && !fallback_cursor.node().is_extra()
7170 {
7171 let candidate = fallback_cursor.node();
7172 #[allow(clippy::needless_question_mark)]
7173 if (|| -> ::core::result::Result<
7174 _,
7175 ::treesitter_types::ParseError,
7176 > {
7177 let child = candidate;
7178 Ok(
7179 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
7180 child,
7181 src,
7182 ))?,
7183 )
7184 })()
7185 .is_ok()
7186 {
7187 fallback_child = Some(candidate);
7188 break;
7189 }
7190 }
7191 if !fallback_cursor.goto_next_sibling() {
7192 break;
7193 }
7194 }
7195 }
7196 if fallback_child.is_none() {
7197 let mut cursor2 = node.walk();
7198 if cursor2.goto_first_child() {
7199 loop {
7200 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7201 let candidate = cursor2.node();
7202 #[allow(clippy::needless_question_mark)]
7203 if (|| -> ::core::result::Result<
7204 _,
7205 ::treesitter_types::ParseError,
7206 > {
7207 let child = candidate;
7208 Ok(
7209 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
7210 child,
7211 src,
7212 ))?,
7213 )
7214 })()
7215 .is_ok()
7216 {
7217 fallback_child = Some(candidate);
7218 break;
7219 }
7220 }
7221 if !cursor2.goto_next_sibling() {
7222 break;
7223 }
7224 }
7225 }
7226 }
7227 fallback_child.ok_or_else(|| {
7228 ::treesitter_types::ParseError::missing_field("children", node)
7229 })?
7230 };
7231 ::treesitter_types::runtime::maybe_grow_stack(|| {
7232 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7233 })?
7234 },
7235 })
7236 }
7237}
7238impl ::treesitter_types::Spanned for JoinIntoClause<'_> {
7239 fn span(&self) -> ::treesitter_types::Span {
7240 self.span
7241 }
7242}
7243#[derive(Debug, Clone, PartialEq, Eq)]
7244pub struct LabeledStatement<'tree> {
7245 pub span: ::treesitter_types::Span,
7246 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
7247}
7248impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
7249 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7250 fn from_node(
7251 node: ::treesitter_types::tree_sitter::Node<'tree>,
7252 src: &'tree [u8],
7253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7254 debug_assert_eq!(node.kind(), "labeled_statement");
7255 Ok(Self {
7256 span: ::treesitter_types::Span::from(node),
7257 children: {
7258 #[allow(clippy::suspicious_else_formatting)]
7259 let non_field_children = {
7260 let mut cursor = node.walk();
7261 let mut result = ::std::vec::Vec::new();
7262 if cursor.goto_first_child() {
7263 loop {
7264 if cursor.field_name().is_none()
7265 && cursor.node().is_named()
7266 && !cursor.node().is_extra()
7267 {
7268 result.push(cursor.node());
7269 }
7270 if !cursor.goto_next_sibling() {
7271 break;
7272 }
7273 }
7274 }
7275 result
7276 };
7277 let mut items = ::std::vec::Vec::new();
7278 for child in non_field_children {
7279 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7280 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
7281 child, src,
7282 )
7283 })?);
7284 }
7285 items
7286 },
7287 })
7288 }
7289}
7290impl ::treesitter_types::Spanned for LabeledStatement<'_> {
7291 fn span(&self) -> ::treesitter_types::Span {
7292 self.span
7293 }
7294}
7295#[derive(Debug, Clone, PartialEq, Eq)]
7296pub struct LambdaExpression<'tree> {
7297 pub span: ::treesitter_types::Span,
7298 pub body: LambdaExpressionBody<'tree>,
7299 pub parameters: LambdaExpressionParameters<'tree>,
7300 pub r#type: ::core::option::Option<Type<'tree>>,
7301 pub children: ::std::vec::Vec<LambdaExpressionChildren<'tree>>,
7302}
7303impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
7304 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7305 fn from_node(
7306 node: ::treesitter_types::tree_sitter::Node<'tree>,
7307 src: &'tree [u8],
7308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7309 debug_assert_eq!(node.kind(), "lambda_expression");
7310 Ok(Self {
7311 span: ::treesitter_types::Span::from(node),
7312 body: {
7313 let child = node
7314 .child_by_field_name("body")
7315 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7316 ::treesitter_types::runtime::maybe_grow_stack(|| {
7317 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)
7318 })?
7319 },
7320 parameters: {
7321 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7322 ::treesitter_types::ParseError::missing_field("parameters", node)
7323 })?;
7324 ::treesitter_types::runtime::maybe_grow_stack(|| {
7325 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(
7326 child, src,
7327 )
7328 })?
7329 },
7330 r#type: match node.child_by_field_name("type") {
7331 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7332 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7333 })?),
7334 None => None,
7335 },
7336 children: {
7337 #[allow(clippy::suspicious_else_formatting)]
7338 let non_field_children = {
7339 let mut cursor = node.walk();
7340 let mut result = ::std::vec::Vec::new();
7341 if cursor.goto_first_child() {
7342 loop {
7343 if cursor.field_name().is_none()
7344 && cursor.node().is_named()
7345 && !cursor.node().is_extra()
7346 {
7347 result.push(cursor.node());
7348 }
7349 if !cursor.goto_next_sibling() {
7350 break;
7351 }
7352 }
7353 }
7354 result
7355 };
7356 let mut items = ::std::vec::Vec::new();
7357 for child in non_field_children {
7358 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7359 <LambdaExpressionChildren as ::treesitter_types::FromNode>::from_node(
7360 child, src,
7361 )
7362 })?);
7363 }
7364 items
7365 },
7366 })
7367 }
7368}
7369impl ::treesitter_types::Spanned for LambdaExpression<'_> {
7370 fn span(&self) -> ::treesitter_types::Span {
7371 self.span
7372 }
7373}
7374#[derive(Debug, Clone, PartialEq, Eq)]
7375pub struct LetClause<'tree> {
7376 pub span: ::treesitter_types::Span,
7377 pub children: ::std::vec::Vec<LetClauseChildren<'tree>>,
7378}
7379impl<'tree> ::treesitter_types::FromNode<'tree> for LetClause<'tree> {
7380 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7381 fn from_node(
7382 node: ::treesitter_types::tree_sitter::Node<'tree>,
7383 src: &'tree [u8],
7384 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7385 debug_assert_eq!(node.kind(), "let_clause");
7386 Ok(Self {
7387 span: ::treesitter_types::Span::from(node),
7388 children: {
7389 #[allow(clippy::suspicious_else_formatting)]
7390 let non_field_children = {
7391 let mut cursor = node.walk();
7392 let mut result = ::std::vec::Vec::new();
7393 if cursor.goto_first_child() {
7394 loop {
7395 if cursor.field_name().is_none()
7396 && cursor.node().is_named()
7397 && !cursor.node().is_extra()
7398 {
7399 result.push(cursor.node());
7400 }
7401 if !cursor.goto_next_sibling() {
7402 break;
7403 }
7404 }
7405 }
7406 result
7407 };
7408 let mut items = ::std::vec::Vec::new();
7409 for child in non_field_children {
7410 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7411 <LetClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
7412 })?);
7413 }
7414 items
7415 },
7416 })
7417 }
7418}
7419impl ::treesitter_types::Spanned for LetClause<'_> {
7420 fn span(&self) -> ::treesitter_types::Span {
7421 self.span
7422 }
7423}
7424#[derive(Debug, Clone, PartialEq, Eq)]
7425pub struct ListPattern<'tree> {
7426 pub span: ::treesitter_types::Span,
7427 pub children: ::std::vec::Vec<Pattern<'tree>>,
7428}
7429impl<'tree> ::treesitter_types::FromNode<'tree> for ListPattern<'tree> {
7430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7431 fn from_node(
7432 node: ::treesitter_types::tree_sitter::Node<'tree>,
7433 src: &'tree [u8],
7434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7435 debug_assert_eq!(node.kind(), "list_pattern");
7436 Ok(Self {
7437 span: ::treesitter_types::Span::from(node),
7438 children: {
7439 #[allow(clippy::suspicious_else_formatting)]
7440 let non_field_children = {
7441 let mut cursor = node.walk();
7442 let mut result = ::std::vec::Vec::new();
7443 if cursor.goto_first_child() {
7444 loop {
7445 if cursor.field_name().is_none()
7446 && cursor.node().is_named()
7447 && !cursor.node().is_extra()
7448 {
7449 result.push(cursor.node());
7450 }
7451 if !cursor.goto_next_sibling() {
7452 break;
7453 }
7454 }
7455 }
7456 result
7457 };
7458 let mut items = ::std::vec::Vec::new();
7459 for child in non_field_children {
7460 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7461 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
7462 })?);
7463 }
7464 items
7465 },
7466 })
7467 }
7468}
7469impl ::treesitter_types::Spanned for ListPattern<'_> {
7470 fn span(&self) -> ::treesitter_types::Span {
7471 self.span
7472 }
7473}
7474#[derive(Debug, Clone, PartialEq, Eq)]
7475pub struct LocalDeclarationStatement<'tree> {
7476 pub span: ::treesitter_types::Span,
7477 pub children: ::std::vec::Vec<LocalDeclarationStatementChildren<'tree>>,
7478}
7479impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatement<'tree> {
7480 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7481 fn from_node(
7482 node: ::treesitter_types::tree_sitter::Node<'tree>,
7483 src: &'tree [u8],
7484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7485 debug_assert_eq!(node.kind(), "local_declaration_statement");
7486 Ok(Self {
7487 span: ::treesitter_types::Span::from(node),
7488 children: {
7489 #[allow(clippy::suspicious_else_formatting)]
7490 let non_field_children = {
7491 let mut cursor = node.walk();
7492 let mut result = ::std::vec::Vec::new();
7493 if cursor.goto_first_child() {
7494 loop {
7495 if cursor.field_name().is_none()
7496 && cursor.node().is_named()
7497 && !cursor.node().is_extra()
7498 {
7499 result.push(cursor.node());
7500 }
7501 if !cursor.goto_next_sibling() {
7502 break;
7503 }
7504 }
7505 }
7506 result
7507 };
7508 let mut items = ::std::vec::Vec::new();
7509 for child in non_field_children {
7510 items
7511 .push(
7512 ::treesitter_types::runtime::maybe_grow_stack(|| <LocalDeclarationStatementChildren as ::treesitter_types::FromNode>::from_node(
7513 child,
7514 src,
7515 ))?,
7516 );
7517 }
7518 items
7519 },
7520 })
7521 }
7522}
7523impl ::treesitter_types::Spanned for LocalDeclarationStatement<'_> {
7524 fn span(&self) -> ::treesitter_types::Span {
7525 self.span
7526 }
7527}
7528#[derive(Debug, Clone, PartialEq, Eq)]
7529pub struct LocalFunctionStatement<'tree> {
7530 pub span: ::treesitter_types::Span,
7531 pub body: ::core::option::Option<LocalFunctionStatementBody<'tree>>,
7532 pub name: Identifier<'tree>,
7533 pub parameters: ParameterList<'tree>,
7534 pub r#type: Type<'tree>,
7535 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
7536 pub children: ::std::vec::Vec<LocalFunctionStatementChildren<'tree>>,
7537}
7538impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatement<'tree> {
7539 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7540 fn from_node(
7541 node: ::treesitter_types::tree_sitter::Node<'tree>,
7542 src: &'tree [u8],
7543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7544 debug_assert_eq!(node.kind(), "local_function_statement");
7545 Ok(Self {
7546 span: ::treesitter_types::Span::from(node),
7547 body: match node.child_by_field_name("body") {
7548 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7549 <LocalFunctionStatementBody as ::treesitter_types::FromNode>::from_node(
7550 child, src,
7551 )
7552 })?),
7553 None => None,
7554 },
7555 name: {
7556 let child = node
7557 .child_by_field_name("name")
7558 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7559 ::treesitter_types::runtime::maybe_grow_stack(|| {
7560 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7561 })?
7562 },
7563 parameters: {
7564 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7565 ::treesitter_types::ParseError::missing_field("parameters", node)
7566 })?;
7567 ::treesitter_types::runtime::maybe_grow_stack(|| {
7568 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7569 })?
7570 },
7571 r#type: {
7572 let child = node
7573 .child_by_field_name("type")
7574 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7575 ::treesitter_types::runtime::maybe_grow_stack(|| {
7576 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7577 })?
7578 },
7579 type_parameters: match node.child_by_field_name("type_parameters") {
7580 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7581 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7582 })?),
7583 None => None,
7584 },
7585 children: {
7586 #[allow(clippy::suspicious_else_formatting)]
7587 let non_field_children = {
7588 let mut cursor = node.walk();
7589 let mut result = ::std::vec::Vec::new();
7590 if cursor.goto_first_child() {
7591 loop {
7592 if cursor.field_name().is_none()
7593 && cursor.node().is_named()
7594 && !cursor.node().is_extra()
7595 {
7596 result.push(cursor.node());
7597 }
7598 if !cursor.goto_next_sibling() {
7599 break;
7600 }
7601 }
7602 }
7603 result
7604 };
7605 let mut items = ::std::vec::Vec::new();
7606 for child in non_field_children {
7607 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7608 <LocalFunctionStatementChildren as ::treesitter_types::FromNode>::from_node(
7609 child, src,
7610 )
7611 })?);
7612 }
7613 items
7614 },
7615 })
7616 }
7617}
7618impl ::treesitter_types::Spanned for LocalFunctionStatement<'_> {
7619 fn span(&self) -> ::treesitter_types::Span {
7620 self.span
7621 }
7622}
7623#[derive(Debug, Clone, PartialEq, Eq)]
7624pub struct LockStatement<'tree> {
7625 pub span: ::treesitter_types::Span,
7626 pub children: ::std::vec::Vec<LockStatementChildren<'tree>>,
7627}
7628impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatement<'tree> {
7629 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7630 fn from_node(
7631 node: ::treesitter_types::tree_sitter::Node<'tree>,
7632 src: &'tree [u8],
7633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7634 debug_assert_eq!(node.kind(), "lock_statement");
7635 Ok(Self {
7636 span: ::treesitter_types::Span::from(node),
7637 children: {
7638 #[allow(clippy::suspicious_else_formatting)]
7639 let non_field_children = {
7640 let mut cursor = node.walk();
7641 let mut result = ::std::vec::Vec::new();
7642 if cursor.goto_first_child() {
7643 loop {
7644 if cursor.field_name().is_none()
7645 && cursor.node().is_named()
7646 && !cursor.node().is_extra()
7647 {
7648 result.push(cursor.node());
7649 }
7650 if !cursor.goto_next_sibling() {
7651 break;
7652 }
7653 }
7654 }
7655 result
7656 };
7657 let mut items = ::std::vec::Vec::new();
7658 for child in non_field_children {
7659 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7660 <LockStatementChildren as ::treesitter_types::FromNode>::from_node(
7661 child, src,
7662 )
7663 })?);
7664 }
7665 items
7666 },
7667 })
7668 }
7669}
7670impl ::treesitter_types::Spanned for LockStatement<'_> {
7671 fn span(&self) -> ::treesitter_types::Span {
7672 self.span
7673 }
7674}
7675#[derive(Debug, Clone, PartialEq, Eq)]
7676pub struct MakerefExpression<'tree> {
7677 pub span: ::treesitter_types::Span,
7678 pub children: Expression<'tree>,
7679}
7680impl<'tree> ::treesitter_types::FromNode<'tree> for MakerefExpression<'tree> {
7681 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7682 fn from_node(
7683 node: ::treesitter_types::tree_sitter::Node<'tree>,
7684 src: &'tree [u8],
7685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7686 debug_assert_eq!(node.kind(), "makeref_expression");
7687 Ok(Self {
7688 span: ::treesitter_types::Span::from(node),
7689 children: {
7690 #[allow(clippy::suspicious_else_formatting)]
7691 let non_field_children = {
7692 let mut cursor = node.walk();
7693 let mut result = ::std::vec::Vec::new();
7694 if cursor.goto_first_child() {
7695 loop {
7696 if cursor.field_name().is_none()
7697 && cursor.node().is_named()
7698 && !cursor.node().is_extra()
7699 {
7700 result.push(cursor.node());
7701 }
7702 if !cursor.goto_next_sibling() {
7703 break;
7704 }
7705 }
7706 }
7707 result
7708 };
7709 let child = if let Some(&c) = non_field_children.first() {
7710 c
7711 } else {
7712 let mut fallback_cursor = node.walk();
7713 let mut fallback_child = None;
7714 if fallback_cursor.goto_first_child() {
7715 loop {
7716 if fallback_cursor.field_name().is_none()
7717 && !fallback_cursor.node().is_extra()
7718 {
7719 let candidate = fallback_cursor.node();
7720 #[allow(clippy::needless_question_mark)]
7721 if (|| -> ::core::result::Result<
7722 _,
7723 ::treesitter_types::ParseError,
7724 > {
7725 let child = candidate;
7726 Ok(
7727 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7728 child,
7729 src,
7730 ))?,
7731 )
7732 })()
7733 .is_ok()
7734 {
7735 fallback_child = Some(candidate);
7736 break;
7737 }
7738 }
7739 if !fallback_cursor.goto_next_sibling() {
7740 break;
7741 }
7742 }
7743 }
7744 if fallback_child.is_none() {
7745 let mut cursor2 = node.walk();
7746 if cursor2.goto_first_child() {
7747 loop {
7748 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7749 let candidate = cursor2.node();
7750 #[allow(clippy::needless_question_mark)]
7751 if (|| -> ::core::result::Result<
7752 _,
7753 ::treesitter_types::ParseError,
7754 > {
7755 let child = candidate;
7756 Ok(
7757 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7758 child,
7759 src,
7760 ))?,
7761 )
7762 })()
7763 .is_ok()
7764 {
7765 fallback_child = Some(candidate);
7766 break;
7767 }
7768 }
7769 if !cursor2.goto_next_sibling() {
7770 break;
7771 }
7772 }
7773 }
7774 }
7775 fallback_child.ok_or_else(|| {
7776 ::treesitter_types::ParseError::missing_field("children", node)
7777 })?
7778 };
7779 ::treesitter_types::runtime::maybe_grow_stack(|| {
7780 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7781 })?
7782 },
7783 })
7784 }
7785}
7786impl ::treesitter_types::Spanned for MakerefExpression<'_> {
7787 fn span(&self) -> ::treesitter_types::Span {
7788 self.span
7789 }
7790}
7791#[derive(Debug, Clone, PartialEq, Eq)]
7792pub struct MemberAccessExpression<'tree> {
7793 pub span: ::treesitter_types::Span,
7794 pub expression: MemberAccessExpressionExpression<'tree>,
7795 pub name: MemberAccessExpressionName<'tree>,
7796}
7797impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpression<'tree> {
7798 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7799 fn from_node(
7800 node: ::treesitter_types::tree_sitter::Node<'tree>,
7801 src: &'tree [u8],
7802 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7803 debug_assert_eq!(node.kind(), "member_access_expression");
7804 Ok(Self {
7805 span: ::treesitter_types::Span::from(node),
7806 expression: {
7807 let child = node.child_by_field_name("expression").ok_or_else(|| {
7808 ::treesitter_types::ParseError::missing_field("expression", node)
7809 })?;
7810 ::treesitter_types::runtime::maybe_grow_stack(|| {
7811 <MemberAccessExpressionExpression as ::treesitter_types::FromNode>::from_node(
7812 child, src,
7813 )
7814 })?
7815 },
7816 name: {
7817 let child = node
7818 .child_by_field_name("name")
7819 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7820 ::treesitter_types::runtime::maybe_grow_stack(|| {
7821 <MemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(
7822 child, src,
7823 )
7824 })?
7825 },
7826 })
7827 }
7828}
7829impl ::treesitter_types::Spanned for MemberAccessExpression<'_> {
7830 fn span(&self) -> ::treesitter_types::Span {
7831 self.span
7832 }
7833}
7834#[derive(Debug, Clone, PartialEq, Eq)]
7835pub struct MemberBindingExpression<'tree> {
7836 pub span: ::treesitter_types::Span,
7837 pub name: MemberBindingExpressionName<'tree>,
7838}
7839impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpression<'tree> {
7840 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7841 fn from_node(
7842 node: ::treesitter_types::tree_sitter::Node<'tree>,
7843 src: &'tree [u8],
7844 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7845 debug_assert_eq!(node.kind(), "member_binding_expression");
7846 Ok(Self {
7847 span: ::treesitter_types::Span::from(node),
7848 name: {
7849 let child = node
7850 .child_by_field_name("name")
7851 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7852 ::treesitter_types::runtime::maybe_grow_stack(|| {
7853 <MemberBindingExpressionName as ::treesitter_types::FromNode>::from_node(
7854 child, src,
7855 )
7856 })?
7857 },
7858 })
7859 }
7860}
7861impl ::treesitter_types::Spanned for MemberBindingExpression<'_> {
7862 fn span(&self) -> ::treesitter_types::Span {
7863 self.span
7864 }
7865}
7866#[derive(Debug, Clone, PartialEq, Eq)]
7867pub struct MethodDeclaration<'tree> {
7868 pub span: ::treesitter_types::Span,
7869 pub body: ::core::option::Option<MethodDeclarationBody<'tree>>,
7870 pub name: Identifier<'tree>,
7871 pub parameters: ParameterList<'tree>,
7872 pub returns: Type<'tree>,
7873 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
7874 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
7875}
7876impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
7877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7878 fn from_node(
7879 node: ::treesitter_types::tree_sitter::Node<'tree>,
7880 src: &'tree [u8],
7881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7882 debug_assert_eq!(node.kind(), "method_declaration");
7883 Ok(Self {
7884 span: ::treesitter_types::Span::from(node),
7885 body: match node.child_by_field_name("body") {
7886 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7887 <MethodDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
7888 })?),
7889 None => None,
7890 },
7891 name: {
7892 let child = node
7893 .child_by_field_name("name")
7894 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7895 ::treesitter_types::runtime::maybe_grow_stack(|| {
7896 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7897 })?
7898 },
7899 parameters: {
7900 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7901 ::treesitter_types::ParseError::missing_field("parameters", node)
7902 })?;
7903 ::treesitter_types::runtime::maybe_grow_stack(|| {
7904 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7905 })?
7906 },
7907 returns: {
7908 let child = node.child_by_field_name("returns").ok_or_else(|| {
7909 ::treesitter_types::ParseError::missing_field("returns", node)
7910 })?;
7911 ::treesitter_types::runtime::maybe_grow_stack(|| {
7912 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7913 })?
7914 },
7915 type_parameters: match node.child_by_field_name("type_parameters") {
7916 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7917 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7918 })?),
7919 None => None,
7920 },
7921 children: {
7922 #[allow(clippy::suspicious_else_formatting)]
7923 let non_field_children = {
7924 let mut cursor = node.walk();
7925 let mut result = ::std::vec::Vec::new();
7926 if cursor.goto_first_child() {
7927 loop {
7928 if cursor.field_name().is_none()
7929 && cursor.node().is_named()
7930 && !cursor.node().is_extra()
7931 {
7932 result.push(cursor.node());
7933 }
7934 if !cursor.goto_next_sibling() {
7935 break;
7936 }
7937 }
7938 }
7939 result
7940 };
7941 let mut items = ::std::vec::Vec::new();
7942 for child in non_field_children {
7943 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7944 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7945 child, src,
7946 )
7947 })?);
7948 }
7949 items
7950 },
7951 })
7952 }
7953}
7954impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
7955 fn span(&self) -> ::treesitter_types::Span {
7956 self.span
7957 }
7958}
7959#[derive(Debug, Clone, PartialEq, Eq)]
7960pub struct Modifier<'tree> {
7961 pub span: ::treesitter_types::Span,
7962 text: &'tree str,
7963}
7964impl<'tree> ::treesitter_types::FromNode<'tree> for Modifier<'tree> {
7965 fn from_node(
7966 node: ::treesitter_types::tree_sitter::Node<'tree>,
7967 src: &'tree [u8],
7968 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7969 debug_assert_eq!(node.kind(), "modifier");
7970 Ok(Self {
7971 span: ::treesitter_types::Span::from(node),
7972 text: node.utf8_text(src)?,
7973 })
7974 }
7975}
7976impl<'tree> ::treesitter_types::LeafNode<'tree> for Modifier<'tree> {
7977 fn text(&self) -> &'tree str {
7978 self.text
7979 }
7980}
7981impl ::treesitter_types::Spanned for Modifier<'_> {
7982 fn span(&self) -> ::treesitter_types::Span {
7983 self.span
7984 }
7985}
7986#[derive(Debug, Clone, PartialEq, Eq)]
7987pub struct NamespaceDeclaration<'tree> {
7988 pub span: ::treesitter_types::Span,
7989 pub body: DeclarationList<'tree>,
7990 pub name: NamespaceDeclarationName<'tree>,
7991}
7992impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclaration<'tree> {
7993 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7994 fn from_node(
7995 node: ::treesitter_types::tree_sitter::Node<'tree>,
7996 src: &'tree [u8],
7997 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7998 debug_assert_eq!(node.kind(), "namespace_declaration");
7999 Ok(Self {
8000 span: ::treesitter_types::Span::from(node),
8001 body: {
8002 let child = node
8003 .child_by_field_name("body")
8004 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8005 ::treesitter_types::runtime::maybe_grow_stack(|| {
8006 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
8007 })?
8008 },
8009 name: {
8010 let child = node
8011 .child_by_field_name("name")
8012 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8013 ::treesitter_types::runtime::maybe_grow_stack(|| {
8014 <NamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(
8015 child, src,
8016 )
8017 })?
8018 },
8019 })
8020 }
8021}
8022impl ::treesitter_types::Spanned for NamespaceDeclaration<'_> {
8023 fn span(&self) -> ::treesitter_types::Span {
8024 self.span
8025 }
8026}
8027#[derive(Debug, Clone, PartialEq, Eq)]
8028pub struct NegatedPattern<'tree> {
8029 pub span: ::treesitter_types::Span,
8030 pub children: Pattern<'tree>,
8031}
8032impl<'tree> ::treesitter_types::FromNode<'tree> for NegatedPattern<'tree> {
8033 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8034 fn from_node(
8035 node: ::treesitter_types::tree_sitter::Node<'tree>,
8036 src: &'tree [u8],
8037 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8038 debug_assert_eq!(node.kind(), "negated_pattern");
8039 Ok(Self {
8040 span: ::treesitter_types::Span::from(node),
8041 children: {
8042 #[allow(clippy::suspicious_else_formatting)]
8043 let non_field_children = {
8044 let mut cursor = node.walk();
8045 let mut result = ::std::vec::Vec::new();
8046 if cursor.goto_first_child() {
8047 loop {
8048 if cursor.field_name().is_none()
8049 && cursor.node().is_named()
8050 && !cursor.node().is_extra()
8051 {
8052 result.push(cursor.node());
8053 }
8054 if !cursor.goto_next_sibling() {
8055 break;
8056 }
8057 }
8058 }
8059 result
8060 };
8061 let child = if let Some(&c) = non_field_children.first() {
8062 c
8063 } else {
8064 let mut fallback_cursor = node.walk();
8065 let mut fallback_child = None;
8066 if fallback_cursor.goto_first_child() {
8067 loop {
8068 if fallback_cursor.field_name().is_none()
8069 && !fallback_cursor.node().is_extra()
8070 {
8071 let candidate = fallback_cursor.node();
8072 #[allow(clippy::needless_question_mark)]
8073 if (|| -> ::core::result::Result<
8074 _,
8075 ::treesitter_types::ParseError,
8076 > {
8077 let child = candidate;
8078 Ok(
8079 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8080 child,
8081 src,
8082 ))?,
8083 )
8084 })()
8085 .is_ok()
8086 {
8087 fallback_child = Some(candidate);
8088 break;
8089 }
8090 }
8091 if !fallback_cursor.goto_next_sibling() {
8092 break;
8093 }
8094 }
8095 }
8096 if fallback_child.is_none() {
8097 let mut cursor2 = node.walk();
8098 if cursor2.goto_first_child() {
8099 loop {
8100 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8101 let candidate = cursor2.node();
8102 #[allow(clippy::needless_question_mark)]
8103 if (|| -> ::core::result::Result<
8104 _,
8105 ::treesitter_types::ParseError,
8106 > {
8107 let child = candidate;
8108 Ok(
8109 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8110 child,
8111 src,
8112 ))?,
8113 )
8114 })()
8115 .is_ok()
8116 {
8117 fallback_child = Some(candidate);
8118 break;
8119 }
8120 }
8121 if !cursor2.goto_next_sibling() {
8122 break;
8123 }
8124 }
8125 }
8126 }
8127 fallback_child.ok_or_else(|| {
8128 ::treesitter_types::ParseError::missing_field("children", node)
8129 })?
8130 };
8131 ::treesitter_types::runtime::maybe_grow_stack(|| {
8132 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8133 })?
8134 },
8135 })
8136 }
8137}
8138impl ::treesitter_types::Spanned for NegatedPattern<'_> {
8139 fn span(&self) -> ::treesitter_types::Span {
8140 self.span
8141 }
8142}
8143#[derive(Debug, Clone, PartialEq, Eq)]
8144pub struct NullableType<'tree> {
8145 pub span: ::treesitter_types::Span,
8146 pub r#type: NullableTypeType<'tree>,
8147}
8148impl<'tree> ::treesitter_types::FromNode<'tree> for NullableType<'tree> {
8149 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8150 fn from_node(
8151 node: ::treesitter_types::tree_sitter::Node<'tree>,
8152 src: &'tree [u8],
8153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8154 debug_assert_eq!(node.kind(), "nullable_type");
8155 Ok(Self {
8156 span: ::treesitter_types::Span::from(node),
8157 r#type: {
8158 let child = node
8159 .child_by_field_name("type")
8160 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8161 ::treesitter_types::runtime::maybe_grow_stack(|| {
8162 <NullableTypeType as ::treesitter_types::FromNode>::from_node(child, src)
8163 })?
8164 },
8165 })
8166 }
8167}
8168impl ::treesitter_types::Spanned for NullableType<'_> {
8169 fn span(&self) -> ::treesitter_types::Span {
8170 self.span
8171 }
8172}
8173#[derive(Debug, Clone, PartialEq, Eq)]
8174pub struct ObjectCreationExpression<'tree> {
8175 pub span: ::treesitter_types::Span,
8176 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
8177 pub initializer: ::core::option::Option<InitializerExpression<'tree>>,
8178 pub r#type: Type<'tree>,
8179}
8180impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
8181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8182 fn from_node(
8183 node: ::treesitter_types::tree_sitter::Node<'tree>,
8184 src: &'tree [u8],
8185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8186 debug_assert_eq!(node.kind(), "object_creation_expression");
8187 Ok(Self {
8188 span: ::treesitter_types::Span::from(node),
8189 arguments: match node.child_by_field_name("arguments") {
8190 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8191 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
8192 })?),
8193 None => None,
8194 },
8195 initializer: match node.child_by_field_name("initializer") {
8196 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8197 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
8198 })?),
8199 None => None,
8200 },
8201 r#type: {
8202 let child = node
8203 .child_by_field_name("type")
8204 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8205 ::treesitter_types::runtime::maybe_grow_stack(|| {
8206 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8207 })?
8208 },
8209 })
8210 }
8211}
8212impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
8213 fn span(&self) -> ::treesitter_types::Span {
8214 self.span
8215 }
8216}
8217#[derive(Debug, Clone, PartialEq, Eq)]
8218pub struct OperatorDeclaration<'tree> {
8219 pub span: ::treesitter_types::Span,
8220 pub body: ::core::option::Option<OperatorDeclarationBody<'tree>>,
8221 pub operator: OperatorDeclarationOperator,
8222 pub parameters: ParameterList<'tree>,
8223 pub r#type: Type<'tree>,
8224 pub children: ::std::vec::Vec<OperatorDeclarationChildren<'tree>>,
8225}
8226impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclaration<'tree> {
8227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8228 fn from_node(
8229 node: ::treesitter_types::tree_sitter::Node<'tree>,
8230 src: &'tree [u8],
8231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8232 debug_assert_eq!(node.kind(), "operator_declaration");
8233 Ok(Self {
8234 span: ::treesitter_types::Span::from(node),
8235 body: match node.child_by_field_name("body") {
8236 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8237 <OperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
8238 })?),
8239 None => None,
8240 },
8241 operator: {
8242 let child = node.child_by_field_name("operator").ok_or_else(|| {
8243 ::treesitter_types::ParseError::missing_field("operator", node)
8244 })?;
8245 ::treesitter_types::runtime::maybe_grow_stack(|| {
8246 <OperatorDeclarationOperator as ::treesitter_types::FromNode>::from_node(
8247 child, src,
8248 )
8249 })?
8250 },
8251 parameters: {
8252 let child = node.child_by_field_name("parameters").ok_or_else(|| {
8253 ::treesitter_types::ParseError::missing_field("parameters", node)
8254 })?;
8255 ::treesitter_types::runtime::maybe_grow_stack(|| {
8256 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
8257 })?
8258 },
8259 r#type: {
8260 let child = node
8261 .child_by_field_name("type")
8262 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8263 ::treesitter_types::runtime::maybe_grow_stack(|| {
8264 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8265 })?
8266 },
8267 children: {
8268 #[allow(clippy::suspicious_else_formatting)]
8269 let non_field_children = {
8270 let mut cursor = node.walk();
8271 let mut result = ::std::vec::Vec::new();
8272 if cursor.goto_first_child() {
8273 loop {
8274 if cursor.field_name().is_none()
8275 && cursor.node().is_named()
8276 && !cursor.node().is_extra()
8277 {
8278 result.push(cursor.node());
8279 }
8280 if !cursor.goto_next_sibling() {
8281 break;
8282 }
8283 }
8284 }
8285 result
8286 };
8287 let mut items = ::std::vec::Vec::new();
8288 for child in non_field_children {
8289 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8290 <OperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
8291 child, src,
8292 )
8293 })?);
8294 }
8295 items
8296 },
8297 })
8298 }
8299}
8300impl ::treesitter_types::Spanned for OperatorDeclaration<'_> {
8301 fn span(&self) -> ::treesitter_types::Span {
8302 self.span
8303 }
8304}
8305#[derive(Debug, Clone, PartialEq, Eq)]
8306pub struct OrPattern<'tree> {
8307 pub span: ::treesitter_types::Span,
8308 pub left: Pattern<'tree>,
8309 pub operator: OrPatternOperator,
8310 pub right: Pattern<'tree>,
8311}
8312impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
8313 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8314 fn from_node(
8315 node: ::treesitter_types::tree_sitter::Node<'tree>,
8316 src: &'tree [u8],
8317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8318 debug_assert_eq!(node.kind(), "or_pattern");
8319 Ok(Self {
8320 span: ::treesitter_types::Span::from(node),
8321 left: {
8322 let child = node
8323 .child_by_field_name("left")
8324 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
8325 ::treesitter_types::runtime::maybe_grow_stack(|| {
8326 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8327 })?
8328 },
8329 operator: {
8330 let child = node.child_by_field_name("operator").ok_or_else(|| {
8331 ::treesitter_types::ParseError::missing_field("operator", node)
8332 })?;
8333 ::treesitter_types::runtime::maybe_grow_stack(|| {
8334 <OrPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)
8335 })?
8336 },
8337 right: {
8338 let child = node
8339 .child_by_field_name("right")
8340 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
8341 ::treesitter_types::runtime::maybe_grow_stack(|| {
8342 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8343 })?
8344 },
8345 })
8346 }
8347}
8348impl ::treesitter_types::Spanned for OrPattern<'_> {
8349 fn span(&self) -> ::treesitter_types::Span {
8350 self.span
8351 }
8352}
8353#[derive(Debug, Clone, PartialEq, Eq)]
8354pub struct OrderByClause<'tree> {
8355 pub span: ::treesitter_types::Span,
8356 pub children: ::std::vec::Vec<Expression<'tree>>,
8357}
8358impl<'tree> ::treesitter_types::FromNode<'tree> for OrderByClause<'tree> {
8359 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8360 fn from_node(
8361 node: ::treesitter_types::tree_sitter::Node<'tree>,
8362 src: &'tree [u8],
8363 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8364 debug_assert_eq!(node.kind(), "order_by_clause");
8365 Ok(Self {
8366 span: ::treesitter_types::Span::from(node),
8367 children: {
8368 #[allow(clippy::suspicious_else_formatting)]
8369 let non_field_children = {
8370 let mut cursor = node.walk();
8371 let mut result = ::std::vec::Vec::new();
8372 if cursor.goto_first_child() {
8373 loop {
8374 if cursor.field_name().is_none()
8375 && cursor.node().is_named()
8376 && !cursor.node().is_extra()
8377 {
8378 result.push(cursor.node());
8379 }
8380 if !cursor.goto_next_sibling() {
8381 break;
8382 }
8383 }
8384 }
8385 result
8386 };
8387 let mut items = ::std::vec::Vec::new();
8388 for child in non_field_children {
8389 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8390 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8391 })?);
8392 }
8393 items
8394 },
8395 })
8396 }
8397}
8398impl ::treesitter_types::Spanned for OrderByClause<'_> {
8399 fn span(&self) -> ::treesitter_types::Span {
8400 self.span
8401 }
8402}
8403#[derive(Debug, Clone, PartialEq, Eq)]
8404pub struct Parameter<'tree> {
8405 pub span: ::treesitter_types::Span,
8406 pub name: Identifier<'tree>,
8407 pub r#type: ::core::option::Option<Type<'tree>>,
8408 pub children: ::std::vec::Vec<ParameterChildren<'tree>>,
8409}
8410impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
8411 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8412 fn from_node(
8413 node: ::treesitter_types::tree_sitter::Node<'tree>,
8414 src: &'tree [u8],
8415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8416 debug_assert_eq!(node.kind(), "parameter");
8417 Ok(Self {
8418 span: ::treesitter_types::Span::from(node),
8419 name: {
8420 let child = node
8421 .child_by_field_name("name")
8422 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8423 ::treesitter_types::runtime::maybe_grow_stack(|| {
8424 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8425 })?
8426 },
8427 r#type: match node.child_by_field_name("type") {
8428 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8429 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8430 })?),
8431 None => None,
8432 },
8433 children: {
8434 #[allow(clippy::suspicious_else_formatting)]
8435 let non_field_children = {
8436 let mut cursor = node.walk();
8437 let mut result = ::std::vec::Vec::new();
8438 if cursor.goto_first_child() {
8439 loop {
8440 if cursor.field_name().is_none()
8441 && cursor.node().is_named()
8442 && !cursor.node().is_extra()
8443 {
8444 result.push(cursor.node());
8445 }
8446 if !cursor.goto_next_sibling() {
8447 break;
8448 }
8449 }
8450 }
8451 result
8452 };
8453 let mut items = ::std::vec::Vec::new();
8454 for child in non_field_children {
8455 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8456 <ParameterChildren as ::treesitter_types::FromNode>::from_node(child, src)
8457 })?);
8458 }
8459 items
8460 },
8461 })
8462 }
8463}
8464impl ::treesitter_types::Spanned for Parameter<'_> {
8465 fn span(&self) -> ::treesitter_types::Span {
8466 self.span
8467 }
8468}
8469#[derive(Debug, Clone, PartialEq, Eq)]
8470pub struct ParameterList<'tree> {
8471 pub span: ::treesitter_types::Span,
8472 pub name: ::std::vec::Vec<Identifier<'tree>>,
8473 pub r#type: ::std::vec::Vec<ParameterListType<'tree>>,
8474 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
8475}
8476impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
8477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8478 fn from_node(
8479 node: ::treesitter_types::tree_sitter::Node<'tree>,
8480 src: &'tree [u8],
8481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8482 debug_assert_eq!(node.kind(), "parameter_list");
8483 Ok(Self {
8484 span: ::treesitter_types::Span::from(node),
8485 name: {
8486 let mut cursor = node.walk();
8487 let mut items = ::std::vec::Vec::new();
8488 for child in node.children_by_field_name("name", &mut cursor) {
8489 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8490 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8491 })?);
8492 }
8493 items
8494 },
8495 r#type: {
8496 let mut cursor = node.walk();
8497 let mut items = ::std::vec::Vec::new();
8498 for child in node.children_by_field_name("type", &mut cursor) {
8499 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8500 <ParameterListType as ::treesitter_types::FromNode>::from_node(child, src)
8501 })?);
8502 }
8503 items
8504 },
8505 children: {
8506 #[allow(clippy::suspicious_else_formatting)]
8507 let non_field_children = {
8508 let mut cursor = node.walk();
8509 let mut result = ::std::vec::Vec::new();
8510 if cursor.goto_first_child() {
8511 loop {
8512 if cursor.field_name().is_none()
8513 && cursor.node().is_named()
8514 && !cursor.node().is_extra()
8515 {
8516 result.push(cursor.node());
8517 }
8518 if !cursor.goto_next_sibling() {
8519 break;
8520 }
8521 }
8522 }
8523 result
8524 };
8525 let mut items = ::std::vec::Vec::new();
8526 for child in non_field_children {
8527 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8528 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
8529 child, src,
8530 )
8531 })?);
8532 }
8533 items
8534 },
8535 })
8536 }
8537}
8538impl ::treesitter_types::Spanned for ParameterList<'_> {
8539 fn span(&self) -> ::treesitter_types::Span {
8540 self.span
8541 }
8542}
8543#[derive(Debug, Clone, PartialEq, Eq)]
8544pub struct ParenthesizedExpression<'tree> {
8545 pub span: ::treesitter_types::Span,
8546 pub children: ParenthesizedExpressionChildren<'tree>,
8547}
8548impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
8549 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8550 fn from_node(
8551 node: ::treesitter_types::tree_sitter::Node<'tree>,
8552 src: &'tree [u8],
8553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8554 debug_assert_eq!(node.kind(), "parenthesized_expression");
8555 Ok(Self {
8556 span: ::treesitter_types::Span::from(node),
8557 children: {
8558 #[allow(clippy::suspicious_else_formatting)]
8559 let non_field_children = {
8560 let mut cursor = node.walk();
8561 let mut result = ::std::vec::Vec::new();
8562 if cursor.goto_first_child() {
8563 loop {
8564 if cursor.field_name().is_none()
8565 && cursor.node().is_named()
8566 && !cursor.node().is_extra()
8567 {
8568 result.push(cursor.node());
8569 }
8570 if !cursor.goto_next_sibling() {
8571 break;
8572 }
8573 }
8574 }
8575 result
8576 };
8577 let child = if let Some(&c) = non_field_children.first() {
8578 c
8579 } else {
8580 let mut fallback_cursor = node.walk();
8581 let mut fallback_child = None;
8582 if fallback_cursor.goto_first_child() {
8583 loop {
8584 if fallback_cursor.field_name().is_none()
8585 && !fallback_cursor.node().is_extra()
8586 {
8587 let candidate = fallback_cursor.node();
8588 #[allow(clippy::needless_question_mark)]
8589 if (|| -> ::core::result::Result<
8590 _,
8591 ::treesitter_types::ParseError,
8592 > {
8593 let child = candidate;
8594 Ok(
8595 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8596 child,
8597 src,
8598 ))?,
8599 )
8600 })()
8601 .is_ok()
8602 {
8603 fallback_child = Some(candidate);
8604 break;
8605 }
8606 }
8607 if !fallback_cursor.goto_next_sibling() {
8608 break;
8609 }
8610 }
8611 }
8612 if fallback_child.is_none() {
8613 let mut cursor2 = node.walk();
8614 if cursor2.goto_first_child() {
8615 loop {
8616 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8617 let candidate = cursor2.node();
8618 #[allow(clippy::needless_question_mark)]
8619 if (|| -> ::core::result::Result<
8620 _,
8621 ::treesitter_types::ParseError,
8622 > {
8623 let child = candidate;
8624 Ok(
8625 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8626 child,
8627 src,
8628 ))?,
8629 )
8630 })()
8631 .is_ok()
8632 {
8633 fallback_child = Some(candidate);
8634 break;
8635 }
8636 }
8637 if !cursor2.goto_next_sibling() {
8638 break;
8639 }
8640 }
8641 }
8642 }
8643 fallback_child.ok_or_else(|| {
8644 ::treesitter_types::ParseError::missing_field("children", node)
8645 })?
8646 };
8647 ::treesitter_types::runtime::maybe_grow_stack(|| {
8648 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8649 child, src,
8650 )
8651 })?
8652 },
8653 })
8654 }
8655}
8656impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
8657 fn span(&self) -> ::treesitter_types::Span {
8658 self.span
8659 }
8660}
8661#[derive(Debug, Clone, PartialEq, Eq)]
8662pub struct ParenthesizedPattern<'tree> {
8663 pub span: ::treesitter_types::Span,
8664 pub children: Pattern<'tree>,
8665}
8666impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedPattern<'tree> {
8667 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8668 fn from_node(
8669 node: ::treesitter_types::tree_sitter::Node<'tree>,
8670 src: &'tree [u8],
8671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8672 debug_assert_eq!(node.kind(), "parenthesized_pattern");
8673 Ok(Self {
8674 span: ::treesitter_types::Span::from(node),
8675 children: {
8676 #[allow(clippy::suspicious_else_formatting)]
8677 let non_field_children = {
8678 let mut cursor = node.walk();
8679 let mut result = ::std::vec::Vec::new();
8680 if cursor.goto_first_child() {
8681 loop {
8682 if cursor.field_name().is_none()
8683 && cursor.node().is_named()
8684 && !cursor.node().is_extra()
8685 {
8686 result.push(cursor.node());
8687 }
8688 if !cursor.goto_next_sibling() {
8689 break;
8690 }
8691 }
8692 }
8693 result
8694 };
8695 let child = if let Some(&c) = non_field_children.first() {
8696 c
8697 } else {
8698 let mut fallback_cursor = node.walk();
8699 let mut fallback_child = None;
8700 if fallback_cursor.goto_first_child() {
8701 loop {
8702 if fallback_cursor.field_name().is_none()
8703 && !fallback_cursor.node().is_extra()
8704 {
8705 let candidate = fallback_cursor.node();
8706 #[allow(clippy::needless_question_mark)]
8707 if (|| -> ::core::result::Result<
8708 _,
8709 ::treesitter_types::ParseError,
8710 > {
8711 let child = candidate;
8712 Ok(
8713 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8714 child,
8715 src,
8716 ))?,
8717 )
8718 })()
8719 .is_ok()
8720 {
8721 fallback_child = Some(candidate);
8722 break;
8723 }
8724 }
8725 if !fallback_cursor.goto_next_sibling() {
8726 break;
8727 }
8728 }
8729 }
8730 if fallback_child.is_none() {
8731 let mut cursor2 = node.walk();
8732 if cursor2.goto_first_child() {
8733 loop {
8734 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8735 let candidate = cursor2.node();
8736 #[allow(clippy::needless_question_mark)]
8737 if (|| -> ::core::result::Result<
8738 _,
8739 ::treesitter_types::ParseError,
8740 > {
8741 let child = candidate;
8742 Ok(
8743 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8744 child,
8745 src,
8746 ))?,
8747 )
8748 })()
8749 .is_ok()
8750 {
8751 fallback_child = Some(candidate);
8752 break;
8753 }
8754 }
8755 if !cursor2.goto_next_sibling() {
8756 break;
8757 }
8758 }
8759 }
8760 }
8761 fallback_child.ok_or_else(|| {
8762 ::treesitter_types::ParseError::missing_field("children", node)
8763 })?
8764 };
8765 ::treesitter_types::runtime::maybe_grow_stack(|| {
8766 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8767 })?
8768 },
8769 })
8770 }
8771}
8772impl ::treesitter_types::Spanned for ParenthesizedPattern<'_> {
8773 fn span(&self) -> ::treesitter_types::Span {
8774 self.span
8775 }
8776}
8777#[derive(Debug, Clone, PartialEq, Eq)]
8778pub struct ParenthesizedVariableDesignation<'tree> {
8779 pub span: ::treesitter_types::Span,
8780 pub name: ::std::vec::Vec<Identifier<'tree>>,
8781 pub children: ::std::vec::Vec<ParenthesizedVariableDesignationChildren<'tree>>,
8782}
8783impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedVariableDesignation<'tree> {
8784 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8785 fn from_node(
8786 node: ::treesitter_types::tree_sitter::Node<'tree>,
8787 src: &'tree [u8],
8788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8789 debug_assert_eq!(node.kind(), "parenthesized_variable_designation");
8790 Ok(Self {
8791 span: ::treesitter_types::Span::from(node),
8792 name: {
8793 let mut cursor = node.walk();
8794 let mut items = ::std::vec::Vec::new();
8795 for child in node.children_by_field_name("name", &mut cursor) {
8796 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8797 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8798 })?);
8799 }
8800 items
8801 },
8802 children: {
8803 #[allow(clippy::suspicious_else_formatting)]
8804 let non_field_children = {
8805 let mut cursor = node.walk();
8806 let mut result = ::std::vec::Vec::new();
8807 if cursor.goto_first_child() {
8808 loop {
8809 if cursor.field_name().is_none()
8810 && cursor.node().is_named()
8811 && !cursor.node().is_extra()
8812 {
8813 result.push(cursor.node());
8814 }
8815 if !cursor.goto_next_sibling() {
8816 break;
8817 }
8818 }
8819 }
8820 result
8821 };
8822 let mut items = ::std::vec::Vec::new();
8823 for child in non_field_children {
8824 items
8825 .push(
8826 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedVariableDesignationChildren as ::treesitter_types::FromNode>::from_node(
8827 child,
8828 src,
8829 ))?,
8830 );
8831 }
8832 items
8833 },
8834 })
8835 }
8836}
8837impl ::treesitter_types::Spanned for ParenthesizedVariableDesignation<'_> {
8838 fn span(&self) -> ::treesitter_types::Span {
8839 self.span
8840 }
8841}
8842#[derive(Debug, Clone, PartialEq, Eq)]
8843pub struct PointerType<'tree> {
8844 pub span: ::treesitter_types::Span,
8845 pub r#type: PointerTypeType<'tree>,
8846}
8847impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
8848 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8849 fn from_node(
8850 node: ::treesitter_types::tree_sitter::Node<'tree>,
8851 src: &'tree [u8],
8852 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8853 debug_assert_eq!(node.kind(), "pointer_type");
8854 Ok(Self {
8855 span: ::treesitter_types::Span::from(node),
8856 r#type: {
8857 let child = node
8858 .child_by_field_name("type")
8859 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8860 ::treesitter_types::runtime::maybe_grow_stack(|| {
8861 <PointerTypeType as ::treesitter_types::FromNode>::from_node(child, src)
8862 })?
8863 },
8864 })
8865 }
8866}
8867impl ::treesitter_types::Spanned for PointerType<'_> {
8868 fn span(&self) -> ::treesitter_types::Span {
8869 self.span
8870 }
8871}
8872#[derive(Debug, Clone, PartialEq, Eq)]
8873pub struct PositionalPatternClause<'tree> {
8874 pub span: ::treesitter_types::Span,
8875 pub children: ::std::vec::Vec<Subpattern<'tree>>,
8876}
8877impl<'tree> ::treesitter_types::FromNode<'tree> for PositionalPatternClause<'tree> {
8878 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8879 fn from_node(
8880 node: ::treesitter_types::tree_sitter::Node<'tree>,
8881 src: &'tree [u8],
8882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8883 debug_assert_eq!(node.kind(), "positional_pattern_clause");
8884 Ok(Self {
8885 span: ::treesitter_types::Span::from(node),
8886 children: {
8887 #[allow(clippy::suspicious_else_formatting)]
8888 let non_field_children = {
8889 let mut cursor = node.walk();
8890 let mut result = ::std::vec::Vec::new();
8891 if cursor.goto_first_child() {
8892 loop {
8893 if cursor.field_name().is_none()
8894 && cursor.node().is_named()
8895 && !cursor.node().is_extra()
8896 {
8897 result.push(cursor.node());
8898 }
8899 if !cursor.goto_next_sibling() {
8900 break;
8901 }
8902 }
8903 }
8904 result
8905 };
8906 let mut items = ::std::vec::Vec::new();
8907 for child in non_field_children {
8908 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8909 <Subpattern as ::treesitter_types::FromNode>::from_node(child, src)
8910 })?);
8911 }
8912 items
8913 },
8914 })
8915 }
8916}
8917impl ::treesitter_types::Spanned for PositionalPatternClause<'_> {
8918 fn span(&self) -> ::treesitter_types::Span {
8919 self.span
8920 }
8921}
8922#[derive(Debug, Clone, PartialEq, Eq)]
8923pub struct PostfixUnaryExpression<'tree> {
8924 pub span: ::treesitter_types::Span,
8925 pub children: Expression<'tree>,
8926}
8927impl<'tree> ::treesitter_types::FromNode<'tree> for PostfixUnaryExpression<'tree> {
8928 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8929 fn from_node(
8930 node: ::treesitter_types::tree_sitter::Node<'tree>,
8931 src: &'tree [u8],
8932 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8933 debug_assert_eq!(node.kind(), "postfix_unary_expression");
8934 Ok(Self {
8935 span: ::treesitter_types::Span::from(node),
8936 children: {
8937 #[allow(clippy::suspicious_else_formatting)]
8938 let non_field_children = {
8939 let mut cursor = node.walk();
8940 let mut result = ::std::vec::Vec::new();
8941 if cursor.goto_first_child() {
8942 loop {
8943 if cursor.field_name().is_none()
8944 && cursor.node().is_named()
8945 && !cursor.node().is_extra()
8946 {
8947 result.push(cursor.node());
8948 }
8949 if !cursor.goto_next_sibling() {
8950 break;
8951 }
8952 }
8953 }
8954 result
8955 };
8956 let child = if let Some(&c) = non_field_children.first() {
8957 c
8958 } else {
8959 let mut fallback_cursor = node.walk();
8960 let mut fallback_child = None;
8961 if fallback_cursor.goto_first_child() {
8962 loop {
8963 if fallback_cursor.field_name().is_none()
8964 && !fallback_cursor.node().is_extra()
8965 {
8966 let candidate = fallback_cursor.node();
8967 #[allow(clippy::needless_question_mark)]
8968 if (|| -> ::core::result::Result<
8969 _,
8970 ::treesitter_types::ParseError,
8971 > {
8972 let child = candidate;
8973 Ok(
8974 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8975 child,
8976 src,
8977 ))?,
8978 )
8979 })()
8980 .is_ok()
8981 {
8982 fallback_child = Some(candidate);
8983 break;
8984 }
8985 }
8986 if !fallback_cursor.goto_next_sibling() {
8987 break;
8988 }
8989 }
8990 }
8991 if fallback_child.is_none() {
8992 let mut cursor2 = node.walk();
8993 if cursor2.goto_first_child() {
8994 loop {
8995 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8996 let candidate = cursor2.node();
8997 #[allow(clippy::needless_question_mark)]
8998 if (|| -> ::core::result::Result<
8999 _,
9000 ::treesitter_types::ParseError,
9001 > {
9002 let child = candidate;
9003 Ok(
9004 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9005 child,
9006 src,
9007 ))?,
9008 )
9009 })()
9010 .is_ok()
9011 {
9012 fallback_child = Some(candidate);
9013 break;
9014 }
9015 }
9016 if !cursor2.goto_next_sibling() {
9017 break;
9018 }
9019 }
9020 }
9021 }
9022 fallback_child.ok_or_else(|| {
9023 ::treesitter_types::ParseError::missing_field("children", node)
9024 })?
9025 };
9026 ::treesitter_types::runtime::maybe_grow_stack(|| {
9027 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9028 })?
9029 },
9030 })
9031 }
9032}
9033impl ::treesitter_types::Spanned for PostfixUnaryExpression<'_> {
9034 fn span(&self) -> ::treesitter_types::Span {
9035 self.span
9036 }
9037}
9038#[derive(Debug, Clone, PartialEq, Eq)]
9039pub struct PrefixUnaryExpression<'tree> {
9040 pub span: ::treesitter_types::Span,
9041 pub children: Expression<'tree>,
9042}
9043impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnaryExpression<'tree> {
9044 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9045 fn from_node(
9046 node: ::treesitter_types::tree_sitter::Node<'tree>,
9047 src: &'tree [u8],
9048 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9049 debug_assert_eq!(node.kind(), "prefix_unary_expression");
9050 Ok(Self {
9051 span: ::treesitter_types::Span::from(node),
9052 children: {
9053 #[allow(clippy::suspicious_else_formatting)]
9054 let non_field_children = {
9055 let mut cursor = node.walk();
9056 let mut result = ::std::vec::Vec::new();
9057 if cursor.goto_first_child() {
9058 loop {
9059 if cursor.field_name().is_none()
9060 && cursor.node().is_named()
9061 && !cursor.node().is_extra()
9062 {
9063 result.push(cursor.node());
9064 }
9065 if !cursor.goto_next_sibling() {
9066 break;
9067 }
9068 }
9069 }
9070 result
9071 };
9072 let child = if let Some(&c) = non_field_children.first() {
9073 c
9074 } else {
9075 let mut fallback_cursor = node.walk();
9076 let mut fallback_child = None;
9077 if fallback_cursor.goto_first_child() {
9078 loop {
9079 if fallback_cursor.field_name().is_none()
9080 && !fallback_cursor.node().is_extra()
9081 {
9082 let candidate = fallback_cursor.node();
9083 #[allow(clippy::needless_question_mark)]
9084 if (|| -> ::core::result::Result<
9085 _,
9086 ::treesitter_types::ParseError,
9087 > {
9088 let child = candidate;
9089 Ok(
9090 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9091 child,
9092 src,
9093 ))?,
9094 )
9095 })()
9096 .is_ok()
9097 {
9098 fallback_child = Some(candidate);
9099 break;
9100 }
9101 }
9102 if !fallback_cursor.goto_next_sibling() {
9103 break;
9104 }
9105 }
9106 }
9107 if fallback_child.is_none() {
9108 let mut cursor2 = node.walk();
9109 if cursor2.goto_first_child() {
9110 loop {
9111 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9112 let candidate = cursor2.node();
9113 #[allow(clippy::needless_question_mark)]
9114 if (|| -> ::core::result::Result<
9115 _,
9116 ::treesitter_types::ParseError,
9117 > {
9118 let child = candidate;
9119 Ok(
9120 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9121 child,
9122 src,
9123 ))?,
9124 )
9125 })()
9126 .is_ok()
9127 {
9128 fallback_child = Some(candidate);
9129 break;
9130 }
9131 }
9132 if !cursor2.goto_next_sibling() {
9133 break;
9134 }
9135 }
9136 }
9137 }
9138 fallback_child.ok_or_else(|| {
9139 ::treesitter_types::ParseError::missing_field("children", node)
9140 })?
9141 };
9142 ::treesitter_types::runtime::maybe_grow_stack(|| {
9143 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9144 })?
9145 },
9146 })
9147 }
9148}
9149impl ::treesitter_types::Spanned for PrefixUnaryExpression<'_> {
9150 fn span(&self) -> ::treesitter_types::Span {
9151 self.span
9152 }
9153}
9154#[derive(Debug, Clone, PartialEq, Eq)]
9155pub struct PreprocDefine<'tree> {
9156 pub span: ::treesitter_types::Span,
9157 pub children: PreprocArg<'tree>,
9158}
9159impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefine<'tree> {
9160 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9161 fn from_node(
9162 node: ::treesitter_types::tree_sitter::Node<'tree>,
9163 src: &'tree [u8],
9164 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9165 debug_assert_eq!(node.kind(), "preproc_define");
9166 Ok(Self {
9167 span: ::treesitter_types::Span::from(node),
9168 children: {
9169 #[allow(clippy::suspicious_else_formatting)]
9170 let non_field_children = {
9171 let mut cursor = node.walk();
9172 let mut result = ::std::vec::Vec::new();
9173 if cursor.goto_first_child() {
9174 loop {
9175 if cursor.field_name().is_none()
9176 && cursor.node().is_named()
9177 && !cursor.node().is_extra()
9178 {
9179 result.push(cursor.node());
9180 }
9181 if !cursor.goto_next_sibling() {
9182 break;
9183 }
9184 }
9185 }
9186 result
9187 };
9188 let child = if let Some(&c) = non_field_children.first() {
9189 c
9190 } else {
9191 let mut fallback_cursor = node.walk();
9192 let mut fallback_child = None;
9193 if fallback_cursor.goto_first_child() {
9194 loop {
9195 if fallback_cursor.field_name().is_none()
9196 && !fallback_cursor.node().is_extra()
9197 {
9198 let candidate = fallback_cursor.node();
9199 #[allow(clippy::needless_question_mark)]
9200 if (|| -> ::core::result::Result<
9201 _,
9202 ::treesitter_types::ParseError,
9203 > {
9204 let child = candidate;
9205 Ok(
9206 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9207 child,
9208 src,
9209 ))?,
9210 )
9211 })()
9212 .is_ok()
9213 {
9214 fallback_child = Some(candidate);
9215 break;
9216 }
9217 }
9218 if !fallback_cursor.goto_next_sibling() {
9219 break;
9220 }
9221 }
9222 }
9223 if fallback_child.is_none() {
9224 let mut cursor2 = node.walk();
9225 if cursor2.goto_first_child() {
9226 loop {
9227 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9228 let candidate = cursor2.node();
9229 #[allow(clippy::needless_question_mark)]
9230 if (|| -> ::core::result::Result<
9231 _,
9232 ::treesitter_types::ParseError,
9233 > {
9234 let child = candidate;
9235 Ok(
9236 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9237 child,
9238 src,
9239 ))?,
9240 )
9241 })()
9242 .is_ok()
9243 {
9244 fallback_child = Some(candidate);
9245 break;
9246 }
9247 }
9248 if !cursor2.goto_next_sibling() {
9249 break;
9250 }
9251 }
9252 }
9253 }
9254 fallback_child.ok_or_else(|| {
9255 ::treesitter_types::ParseError::missing_field("children", node)
9256 })?
9257 };
9258 ::treesitter_types::runtime::maybe_grow_stack(|| {
9259 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9260 })?
9261 },
9262 })
9263 }
9264}
9265impl ::treesitter_types::Spanned for PreprocDefine<'_> {
9266 fn span(&self) -> ::treesitter_types::Span {
9267 self.span
9268 }
9269}
9270#[derive(Debug, Clone, PartialEq, Eq)]
9271pub struct PreprocElif<'tree> {
9272 pub span: ::treesitter_types::Span,
9273 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
9274 pub condition: PreprocElifCondition<'tree>,
9275 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
9276}
9277impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
9278 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9279 fn from_node(
9280 node: ::treesitter_types::tree_sitter::Node<'tree>,
9281 src: &'tree [u8],
9282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9283 debug_assert_eq!(node.kind(), "preproc_elif");
9284 Ok(Self {
9285 span: ::treesitter_types::Span::from(node),
9286 alternative: match node.child_by_field_name("alternative") {
9287 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9288 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(child, src)
9289 })?),
9290 None => None,
9291 },
9292 condition: {
9293 let child = node.child_by_field_name("condition").ok_or_else(|| {
9294 ::treesitter_types::ParseError::missing_field("condition", node)
9295 })?;
9296 ::treesitter_types::runtime::maybe_grow_stack(|| {
9297 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)
9298 })?
9299 },
9300 children: {
9301 #[allow(clippy::suspicious_else_formatting)]
9302 let non_field_children = {
9303 let mut cursor = node.walk();
9304 let mut result = ::std::vec::Vec::new();
9305 if cursor.goto_first_child() {
9306 loop {
9307 if cursor.field_name().is_none()
9308 && cursor.node().is_named()
9309 && !cursor.node().is_extra()
9310 {
9311 result.push(cursor.node());
9312 }
9313 if !cursor.goto_next_sibling() {
9314 break;
9315 }
9316 }
9317 }
9318 result
9319 };
9320 let mut items = ::std::vec::Vec::new();
9321 for child in non_field_children {
9322 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9323 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(child, src)
9324 })?);
9325 }
9326 items
9327 },
9328 })
9329 }
9330}
9331impl ::treesitter_types::Spanned for PreprocElif<'_> {
9332 fn span(&self) -> ::treesitter_types::Span {
9333 self.span
9334 }
9335}
9336#[derive(Debug, Clone, PartialEq, Eq)]
9337pub struct PreprocElse<'tree> {
9338 pub span: ::treesitter_types::Span,
9339 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
9340}
9341impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
9342 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9343 fn from_node(
9344 node: ::treesitter_types::tree_sitter::Node<'tree>,
9345 src: &'tree [u8],
9346 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9347 debug_assert_eq!(node.kind(), "preproc_else");
9348 Ok(Self {
9349 span: ::treesitter_types::Span::from(node),
9350 children: {
9351 #[allow(clippy::suspicious_else_formatting)]
9352 let non_field_children = {
9353 let mut cursor = node.walk();
9354 let mut result = ::std::vec::Vec::new();
9355 if cursor.goto_first_child() {
9356 loop {
9357 if cursor.field_name().is_none()
9358 && cursor.node().is_named()
9359 && !cursor.node().is_extra()
9360 {
9361 result.push(cursor.node());
9362 }
9363 if !cursor.goto_next_sibling() {
9364 break;
9365 }
9366 }
9367 }
9368 result
9369 };
9370 let mut items = ::std::vec::Vec::new();
9371 for child in non_field_children {
9372 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9373 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(child, src)
9374 })?);
9375 }
9376 items
9377 },
9378 })
9379 }
9380}
9381impl ::treesitter_types::Spanned for PreprocElse<'_> {
9382 fn span(&self) -> ::treesitter_types::Span {
9383 self.span
9384 }
9385}
9386#[derive(Debug, Clone, PartialEq, Eq)]
9387pub struct PreprocEndregion<'tree> {
9388 pub span: ::treesitter_types::Span,
9389 pub content: ::core::option::Option<PreprocArg<'tree>>,
9390}
9391impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocEndregion<'tree> {
9392 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9393 fn from_node(
9394 node: ::treesitter_types::tree_sitter::Node<'tree>,
9395 src: &'tree [u8],
9396 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9397 debug_assert_eq!(node.kind(), "preproc_endregion");
9398 Ok(Self {
9399 span: ::treesitter_types::Span::from(node),
9400 content: match node.child_by_field_name("content") {
9401 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9402 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9403 })?),
9404 None => None,
9405 },
9406 })
9407 }
9408}
9409impl ::treesitter_types::Spanned for PreprocEndregion<'_> {
9410 fn span(&self) -> ::treesitter_types::Span {
9411 self.span
9412 }
9413}
9414#[derive(Debug, Clone, PartialEq, Eq)]
9415pub struct PreprocError<'tree> {
9416 pub span: ::treesitter_types::Span,
9417 pub children: PreprocArg<'tree>,
9418}
9419impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocError<'tree> {
9420 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9421 fn from_node(
9422 node: ::treesitter_types::tree_sitter::Node<'tree>,
9423 src: &'tree [u8],
9424 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9425 debug_assert_eq!(node.kind(), "preproc_error");
9426 Ok(Self {
9427 span: ::treesitter_types::Span::from(node),
9428 children: {
9429 #[allow(clippy::suspicious_else_formatting)]
9430 let non_field_children = {
9431 let mut cursor = node.walk();
9432 let mut result = ::std::vec::Vec::new();
9433 if cursor.goto_first_child() {
9434 loop {
9435 if cursor.field_name().is_none()
9436 && cursor.node().is_named()
9437 && !cursor.node().is_extra()
9438 {
9439 result.push(cursor.node());
9440 }
9441 if !cursor.goto_next_sibling() {
9442 break;
9443 }
9444 }
9445 }
9446 result
9447 };
9448 let child = if let Some(&c) = non_field_children.first() {
9449 c
9450 } else {
9451 let mut fallback_cursor = node.walk();
9452 let mut fallback_child = None;
9453 if fallback_cursor.goto_first_child() {
9454 loop {
9455 if fallback_cursor.field_name().is_none()
9456 && !fallback_cursor.node().is_extra()
9457 {
9458 let candidate = fallback_cursor.node();
9459 #[allow(clippy::needless_question_mark)]
9460 if (|| -> ::core::result::Result<
9461 _,
9462 ::treesitter_types::ParseError,
9463 > {
9464 let child = candidate;
9465 Ok(
9466 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9467 child,
9468 src,
9469 ))?,
9470 )
9471 })()
9472 .is_ok()
9473 {
9474 fallback_child = Some(candidate);
9475 break;
9476 }
9477 }
9478 if !fallback_cursor.goto_next_sibling() {
9479 break;
9480 }
9481 }
9482 }
9483 if fallback_child.is_none() {
9484 let mut cursor2 = node.walk();
9485 if cursor2.goto_first_child() {
9486 loop {
9487 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9488 let candidate = cursor2.node();
9489 #[allow(clippy::needless_question_mark)]
9490 if (|| -> ::core::result::Result<
9491 _,
9492 ::treesitter_types::ParseError,
9493 > {
9494 let child = candidate;
9495 Ok(
9496 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9497 child,
9498 src,
9499 ))?,
9500 )
9501 })()
9502 .is_ok()
9503 {
9504 fallback_child = Some(candidate);
9505 break;
9506 }
9507 }
9508 if !cursor2.goto_next_sibling() {
9509 break;
9510 }
9511 }
9512 }
9513 }
9514 fallback_child.ok_or_else(|| {
9515 ::treesitter_types::ParseError::missing_field("children", node)
9516 })?
9517 };
9518 ::treesitter_types::runtime::maybe_grow_stack(|| {
9519 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9520 })?
9521 },
9522 })
9523 }
9524}
9525impl ::treesitter_types::Spanned for PreprocError<'_> {
9526 fn span(&self) -> ::treesitter_types::Span {
9527 self.span
9528 }
9529}
9530#[derive(Debug, Clone, PartialEq, Eq)]
9531pub struct PreprocIf<'tree> {
9532 pub span: ::treesitter_types::Span,
9533 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
9534 pub condition: PreprocIfCondition<'tree>,
9535 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
9536}
9537impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
9538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9539 fn from_node(
9540 node: ::treesitter_types::tree_sitter::Node<'tree>,
9541 src: &'tree [u8],
9542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9543 debug_assert_eq!(node.kind(), "preproc_if");
9544 Ok(Self {
9545 span: ::treesitter_types::Span::from(node),
9546 alternative: match node.child_by_field_name("alternative") {
9547 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9548 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)
9549 })?),
9550 None => None,
9551 },
9552 condition: {
9553 let child = node.child_by_field_name("condition").ok_or_else(|| {
9554 ::treesitter_types::ParseError::missing_field("condition", node)
9555 })?;
9556 ::treesitter_types::runtime::maybe_grow_stack(|| {
9557 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)
9558 })?
9559 },
9560 children: {
9561 #[allow(clippy::suspicious_else_formatting)]
9562 let non_field_children = {
9563 let mut cursor = node.walk();
9564 let mut result = ::std::vec::Vec::new();
9565 if cursor.goto_first_child() {
9566 loop {
9567 if cursor.field_name().is_none()
9568 && cursor.node().is_named()
9569 && !cursor.node().is_extra()
9570 {
9571 result.push(cursor.node());
9572 }
9573 if !cursor.goto_next_sibling() {
9574 break;
9575 }
9576 }
9577 }
9578 result
9579 };
9580 let mut items = ::std::vec::Vec::new();
9581 for child in non_field_children {
9582 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9583 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)
9584 })?);
9585 }
9586 items
9587 },
9588 })
9589 }
9590}
9591impl ::treesitter_types::Spanned for PreprocIf<'_> {
9592 fn span(&self) -> ::treesitter_types::Span {
9593 self.span
9594 }
9595}
9596#[derive(Debug, Clone, PartialEq, Eq)]
9597pub struct PreprocLine<'tree> {
9598 pub span: ::treesitter_types::Span,
9599 pub children: ::std::vec::Vec<PreprocLineChildren<'tree>>,
9600}
9601impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLine<'tree> {
9602 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9603 fn from_node(
9604 node: ::treesitter_types::tree_sitter::Node<'tree>,
9605 src: &'tree [u8],
9606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9607 debug_assert_eq!(node.kind(), "preproc_line");
9608 Ok(Self {
9609 span: ::treesitter_types::Span::from(node),
9610 children: {
9611 #[allow(clippy::suspicious_else_formatting)]
9612 let non_field_children = {
9613 let mut cursor = node.walk();
9614 let mut result = ::std::vec::Vec::new();
9615 if cursor.goto_first_child() {
9616 loop {
9617 if cursor.field_name().is_none()
9618 && cursor.node().is_named()
9619 && !cursor.node().is_extra()
9620 {
9621 result.push(cursor.node());
9622 }
9623 if !cursor.goto_next_sibling() {
9624 break;
9625 }
9626 }
9627 }
9628 result
9629 };
9630 let mut items = ::std::vec::Vec::new();
9631 for child in non_field_children {
9632 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9633 <PreprocLineChildren as ::treesitter_types::FromNode>::from_node(child, src)
9634 })?);
9635 }
9636 items
9637 },
9638 })
9639 }
9640}
9641impl ::treesitter_types::Spanned for PreprocLine<'_> {
9642 fn span(&self) -> ::treesitter_types::Span {
9643 self.span
9644 }
9645}
9646#[derive(Debug, Clone, PartialEq, Eq)]
9647pub struct PreprocNullable<'tree> {
9648 pub span: ::treesitter_types::Span,
9649 text: &'tree str,
9650}
9651impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocNullable<'tree> {
9652 fn from_node(
9653 node: ::treesitter_types::tree_sitter::Node<'tree>,
9654 src: &'tree [u8],
9655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9656 debug_assert_eq!(node.kind(), "preproc_nullable");
9657 Ok(Self {
9658 span: ::treesitter_types::Span::from(node),
9659 text: node.utf8_text(src)?,
9660 })
9661 }
9662}
9663impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocNullable<'tree> {
9664 fn text(&self) -> &'tree str {
9665 self.text
9666 }
9667}
9668impl ::treesitter_types::Spanned for PreprocNullable<'_> {
9669 fn span(&self) -> ::treesitter_types::Span {
9670 self.span
9671 }
9672}
9673#[derive(Debug, Clone, PartialEq, Eq)]
9674pub struct PreprocPragma<'tree> {
9675 pub span: ::treesitter_types::Span,
9676 pub children: ::std::vec::Vec<PreprocPragmaChildren<'tree>>,
9677}
9678impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragma<'tree> {
9679 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9680 fn from_node(
9681 node: ::treesitter_types::tree_sitter::Node<'tree>,
9682 src: &'tree [u8],
9683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9684 debug_assert_eq!(node.kind(), "preproc_pragma");
9685 Ok(Self {
9686 span: ::treesitter_types::Span::from(node),
9687 children: {
9688 #[allow(clippy::suspicious_else_formatting)]
9689 let non_field_children = {
9690 let mut cursor = node.walk();
9691 let mut result = ::std::vec::Vec::new();
9692 if cursor.goto_first_child() {
9693 loop {
9694 if cursor.field_name().is_none()
9695 && cursor.node().is_named()
9696 && !cursor.node().is_extra()
9697 {
9698 result.push(cursor.node());
9699 }
9700 if !cursor.goto_next_sibling() {
9701 break;
9702 }
9703 }
9704 }
9705 result
9706 };
9707 let mut items = ::std::vec::Vec::new();
9708 for child in non_field_children {
9709 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9710 <PreprocPragmaChildren as ::treesitter_types::FromNode>::from_node(
9711 child, src,
9712 )
9713 })?);
9714 }
9715 items
9716 },
9717 })
9718 }
9719}
9720impl ::treesitter_types::Spanned for PreprocPragma<'_> {
9721 fn span(&self) -> ::treesitter_types::Span {
9722 self.span
9723 }
9724}
9725#[derive(Debug, Clone, PartialEq, Eq)]
9726pub struct PreprocRegion<'tree> {
9727 pub span: ::treesitter_types::Span,
9728 pub content: ::core::option::Option<PreprocArg<'tree>>,
9729}
9730impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocRegion<'tree> {
9731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9732 fn from_node(
9733 node: ::treesitter_types::tree_sitter::Node<'tree>,
9734 src: &'tree [u8],
9735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9736 debug_assert_eq!(node.kind(), "preproc_region");
9737 Ok(Self {
9738 span: ::treesitter_types::Span::from(node),
9739 content: match node.child_by_field_name("content") {
9740 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9741 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9742 })?),
9743 None => None,
9744 },
9745 })
9746 }
9747}
9748impl ::treesitter_types::Spanned for PreprocRegion<'_> {
9749 fn span(&self) -> ::treesitter_types::Span {
9750 self.span
9751 }
9752}
9753#[derive(Debug, Clone, PartialEq, Eq)]
9754pub struct PreprocUndef<'tree> {
9755 pub span: ::treesitter_types::Span,
9756 pub children: PreprocArg<'tree>,
9757}
9758impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocUndef<'tree> {
9759 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9760 fn from_node(
9761 node: ::treesitter_types::tree_sitter::Node<'tree>,
9762 src: &'tree [u8],
9763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9764 debug_assert_eq!(node.kind(), "preproc_undef");
9765 Ok(Self {
9766 span: ::treesitter_types::Span::from(node),
9767 children: {
9768 #[allow(clippy::suspicious_else_formatting)]
9769 let non_field_children = {
9770 let mut cursor = node.walk();
9771 let mut result = ::std::vec::Vec::new();
9772 if cursor.goto_first_child() {
9773 loop {
9774 if cursor.field_name().is_none()
9775 && cursor.node().is_named()
9776 && !cursor.node().is_extra()
9777 {
9778 result.push(cursor.node());
9779 }
9780 if !cursor.goto_next_sibling() {
9781 break;
9782 }
9783 }
9784 }
9785 result
9786 };
9787 let child = if let Some(&c) = non_field_children.first() {
9788 c
9789 } else {
9790 let mut fallback_cursor = node.walk();
9791 let mut fallback_child = None;
9792 if fallback_cursor.goto_first_child() {
9793 loop {
9794 if fallback_cursor.field_name().is_none()
9795 && !fallback_cursor.node().is_extra()
9796 {
9797 let candidate = fallback_cursor.node();
9798 #[allow(clippy::needless_question_mark)]
9799 if (|| -> ::core::result::Result<
9800 _,
9801 ::treesitter_types::ParseError,
9802 > {
9803 let child = candidate;
9804 Ok(
9805 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9806 child,
9807 src,
9808 ))?,
9809 )
9810 })()
9811 .is_ok()
9812 {
9813 fallback_child = Some(candidate);
9814 break;
9815 }
9816 }
9817 if !fallback_cursor.goto_next_sibling() {
9818 break;
9819 }
9820 }
9821 }
9822 if fallback_child.is_none() {
9823 let mut cursor2 = node.walk();
9824 if cursor2.goto_first_child() {
9825 loop {
9826 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9827 let candidate = cursor2.node();
9828 #[allow(clippy::needless_question_mark)]
9829 if (|| -> ::core::result::Result<
9830 _,
9831 ::treesitter_types::ParseError,
9832 > {
9833 let child = candidate;
9834 Ok(
9835 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9836 child,
9837 src,
9838 ))?,
9839 )
9840 })()
9841 .is_ok()
9842 {
9843 fallback_child = Some(candidate);
9844 break;
9845 }
9846 }
9847 if !cursor2.goto_next_sibling() {
9848 break;
9849 }
9850 }
9851 }
9852 }
9853 fallback_child.ok_or_else(|| {
9854 ::treesitter_types::ParseError::missing_field("children", node)
9855 })?
9856 };
9857 ::treesitter_types::runtime::maybe_grow_stack(|| {
9858 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9859 })?
9860 },
9861 })
9862 }
9863}
9864impl ::treesitter_types::Spanned for PreprocUndef<'_> {
9865 fn span(&self) -> ::treesitter_types::Span {
9866 self.span
9867 }
9868}
9869#[derive(Debug, Clone, PartialEq, Eq)]
9870pub struct PreprocWarning<'tree> {
9871 pub span: ::treesitter_types::Span,
9872 pub children: PreprocArg<'tree>,
9873}
9874impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocWarning<'tree> {
9875 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9876 fn from_node(
9877 node: ::treesitter_types::tree_sitter::Node<'tree>,
9878 src: &'tree [u8],
9879 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9880 debug_assert_eq!(node.kind(), "preproc_warning");
9881 Ok(Self {
9882 span: ::treesitter_types::Span::from(node),
9883 children: {
9884 #[allow(clippy::suspicious_else_formatting)]
9885 let non_field_children = {
9886 let mut cursor = node.walk();
9887 let mut result = ::std::vec::Vec::new();
9888 if cursor.goto_first_child() {
9889 loop {
9890 if cursor.field_name().is_none()
9891 && cursor.node().is_named()
9892 && !cursor.node().is_extra()
9893 {
9894 result.push(cursor.node());
9895 }
9896 if !cursor.goto_next_sibling() {
9897 break;
9898 }
9899 }
9900 }
9901 result
9902 };
9903 let child = if let Some(&c) = non_field_children.first() {
9904 c
9905 } else {
9906 let mut fallback_cursor = node.walk();
9907 let mut fallback_child = None;
9908 if fallback_cursor.goto_first_child() {
9909 loop {
9910 if fallback_cursor.field_name().is_none()
9911 && !fallback_cursor.node().is_extra()
9912 {
9913 let candidate = fallback_cursor.node();
9914 #[allow(clippy::needless_question_mark)]
9915 if (|| -> ::core::result::Result<
9916 _,
9917 ::treesitter_types::ParseError,
9918 > {
9919 let child = candidate;
9920 Ok(
9921 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9922 child,
9923 src,
9924 ))?,
9925 )
9926 })()
9927 .is_ok()
9928 {
9929 fallback_child = Some(candidate);
9930 break;
9931 }
9932 }
9933 if !fallback_cursor.goto_next_sibling() {
9934 break;
9935 }
9936 }
9937 }
9938 if fallback_child.is_none() {
9939 let mut cursor2 = node.walk();
9940 if cursor2.goto_first_child() {
9941 loop {
9942 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9943 let candidate = cursor2.node();
9944 #[allow(clippy::needless_question_mark)]
9945 if (|| -> ::core::result::Result<
9946 _,
9947 ::treesitter_types::ParseError,
9948 > {
9949 let child = candidate;
9950 Ok(
9951 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9952 child,
9953 src,
9954 ))?,
9955 )
9956 })()
9957 .is_ok()
9958 {
9959 fallback_child = Some(candidate);
9960 break;
9961 }
9962 }
9963 if !cursor2.goto_next_sibling() {
9964 break;
9965 }
9966 }
9967 }
9968 }
9969 fallback_child.ok_or_else(|| {
9970 ::treesitter_types::ParseError::missing_field("children", node)
9971 })?
9972 };
9973 ::treesitter_types::runtime::maybe_grow_stack(|| {
9974 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9975 })?
9976 },
9977 })
9978 }
9979}
9980impl ::treesitter_types::Spanned for PreprocWarning<'_> {
9981 fn span(&self) -> ::treesitter_types::Span {
9982 self.span
9983 }
9984}
9985#[derive(Debug, Clone, PartialEq, Eq)]
9986pub struct PrimaryConstructorBaseType<'tree> {
9987 pub span: ::treesitter_types::Span,
9988 pub r#type: PrimaryConstructorBaseTypeType<'tree>,
9989 pub children: ArgumentList<'tree>,
9990}
9991impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseType<'tree> {
9992 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9993 fn from_node(
9994 node: ::treesitter_types::tree_sitter::Node<'tree>,
9995 src: &'tree [u8],
9996 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9997 debug_assert_eq!(node.kind(), "primary_constructor_base_type");
9998 Ok(Self {
9999 span: ::treesitter_types::Span::from(node),
10000 r#type: {
10001 let child = node
10002 .child_by_field_name("type")
10003 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10004 ::treesitter_types::runtime::maybe_grow_stack(|| {
10005 <PrimaryConstructorBaseTypeType as ::treesitter_types::FromNode>::from_node(
10006 child, src,
10007 )
10008 })?
10009 },
10010 children: {
10011 #[allow(clippy::suspicious_else_formatting)]
10012 let non_field_children = {
10013 let mut cursor = node.walk();
10014 let mut result = ::std::vec::Vec::new();
10015 if cursor.goto_first_child() {
10016 loop {
10017 if cursor.field_name().is_none()
10018 && cursor.node().is_named()
10019 && !cursor.node().is_extra()
10020 {
10021 result.push(cursor.node());
10022 }
10023 if !cursor.goto_next_sibling() {
10024 break;
10025 }
10026 }
10027 }
10028 result
10029 };
10030 let child = if let Some(&c) = non_field_children.first() {
10031 c
10032 } else {
10033 let mut fallback_cursor = node.walk();
10034 let mut fallback_child = None;
10035 if fallback_cursor.goto_first_child() {
10036 loop {
10037 if fallback_cursor.field_name().is_none()
10038 && !fallback_cursor.node().is_extra()
10039 {
10040 let candidate = fallback_cursor.node();
10041 #[allow(clippy::needless_question_mark)]
10042 if (|| -> ::core::result::Result<
10043 _,
10044 ::treesitter_types::ParseError,
10045 > {
10046 let child = candidate;
10047 Ok(
10048 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
10049 child,
10050 src,
10051 ))?,
10052 )
10053 })()
10054 .is_ok()
10055 {
10056 fallback_child = Some(candidate);
10057 break;
10058 }
10059 }
10060 if !fallback_cursor.goto_next_sibling() {
10061 break;
10062 }
10063 }
10064 }
10065 if fallback_child.is_none() {
10066 let mut cursor2 = node.walk();
10067 if cursor2.goto_first_child() {
10068 loop {
10069 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10070 let candidate = cursor2.node();
10071 #[allow(clippy::needless_question_mark)]
10072 if (|| -> ::core::result::Result<
10073 _,
10074 ::treesitter_types::ParseError,
10075 > {
10076 let child = candidate;
10077 Ok(
10078 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
10079 child,
10080 src,
10081 ))?,
10082 )
10083 })()
10084 .is_ok()
10085 {
10086 fallback_child = Some(candidate);
10087 break;
10088 }
10089 }
10090 if !cursor2.goto_next_sibling() {
10091 break;
10092 }
10093 }
10094 }
10095 }
10096 fallback_child.ok_or_else(|| {
10097 ::treesitter_types::ParseError::missing_field("children", node)
10098 })?
10099 };
10100 ::treesitter_types::runtime::maybe_grow_stack(|| {
10101 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10102 })?
10103 },
10104 })
10105 }
10106}
10107impl ::treesitter_types::Spanned for PrimaryConstructorBaseType<'_> {
10108 fn span(&self) -> ::treesitter_types::Span {
10109 self.span
10110 }
10111}
10112#[derive(Debug, Clone, PartialEq, Eq)]
10113pub struct PropertyDeclaration<'tree> {
10114 pub span: ::treesitter_types::Span,
10115 pub accessors: ::core::option::Option<AccessorList<'tree>>,
10116 pub name: Identifier<'tree>,
10117 pub r#type: Type<'tree>,
10118 pub value: ::core::option::Option<PropertyDeclarationValue<'tree>>,
10119 pub children: ::std::vec::Vec<PropertyDeclarationChildren<'tree>>,
10120}
10121impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclaration<'tree> {
10122 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10123 fn from_node(
10124 node: ::treesitter_types::tree_sitter::Node<'tree>,
10125 src: &'tree [u8],
10126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10127 debug_assert_eq!(node.kind(), "property_declaration");
10128 Ok(Self {
10129 span: ::treesitter_types::Span::from(node),
10130 accessors: match node.child_by_field_name("accessors") {
10131 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10132 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
10133 })?),
10134 None => None,
10135 },
10136 name: {
10137 let child = node
10138 .child_by_field_name("name")
10139 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10140 ::treesitter_types::runtime::maybe_grow_stack(|| {
10141 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10142 })?
10143 },
10144 r#type: {
10145 let child = node
10146 .child_by_field_name("type")
10147 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10148 ::treesitter_types::runtime::maybe_grow_stack(|| {
10149 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10150 })?
10151 },
10152 value: match node.child_by_field_name("value") {
10153 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10154 <PropertyDeclarationValue as ::treesitter_types::FromNode>::from_node(
10155 child, src,
10156 )
10157 })?),
10158 None => None,
10159 },
10160 children: {
10161 #[allow(clippy::suspicious_else_formatting)]
10162 let non_field_children = {
10163 let mut cursor = node.walk();
10164 let mut result = ::std::vec::Vec::new();
10165 if cursor.goto_first_child() {
10166 loop {
10167 if cursor.field_name().is_none()
10168 && cursor.node().is_named()
10169 && !cursor.node().is_extra()
10170 {
10171 result.push(cursor.node());
10172 }
10173 if !cursor.goto_next_sibling() {
10174 break;
10175 }
10176 }
10177 }
10178 result
10179 };
10180 let mut items = ::std::vec::Vec::new();
10181 for child in non_field_children {
10182 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10183 <PropertyDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10184 child, src,
10185 )
10186 })?);
10187 }
10188 items
10189 },
10190 })
10191 }
10192}
10193impl ::treesitter_types::Spanned for PropertyDeclaration<'_> {
10194 fn span(&self) -> ::treesitter_types::Span {
10195 self.span
10196 }
10197}
10198#[derive(Debug, Clone, PartialEq, Eq)]
10199pub struct PropertyPatternClause<'tree> {
10200 pub span: ::treesitter_types::Span,
10201 pub children: ::std::vec::Vec<Subpattern<'tree>>,
10202}
10203impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPatternClause<'tree> {
10204 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10205 fn from_node(
10206 node: ::treesitter_types::tree_sitter::Node<'tree>,
10207 src: &'tree [u8],
10208 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10209 debug_assert_eq!(node.kind(), "property_pattern_clause");
10210 Ok(Self {
10211 span: ::treesitter_types::Span::from(node),
10212 children: {
10213 #[allow(clippy::suspicious_else_formatting)]
10214 let non_field_children = {
10215 let mut cursor = node.walk();
10216 let mut result = ::std::vec::Vec::new();
10217 if cursor.goto_first_child() {
10218 loop {
10219 if cursor.field_name().is_none()
10220 && cursor.node().is_named()
10221 && !cursor.node().is_extra()
10222 {
10223 result.push(cursor.node());
10224 }
10225 if !cursor.goto_next_sibling() {
10226 break;
10227 }
10228 }
10229 }
10230 result
10231 };
10232 let mut items = ::std::vec::Vec::new();
10233 for child in non_field_children {
10234 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10235 <Subpattern as ::treesitter_types::FromNode>::from_node(child, src)
10236 })?);
10237 }
10238 items
10239 },
10240 })
10241 }
10242}
10243impl ::treesitter_types::Spanned for PropertyPatternClause<'_> {
10244 fn span(&self) -> ::treesitter_types::Span {
10245 self.span
10246 }
10247}
10248#[derive(Debug, Clone, PartialEq, Eq)]
10249pub struct QualifiedName<'tree> {
10250 pub span: ::treesitter_types::Span,
10251 pub name: QualifiedNameName<'tree>,
10252 pub qualifier: QualifiedNameQualifier<'tree>,
10253}
10254impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedName<'tree> {
10255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10256 fn from_node(
10257 node: ::treesitter_types::tree_sitter::Node<'tree>,
10258 src: &'tree [u8],
10259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10260 debug_assert_eq!(node.kind(), "qualified_name");
10261 Ok(Self {
10262 span: ::treesitter_types::Span::from(node),
10263 name: {
10264 let child = node
10265 .child_by_field_name("name")
10266 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10267 ::treesitter_types::runtime::maybe_grow_stack(|| {
10268 <QualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)
10269 })?
10270 },
10271 qualifier: {
10272 let child = node.child_by_field_name("qualifier").ok_or_else(|| {
10273 ::treesitter_types::ParseError::missing_field("qualifier", node)
10274 })?;
10275 ::treesitter_types::runtime::maybe_grow_stack(|| {
10276 <QualifiedNameQualifier as ::treesitter_types::FromNode>::from_node(child, src)
10277 })?
10278 },
10279 })
10280 }
10281}
10282impl ::treesitter_types::Spanned for QualifiedName<'_> {
10283 fn span(&self) -> ::treesitter_types::Span {
10284 self.span
10285 }
10286}
10287#[derive(Debug, Clone, PartialEq, Eq)]
10288pub struct QueryExpression<'tree> {
10289 pub span: ::treesitter_types::Span,
10290 pub children: ::std::vec::Vec<QueryExpressionChildren<'tree>>,
10291}
10292impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpression<'tree> {
10293 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10294 fn from_node(
10295 node: ::treesitter_types::tree_sitter::Node<'tree>,
10296 src: &'tree [u8],
10297 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10298 debug_assert_eq!(node.kind(), "query_expression");
10299 Ok(Self {
10300 span: ::treesitter_types::Span::from(node),
10301 children: {
10302 #[allow(clippy::suspicious_else_formatting)]
10303 let non_field_children = {
10304 let mut cursor = node.walk();
10305 let mut result = ::std::vec::Vec::new();
10306 if cursor.goto_first_child() {
10307 loop {
10308 if cursor.field_name().is_none()
10309 && cursor.node().is_named()
10310 && !cursor.node().is_extra()
10311 {
10312 result.push(cursor.node());
10313 }
10314 if !cursor.goto_next_sibling() {
10315 break;
10316 }
10317 }
10318 }
10319 result
10320 };
10321 let mut items = ::std::vec::Vec::new();
10322 for child in non_field_children {
10323 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10324 <QueryExpressionChildren as ::treesitter_types::FromNode>::from_node(
10325 child, src,
10326 )
10327 })?);
10328 }
10329 items
10330 },
10331 })
10332 }
10333}
10334impl ::treesitter_types::Spanned for QueryExpression<'_> {
10335 fn span(&self) -> ::treesitter_types::Span {
10336 self.span
10337 }
10338}
10339#[derive(Debug, Clone, PartialEq, Eq)]
10340pub struct RangeExpression<'tree> {
10341 pub span: ::treesitter_types::Span,
10342 pub children: ::std::vec::Vec<Expression<'tree>>,
10343}
10344impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
10345 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10346 fn from_node(
10347 node: ::treesitter_types::tree_sitter::Node<'tree>,
10348 src: &'tree [u8],
10349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10350 debug_assert_eq!(node.kind(), "range_expression");
10351 Ok(Self {
10352 span: ::treesitter_types::Span::from(node),
10353 children: {
10354 #[allow(clippy::suspicious_else_formatting)]
10355 let non_field_children = {
10356 let mut cursor = node.walk();
10357 let mut result = ::std::vec::Vec::new();
10358 if cursor.goto_first_child() {
10359 loop {
10360 if cursor.field_name().is_none()
10361 && cursor.node().is_named()
10362 && !cursor.node().is_extra()
10363 {
10364 result.push(cursor.node());
10365 }
10366 if !cursor.goto_next_sibling() {
10367 break;
10368 }
10369 }
10370 }
10371 result
10372 };
10373 let mut items = ::std::vec::Vec::new();
10374 for child in non_field_children {
10375 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10376 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10377 })?);
10378 }
10379 items
10380 },
10381 })
10382 }
10383}
10384impl ::treesitter_types::Spanned for RangeExpression<'_> {
10385 fn span(&self) -> ::treesitter_types::Span {
10386 self.span
10387 }
10388}
10389#[derive(Debug, Clone, PartialEq, Eq)]
10390pub struct RawStringLiteral<'tree> {
10391 pub span: ::treesitter_types::Span,
10392 pub children: ::std::vec::Vec<RawStringLiteralChildren<'tree>>,
10393}
10394impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
10395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10396 fn from_node(
10397 node: ::treesitter_types::tree_sitter::Node<'tree>,
10398 src: &'tree [u8],
10399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10400 debug_assert_eq!(node.kind(), "raw_string_literal");
10401 Ok(Self {
10402 span: ::treesitter_types::Span::from(node),
10403 children: {
10404 #[allow(clippy::suspicious_else_formatting)]
10405 let non_field_children = {
10406 let mut cursor = node.walk();
10407 let mut result = ::std::vec::Vec::new();
10408 if cursor.goto_first_child() {
10409 loop {
10410 if cursor.field_name().is_none()
10411 && cursor.node().is_named()
10412 && !cursor.node().is_extra()
10413 {
10414 result.push(cursor.node());
10415 }
10416 if !cursor.goto_next_sibling() {
10417 break;
10418 }
10419 }
10420 }
10421 result
10422 };
10423 let mut items = ::std::vec::Vec::new();
10424 for child in non_field_children {
10425 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10426 <RawStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
10427 child, src,
10428 )
10429 })?);
10430 }
10431 items
10432 },
10433 })
10434 }
10435}
10436impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
10437 fn span(&self) -> ::treesitter_types::Span {
10438 self.span
10439 }
10440}
10441#[derive(Debug, Clone, PartialEq, Eq)]
10442pub struct RecordDeclaration<'tree> {
10443 pub span: ::treesitter_types::Span,
10444 pub body: ::core::option::Option<DeclarationList<'tree>>,
10445 pub name: Identifier<'tree>,
10446 pub children: ::std::vec::Vec<RecordDeclarationChildren<'tree>>,
10447}
10448impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
10449 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10450 fn from_node(
10451 node: ::treesitter_types::tree_sitter::Node<'tree>,
10452 src: &'tree [u8],
10453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10454 debug_assert_eq!(node.kind(), "record_declaration");
10455 Ok(Self {
10456 span: ::treesitter_types::Span::from(node),
10457 body: match node.child_by_field_name("body") {
10458 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10459 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
10460 })?),
10461 None => None,
10462 },
10463 name: {
10464 let child = node
10465 .child_by_field_name("name")
10466 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10467 ::treesitter_types::runtime::maybe_grow_stack(|| {
10468 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10469 })?
10470 },
10471 children: {
10472 #[allow(clippy::suspicious_else_formatting)]
10473 let non_field_children = {
10474 let mut cursor = node.walk();
10475 let mut result = ::std::vec::Vec::new();
10476 if cursor.goto_first_child() {
10477 loop {
10478 if cursor.field_name().is_none()
10479 && cursor.node().is_named()
10480 && !cursor.node().is_extra()
10481 {
10482 result.push(cursor.node());
10483 }
10484 if !cursor.goto_next_sibling() {
10485 break;
10486 }
10487 }
10488 }
10489 result
10490 };
10491 let mut items = ::std::vec::Vec::new();
10492 for child in non_field_children {
10493 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10494 <RecordDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10495 child, src,
10496 )
10497 })?);
10498 }
10499 items
10500 },
10501 })
10502 }
10503}
10504impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
10505 fn span(&self) -> ::treesitter_types::Span {
10506 self.span
10507 }
10508}
10509#[derive(Debug, Clone, PartialEq, Eq)]
10510pub struct RecursivePattern<'tree> {
10511 pub span: ::treesitter_types::Span,
10512 pub name: ::core::option::Option<Identifier<'tree>>,
10513 pub r#type: ::core::option::Option<Type<'tree>>,
10514 pub children: ::std::vec::Vec<RecursivePatternChildren<'tree>>,
10515}
10516impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePattern<'tree> {
10517 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10518 fn from_node(
10519 node: ::treesitter_types::tree_sitter::Node<'tree>,
10520 src: &'tree [u8],
10521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10522 debug_assert_eq!(node.kind(), "recursive_pattern");
10523 Ok(Self {
10524 span: ::treesitter_types::Span::from(node),
10525 name: match node.child_by_field_name("name") {
10526 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10527 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10528 })?),
10529 None => None,
10530 },
10531 r#type: match node.child_by_field_name("type") {
10532 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10533 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10534 })?),
10535 None => None,
10536 },
10537 children: {
10538 #[allow(clippy::suspicious_else_formatting)]
10539 let non_field_children = {
10540 let mut cursor = node.walk();
10541 let mut result = ::std::vec::Vec::new();
10542 if cursor.goto_first_child() {
10543 loop {
10544 if cursor.field_name().is_none()
10545 && cursor.node().is_named()
10546 && !cursor.node().is_extra()
10547 {
10548 result.push(cursor.node());
10549 }
10550 if !cursor.goto_next_sibling() {
10551 break;
10552 }
10553 }
10554 }
10555 result
10556 };
10557 let mut items = ::std::vec::Vec::new();
10558 for child in non_field_children {
10559 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10560 <RecursivePatternChildren as ::treesitter_types::FromNode>::from_node(
10561 child, src,
10562 )
10563 })?);
10564 }
10565 items
10566 },
10567 })
10568 }
10569}
10570impl ::treesitter_types::Spanned for RecursivePattern<'_> {
10571 fn span(&self) -> ::treesitter_types::Span {
10572 self.span
10573 }
10574}
10575#[derive(Debug, Clone, PartialEq, Eq)]
10576pub struct RefExpression<'tree> {
10577 pub span: ::treesitter_types::Span,
10578 pub children: Expression<'tree>,
10579}
10580impl<'tree> ::treesitter_types::FromNode<'tree> for RefExpression<'tree> {
10581 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10582 fn from_node(
10583 node: ::treesitter_types::tree_sitter::Node<'tree>,
10584 src: &'tree [u8],
10585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10586 debug_assert_eq!(node.kind(), "ref_expression");
10587 Ok(Self {
10588 span: ::treesitter_types::Span::from(node),
10589 children: {
10590 #[allow(clippy::suspicious_else_formatting)]
10591 let non_field_children = {
10592 let mut cursor = node.walk();
10593 let mut result = ::std::vec::Vec::new();
10594 if cursor.goto_first_child() {
10595 loop {
10596 if cursor.field_name().is_none()
10597 && cursor.node().is_named()
10598 && !cursor.node().is_extra()
10599 {
10600 result.push(cursor.node());
10601 }
10602 if !cursor.goto_next_sibling() {
10603 break;
10604 }
10605 }
10606 }
10607 result
10608 };
10609 let child = if let Some(&c) = non_field_children.first() {
10610 c
10611 } else {
10612 let mut fallback_cursor = node.walk();
10613 let mut fallback_child = None;
10614 if fallback_cursor.goto_first_child() {
10615 loop {
10616 if fallback_cursor.field_name().is_none()
10617 && !fallback_cursor.node().is_extra()
10618 {
10619 let candidate = fallback_cursor.node();
10620 #[allow(clippy::needless_question_mark)]
10621 if (|| -> ::core::result::Result<
10622 _,
10623 ::treesitter_types::ParseError,
10624 > {
10625 let child = candidate;
10626 Ok(
10627 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10628 child,
10629 src,
10630 ))?,
10631 )
10632 })()
10633 .is_ok()
10634 {
10635 fallback_child = Some(candidate);
10636 break;
10637 }
10638 }
10639 if !fallback_cursor.goto_next_sibling() {
10640 break;
10641 }
10642 }
10643 }
10644 if fallback_child.is_none() {
10645 let mut cursor2 = node.walk();
10646 if cursor2.goto_first_child() {
10647 loop {
10648 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10649 let candidate = cursor2.node();
10650 #[allow(clippy::needless_question_mark)]
10651 if (|| -> ::core::result::Result<
10652 _,
10653 ::treesitter_types::ParseError,
10654 > {
10655 let child = candidate;
10656 Ok(
10657 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10658 child,
10659 src,
10660 ))?,
10661 )
10662 })()
10663 .is_ok()
10664 {
10665 fallback_child = Some(candidate);
10666 break;
10667 }
10668 }
10669 if !cursor2.goto_next_sibling() {
10670 break;
10671 }
10672 }
10673 }
10674 }
10675 fallback_child.ok_or_else(|| {
10676 ::treesitter_types::ParseError::missing_field("children", node)
10677 })?
10678 };
10679 ::treesitter_types::runtime::maybe_grow_stack(|| {
10680 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10681 })?
10682 },
10683 })
10684 }
10685}
10686impl ::treesitter_types::Spanned for RefExpression<'_> {
10687 fn span(&self) -> ::treesitter_types::Span {
10688 self.span
10689 }
10690}
10691#[derive(Debug, Clone, PartialEq, Eq)]
10692pub struct RefType<'tree> {
10693 pub span: ::treesitter_types::Span,
10694 pub r#type: Type<'tree>,
10695}
10696impl<'tree> ::treesitter_types::FromNode<'tree> for RefType<'tree> {
10697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10698 fn from_node(
10699 node: ::treesitter_types::tree_sitter::Node<'tree>,
10700 src: &'tree [u8],
10701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10702 debug_assert_eq!(node.kind(), "ref_type");
10703 Ok(Self {
10704 span: ::treesitter_types::Span::from(node),
10705 r#type: {
10706 let child = node
10707 .child_by_field_name("type")
10708 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10709 ::treesitter_types::runtime::maybe_grow_stack(|| {
10710 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10711 })?
10712 },
10713 })
10714 }
10715}
10716impl ::treesitter_types::Spanned for RefType<'_> {
10717 fn span(&self) -> ::treesitter_types::Span {
10718 self.span
10719 }
10720}
10721#[derive(Debug, Clone, PartialEq, Eq)]
10722pub struct ReftypeExpression<'tree> {
10723 pub span: ::treesitter_types::Span,
10724 pub children: Expression<'tree>,
10725}
10726impl<'tree> ::treesitter_types::FromNode<'tree> for ReftypeExpression<'tree> {
10727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10728 fn from_node(
10729 node: ::treesitter_types::tree_sitter::Node<'tree>,
10730 src: &'tree [u8],
10731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10732 debug_assert_eq!(node.kind(), "reftype_expression");
10733 Ok(Self {
10734 span: ::treesitter_types::Span::from(node),
10735 children: {
10736 #[allow(clippy::suspicious_else_formatting)]
10737 let non_field_children = {
10738 let mut cursor = node.walk();
10739 let mut result = ::std::vec::Vec::new();
10740 if cursor.goto_first_child() {
10741 loop {
10742 if cursor.field_name().is_none()
10743 && cursor.node().is_named()
10744 && !cursor.node().is_extra()
10745 {
10746 result.push(cursor.node());
10747 }
10748 if !cursor.goto_next_sibling() {
10749 break;
10750 }
10751 }
10752 }
10753 result
10754 };
10755 let child = if let Some(&c) = non_field_children.first() {
10756 c
10757 } else {
10758 let mut fallback_cursor = node.walk();
10759 let mut fallback_child = None;
10760 if fallback_cursor.goto_first_child() {
10761 loop {
10762 if fallback_cursor.field_name().is_none()
10763 && !fallback_cursor.node().is_extra()
10764 {
10765 let candidate = fallback_cursor.node();
10766 #[allow(clippy::needless_question_mark)]
10767 if (|| -> ::core::result::Result<
10768 _,
10769 ::treesitter_types::ParseError,
10770 > {
10771 let child = candidate;
10772 Ok(
10773 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10774 child,
10775 src,
10776 ))?,
10777 )
10778 })()
10779 .is_ok()
10780 {
10781 fallback_child = Some(candidate);
10782 break;
10783 }
10784 }
10785 if !fallback_cursor.goto_next_sibling() {
10786 break;
10787 }
10788 }
10789 }
10790 if fallback_child.is_none() {
10791 let mut cursor2 = node.walk();
10792 if cursor2.goto_first_child() {
10793 loop {
10794 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10795 let candidate = cursor2.node();
10796 #[allow(clippy::needless_question_mark)]
10797 if (|| -> ::core::result::Result<
10798 _,
10799 ::treesitter_types::ParseError,
10800 > {
10801 let child = candidate;
10802 Ok(
10803 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10804 child,
10805 src,
10806 ))?,
10807 )
10808 })()
10809 .is_ok()
10810 {
10811 fallback_child = Some(candidate);
10812 break;
10813 }
10814 }
10815 if !cursor2.goto_next_sibling() {
10816 break;
10817 }
10818 }
10819 }
10820 }
10821 fallback_child.ok_or_else(|| {
10822 ::treesitter_types::ParseError::missing_field("children", node)
10823 })?
10824 };
10825 ::treesitter_types::runtime::maybe_grow_stack(|| {
10826 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10827 })?
10828 },
10829 })
10830 }
10831}
10832impl ::treesitter_types::Spanned for ReftypeExpression<'_> {
10833 fn span(&self) -> ::treesitter_types::Span {
10834 self.span
10835 }
10836}
10837#[derive(Debug, Clone, PartialEq, Eq)]
10838pub struct RefvalueExpression<'tree> {
10839 pub span: ::treesitter_types::Span,
10840 pub r#type: Type<'tree>,
10841 pub value: Expression<'tree>,
10842}
10843impl<'tree> ::treesitter_types::FromNode<'tree> for RefvalueExpression<'tree> {
10844 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10845 fn from_node(
10846 node: ::treesitter_types::tree_sitter::Node<'tree>,
10847 src: &'tree [u8],
10848 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10849 debug_assert_eq!(node.kind(), "refvalue_expression");
10850 Ok(Self {
10851 span: ::treesitter_types::Span::from(node),
10852 r#type: {
10853 let child = node
10854 .child_by_field_name("type")
10855 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10856 ::treesitter_types::runtime::maybe_grow_stack(|| {
10857 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10858 })?
10859 },
10860 value: {
10861 let child = node
10862 .child_by_field_name("value")
10863 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
10864 ::treesitter_types::runtime::maybe_grow_stack(|| {
10865 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10866 })?
10867 },
10868 })
10869 }
10870}
10871impl ::treesitter_types::Spanned for RefvalueExpression<'_> {
10872 fn span(&self) -> ::treesitter_types::Span {
10873 self.span
10874 }
10875}
10876#[derive(Debug, Clone, PartialEq, Eq)]
10877pub struct RelationalPattern<'tree> {
10878 pub span: ::treesitter_types::Span,
10879 pub children: Expression<'tree>,
10880}
10881impl<'tree> ::treesitter_types::FromNode<'tree> for RelationalPattern<'tree> {
10882 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10883 fn from_node(
10884 node: ::treesitter_types::tree_sitter::Node<'tree>,
10885 src: &'tree [u8],
10886 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10887 debug_assert_eq!(node.kind(), "relational_pattern");
10888 Ok(Self {
10889 span: ::treesitter_types::Span::from(node),
10890 children: {
10891 #[allow(clippy::suspicious_else_formatting)]
10892 let non_field_children = {
10893 let mut cursor = node.walk();
10894 let mut result = ::std::vec::Vec::new();
10895 if cursor.goto_first_child() {
10896 loop {
10897 if cursor.field_name().is_none()
10898 && cursor.node().is_named()
10899 && !cursor.node().is_extra()
10900 {
10901 result.push(cursor.node());
10902 }
10903 if !cursor.goto_next_sibling() {
10904 break;
10905 }
10906 }
10907 }
10908 result
10909 };
10910 let child = if let Some(&c) = non_field_children.first() {
10911 c
10912 } else {
10913 let mut fallback_cursor = node.walk();
10914 let mut fallback_child = None;
10915 if fallback_cursor.goto_first_child() {
10916 loop {
10917 if fallback_cursor.field_name().is_none()
10918 && !fallback_cursor.node().is_extra()
10919 {
10920 let candidate = fallback_cursor.node();
10921 #[allow(clippy::needless_question_mark)]
10922 if (|| -> ::core::result::Result<
10923 _,
10924 ::treesitter_types::ParseError,
10925 > {
10926 let child = candidate;
10927 Ok(
10928 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10929 child,
10930 src,
10931 ))?,
10932 )
10933 })()
10934 .is_ok()
10935 {
10936 fallback_child = Some(candidate);
10937 break;
10938 }
10939 }
10940 if !fallback_cursor.goto_next_sibling() {
10941 break;
10942 }
10943 }
10944 }
10945 if fallback_child.is_none() {
10946 let mut cursor2 = node.walk();
10947 if cursor2.goto_first_child() {
10948 loop {
10949 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10950 let candidate = cursor2.node();
10951 #[allow(clippy::needless_question_mark)]
10952 if (|| -> ::core::result::Result<
10953 _,
10954 ::treesitter_types::ParseError,
10955 > {
10956 let child = candidate;
10957 Ok(
10958 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10959 child,
10960 src,
10961 ))?,
10962 )
10963 })()
10964 .is_ok()
10965 {
10966 fallback_child = Some(candidate);
10967 break;
10968 }
10969 }
10970 if !cursor2.goto_next_sibling() {
10971 break;
10972 }
10973 }
10974 }
10975 }
10976 fallback_child.ok_or_else(|| {
10977 ::treesitter_types::ParseError::missing_field("children", node)
10978 })?
10979 };
10980 ::treesitter_types::runtime::maybe_grow_stack(|| {
10981 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10982 })?
10983 },
10984 })
10985 }
10986}
10987impl ::treesitter_types::Spanned for RelationalPattern<'_> {
10988 fn span(&self) -> ::treesitter_types::Span {
10989 self.span
10990 }
10991}
10992#[derive(Debug, Clone, PartialEq, Eq)]
10993pub struct ReturnStatement<'tree> {
10994 pub span: ::treesitter_types::Span,
10995 pub children: ::core::option::Option<Expression<'tree>>,
10996}
10997impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
10998 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10999 fn from_node(
11000 node: ::treesitter_types::tree_sitter::Node<'tree>,
11001 src: &'tree [u8],
11002 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11003 debug_assert_eq!(node.kind(), "return_statement");
11004 Ok(Self {
11005 span: ::treesitter_types::Span::from(node),
11006 children: {
11007 #[allow(clippy::suspicious_else_formatting)]
11008 let non_field_children = {
11009 let mut cursor = node.walk();
11010 let mut result = ::std::vec::Vec::new();
11011 if cursor.goto_first_child() {
11012 loop {
11013 if cursor.field_name().is_none()
11014 && cursor.node().is_named()
11015 && !cursor.node().is_extra()
11016 {
11017 result.push(cursor.node());
11018 }
11019 if !cursor.goto_next_sibling() {
11020 break;
11021 }
11022 }
11023 }
11024 result
11025 };
11026 match non_field_children.first() {
11027 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11028 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11029 })?),
11030 None => None,
11031 }
11032 },
11033 })
11034 }
11035}
11036impl ::treesitter_types::Spanned for ReturnStatement<'_> {
11037 fn span(&self) -> ::treesitter_types::Span {
11038 self.span
11039 }
11040}
11041#[derive(Debug, Clone, PartialEq, Eq)]
11042pub struct ScopedType<'tree> {
11043 pub span: ::treesitter_types::Span,
11044 pub r#type: ScopedTypeType<'tree>,
11045}
11046impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedType<'tree> {
11047 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11048 fn from_node(
11049 node: ::treesitter_types::tree_sitter::Node<'tree>,
11050 src: &'tree [u8],
11051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11052 debug_assert_eq!(node.kind(), "scoped_type");
11053 Ok(Self {
11054 span: ::treesitter_types::Span::from(node),
11055 r#type: {
11056 let child = node
11057 .child_by_field_name("type")
11058 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11059 ::treesitter_types::runtime::maybe_grow_stack(|| {
11060 <ScopedTypeType as ::treesitter_types::FromNode>::from_node(child, src)
11061 })?
11062 },
11063 })
11064 }
11065}
11066impl ::treesitter_types::Spanned for ScopedType<'_> {
11067 fn span(&self) -> ::treesitter_types::Span {
11068 self.span
11069 }
11070}
11071#[derive(Debug, Clone, PartialEq, Eq)]
11072pub struct SelectClause<'tree> {
11073 pub span: ::treesitter_types::Span,
11074 pub children: Expression<'tree>,
11075}
11076impl<'tree> ::treesitter_types::FromNode<'tree> for SelectClause<'tree> {
11077 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11078 fn from_node(
11079 node: ::treesitter_types::tree_sitter::Node<'tree>,
11080 src: &'tree [u8],
11081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11082 debug_assert_eq!(node.kind(), "select_clause");
11083 Ok(Self {
11084 span: ::treesitter_types::Span::from(node),
11085 children: {
11086 #[allow(clippy::suspicious_else_formatting)]
11087 let non_field_children = {
11088 let mut cursor = node.walk();
11089 let mut result = ::std::vec::Vec::new();
11090 if cursor.goto_first_child() {
11091 loop {
11092 if cursor.field_name().is_none()
11093 && cursor.node().is_named()
11094 && !cursor.node().is_extra()
11095 {
11096 result.push(cursor.node());
11097 }
11098 if !cursor.goto_next_sibling() {
11099 break;
11100 }
11101 }
11102 }
11103 result
11104 };
11105 let child = if let Some(&c) = non_field_children.first() {
11106 c
11107 } else {
11108 let mut fallback_cursor = node.walk();
11109 let mut fallback_child = None;
11110 if fallback_cursor.goto_first_child() {
11111 loop {
11112 if fallback_cursor.field_name().is_none()
11113 && !fallback_cursor.node().is_extra()
11114 {
11115 let candidate = fallback_cursor.node();
11116 #[allow(clippy::needless_question_mark)]
11117 if (|| -> ::core::result::Result<
11118 _,
11119 ::treesitter_types::ParseError,
11120 > {
11121 let child = candidate;
11122 Ok(
11123 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11124 child,
11125 src,
11126 ))?,
11127 )
11128 })()
11129 .is_ok()
11130 {
11131 fallback_child = Some(candidate);
11132 break;
11133 }
11134 }
11135 if !fallback_cursor.goto_next_sibling() {
11136 break;
11137 }
11138 }
11139 }
11140 if fallback_child.is_none() {
11141 let mut cursor2 = node.walk();
11142 if cursor2.goto_first_child() {
11143 loop {
11144 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11145 let candidate = cursor2.node();
11146 #[allow(clippy::needless_question_mark)]
11147 if (|| -> ::core::result::Result<
11148 _,
11149 ::treesitter_types::ParseError,
11150 > {
11151 let child = candidate;
11152 Ok(
11153 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11154 child,
11155 src,
11156 ))?,
11157 )
11158 })()
11159 .is_ok()
11160 {
11161 fallback_child = Some(candidate);
11162 break;
11163 }
11164 }
11165 if !cursor2.goto_next_sibling() {
11166 break;
11167 }
11168 }
11169 }
11170 }
11171 fallback_child.ok_or_else(|| {
11172 ::treesitter_types::ParseError::missing_field("children", node)
11173 })?
11174 };
11175 ::treesitter_types::runtime::maybe_grow_stack(|| {
11176 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11177 })?
11178 },
11179 })
11180 }
11181}
11182impl ::treesitter_types::Spanned for SelectClause<'_> {
11183 fn span(&self) -> ::treesitter_types::Span {
11184 self.span
11185 }
11186}
11187#[derive(Debug, Clone, PartialEq, Eq)]
11188pub struct SizeofExpression<'tree> {
11189 pub span: ::treesitter_types::Span,
11190 pub r#type: Type<'tree>,
11191}
11192impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
11193 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11194 fn from_node(
11195 node: ::treesitter_types::tree_sitter::Node<'tree>,
11196 src: &'tree [u8],
11197 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11198 debug_assert_eq!(node.kind(), "sizeof_expression");
11199 Ok(Self {
11200 span: ::treesitter_types::Span::from(node),
11201 r#type: {
11202 let child = node
11203 .child_by_field_name("type")
11204 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11205 ::treesitter_types::runtime::maybe_grow_stack(|| {
11206 <Type as ::treesitter_types::FromNode>::from_node(child, src)
11207 })?
11208 },
11209 })
11210 }
11211}
11212impl ::treesitter_types::Spanned for SizeofExpression<'_> {
11213 fn span(&self) -> ::treesitter_types::Span {
11214 self.span
11215 }
11216}
11217#[derive(Debug, Clone, PartialEq, Eq)]
11218pub struct StackallocExpression<'tree> {
11219 pub span: ::treesitter_types::Span,
11220 pub r#type: ArrayType<'tree>,
11221 pub children: ::core::option::Option<InitializerExpression<'tree>>,
11222}
11223impl<'tree> ::treesitter_types::FromNode<'tree> for StackallocExpression<'tree> {
11224 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11225 fn from_node(
11226 node: ::treesitter_types::tree_sitter::Node<'tree>,
11227 src: &'tree [u8],
11228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11229 debug_assert_eq!(node.kind(), "stackalloc_expression");
11230 Ok(Self {
11231 span: ::treesitter_types::Span::from(node),
11232 r#type: {
11233 let child = node
11234 .child_by_field_name("type")
11235 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11236 ::treesitter_types::runtime::maybe_grow_stack(|| {
11237 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)
11238 })?
11239 },
11240 children: {
11241 #[allow(clippy::suspicious_else_formatting)]
11242 let non_field_children = {
11243 let mut cursor = node.walk();
11244 let mut result = ::std::vec::Vec::new();
11245 if cursor.goto_first_child() {
11246 loop {
11247 if cursor.field_name().is_none()
11248 && cursor.node().is_named()
11249 && !cursor.node().is_extra()
11250 {
11251 result.push(cursor.node());
11252 }
11253 if !cursor.goto_next_sibling() {
11254 break;
11255 }
11256 }
11257 }
11258 result
11259 };
11260 match non_field_children.first() {
11261 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11262 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
11263 child, src,
11264 )
11265 })?),
11266 None => None,
11267 }
11268 },
11269 })
11270 }
11271}
11272impl ::treesitter_types::Spanned for StackallocExpression<'_> {
11273 fn span(&self) -> ::treesitter_types::Span {
11274 self.span
11275 }
11276}
11277#[derive(Debug, Clone, PartialEq, Eq)]
11278pub struct StringLiteral<'tree> {
11279 pub span: ::treesitter_types::Span,
11280 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
11281}
11282impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
11283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11284 fn from_node(
11285 node: ::treesitter_types::tree_sitter::Node<'tree>,
11286 src: &'tree [u8],
11287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11288 debug_assert_eq!(node.kind(), "string_literal");
11289 Ok(Self {
11290 span: ::treesitter_types::Span::from(node),
11291 children: {
11292 #[allow(clippy::suspicious_else_formatting)]
11293 let non_field_children = {
11294 let mut cursor = node.walk();
11295 let mut result = ::std::vec::Vec::new();
11296 if cursor.goto_first_child() {
11297 loop {
11298 if cursor.field_name().is_none()
11299 && cursor.node().is_named()
11300 && !cursor.node().is_extra()
11301 {
11302 result.push(cursor.node());
11303 }
11304 if !cursor.goto_next_sibling() {
11305 break;
11306 }
11307 }
11308 }
11309 result
11310 };
11311 let mut items = ::std::vec::Vec::new();
11312 for child in non_field_children {
11313 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11314 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
11315 child, src,
11316 )
11317 })?);
11318 }
11319 items
11320 },
11321 })
11322 }
11323}
11324impl ::treesitter_types::Spanned for StringLiteral<'_> {
11325 fn span(&self) -> ::treesitter_types::Span {
11326 self.span
11327 }
11328}
11329#[derive(Debug, Clone, PartialEq, Eq)]
11330pub struct StringLiteralContent<'tree> {
11331 pub span: ::treesitter_types::Span,
11332 text: &'tree str,
11333}
11334impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralContent<'tree> {
11335 fn from_node(
11336 node: ::treesitter_types::tree_sitter::Node<'tree>,
11337 src: &'tree [u8],
11338 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11339 debug_assert_eq!(node.kind(), "string_literal_content");
11340 Ok(Self {
11341 span: ::treesitter_types::Span::from(node),
11342 text: node.utf8_text(src)?,
11343 })
11344 }
11345}
11346impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralContent<'tree> {
11347 fn text(&self) -> &'tree str {
11348 self.text
11349 }
11350}
11351impl ::treesitter_types::Spanned for StringLiteralContent<'_> {
11352 fn span(&self) -> ::treesitter_types::Span {
11353 self.span
11354 }
11355}
11356#[derive(Debug, Clone, PartialEq, Eq)]
11357pub struct StructDeclaration<'tree> {
11358 pub span: ::treesitter_types::Span,
11359 pub body: DeclarationList<'tree>,
11360 pub name: Identifier<'tree>,
11361 pub children: ::std::vec::Vec<StructDeclarationChildren<'tree>>,
11362}
11363impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclaration<'tree> {
11364 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11365 fn from_node(
11366 node: ::treesitter_types::tree_sitter::Node<'tree>,
11367 src: &'tree [u8],
11368 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11369 debug_assert_eq!(node.kind(), "struct_declaration");
11370 Ok(Self {
11371 span: ::treesitter_types::Span::from(node),
11372 body: {
11373 let child = node
11374 .child_by_field_name("body")
11375 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11376 ::treesitter_types::runtime::maybe_grow_stack(|| {
11377 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
11378 })?
11379 },
11380 name: {
11381 let child = node
11382 .child_by_field_name("name")
11383 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
11384 ::treesitter_types::runtime::maybe_grow_stack(|| {
11385 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
11386 })?
11387 },
11388 children: {
11389 #[allow(clippy::suspicious_else_formatting)]
11390 let non_field_children = {
11391 let mut cursor = node.walk();
11392 let mut result = ::std::vec::Vec::new();
11393 if cursor.goto_first_child() {
11394 loop {
11395 if cursor.field_name().is_none()
11396 && cursor.node().is_named()
11397 && !cursor.node().is_extra()
11398 {
11399 result.push(cursor.node());
11400 }
11401 if !cursor.goto_next_sibling() {
11402 break;
11403 }
11404 }
11405 }
11406 result
11407 };
11408 let mut items = ::std::vec::Vec::new();
11409 for child in non_field_children {
11410 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11411 <StructDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11412 child, src,
11413 )
11414 })?);
11415 }
11416 items
11417 },
11418 })
11419 }
11420}
11421impl ::treesitter_types::Spanned for StructDeclaration<'_> {
11422 fn span(&self) -> ::treesitter_types::Span {
11423 self.span
11424 }
11425}
11426#[derive(Debug, Clone, PartialEq, Eq)]
11427pub struct Subpattern<'tree> {
11428 pub span: ::treesitter_types::Span,
11429 pub children: ::std::vec::Vec<SubpatternChildren<'tree>>,
11430}
11431impl<'tree> ::treesitter_types::FromNode<'tree> for Subpattern<'tree> {
11432 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11433 fn from_node(
11434 node: ::treesitter_types::tree_sitter::Node<'tree>,
11435 src: &'tree [u8],
11436 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11437 debug_assert_eq!(node.kind(), "subpattern");
11438 Ok(Self {
11439 span: ::treesitter_types::Span::from(node),
11440 children: {
11441 #[allow(clippy::suspicious_else_formatting)]
11442 let non_field_children = {
11443 let mut cursor = node.walk();
11444 let mut result = ::std::vec::Vec::new();
11445 if cursor.goto_first_child() {
11446 loop {
11447 if cursor.field_name().is_none()
11448 && cursor.node().is_named()
11449 && !cursor.node().is_extra()
11450 {
11451 result.push(cursor.node());
11452 }
11453 if !cursor.goto_next_sibling() {
11454 break;
11455 }
11456 }
11457 }
11458 result
11459 };
11460 let mut items = ::std::vec::Vec::new();
11461 for child in non_field_children {
11462 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11463 <SubpatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
11464 })?);
11465 }
11466 items
11467 },
11468 })
11469 }
11470}
11471impl ::treesitter_types::Spanned for Subpattern<'_> {
11472 fn span(&self) -> ::treesitter_types::Span {
11473 self.span
11474 }
11475}
11476#[derive(Debug, Clone, PartialEq, Eq)]
11477pub struct SwitchBody<'tree> {
11478 pub span: ::treesitter_types::Span,
11479 pub children: ::std::vec::Vec<SwitchSection<'tree>>,
11480}
11481impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
11482 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11483 fn from_node(
11484 node: ::treesitter_types::tree_sitter::Node<'tree>,
11485 src: &'tree [u8],
11486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11487 debug_assert_eq!(node.kind(), "switch_body");
11488 Ok(Self {
11489 span: ::treesitter_types::Span::from(node),
11490 children: {
11491 #[allow(clippy::suspicious_else_formatting)]
11492 let non_field_children = {
11493 let mut cursor = node.walk();
11494 let mut result = ::std::vec::Vec::new();
11495 if cursor.goto_first_child() {
11496 loop {
11497 if cursor.field_name().is_none()
11498 && cursor.node().is_named()
11499 && !cursor.node().is_extra()
11500 {
11501 result.push(cursor.node());
11502 }
11503 if !cursor.goto_next_sibling() {
11504 break;
11505 }
11506 }
11507 }
11508 result
11509 };
11510 let mut items = ::std::vec::Vec::new();
11511 for child in non_field_children {
11512 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11513 <SwitchSection as ::treesitter_types::FromNode>::from_node(child, src)
11514 })?);
11515 }
11516 items
11517 },
11518 })
11519 }
11520}
11521impl ::treesitter_types::Spanned for SwitchBody<'_> {
11522 fn span(&self) -> ::treesitter_types::Span {
11523 self.span
11524 }
11525}
11526#[derive(Debug, Clone, PartialEq, Eq)]
11527pub struct SwitchExpression<'tree> {
11528 pub span: ::treesitter_types::Span,
11529 pub children: ::std::vec::Vec<SwitchExpressionChildren<'tree>>,
11530}
11531impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
11532 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11533 fn from_node(
11534 node: ::treesitter_types::tree_sitter::Node<'tree>,
11535 src: &'tree [u8],
11536 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11537 debug_assert_eq!(node.kind(), "switch_expression");
11538 Ok(Self {
11539 span: ::treesitter_types::Span::from(node),
11540 children: {
11541 #[allow(clippy::suspicious_else_formatting)]
11542 let non_field_children = {
11543 let mut cursor = node.walk();
11544 let mut result = ::std::vec::Vec::new();
11545 if cursor.goto_first_child() {
11546 loop {
11547 if cursor.field_name().is_none()
11548 && cursor.node().is_named()
11549 && !cursor.node().is_extra()
11550 {
11551 result.push(cursor.node());
11552 }
11553 if !cursor.goto_next_sibling() {
11554 break;
11555 }
11556 }
11557 }
11558 result
11559 };
11560 let mut items = ::std::vec::Vec::new();
11561 for child in non_field_children {
11562 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11563 <SwitchExpressionChildren as ::treesitter_types::FromNode>::from_node(
11564 child, src,
11565 )
11566 })?);
11567 }
11568 items
11569 },
11570 })
11571 }
11572}
11573impl ::treesitter_types::Spanned for SwitchExpression<'_> {
11574 fn span(&self) -> ::treesitter_types::Span {
11575 self.span
11576 }
11577}
11578#[derive(Debug, Clone, PartialEq, Eq)]
11579pub struct SwitchExpressionArm<'tree> {
11580 pub span: ::treesitter_types::Span,
11581 pub children: ::std::vec::Vec<SwitchExpressionArmChildren<'tree>>,
11582}
11583impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArm<'tree> {
11584 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11585 fn from_node(
11586 node: ::treesitter_types::tree_sitter::Node<'tree>,
11587 src: &'tree [u8],
11588 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11589 debug_assert_eq!(node.kind(), "switch_expression_arm");
11590 Ok(Self {
11591 span: ::treesitter_types::Span::from(node),
11592 children: {
11593 #[allow(clippy::suspicious_else_formatting)]
11594 let non_field_children = {
11595 let mut cursor = node.walk();
11596 let mut result = ::std::vec::Vec::new();
11597 if cursor.goto_first_child() {
11598 loop {
11599 if cursor.field_name().is_none()
11600 && cursor.node().is_named()
11601 && !cursor.node().is_extra()
11602 {
11603 result.push(cursor.node());
11604 }
11605 if !cursor.goto_next_sibling() {
11606 break;
11607 }
11608 }
11609 }
11610 result
11611 };
11612 let mut items = ::std::vec::Vec::new();
11613 for child in non_field_children {
11614 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11615 <SwitchExpressionArmChildren as ::treesitter_types::FromNode>::from_node(
11616 child, src,
11617 )
11618 })?);
11619 }
11620 items
11621 },
11622 })
11623 }
11624}
11625impl ::treesitter_types::Spanned for SwitchExpressionArm<'_> {
11626 fn span(&self) -> ::treesitter_types::Span {
11627 self.span
11628 }
11629}
11630#[derive(Debug, Clone, PartialEq, Eq)]
11631pub struct SwitchSection<'tree> {
11632 pub span: ::treesitter_types::Span,
11633 pub children: ::std::vec::Vec<SwitchSectionChildren<'tree>>,
11634}
11635impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSection<'tree> {
11636 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11637 fn from_node(
11638 node: ::treesitter_types::tree_sitter::Node<'tree>,
11639 src: &'tree [u8],
11640 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11641 debug_assert_eq!(node.kind(), "switch_section");
11642 Ok(Self {
11643 span: ::treesitter_types::Span::from(node),
11644 children: {
11645 #[allow(clippy::suspicious_else_formatting)]
11646 let non_field_children = {
11647 let mut cursor = node.walk();
11648 let mut result = ::std::vec::Vec::new();
11649 if cursor.goto_first_child() {
11650 loop {
11651 if cursor.field_name().is_none()
11652 && cursor.node().is_named()
11653 && !cursor.node().is_extra()
11654 {
11655 result.push(cursor.node());
11656 }
11657 if !cursor.goto_next_sibling() {
11658 break;
11659 }
11660 }
11661 }
11662 result
11663 };
11664 let mut items = ::std::vec::Vec::new();
11665 for child in non_field_children {
11666 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11667 <SwitchSectionChildren as ::treesitter_types::FromNode>::from_node(
11668 child, src,
11669 )
11670 })?);
11671 }
11672 items
11673 },
11674 })
11675 }
11676}
11677impl ::treesitter_types::Spanned for SwitchSection<'_> {
11678 fn span(&self) -> ::treesitter_types::Span {
11679 self.span
11680 }
11681}
11682#[derive(Debug, Clone, PartialEq, Eq)]
11683pub struct SwitchStatement<'tree> {
11684 pub span: ::treesitter_types::Span,
11685 pub body: SwitchBody<'tree>,
11686 pub value: SwitchStatementValue<'tree>,
11687}
11688impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
11689 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11690 fn from_node(
11691 node: ::treesitter_types::tree_sitter::Node<'tree>,
11692 src: &'tree [u8],
11693 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11694 debug_assert_eq!(node.kind(), "switch_statement");
11695 Ok(Self {
11696 span: ::treesitter_types::Span::from(node),
11697 body: {
11698 let child = node
11699 .child_by_field_name("body")
11700 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11701 ::treesitter_types::runtime::maybe_grow_stack(|| {
11702 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)
11703 })?
11704 },
11705 value: {
11706 let child = node
11707 .child_by_field_name("value")
11708 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
11709 ::treesitter_types::runtime::maybe_grow_stack(|| {
11710 <SwitchStatementValue as ::treesitter_types::FromNode>::from_node(child, src)
11711 })?
11712 },
11713 })
11714 }
11715}
11716impl ::treesitter_types::Spanned for SwitchStatement<'_> {
11717 fn span(&self) -> ::treesitter_types::Span {
11718 self.span
11719 }
11720}
11721#[derive(Debug, Clone, PartialEq, Eq)]
11722pub struct ThrowExpression<'tree> {
11723 pub span: ::treesitter_types::Span,
11724 pub children: Expression<'tree>,
11725}
11726impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowExpression<'tree> {
11727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11728 fn from_node(
11729 node: ::treesitter_types::tree_sitter::Node<'tree>,
11730 src: &'tree [u8],
11731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11732 debug_assert_eq!(node.kind(), "throw_expression");
11733 Ok(Self {
11734 span: ::treesitter_types::Span::from(node),
11735 children: {
11736 #[allow(clippy::suspicious_else_formatting)]
11737 let non_field_children = {
11738 let mut cursor = node.walk();
11739 let mut result = ::std::vec::Vec::new();
11740 if cursor.goto_first_child() {
11741 loop {
11742 if cursor.field_name().is_none()
11743 && cursor.node().is_named()
11744 && !cursor.node().is_extra()
11745 {
11746 result.push(cursor.node());
11747 }
11748 if !cursor.goto_next_sibling() {
11749 break;
11750 }
11751 }
11752 }
11753 result
11754 };
11755 let child = if let Some(&c) = non_field_children.first() {
11756 c
11757 } else {
11758 let mut fallback_cursor = node.walk();
11759 let mut fallback_child = None;
11760 if fallback_cursor.goto_first_child() {
11761 loop {
11762 if fallback_cursor.field_name().is_none()
11763 && !fallback_cursor.node().is_extra()
11764 {
11765 let candidate = fallback_cursor.node();
11766 #[allow(clippy::needless_question_mark)]
11767 if (|| -> ::core::result::Result<
11768 _,
11769 ::treesitter_types::ParseError,
11770 > {
11771 let child = candidate;
11772 Ok(
11773 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11774 child,
11775 src,
11776 ))?,
11777 )
11778 })()
11779 .is_ok()
11780 {
11781 fallback_child = Some(candidate);
11782 break;
11783 }
11784 }
11785 if !fallback_cursor.goto_next_sibling() {
11786 break;
11787 }
11788 }
11789 }
11790 if fallback_child.is_none() {
11791 let mut cursor2 = node.walk();
11792 if cursor2.goto_first_child() {
11793 loop {
11794 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11795 let candidate = cursor2.node();
11796 #[allow(clippy::needless_question_mark)]
11797 if (|| -> ::core::result::Result<
11798 _,
11799 ::treesitter_types::ParseError,
11800 > {
11801 let child = candidate;
11802 Ok(
11803 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11804 child,
11805 src,
11806 ))?,
11807 )
11808 })()
11809 .is_ok()
11810 {
11811 fallback_child = Some(candidate);
11812 break;
11813 }
11814 }
11815 if !cursor2.goto_next_sibling() {
11816 break;
11817 }
11818 }
11819 }
11820 }
11821 fallback_child.ok_or_else(|| {
11822 ::treesitter_types::ParseError::missing_field("children", node)
11823 })?
11824 };
11825 ::treesitter_types::runtime::maybe_grow_stack(|| {
11826 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11827 })?
11828 },
11829 })
11830 }
11831}
11832impl ::treesitter_types::Spanned for ThrowExpression<'_> {
11833 fn span(&self) -> ::treesitter_types::Span {
11834 self.span
11835 }
11836}
11837#[derive(Debug, Clone, PartialEq, Eq)]
11838pub struct ThrowStatement<'tree> {
11839 pub span: ::treesitter_types::Span,
11840 pub children: ::core::option::Option<Expression<'tree>>,
11841}
11842impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
11843 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11844 fn from_node(
11845 node: ::treesitter_types::tree_sitter::Node<'tree>,
11846 src: &'tree [u8],
11847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11848 debug_assert_eq!(node.kind(), "throw_statement");
11849 Ok(Self {
11850 span: ::treesitter_types::Span::from(node),
11851 children: {
11852 #[allow(clippy::suspicious_else_formatting)]
11853 let non_field_children = {
11854 let mut cursor = node.walk();
11855 let mut result = ::std::vec::Vec::new();
11856 if cursor.goto_first_child() {
11857 loop {
11858 if cursor.field_name().is_none()
11859 && cursor.node().is_named()
11860 && !cursor.node().is_extra()
11861 {
11862 result.push(cursor.node());
11863 }
11864 if !cursor.goto_next_sibling() {
11865 break;
11866 }
11867 }
11868 }
11869 result
11870 };
11871 match non_field_children.first() {
11872 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11873 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11874 })?),
11875 None => None,
11876 }
11877 },
11878 })
11879 }
11880}
11881impl ::treesitter_types::Spanned for ThrowStatement<'_> {
11882 fn span(&self) -> ::treesitter_types::Span {
11883 self.span
11884 }
11885}
11886#[derive(Debug, Clone, PartialEq, Eq)]
11887pub struct TryStatement<'tree> {
11888 pub span: ::treesitter_types::Span,
11889 pub body: Block<'tree>,
11890 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
11891}
11892impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
11893 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11894 fn from_node(
11895 node: ::treesitter_types::tree_sitter::Node<'tree>,
11896 src: &'tree [u8],
11897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11898 debug_assert_eq!(node.kind(), "try_statement");
11899 Ok(Self {
11900 span: ::treesitter_types::Span::from(node),
11901 body: {
11902 let child = node
11903 .child_by_field_name("body")
11904 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11905 ::treesitter_types::runtime::maybe_grow_stack(|| {
11906 <Block as ::treesitter_types::FromNode>::from_node(child, src)
11907 })?
11908 },
11909 children: {
11910 #[allow(clippy::suspicious_else_formatting)]
11911 let non_field_children = {
11912 let mut cursor = node.walk();
11913 let mut result = ::std::vec::Vec::new();
11914 if cursor.goto_first_child() {
11915 loop {
11916 if cursor.field_name().is_none()
11917 && cursor.node().is_named()
11918 && !cursor.node().is_extra()
11919 {
11920 result.push(cursor.node());
11921 }
11922 if !cursor.goto_next_sibling() {
11923 break;
11924 }
11925 }
11926 }
11927 result
11928 };
11929 let mut items = ::std::vec::Vec::new();
11930 for child in non_field_children {
11931 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11932 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
11933 child, src,
11934 )
11935 })?);
11936 }
11937 items
11938 },
11939 })
11940 }
11941}
11942impl ::treesitter_types::Spanned for TryStatement<'_> {
11943 fn span(&self) -> ::treesitter_types::Span {
11944 self.span
11945 }
11946}
11947#[derive(Debug, Clone, PartialEq, Eq)]
11948pub struct TupleElement<'tree> {
11949 pub span: ::treesitter_types::Span,
11950 pub name: ::core::option::Option<Identifier<'tree>>,
11951 pub r#type: Type<'tree>,
11952}
11953impl<'tree> ::treesitter_types::FromNode<'tree> for TupleElement<'tree> {
11954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11955 fn from_node(
11956 node: ::treesitter_types::tree_sitter::Node<'tree>,
11957 src: &'tree [u8],
11958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11959 debug_assert_eq!(node.kind(), "tuple_element");
11960 Ok(Self {
11961 span: ::treesitter_types::Span::from(node),
11962 name: match node.child_by_field_name("name") {
11963 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11964 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
11965 })?),
11966 None => None,
11967 },
11968 r#type: {
11969 let child = node
11970 .child_by_field_name("type")
11971 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11972 ::treesitter_types::runtime::maybe_grow_stack(|| {
11973 <Type as ::treesitter_types::FromNode>::from_node(child, src)
11974 })?
11975 },
11976 })
11977 }
11978}
11979impl ::treesitter_types::Spanned for TupleElement<'_> {
11980 fn span(&self) -> ::treesitter_types::Span {
11981 self.span
11982 }
11983}
11984#[derive(Debug, Clone, PartialEq, Eq)]
11985pub struct TupleExpression<'tree> {
11986 pub span: ::treesitter_types::Span,
11987 pub children: ::std::vec::Vec<Argument<'tree>>,
11988}
11989impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
11990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11991 fn from_node(
11992 node: ::treesitter_types::tree_sitter::Node<'tree>,
11993 src: &'tree [u8],
11994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11995 debug_assert_eq!(node.kind(), "tuple_expression");
11996 Ok(Self {
11997 span: ::treesitter_types::Span::from(node),
11998 children: {
11999 #[allow(clippy::suspicious_else_formatting)]
12000 let non_field_children = {
12001 let mut cursor = node.walk();
12002 let mut result = ::std::vec::Vec::new();
12003 if cursor.goto_first_child() {
12004 loop {
12005 if cursor.field_name().is_none()
12006 && cursor.node().is_named()
12007 && !cursor.node().is_extra()
12008 {
12009 result.push(cursor.node());
12010 }
12011 if !cursor.goto_next_sibling() {
12012 break;
12013 }
12014 }
12015 }
12016 result
12017 };
12018 let mut items = ::std::vec::Vec::new();
12019 for child in non_field_children {
12020 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12021 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
12022 })?);
12023 }
12024 items
12025 },
12026 })
12027 }
12028}
12029impl ::treesitter_types::Spanned for TupleExpression<'_> {
12030 fn span(&self) -> ::treesitter_types::Span {
12031 self.span
12032 }
12033}
12034#[derive(Debug, Clone, PartialEq, Eq)]
12035pub struct TuplePattern<'tree> {
12036 pub span: ::treesitter_types::Span,
12037 pub name: ::std::vec::Vec<Identifier<'tree>>,
12038 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
12039}
12040impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
12041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12042 fn from_node(
12043 node: ::treesitter_types::tree_sitter::Node<'tree>,
12044 src: &'tree [u8],
12045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12046 debug_assert_eq!(node.kind(), "tuple_pattern");
12047 Ok(Self {
12048 span: ::treesitter_types::Span::from(node),
12049 name: {
12050 let mut cursor = node.walk();
12051 let mut items = ::std::vec::Vec::new();
12052 for child in node.children_by_field_name("name", &mut cursor) {
12053 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12054 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12055 })?);
12056 }
12057 items
12058 },
12059 children: {
12060 #[allow(clippy::suspicious_else_formatting)]
12061 let non_field_children = {
12062 let mut cursor = node.walk();
12063 let mut result = ::std::vec::Vec::new();
12064 if cursor.goto_first_child() {
12065 loop {
12066 if cursor.field_name().is_none()
12067 && cursor.node().is_named()
12068 && !cursor.node().is_extra()
12069 {
12070 result.push(cursor.node());
12071 }
12072 if !cursor.goto_next_sibling() {
12073 break;
12074 }
12075 }
12076 }
12077 result
12078 };
12079 let mut items = ::std::vec::Vec::new();
12080 for child in non_field_children {
12081 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12082 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
12083 child, src,
12084 )
12085 })?);
12086 }
12087 items
12088 },
12089 })
12090 }
12091}
12092impl ::treesitter_types::Spanned for TuplePattern<'_> {
12093 fn span(&self) -> ::treesitter_types::Span {
12094 self.span
12095 }
12096}
12097#[derive(Debug, Clone, PartialEq, Eq)]
12098pub struct TupleType<'tree> {
12099 pub span: ::treesitter_types::Span,
12100 pub children: ::std::vec::Vec<TupleElement<'tree>>,
12101}
12102impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
12103 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12104 fn from_node(
12105 node: ::treesitter_types::tree_sitter::Node<'tree>,
12106 src: &'tree [u8],
12107 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12108 debug_assert_eq!(node.kind(), "tuple_type");
12109 Ok(Self {
12110 span: ::treesitter_types::Span::from(node),
12111 children: {
12112 #[allow(clippy::suspicious_else_formatting)]
12113 let non_field_children = {
12114 let mut cursor = node.walk();
12115 let mut result = ::std::vec::Vec::new();
12116 if cursor.goto_first_child() {
12117 loop {
12118 if cursor.field_name().is_none()
12119 && cursor.node().is_named()
12120 && !cursor.node().is_extra()
12121 {
12122 result.push(cursor.node());
12123 }
12124 if !cursor.goto_next_sibling() {
12125 break;
12126 }
12127 }
12128 }
12129 result
12130 };
12131 let mut items = ::std::vec::Vec::new();
12132 for child in non_field_children {
12133 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12134 <TupleElement as ::treesitter_types::FromNode>::from_node(child, src)
12135 })?);
12136 }
12137 items
12138 },
12139 })
12140 }
12141}
12142impl ::treesitter_types::Spanned for TupleType<'_> {
12143 fn span(&self) -> ::treesitter_types::Span {
12144 self.span
12145 }
12146}
12147#[derive(Debug, Clone, PartialEq, Eq)]
12148pub struct TypeArgumentList<'tree> {
12149 pub span: ::treesitter_types::Span,
12150 pub children: ::std::vec::Vec<Type<'tree>>,
12151}
12152impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentList<'tree> {
12153 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12154 fn from_node(
12155 node: ::treesitter_types::tree_sitter::Node<'tree>,
12156 src: &'tree [u8],
12157 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12158 debug_assert_eq!(node.kind(), "type_argument_list");
12159 Ok(Self {
12160 span: ::treesitter_types::Span::from(node),
12161 children: {
12162 #[allow(clippy::suspicious_else_formatting)]
12163 let non_field_children = {
12164 let mut cursor = node.walk();
12165 let mut result = ::std::vec::Vec::new();
12166 if cursor.goto_first_child() {
12167 loop {
12168 if cursor.field_name().is_none()
12169 && cursor.node().is_named()
12170 && !cursor.node().is_extra()
12171 {
12172 result.push(cursor.node());
12173 }
12174 if !cursor.goto_next_sibling() {
12175 break;
12176 }
12177 }
12178 }
12179 result
12180 };
12181 let mut items = ::std::vec::Vec::new();
12182 for child in non_field_children {
12183 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12184 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12185 })?);
12186 }
12187 items
12188 },
12189 })
12190 }
12191}
12192impl ::treesitter_types::Spanned for TypeArgumentList<'_> {
12193 fn span(&self) -> ::treesitter_types::Span {
12194 self.span
12195 }
12196}
12197#[derive(Debug, Clone, PartialEq, Eq)]
12198pub struct TypeParameter<'tree> {
12199 pub span: ::treesitter_types::Span,
12200 pub name: Identifier<'tree>,
12201 pub children: ::std::vec::Vec<AttributeList<'tree>>,
12202}
12203impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
12204 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12205 fn from_node(
12206 node: ::treesitter_types::tree_sitter::Node<'tree>,
12207 src: &'tree [u8],
12208 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12209 debug_assert_eq!(node.kind(), "type_parameter");
12210 Ok(Self {
12211 span: ::treesitter_types::Span::from(node),
12212 name: {
12213 let child = node
12214 .child_by_field_name("name")
12215 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
12216 ::treesitter_types::runtime::maybe_grow_stack(|| {
12217 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12218 })?
12219 },
12220 children: {
12221 #[allow(clippy::suspicious_else_formatting)]
12222 let non_field_children = {
12223 let mut cursor = node.walk();
12224 let mut result = ::std::vec::Vec::new();
12225 if cursor.goto_first_child() {
12226 loop {
12227 if cursor.field_name().is_none()
12228 && cursor.node().is_named()
12229 && !cursor.node().is_extra()
12230 {
12231 result.push(cursor.node());
12232 }
12233 if !cursor.goto_next_sibling() {
12234 break;
12235 }
12236 }
12237 }
12238 result
12239 };
12240 let mut items = ::std::vec::Vec::new();
12241 for child in non_field_children {
12242 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12243 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
12244 })?);
12245 }
12246 items
12247 },
12248 })
12249 }
12250}
12251impl ::treesitter_types::Spanned for TypeParameter<'_> {
12252 fn span(&self) -> ::treesitter_types::Span {
12253 self.span
12254 }
12255}
12256#[derive(Debug, Clone, PartialEq, Eq)]
12257pub struct TypeParameterConstraint<'tree> {
12258 pub span: ::treesitter_types::Span,
12259 pub r#type: ::core::option::Option<Type<'tree>>,
12260 pub children: ::core::option::Option<ConstructorConstraint<'tree>>,
12261}
12262impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraint<'tree> {
12263 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12264 fn from_node(
12265 node: ::treesitter_types::tree_sitter::Node<'tree>,
12266 src: &'tree [u8],
12267 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12268 debug_assert_eq!(node.kind(), "type_parameter_constraint");
12269 Ok(Self {
12270 span: ::treesitter_types::Span::from(node),
12271 r#type: match node.child_by_field_name("type") {
12272 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12273 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12274 })?),
12275 None => None,
12276 },
12277 children: {
12278 #[allow(clippy::suspicious_else_formatting)]
12279 let non_field_children = {
12280 let mut cursor = node.walk();
12281 let mut result = ::std::vec::Vec::new();
12282 if cursor.goto_first_child() {
12283 loop {
12284 if cursor.field_name().is_none()
12285 && cursor.node().is_named()
12286 && !cursor.node().is_extra()
12287 {
12288 result.push(cursor.node());
12289 }
12290 if !cursor.goto_next_sibling() {
12291 break;
12292 }
12293 }
12294 }
12295 result
12296 };
12297 match non_field_children.first() {
12298 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12299 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(
12300 child, src,
12301 )
12302 })?),
12303 None => None,
12304 }
12305 },
12306 })
12307 }
12308}
12309impl ::treesitter_types::Spanned for TypeParameterConstraint<'_> {
12310 fn span(&self) -> ::treesitter_types::Span {
12311 self.span
12312 }
12313}
12314#[derive(Debug, Clone, PartialEq, Eq)]
12315pub struct TypeParameterConstraintsClause<'tree> {
12316 pub span: ::treesitter_types::Span,
12317 pub children: ::std::vec::Vec<TypeParameterConstraintsClauseChildren<'tree>>,
12318}
12319impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClause<'tree> {
12320 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12321 fn from_node(
12322 node: ::treesitter_types::tree_sitter::Node<'tree>,
12323 src: &'tree [u8],
12324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12325 debug_assert_eq!(node.kind(), "type_parameter_constraints_clause");
12326 Ok(Self {
12327 span: ::treesitter_types::Span::from(node),
12328 children: {
12329 #[allow(clippy::suspicious_else_formatting)]
12330 let non_field_children = {
12331 let mut cursor = node.walk();
12332 let mut result = ::std::vec::Vec::new();
12333 if cursor.goto_first_child() {
12334 loop {
12335 if cursor.field_name().is_none()
12336 && cursor.node().is_named()
12337 && !cursor.node().is_extra()
12338 {
12339 result.push(cursor.node());
12340 }
12341 if !cursor.goto_next_sibling() {
12342 break;
12343 }
12344 }
12345 }
12346 result
12347 };
12348 let mut items = ::std::vec::Vec::new();
12349 for child in non_field_children {
12350 items
12351 .push(
12352 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeParameterConstraintsClauseChildren as ::treesitter_types::FromNode>::from_node(
12353 child,
12354 src,
12355 ))?,
12356 );
12357 }
12358 items
12359 },
12360 })
12361 }
12362}
12363impl ::treesitter_types::Spanned for TypeParameterConstraintsClause<'_> {
12364 fn span(&self) -> ::treesitter_types::Span {
12365 self.span
12366 }
12367}
12368#[derive(Debug, Clone, PartialEq, Eq)]
12369pub struct TypeParameterList<'tree> {
12370 pub span: ::treesitter_types::Span,
12371 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
12372}
12373impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterList<'tree> {
12374 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12375 fn from_node(
12376 node: ::treesitter_types::tree_sitter::Node<'tree>,
12377 src: &'tree [u8],
12378 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12379 debug_assert_eq!(node.kind(), "type_parameter_list");
12380 Ok(Self {
12381 span: ::treesitter_types::Span::from(node),
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 let mut items = ::std::vec::Vec::new();
12403 for child in non_field_children {
12404 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12405 <TypeParameter as ::treesitter_types::FromNode>::from_node(child, src)
12406 })?);
12407 }
12408 items
12409 },
12410 })
12411 }
12412}
12413impl ::treesitter_types::Spanned for TypeParameterList<'_> {
12414 fn span(&self) -> ::treesitter_types::Span {
12415 self.span
12416 }
12417}
12418#[derive(Debug, Clone, PartialEq, Eq)]
12419pub struct TypePattern<'tree> {
12420 pub span: ::treesitter_types::Span,
12421 pub r#type: Type<'tree>,
12422}
12423impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
12424 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12425 fn from_node(
12426 node: ::treesitter_types::tree_sitter::Node<'tree>,
12427 src: &'tree [u8],
12428 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12429 debug_assert_eq!(node.kind(), "type_pattern");
12430 Ok(Self {
12431 span: ::treesitter_types::Span::from(node),
12432 r#type: {
12433 let child = node
12434 .child_by_field_name("type")
12435 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12436 ::treesitter_types::runtime::maybe_grow_stack(|| {
12437 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12438 })?
12439 },
12440 })
12441 }
12442}
12443impl ::treesitter_types::Spanned for TypePattern<'_> {
12444 fn span(&self) -> ::treesitter_types::Span {
12445 self.span
12446 }
12447}
12448#[derive(Debug, Clone, PartialEq, Eq)]
12449pub struct TypeofExpression<'tree> {
12450 pub span: ::treesitter_types::Span,
12451 pub r#type: Type<'tree>,
12452}
12453impl<'tree> ::treesitter_types::FromNode<'tree> for TypeofExpression<'tree> {
12454 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12455 fn from_node(
12456 node: ::treesitter_types::tree_sitter::Node<'tree>,
12457 src: &'tree [u8],
12458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12459 debug_assert_eq!(node.kind(), "typeof_expression");
12460 Ok(Self {
12461 span: ::treesitter_types::Span::from(node),
12462 r#type: {
12463 let child = node
12464 .child_by_field_name("type")
12465 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12466 ::treesitter_types::runtime::maybe_grow_stack(|| {
12467 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12468 })?
12469 },
12470 })
12471 }
12472}
12473impl ::treesitter_types::Spanned for TypeofExpression<'_> {
12474 fn span(&self) -> ::treesitter_types::Span {
12475 self.span
12476 }
12477}
12478#[derive(Debug, Clone, PartialEq, Eq)]
12479pub struct UnaryExpression<'tree> {
12480 pub span: ::treesitter_types::Span,
12481 pub argument: UnaryExpressionArgument<'tree>,
12482 pub operator: UnaryExpressionOperator,
12483}
12484impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
12485 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12486 fn from_node(
12487 node: ::treesitter_types::tree_sitter::Node<'tree>,
12488 src: &'tree [u8],
12489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12490 debug_assert_eq!(node.kind(), "unary_expression");
12491 Ok(Self {
12492 span: ::treesitter_types::Span::from(node),
12493 argument: {
12494 let child = node.child_by_field_name("argument").ok_or_else(|| {
12495 ::treesitter_types::ParseError::missing_field("argument", node)
12496 })?;
12497 ::treesitter_types::runtime::maybe_grow_stack(|| {
12498 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)
12499 })?
12500 },
12501 operator: {
12502 let child = node.child_by_field_name("operator").ok_or_else(|| {
12503 ::treesitter_types::ParseError::missing_field("operator", node)
12504 })?;
12505 ::treesitter_types::runtime::maybe_grow_stack(|| {
12506 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
12507 })?
12508 },
12509 })
12510 }
12511}
12512impl ::treesitter_types::Spanned for UnaryExpression<'_> {
12513 fn span(&self) -> ::treesitter_types::Span {
12514 self.span
12515 }
12516}
12517#[derive(Debug, Clone, PartialEq, Eq)]
12518pub struct UnsafeStatement<'tree> {
12519 pub span: ::treesitter_types::Span,
12520 pub children: Block<'tree>,
12521}
12522impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeStatement<'tree> {
12523 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12524 fn from_node(
12525 node: ::treesitter_types::tree_sitter::Node<'tree>,
12526 src: &'tree [u8],
12527 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12528 debug_assert_eq!(node.kind(), "unsafe_statement");
12529 Ok(Self {
12530 span: ::treesitter_types::Span::from(node),
12531 children: {
12532 #[allow(clippy::suspicious_else_formatting)]
12533 let non_field_children = {
12534 let mut cursor = node.walk();
12535 let mut result = ::std::vec::Vec::new();
12536 if cursor.goto_first_child() {
12537 loop {
12538 if cursor.field_name().is_none()
12539 && cursor.node().is_named()
12540 && !cursor.node().is_extra()
12541 {
12542 result.push(cursor.node());
12543 }
12544 if !cursor.goto_next_sibling() {
12545 break;
12546 }
12547 }
12548 }
12549 result
12550 };
12551 let child = if let Some(&c) = non_field_children.first() {
12552 c
12553 } else {
12554 let mut fallback_cursor = node.walk();
12555 let mut fallback_child = None;
12556 if fallback_cursor.goto_first_child() {
12557 loop {
12558 if fallback_cursor.field_name().is_none()
12559 && !fallback_cursor.node().is_extra()
12560 {
12561 let candidate = fallback_cursor.node();
12562 #[allow(clippy::needless_question_mark)]
12563 if (|| -> ::core::result::Result<
12564 _,
12565 ::treesitter_types::ParseError,
12566 > {
12567 let child = candidate;
12568 Ok(
12569 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
12570 child,
12571 src,
12572 ))?,
12573 )
12574 })()
12575 .is_ok()
12576 {
12577 fallback_child = Some(candidate);
12578 break;
12579 }
12580 }
12581 if !fallback_cursor.goto_next_sibling() {
12582 break;
12583 }
12584 }
12585 }
12586 if fallback_child.is_none() {
12587 let mut cursor2 = node.walk();
12588 if cursor2.goto_first_child() {
12589 loop {
12590 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12591 let candidate = cursor2.node();
12592 #[allow(clippy::needless_question_mark)]
12593 if (|| -> ::core::result::Result<
12594 _,
12595 ::treesitter_types::ParseError,
12596 > {
12597 let child = candidate;
12598 Ok(
12599 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
12600 child,
12601 src,
12602 ))?,
12603 )
12604 })()
12605 .is_ok()
12606 {
12607 fallback_child = Some(candidate);
12608 break;
12609 }
12610 }
12611 if !cursor2.goto_next_sibling() {
12612 break;
12613 }
12614 }
12615 }
12616 }
12617 fallback_child.ok_or_else(|| {
12618 ::treesitter_types::ParseError::missing_field("children", node)
12619 })?
12620 };
12621 ::treesitter_types::runtime::maybe_grow_stack(|| {
12622 <Block as ::treesitter_types::FromNode>::from_node(child, src)
12623 })?
12624 },
12625 })
12626 }
12627}
12628impl ::treesitter_types::Spanned for UnsafeStatement<'_> {
12629 fn span(&self) -> ::treesitter_types::Span {
12630 self.span
12631 }
12632}
12633#[derive(Debug, Clone, PartialEq, Eq)]
12634pub struct UsingDirective<'tree> {
12635 pub span: ::treesitter_types::Span,
12636 pub name: ::core::option::Option<Identifier<'tree>>,
12637 pub children: Type<'tree>,
12638}
12639impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDirective<'tree> {
12640 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12641 fn from_node(
12642 node: ::treesitter_types::tree_sitter::Node<'tree>,
12643 src: &'tree [u8],
12644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12645 debug_assert_eq!(node.kind(), "using_directive");
12646 Ok(Self {
12647 span: ::treesitter_types::Span::from(node),
12648 name: match node.child_by_field_name("name") {
12649 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12650 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12651 })?),
12652 None => None,
12653 },
12654 children: {
12655 #[allow(clippy::suspicious_else_formatting)]
12656 let non_field_children = {
12657 let mut cursor = node.walk();
12658 let mut result = ::std::vec::Vec::new();
12659 if cursor.goto_first_child() {
12660 loop {
12661 if cursor.field_name().is_none()
12662 && cursor.node().is_named()
12663 && !cursor.node().is_extra()
12664 {
12665 result.push(cursor.node());
12666 }
12667 if !cursor.goto_next_sibling() {
12668 break;
12669 }
12670 }
12671 }
12672 result
12673 };
12674 let child = if let Some(&c) = non_field_children.first() {
12675 c
12676 } else {
12677 let mut fallback_cursor = node.walk();
12678 let mut fallback_child = None;
12679 if fallback_cursor.goto_first_child() {
12680 loop {
12681 if fallback_cursor.field_name().is_none()
12682 && !fallback_cursor.node().is_extra()
12683 {
12684 let candidate = fallback_cursor.node();
12685 #[allow(clippy::needless_question_mark)]
12686 if (|| -> ::core::result::Result<
12687 _,
12688 ::treesitter_types::ParseError,
12689 > {
12690 let child = candidate;
12691 Ok(
12692 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
12693 child,
12694 src,
12695 ))?,
12696 )
12697 })()
12698 .is_ok()
12699 {
12700 fallback_child = Some(candidate);
12701 break;
12702 }
12703 }
12704 if !fallback_cursor.goto_next_sibling() {
12705 break;
12706 }
12707 }
12708 }
12709 if fallback_child.is_none() {
12710 let mut cursor2 = node.walk();
12711 if cursor2.goto_first_child() {
12712 loop {
12713 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12714 let candidate = cursor2.node();
12715 #[allow(clippy::needless_question_mark)]
12716 if (|| -> ::core::result::Result<
12717 _,
12718 ::treesitter_types::ParseError,
12719 > {
12720 let child = candidate;
12721 Ok(
12722 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
12723 child,
12724 src,
12725 ))?,
12726 )
12727 })()
12728 .is_ok()
12729 {
12730 fallback_child = Some(candidate);
12731 break;
12732 }
12733 }
12734 if !cursor2.goto_next_sibling() {
12735 break;
12736 }
12737 }
12738 }
12739 }
12740 fallback_child.ok_or_else(|| {
12741 ::treesitter_types::ParseError::missing_field("children", node)
12742 })?
12743 };
12744 ::treesitter_types::runtime::maybe_grow_stack(|| {
12745 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12746 })?
12747 },
12748 })
12749 }
12750}
12751impl ::treesitter_types::Spanned for UsingDirective<'_> {
12752 fn span(&self) -> ::treesitter_types::Span {
12753 self.span
12754 }
12755}
12756#[derive(Debug, Clone, PartialEq, Eq)]
12757pub struct UsingStatement<'tree> {
12758 pub span: ::treesitter_types::Span,
12759 pub body: Statement<'tree>,
12760 pub children: UsingStatementChildren<'tree>,
12761}
12762impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatement<'tree> {
12763 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12764 fn from_node(
12765 node: ::treesitter_types::tree_sitter::Node<'tree>,
12766 src: &'tree [u8],
12767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12768 debug_assert_eq!(node.kind(), "using_statement");
12769 Ok(Self {
12770 span: ::treesitter_types::Span::from(node),
12771 body: {
12772 let child = node
12773 .child_by_field_name("body")
12774 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
12775 ::treesitter_types::runtime::maybe_grow_stack(|| {
12776 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
12777 })?
12778 },
12779 children: {
12780 #[allow(clippy::suspicious_else_formatting)]
12781 let non_field_children = {
12782 let mut cursor = node.walk();
12783 let mut result = ::std::vec::Vec::new();
12784 if cursor.goto_first_child() {
12785 loop {
12786 if cursor.field_name().is_none()
12787 && cursor.node().is_named()
12788 && !cursor.node().is_extra()
12789 {
12790 result.push(cursor.node());
12791 }
12792 if !cursor.goto_next_sibling() {
12793 break;
12794 }
12795 }
12796 }
12797 result
12798 };
12799 let child = if let Some(&c) = non_field_children.first() {
12800 c
12801 } else {
12802 let mut fallback_cursor = node.walk();
12803 let mut fallback_child = None;
12804 if fallback_cursor.goto_first_child() {
12805 loop {
12806 if fallback_cursor.field_name().is_none()
12807 && !fallback_cursor.node().is_extra()
12808 {
12809 let candidate = fallback_cursor.node();
12810 #[allow(clippy::needless_question_mark)]
12811 if (|| -> ::core::result::Result<
12812 _,
12813 ::treesitter_types::ParseError,
12814 > {
12815 let child = candidate;
12816 Ok(
12817 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
12818 child,
12819 src,
12820 ))?,
12821 )
12822 })()
12823 .is_ok()
12824 {
12825 fallback_child = Some(candidate);
12826 break;
12827 }
12828 }
12829 if !fallback_cursor.goto_next_sibling() {
12830 break;
12831 }
12832 }
12833 }
12834 if fallback_child.is_none() {
12835 let mut cursor2 = node.walk();
12836 if cursor2.goto_first_child() {
12837 loop {
12838 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12839 let candidate = cursor2.node();
12840 #[allow(clippy::needless_question_mark)]
12841 if (|| -> ::core::result::Result<
12842 _,
12843 ::treesitter_types::ParseError,
12844 > {
12845 let child = candidate;
12846 Ok(
12847 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
12848 child,
12849 src,
12850 ))?,
12851 )
12852 })()
12853 .is_ok()
12854 {
12855 fallback_child = Some(candidate);
12856 break;
12857 }
12858 }
12859 if !cursor2.goto_next_sibling() {
12860 break;
12861 }
12862 }
12863 }
12864 }
12865 fallback_child.ok_or_else(|| {
12866 ::treesitter_types::ParseError::missing_field("children", node)
12867 })?
12868 };
12869 ::treesitter_types::runtime::maybe_grow_stack(|| {
12870 <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
12871 })?
12872 },
12873 })
12874 }
12875}
12876impl ::treesitter_types::Spanned for UsingStatement<'_> {
12877 fn span(&self) -> ::treesitter_types::Span {
12878 self.span
12879 }
12880}
12881#[derive(Debug, Clone, PartialEq, Eq)]
12882pub struct VarPattern<'tree> {
12883 pub span: ::treesitter_types::Span,
12884 pub name: ::core::option::Option<Identifier<'tree>>,
12885 pub children: ::core::option::Option<VarPatternChildren<'tree>>,
12886}
12887impl<'tree> ::treesitter_types::FromNode<'tree> for VarPattern<'tree> {
12888 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12889 fn from_node(
12890 node: ::treesitter_types::tree_sitter::Node<'tree>,
12891 src: &'tree [u8],
12892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12893 debug_assert_eq!(node.kind(), "var_pattern");
12894 Ok(Self {
12895 span: ::treesitter_types::Span::from(node),
12896 name: match node.child_by_field_name("name") {
12897 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12898 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12899 })?),
12900 None => None,
12901 },
12902 children: {
12903 #[allow(clippy::suspicious_else_formatting)]
12904 let non_field_children = {
12905 let mut cursor = node.walk();
12906 let mut result = ::std::vec::Vec::new();
12907 if cursor.goto_first_child() {
12908 loop {
12909 if cursor.field_name().is_none()
12910 && cursor.node().is_named()
12911 && !cursor.node().is_extra()
12912 {
12913 result.push(cursor.node());
12914 }
12915 if !cursor.goto_next_sibling() {
12916 break;
12917 }
12918 }
12919 }
12920 result
12921 };
12922 match non_field_children.first() {
12923 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12924 <VarPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
12925 })?),
12926 None => None,
12927 }
12928 },
12929 })
12930 }
12931}
12932impl ::treesitter_types::Spanned for VarPattern<'_> {
12933 fn span(&self) -> ::treesitter_types::Span {
12934 self.span
12935 }
12936}
12937#[derive(Debug, Clone, PartialEq, Eq)]
12938pub struct VariableDeclaration<'tree> {
12939 pub span: ::treesitter_types::Span,
12940 pub r#type: Type<'tree>,
12941 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
12942}
12943impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
12944 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12945 fn from_node(
12946 node: ::treesitter_types::tree_sitter::Node<'tree>,
12947 src: &'tree [u8],
12948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12949 debug_assert_eq!(node.kind(), "variable_declaration");
12950 Ok(Self {
12951 span: ::treesitter_types::Span::from(node),
12952 r#type: {
12953 let child = node
12954 .child_by_field_name("type")
12955 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12956 ::treesitter_types::runtime::maybe_grow_stack(|| {
12957 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12958 })?
12959 },
12960 children: {
12961 #[allow(clippy::suspicious_else_formatting)]
12962 let non_field_children = {
12963 let mut cursor = node.walk();
12964 let mut result = ::std::vec::Vec::new();
12965 if cursor.goto_first_child() {
12966 loop {
12967 if cursor.field_name().is_none()
12968 && cursor.node().is_named()
12969 && !cursor.node().is_extra()
12970 {
12971 result.push(cursor.node());
12972 }
12973 if !cursor.goto_next_sibling() {
12974 break;
12975 }
12976 }
12977 }
12978 result
12979 };
12980 let mut items = ::std::vec::Vec::new();
12981 for child in non_field_children {
12982 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12983 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
12984 })?);
12985 }
12986 items
12987 },
12988 })
12989 }
12990}
12991impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
12992 fn span(&self) -> ::treesitter_types::Span {
12993 self.span
12994 }
12995}
12996#[derive(Debug, Clone, PartialEq, Eq)]
12997pub struct VariableDeclarator<'tree> {
12998 pub span: ::treesitter_types::Span,
12999 pub name: ::core::option::Option<Identifier<'tree>>,
13000 pub children: ::std::vec::Vec<VariableDeclaratorChildren<'tree>>,
13001}
13002impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
13003 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13004 fn from_node(
13005 node: ::treesitter_types::tree_sitter::Node<'tree>,
13006 src: &'tree [u8],
13007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13008 debug_assert_eq!(node.kind(), "variable_declarator");
13009 Ok(Self {
13010 span: ::treesitter_types::Span::from(node),
13011 name: match node.child_by_field_name("name") {
13012 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13013 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
13014 })?),
13015 None => None,
13016 },
13017 children: {
13018 #[allow(clippy::suspicious_else_formatting)]
13019 let non_field_children = {
13020 let mut cursor = node.walk();
13021 let mut result = ::std::vec::Vec::new();
13022 if cursor.goto_first_child() {
13023 loop {
13024 if cursor.field_name().is_none()
13025 && cursor.node().is_named()
13026 && !cursor.node().is_extra()
13027 {
13028 result.push(cursor.node());
13029 }
13030 if !cursor.goto_next_sibling() {
13031 break;
13032 }
13033 }
13034 }
13035 result
13036 };
13037 let mut items = ::std::vec::Vec::new();
13038 for child in non_field_children {
13039 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13040 <VariableDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
13041 child, src,
13042 )
13043 })?);
13044 }
13045 items
13046 },
13047 })
13048 }
13049}
13050impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
13051 fn span(&self) -> ::treesitter_types::Span {
13052 self.span
13053 }
13054}
13055#[derive(Debug, Clone, PartialEq, Eq)]
13056pub struct WhenClause<'tree> {
13057 pub span: ::treesitter_types::Span,
13058 pub children: Expression<'tree>,
13059}
13060impl<'tree> ::treesitter_types::FromNode<'tree> for WhenClause<'tree> {
13061 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13062 fn from_node(
13063 node: ::treesitter_types::tree_sitter::Node<'tree>,
13064 src: &'tree [u8],
13065 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13066 debug_assert_eq!(node.kind(), "when_clause");
13067 Ok(Self {
13068 span: ::treesitter_types::Span::from(node),
13069 children: {
13070 #[allow(clippy::suspicious_else_formatting)]
13071 let non_field_children = {
13072 let mut cursor = node.walk();
13073 let mut result = ::std::vec::Vec::new();
13074 if cursor.goto_first_child() {
13075 loop {
13076 if cursor.field_name().is_none()
13077 && cursor.node().is_named()
13078 && !cursor.node().is_extra()
13079 {
13080 result.push(cursor.node());
13081 }
13082 if !cursor.goto_next_sibling() {
13083 break;
13084 }
13085 }
13086 }
13087 result
13088 };
13089 let child = if let Some(&c) = non_field_children.first() {
13090 c
13091 } else {
13092 let mut fallback_cursor = node.walk();
13093 let mut fallback_child = None;
13094 if fallback_cursor.goto_first_child() {
13095 loop {
13096 if fallback_cursor.field_name().is_none()
13097 && !fallback_cursor.node().is_extra()
13098 {
13099 let candidate = fallback_cursor.node();
13100 #[allow(clippy::needless_question_mark)]
13101 if (|| -> ::core::result::Result<
13102 _,
13103 ::treesitter_types::ParseError,
13104 > {
13105 let child = candidate;
13106 Ok(
13107 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13108 child,
13109 src,
13110 ))?,
13111 )
13112 })()
13113 .is_ok()
13114 {
13115 fallback_child = Some(candidate);
13116 break;
13117 }
13118 }
13119 if !fallback_cursor.goto_next_sibling() {
13120 break;
13121 }
13122 }
13123 }
13124 if fallback_child.is_none() {
13125 let mut cursor2 = node.walk();
13126 if cursor2.goto_first_child() {
13127 loop {
13128 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13129 let candidate = cursor2.node();
13130 #[allow(clippy::needless_question_mark)]
13131 if (|| -> ::core::result::Result<
13132 _,
13133 ::treesitter_types::ParseError,
13134 > {
13135 let child = candidate;
13136 Ok(
13137 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13138 child,
13139 src,
13140 ))?,
13141 )
13142 })()
13143 .is_ok()
13144 {
13145 fallback_child = Some(candidate);
13146 break;
13147 }
13148 }
13149 if !cursor2.goto_next_sibling() {
13150 break;
13151 }
13152 }
13153 }
13154 }
13155 fallback_child.ok_or_else(|| {
13156 ::treesitter_types::ParseError::missing_field("children", node)
13157 })?
13158 };
13159 ::treesitter_types::runtime::maybe_grow_stack(|| {
13160 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13161 })?
13162 },
13163 })
13164 }
13165}
13166impl ::treesitter_types::Spanned for WhenClause<'_> {
13167 fn span(&self) -> ::treesitter_types::Span {
13168 self.span
13169 }
13170}
13171#[derive(Debug, Clone, PartialEq, Eq)]
13172pub struct WhereClause<'tree> {
13173 pub span: ::treesitter_types::Span,
13174 pub children: Expression<'tree>,
13175}
13176impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
13177 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13178 fn from_node(
13179 node: ::treesitter_types::tree_sitter::Node<'tree>,
13180 src: &'tree [u8],
13181 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13182 debug_assert_eq!(node.kind(), "where_clause");
13183 Ok(Self {
13184 span: ::treesitter_types::Span::from(node),
13185 children: {
13186 #[allow(clippy::suspicious_else_formatting)]
13187 let non_field_children = {
13188 let mut cursor = node.walk();
13189 let mut result = ::std::vec::Vec::new();
13190 if cursor.goto_first_child() {
13191 loop {
13192 if cursor.field_name().is_none()
13193 && cursor.node().is_named()
13194 && !cursor.node().is_extra()
13195 {
13196 result.push(cursor.node());
13197 }
13198 if !cursor.goto_next_sibling() {
13199 break;
13200 }
13201 }
13202 }
13203 result
13204 };
13205 let child = if let Some(&c) = non_field_children.first() {
13206 c
13207 } else {
13208 let mut fallback_cursor = node.walk();
13209 let mut fallback_child = None;
13210 if fallback_cursor.goto_first_child() {
13211 loop {
13212 if fallback_cursor.field_name().is_none()
13213 && !fallback_cursor.node().is_extra()
13214 {
13215 let candidate = fallback_cursor.node();
13216 #[allow(clippy::needless_question_mark)]
13217 if (|| -> ::core::result::Result<
13218 _,
13219 ::treesitter_types::ParseError,
13220 > {
13221 let child = candidate;
13222 Ok(
13223 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13224 child,
13225 src,
13226 ))?,
13227 )
13228 })()
13229 .is_ok()
13230 {
13231 fallback_child = Some(candidate);
13232 break;
13233 }
13234 }
13235 if !fallback_cursor.goto_next_sibling() {
13236 break;
13237 }
13238 }
13239 }
13240 if fallback_child.is_none() {
13241 let mut cursor2 = node.walk();
13242 if cursor2.goto_first_child() {
13243 loop {
13244 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13245 let candidate = cursor2.node();
13246 #[allow(clippy::needless_question_mark)]
13247 if (|| -> ::core::result::Result<
13248 _,
13249 ::treesitter_types::ParseError,
13250 > {
13251 let child = candidate;
13252 Ok(
13253 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13254 child,
13255 src,
13256 ))?,
13257 )
13258 })()
13259 .is_ok()
13260 {
13261 fallback_child = Some(candidate);
13262 break;
13263 }
13264 }
13265 if !cursor2.goto_next_sibling() {
13266 break;
13267 }
13268 }
13269 }
13270 }
13271 fallback_child.ok_or_else(|| {
13272 ::treesitter_types::ParseError::missing_field("children", node)
13273 })?
13274 };
13275 ::treesitter_types::runtime::maybe_grow_stack(|| {
13276 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13277 })?
13278 },
13279 })
13280 }
13281}
13282impl ::treesitter_types::Spanned for WhereClause<'_> {
13283 fn span(&self) -> ::treesitter_types::Span {
13284 self.span
13285 }
13286}
13287#[derive(Debug, Clone, PartialEq, Eq)]
13288pub struct WhileStatement<'tree> {
13289 pub span: ::treesitter_types::Span,
13290 pub body: Statement<'tree>,
13291 pub condition: Expression<'tree>,
13292}
13293impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
13294 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13295 fn from_node(
13296 node: ::treesitter_types::tree_sitter::Node<'tree>,
13297 src: &'tree [u8],
13298 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13299 debug_assert_eq!(node.kind(), "while_statement");
13300 Ok(Self {
13301 span: ::treesitter_types::Span::from(node),
13302 body: {
13303 let child = node
13304 .child_by_field_name("body")
13305 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
13306 ::treesitter_types::runtime::maybe_grow_stack(|| {
13307 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
13308 })?
13309 },
13310 condition: {
13311 let child = node.child_by_field_name("condition").ok_or_else(|| {
13312 ::treesitter_types::ParseError::missing_field("condition", node)
13313 })?;
13314 ::treesitter_types::runtime::maybe_grow_stack(|| {
13315 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13316 })?
13317 },
13318 })
13319 }
13320}
13321impl ::treesitter_types::Spanned for WhileStatement<'_> {
13322 fn span(&self) -> ::treesitter_types::Span {
13323 self.span
13324 }
13325}
13326#[derive(Debug, Clone, PartialEq, Eq)]
13327pub struct WithExpression<'tree> {
13328 pub span: ::treesitter_types::Span,
13329 pub children: ::std::vec::Vec<WithExpressionChildren<'tree>>,
13330}
13331impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpression<'tree> {
13332 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13333 fn from_node(
13334 node: ::treesitter_types::tree_sitter::Node<'tree>,
13335 src: &'tree [u8],
13336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13337 debug_assert_eq!(node.kind(), "with_expression");
13338 Ok(Self {
13339 span: ::treesitter_types::Span::from(node),
13340 children: {
13341 #[allow(clippy::suspicious_else_formatting)]
13342 let non_field_children = {
13343 let mut cursor = node.walk();
13344 let mut result = ::std::vec::Vec::new();
13345 if cursor.goto_first_child() {
13346 loop {
13347 if cursor.field_name().is_none()
13348 && cursor.node().is_named()
13349 && !cursor.node().is_extra()
13350 {
13351 result.push(cursor.node());
13352 }
13353 if !cursor.goto_next_sibling() {
13354 break;
13355 }
13356 }
13357 }
13358 result
13359 };
13360 let mut items = ::std::vec::Vec::new();
13361 for child in non_field_children {
13362 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13363 <WithExpressionChildren as ::treesitter_types::FromNode>::from_node(
13364 child, src,
13365 )
13366 })?);
13367 }
13368 items
13369 },
13370 })
13371 }
13372}
13373impl ::treesitter_types::Spanned for WithExpression<'_> {
13374 fn span(&self) -> ::treesitter_types::Span {
13375 self.span
13376 }
13377}
13378#[derive(Debug, Clone, PartialEq, Eq)]
13379pub struct WithInitializer<'tree> {
13380 pub span: ::treesitter_types::Span,
13381 pub children: ::std::vec::Vec<WithInitializerChildren<'tree>>,
13382}
13383impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializer<'tree> {
13384 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13385 fn from_node(
13386 node: ::treesitter_types::tree_sitter::Node<'tree>,
13387 src: &'tree [u8],
13388 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13389 debug_assert_eq!(node.kind(), "with_initializer");
13390 Ok(Self {
13391 span: ::treesitter_types::Span::from(node),
13392 children: {
13393 #[allow(clippy::suspicious_else_formatting)]
13394 let non_field_children = {
13395 let mut cursor = node.walk();
13396 let mut result = ::std::vec::Vec::new();
13397 if cursor.goto_first_child() {
13398 loop {
13399 if cursor.field_name().is_none()
13400 && cursor.node().is_named()
13401 && !cursor.node().is_extra()
13402 {
13403 result.push(cursor.node());
13404 }
13405 if !cursor.goto_next_sibling() {
13406 break;
13407 }
13408 }
13409 }
13410 result
13411 };
13412 let mut items = ::std::vec::Vec::new();
13413 for child in non_field_children {
13414 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13415 <WithInitializerChildren as ::treesitter_types::FromNode>::from_node(
13416 child, src,
13417 )
13418 })?);
13419 }
13420 items
13421 },
13422 })
13423 }
13424}
13425impl ::treesitter_types::Spanned for WithInitializer<'_> {
13426 fn span(&self) -> ::treesitter_types::Span {
13427 self.span
13428 }
13429}
13430#[derive(Debug, Clone, PartialEq, Eq)]
13431pub struct YieldStatement<'tree> {
13432 pub span: ::treesitter_types::Span,
13433 pub children: ::core::option::Option<Expression<'tree>>,
13434}
13435impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
13436 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13437 fn from_node(
13438 node: ::treesitter_types::tree_sitter::Node<'tree>,
13439 src: &'tree [u8],
13440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13441 debug_assert_eq!(node.kind(), "yield_statement");
13442 Ok(Self {
13443 span: ::treesitter_types::Span::from(node),
13444 children: {
13445 #[allow(clippy::suspicious_else_formatting)]
13446 let non_field_children = {
13447 let mut cursor = node.walk();
13448 let mut result = ::std::vec::Vec::new();
13449 if cursor.goto_first_child() {
13450 loop {
13451 if cursor.field_name().is_none()
13452 && cursor.node().is_named()
13453 && !cursor.node().is_extra()
13454 {
13455 result.push(cursor.node());
13456 }
13457 if !cursor.goto_next_sibling() {
13458 break;
13459 }
13460 }
13461 }
13462 result
13463 };
13464 match non_field_children.first() {
13465 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13466 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13467 })?),
13468 None => None,
13469 }
13470 },
13471 })
13472 }
13473}
13474impl ::treesitter_types::Spanned for YieldStatement<'_> {
13475 fn span(&self) -> ::treesitter_types::Span {
13476 self.span
13477 }
13478}
13479#[derive(Debug, Clone, PartialEq, Eq)]
13480pub struct CharacterLiteralContent<'tree> {
13481 pub span: ::treesitter_types::Span,
13482 text: &'tree str,
13483}
13484impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralContent<'tree> {
13485 fn from_node(
13486 node: ::treesitter_types::tree_sitter::Node<'tree>,
13487 src: &'tree [u8],
13488 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13489 debug_assert_eq!(node.kind(), "character_literal_content");
13490 Ok(Self {
13491 span: ::treesitter_types::Span::from(node),
13492 text: node.utf8_text(src)?,
13493 })
13494 }
13495}
13496impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteralContent<'tree> {
13497 fn text(&self) -> &'tree str {
13498 self.text
13499 }
13500}
13501impl ::treesitter_types::Spanned for CharacterLiteralContent<'_> {
13502 fn span(&self) -> ::treesitter_types::Span {
13503 self.span
13504 }
13505}
13506#[derive(Debug, Clone, PartialEq, Eq)]
13507pub struct Comment<'tree> {
13508 pub span: ::treesitter_types::Span,
13509 text: &'tree str,
13510}
13511impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
13512 fn from_node(
13513 node: ::treesitter_types::tree_sitter::Node<'tree>,
13514 src: &'tree [u8],
13515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13516 debug_assert_eq!(node.kind(), "comment");
13517 Ok(Self {
13518 span: ::treesitter_types::Span::from(node),
13519 text: node.utf8_text(src)?,
13520 })
13521 }
13522}
13523impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
13524 fn text(&self) -> &'tree str {
13525 self.text
13526 }
13527}
13528impl ::treesitter_types::Spanned for Comment<'_> {
13529 fn span(&self) -> ::treesitter_types::Span {
13530 self.span
13531 }
13532}
13533#[derive(Debug, Clone, PartialEq, Eq)]
13534pub struct Discard<'tree> {
13535 pub span: ::treesitter_types::Span,
13536 text: &'tree str,
13537}
13538impl<'tree> ::treesitter_types::FromNode<'tree> for Discard<'tree> {
13539 fn from_node(
13540 node: ::treesitter_types::tree_sitter::Node<'tree>,
13541 src: &'tree [u8],
13542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13543 debug_assert_eq!(node.kind(), "discard");
13544 Ok(Self {
13545 span: ::treesitter_types::Span::from(node),
13546 text: node.utf8_text(src)?,
13547 })
13548 }
13549}
13550impl<'tree> ::treesitter_types::LeafNode<'tree> for Discard<'tree> {
13551 fn text(&self) -> &'tree str {
13552 self.text
13553 }
13554}
13555impl ::treesitter_types::Spanned for Discard<'_> {
13556 fn span(&self) -> ::treesitter_types::Span {
13557 self.span
13558 }
13559}
13560#[derive(Debug, Clone, PartialEq, Eq)]
13561pub struct EscapeSequence<'tree> {
13562 pub span: ::treesitter_types::Span,
13563 text: &'tree str,
13564}
13565impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
13566 fn from_node(
13567 node: ::treesitter_types::tree_sitter::Node<'tree>,
13568 src: &'tree [u8],
13569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13570 debug_assert_eq!(node.kind(), "escape_sequence");
13571 Ok(Self {
13572 span: ::treesitter_types::Span::from(node),
13573 text: node.utf8_text(src)?,
13574 })
13575 }
13576}
13577impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
13578 fn text(&self) -> &'tree str {
13579 self.text
13580 }
13581}
13582impl ::treesitter_types::Spanned for EscapeSequence<'_> {
13583 fn span(&self) -> ::treesitter_types::Span {
13584 self.span
13585 }
13586}
13587#[derive(Debug, Clone, PartialEq, Eq)]
13588pub struct IntegerLiteral<'tree> {
13589 pub span: ::treesitter_types::Span,
13590 text: &'tree str,
13591}
13592impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
13593 fn from_node(
13594 node: ::treesitter_types::tree_sitter::Node<'tree>,
13595 src: &'tree [u8],
13596 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13597 debug_assert_eq!(node.kind(), "integer_literal");
13598 Ok(Self {
13599 span: ::treesitter_types::Span::from(node),
13600 text: node.utf8_text(src)?,
13601 })
13602 }
13603}
13604impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
13605 fn text(&self) -> &'tree str {
13606 self.text
13607 }
13608}
13609impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
13610 fn span(&self) -> ::treesitter_types::Span {
13611 self.span
13612 }
13613}
13614#[derive(Debug, Clone, PartialEq, Eq)]
13615pub struct InterpolationBrace<'tree> {
13616 pub span: ::treesitter_types::Span,
13617 text: &'tree str,
13618}
13619impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationBrace<'tree> {
13620 fn from_node(
13621 node: ::treesitter_types::tree_sitter::Node<'tree>,
13622 src: &'tree [u8],
13623 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13624 debug_assert_eq!(node.kind(), "interpolation_brace");
13625 Ok(Self {
13626 span: ::treesitter_types::Span::from(node),
13627 text: node.utf8_text(src)?,
13628 })
13629 }
13630}
13631impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationBrace<'tree> {
13632 fn text(&self) -> &'tree str {
13633 self.text
13634 }
13635}
13636impl ::treesitter_types::Spanned for InterpolationBrace<'_> {
13637 fn span(&self) -> ::treesitter_types::Span {
13638 self.span
13639 }
13640}
13641#[derive(Debug, Clone, PartialEq, Eq)]
13642pub struct InterpolationQuote<'tree> {
13643 pub span: ::treesitter_types::Span,
13644 text: &'tree str,
13645}
13646impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationQuote<'tree> {
13647 fn from_node(
13648 node: ::treesitter_types::tree_sitter::Node<'tree>,
13649 src: &'tree [u8],
13650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13651 debug_assert_eq!(node.kind(), "interpolation_quote");
13652 Ok(Self {
13653 span: ::treesitter_types::Span::from(node),
13654 text: node.utf8_text(src)?,
13655 })
13656 }
13657}
13658impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationQuote<'tree> {
13659 fn text(&self) -> &'tree str {
13660 self.text
13661 }
13662}
13663impl ::treesitter_types::Spanned for InterpolationQuote<'_> {
13664 fn span(&self) -> ::treesitter_types::Span {
13665 self.span
13666 }
13667}
13668#[derive(Debug, Clone, PartialEq, Eq)]
13669pub struct InterpolationStart<'tree> {
13670 pub span: ::treesitter_types::Span,
13671 text: &'tree str,
13672}
13673impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationStart<'tree> {
13674 fn from_node(
13675 node: ::treesitter_types::tree_sitter::Node<'tree>,
13676 src: &'tree [u8],
13677 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13678 debug_assert_eq!(node.kind(), "interpolation_start");
13679 Ok(Self {
13680 span: ::treesitter_types::Span::from(node),
13681 text: node.utf8_text(src)?,
13682 })
13683 }
13684}
13685impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationStart<'tree> {
13686 fn text(&self) -> &'tree str {
13687 self.text
13688 }
13689}
13690impl ::treesitter_types::Spanned for InterpolationStart<'_> {
13691 fn span(&self) -> ::treesitter_types::Span {
13692 self.span
13693 }
13694}
13695#[derive(Debug, Clone, PartialEq, Eq)]
13696pub struct NullLiteral<'tree> {
13697 pub span: ::treesitter_types::Span,
13698 text: &'tree str,
13699}
13700impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
13701 fn from_node(
13702 node: ::treesitter_types::tree_sitter::Node<'tree>,
13703 src: &'tree [u8],
13704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13705 debug_assert_eq!(node.kind(), "null_literal");
13706 Ok(Self {
13707 span: ::treesitter_types::Span::from(node),
13708 text: node.utf8_text(src)?,
13709 })
13710 }
13711}
13712impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
13713 fn text(&self) -> &'tree str {
13714 self.text
13715 }
13716}
13717impl ::treesitter_types::Spanned for NullLiteral<'_> {
13718 fn span(&self) -> ::treesitter_types::Span {
13719 self.span
13720 }
13721}
13722#[derive(Debug, Clone, PartialEq, Eq)]
13723pub struct PredefinedType<'tree> {
13724 pub span: ::treesitter_types::Span,
13725 text: &'tree str,
13726}
13727impl<'tree> ::treesitter_types::FromNode<'tree> for PredefinedType<'tree> {
13728 fn from_node(
13729 node: ::treesitter_types::tree_sitter::Node<'tree>,
13730 src: &'tree [u8],
13731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13732 debug_assert_eq!(node.kind(), "predefined_type");
13733 Ok(Self {
13734 span: ::treesitter_types::Span::from(node),
13735 text: node.utf8_text(src)?,
13736 })
13737 }
13738}
13739impl<'tree> ::treesitter_types::LeafNode<'tree> for PredefinedType<'tree> {
13740 fn text(&self) -> &'tree str {
13741 self.text
13742 }
13743}
13744impl ::treesitter_types::Spanned for PredefinedType<'_> {
13745 fn span(&self) -> ::treesitter_types::Span {
13746 self.span
13747 }
13748}
13749#[derive(Debug, Clone, PartialEq, Eq)]
13750pub struct PreprocArg<'tree> {
13751 pub span: ::treesitter_types::Span,
13752 text: &'tree str,
13753}
13754impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
13755 fn from_node(
13756 node: ::treesitter_types::tree_sitter::Node<'tree>,
13757 src: &'tree [u8],
13758 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13759 debug_assert_eq!(node.kind(), "preproc_arg");
13760 Ok(Self {
13761 span: ::treesitter_types::Span::from(node),
13762 text: node.utf8_text(src)?,
13763 })
13764 }
13765}
13766impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
13767 fn text(&self) -> &'tree str {
13768 self.text
13769 }
13770}
13771impl ::treesitter_types::Spanned for PreprocArg<'_> {
13772 fn span(&self) -> ::treesitter_types::Span {
13773 self.span
13774 }
13775}
13776#[derive(Debug, Clone, PartialEq, Eq)]
13777pub struct RawStringContent<'tree> {
13778 pub span: ::treesitter_types::Span,
13779 text: &'tree str,
13780}
13781impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringContent<'tree> {
13782 fn from_node(
13783 node: ::treesitter_types::tree_sitter::Node<'tree>,
13784 src: &'tree [u8],
13785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13786 debug_assert_eq!(node.kind(), "raw_string_content");
13787 Ok(Self {
13788 span: ::treesitter_types::Span::from(node),
13789 text: node.utf8_text(src)?,
13790 })
13791 }
13792}
13793impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringContent<'tree> {
13794 fn text(&self) -> &'tree str {
13795 self.text
13796 }
13797}
13798impl ::treesitter_types::Spanned for RawStringContent<'_> {
13799 fn span(&self) -> ::treesitter_types::Span {
13800 self.span
13801 }
13802}
13803#[derive(Debug, Clone, PartialEq, Eq)]
13804pub struct RawStringEnd<'tree> {
13805 pub span: ::treesitter_types::Span,
13806 text: &'tree str,
13807}
13808impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringEnd<'tree> {
13809 fn from_node(
13810 node: ::treesitter_types::tree_sitter::Node<'tree>,
13811 src: &'tree [u8],
13812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13813 debug_assert_eq!(node.kind(), "raw_string_end");
13814 Ok(Self {
13815 span: ::treesitter_types::Span::from(node),
13816 text: node.utf8_text(src)?,
13817 })
13818 }
13819}
13820impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringEnd<'tree> {
13821 fn text(&self) -> &'tree str {
13822 self.text
13823 }
13824}
13825impl ::treesitter_types::Spanned for RawStringEnd<'_> {
13826 fn span(&self) -> ::treesitter_types::Span {
13827 self.span
13828 }
13829}
13830#[derive(Debug, Clone, PartialEq, Eq)]
13831pub struct RawStringStart<'tree> {
13832 pub span: ::treesitter_types::Span,
13833 text: &'tree str,
13834}
13835impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringStart<'tree> {
13836 fn from_node(
13837 node: ::treesitter_types::tree_sitter::Node<'tree>,
13838 src: &'tree [u8],
13839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13840 debug_assert_eq!(node.kind(), "raw_string_start");
13841 Ok(Self {
13842 span: ::treesitter_types::Span::from(node),
13843 text: node.utf8_text(src)?,
13844 })
13845 }
13846}
13847impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringStart<'tree> {
13848 fn text(&self) -> &'tree str {
13849 self.text
13850 }
13851}
13852impl ::treesitter_types::Spanned for RawStringStart<'_> {
13853 fn span(&self) -> ::treesitter_types::Span {
13854 self.span
13855 }
13856}
13857#[derive(Debug, Clone, PartialEq, Eq)]
13858pub struct RealLiteral<'tree> {
13859 pub span: ::treesitter_types::Span,
13860 text: &'tree str,
13861}
13862impl<'tree> ::treesitter_types::FromNode<'tree> for RealLiteral<'tree> {
13863 fn from_node(
13864 node: ::treesitter_types::tree_sitter::Node<'tree>,
13865 src: &'tree [u8],
13866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13867 debug_assert_eq!(node.kind(), "real_literal");
13868 Ok(Self {
13869 span: ::treesitter_types::Span::from(node),
13870 text: node.utf8_text(src)?,
13871 })
13872 }
13873}
13874impl<'tree> ::treesitter_types::LeafNode<'tree> for RealLiteral<'tree> {
13875 fn text(&self) -> &'tree str {
13876 self.text
13877 }
13878}
13879impl ::treesitter_types::Spanned for RealLiteral<'_> {
13880 fn span(&self) -> ::treesitter_types::Span {
13881 self.span
13882 }
13883}
13884#[derive(Debug, Clone, PartialEq, Eq)]
13885pub struct ShebangDirective<'tree> {
13886 pub span: ::treesitter_types::Span,
13887 text: &'tree str,
13888}
13889impl<'tree> ::treesitter_types::FromNode<'tree> for ShebangDirective<'tree> {
13890 fn from_node(
13891 node: ::treesitter_types::tree_sitter::Node<'tree>,
13892 src: &'tree [u8],
13893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13894 debug_assert_eq!(node.kind(), "shebang_directive");
13895 Ok(Self {
13896 span: ::treesitter_types::Span::from(node),
13897 text: node.utf8_text(src)?,
13898 })
13899 }
13900}
13901impl<'tree> ::treesitter_types::LeafNode<'tree> for ShebangDirective<'tree> {
13902 fn text(&self) -> &'tree str {
13903 self.text
13904 }
13905}
13906impl ::treesitter_types::Spanned for ShebangDirective<'_> {
13907 fn span(&self) -> ::treesitter_types::Span {
13908 self.span
13909 }
13910}
13911#[derive(Debug, Clone, PartialEq, Eq)]
13912pub struct StringContent<'tree> {
13913 pub span: ::treesitter_types::Span,
13914 text: &'tree str,
13915}
13916impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
13917 fn from_node(
13918 node: ::treesitter_types::tree_sitter::Node<'tree>,
13919 src: &'tree [u8],
13920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13921 debug_assert_eq!(node.kind(), "string_content");
13922 Ok(Self {
13923 span: ::treesitter_types::Span::from(node),
13924 text: node.utf8_text(src)?,
13925 })
13926 }
13927}
13928impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
13929 fn text(&self) -> &'tree str {
13930 self.text
13931 }
13932}
13933impl ::treesitter_types::Spanned for StringContent<'_> {
13934 fn span(&self) -> ::treesitter_types::Span {
13935 self.span
13936 }
13937}
13938#[derive(Debug, Clone, PartialEq, Eq)]
13939pub struct StringLiteralEncoding<'tree> {
13940 pub span: ::treesitter_types::Span,
13941 text: &'tree str,
13942}
13943impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralEncoding<'tree> {
13944 fn from_node(
13945 node: ::treesitter_types::tree_sitter::Node<'tree>,
13946 src: &'tree [u8],
13947 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13948 debug_assert_eq!(node.kind(), "string_literal_encoding");
13949 Ok(Self {
13950 span: ::treesitter_types::Span::from(node),
13951 text: node.utf8_text(src)?,
13952 })
13953 }
13954}
13955impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralEncoding<'tree> {
13956 fn text(&self) -> &'tree str {
13957 self.text
13958 }
13959}
13960impl ::treesitter_types::Spanned for StringLiteralEncoding<'_> {
13961 fn span(&self) -> ::treesitter_types::Span {
13962 self.span
13963 }
13964}
13965#[derive(Debug, Clone, PartialEq, Eq)]
13966pub struct VerbatimStringLiteral<'tree> {
13967 pub span: ::treesitter_types::Span,
13968 text: &'tree str,
13969}
13970impl<'tree> ::treesitter_types::FromNode<'tree> for VerbatimStringLiteral<'tree> {
13971 fn from_node(
13972 node: ::treesitter_types::tree_sitter::Node<'tree>,
13973 src: &'tree [u8],
13974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13975 debug_assert_eq!(node.kind(), "verbatim_string_literal");
13976 Ok(Self {
13977 span: ::treesitter_types::Span::from(node),
13978 text: node.utf8_text(src)?,
13979 })
13980 }
13981}
13982impl<'tree> ::treesitter_types::LeafNode<'tree> for VerbatimStringLiteral<'tree> {
13983 fn text(&self) -> &'tree str {
13984 self.text
13985 }
13986}
13987impl ::treesitter_types::Spanned for VerbatimStringLiteral<'_> {
13988 fn span(&self) -> ::treesitter_types::Span {
13989 self.span
13990 }
13991}
13992#[derive(Debug, Clone, PartialEq, Eq)]
13993pub enum AccessorDeclarationBody<'tree> {
13994 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
13995 Block(::std::boxed::Box<Block<'tree>>),
13996}
13997impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationBody<'tree> {
13998 #[allow(clippy::collapsible_else_if)]
13999 fn from_node(
14000 node: ::treesitter_types::tree_sitter::Node<'tree>,
14001 src: &'tree [u8],
14002 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14003 match node.kind() {
14004 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
14005 ::treesitter_types::runtime::maybe_grow_stack(|| {
14006 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
14007 })?,
14008 ))),
14009 "block" => Ok(Self::Block(::std::boxed::Box::new(
14010 ::treesitter_types::runtime::maybe_grow_stack(|| {
14011 <Block as ::treesitter_types::FromNode>::from_node(node, src)
14012 })?,
14013 ))),
14014 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14015 }
14016 }
14017}
14018impl ::treesitter_types::Spanned for AccessorDeclarationBody<'_> {
14019 fn span(&self) -> ::treesitter_types::Span {
14020 match self {
14021 Self::ArrowExpressionClause(inner) => inner.span(),
14022 Self::Block(inner) => inner.span(),
14023 }
14024 }
14025}
14026#[derive(Debug, Clone, PartialEq, Eq)]
14027pub enum AccessorDeclarationName<'tree> {
14028 Add(::treesitter_types::Span),
14029 Get(::treesitter_types::Span),
14030 Identifier(::std::boxed::Box<Identifier<'tree>>),
14031 Init(::treesitter_types::Span),
14032 Remove(::treesitter_types::Span),
14033 Set(::treesitter_types::Span),
14034}
14035impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationName<'tree> {
14036 #[allow(clippy::collapsible_else_if)]
14037 fn from_node(
14038 node: ::treesitter_types::tree_sitter::Node<'tree>,
14039 src: &'tree [u8],
14040 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14041 match node.kind() {
14042 "add" => Ok(Self::Add(::treesitter_types::Span::from(node))),
14043 "get" => Ok(Self::Get(::treesitter_types::Span::from(node))),
14044 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14045 ::treesitter_types::runtime::maybe_grow_stack(|| {
14046 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14047 })?,
14048 ))),
14049 "init" => Ok(Self::Init(::treesitter_types::Span::from(node))),
14050 "remove" => Ok(Self::Remove(::treesitter_types::Span::from(node))),
14051 "set" => Ok(Self::Set(::treesitter_types::Span::from(node))),
14052 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14053 }
14054 }
14055}
14056impl ::treesitter_types::Spanned for AccessorDeclarationName<'_> {
14057 fn span(&self) -> ::treesitter_types::Span {
14058 match self {
14059 Self::Add(span) => *span,
14060 Self::Get(span) => *span,
14061 Self::Identifier(inner) => inner.span(),
14062 Self::Init(span) => *span,
14063 Self::Remove(span) => *span,
14064 Self::Set(span) => *span,
14065 }
14066 }
14067}
14068#[derive(Debug, Clone, PartialEq, Eq)]
14069pub enum AccessorDeclarationChildren<'tree> {
14070 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14071 Modifier(::std::boxed::Box<Modifier<'tree>>),
14072}
14073impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationChildren<'tree> {
14074 #[allow(clippy::collapsible_else_if)]
14075 fn from_node(
14076 node: ::treesitter_types::tree_sitter::Node<'tree>,
14077 src: &'tree [u8],
14078 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14079 match node.kind() {
14080 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14081 ::treesitter_types::runtime::maybe_grow_stack(|| {
14082 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
14083 })?,
14084 ))),
14085 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14086 ::treesitter_types::runtime::maybe_grow_stack(|| {
14087 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
14088 })?,
14089 ))),
14090 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14091 }
14092 }
14093}
14094impl ::treesitter_types::Spanned for AccessorDeclarationChildren<'_> {
14095 fn span(&self) -> ::treesitter_types::Span {
14096 match self {
14097 Self::AttributeList(inner) => inner.span(),
14098 Self::Modifier(inner) => inner.span(),
14099 }
14100 }
14101}
14102#[derive(Debug, Clone, PartialEq, Eq)]
14103pub enum AliasQualifiedNameName<'tree> {
14104 GenericName(::std::boxed::Box<GenericName<'tree>>),
14105 Identifier(::std::boxed::Box<Identifier<'tree>>),
14106}
14107impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedNameName<'tree> {
14108 #[allow(clippy::collapsible_else_if)]
14109 fn from_node(
14110 node: ::treesitter_types::tree_sitter::Node<'tree>,
14111 src: &'tree [u8],
14112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14113 match node.kind() {
14114 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14115 ::treesitter_types::runtime::maybe_grow_stack(|| {
14116 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
14117 })?,
14118 ))),
14119 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14120 ::treesitter_types::runtime::maybe_grow_stack(|| {
14121 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14122 })?,
14123 ))),
14124 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14125 }
14126 }
14127}
14128impl ::treesitter_types::Spanned for AliasQualifiedNameName<'_> {
14129 fn span(&self) -> ::treesitter_types::Span {
14130 match self {
14131 Self::GenericName(inner) => inner.span(),
14132 Self::Identifier(inner) => inner.span(),
14133 }
14134 }
14135}
14136#[derive(Debug, Clone, PartialEq, Eq)]
14137pub enum AndPatternOperator {
14138 And(::treesitter_types::Span),
14139}
14140impl<'tree> ::treesitter_types::FromNode<'tree> for AndPatternOperator {
14141 #[allow(clippy::collapsible_else_if)]
14142 fn from_node(
14143 node: ::treesitter_types::tree_sitter::Node<'tree>,
14144 _src: &'tree [u8],
14145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14146 match node.kind() {
14147 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
14148 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14149 }
14150 }
14151}
14152impl ::treesitter_types::Spanned for AndPatternOperator {
14153 fn span(&self) -> ::treesitter_types::Span {
14154 match self {
14155 Self::And(span) => *span,
14156 }
14157 }
14158}
14159#[derive(Debug, Clone, PartialEq, Eq)]
14160pub enum AnonymousMethodExpressionChildren<'tree> {
14161 Block(::std::boxed::Box<Block<'tree>>),
14162 Modifier(::std::boxed::Box<Modifier<'tree>>),
14163}
14164impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpressionChildren<'tree> {
14165 #[allow(clippy::collapsible_else_if)]
14166 fn from_node(
14167 node: ::treesitter_types::tree_sitter::Node<'tree>,
14168 src: &'tree [u8],
14169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14170 match node.kind() {
14171 "block" => Ok(Self::Block(::std::boxed::Box::new(
14172 ::treesitter_types::runtime::maybe_grow_stack(|| {
14173 <Block as ::treesitter_types::FromNode>::from_node(node, src)
14174 })?,
14175 ))),
14176 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14177 ::treesitter_types::runtime::maybe_grow_stack(|| {
14178 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
14179 })?,
14180 ))),
14181 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14182 }
14183 }
14184}
14185impl ::treesitter_types::Spanned for AnonymousMethodExpressionChildren<'_> {
14186 fn span(&self) -> ::treesitter_types::Span {
14187 match self {
14188 Self::Block(inner) => inner.span(),
14189 Self::Modifier(inner) => inner.span(),
14190 }
14191 }
14192}
14193#[derive(Debug, Clone, PartialEq, Eq)]
14194pub enum AnonymousObjectCreationExpressionChildren<'tree> {
14195 Expression(::std::boxed::Box<Expression<'tree>>),
14196 Identifier(::std::boxed::Box<Identifier<'tree>>),
14197}
14198impl<'tree> ::treesitter_types::FromNode<'tree>
14199 for AnonymousObjectCreationExpressionChildren<'tree>
14200{
14201 #[allow(clippy::collapsible_else_if)]
14202 fn from_node(
14203 node: ::treesitter_types::tree_sitter::Node<'tree>,
14204 src: &'tree [u8],
14205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14206 match node.kind() {
14207 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14208 ::treesitter_types::runtime::maybe_grow_stack(|| {
14209 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14210 })?,
14211 ))),
14212 _other => {
14213 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14214 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14215 }) {
14216 Ok(Self::Expression(::std::boxed::Box::new(v)))
14217 } else {
14218 Err(::treesitter_types::ParseError::unexpected_kind(
14219 _other, node,
14220 ))
14221 }
14222 }
14223 }
14224 }
14225}
14226impl ::treesitter_types::Spanned for AnonymousObjectCreationExpressionChildren<'_> {
14227 fn span(&self) -> ::treesitter_types::Span {
14228 match self {
14229 Self::Expression(inner) => inner.span(),
14230 Self::Identifier(inner) => inner.span(),
14231 }
14232 }
14233}
14234#[derive(Debug, Clone, PartialEq, Eq)]
14235pub enum ArgumentChildren<'tree> {
14236 DeclarationExpression(::std::boxed::Box<DeclarationExpression<'tree>>),
14237 Expression(::std::boxed::Box<Expression<'tree>>),
14238}
14239impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentChildren<'tree> {
14240 #[allow(clippy::collapsible_else_if)]
14241 fn from_node(
14242 node: ::treesitter_types::tree_sitter::Node<'tree>,
14243 src: &'tree [u8],
14244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14245 match node.kind() {
14246 "declaration_expression" => Ok(Self::DeclarationExpression(::std::boxed::Box::new(
14247 ::treesitter_types::runtime::maybe_grow_stack(|| {
14248 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14249 })?,
14250 ))),
14251 _other => {
14252 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14253 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14254 }) {
14255 Ok(Self::Expression(::std::boxed::Box::new(v)))
14256 } else {
14257 Err(::treesitter_types::ParseError::unexpected_kind(
14258 _other, node,
14259 ))
14260 }
14261 }
14262 }
14263 }
14264}
14265impl ::treesitter_types::Spanned for ArgumentChildren<'_> {
14266 fn span(&self) -> ::treesitter_types::Span {
14267 match self {
14268 Self::DeclarationExpression(inner) => inner.span(),
14269 Self::Expression(inner) => inner.span(),
14270 }
14271 }
14272}
14273#[derive(Debug, Clone, PartialEq, Eq)]
14274pub enum ArrayTypeType<'tree> {
14275 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
14276 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
14277 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
14278 GenericName(::std::boxed::Box<GenericName<'tree>>),
14279 Identifier(::std::boxed::Box<Identifier<'tree>>),
14280 NullableType(::std::boxed::Box<NullableType<'tree>>),
14281 PointerType(::std::boxed::Box<PointerType<'tree>>),
14282 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
14283 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14284 TupleType(::std::boxed::Box<TupleType<'tree>>),
14285}
14286impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayTypeType<'tree> {
14287 #[allow(clippy::collapsible_else_if)]
14288 fn from_node(
14289 node: ::treesitter_types::tree_sitter::Node<'tree>,
14290 src: &'tree [u8],
14291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14292 match node.kind() {
14293 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
14294 ::treesitter_types::runtime::maybe_grow_stack(|| {
14295 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14296 })?,
14297 ))),
14298 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
14299 ::treesitter_types::runtime::maybe_grow_stack(|| {
14300 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
14301 })?,
14302 ))),
14303 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
14304 ::treesitter_types::runtime::maybe_grow_stack(|| {
14305 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
14306 })?,
14307 ))),
14308 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14309 ::treesitter_types::runtime::maybe_grow_stack(|| {
14310 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
14311 })?,
14312 ))),
14313 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14314 ::treesitter_types::runtime::maybe_grow_stack(|| {
14315 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14316 })?,
14317 ))),
14318 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
14319 ::treesitter_types::runtime::maybe_grow_stack(|| {
14320 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
14321 })?,
14322 ))),
14323 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
14324 ::treesitter_types::runtime::maybe_grow_stack(|| {
14325 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
14326 })?,
14327 ))),
14328 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
14329 ::treesitter_types::runtime::maybe_grow_stack(|| {
14330 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
14331 })?,
14332 ))),
14333 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14334 ::treesitter_types::runtime::maybe_grow_stack(|| {
14335 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14336 })?,
14337 ))),
14338 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
14339 ::treesitter_types::runtime::maybe_grow_stack(|| {
14340 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
14341 })?,
14342 ))),
14343 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14344 }
14345 }
14346}
14347impl ::treesitter_types::Spanned for ArrayTypeType<'_> {
14348 fn span(&self) -> ::treesitter_types::Span {
14349 match self {
14350 Self::AliasQualifiedName(inner) => inner.span(),
14351 Self::ArrayType(inner) => inner.span(),
14352 Self::FunctionPointerType(inner) => inner.span(),
14353 Self::GenericName(inner) => inner.span(),
14354 Self::Identifier(inner) => inner.span(),
14355 Self::NullableType(inner) => inner.span(),
14356 Self::PointerType(inner) => inner.span(),
14357 Self::PredefinedType(inner) => inner.span(),
14358 Self::QualifiedName(inner) => inner.span(),
14359 Self::TupleType(inner) => inner.span(),
14360 }
14361 }
14362}
14363#[derive(Debug, Clone, PartialEq, Eq)]
14364pub enum AsExpressionOperator {
14365 As(::treesitter_types::Span),
14366}
14367impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpressionOperator {
14368 #[allow(clippy::collapsible_else_if)]
14369 fn from_node(
14370 node: ::treesitter_types::tree_sitter::Node<'tree>,
14371 _src: &'tree [u8],
14372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14373 match node.kind() {
14374 "as" => Ok(Self::As(::treesitter_types::Span::from(node))),
14375 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14376 }
14377 }
14378}
14379impl ::treesitter_types::Spanned for AsExpressionOperator {
14380 fn span(&self) -> ::treesitter_types::Span {
14381 match self {
14382 Self::As(span) => *span,
14383 }
14384 }
14385}
14386#[derive(Debug, Clone, PartialEq, Eq)]
14387pub enum AssignmentExpressionOperator {
14388 PercentEq(::treesitter_types::Span),
14389 AmpEq(::treesitter_types::Span),
14390 StarEq(::treesitter_types::Span),
14391 PlusEq(::treesitter_types::Span),
14392 MinusEq(::treesitter_types::Span),
14393 SlashEq(::treesitter_types::Span),
14394 ShlEq(::treesitter_types::Span),
14395 Eq(::treesitter_types::Span),
14396 ShrEq(::treesitter_types::Span),
14397 GtGtGtEq(::treesitter_types::Span),
14398 QuestionQuestionEq(::treesitter_types::Span),
14399 CaretEq(::treesitter_types::Span),
14400 PipeEq(::treesitter_types::Span),
14401}
14402impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
14403 #[allow(clippy::collapsible_else_if)]
14404 fn from_node(
14405 node: ::treesitter_types::tree_sitter::Node<'tree>,
14406 _src: &'tree [u8],
14407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14408 match node.kind() {
14409 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
14410 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
14411 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
14412 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
14413 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
14414 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
14415 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
14416 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
14417 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
14418 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
14419 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
14420 node,
14421 ))),
14422 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
14423 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
14424 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14425 }
14426 }
14427}
14428impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
14429 fn span(&self) -> ::treesitter_types::Span {
14430 match self {
14431 Self::PercentEq(span) => *span,
14432 Self::AmpEq(span) => *span,
14433 Self::StarEq(span) => *span,
14434 Self::PlusEq(span) => *span,
14435 Self::MinusEq(span) => *span,
14436 Self::SlashEq(span) => *span,
14437 Self::ShlEq(span) => *span,
14438 Self::Eq(span) => *span,
14439 Self::ShrEq(span) => *span,
14440 Self::GtGtGtEq(span) => *span,
14441 Self::QuestionQuestionEq(span) => *span,
14442 Self::CaretEq(span) => *span,
14443 Self::PipeEq(span) => *span,
14444 }
14445 }
14446}
14447#[derive(Debug, Clone, PartialEq, Eq)]
14448pub enum AttributeName<'tree> {
14449 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
14450 GenericName(::std::boxed::Box<GenericName<'tree>>),
14451 Identifier(::std::boxed::Box<Identifier<'tree>>),
14452 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14453}
14454impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeName<'tree> {
14455 #[allow(clippy::collapsible_else_if)]
14456 fn from_node(
14457 node: ::treesitter_types::tree_sitter::Node<'tree>,
14458 src: &'tree [u8],
14459 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14460 match node.kind() {
14461 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
14462 ::treesitter_types::runtime::maybe_grow_stack(|| {
14463 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14464 })?,
14465 ))),
14466 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14467 ::treesitter_types::runtime::maybe_grow_stack(|| {
14468 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
14469 })?,
14470 ))),
14471 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14472 ::treesitter_types::runtime::maybe_grow_stack(|| {
14473 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14474 })?,
14475 ))),
14476 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14477 ::treesitter_types::runtime::maybe_grow_stack(|| {
14478 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14479 })?,
14480 ))),
14481 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14482 }
14483 }
14484}
14485impl ::treesitter_types::Spanned for AttributeName<'_> {
14486 fn span(&self) -> ::treesitter_types::Span {
14487 match self {
14488 Self::AliasQualifiedName(inner) => inner.span(),
14489 Self::GenericName(inner) => inner.span(),
14490 Self::Identifier(inner) => inner.span(),
14491 Self::QualifiedName(inner) => inner.span(),
14492 }
14493 }
14494}
14495#[derive(Debug, Clone, PartialEq, Eq)]
14496pub enum AttributeArgumentChildren<'tree> {
14497 Expression(::std::boxed::Box<Expression<'tree>>),
14498 Identifier(::std::boxed::Box<Identifier<'tree>>),
14499}
14500impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgumentChildren<'tree> {
14501 #[allow(clippy::collapsible_else_if)]
14502 fn from_node(
14503 node: ::treesitter_types::tree_sitter::Node<'tree>,
14504 src: &'tree [u8],
14505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14506 match node.kind() {
14507 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14508 ::treesitter_types::runtime::maybe_grow_stack(|| {
14509 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14510 })?,
14511 ))),
14512 _other => {
14513 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14514 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14515 }) {
14516 Ok(Self::Expression(::std::boxed::Box::new(v)))
14517 } else {
14518 Err(::treesitter_types::ParseError::unexpected_kind(
14519 _other, node,
14520 ))
14521 }
14522 }
14523 }
14524 }
14525}
14526impl ::treesitter_types::Spanned for AttributeArgumentChildren<'_> {
14527 fn span(&self) -> ::treesitter_types::Span {
14528 match self {
14529 Self::Expression(inner) => inner.span(),
14530 Self::Identifier(inner) => inner.span(),
14531 }
14532 }
14533}
14534#[derive(Debug, Clone, PartialEq, Eq)]
14535pub enum AttributeListChildren<'tree> {
14536 Attribute(::std::boxed::Box<Attribute<'tree>>),
14537 AttributeTargetSpecifier(::std::boxed::Box<AttributeTargetSpecifier<'tree>>),
14538}
14539impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeListChildren<'tree> {
14540 #[allow(clippy::collapsible_else_if)]
14541 fn from_node(
14542 node: ::treesitter_types::tree_sitter::Node<'tree>,
14543 src: &'tree [u8],
14544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14545 match node.kind() {
14546 "attribute" => Ok(Self::Attribute(::std::boxed::Box::new(
14547 ::treesitter_types::runtime::maybe_grow_stack(|| {
14548 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
14549 })?,
14550 ))),
14551 "attribute_target_specifier" => Ok(Self::AttributeTargetSpecifier(
14552 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14553 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14554 })?),
14555 )),
14556 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14557 }
14558 }
14559}
14560impl ::treesitter_types::Spanned for AttributeListChildren<'_> {
14561 fn span(&self) -> ::treesitter_types::Span {
14562 match self {
14563 Self::Attribute(inner) => inner.span(),
14564 Self::AttributeTargetSpecifier(inner) => inner.span(),
14565 }
14566 }
14567}
14568#[derive(Debug, Clone, PartialEq, Eq)]
14569pub enum BaseListChildren<'tree> {
14570 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
14571 PrimaryConstructorBaseType(::std::boxed::Box<PrimaryConstructorBaseType<'tree>>),
14572 Type(::std::boxed::Box<Type<'tree>>),
14573}
14574impl<'tree> ::treesitter_types::FromNode<'tree> for BaseListChildren<'tree> {
14575 #[allow(clippy::collapsible_else_if)]
14576 fn from_node(
14577 node: ::treesitter_types::tree_sitter::Node<'tree>,
14578 src: &'tree [u8],
14579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14580 match node.kind() {
14581 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
14582 ::treesitter_types::runtime::maybe_grow_stack(|| {
14583 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
14584 })?,
14585 ))),
14586 "primary_constructor_base_type" => Ok(Self::PrimaryConstructorBaseType(
14587 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14588 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(
14589 node, src,
14590 )
14591 })?),
14592 )),
14593 _other => {
14594 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14595 <Type as ::treesitter_types::FromNode>::from_node(node, src)
14596 }) {
14597 Ok(Self::Type(::std::boxed::Box::new(v)))
14598 } else {
14599 Err(::treesitter_types::ParseError::unexpected_kind(
14600 _other, node,
14601 ))
14602 }
14603 }
14604 }
14605 }
14606}
14607impl ::treesitter_types::Spanned for BaseListChildren<'_> {
14608 fn span(&self) -> ::treesitter_types::Span {
14609 match self {
14610 Self::ArgumentList(inner) => inner.span(),
14611 Self::PrimaryConstructorBaseType(inner) => inner.span(),
14612 Self::Type(inner) => inner.span(),
14613 }
14614 }
14615}
14616#[derive(Debug, Clone, PartialEq, Eq)]
14617pub enum BinaryExpressionLeft<'tree> {
14618 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
14619 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
14620 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
14621 Expression(::std::boxed::Box<Expression<'tree>>),
14622 Identifier(::std::boxed::Box<Identifier<'tree>>),
14623 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
14624 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14625 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
14626}
14627impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
14628 #[allow(clippy::collapsible_else_if)]
14629 fn from_node(
14630 node: ::treesitter_types::tree_sitter::Node<'tree>,
14631 src: &'tree [u8],
14632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14633 match node.kind() {
14634 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
14635 ::treesitter_types::runtime::maybe_grow_stack(|| {
14636 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14637 })?,
14638 ))),
14639 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
14640 ::treesitter_types::runtime::maybe_grow_stack(|| {
14641 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14642 })?,
14643 ))),
14644 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
14645 ::treesitter_types::runtime::maybe_grow_stack(|| {
14646 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14647 })?,
14648 ))),
14649 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14650 ::treesitter_types::runtime::maybe_grow_stack(|| {
14651 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14652 })?,
14653 ))),
14654 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
14655 ::treesitter_types::runtime::maybe_grow_stack(|| {
14656 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14657 })?,
14658 ))),
14659 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
14660 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14661 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14662 })?),
14663 )),
14664 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
14665 ::treesitter_types::runtime::maybe_grow_stack(|| {
14666 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14667 })?,
14668 ))),
14669 _other => {
14670 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14671 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14672 }) {
14673 Ok(Self::Expression(::std::boxed::Box::new(v)))
14674 } else {
14675 Err(::treesitter_types::ParseError::unexpected_kind(
14676 _other, node,
14677 ))
14678 }
14679 }
14680 }
14681 }
14682}
14683impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
14684 fn span(&self) -> ::treesitter_types::Span {
14685 match self {
14686 Self::BinaryExpression(inner) => inner.span(),
14687 Self::BooleanLiteral(inner) => inner.span(),
14688 Self::CharacterLiteral(inner) => inner.span(),
14689 Self::Expression(inner) => inner.span(),
14690 Self::Identifier(inner) => inner.span(),
14691 Self::IntegerLiteral(inner) => inner.span(),
14692 Self::ParenthesizedExpression(inner) => inner.span(),
14693 Self::UnaryExpression(inner) => inner.span(),
14694 }
14695 }
14696}
14697#[derive(Debug, Clone, PartialEq, Eq)]
14698pub enum BinaryExpressionOperator {
14699 NotEq(::treesitter_types::Span),
14700 Percent(::treesitter_types::Span),
14701 Amp(::treesitter_types::Span),
14702 AmpAmp(::treesitter_types::Span),
14703 Star(::treesitter_types::Span),
14704 Plus(::treesitter_types::Span),
14705 Minus(::treesitter_types::Span),
14706 Slash(::treesitter_types::Span),
14707 Lt(::treesitter_types::Span),
14708 Shl(::treesitter_types::Span),
14709 LtEq(::treesitter_types::Span),
14710 EqEq(::treesitter_types::Span),
14711 Gt(::treesitter_types::Span),
14712 GtEq(::treesitter_types::Span),
14713 Shr(::treesitter_types::Span),
14714 GtGtGt(::treesitter_types::Span),
14715 QuestionQuestion(::treesitter_types::Span),
14716 Caret(::treesitter_types::Span),
14717 Pipe(::treesitter_types::Span),
14718 PipePipe(::treesitter_types::Span),
14719}
14720impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
14721 #[allow(clippy::collapsible_else_if)]
14722 fn from_node(
14723 node: ::treesitter_types::tree_sitter::Node<'tree>,
14724 _src: &'tree [u8],
14725 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14726 match node.kind() {
14727 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
14728 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
14729 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
14730 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
14731 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
14732 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
14733 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
14734 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
14735 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
14736 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
14737 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
14738 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
14739 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
14740 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
14741 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
14742 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
14743 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
14744 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
14745 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
14746 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
14747 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14748 }
14749 }
14750}
14751impl ::treesitter_types::Spanned for BinaryExpressionOperator {
14752 fn span(&self) -> ::treesitter_types::Span {
14753 match self {
14754 Self::NotEq(span) => *span,
14755 Self::Percent(span) => *span,
14756 Self::Amp(span) => *span,
14757 Self::AmpAmp(span) => *span,
14758 Self::Star(span) => *span,
14759 Self::Plus(span) => *span,
14760 Self::Minus(span) => *span,
14761 Self::Slash(span) => *span,
14762 Self::Lt(span) => *span,
14763 Self::Shl(span) => *span,
14764 Self::LtEq(span) => *span,
14765 Self::EqEq(span) => *span,
14766 Self::Gt(span) => *span,
14767 Self::GtEq(span) => *span,
14768 Self::Shr(span) => *span,
14769 Self::GtGtGt(span) => *span,
14770 Self::QuestionQuestion(span) => *span,
14771 Self::Caret(span) => *span,
14772 Self::Pipe(span) => *span,
14773 Self::PipePipe(span) => *span,
14774 }
14775 }
14776}
14777#[derive(Debug, Clone, PartialEq, Eq)]
14778pub enum BinaryExpressionRight<'tree> {
14779 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
14780 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
14781 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
14782 Expression(::std::boxed::Box<Expression<'tree>>),
14783 Identifier(::std::boxed::Box<Identifier<'tree>>),
14784 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
14785 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14786 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
14787}
14788impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
14789 #[allow(clippy::collapsible_else_if)]
14790 fn from_node(
14791 node: ::treesitter_types::tree_sitter::Node<'tree>,
14792 src: &'tree [u8],
14793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14794 match node.kind() {
14795 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
14796 ::treesitter_types::runtime::maybe_grow_stack(|| {
14797 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14798 })?,
14799 ))),
14800 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
14801 ::treesitter_types::runtime::maybe_grow_stack(|| {
14802 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14803 })?,
14804 ))),
14805 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
14806 ::treesitter_types::runtime::maybe_grow_stack(|| {
14807 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14808 })?,
14809 ))),
14810 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14811 ::treesitter_types::runtime::maybe_grow_stack(|| {
14812 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14813 })?,
14814 ))),
14815 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
14816 ::treesitter_types::runtime::maybe_grow_stack(|| {
14817 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14818 })?,
14819 ))),
14820 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
14821 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14822 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14823 })?),
14824 )),
14825 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
14826 ::treesitter_types::runtime::maybe_grow_stack(|| {
14827 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14828 })?,
14829 ))),
14830 _other => {
14831 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14832 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14833 }) {
14834 Ok(Self::Expression(::std::boxed::Box::new(v)))
14835 } else {
14836 Err(::treesitter_types::ParseError::unexpected_kind(
14837 _other, node,
14838 ))
14839 }
14840 }
14841 }
14842 }
14843}
14844impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
14845 fn span(&self) -> ::treesitter_types::Span {
14846 match self {
14847 Self::BinaryExpression(inner) => inner.span(),
14848 Self::BooleanLiteral(inner) => inner.span(),
14849 Self::CharacterLiteral(inner) => inner.span(),
14850 Self::Expression(inner) => inner.span(),
14851 Self::Identifier(inner) => inner.span(),
14852 Self::IntegerLiteral(inner) => inner.span(),
14853 Self::ParenthesizedExpression(inner) => inner.span(),
14854 Self::UnaryExpression(inner) => inner.span(),
14855 }
14856 }
14857}
14858#[derive(Debug, Clone, PartialEq, Eq)]
14859pub enum BracketedParameterListType<'tree> {
14860 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
14861 NullableType(::std::boxed::Box<NullableType<'tree>>),
14862}
14863impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterListType<'tree> {
14864 #[allow(clippy::collapsible_else_if)]
14865 fn from_node(
14866 node: ::treesitter_types::tree_sitter::Node<'tree>,
14867 src: &'tree [u8],
14868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14869 match node.kind() {
14870 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
14871 ::treesitter_types::runtime::maybe_grow_stack(|| {
14872 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
14873 })?,
14874 ))),
14875 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
14876 ::treesitter_types::runtime::maybe_grow_stack(|| {
14877 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
14878 })?,
14879 ))),
14880 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14881 }
14882 }
14883}
14884impl ::treesitter_types::Spanned for BracketedParameterListType<'_> {
14885 fn span(&self) -> ::treesitter_types::Span {
14886 match self {
14887 Self::ArrayType(inner) => inner.span(),
14888 Self::NullableType(inner) => inner.span(),
14889 }
14890 }
14891}
14892#[derive(Debug, Clone, PartialEq, Eq)]
14893pub enum BracketedParameterListChildren<'tree> {
14894 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14895 Parameter(::std::boxed::Box<Parameter<'tree>>),
14896}
14897impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterListChildren<'tree> {
14898 #[allow(clippy::collapsible_else_if)]
14899 fn from_node(
14900 node: ::treesitter_types::tree_sitter::Node<'tree>,
14901 src: &'tree [u8],
14902 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14903 match node.kind() {
14904 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14905 ::treesitter_types::runtime::maybe_grow_stack(|| {
14906 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
14907 })?,
14908 ))),
14909 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
14910 ::treesitter_types::runtime::maybe_grow_stack(|| {
14911 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
14912 })?,
14913 ))),
14914 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14915 }
14916 }
14917}
14918impl ::treesitter_types::Spanned for BracketedParameterListChildren<'_> {
14919 fn span(&self) -> ::treesitter_types::Span {
14920 match self {
14921 Self::AttributeList(inner) => inner.span(),
14922 Self::Parameter(inner) => inner.span(),
14923 }
14924 }
14925}
14926#[derive(Debug, Clone, PartialEq, Eq)]
14927pub enum CatchClauseChildren<'tree> {
14928 CatchDeclaration(::std::boxed::Box<CatchDeclaration<'tree>>),
14929 CatchFilterClause(::std::boxed::Box<CatchFilterClause<'tree>>),
14930}
14931impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseChildren<'tree> {
14932 #[allow(clippy::collapsible_else_if)]
14933 fn from_node(
14934 node: ::treesitter_types::tree_sitter::Node<'tree>,
14935 src: &'tree [u8],
14936 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14937 match node.kind() {
14938 "catch_declaration" => Ok(Self::CatchDeclaration(::std::boxed::Box::new(
14939 ::treesitter_types::runtime::maybe_grow_stack(|| {
14940 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14941 })?,
14942 ))),
14943 "catch_filter_clause" => Ok(Self::CatchFilterClause(::std::boxed::Box::new(
14944 ::treesitter_types::runtime::maybe_grow_stack(|| {
14945 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)
14946 })?,
14947 ))),
14948 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14949 }
14950 }
14951}
14952impl ::treesitter_types::Spanned for CatchClauseChildren<'_> {
14953 fn span(&self) -> ::treesitter_types::Span {
14954 match self {
14955 Self::CatchDeclaration(inner) => inner.span(),
14956 Self::CatchFilterClause(inner) => inner.span(),
14957 }
14958 }
14959}
14960#[derive(Debug, Clone, PartialEq, Eq)]
14961pub enum CharacterLiteralChildren<'tree> {
14962 CharacterLiteralContent(::std::boxed::Box<CharacterLiteralContent<'tree>>),
14963 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
14964}
14965impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralChildren<'tree> {
14966 #[allow(clippy::collapsible_else_if)]
14967 fn from_node(
14968 node: ::treesitter_types::tree_sitter::Node<'tree>,
14969 src: &'tree [u8],
14970 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14971 match node.kind() {
14972 "character_literal_content" => Ok(Self::CharacterLiteralContent(
14973 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14974 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
14975 })?),
14976 )),
14977 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
14978 ::treesitter_types::runtime::maybe_grow_stack(|| {
14979 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
14980 })?,
14981 ))),
14982 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14983 }
14984 }
14985}
14986impl ::treesitter_types::Spanned for CharacterLiteralChildren<'_> {
14987 fn span(&self) -> ::treesitter_types::Span {
14988 match self {
14989 Self::CharacterLiteralContent(inner) => inner.span(),
14990 Self::EscapeSequence(inner) => inner.span(),
14991 }
14992 }
14993}
14994#[derive(Debug, Clone, PartialEq, Eq)]
14995pub enum ClassDeclarationChildren<'tree> {
14996 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14997 BaseList(::std::boxed::Box<BaseList<'tree>>),
14998 Modifier(::std::boxed::Box<Modifier<'tree>>),
14999 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
15000 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
15001 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
15002}
15003impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarationChildren<'tree> {
15004 #[allow(clippy::collapsible_else_if)]
15005 fn from_node(
15006 node: ::treesitter_types::tree_sitter::Node<'tree>,
15007 src: &'tree [u8],
15008 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15009 match node.kind() {
15010 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15011 ::treesitter_types::runtime::maybe_grow_stack(|| {
15012 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15013 })?,
15014 ))),
15015 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
15016 ::treesitter_types::runtime::maybe_grow_stack(|| {
15017 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
15018 })?,
15019 ))),
15020 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15021 ::treesitter_types::runtime::maybe_grow_stack(|| {
15022 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15023 })?,
15024 ))),
15025 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
15026 ::treesitter_types::runtime::maybe_grow_stack(|| {
15027 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
15028 })?,
15029 ))),
15030 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
15031 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15032 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
15033 node, src,
15034 )
15035 })?),
15036 )),
15037 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
15038 ::treesitter_types::runtime::maybe_grow_stack(|| {
15039 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
15040 })?,
15041 ))),
15042 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15043 }
15044 }
15045}
15046impl ::treesitter_types::Spanned for ClassDeclarationChildren<'_> {
15047 fn span(&self) -> ::treesitter_types::Span {
15048 match self {
15049 Self::AttributeList(inner) => inner.span(),
15050 Self::BaseList(inner) => inner.span(),
15051 Self::Modifier(inner) => inner.span(),
15052 Self::ParameterList(inner) => inner.span(),
15053 Self::TypeParameterConstraintsClause(inner) => inner.span(),
15054 Self::TypeParameterList(inner) => inner.span(),
15055 }
15056 }
15057}
15058#[derive(Debug, Clone, PartialEq, Eq)]
15059pub enum CompilationUnitChildren<'tree> {
15060 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
15061 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
15062 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
15063 GlobalStatement(::std::boxed::Box<GlobalStatement<'tree>>),
15064 NamespaceDeclaration(::std::boxed::Box<NamespaceDeclaration<'tree>>),
15065 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
15066 ShebangDirective(::std::boxed::Box<ShebangDirective<'tree>>),
15067 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
15068 UsingDirective(::std::boxed::Box<UsingDirective<'tree>>),
15069}
15070impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnitChildren<'tree> {
15071 #[allow(clippy::collapsible_else_if)]
15072 fn from_node(
15073 node: ::treesitter_types::tree_sitter::Node<'tree>,
15074 src: &'tree [u8],
15075 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15076 match node.kind() {
15077 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
15078 ::treesitter_types::runtime::maybe_grow_stack(|| {
15079 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
15080 })?,
15081 ))),
15082 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
15083 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15084 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
15085 node, src,
15086 )
15087 })?),
15088 )),
15089 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
15090 ::treesitter_types::runtime::maybe_grow_stack(|| {
15091 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
15092 })?,
15093 ))),
15094 "global_statement" => Ok(Self::GlobalStatement(::std::boxed::Box::new(
15095 ::treesitter_types::runtime::maybe_grow_stack(|| {
15096 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)
15097 })?,
15098 ))),
15099 "namespace_declaration" => Ok(Self::NamespaceDeclaration(::std::boxed::Box::new(
15100 ::treesitter_types::runtime::maybe_grow_stack(|| {
15101 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15102 })?,
15103 ))),
15104 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
15105 ::treesitter_types::runtime::maybe_grow_stack(|| {
15106 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
15107 })?,
15108 ))),
15109 "shebang_directive" => Ok(Self::ShebangDirective(::std::boxed::Box::new(
15110 ::treesitter_types::runtime::maybe_grow_stack(|| {
15111 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)
15112 })?,
15113 ))),
15114 "using_directive" => Ok(Self::UsingDirective(::std::boxed::Box::new(
15115 ::treesitter_types::runtime::maybe_grow_stack(|| {
15116 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
15117 })?,
15118 ))),
15119 _other => {
15120 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15121 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15122 }) {
15123 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
15124 } else {
15125 Err(::treesitter_types::ParseError::unexpected_kind(
15126 _other, node,
15127 ))
15128 }
15129 }
15130 }
15131 }
15132}
15133impl ::treesitter_types::Spanned for CompilationUnitChildren<'_> {
15134 fn span(&self) -> ::treesitter_types::Span {
15135 match self {
15136 Self::ExternAliasDirective(inner) => inner.span(),
15137 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
15138 Self::GlobalAttribute(inner) => inner.span(),
15139 Self::GlobalStatement(inner) => inner.span(),
15140 Self::NamespaceDeclaration(inner) => inner.span(),
15141 Self::PreprocIf(inner) => inner.span(),
15142 Self::ShebangDirective(inner) => inner.span(),
15143 Self::TypeDeclaration(inner) => inner.span(),
15144 Self::UsingDirective(inner) => inner.span(),
15145 }
15146 }
15147}
15148#[derive(Debug, Clone, PartialEq, Eq)]
15149pub enum ConditionalAccessExpressionChildren<'tree> {
15150 ElementBindingExpression(::std::boxed::Box<ElementBindingExpression<'tree>>),
15151 MemberBindingExpression(::std::boxed::Box<MemberBindingExpression<'tree>>),
15152}
15153impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpressionChildren<'tree> {
15154 #[allow(clippy::collapsible_else_if)]
15155 fn from_node(
15156 node: ::treesitter_types::tree_sitter::Node<'tree>,
15157 src: &'tree [u8],
15158 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15159 match node.kind() {
15160 "element_binding_expression" => Ok(Self::ElementBindingExpression(
15161 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15162 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
15163 })?),
15164 )),
15165 "member_binding_expression" => Ok(Self::MemberBindingExpression(
15166 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15167 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
15168 })?),
15169 )),
15170 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15171 }
15172 }
15173}
15174impl ::treesitter_types::Spanned for ConditionalAccessExpressionChildren<'_> {
15175 fn span(&self) -> ::treesitter_types::Span {
15176 match self {
15177 Self::ElementBindingExpression(inner) => inner.span(),
15178 Self::MemberBindingExpression(inner) => inner.span(),
15179 }
15180 }
15181}
15182#[derive(Debug, Clone, PartialEq, Eq)]
15183pub enum ConstantPatternChildren<'tree> {
15184 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
15185 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
15186 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
15187 GenericName(::std::boxed::Box<GenericName<'tree>>),
15188 Identifier(::std::boxed::Box<Identifier<'tree>>),
15189 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
15190 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
15191 Literal(::std::boxed::Box<Literal<'tree>>),
15192 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
15193 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15194 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
15195 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
15196 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
15197 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
15198 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
15199}
15200impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPatternChildren<'tree> {
15201 #[allow(clippy::collapsible_else_if)]
15202 fn from_node(
15203 node: ::treesitter_types::tree_sitter::Node<'tree>,
15204 src: &'tree [u8],
15205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15206 match node.kind() {
15207 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
15208 ::treesitter_types::runtime::maybe_grow_stack(|| {
15209 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15210 })?,
15211 ))),
15212 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
15213 ::treesitter_types::runtime::maybe_grow_stack(|| {
15214 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15215 })?,
15216 ))),
15217 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
15218 ::treesitter_types::runtime::maybe_grow_stack(|| {
15219 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
15220 })?,
15221 ))),
15222 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15223 ::treesitter_types::runtime::maybe_grow_stack(|| {
15224 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
15225 })?,
15226 ))),
15227 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15228 ::treesitter_types::runtime::maybe_grow_stack(|| {
15229 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15230 })?,
15231 ))),
15232 "interpolated_string_expression" => Ok(Self::InterpolatedStringExpression(
15233 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15234 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
15235 node, src,
15236 )
15237 })?),
15238 )),
15239 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
15240 ::treesitter_types::runtime::maybe_grow_stack(|| {
15241 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15242 })?,
15243 ))),
15244 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
15245 ::treesitter_types::runtime::maybe_grow_stack(|| {
15246 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15247 })?,
15248 ))),
15249 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15250 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15251 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15252 })?),
15253 )),
15254 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
15255 ::treesitter_types::runtime::maybe_grow_stack(|| {
15256 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15257 })?,
15258 ))),
15259 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
15260 ::treesitter_types::runtime::maybe_grow_stack(|| {
15261 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15262 })?,
15263 ))),
15264 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
15265 ::treesitter_types::runtime::maybe_grow_stack(|| {
15266 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
15267 })?,
15268 ))),
15269 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
15270 ::treesitter_types::runtime::maybe_grow_stack(|| {
15271 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
15272 })?,
15273 ))),
15274 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
15275 ::treesitter_types::runtime::maybe_grow_stack(|| {
15276 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
15277 })?,
15278 ))),
15279 _other => {
15280 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15281 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
15282 }) {
15283 Ok(Self::Literal(::std::boxed::Box::new(v)))
15284 } else {
15285 Err(::treesitter_types::ParseError::unexpected_kind(
15286 _other, node,
15287 ))
15288 }
15289 }
15290 }
15291 }
15292}
15293impl ::treesitter_types::Spanned for ConstantPatternChildren<'_> {
15294 fn span(&self) -> ::treesitter_types::Span {
15295 match self {
15296 Self::BinaryExpression(inner) => inner.span(),
15297 Self::CastExpression(inner) => inner.span(),
15298 Self::DefaultExpression(inner) => inner.span(),
15299 Self::GenericName(inner) => inner.span(),
15300 Self::Identifier(inner) => inner.span(),
15301 Self::InterpolatedStringExpression(inner) => inner.span(),
15302 Self::InvocationExpression(inner) => inner.span(),
15303 Self::Literal(inner) => inner.span(),
15304 Self::MemberAccessExpression(inner) => inner.span(),
15305 Self::ParenthesizedExpression(inner) => inner.span(),
15306 Self::PostfixUnaryExpression(inner) => inner.span(),
15307 Self::PrefixUnaryExpression(inner) => inner.span(),
15308 Self::SizeofExpression(inner) => inner.span(),
15309 Self::TupleExpression(inner) => inner.span(),
15310 Self::TypeofExpression(inner) => inner.span(),
15311 }
15312 }
15313}
15314#[derive(Debug, Clone, PartialEq, Eq)]
15315pub enum ConstructorDeclarationBody<'tree> {
15316 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15317 Block(::std::boxed::Box<Block<'tree>>),
15318}
15319impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationBody<'tree> {
15320 #[allow(clippy::collapsible_else_if)]
15321 fn from_node(
15322 node: ::treesitter_types::tree_sitter::Node<'tree>,
15323 src: &'tree [u8],
15324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15325 match node.kind() {
15326 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15327 ::treesitter_types::runtime::maybe_grow_stack(|| {
15328 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
15329 })?,
15330 ))),
15331 "block" => Ok(Self::Block(::std::boxed::Box::new(
15332 ::treesitter_types::runtime::maybe_grow_stack(|| {
15333 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15334 })?,
15335 ))),
15336 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15337 }
15338 }
15339}
15340impl ::treesitter_types::Spanned for ConstructorDeclarationBody<'_> {
15341 fn span(&self) -> ::treesitter_types::Span {
15342 match self {
15343 Self::ArrowExpressionClause(inner) => inner.span(),
15344 Self::Block(inner) => inner.span(),
15345 }
15346 }
15347}
15348#[derive(Debug, Clone, PartialEq, Eq)]
15349pub enum ConstructorDeclarationChildren<'tree> {
15350 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15351 ConstructorInitializer(::std::boxed::Box<ConstructorInitializer<'tree>>),
15352 Modifier(::std::boxed::Box<Modifier<'tree>>),
15353}
15354impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
15355 #[allow(clippy::collapsible_else_if)]
15356 fn from_node(
15357 node: ::treesitter_types::tree_sitter::Node<'tree>,
15358 src: &'tree [u8],
15359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15360 match node.kind() {
15361 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15362 ::treesitter_types::runtime::maybe_grow_stack(|| {
15363 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15364 })?,
15365 ))),
15366 "constructor_initializer" => Ok(Self::ConstructorInitializer(::std::boxed::Box::new(
15367 ::treesitter_types::runtime::maybe_grow_stack(|| {
15368 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15369 })?,
15370 ))),
15371 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15372 ::treesitter_types::runtime::maybe_grow_stack(|| {
15373 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15374 })?,
15375 ))),
15376 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15377 }
15378 }
15379}
15380impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
15381 fn span(&self) -> ::treesitter_types::Span {
15382 match self {
15383 Self::AttributeList(inner) => inner.span(),
15384 Self::ConstructorInitializer(inner) => inner.span(),
15385 Self::Modifier(inner) => inner.span(),
15386 }
15387 }
15388}
15389#[derive(Debug, Clone, PartialEq, Eq)]
15390pub enum ConversionOperatorDeclarationBody<'tree> {
15391 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15392 Block(::std::boxed::Box<Block<'tree>>),
15393}
15394impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationBody<'tree> {
15395 #[allow(clippy::collapsible_else_if)]
15396 fn from_node(
15397 node: ::treesitter_types::tree_sitter::Node<'tree>,
15398 src: &'tree [u8],
15399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15400 match node.kind() {
15401 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15402 ::treesitter_types::runtime::maybe_grow_stack(|| {
15403 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
15404 })?,
15405 ))),
15406 "block" => Ok(Self::Block(::std::boxed::Box::new(
15407 ::treesitter_types::runtime::maybe_grow_stack(|| {
15408 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15409 })?,
15410 ))),
15411 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15412 }
15413 }
15414}
15415impl ::treesitter_types::Spanned for ConversionOperatorDeclarationBody<'_> {
15416 fn span(&self) -> ::treesitter_types::Span {
15417 match self {
15418 Self::ArrowExpressionClause(inner) => inner.span(),
15419 Self::Block(inner) => inner.span(),
15420 }
15421 }
15422}
15423#[derive(Debug, Clone, PartialEq, Eq)]
15424pub enum ConversionOperatorDeclarationChildren<'tree> {
15425 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15426 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
15427 Modifier(::std::boxed::Box<Modifier<'tree>>),
15428}
15429impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationChildren<'tree> {
15430 #[allow(clippy::collapsible_else_if)]
15431 fn from_node(
15432 node: ::treesitter_types::tree_sitter::Node<'tree>,
15433 src: &'tree [u8],
15434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15435 match node.kind() {
15436 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15437 ::treesitter_types::runtime::maybe_grow_stack(|| {
15438 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15439 })?,
15440 ))),
15441 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
15442 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15443 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
15444 node, src,
15445 )
15446 })?),
15447 )),
15448 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15449 ::treesitter_types::runtime::maybe_grow_stack(|| {
15450 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15451 })?,
15452 ))),
15453 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15454 }
15455 }
15456}
15457impl ::treesitter_types::Spanned for ConversionOperatorDeclarationChildren<'_> {
15458 fn span(&self) -> ::treesitter_types::Span {
15459 match self {
15460 Self::AttributeList(inner) => inner.span(),
15461 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
15462 Self::Modifier(inner) => inner.span(),
15463 }
15464 }
15465}
15466#[derive(Debug, Clone, PartialEq, Eq)]
15467pub enum DeclarationPatternChildren<'tree> {
15468 Discard(::std::boxed::Box<Discard<'tree>>),
15469 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
15470}
15471impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPatternChildren<'tree> {
15472 #[allow(clippy::collapsible_else_if)]
15473 fn from_node(
15474 node: ::treesitter_types::tree_sitter::Node<'tree>,
15475 src: &'tree [u8],
15476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15477 match node.kind() {
15478 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
15479 ::treesitter_types::runtime::maybe_grow_stack(|| {
15480 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
15481 })?,
15482 ))),
15483 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
15484 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15485 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
15486 node, src,
15487 )
15488 })?),
15489 )),
15490 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15491 }
15492 }
15493}
15494impl ::treesitter_types::Spanned for DeclarationPatternChildren<'_> {
15495 fn span(&self) -> ::treesitter_types::Span {
15496 match self {
15497 Self::Discard(inner) => inner.span(),
15498 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
15499 }
15500 }
15501}
15502#[derive(Debug, Clone, PartialEq, Eq)]
15503pub enum DelegateDeclarationChildren<'tree> {
15504 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15505 Modifier(::std::boxed::Box<Modifier<'tree>>),
15506 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
15507}
15508impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclarationChildren<'tree> {
15509 #[allow(clippy::collapsible_else_if)]
15510 fn from_node(
15511 node: ::treesitter_types::tree_sitter::Node<'tree>,
15512 src: &'tree [u8],
15513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15514 match node.kind() {
15515 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15516 ::treesitter_types::runtime::maybe_grow_stack(|| {
15517 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15518 })?,
15519 ))),
15520 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15521 ::treesitter_types::runtime::maybe_grow_stack(|| {
15522 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15523 })?,
15524 ))),
15525 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
15526 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15527 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
15528 node, src,
15529 )
15530 })?),
15531 )),
15532 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15533 }
15534 }
15535}
15536impl ::treesitter_types::Spanned for DelegateDeclarationChildren<'_> {
15537 fn span(&self) -> ::treesitter_types::Span {
15538 match self {
15539 Self::AttributeList(inner) => inner.span(),
15540 Self::Modifier(inner) => inner.span(),
15541 Self::TypeParameterConstraintsClause(inner) => inner.span(),
15542 }
15543 }
15544}
15545#[derive(Debug, Clone, PartialEq, Eq)]
15546pub enum DestructorDeclarationBody<'tree> {
15547 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15548 Block(::std::boxed::Box<Block<'tree>>),
15549}
15550impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclarationBody<'tree> {
15551 #[allow(clippy::collapsible_else_if)]
15552 fn from_node(
15553 node: ::treesitter_types::tree_sitter::Node<'tree>,
15554 src: &'tree [u8],
15555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15556 match node.kind() {
15557 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15558 ::treesitter_types::runtime::maybe_grow_stack(|| {
15559 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
15560 })?,
15561 ))),
15562 "block" => Ok(Self::Block(::std::boxed::Box::new(
15563 ::treesitter_types::runtime::maybe_grow_stack(|| {
15564 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15565 })?,
15566 ))),
15567 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15568 }
15569 }
15570}
15571impl ::treesitter_types::Spanned for DestructorDeclarationBody<'_> {
15572 fn span(&self) -> ::treesitter_types::Span {
15573 match self {
15574 Self::ArrowExpressionClause(inner) => inner.span(),
15575 Self::Block(inner) => inner.span(),
15576 }
15577 }
15578}
15579#[derive(Debug, Clone, PartialEq, Eq)]
15580pub enum EnumDeclarationChildren<'tree> {
15581 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15582 BaseList(::std::boxed::Box<BaseList<'tree>>),
15583 Modifier(::std::boxed::Box<Modifier<'tree>>),
15584}
15585impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationChildren<'tree> {
15586 #[allow(clippy::collapsible_else_if)]
15587 fn from_node(
15588 node: ::treesitter_types::tree_sitter::Node<'tree>,
15589 src: &'tree [u8],
15590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15591 match node.kind() {
15592 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15593 ::treesitter_types::runtime::maybe_grow_stack(|| {
15594 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15595 })?,
15596 ))),
15597 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
15598 ::treesitter_types::runtime::maybe_grow_stack(|| {
15599 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
15600 })?,
15601 ))),
15602 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15603 ::treesitter_types::runtime::maybe_grow_stack(|| {
15604 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15605 })?,
15606 ))),
15607 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15608 }
15609 }
15610}
15611impl ::treesitter_types::Spanned for EnumDeclarationChildren<'_> {
15612 fn span(&self) -> ::treesitter_types::Span {
15613 match self {
15614 Self::AttributeList(inner) => inner.span(),
15615 Self::BaseList(inner) => inner.span(),
15616 Self::Modifier(inner) => inner.span(),
15617 }
15618 }
15619}
15620#[derive(Debug, Clone, PartialEq, Eq)]
15621pub enum EnumMemberDeclarationListChildren<'tree> {
15622 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
15623 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
15624}
15625impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationListChildren<'tree> {
15626 #[allow(clippy::collapsible_else_if)]
15627 fn from_node(
15628 node: ::treesitter_types::tree_sitter::Node<'tree>,
15629 src: &'tree [u8],
15630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15631 match node.kind() {
15632 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
15633 ::treesitter_types::runtime::maybe_grow_stack(|| {
15634 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15635 })?,
15636 ))),
15637 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
15638 ::treesitter_types::runtime::maybe_grow_stack(|| {
15639 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
15640 })?,
15641 ))),
15642 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15643 }
15644 }
15645}
15646impl ::treesitter_types::Spanned for EnumMemberDeclarationListChildren<'_> {
15647 fn span(&self) -> ::treesitter_types::Span {
15648 match self {
15649 Self::EnumMemberDeclaration(inner) => inner.span(),
15650 Self::PreprocIf(inner) => inner.span(),
15651 }
15652 }
15653}
15654#[derive(Debug, Clone, PartialEq, Eq)]
15655pub enum EventDeclarationChildren<'tree> {
15656 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15657 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
15658 Modifier(::std::boxed::Box<Modifier<'tree>>),
15659}
15660impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclarationChildren<'tree> {
15661 #[allow(clippy::collapsible_else_if)]
15662 fn from_node(
15663 node: ::treesitter_types::tree_sitter::Node<'tree>,
15664 src: &'tree [u8],
15665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15666 match node.kind() {
15667 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15668 ::treesitter_types::runtime::maybe_grow_stack(|| {
15669 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15670 })?,
15671 ))),
15672 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
15673 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15674 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
15675 node, src,
15676 )
15677 })?),
15678 )),
15679 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15680 ::treesitter_types::runtime::maybe_grow_stack(|| {
15681 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15682 })?,
15683 ))),
15684 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15685 }
15686 }
15687}
15688impl ::treesitter_types::Spanned for EventDeclarationChildren<'_> {
15689 fn span(&self) -> ::treesitter_types::Span {
15690 match self {
15691 Self::AttributeList(inner) => inner.span(),
15692 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
15693 Self::Modifier(inner) => inner.span(),
15694 }
15695 }
15696}
15697#[derive(Debug, Clone, PartialEq, Eq)]
15698pub enum EventFieldDeclarationChildren<'tree> {
15699 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15700 Modifier(::std::boxed::Box<Modifier<'tree>>),
15701 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15702}
15703impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclarationChildren<'tree> {
15704 #[allow(clippy::collapsible_else_if)]
15705 fn from_node(
15706 node: ::treesitter_types::tree_sitter::Node<'tree>,
15707 src: &'tree [u8],
15708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15709 match node.kind() {
15710 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15711 ::treesitter_types::runtime::maybe_grow_stack(|| {
15712 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15713 })?,
15714 ))),
15715 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15716 ::treesitter_types::runtime::maybe_grow_stack(|| {
15717 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15718 })?,
15719 ))),
15720 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15721 ::treesitter_types::runtime::maybe_grow_stack(|| {
15722 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15723 })?,
15724 ))),
15725 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15726 }
15727 }
15728}
15729impl ::treesitter_types::Spanned for EventFieldDeclarationChildren<'_> {
15730 fn span(&self) -> ::treesitter_types::Span {
15731 match self {
15732 Self::AttributeList(inner) => inner.span(),
15733 Self::Modifier(inner) => inner.span(),
15734 Self::VariableDeclaration(inner) => inner.span(),
15735 }
15736 }
15737}
15738#[derive(Debug, Clone, PartialEq, Eq)]
15739pub enum ExplicitInterfaceSpecifierChildren<'tree> {
15740 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15741 GenericName(::std::boxed::Box<GenericName<'tree>>),
15742 Identifier(::std::boxed::Box<Identifier<'tree>>),
15743 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15744}
15745impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifierChildren<'tree> {
15746 #[allow(clippy::collapsible_else_if)]
15747 fn from_node(
15748 node: ::treesitter_types::tree_sitter::Node<'tree>,
15749 src: &'tree [u8],
15750 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15751 match node.kind() {
15752 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15753 ::treesitter_types::runtime::maybe_grow_stack(|| {
15754 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15755 })?,
15756 ))),
15757 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15758 ::treesitter_types::runtime::maybe_grow_stack(|| {
15759 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
15760 })?,
15761 ))),
15762 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15763 ::treesitter_types::runtime::maybe_grow_stack(|| {
15764 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15765 })?,
15766 ))),
15767 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15768 ::treesitter_types::runtime::maybe_grow_stack(|| {
15769 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15770 })?,
15771 ))),
15772 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15773 }
15774 }
15775}
15776impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifierChildren<'_> {
15777 fn span(&self) -> ::treesitter_types::Span {
15778 match self {
15779 Self::AliasQualifiedName(inner) => inner.span(),
15780 Self::GenericName(inner) => inner.span(),
15781 Self::Identifier(inner) => inner.span(),
15782 Self::QualifiedName(inner) => inner.span(),
15783 }
15784 }
15785}
15786#[derive(Debug, Clone, PartialEq, Eq)]
15787pub enum ExpressionStatementChildren<'tree> {
15788 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
15789 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
15790 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
15791 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
15792 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15793 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
15794 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
15795}
15796impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
15797 #[allow(clippy::collapsible_else_if)]
15798 fn from_node(
15799 node: ::treesitter_types::tree_sitter::Node<'tree>,
15800 src: &'tree [u8],
15801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15802 match node.kind() {
15803 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
15804 ::treesitter_types::runtime::maybe_grow_stack(|| {
15805 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
15806 })?,
15807 ))),
15808 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
15809 ::treesitter_types::runtime::maybe_grow_stack(|| {
15810 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
15811 })?,
15812 ))),
15813 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
15814 ::treesitter_types::runtime::maybe_grow_stack(|| {
15815 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15816 })?,
15817 ))),
15818 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
15819 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15820 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15821 })?),
15822 )),
15823 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15824 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15825 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15826 })?),
15827 )),
15828 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
15829 ::treesitter_types::runtime::maybe_grow_stack(|| {
15830 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15831 })?,
15832 ))),
15833 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
15834 ::treesitter_types::runtime::maybe_grow_stack(|| {
15835 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15836 })?,
15837 ))),
15838 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15839 }
15840 }
15841}
15842impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
15843 fn span(&self) -> ::treesitter_types::Span {
15844 match self {
15845 Self::AssignmentExpression(inner) => inner.span(),
15846 Self::AwaitExpression(inner) => inner.span(),
15847 Self::InvocationExpression(inner) => inner.span(),
15848 Self::ObjectCreationExpression(inner) => inner.span(),
15849 Self::ParenthesizedExpression(inner) => inner.span(),
15850 Self::PostfixUnaryExpression(inner) => inner.span(),
15851 Self::PrefixUnaryExpression(inner) => inner.span(),
15852 }
15853 }
15854}
15855#[derive(Debug, Clone, PartialEq, Eq)]
15856pub enum FieldDeclarationChildren<'tree> {
15857 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15858 Modifier(::std::boxed::Box<Modifier<'tree>>),
15859 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15860}
15861impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
15862 #[allow(clippy::collapsible_else_if)]
15863 fn from_node(
15864 node: ::treesitter_types::tree_sitter::Node<'tree>,
15865 src: &'tree [u8],
15866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15867 match node.kind() {
15868 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15869 ::treesitter_types::runtime::maybe_grow_stack(|| {
15870 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15871 })?,
15872 ))),
15873 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15874 ::treesitter_types::runtime::maybe_grow_stack(|| {
15875 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15876 })?,
15877 ))),
15878 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15879 ::treesitter_types::runtime::maybe_grow_stack(|| {
15880 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15881 })?,
15882 ))),
15883 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15884 }
15885 }
15886}
15887impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
15888 fn span(&self) -> ::treesitter_types::Span {
15889 match self {
15890 Self::AttributeList(inner) => inner.span(),
15891 Self::Modifier(inner) => inner.span(),
15892 Self::VariableDeclaration(inner) => inner.span(),
15893 }
15894 }
15895}
15896#[derive(Debug, Clone, PartialEq, Eq)]
15897pub enum FileScopedNamespaceDeclarationName<'tree> {
15898 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15899 GenericName(::std::boxed::Box<GenericName<'tree>>),
15900 Identifier(::std::boxed::Box<Identifier<'tree>>),
15901 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15902}
15903impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclarationName<'tree> {
15904 #[allow(clippy::collapsible_else_if)]
15905 fn from_node(
15906 node: ::treesitter_types::tree_sitter::Node<'tree>,
15907 src: &'tree [u8],
15908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15909 match node.kind() {
15910 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15911 ::treesitter_types::runtime::maybe_grow_stack(|| {
15912 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15913 })?,
15914 ))),
15915 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15916 ::treesitter_types::runtime::maybe_grow_stack(|| {
15917 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
15918 })?,
15919 ))),
15920 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15921 ::treesitter_types::runtime::maybe_grow_stack(|| {
15922 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15923 })?,
15924 ))),
15925 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15926 ::treesitter_types::runtime::maybe_grow_stack(|| {
15927 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15928 })?,
15929 ))),
15930 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15931 }
15932 }
15933}
15934impl ::treesitter_types::Spanned for FileScopedNamespaceDeclarationName<'_> {
15935 fn span(&self) -> ::treesitter_types::Span {
15936 match self {
15937 Self::AliasQualifiedName(inner) => inner.span(),
15938 Self::GenericName(inner) => inner.span(),
15939 Self::Identifier(inner) => inner.span(),
15940 Self::QualifiedName(inner) => inner.span(),
15941 }
15942 }
15943}
15944#[derive(Debug, Clone, PartialEq, Eq)]
15945pub enum FixedStatementChildren<'tree> {
15946 Statement(::std::boxed::Box<Statement<'tree>>),
15947 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15948}
15949impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatementChildren<'tree> {
15950 #[allow(clippy::collapsible_else_if)]
15951 fn from_node(
15952 node: ::treesitter_types::tree_sitter::Node<'tree>,
15953 src: &'tree [u8],
15954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15955 match node.kind() {
15956 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15957 ::treesitter_types::runtime::maybe_grow_stack(|| {
15958 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15959 })?,
15960 ))),
15961 _other => {
15962 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15963 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
15964 }) {
15965 Ok(Self::Statement(::std::boxed::Box::new(v)))
15966 } else {
15967 Err(::treesitter_types::ParseError::unexpected_kind(
15968 _other, node,
15969 ))
15970 }
15971 }
15972 }
15973 }
15974}
15975impl ::treesitter_types::Spanned for FixedStatementChildren<'_> {
15976 fn span(&self) -> ::treesitter_types::Span {
15977 match self {
15978 Self::Statement(inner) => inner.span(),
15979 Self::VariableDeclaration(inner) => inner.span(),
15980 }
15981 }
15982}
15983#[derive(Debug, Clone, PartialEq, Eq)]
15984pub enum ForStatementInitializer<'tree> {
15985 Comma(::treesitter_types::Span),
15986 Expression(::std::boxed::Box<Expression<'tree>>),
15987 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
15988}
15989impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
15990 #[allow(clippy::collapsible_else_if)]
15991 fn from_node(
15992 node: ::treesitter_types::tree_sitter::Node<'tree>,
15993 src: &'tree [u8],
15994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15995 match node.kind() {
15996 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
15997 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
15998 ::treesitter_types::runtime::maybe_grow_stack(|| {
15999 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16000 })?,
16001 ))),
16002 _other => {
16003 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16004 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16005 }) {
16006 Ok(Self::Expression(::std::boxed::Box::new(v)))
16007 } else {
16008 Err(::treesitter_types::ParseError::unexpected_kind(
16009 _other, node,
16010 ))
16011 }
16012 }
16013 }
16014 }
16015}
16016impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
16017 fn span(&self) -> ::treesitter_types::Span {
16018 match self {
16019 Self::Comma(span) => *span,
16020 Self::Expression(inner) => inner.span(),
16021 Self::VariableDeclaration(inner) => inner.span(),
16022 }
16023 }
16024}
16025#[derive(Debug, Clone, PartialEq, Eq)]
16026pub enum ForStatementUpdate<'tree> {
16027 Comma(::treesitter_types::Span),
16028 Expression(::std::boxed::Box<Expression<'tree>>),
16029}
16030impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
16031 #[allow(clippy::collapsible_else_if)]
16032 fn from_node(
16033 node: ::treesitter_types::tree_sitter::Node<'tree>,
16034 src: &'tree [u8],
16035 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16036 match node.kind() {
16037 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
16038 _other => {
16039 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16040 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16041 }) {
16042 Ok(Self::Expression(::std::boxed::Box::new(v)))
16043 } else {
16044 Err(::treesitter_types::ParseError::unexpected_kind(
16045 _other, node,
16046 ))
16047 }
16048 }
16049 }
16050 }
16051}
16052impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
16053 fn span(&self) -> ::treesitter_types::Span {
16054 match self {
16055 Self::Comma(span) => *span,
16056 Self::Expression(inner) => inner.span(),
16057 }
16058 }
16059}
16060#[derive(Debug, Clone, PartialEq, Eq)]
16061pub enum ForeachStatementLeft<'tree> {
16062 Expression(::std::boxed::Box<Expression<'tree>>),
16063 Identifier(::std::boxed::Box<Identifier<'tree>>),
16064 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
16065}
16066impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementLeft<'tree> {
16067 #[allow(clippy::collapsible_else_if)]
16068 fn from_node(
16069 node: ::treesitter_types::tree_sitter::Node<'tree>,
16070 src: &'tree [u8],
16071 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16072 match node.kind() {
16073 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16074 ::treesitter_types::runtime::maybe_grow_stack(|| {
16075 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16076 })?,
16077 ))),
16078 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
16079 ::treesitter_types::runtime::maybe_grow_stack(|| {
16080 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
16081 })?,
16082 ))),
16083 _other => {
16084 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16085 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16086 }) {
16087 Ok(Self::Expression(::std::boxed::Box::new(v)))
16088 } else {
16089 Err(::treesitter_types::ParseError::unexpected_kind(
16090 _other, node,
16091 ))
16092 }
16093 }
16094 }
16095 }
16096}
16097impl ::treesitter_types::Spanned for ForeachStatementLeft<'_> {
16098 fn span(&self) -> ::treesitter_types::Span {
16099 match self {
16100 Self::Expression(inner) => inner.span(),
16101 Self::Identifier(inner) => inner.span(),
16102 Self::TuplePattern(inner) => inner.span(),
16103 }
16104 }
16105}
16106#[derive(Debug, Clone, PartialEq, Eq)]
16107pub enum FunctionPointerParameterType<'tree> {
16108 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16109 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
16110 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
16111 GenericName(::std::boxed::Box<GenericName<'tree>>),
16112 Identifier(::std::boxed::Box<Identifier<'tree>>),
16113 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
16114 NullableType(::std::boxed::Box<NullableType<'tree>>),
16115 PointerType(::std::boxed::Box<PointerType<'tree>>),
16116 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16117 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16118 TupleType(::std::boxed::Box<TupleType<'tree>>),
16119}
16120impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameterType<'tree> {
16121 #[allow(clippy::collapsible_else_if)]
16122 fn from_node(
16123 node: ::treesitter_types::tree_sitter::Node<'tree>,
16124 src: &'tree [u8],
16125 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16126 match node.kind() {
16127 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16128 ::treesitter_types::runtime::maybe_grow_stack(|| {
16129 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16130 })?,
16131 ))),
16132 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
16133 ::treesitter_types::runtime::maybe_grow_stack(|| {
16134 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
16135 })?,
16136 ))),
16137 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
16138 ::treesitter_types::runtime::maybe_grow_stack(|| {
16139 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
16140 })?,
16141 ))),
16142 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16143 ::treesitter_types::runtime::maybe_grow_stack(|| {
16144 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16145 })?,
16146 ))),
16147 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16148 ::treesitter_types::runtime::maybe_grow_stack(|| {
16149 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16150 })?,
16151 ))),
16152 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
16153 ::treesitter_types::runtime::maybe_grow_stack(|| {
16154 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
16155 })?,
16156 ))),
16157 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
16158 ::treesitter_types::runtime::maybe_grow_stack(|| {
16159 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
16160 })?,
16161 ))),
16162 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
16163 ::treesitter_types::runtime::maybe_grow_stack(|| {
16164 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
16165 })?,
16166 ))),
16167 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16168 ::treesitter_types::runtime::maybe_grow_stack(|| {
16169 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
16170 })?,
16171 ))),
16172 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16173 ::treesitter_types::runtime::maybe_grow_stack(|| {
16174 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16175 })?,
16176 ))),
16177 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
16178 ::treesitter_types::runtime::maybe_grow_stack(|| {
16179 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
16180 })?,
16181 ))),
16182 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16183 }
16184 }
16185}
16186impl ::treesitter_types::Spanned for FunctionPointerParameterType<'_> {
16187 fn span(&self) -> ::treesitter_types::Span {
16188 match self {
16189 Self::AliasQualifiedName(inner) => inner.span(),
16190 Self::ArrayType(inner) => inner.span(),
16191 Self::FunctionPointerType(inner) => inner.span(),
16192 Self::GenericName(inner) => inner.span(),
16193 Self::Identifier(inner) => inner.span(),
16194 Self::ImplicitType(inner) => inner.span(),
16195 Self::NullableType(inner) => inner.span(),
16196 Self::PointerType(inner) => inner.span(),
16197 Self::PredefinedType(inner) => inner.span(),
16198 Self::QualifiedName(inner) => inner.span(),
16199 Self::TupleType(inner) => inner.span(),
16200 }
16201 }
16202}
16203#[derive(Debug, Clone, PartialEq, Eq)]
16204pub enum FunctionPointerTypeChildren<'tree> {
16205 CallingConvention(::std::boxed::Box<CallingConvention<'tree>>),
16206 FunctionPointerParameter(::std::boxed::Box<FunctionPointerParameter<'tree>>),
16207}
16208impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerTypeChildren<'tree> {
16209 #[allow(clippy::collapsible_else_if)]
16210 fn from_node(
16211 node: ::treesitter_types::tree_sitter::Node<'tree>,
16212 src: &'tree [u8],
16213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16214 match node.kind() {
16215 "calling_convention" => Ok(Self::CallingConvention(::std::boxed::Box::new(
16216 ::treesitter_types::runtime::maybe_grow_stack(|| {
16217 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
16218 })?,
16219 ))),
16220 "function_pointer_parameter" => Ok(Self::FunctionPointerParameter(
16221 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16222 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(node, src)
16223 })?),
16224 )),
16225 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16226 }
16227 }
16228}
16229impl ::treesitter_types::Spanned for FunctionPointerTypeChildren<'_> {
16230 fn span(&self) -> ::treesitter_types::Span {
16231 match self {
16232 Self::CallingConvention(inner) => inner.span(),
16233 Self::FunctionPointerParameter(inner) => inner.span(),
16234 }
16235 }
16236}
16237#[derive(Debug, Clone, PartialEq, Eq)]
16238pub enum GenericNameChildren<'tree> {
16239 Identifier(::std::boxed::Box<Identifier<'tree>>),
16240 TypeArgumentList(::std::boxed::Box<TypeArgumentList<'tree>>),
16241}
16242impl<'tree> ::treesitter_types::FromNode<'tree> for GenericNameChildren<'tree> {
16243 #[allow(clippy::collapsible_else_if)]
16244 fn from_node(
16245 node: ::treesitter_types::tree_sitter::Node<'tree>,
16246 src: &'tree [u8],
16247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16248 match node.kind() {
16249 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16250 ::treesitter_types::runtime::maybe_grow_stack(|| {
16251 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16252 })?,
16253 ))),
16254 "type_argument_list" => Ok(Self::TypeArgumentList(::std::boxed::Box::new(
16255 ::treesitter_types::runtime::maybe_grow_stack(|| {
16256 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16257 })?,
16258 ))),
16259 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16260 }
16261 }
16262}
16263impl ::treesitter_types::Spanned for GenericNameChildren<'_> {
16264 fn span(&self) -> ::treesitter_types::Span {
16265 match self {
16266 Self::Identifier(inner) => inner.span(),
16267 Self::TypeArgumentList(inner) => inner.span(),
16268 }
16269 }
16270}
16271#[derive(Debug, Clone, PartialEq, Eq)]
16272pub enum ImplicitObjectCreationExpressionChildren<'tree> {
16273 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
16274 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
16275}
16276impl<'tree> ::treesitter_types::FromNode<'tree>
16277 for ImplicitObjectCreationExpressionChildren<'tree>
16278{
16279 #[allow(clippy::collapsible_else_if)]
16280 fn from_node(
16281 node: ::treesitter_types::tree_sitter::Node<'tree>,
16282 src: &'tree [u8],
16283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16284 match node.kind() {
16285 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
16286 ::treesitter_types::runtime::maybe_grow_stack(|| {
16287 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16288 })?,
16289 ))),
16290 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
16291 ::treesitter_types::runtime::maybe_grow_stack(|| {
16292 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
16293 })?,
16294 ))),
16295 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16296 }
16297 }
16298}
16299impl ::treesitter_types::Spanned for ImplicitObjectCreationExpressionChildren<'_> {
16300 fn span(&self) -> ::treesitter_types::Span {
16301 match self {
16302 Self::ArgumentList(inner) => inner.span(),
16303 Self::InitializerExpression(inner) => inner.span(),
16304 }
16305 }
16306}
16307#[derive(Debug, Clone, PartialEq, Eq)]
16308pub enum IndexerDeclarationChildren<'tree> {
16309 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16310 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
16311 Modifier(::std::boxed::Box<Modifier<'tree>>),
16312}
16313impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclarationChildren<'tree> {
16314 #[allow(clippy::collapsible_else_if)]
16315 fn from_node(
16316 node: ::treesitter_types::tree_sitter::Node<'tree>,
16317 src: &'tree [u8],
16318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16319 match node.kind() {
16320 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16321 ::treesitter_types::runtime::maybe_grow_stack(|| {
16322 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16323 })?,
16324 ))),
16325 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
16326 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16327 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
16328 node, src,
16329 )
16330 })?),
16331 )),
16332 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16333 ::treesitter_types::runtime::maybe_grow_stack(|| {
16334 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16335 })?,
16336 ))),
16337 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16338 }
16339 }
16340}
16341impl ::treesitter_types::Spanned for IndexerDeclarationChildren<'_> {
16342 fn span(&self) -> ::treesitter_types::Span {
16343 match self {
16344 Self::AttributeList(inner) => inner.span(),
16345 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
16346 Self::Modifier(inner) => inner.span(),
16347 }
16348 }
16349}
16350#[derive(Debug, Clone, PartialEq, Eq)]
16351pub enum InterfaceDeclarationChildren<'tree> {
16352 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16353 BaseList(::std::boxed::Box<BaseList<'tree>>),
16354 Modifier(::std::boxed::Box<Modifier<'tree>>),
16355 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
16356}
16357impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
16358 #[allow(clippy::collapsible_else_if)]
16359 fn from_node(
16360 node: ::treesitter_types::tree_sitter::Node<'tree>,
16361 src: &'tree [u8],
16362 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16363 match node.kind() {
16364 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16365 ::treesitter_types::runtime::maybe_grow_stack(|| {
16366 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16367 })?,
16368 ))),
16369 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
16370 ::treesitter_types::runtime::maybe_grow_stack(|| {
16371 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
16372 })?,
16373 ))),
16374 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16375 ::treesitter_types::runtime::maybe_grow_stack(|| {
16376 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16377 })?,
16378 ))),
16379 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
16380 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16381 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
16382 node, src,
16383 )
16384 })?),
16385 )),
16386 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16387 }
16388 }
16389}
16390impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
16391 fn span(&self) -> ::treesitter_types::Span {
16392 match self {
16393 Self::AttributeList(inner) => inner.span(),
16394 Self::BaseList(inner) => inner.span(),
16395 Self::Modifier(inner) => inner.span(),
16396 Self::TypeParameterConstraintsClause(inner) => inner.span(),
16397 }
16398 }
16399}
16400#[derive(Debug, Clone, PartialEq, Eq)]
16401pub enum InterpolatedStringExpressionChildren<'tree> {
16402 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
16403 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
16404 InterpolationQuote(::std::boxed::Box<InterpolationQuote<'tree>>),
16405 InterpolationStart(::std::boxed::Box<InterpolationStart<'tree>>),
16406 StringContent(::std::boxed::Box<StringContent<'tree>>),
16407}
16408impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpressionChildren<'tree> {
16409 #[allow(clippy::collapsible_else_if)]
16410 fn from_node(
16411 node: ::treesitter_types::tree_sitter::Node<'tree>,
16412 src: &'tree [u8],
16413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16414 match node.kind() {
16415 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
16416 ::treesitter_types::runtime::maybe_grow_stack(|| {
16417 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
16418 })?,
16419 ))),
16420 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
16421 ::treesitter_types::runtime::maybe_grow_stack(|| {
16422 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
16423 })?,
16424 ))),
16425 "interpolation_quote" => Ok(Self::InterpolationQuote(::std::boxed::Box::new(
16426 ::treesitter_types::runtime::maybe_grow_stack(|| {
16427 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)
16428 })?,
16429 ))),
16430 "interpolation_start" => Ok(Self::InterpolationStart(::std::boxed::Box::new(
16431 ::treesitter_types::runtime::maybe_grow_stack(|| {
16432 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)
16433 })?,
16434 ))),
16435 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
16436 ::treesitter_types::runtime::maybe_grow_stack(|| {
16437 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
16438 })?,
16439 ))),
16440 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16441 }
16442 }
16443}
16444impl ::treesitter_types::Spanned for InterpolatedStringExpressionChildren<'_> {
16445 fn span(&self) -> ::treesitter_types::Span {
16446 match self {
16447 Self::EscapeSequence(inner) => inner.span(),
16448 Self::Interpolation(inner) => inner.span(),
16449 Self::InterpolationQuote(inner) => inner.span(),
16450 Self::InterpolationStart(inner) => inner.span(),
16451 Self::StringContent(inner) => inner.span(),
16452 }
16453 }
16454}
16455#[derive(Debug, Clone, PartialEq, Eq)]
16456pub enum InterpolationChildren<'tree> {
16457 Expression(::std::boxed::Box<Expression<'tree>>),
16458 InterpolationAlignmentClause(::std::boxed::Box<InterpolationAlignmentClause<'tree>>),
16459 InterpolationBrace(::std::boxed::Box<InterpolationBrace<'tree>>),
16460 InterpolationFormatClause(::std::boxed::Box<InterpolationFormatClause<'tree>>),
16461}
16462impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
16463 #[allow(clippy::collapsible_else_if)]
16464 fn from_node(
16465 node: ::treesitter_types::tree_sitter::Node<'tree>,
16466 src: &'tree [u8],
16467 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16468 match node.kind() {
16469 "interpolation_alignment_clause" => Ok(Self::InterpolationAlignmentClause(
16470 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16471 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(
16472 node, src,
16473 )
16474 })?),
16475 )),
16476 "interpolation_brace" => Ok(Self::InterpolationBrace(::std::boxed::Box::new(
16477 ::treesitter_types::runtime::maybe_grow_stack(|| {
16478 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)
16479 })?,
16480 ))),
16481 "interpolation_format_clause" => Ok(Self::InterpolationFormatClause(
16482 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16483 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(
16484 node, src,
16485 )
16486 })?),
16487 )),
16488 _other => {
16489 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16490 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16491 }) {
16492 Ok(Self::Expression(::std::boxed::Box::new(v)))
16493 } else {
16494 Err(::treesitter_types::ParseError::unexpected_kind(
16495 _other, node,
16496 ))
16497 }
16498 }
16499 }
16500 }
16501}
16502impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
16503 fn span(&self) -> ::treesitter_types::Span {
16504 match self {
16505 Self::Expression(inner) => inner.span(),
16506 Self::InterpolationAlignmentClause(inner) => inner.span(),
16507 Self::InterpolationBrace(inner) => inner.span(),
16508 Self::InterpolationFormatClause(inner) => inner.span(),
16509 }
16510 }
16511}
16512#[derive(Debug, Clone, PartialEq, Eq)]
16513pub enum IsExpressionOperator {
16514 Is(::treesitter_types::Span),
16515}
16516impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpressionOperator {
16517 #[allow(clippy::collapsible_else_if)]
16518 fn from_node(
16519 node: ::treesitter_types::tree_sitter::Node<'tree>,
16520 _src: &'tree [u8],
16521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16522 match node.kind() {
16523 "is" => Ok(Self::Is(::treesitter_types::Span::from(node))),
16524 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16525 }
16526 }
16527}
16528impl ::treesitter_types::Spanned for IsExpressionOperator {
16529 fn span(&self) -> ::treesitter_types::Span {
16530 match self {
16531 Self::Is(span) => *span,
16532 }
16533 }
16534}
16535#[derive(Debug, Clone, PartialEq, Eq)]
16536pub enum JoinClauseChildren<'tree> {
16537 Expression(::std::boxed::Box<Expression<'tree>>),
16538 Identifier(::std::boxed::Box<Identifier<'tree>>),
16539 JoinIntoClause(::std::boxed::Box<JoinIntoClause<'tree>>),
16540}
16541impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClauseChildren<'tree> {
16542 #[allow(clippy::collapsible_else_if)]
16543 fn from_node(
16544 node: ::treesitter_types::tree_sitter::Node<'tree>,
16545 src: &'tree [u8],
16546 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16547 match node.kind() {
16548 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16549 ::treesitter_types::runtime::maybe_grow_stack(|| {
16550 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16551 })?,
16552 ))),
16553 "join_into_clause" => Ok(Self::JoinIntoClause(::std::boxed::Box::new(
16554 ::treesitter_types::runtime::maybe_grow_stack(|| {
16555 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)
16556 })?,
16557 ))),
16558 _other => {
16559 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16560 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16561 }) {
16562 Ok(Self::Expression(::std::boxed::Box::new(v)))
16563 } else {
16564 Err(::treesitter_types::ParseError::unexpected_kind(
16565 _other, node,
16566 ))
16567 }
16568 }
16569 }
16570 }
16571}
16572impl ::treesitter_types::Spanned for JoinClauseChildren<'_> {
16573 fn span(&self) -> ::treesitter_types::Span {
16574 match self {
16575 Self::Expression(inner) => inner.span(),
16576 Self::Identifier(inner) => inner.span(),
16577 Self::JoinIntoClause(inner) => inner.span(),
16578 }
16579 }
16580}
16581#[derive(Debug, Clone, PartialEq, Eq)]
16582pub enum LabeledStatementChildren<'tree> {
16583 Identifier(::std::boxed::Box<Identifier<'tree>>),
16584 Statement(::std::boxed::Box<Statement<'tree>>),
16585}
16586impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
16587 #[allow(clippy::collapsible_else_if)]
16588 fn from_node(
16589 node: ::treesitter_types::tree_sitter::Node<'tree>,
16590 src: &'tree [u8],
16591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16592 match node.kind() {
16593 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16594 ::treesitter_types::runtime::maybe_grow_stack(|| {
16595 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16596 })?,
16597 ))),
16598 _other => {
16599 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16600 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16601 }) {
16602 Ok(Self::Statement(::std::boxed::Box::new(v)))
16603 } else {
16604 Err(::treesitter_types::ParseError::unexpected_kind(
16605 _other, node,
16606 ))
16607 }
16608 }
16609 }
16610 }
16611}
16612impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
16613 fn span(&self) -> ::treesitter_types::Span {
16614 match self {
16615 Self::Identifier(inner) => inner.span(),
16616 Self::Statement(inner) => inner.span(),
16617 }
16618 }
16619}
16620#[derive(Debug, Clone, PartialEq, Eq)]
16621pub enum LambdaExpressionBody<'tree> {
16622 Block(::std::boxed::Box<Block<'tree>>),
16623 Expression(::std::boxed::Box<Expression<'tree>>),
16624}
16625impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
16626 #[allow(clippy::collapsible_else_if)]
16627 fn from_node(
16628 node: ::treesitter_types::tree_sitter::Node<'tree>,
16629 src: &'tree [u8],
16630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16631 match node.kind() {
16632 "block" => Ok(Self::Block(::std::boxed::Box::new(
16633 ::treesitter_types::runtime::maybe_grow_stack(|| {
16634 <Block as ::treesitter_types::FromNode>::from_node(node, src)
16635 })?,
16636 ))),
16637 _other => {
16638 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16639 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16640 }) {
16641 Ok(Self::Expression(::std::boxed::Box::new(v)))
16642 } else {
16643 Err(::treesitter_types::ParseError::unexpected_kind(
16644 _other, node,
16645 ))
16646 }
16647 }
16648 }
16649 }
16650}
16651impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
16652 fn span(&self) -> ::treesitter_types::Span {
16653 match self {
16654 Self::Block(inner) => inner.span(),
16655 Self::Expression(inner) => inner.span(),
16656 }
16657 }
16658}
16659#[derive(Debug, Clone, PartialEq, Eq)]
16660pub enum LambdaExpressionParameters<'tree> {
16661 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
16662 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
16663}
16664impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
16665 #[allow(clippy::collapsible_else_if)]
16666 fn from_node(
16667 node: ::treesitter_types::tree_sitter::Node<'tree>,
16668 src: &'tree [u8],
16669 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16670 match node.kind() {
16671 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
16672 ::treesitter_types::runtime::maybe_grow_stack(|| {
16673 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
16674 })?,
16675 ))),
16676 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
16677 ::treesitter_types::runtime::maybe_grow_stack(|| {
16678 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
16679 })?,
16680 ))),
16681 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16682 }
16683 }
16684}
16685impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
16686 fn span(&self) -> ::treesitter_types::Span {
16687 match self {
16688 Self::ImplicitParameter(inner) => inner.span(),
16689 Self::ParameterList(inner) => inner.span(),
16690 }
16691 }
16692}
16693#[derive(Debug, Clone, PartialEq, Eq)]
16694pub enum LambdaExpressionChildren<'tree> {
16695 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16696 Modifier(::std::boxed::Box<Modifier<'tree>>),
16697}
16698impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionChildren<'tree> {
16699 #[allow(clippy::collapsible_else_if)]
16700 fn from_node(
16701 node: ::treesitter_types::tree_sitter::Node<'tree>,
16702 src: &'tree [u8],
16703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16704 match node.kind() {
16705 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16706 ::treesitter_types::runtime::maybe_grow_stack(|| {
16707 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16708 })?,
16709 ))),
16710 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16711 ::treesitter_types::runtime::maybe_grow_stack(|| {
16712 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16713 })?,
16714 ))),
16715 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16716 }
16717 }
16718}
16719impl ::treesitter_types::Spanned for LambdaExpressionChildren<'_> {
16720 fn span(&self) -> ::treesitter_types::Span {
16721 match self {
16722 Self::AttributeList(inner) => inner.span(),
16723 Self::Modifier(inner) => inner.span(),
16724 }
16725 }
16726}
16727#[derive(Debug, Clone, PartialEq, Eq)]
16728pub enum LetClauseChildren<'tree> {
16729 Expression(::std::boxed::Box<Expression<'tree>>),
16730 Identifier(::std::boxed::Box<Identifier<'tree>>),
16731}
16732impl<'tree> ::treesitter_types::FromNode<'tree> for LetClauseChildren<'tree> {
16733 #[allow(clippy::collapsible_else_if)]
16734 fn from_node(
16735 node: ::treesitter_types::tree_sitter::Node<'tree>,
16736 src: &'tree [u8],
16737 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16738 match node.kind() {
16739 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16740 ::treesitter_types::runtime::maybe_grow_stack(|| {
16741 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16742 })?,
16743 ))),
16744 _other => {
16745 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16746 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16747 }) {
16748 Ok(Self::Expression(::std::boxed::Box::new(v)))
16749 } else {
16750 Err(::treesitter_types::ParseError::unexpected_kind(
16751 _other, node,
16752 ))
16753 }
16754 }
16755 }
16756 }
16757}
16758impl ::treesitter_types::Spanned for LetClauseChildren<'_> {
16759 fn span(&self) -> ::treesitter_types::Span {
16760 match self {
16761 Self::Expression(inner) => inner.span(),
16762 Self::Identifier(inner) => inner.span(),
16763 }
16764 }
16765}
16766#[derive(Debug, Clone, PartialEq, Eq)]
16767pub enum LocalDeclarationStatementChildren<'tree> {
16768 Modifier(::std::boxed::Box<Modifier<'tree>>),
16769 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
16770}
16771impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatementChildren<'tree> {
16772 #[allow(clippy::collapsible_else_if)]
16773 fn from_node(
16774 node: ::treesitter_types::tree_sitter::Node<'tree>,
16775 src: &'tree [u8],
16776 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16777 match node.kind() {
16778 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16779 ::treesitter_types::runtime::maybe_grow_stack(|| {
16780 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16781 })?,
16782 ))),
16783 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
16784 ::treesitter_types::runtime::maybe_grow_stack(|| {
16785 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16786 })?,
16787 ))),
16788 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16789 }
16790 }
16791}
16792impl ::treesitter_types::Spanned for LocalDeclarationStatementChildren<'_> {
16793 fn span(&self) -> ::treesitter_types::Span {
16794 match self {
16795 Self::Modifier(inner) => inner.span(),
16796 Self::VariableDeclaration(inner) => inner.span(),
16797 }
16798 }
16799}
16800#[derive(Debug, Clone, PartialEq, Eq)]
16801pub enum LocalFunctionStatementBody<'tree> {
16802 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
16803 Block(::std::boxed::Box<Block<'tree>>),
16804}
16805impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementBody<'tree> {
16806 #[allow(clippy::collapsible_else_if)]
16807 fn from_node(
16808 node: ::treesitter_types::tree_sitter::Node<'tree>,
16809 src: &'tree [u8],
16810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16811 match node.kind() {
16812 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
16813 ::treesitter_types::runtime::maybe_grow_stack(|| {
16814 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
16815 })?,
16816 ))),
16817 "block" => Ok(Self::Block(::std::boxed::Box::new(
16818 ::treesitter_types::runtime::maybe_grow_stack(|| {
16819 <Block as ::treesitter_types::FromNode>::from_node(node, src)
16820 })?,
16821 ))),
16822 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16823 }
16824 }
16825}
16826impl ::treesitter_types::Spanned for LocalFunctionStatementBody<'_> {
16827 fn span(&self) -> ::treesitter_types::Span {
16828 match self {
16829 Self::ArrowExpressionClause(inner) => inner.span(),
16830 Self::Block(inner) => inner.span(),
16831 }
16832 }
16833}
16834#[derive(Debug, Clone, PartialEq, Eq)]
16835pub enum LocalFunctionStatementChildren<'tree> {
16836 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16837 Modifier(::std::boxed::Box<Modifier<'tree>>),
16838 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
16839}
16840impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementChildren<'tree> {
16841 #[allow(clippy::collapsible_else_if)]
16842 fn from_node(
16843 node: ::treesitter_types::tree_sitter::Node<'tree>,
16844 src: &'tree [u8],
16845 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16846 match node.kind() {
16847 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16848 ::treesitter_types::runtime::maybe_grow_stack(|| {
16849 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16850 })?,
16851 ))),
16852 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16853 ::treesitter_types::runtime::maybe_grow_stack(|| {
16854 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16855 })?,
16856 ))),
16857 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
16858 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16859 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
16860 node, src,
16861 )
16862 })?),
16863 )),
16864 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16865 }
16866 }
16867}
16868impl ::treesitter_types::Spanned for LocalFunctionStatementChildren<'_> {
16869 fn span(&self) -> ::treesitter_types::Span {
16870 match self {
16871 Self::AttributeList(inner) => inner.span(),
16872 Self::Modifier(inner) => inner.span(),
16873 Self::TypeParameterConstraintsClause(inner) => inner.span(),
16874 }
16875 }
16876}
16877#[derive(Debug, Clone, PartialEq, Eq)]
16878pub enum LockStatementChildren<'tree> {
16879 Expression(::std::boxed::Box<Expression<'tree>>),
16880 Statement(::std::boxed::Box<Statement<'tree>>),
16881}
16882impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatementChildren<'tree> {
16883 #[allow(clippy::collapsible_else_if)]
16884 fn from_node(
16885 node: ::treesitter_types::tree_sitter::Node<'tree>,
16886 src: &'tree [u8],
16887 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16888 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16889 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16890 }) {
16891 Ok(Self::Expression(::std::boxed::Box::new(v)))
16892 } else {
16893 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16894 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16895 }) {
16896 Ok(Self::Statement(::std::boxed::Box::new(v)))
16897 } else {
16898 Err(::treesitter_types::ParseError::unexpected_kind(
16899 node.kind(),
16900 node,
16901 ))
16902 }
16903 }
16904 }
16905}
16906impl ::treesitter_types::Spanned for LockStatementChildren<'_> {
16907 fn span(&self) -> ::treesitter_types::Span {
16908 match self {
16909 Self::Expression(inner) => inner.span(),
16910 Self::Statement(inner) => inner.span(),
16911 }
16912 }
16913}
16914#[derive(Debug, Clone, PartialEq, Eq)]
16915pub enum MemberAccessExpressionExpression<'tree> {
16916 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16917 Expression(::std::boxed::Box<Expression<'tree>>),
16918 GenericName(::std::boxed::Box<GenericName<'tree>>),
16919 Identifier(::std::boxed::Box<Identifier<'tree>>),
16920 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16921 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16922}
16923impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionExpression<'tree> {
16924 #[allow(clippy::collapsible_else_if)]
16925 fn from_node(
16926 node: ::treesitter_types::tree_sitter::Node<'tree>,
16927 src: &'tree [u8],
16928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16929 match node.kind() {
16930 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16931 ::treesitter_types::runtime::maybe_grow_stack(|| {
16932 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16933 })?,
16934 ))),
16935 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16936 ::treesitter_types::runtime::maybe_grow_stack(|| {
16937 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16938 })?,
16939 ))),
16940 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16941 ::treesitter_types::runtime::maybe_grow_stack(|| {
16942 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16943 })?,
16944 ))),
16945 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16946 ::treesitter_types::runtime::maybe_grow_stack(|| {
16947 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
16948 })?,
16949 ))),
16950 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16951 ::treesitter_types::runtime::maybe_grow_stack(|| {
16952 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16953 })?,
16954 ))),
16955 _other => {
16956 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16957 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16958 }) {
16959 Ok(Self::Expression(::std::boxed::Box::new(v)))
16960 } else {
16961 Err(::treesitter_types::ParseError::unexpected_kind(
16962 _other, node,
16963 ))
16964 }
16965 }
16966 }
16967 }
16968}
16969impl ::treesitter_types::Spanned for MemberAccessExpressionExpression<'_> {
16970 fn span(&self) -> ::treesitter_types::Span {
16971 match self {
16972 Self::AliasQualifiedName(inner) => inner.span(),
16973 Self::Expression(inner) => inner.span(),
16974 Self::GenericName(inner) => inner.span(),
16975 Self::Identifier(inner) => inner.span(),
16976 Self::PredefinedType(inner) => inner.span(),
16977 Self::QualifiedName(inner) => inner.span(),
16978 }
16979 }
16980}
16981#[derive(Debug, Clone, PartialEq, Eq)]
16982pub enum MemberAccessExpressionName<'tree> {
16983 GenericName(::std::boxed::Box<GenericName<'tree>>),
16984 Identifier(::std::boxed::Box<Identifier<'tree>>),
16985}
16986impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionName<'tree> {
16987 #[allow(clippy::collapsible_else_if)]
16988 fn from_node(
16989 node: ::treesitter_types::tree_sitter::Node<'tree>,
16990 src: &'tree [u8],
16991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16992 match node.kind() {
16993 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16994 ::treesitter_types::runtime::maybe_grow_stack(|| {
16995 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16996 })?,
16997 ))),
16998 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16999 ::treesitter_types::runtime::maybe_grow_stack(|| {
17000 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17001 })?,
17002 ))),
17003 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17004 }
17005 }
17006}
17007impl ::treesitter_types::Spanned for MemberAccessExpressionName<'_> {
17008 fn span(&self) -> ::treesitter_types::Span {
17009 match self {
17010 Self::GenericName(inner) => inner.span(),
17011 Self::Identifier(inner) => inner.span(),
17012 }
17013 }
17014}
17015#[derive(Debug, Clone, PartialEq, Eq)]
17016pub enum MemberBindingExpressionName<'tree> {
17017 GenericName(::std::boxed::Box<GenericName<'tree>>),
17018 Identifier(::std::boxed::Box<Identifier<'tree>>),
17019}
17020impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpressionName<'tree> {
17021 #[allow(clippy::collapsible_else_if)]
17022 fn from_node(
17023 node: ::treesitter_types::tree_sitter::Node<'tree>,
17024 src: &'tree [u8],
17025 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17026 match node.kind() {
17027 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17028 ::treesitter_types::runtime::maybe_grow_stack(|| {
17029 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17030 })?,
17031 ))),
17032 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17033 ::treesitter_types::runtime::maybe_grow_stack(|| {
17034 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17035 })?,
17036 ))),
17037 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17038 }
17039 }
17040}
17041impl ::treesitter_types::Spanned for MemberBindingExpressionName<'_> {
17042 fn span(&self) -> ::treesitter_types::Span {
17043 match self {
17044 Self::GenericName(inner) => inner.span(),
17045 Self::Identifier(inner) => inner.span(),
17046 }
17047 }
17048}
17049#[derive(Debug, Clone, PartialEq, Eq)]
17050pub enum MethodDeclarationBody<'tree> {
17051 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
17052 Block(::std::boxed::Box<Block<'tree>>),
17053}
17054impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationBody<'tree> {
17055 #[allow(clippy::collapsible_else_if)]
17056 fn from_node(
17057 node: ::treesitter_types::tree_sitter::Node<'tree>,
17058 src: &'tree [u8],
17059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17060 match node.kind() {
17061 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
17062 ::treesitter_types::runtime::maybe_grow_stack(|| {
17063 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
17064 })?,
17065 ))),
17066 "block" => Ok(Self::Block(::std::boxed::Box::new(
17067 ::treesitter_types::runtime::maybe_grow_stack(|| {
17068 <Block as ::treesitter_types::FromNode>::from_node(node, src)
17069 })?,
17070 ))),
17071 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17072 }
17073 }
17074}
17075impl ::treesitter_types::Spanned for MethodDeclarationBody<'_> {
17076 fn span(&self) -> ::treesitter_types::Span {
17077 match self {
17078 Self::ArrowExpressionClause(inner) => inner.span(),
17079 Self::Block(inner) => inner.span(),
17080 }
17081 }
17082}
17083#[derive(Debug, Clone, PartialEq, Eq)]
17084pub enum MethodDeclarationChildren<'tree> {
17085 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17086 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
17087 Modifier(::std::boxed::Box<Modifier<'tree>>),
17088 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17089}
17090impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
17091 #[allow(clippy::collapsible_else_if)]
17092 fn from_node(
17093 node: ::treesitter_types::tree_sitter::Node<'tree>,
17094 src: &'tree [u8],
17095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17096 match node.kind() {
17097 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17098 ::treesitter_types::runtime::maybe_grow_stack(|| {
17099 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17100 })?,
17101 ))),
17102 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
17103 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17104 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
17105 node, src,
17106 )
17107 })?),
17108 )),
17109 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17110 ::treesitter_types::runtime::maybe_grow_stack(|| {
17111 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17112 })?,
17113 ))),
17114 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17115 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17116 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17117 node, src,
17118 )
17119 })?),
17120 )),
17121 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17122 }
17123 }
17124}
17125impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
17126 fn span(&self) -> ::treesitter_types::Span {
17127 match self {
17128 Self::AttributeList(inner) => inner.span(),
17129 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
17130 Self::Modifier(inner) => inner.span(),
17131 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17132 }
17133 }
17134}
17135#[derive(Debug, Clone, PartialEq, Eq)]
17136pub enum NamespaceDeclarationName<'tree> {
17137 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17138 GenericName(::std::boxed::Box<GenericName<'tree>>),
17139 Identifier(::std::boxed::Box<Identifier<'tree>>),
17140 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17141}
17142impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclarationName<'tree> {
17143 #[allow(clippy::collapsible_else_if)]
17144 fn from_node(
17145 node: ::treesitter_types::tree_sitter::Node<'tree>,
17146 src: &'tree [u8],
17147 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17148 match node.kind() {
17149 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17150 ::treesitter_types::runtime::maybe_grow_stack(|| {
17151 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17152 })?,
17153 ))),
17154 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17155 ::treesitter_types::runtime::maybe_grow_stack(|| {
17156 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17157 })?,
17158 ))),
17159 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17160 ::treesitter_types::runtime::maybe_grow_stack(|| {
17161 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17162 })?,
17163 ))),
17164 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17165 ::treesitter_types::runtime::maybe_grow_stack(|| {
17166 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17167 })?,
17168 ))),
17169 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17170 }
17171 }
17172}
17173impl ::treesitter_types::Spanned for NamespaceDeclarationName<'_> {
17174 fn span(&self) -> ::treesitter_types::Span {
17175 match self {
17176 Self::AliasQualifiedName(inner) => inner.span(),
17177 Self::GenericName(inner) => inner.span(),
17178 Self::Identifier(inner) => inner.span(),
17179 Self::QualifiedName(inner) => inner.span(),
17180 }
17181 }
17182}
17183#[derive(Debug, Clone, PartialEq, Eq)]
17184pub enum NullableTypeType<'tree> {
17185 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17186 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
17187 GenericName(::std::boxed::Box<GenericName<'tree>>),
17188 Identifier(::std::boxed::Box<Identifier<'tree>>),
17189 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
17190 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17191 TupleType(::std::boxed::Box<TupleType<'tree>>),
17192}
17193impl<'tree> ::treesitter_types::FromNode<'tree> for NullableTypeType<'tree> {
17194 #[allow(clippy::collapsible_else_if)]
17195 fn from_node(
17196 node: ::treesitter_types::tree_sitter::Node<'tree>,
17197 src: &'tree [u8],
17198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17199 match node.kind() {
17200 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17201 ::treesitter_types::runtime::maybe_grow_stack(|| {
17202 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17203 })?,
17204 ))),
17205 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
17206 ::treesitter_types::runtime::maybe_grow_stack(|| {
17207 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
17208 })?,
17209 ))),
17210 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17211 ::treesitter_types::runtime::maybe_grow_stack(|| {
17212 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17213 })?,
17214 ))),
17215 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17216 ::treesitter_types::runtime::maybe_grow_stack(|| {
17217 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17218 })?,
17219 ))),
17220 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
17221 ::treesitter_types::runtime::maybe_grow_stack(|| {
17222 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
17223 })?,
17224 ))),
17225 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17226 ::treesitter_types::runtime::maybe_grow_stack(|| {
17227 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17228 })?,
17229 ))),
17230 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
17231 ::treesitter_types::runtime::maybe_grow_stack(|| {
17232 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
17233 })?,
17234 ))),
17235 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17236 }
17237 }
17238}
17239impl ::treesitter_types::Spanned for NullableTypeType<'_> {
17240 fn span(&self) -> ::treesitter_types::Span {
17241 match self {
17242 Self::AliasQualifiedName(inner) => inner.span(),
17243 Self::ArrayType(inner) => inner.span(),
17244 Self::GenericName(inner) => inner.span(),
17245 Self::Identifier(inner) => inner.span(),
17246 Self::PredefinedType(inner) => inner.span(),
17247 Self::QualifiedName(inner) => inner.span(),
17248 Self::TupleType(inner) => inner.span(),
17249 }
17250 }
17251}
17252#[derive(Debug, Clone, PartialEq, Eq)]
17253pub enum OperatorDeclarationBody<'tree> {
17254 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
17255 Block(::std::boxed::Box<Block<'tree>>),
17256}
17257impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationBody<'tree> {
17258 #[allow(clippy::collapsible_else_if)]
17259 fn from_node(
17260 node: ::treesitter_types::tree_sitter::Node<'tree>,
17261 src: &'tree [u8],
17262 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17263 match node.kind() {
17264 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
17265 ::treesitter_types::runtime::maybe_grow_stack(|| {
17266 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
17267 })?,
17268 ))),
17269 "block" => Ok(Self::Block(::std::boxed::Box::new(
17270 ::treesitter_types::runtime::maybe_grow_stack(|| {
17271 <Block as ::treesitter_types::FromNode>::from_node(node, src)
17272 })?,
17273 ))),
17274 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17275 }
17276 }
17277}
17278impl ::treesitter_types::Spanned for OperatorDeclarationBody<'_> {
17279 fn span(&self) -> ::treesitter_types::Span {
17280 match self {
17281 Self::ArrowExpressionClause(inner) => inner.span(),
17282 Self::Block(inner) => inner.span(),
17283 }
17284 }
17285}
17286#[derive(Debug, Clone, PartialEq, Eq)]
17287pub enum OperatorDeclarationOperator {
17288 Bang(::treesitter_types::Span),
17289 NotEq(::treesitter_types::Span),
17290 Percent(::treesitter_types::Span),
17291 Amp(::treesitter_types::Span),
17292 Star(::treesitter_types::Span),
17293 Plus(::treesitter_types::Span),
17294 PlusPlus(::treesitter_types::Span),
17295 Minus(::treesitter_types::Span),
17296 MinusMinus(::treesitter_types::Span),
17297 Slash(::treesitter_types::Span),
17298 Lt(::treesitter_types::Span),
17299 Shl(::treesitter_types::Span),
17300 LtEq(::treesitter_types::Span),
17301 EqEq(::treesitter_types::Span),
17302 Gt(::treesitter_types::Span),
17303 GtEq(::treesitter_types::Span),
17304 Shr(::treesitter_types::Span),
17305 GtGtGt(::treesitter_types::Span),
17306 Caret(::treesitter_types::Span),
17307 False(::treesitter_types::Span),
17308 True(::treesitter_types::Span),
17309 Pipe(::treesitter_types::Span),
17310 Tilde(::treesitter_types::Span),
17311}
17312impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationOperator {
17313 #[allow(clippy::collapsible_else_if)]
17314 fn from_node(
17315 node: ::treesitter_types::tree_sitter::Node<'tree>,
17316 _src: &'tree [u8],
17317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17318 match node.kind() {
17319 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
17320 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
17321 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
17322 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
17323 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
17324 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
17325 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
17326 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
17327 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
17328 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
17329 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
17330 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
17331 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
17332 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
17333 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
17334 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
17335 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
17336 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
17337 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
17338 "false" => Ok(Self::False(::treesitter_types::Span::from(node))),
17339 "true" => Ok(Self::True(::treesitter_types::Span::from(node))),
17340 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
17341 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
17342 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17343 }
17344 }
17345}
17346impl ::treesitter_types::Spanned for OperatorDeclarationOperator {
17347 fn span(&self) -> ::treesitter_types::Span {
17348 match self {
17349 Self::Bang(span) => *span,
17350 Self::NotEq(span) => *span,
17351 Self::Percent(span) => *span,
17352 Self::Amp(span) => *span,
17353 Self::Star(span) => *span,
17354 Self::Plus(span) => *span,
17355 Self::PlusPlus(span) => *span,
17356 Self::Minus(span) => *span,
17357 Self::MinusMinus(span) => *span,
17358 Self::Slash(span) => *span,
17359 Self::Lt(span) => *span,
17360 Self::Shl(span) => *span,
17361 Self::LtEq(span) => *span,
17362 Self::EqEq(span) => *span,
17363 Self::Gt(span) => *span,
17364 Self::GtEq(span) => *span,
17365 Self::Shr(span) => *span,
17366 Self::GtGtGt(span) => *span,
17367 Self::Caret(span) => *span,
17368 Self::False(span) => *span,
17369 Self::True(span) => *span,
17370 Self::Pipe(span) => *span,
17371 Self::Tilde(span) => *span,
17372 }
17373 }
17374}
17375#[derive(Debug, Clone, PartialEq, Eq)]
17376pub enum OperatorDeclarationChildren<'tree> {
17377 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17378 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
17379 Modifier(::std::boxed::Box<Modifier<'tree>>),
17380}
17381impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationChildren<'tree> {
17382 #[allow(clippy::collapsible_else_if)]
17383 fn from_node(
17384 node: ::treesitter_types::tree_sitter::Node<'tree>,
17385 src: &'tree [u8],
17386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17387 match node.kind() {
17388 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17389 ::treesitter_types::runtime::maybe_grow_stack(|| {
17390 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17391 })?,
17392 ))),
17393 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
17394 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17395 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
17396 node, src,
17397 )
17398 })?),
17399 )),
17400 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17401 ::treesitter_types::runtime::maybe_grow_stack(|| {
17402 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17403 })?,
17404 ))),
17405 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17406 }
17407 }
17408}
17409impl ::treesitter_types::Spanned for OperatorDeclarationChildren<'_> {
17410 fn span(&self) -> ::treesitter_types::Span {
17411 match self {
17412 Self::AttributeList(inner) => inner.span(),
17413 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
17414 Self::Modifier(inner) => inner.span(),
17415 }
17416 }
17417}
17418#[derive(Debug, Clone, PartialEq, Eq)]
17419pub enum OrPatternOperator {
17420 Or(::treesitter_types::Span),
17421}
17422impl<'tree> ::treesitter_types::FromNode<'tree> for OrPatternOperator {
17423 #[allow(clippy::collapsible_else_if)]
17424 fn from_node(
17425 node: ::treesitter_types::tree_sitter::Node<'tree>,
17426 _src: &'tree [u8],
17427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17428 match node.kind() {
17429 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
17430 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17431 }
17432 }
17433}
17434impl ::treesitter_types::Spanned for OrPatternOperator {
17435 fn span(&self) -> ::treesitter_types::Span {
17436 match self {
17437 Self::Or(span) => *span,
17438 }
17439 }
17440}
17441#[derive(Debug, Clone, PartialEq, Eq)]
17442pub enum ParameterChildren<'tree> {
17443 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17444 Expression(::std::boxed::Box<Expression<'tree>>),
17445 Modifier(::std::boxed::Box<Modifier<'tree>>),
17446}
17447impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterChildren<'tree> {
17448 #[allow(clippy::collapsible_else_if)]
17449 fn from_node(
17450 node: ::treesitter_types::tree_sitter::Node<'tree>,
17451 src: &'tree [u8],
17452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17453 match node.kind() {
17454 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17455 ::treesitter_types::runtime::maybe_grow_stack(|| {
17456 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17457 })?,
17458 ))),
17459 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17460 ::treesitter_types::runtime::maybe_grow_stack(|| {
17461 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17462 })?,
17463 ))),
17464 _other => {
17465 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17466 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17467 }) {
17468 Ok(Self::Expression(::std::boxed::Box::new(v)))
17469 } else {
17470 Err(::treesitter_types::ParseError::unexpected_kind(
17471 _other, node,
17472 ))
17473 }
17474 }
17475 }
17476 }
17477}
17478impl ::treesitter_types::Spanned for ParameterChildren<'_> {
17479 fn span(&self) -> ::treesitter_types::Span {
17480 match self {
17481 Self::AttributeList(inner) => inner.span(),
17482 Self::Expression(inner) => inner.span(),
17483 Self::Modifier(inner) => inner.span(),
17484 }
17485 }
17486}
17487#[derive(Debug, Clone, PartialEq, Eq)]
17488pub enum ParameterListType<'tree> {
17489 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
17490 NullableType(::std::boxed::Box<NullableType<'tree>>),
17491}
17492impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListType<'tree> {
17493 #[allow(clippy::collapsible_else_if)]
17494 fn from_node(
17495 node: ::treesitter_types::tree_sitter::Node<'tree>,
17496 src: &'tree [u8],
17497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17498 match node.kind() {
17499 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
17500 ::treesitter_types::runtime::maybe_grow_stack(|| {
17501 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
17502 })?,
17503 ))),
17504 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
17505 ::treesitter_types::runtime::maybe_grow_stack(|| {
17506 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
17507 })?,
17508 ))),
17509 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17510 }
17511 }
17512}
17513impl ::treesitter_types::Spanned for ParameterListType<'_> {
17514 fn span(&self) -> ::treesitter_types::Span {
17515 match self {
17516 Self::ArrayType(inner) => inner.span(),
17517 Self::NullableType(inner) => inner.span(),
17518 }
17519 }
17520}
17521#[derive(Debug, Clone, PartialEq, Eq)]
17522pub enum ParameterListChildren<'tree> {
17523 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17524 Parameter(::std::boxed::Box<Parameter<'tree>>),
17525}
17526impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
17527 #[allow(clippy::collapsible_else_if)]
17528 fn from_node(
17529 node: ::treesitter_types::tree_sitter::Node<'tree>,
17530 src: &'tree [u8],
17531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17532 match node.kind() {
17533 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17534 ::treesitter_types::runtime::maybe_grow_stack(|| {
17535 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17536 })?,
17537 ))),
17538 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
17539 ::treesitter_types::runtime::maybe_grow_stack(|| {
17540 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
17541 })?,
17542 ))),
17543 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17544 }
17545 }
17546}
17547impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
17548 fn span(&self) -> ::treesitter_types::Span {
17549 match self {
17550 Self::AttributeList(inner) => inner.span(),
17551 Self::Parameter(inner) => inner.span(),
17552 }
17553 }
17554}
17555#[derive(Debug, Clone, PartialEq, Eq)]
17556pub enum ParenthesizedExpressionChildren<'tree> {
17557 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
17558 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
17559 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
17560 LvalueExpression(::std::boxed::Box<LvalueExpression<'tree>>),
17561 NonLvalueExpression(::std::boxed::Box<NonLvalueExpression<'tree>>),
17562 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
17563}
17564impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
17565 #[allow(clippy::collapsible_else_if)]
17566 fn from_node(
17567 node: ::treesitter_types::tree_sitter::Node<'tree>,
17568 src: &'tree [u8],
17569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17570 match node.kind() {
17571 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
17572 ::treesitter_types::runtime::maybe_grow_stack(|| {
17573 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17574 })?,
17575 ))),
17576 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
17577 ::treesitter_types::runtime::maybe_grow_stack(|| {
17578 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17579 })?,
17580 ))),
17581 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
17582 ::treesitter_types::runtime::maybe_grow_stack(|| {
17583 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17584 })?,
17585 ))),
17586 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
17587 ::treesitter_types::runtime::maybe_grow_stack(|| {
17588 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
17589 })?,
17590 ))),
17591 _other => {
17592 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17593 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
17594 }) {
17595 Ok(Self::LvalueExpression(::std::boxed::Box::new(v)))
17596 } else {
17597 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17598 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
17599 }) {
17600 Ok(Self::NonLvalueExpression(::std::boxed::Box::new(v)))
17601 } else {
17602 Err(::treesitter_types::ParseError::unexpected_kind(
17603 _other, node,
17604 ))
17605 }
17606 }
17607 }
17608 }
17609 }
17610}
17611impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
17612 fn span(&self) -> ::treesitter_types::Span {
17613 match self {
17614 Self::BooleanLiteral(inner) => inner.span(),
17615 Self::CharacterLiteral(inner) => inner.span(),
17616 Self::IntegerLiteral(inner) => inner.span(),
17617 Self::LvalueExpression(inner) => inner.span(),
17618 Self::NonLvalueExpression(inner) => inner.span(),
17619 Self::UnaryExpression(inner) => inner.span(),
17620 }
17621 }
17622}
17623#[derive(Debug, Clone, PartialEq, Eq)]
17624pub enum ParenthesizedVariableDesignationChildren<'tree> {
17625 Discard(::std::boxed::Box<Discard<'tree>>),
17626 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
17627}
17628impl<'tree> ::treesitter_types::FromNode<'tree>
17629 for ParenthesizedVariableDesignationChildren<'tree>
17630{
17631 #[allow(clippy::collapsible_else_if)]
17632 fn from_node(
17633 node: ::treesitter_types::tree_sitter::Node<'tree>,
17634 src: &'tree [u8],
17635 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17636 match node.kind() {
17637 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
17638 ::treesitter_types::runtime::maybe_grow_stack(|| {
17639 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
17640 })?,
17641 ))),
17642 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
17643 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17644 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
17645 node, src,
17646 )
17647 })?),
17648 )),
17649 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17650 }
17651 }
17652}
17653impl ::treesitter_types::Spanned for ParenthesizedVariableDesignationChildren<'_> {
17654 fn span(&self) -> ::treesitter_types::Span {
17655 match self {
17656 Self::Discard(inner) => inner.span(),
17657 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
17658 }
17659 }
17660}
17661#[derive(Debug, Clone, PartialEq, Eq)]
17662pub enum PointerTypeType<'tree> {
17663 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17664 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
17665 GenericName(::std::boxed::Box<GenericName<'tree>>),
17666 Identifier(::std::boxed::Box<Identifier<'tree>>),
17667 NullableType(::std::boxed::Box<NullableType<'tree>>),
17668 PointerType(::std::boxed::Box<PointerType<'tree>>),
17669 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
17670 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17671 TupleType(::std::boxed::Box<TupleType<'tree>>),
17672}
17673impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeType<'tree> {
17674 #[allow(clippy::collapsible_else_if)]
17675 fn from_node(
17676 node: ::treesitter_types::tree_sitter::Node<'tree>,
17677 src: &'tree [u8],
17678 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17679 match node.kind() {
17680 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17681 ::treesitter_types::runtime::maybe_grow_stack(|| {
17682 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17683 })?,
17684 ))),
17685 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
17686 ::treesitter_types::runtime::maybe_grow_stack(|| {
17687 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
17688 })?,
17689 ))),
17690 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17691 ::treesitter_types::runtime::maybe_grow_stack(|| {
17692 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17693 })?,
17694 ))),
17695 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17696 ::treesitter_types::runtime::maybe_grow_stack(|| {
17697 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17698 })?,
17699 ))),
17700 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
17701 ::treesitter_types::runtime::maybe_grow_stack(|| {
17702 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
17703 })?,
17704 ))),
17705 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
17706 ::treesitter_types::runtime::maybe_grow_stack(|| {
17707 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
17708 })?,
17709 ))),
17710 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
17711 ::treesitter_types::runtime::maybe_grow_stack(|| {
17712 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
17713 })?,
17714 ))),
17715 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17716 ::treesitter_types::runtime::maybe_grow_stack(|| {
17717 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17718 })?,
17719 ))),
17720 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
17721 ::treesitter_types::runtime::maybe_grow_stack(|| {
17722 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
17723 })?,
17724 ))),
17725 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17726 }
17727 }
17728}
17729impl ::treesitter_types::Spanned for PointerTypeType<'_> {
17730 fn span(&self) -> ::treesitter_types::Span {
17731 match self {
17732 Self::AliasQualifiedName(inner) => inner.span(),
17733 Self::FunctionPointerType(inner) => inner.span(),
17734 Self::GenericName(inner) => inner.span(),
17735 Self::Identifier(inner) => inner.span(),
17736 Self::NullableType(inner) => inner.span(),
17737 Self::PointerType(inner) => inner.span(),
17738 Self::PredefinedType(inner) => inner.span(),
17739 Self::QualifiedName(inner) => inner.span(),
17740 Self::TupleType(inner) => inner.span(),
17741 }
17742 }
17743}
17744#[derive(Debug, Clone, PartialEq, Eq)]
17745pub enum PreprocElifAlternative<'tree> {
17746 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17747 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17748}
17749impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
17750 #[allow(clippy::collapsible_else_if)]
17751 fn from_node(
17752 node: ::treesitter_types::tree_sitter::Node<'tree>,
17753 src: &'tree [u8],
17754 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17755 match node.kind() {
17756 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17757 ::treesitter_types::runtime::maybe_grow_stack(|| {
17758 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
17759 })?,
17760 ))),
17761 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17762 ::treesitter_types::runtime::maybe_grow_stack(|| {
17763 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
17764 })?,
17765 ))),
17766 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17767 }
17768 }
17769}
17770impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
17771 fn span(&self) -> ::treesitter_types::Span {
17772 match self {
17773 Self::PreprocElif(inner) => inner.span(),
17774 Self::PreprocElse(inner) => inner.span(),
17775 }
17776 }
17777}
17778#[derive(Debug, Clone, PartialEq, Eq)]
17779pub enum PreprocElifCondition<'tree> {
17780 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
17781 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
17782 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
17783 Identifier(::std::boxed::Box<Identifier<'tree>>),
17784 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
17785 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17786 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
17787}
17788impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
17789 #[allow(clippy::collapsible_else_if)]
17790 fn from_node(
17791 node: ::treesitter_types::tree_sitter::Node<'tree>,
17792 src: &'tree [u8],
17793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17794 match node.kind() {
17795 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
17796 ::treesitter_types::runtime::maybe_grow_stack(|| {
17797 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
17798 })?,
17799 ))),
17800 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
17801 ::treesitter_types::runtime::maybe_grow_stack(|| {
17802 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17803 })?,
17804 ))),
17805 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
17806 ::treesitter_types::runtime::maybe_grow_stack(|| {
17807 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17808 })?,
17809 ))),
17810 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17811 ::treesitter_types::runtime::maybe_grow_stack(|| {
17812 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17813 })?,
17814 ))),
17815 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
17816 ::treesitter_types::runtime::maybe_grow_stack(|| {
17817 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17818 })?,
17819 ))),
17820 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
17821 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17822 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
17823 })?),
17824 )),
17825 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
17826 ::treesitter_types::runtime::maybe_grow_stack(|| {
17827 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
17828 })?,
17829 ))),
17830 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17831 }
17832 }
17833}
17834impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
17835 fn span(&self) -> ::treesitter_types::Span {
17836 match self {
17837 Self::BinaryExpression(inner) => inner.span(),
17838 Self::BooleanLiteral(inner) => inner.span(),
17839 Self::CharacterLiteral(inner) => inner.span(),
17840 Self::Identifier(inner) => inner.span(),
17841 Self::IntegerLiteral(inner) => inner.span(),
17842 Self::ParenthesizedExpression(inner) => inner.span(),
17843 Self::UnaryExpression(inner) => inner.span(),
17844 }
17845 }
17846}
17847#[derive(Debug, Clone, PartialEq, Eq)]
17848pub enum PreprocElifChildren<'tree> {
17849 Declaration(::std::boxed::Box<Declaration<'tree>>),
17850 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
17851 Expression(::std::boxed::Box<Expression<'tree>>),
17852 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
17853 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
17854 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
17855 Statement(::std::boxed::Box<Statement<'tree>>),
17856 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
17857}
17858impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
17859 #[allow(clippy::collapsible_else_if)]
17860 fn from_node(
17861 node: ::treesitter_types::tree_sitter::Node<'tree>,
17862 src: &'tree [u8],
17863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17864 match node.kind() {
17865 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
17866 ::treesitter_types::runtime::maybe_grow_stack(|| {
17867 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17868 })?,
17869 ))),
17870 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
17871 ::treesitter_types::runtime::maybe_grow_stack(|| {
17872 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
17873 })?,
17874 ))),
17875 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
17876 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17877 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
17878 node, src,
17879 )
17880 })?),
17881 )),
17882 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
17883 ::treesitter_types::runtime::maybe_grow_stack(|| {
17884 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
17885 })?,
17886 ))),
17887 _other => {
17888 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17889 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
17890 }) {
17891 Ok(Self::Declaration(::std::boxed::Box::new(v)))
17892 } else {
17893 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17894 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17895 }) {
17896 Ok(Self::Expression(::std::boxed::Box::new(v)))
17897 } else {
17898 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17899 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17900 }) {
17901 Ok(Self::Statement(::std::boxed::Box::new(v)))
17902 } else {
17903 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17904 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
17905 node, src,
17906 )
17907 }) {
17908 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
17909 } else {
17910 Err(::treesitter_types::ParseError::unexpected_kind(
17911 _other, node,
17912 ))
17913 }
17914 }
17915 }
17916 }
17917 }
17918 }
17919 }
17920}
17921impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
17922 fn span(&self) -> ::treesitter_types::Span {
17923 match self {
17924 Self::Declaration(inner) => inner.span(),
17925 Self::EnumMemberDeclaration(inner) => inner.span(),
17926 Self::Expression(inner) => inner.span(),
17927 Self::ExternAliasDirective(inner) => inner.span(),
17928 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
17929 Self::GlobalAttribute(inner) => inner.span(),
17930 Self::Statement(inner) => inner.span(),
17931 Self::TypeDeclaration(inner) => inner.span(),
17932 }
17933 }
17934}
17935#[derive(Debug, Clone, PartialEq, Eq)]
17936pub enum PreprocElseChildren<'tree> {
17937 Declaration(::std::boxed::Box<Declaration<'tree>>),
17938 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
17939 Expression(::std::boxed::Box<Expression<'tree>>),
17940 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
17941 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
17942 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
17943 Statement(::std::boxed::Box<Statement<'tree>>),
17944 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
17945}
17946impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
17947 #[allow(clippy::collapsible_else_if)]
17948 fn from_node(
17949 node: ::treesitter_types::tree_sitter::Node<'tree>,
17950 src: &'tree [u8],
17951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17952 match node.kind() {
17953 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
17954 ::treesitter_types::runtime::maybe_grow_stack(|| {
17955 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17956 })?,
17957 ))),
17958 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
17959 ::treesitter_types::runtime::maybe_grow_stack(|| {
17960 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
17961 })?,
17962 ))),
17963 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
17964 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17965 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
17966 node, src,
17967 )
17968 })?),
17969 )),
17970 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
17971 ::treesitter_types::runtime::maybe_grow_stack(|| {
17972 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
17973 })?,
17974 ))),
17975 _other => {
17976 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17977 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
17978 }) {
17979 Ok(Self::Declaration(::std::boxed::Box::new(v)))
17980 } else {
17981 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17982 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17983 }) {
17984 Ok(Self::Expression(::std::boxed::Box::new(v)))
17985 } else {
17986 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17987 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17988 }) {
17989 Ok(Self::Statement(::std::boxed::Box::new(v)))
17990 } else {
17991 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17992 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
17993 node, src,
17994 )
17995 }) {
17996 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
17997 } else {
17998 Err(::treesitter_types::ParseError::unexpected_kind(
17999 _other, node,
18000 ))
18001 }
18002 }
18003 }
18004 }
18005 }
18006 }
18007 }
18008}
18009impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
18010 fn span(&self) -> ::treesitter_types::Span {
18011 match self {
18012 Self::Declaration(inner) => inner.span(),
18013 Self::EnumMemberDeclaration(inner) => inner.span(),
18014 Self::Expression(inner) => inner.span(),
18015 Self::ExternAliasDirective(inner) => inner.span(),
18016 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
18017 Self::GlobalAttribute(inner) => inner.span(),
18018 Self::Statement(inner) => inner.span(),
18019 Self::TypeDeclaration(inner) => inner.span(),
18020 }
18021 }
18022}
18023#[derive(Debug, Clone, PartialEq, Eq)]
18024pub enum PreprocIfAlternative<'tree> {
18025 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
18026 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
18027}
18028impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
18029 #[allow(clippy::collapsible_else_if)]
18030 fn from_node(
18031 node: ::treesitter_types::tree_sitter::Node<'tree>,
18032 src: &'tree [u8],
18033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18034 match node.kind() {
18035 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
18036 ::treesitter_types::runtime::maybe_grow_stack(|| {
18037 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
18038 })?,
18039 ))),
18040 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
18041 ::treesitter_types::runtime::maybe_grow_stack(|| {
18042 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
18043 })?,
18044 ))),
18045 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18046 }
18047 }
18048}
18049impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
18050 fn span(&self) -> ::treesitter_types::Span {
18051 match self {
18052 Self::PreprocElif(inner) => inner.span(),
18053 Self::PreprocElse(inner) => inner.span(),
18054 }
18055 }
18056}
18057#[derive(Debug, Clone, PartialEq, Eq)]
18058pub enum PreprocIfCondition<'tree> {
18059 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
18060 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
18061 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
18062 Identifier(::std::boxed::Box<Identifier<'tree>>),
18063 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18064 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
18065 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18066}
18067impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
18068 #[allow(clippy::collapsible_else_if)]
18069 fn from_node(
18070 node: ::treesitter_types::tree_sitter::Node<'tree>,
18071 src: &'tree [u8],
18072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18073 match node.kind() {
18074 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
18075 ::treesitter_types::runtime::maybe_grow_stack(|| {
18076 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18077 })?,
18078 ))),
18079 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
18080 ::treesitter_types::runtime::maybe_grow_stack(|| {
18081 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18082 })?,
18083 ))),
18084 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
18085 ::treesitter_types::runtime::maybe_grow_stack(|| {
18086 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18087 })?,
18088 ))),
18089 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18090 ::treesitter_types::runtime::maybe_grow_stack(|| {
18091 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18092 })?,
18093 ))),
18094 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18095 ::treesitter_types::runtime::maybe_grow_stack(|| {
18096 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18097 })?,
18098 ))),
18099 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
18100 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18101 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
18102 })?),
18103 )),
18104 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18105 ::treesitter_types::runtime::maybe_grow_stack(|| {
18106 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18107 })?,
18108 ))),
18109 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18110 }
18111 }
18112}
18113impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
18114 fn span(&self) -> ::treesitter_types::Span {
18115 match self {
18116 Self::BinaryExpression(inner) => inner.span(),
18117 Self::BooleanLiteral(inner) => inner.span(),
18118 Self::CharacterLiteral(inner) => inner.span(),
18119 Self::Identifier(inner) => inner.span(),
18120 Self::IntegerLiteral(inner) => inner.span(),
18121 Self::ParenthesizedExpression(inner) => inner.span(),
18122 Self::UnaryExpression(inner) => inner.span(),
18123 }
18124 }
18125}
18126#[derive(Debug, Clone, PartialEq, Eq)]
18127pub enum PreprocIfChildren<'tree> {
18128 Declaration(::std::boxed::Box<Declaration<'tree>>),
18129 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
18130 Expression(::std::boxed::Box<Expression<'tree>>),
18131 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
18132 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
18133 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
18134 Statement(::std::boxed::Box<Statement<'tree>>),
18135 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
18136}
18137impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
18138 #[allow(clippy::collapsible_else_if)]
18139 fn from_node(
18140 node: ::treesitter_types::tree_sitter::Node<'tree>,
18141 src: &'tree [u8],
18142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18143 match node.kind() {
18144 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
18145 ::treesitter_types::runtime::maybe_grow_stack(|| {
18146 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18147 })?,
18148 ))),
18149 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
18150 ::treesitter_types::runtime::maybe_grow_stack(|| {
18151 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
18152 })?,
18153 ))),
18154 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
18155 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18156 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
18157 node, src,
18158 )
18159 })?),
18160 )),
18161 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
18162 ::treesitter_types::runtime::maybe_grow_stack(|| {
18163 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
18164 })?,
18165 ))),
18166 _other => {
18167 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18168 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18169 }) {
18170 Ok(Self::Declaration(::std::boxed::Box::new(v)))
18171 } else {
18172 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18173 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18174 }) {
18175 Ok(Self::Expression(::std::boxed::Box::new(v)))
18176 } else {
18177 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18178 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18179 }) {
18180 Ok(Self::Statement(::std::boxed::Box::new(v)))
18181 } else {
18182 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18183 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
18184 node, src,
18185 )
18186 }) {
18187 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
18188 } else {
18189 Err(::treesitter_types::ParseError::unexpected_kind(
18190 _other, node,
18191 ))
18192 }
18193 }
18194 }
18195 }
18196 }
18197 }
18198 }
18199}
18200impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
18201 fn span(&self) -> ::treesitter_types::Span {
18202 match self {
18203 Self::Declaration(inner) => inner.span(),
18204 Self::EnumMemberDeclaration(inner) => inner.span(),
18205 Self::Expression(inner) => inner.span(),
18206 Self::ExternAliasDirective(inner) => inner.span(),
18207 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
18208 Self::GlobalAttribute(inner) => inner.span(),
18209 Self::Statement(inner) => inner.span(),
18210 Self::TypeDeclaration(inner) => inner.span(),
18211 }
18212 }
18213}
18214#[derive(Debug, Clone, PartialEq, Eq)]
18215pub enum PreprocLineChildren<'tree> {
18216 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18217 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
18218}
18219impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLineChildren<'tree> {
18220 #[allow(clippy::collapsible_else_if)]
18221 fn from_node(
18222 node: ::treesitter_types::tree_sitter::Node<'tree>,
18223 src: &'tree [u8],
18224 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18225 match node.kind() {
18226 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18227 ::treesitter_types::runtime::maybe_grow_stack(|| {
18228 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18229 })?,
18230 ))),
18231 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
18232 ::treesitter_types::runtime::maybe_grow_stack(|| {
18233 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18234 })?,
18235 ))),
18236 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18237 }
18238 }
18239}
18240impl ::treesitter_types::Spanned for PreprocLineChildren<'_> {
18241 fn span(&self) -> ::treesitter_types::Span {
18242 match self {
18243 Self::IntegerLiteral(inner) => inner.span(),
18244 Self::StringLiteral(inner) => inner.span(),
18245 }
18246 }
18247}
18248#[derive(Debug, Clone, PartialEq, Eq)]
18249pub enum PreprocPragmaChildren<'tree> {
18250 Identifier(::std::boxed::Box<Identifier<'tree>>),
18251 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18252 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
18253}
18254impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragmaChildren<'tree> {
18255 #[allow(clippy::collapsible_else_if)]
18256 fn from_node(
18257 node: ::treesitter_types::tree_sitter::Node<'tree>,
18258 src: &'tree [u8],
18259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18260 match node.kind() {
18261 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18262 ::treesitter_types::runtime::maybe_grow_stack(|| {
18263 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18264 })?,
18265 ))),
18266 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18267 ::treesitter_types::runtime::maybe_grow_stack(|| {
18268 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18269 })?,
18270 ))),
18271 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
18272 ::treesitter_types::runtime::maybe_grow_stack(|| {
18273 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18274 })?,
18275 ))),
18276 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18277 }
18278 }
18279}
18280impl ::treesitter_types::Spanned for PreprocPragmaChildren<'_> {
18281 fn span(&self) -> ::treesitter_types::Span {
18282 match self {
18283 Self::Identifier(inner) => inner.span(),
18284 Self::IntegerLiteral(inner) => inner.span(),
18285 Self::StringLiteral(inner) => inner.span(),
18286 }
18287 }
18288}
18289#[derive(Debug, Clone, PartialEq, Eq)]
18290pub enum PrimaryConstructorBaseTypeType<'tree> {
18291 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
18292 GenericName(::std::boxed::Box<GenericName<'tree>>),
18293 Identifier(::std::boxed::Box<Identifier<'tree>>),
18294 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
18295}
18296impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseTypeType<'tree> {
18297 #[allow(clippy::collapsible_else_if)]
18298 fn from_node(
18299 node: ::treesitter_types::tree_sitter::Node<'tree>,
18300 src: &'tree [u8],
18301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18302 match node.kind() {
18303 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
18304 ::treesitter_types::runtime::maybe_grow_stack(|| {
18305 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18306 })?,
18307 ))),
18308 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18309 ::treesitter_types::runtime::maybe_grow_stack(|| {
18310 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18311 })?,
18312 ))),
18313 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18314 ::treesitter_types::runtime::maybe_grow_stack(|| {
18315 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18316 })?,
18317 ))),
18318 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
18319 ::treesitter_types::runtime::maybe_grow_stack(|| {
18320 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18321 })?,
18322 ))),
18323 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18324 }
18325 }
18326}
18327impl ::treesitter_types::Spanned for PrimaryConstructorBaseTypeType<'_> {
18328 fn span(&self) -> ::treesitter_types::Span {
18329 match self {
18330 Self::AliasQualifiedName(inner) => inner.span(),
18331 Self::GenericName(inner) => inner.span(),
18332 Self::Identifier(inner) => inner.span(),
18333 Self::QualifiedName(inner) => inner.span(),
18334 }
18335 }
18336}
18337#[derive(Debug, Clone, PartialEq, Eq)]
18338pub enum PropertyDeclarationValue<'tree> {
18339 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
18340 Expression(::std::boxed::Box<Expression<'tree>>),
18341}
18342impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationValue<'tree> {
18343 #[allow(clippy::collapsible_else_if)]
18344 fn from_node(
18345 node: ::treesitter_types::tree_sitter::Node<'tree>,
18346 src: &'tree [u8],
18347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18348 match node.kind() {
18349 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
18350 ::treesitter_types::runtime::maybe_grow_stack(|| {
18351 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
18352 })?,
18353 ))),
18354 _other => {
18355 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18356 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18357 }) {
18358 Ok(Self::Expression(::std::boxed::Box::new(v)))
18359 } else {
18360 Err(::treesitter_types::ParseError::unexpected_kind(
18361 _other, node,
18362 ))
18363 }
18364 }
18365 }
18366 }
18367}
18368impl ::treesitter_types::Spanned for PropertyDeclarationValue<'_> {
18369 fn span(&self) -> ::treesitter_types::Span {
18370 match self {
18371 Self::ArrowExpressionClause(inner) => inner.span(),
18372 Self::Expression(inner) => inner.span(),
18373 }
18374 }
18375}
18376#[derive(Debug, Clone, PartialEq, Eq)]
18377pub enum PropertyDeclarationChildren<'tree> {
18378 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18379 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
18380 Modifier(::std::boxed::Box<Modifier<'tree>>),
18381}
18382impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationChildren<'tree> {
18383 #[allow(clippy::collapsible_else_if)]
18384 fn from_node(
18385 node: ::treesitter_types::tree_sitter::Node<'tree>,
18386 src: &'tree [u8],
18387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18388 match node.kind() {
18389 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18390 ::treesitter_types::runtime::maybe_grow_stack(|| {
18391 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18392 })?,
18393 ))),
18394 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
18395 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18396 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
18397 node, src,
18398 )
18399 })?),
18400 )),
18401 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
18402 ::treesitter_types::runtime::maybe_grow_stack(|| {
18403 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
18404 })?,
18405 ))),
18406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18407 }
18408 }
18409}
18410impl ::treesitter_types::Spanned for PropertyDeclarationChildren<'_> {
18411 fn span(&self) -> ::treesitter_types::Span {
18412 match self {
18413 Self::AttributeList(inner) => inner.span(),
18414 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
18415 Self::Modifier(inner) => inner.span(),
18416 }
18417 }
18418}
18419#[derive(Debug, Clone, PartialEq, Eq)]
18420pub enum QualifiedNameName<'tree> {
18421 GenericName(::std::boxed::Box<GenericName<'tree>>),
18422 Identifier(::std::boxed::Box<Identifier<'tree>>),
18423}
18424impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameName<'tree> {
18425 #[allow(clippy::collapsible_else_if)]
18426 fn from_node(
18427 node: ::treesitter_types::tree_sitter::Node<'tree>,
18428 src: &'tree [u8],
18429 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18430 match node.kind() {
18431 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18432 ::treesitter_types::runtime::maybe_grow_stack(|| {
18433 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18434 })?,
18435 ))),
18436 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18437 ::treesitter_types::runtime::maybe_grow_stack(|| {
18438 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18439 })?,
18440 ))),
18441 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18442 }
18443 }
18444}
18445impl ::treesitter_types::Spanned for QualifiedNameName<'_> {
18446 fn span(&self) -> ::treesitter_types::Span {
18447 match self {
18448 Self::GenericName(inner) => inner.span(),
18449 Self::Identifier(inner) => inner.span(),
18450 }
18451 }
18452}
18453#[derive(Debug, Clone, PartialEq, Eq)]
18454pub enum QualifiedNameQualifier<'tree> {
18455 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
18456 GenericName(::std::boxed::Box<GenericName<'tree>>),
18457 Identifier(::std::boxed::Box<Identifier<'tree>>),
18458 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
18459}
18460impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameQualifier<'tree> {
18461 #[allow(clippy::collapsible_else_if)]
18462 fn from_node(
18463 node: ::treesitter_types::tree_sitter::Node<'tree>,
18464 src: &'tree [u8],
18465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18466 match node.kind() {
18467 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
18468 ::treesitter_types::runtime::maybe_grow_stack(|| {
18469 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18470 })?,
18471 ))),
18472 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18473 ::treesitter_types::runtime::maybe_grow_stack(|| {
18474 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18475 })?,
18476 ))),
18477 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18478 ::treesitter_types::runtime::maybe_grow_stack(|| {
18479 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18480 })?,
18481 ))),
18482 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
18483 ::treesitter_types::runtime::maybe_grow_stack(|| {
18484 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18485 })?,
18486 ))),
18487 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18488 }
18489 }
18490}
18491impl ::treesitter_types::Spanned for QualifiedNameQualifier<'_> {
18492 fn span(&self) -> ::treesitter_types::Span {
18493 match self {
18494 Self::AliasQualifiedName(inner) => inner.span(),
18495 Self::GenericName(inner) => inner.span(),
18496 Self::Identifier(inner) => inner.span(),
18497 Self::QualifiedName(inner) => inner.span(),
18498 }
18499 }
18500}
18501#[derive(Debug, Clone, PartialEq, Eq)]
18502pub enum QueryExpressionChildren<'tree> {
18503 FromClause(::std::boxed::Box<FromClause<'tree>>),
18504 GroupClause(::std::boxed::Box<GroupClause<'tree>>),
18505 Identifier(::std::boxed::Box<Identifier<'tree>>),
18506 JoinClause(::std::boxed::Box<JoinClause<'tree>>),
18507 LetClause(::std::boxed::Box<LetClause<'tree>>),
18508 OrderByClause(::std::boxed::Box<OrderByClause<'tree>>),
18509 SelectClause(::std::boxed::Box<SelectClause<'tree>>),
18510 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
18511}
18512impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpressionChildren<'tree> {
18513 #[allow(clippy::collapsible_else_if)]
18514 fn from_node(
18515 node: ::treesitter_types::tree_sitter::Node<'tree>,
18516 src: &'tree [u8],
18517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18518 match node.kind() {
18519 "from_clause" => Ok(Self::FromClause(::std::boxed::Box::new(
18520 ::treesitter_types::runtime::maybe_grow_stack(|| {
18521 <FromClause as ::treesitter_types::FromNode>::from_node(node, src)
18522 })?,
18523 ))),
18524 "group_clause" => Ok(Self::GroupClause(::std::boxed::Box::new(
18525 ::treesitter_types::runtime::maybe_grow_stack(|| {
18526 <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)
18527 })?,
18528 ))),
18529 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18530 ::treesitter_types::runtime::maybe_grow_stack(|| {
18531 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18532 })?,
18533 ))),
18534 "join_clause" => Ok(Self::JoinClause(::std::boxed::Box::new(
18535 ::treesitter_types::runtime::maybe_grow_stack(|| {
18536 <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)
18537 })?,
18538 ))),
18539 "let_clause" => Ok(Self::LetClause(::std::boxed::Box::new(
18540 ::treesitter_types::runtime::maybe_grow_stack(|| {
18541 <LetClause as ::treesitter_types::FromNode>::from_node(node, src)
18542 })?,
18543 ))),
18544 "order_by_clause" => Ok(Self::OrderByClause(::std::boxed::Box::new(
18545 ::treesitter_types::runtime::maybe_grow_stack(|| {
18546 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)
18547 })?,
18548 ))),
18549 "select_clause" => Ok(Self::SelectClause(::std::boxed::Box::new(
18550 ::treesitter_types::runtime::maybe_grow_stack(|| {
18551 <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)
18552 })?,
18553 ))),
18554 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
18555 ::treesitter_types::runtime::maybe_grow_stack(|| {
18556 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
18557 })?,
18558 ))),
18559 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18560 }
18561 }
18562}
18563impl ::treesitter_types::Spanned for QueryExpressionChildren<'_> {
18564 fn span(&self) -> ::treesitter_types::Span {
18565 match self {
18566 Self::FromClause(inner) => inner.span(),
18567 Self::GroupClause(inner) => inner.span(),
18568 Self::Identifier(inner) => inner.span(),
18569 Self::JoinClause(inner) => inner.span(),
18570 Self::LetClause(inner) => inner.span(),
18571 Self::OrderByClause(inner) => inner.span(),
18572 Self::SelectClause(inner) => inner.span(),
18573 Self::WhereClause(inner) => inner.span(),
18574 }
18575 }
18576}
18577#[derive(Debug, Clone, PartialEq, Eq)]
18578pub enum RawStringLiteralChildren<'tree> {
18579 RawStringContent(::std::boxed::Box<RawStringContent<'tree>>),
18580 RawStringEnd(::std::boxed::Box<RawStringEnd<'tree>>),
18581 RawStringStart(::std::boxed::Box<RawStringStart<'tree>>),
18582}
18583impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralChildren<'tree> {
18584 #[allow(clippy::collapsible_else_if)]
18585 fn from_node(
18586 node: ::treesitter_types::tree_sitter::Node<'tree>,
18587 src: &'tree [u8],
18588 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18589 match node.kind() {
18590 "raw_string_content" => Ok(Self::RawStringContent(::std::boxed::Box::new(
18591 ::treesitter_types::runtime::maybe_grow_stack(|| {
18592 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
18593 })?,
18594 ))),
18595 "raw_string_end" => Ok(Self::RawStringEnd(::std::boxed::Box::new(
18596 ::treesitter_types::runtime::maybe_grow_stack(|| {
18597 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)
18598 })?,
18599 ))),
18600 "raw_string_start" => Ok(Self::RawStringStart(::std::boxed::Box::new(
18601 ::treesitter_types::runtime::maybe_grow_stack(|| {
18602 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)
18603 })?,
18604 ))),
18605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18606 }
18607 }
18608}
18609impl ::treesitter_types::Spanned for RawStringLiteralChildren<'_> {
18610 fn span(&self) -> ::treesitter_types::Span {
18611 match self {
18612 Self::RawStringContent(inner) => inner.span(),
18613 Self::RawStringEnd(inner) => inner.span(),
18614 Self::RawStringStart(inner) => inner.span(),
18615 }
18616 }
18617}
18618#[derive(Debug, Clone, PartialEq, Eq)]
18619pub enum RecordDeclarationChildren<'tree> {
18620 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18621 BaseList(::std::boxed::Box<BaseList<'tree>>),
18622 Modifier(::std::boxed::Box<Modifier<'tree>>),
18623 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
18624 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
18625 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
18626}
18627impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclarationChildren<'tree> {
18628 #[allow(clippy::collapsible_else_if)]
18629 fn from_node(
18630 node: ::treesitter_types::tree_sitter::Node<'tree>,
18631 src: &'tree [u8],
18632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18633 match node.kind() {
18634 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18635 ::treesitter_types::runtime::maybe_grow_stack(|| {
18636 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18637 })?,
18638 ))),
18639 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
18640 ::treesitter_types::runtime::maybe_grow_stack(|| {
18641 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
18642 })?,
18643 ))),
18644 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
18645 ::treesitter_types::runtime::maybe_grow_stack(|| {
18646 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
18647 })?,
18648 ))),
18649 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
18650 ::treesitter_types::runtime::maybe_grow_stack(|| {
18651 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
18652 })?,
18653 ))),
18654 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
18655 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18656 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
18657 node, src,
18658 )
18659 })?),
18660 )),
18661 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
18662 ::treesitter_types::runtime::maybe_grow_stack(|| {
18663 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
18664 })?,
18665 ))),
18666 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18667 }
18668 }
18669}
18670impl ::treesitter_types::Spanned for RecordDeclarationChildren<'_> {
18671 fn span(&self) -> ::treesitter_types::Span {
18672 match self {
18673 Self::AttributeList(inner) => inner.span(),
18674 Self::BaseList(inner) => inner.span(),
18675 Self::Modifier(inner) => inner.span(),
18676 Self::ParameterList(inner) => inner.span(),
18677 Self::TypeParameterConstraintsClause(inner) => inner.span(),
18678 Self::TypeParameterList(inner) => inner.span(),
18679 }
18680 }
18681}
18682#[derive(Debug, Clone, PartialEq, Eq)]
18683pub enum RecursivePatternChildren<'tree> {
18684 Discard(::std::boxed::Box<Discard<'tree>>),
18685 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
18686 PositionalPatternClause(::std::boxed::Box<PositionalPatternClause<'tree>>),
18687 PropertyPatternClause(::std::boxed::Box<PropertyPatternClause<'tree>>),
18688}
18689impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePatternChildren<'tree> {
18690 #[allow(clippy::collapsible_else_if)]
18691 fn from_node(
18692 node: ::treesitter_types::tree_sitter::Node<'tree>,
18693 src: &'tree [u8],
18694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18695 match node.kind() {
18696 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
18697 ::treesitter_types::runtime::maybe_grow_stack(|| {
18698 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
18699 })?,
18700 ))),
18701 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
18702 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18703 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
18704 node, src,
18705 )
18706 })?),
18707 )),
18708 "positional_pattern_clause" => Ok(Self::PositionalPatternClause(
18709 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18710 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
18711 })?),
18712 )),
18713 "property_pattern_clause" => Ok(Self::PropertyPatternClause(::std::boxed::Box::new(
18714 ::treesitter_types::runtime::maybe_grow_stack(|| {
18715 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
18716 })?,
18717 ))),
18718 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18719 }
18720 }
18721}
18722impl ::treesitter_types::Spanned for RecursivePatternChildren<'_> {
18723 fn span(&self) -> ::treesitter_types::Span {
18724 match self {
18725 Self::Discard(inner) => inner.span(),
18726 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
18727 Self::PositionalPatternClause(inner) => inner.span(),
18728 Self::PropertyPatternClause(inner) => inner.span(),
18729 }
18730 }
18731}
18732#[derive(Debug, Clone, PartialEq, Eq)]
18733pub enum ScopedTypeType<'tree> {
18734 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
18735 GenericName(::std::boxed::Box<GenericName<'tree>>),
18736 Identifier(::std::boxed::Box<Identifier<'tree>>),
18737 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
18738 RefType(::std::boxed::Box<RefType<'tree>>),
18739}
18740impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeType<'tree> {
18741 #[allow(clippy::collapsible_else_if)]
18742 fn from_node(
18743 node: ::treesitter_types::tree_sitter::Node<'tree>,
18744 src: &'tree [u8],
18745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18746 match node.kind() {
18747 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
18748 ::treesitter_types::runtime::maybe_grow_stack(|| {
18749 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18750 })?,
18751 ))),
18752 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18753 ::treesitter_types::runtime::maybe_grow_stack(|| {
18754 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18755 })?,
18756 ))),
18757 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18758 ::treesitter_types::runtime::maybe_grow_stack(|| {
18759 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18760 })?,
18761 ))),
18762 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
18763 ::treesitter_types::runtime::maybe_grow_stack(|| {
18764 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18765 })?,
18766 ))),
18767 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
18768 ::treesitter_types::runtime::maybe_grow_stack(|| {
18769 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
18770 })?,
18771 ))),
18772 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18773 }
18774 }
18775}
18776impl ::treesitter_types::Spanned for ScopedTypeType<'_> {
18777 fn span(&self) -> ::treesitter_types::Span {
18778 match self {
18779 Self::AliasQualifiedName(inner) => inner.span(),
18780 Self::GenericName(inner) => inner.span(),
18781 Self::Identifier(inner) => inner.span(),
18782 Self::QualifiedName(inner) => inner.span(),
18783 Self::RefType(inner) => inner.span(),
18784 }
18785 }
18786}
18787#[derive(Debug, Clone, PartialEq, Eq)]
18788pub enum StringLiteralChildren<'tree> {
18789 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
18790 StringLiteralContent(::std::boxed::Box<StringLiteralContent<'tree>>),
18791 StringLiteralEncoding(::std::boxed::Box<StringLiteralEncoding<'tree>>),
18792}
18793impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
18794 #[allow(clippy::collapsible_else_if)]
18795 fn from_node(
18796 node: ::treesitter_types::tree_sitter::Node<'tree>,
18797 src: &'tree [u8],
18798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18799 match node.kind() {
18800 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
18801 ::treesitter_types::runtime::maybe_grow_stack(|| {
18802 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
18803 })?,
18804 ))),
18805 "string_literal_content" => Ok(Self::StringLiteralContent(::std::boxed::Box::new(
18806 ::treesitter_types::runtime::maybe_grow_stack(|| {
18807 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
18808 })?,
18809 ))),
18810 "string_literal_encoding" => Ok(Self::StringLiteralEncoding(::std::boxed::Box::new(
18811 ::treesitter_types::runtime::maybe_grow_stack(|| {
18812 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)
18813 })?,
18814 ))),
18815 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18816 }
18817 }
18818}
18819impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
18820 fn span(&self) -> ::treesitter_types::Span {
18821 match self {
18822 Self::EscapeSequence(inner) => inner.span(),
18823 Self::StringLiteralContent(inner) => inner.span(),
18824 Self::StringLiteralEncoding(inner) => inner.span(),
18825 }
18826 }
18827}
18828#[derive(Debug, Clone, PartialEq, Eq)]
18829pub enum StructDeclarationChildren<'tree> {
18830 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18831 BaseList(::std::boxed::Box<BaseList<'tree>>),
18832 Modifier(::std::boxed::Box<Modifier<'tree>>),
18833 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
18834 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
18835 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
18836}
18837impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclarationChildren<'tree> {
18838 #[allow(clippy::collapsible_else_if)]
18839 fn from_node(
18840 node: ::treesitter_types::tree_sitter::Node<'tree>,
18841 src: &'tree [u8],
18842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18843 match node.kind() {
18844 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18845 ::treesitter_types::runtime::maybe_grow_stack(|| {
18846 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18847 })?,
18848 ))),
18849 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
18850 ::treesitter_types::runtime::maybe_grow_stack(|| {
18851 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
18852 })?,
18853 ))),
18854 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
18855 ::treesitter_types::runtime::maybe_grow_stack(|| {
18856 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
18857 })?,
18858 ))),
18859 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
18860 ::treesitter_types::runtime::maybe_grow_stack(|| {
18861 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
18862 })?,
18863 ))),
18864 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
18865 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18866 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
18867 node, src,
18868 )
18869 })?),
18870 )),
18871 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
18872 ::treesitter_types::runtime::maybe_grow_stack(|| {
18873 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
18874 })?,
18875 ))),
18876 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18877 }
18878 }
18879}
18880impl ::treesitter_types::Spanned for StructDeclarationChildren<'_> {
18881 fn span(&self) -> ::treesitter_types::Span {
18882 match self {
18883 Self::AttributeList(inner) => inner.span(),
18884 Self::BaseList(inner) => inner.span(),
18885 Self::Modifier(inner) => inner.span(),
18886 Self::ParameterList(inner) => inner.span(),
18887 Self::TypeParameterConstraintsClause(inner) => inner.span(),
18888 Self::TypeParameterList(inner) => inner.span(),
18889 }
18890 }
18891}
18892#[derive(Debug, Clone, PartialEq, Eq)]
18893pub enum SubpatternChildren<'tree> {
18894 Expression(::std::boxed::Box<Expression<'tree>>),
18895 Pattern(::std::boxed::Box<Pattern<'tree>>),
18896}
18897impl<'tree> ::treesitter_types::FromNode<'tree> for SubpatternChildren<'tree> {
18898 #[allow(clippy::collapsible_else_if)]
18899 fn from_node(
18900 node: ::treesitter_types::tree_sitter::Node<'tree>,
18901 src: &'tree [u8],
18902 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18903 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18904 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18905 }) {
18906 Ok(Self::Expression(::std::boxed::Box::new(v)))
18907 } else {
18908 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18909 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
18910 }) {
18911 Ok(Self::Pattern(::std::boxed::Box::new(v)))
18912 } else {
18913 Err(::treesitter_types::ParseError::unexpected_kind(
18914 node.kind(),
18915 node,
18916 ))
18917 }
18918 }
18919 }
18920}
18921impl ::treesitter_types::Spanned for SubpatternChildren<'_> {
18922 fn span(&self) -> ::treesitter_types::Span {
18923 match self {
18924 Self::Expression(inner) => inner.span(),
18925 Self::Pattern(inner) => inner.span(),
18926 }
18927 }
18928}
18929#[derive(Debug, Clone, PartialEq, Eq)]
18930pub enum SwitchExpressionChildren<'tree> {
18931 Expression(::std::boxed::Box<Expression<'tree>>),
18932 SwitchExpressionArm(::std::boxed::Box<SwitchExpressionArm<'tree>>),
18933}
18934impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionChildren<'tree> {
18935 #[allow(clippy::collapsible_else_if)]
18936 fn from_node(
18937 node: ::treesitter_types::tree_sitter::Node<'tree>,
18938 src: &'tree [u8],
18939 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18940 match node.kind() {
18941 "switch_expression_arm" => Ok(Self::SwitchExpressionArm(::std::boxed::Box::new(
18942 ::treesitter_types::runtime::maybe_grow_stack(|| {
18943 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)
18944 })?,
18945 ))),
18946 _other => {
18947 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18948 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18949 }) {
18950 Ok(Self::Expression(::std::boxed::Box::new(v)))
18951 } else {
18952 Err(::treesitter_types::ParseError::unexpected_kind(
18953 _other, node,
18954 ))
18955 }
18956 }
18957 }
18958 }
18959}
18960impl ::treesitter_types::Spanned for SwitchExpressionChildren<'_> {
18961 fn span(&self) -> ::treesitter_types::Span {
18962 match self {
18963 Self::Expression(inner) => inner.span(),
18964 Self::SwitchExpressionArm(inner) => inner.span(),
18965 }
18966 }
18967}
18968#[derive(Debug, Clone, PartialEq, Eq)]
18969pub enum SwitchExpressionArmChildren<'tree> {
18970 Expression(::std::boxed::Box<Expression<'tree>>),
18971 Pattern(::std::boxed::Box<Pattern<'tree>>),
18972 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
18973}
18974impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArmChildren<'tree> {
18975 #[allow(clippy::collapsible_else_if)]
18976 fn from_node(
18977 node: ::treesitter_types::tree_sitter::Node<'tree>,
18978 src: &'tree [u8],
18979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18980 match node.kind() {
18981 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
18982 ::treesitter_types::runtime::maybe_grow_stack(|| {
18983 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
18984 })?,
18985 ))),
18986 _other => {
18987 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18988 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18989 }) {
18990 Ok(Self::Expression(::std::boxed::Box::new(v)))
18991 } else {
18992 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18993 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
18994 }) {
18995 Ok(Self::Pattern(::std::boxed::Box::new(v)))
18996 } else {
18997 Err(::treesitter_types::ParseError::unexpected_kind(
18998 _other, node,
18999 ))
19000 }
19001 }
19002 }
19003 }
19004 }
19005}
19006impl ::treesitter_types::Spanned for SwitchExpressionArmChildren<'_> {
19007 fn span(&self) -> ::treesitter_types::Span {
19008 match self {
19009 Self::Expression(inner) => inner.span(),
19010 Self::Pattern(inner) => inner.span(),
19011 Self::WhenClause(inner) => inner.span(),
19012 }
19013 }
19014}
19015#[derive(Debug, Clone, PartialEq, Eq)]
19016pub enum SwitchSectionChildren<'tree> {
19017 Expression(::std::boxed::Box<Expression<'tree>>),
19018 Pattern(::std::boxed::Box<Pattern<'tree>>),
19019 Statement(::std::boxed::Box<Statement<'tree>>),
19020 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
19021}
19022impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSectionChildren<'tree> {
19023 #[allow(clippy::collapsible_else_if)]
19024 fn from_node(
19025 node: ::treesitter_types::tree_sitter::Node<'tree>,
19026 src: &'tree [u8],
19027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19028 match node.kind() {
19029 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
19030 ::treesitter_types::runtime::maybe_grow_stack(|| {
19031 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
19032 })?,
19033 ))),
19034 _other => {
19035 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19036 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19037 }) {
19038 Ok(Self::Expression(::std::boxed::Box::new(v)))
19039 } else {
19040 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19041 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
19042 }) {
19043 Ok(Self::Pattern(::std::boxed::Box::new(v)))
19044 } else {
19045 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19046 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
19047 }) {
19048 Ok(Self::Statement(::std::boxed::Box::new(v)))
19049 } else {
19050 Err(::treesitter_types::ParseError::unexpected_kind(
19051 _other, node,
19052 ))
19053 }
19054 }
19055 }
19056 }
19057 }
19058 }
19059}
19060impl ::treesitter_types::Spanned for SwitchSectionChildren<'_> {
19061 fn span(&self) -> ::treesitter_types::Span {
19062 match self {
19063 Self::Expression(inner) => inner.span(),
19064 Self::Pattern(inner) => inner.span(),
19065 Self::Statement(inner) => inner.span(),
19066 Self::WhenClause(inner) => inner.span(),
19067 }
19068 }
19069}
19070#[derive(Debug, Clone, PartialEq, Eq)]
19071pub enum SwitchStatementValue<'tree> {
19072 Expression(::std::boxed::Box<Expression<'tree>>),
19073 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
19074}
19075impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatementValue<'tree> {
19076 #[allow(clippy::collapsible_else_if)]
19077 fn from_node(
19078 node: ::treesitter_types::tree_sitter::Node<'tree>,
19079 src: &'tree [u8],
19080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19081 match node.kind() {
19082 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
19083 ::treesitter_types::runtime::maybe_grow_stack(|| {
19084 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
19085 })?,
19086 ))),
19087 _other => {
19088 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19089 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19090 }) {
19091 Ok(Self::Expression(::std::boxed::Box::new(v)))
19092 } else {
19093 Err(::treesitter_types::ParseError::unexpected_kind(
19094 _other, node,
19095 ))
19096 }
19097 }
19098 }
19099 }
19100}
19101impl ::treesitter_types::Spanned for SwitchStatementValue<'_> {
19102 fn span(&self) -> ::treesitter_types::Span {
19103 match self {
19104 Self::Expression(inner) => inner.span(),
19105 Self::TupleExpression(inner) => inner.span(),
19106 }
19107 }
19108}
19109#[derive(Debug, Clone, PartialEq, Eq)]
19110pub enum TryStatementChildren<'tree> {
19111 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
19112 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
19113}
19114impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
19115 #[allow(clippy::collapsible_else_if)]
19116 fn from_node(
19117 node: ::treesitter_types::tree_sitter::Node<'tree>,
19118 src: &'tree [u8],
19119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19120 match node.kind() {
19121 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
19122 ::treesitter_types::runtime::maybe_grow_stack(|| {
19123 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
19124 })?,
19125 ))),
19126 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
19127 ::treesitter_types::runtime::maybe_grow_stack(|| {
19128 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
19129 })?,
19130 ))),
19131 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19132 }
19133 }
19134}
19135impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
19136 fn span(&self) -> ::treesitter_types::Span {
19137 match self {
19138 Self::CatchClause(inner) => inner.span(),
19139 Self::FinallyClause(inner) => inner.span(),
19140 }
19141 }
19142}
19143#[derive(Debug, Clone, PartialEq, Eq)]
19144pub enum TuplePatternChildren<'tree> {
19145 Discard(::std::boxed::Box<Discard<'tree>>),
19146 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
19147}
19148impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
19149 #[allow(clippy::collapsible_else_if)]
19150 fn from_node(
19151 node: ::treesitter_types::tree_sitter::Node<'tree>,
19152 src: &'tree [u8],
19153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19154 match node.kind() {
19155 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
19156 ::treesitter_types::runtime::maybe_grow_stack(|| {
19157 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
19158 })?,
19159 ))),
19160 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
19161 ::treesitter_types::runtime::maybe_grow_stack(|| {
19162 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
19163 })?,
19164 ))),
19165 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19166 }
19167 }
19168}
19169impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
19170 fn span(&self) -> ::treesitter_types::Span {
19171 match self {
19172 Self::Discard(inner) => inner.span(),
19173 Self::TuplePattern(inner) => inner.span(),
19174 }
19175 }
19176}
19177#[derive(Debug, Clone, PartialEq, Eq)]
19178pub enum TypeParameterConstraintsClauseChildren<'tree> {
19179 Identifier(::std::boxed::Box<Identifier<'tree>>),
19180 TypeParameterConstraint(::std::boxed::Box<TypeParameterConstraint<'tree>>),
19181}
19182impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClauseChildren<'tree> {
19183 #[allow(clippy::collapsible_else_if)]
19184 fn from_node(
19185 node: ::treesitter_types::tree_sitter::Node<'tree>,
19186 src: &'tree [u8],
19187 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19188 match node.kind() {
19189 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19190 ::treesitter_types::runtime::maybe_grow_stack(|| {
19191 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19192 })?,
19193 ))),
19194 "type_parameter_constraint" => Ok(Self::TypeParameterConstraint(
19195 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19196 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(node, src)
19197 })?),
19198 )),
19199 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19200 }
19201 }
19202}
19203impl ::treesitter_types::Spanned for TypeParameterConstraintsClauseChildren<'_> {
19204 fn span(&self) -> ::treesitter_types::Span {
19205 match self {
19206 Self::Identifier(inner) => inner.span(),
19207 Self::TypeParameterConstraint(inner) => inner.span(),
19208 }
19209 }
19210}
19211#[derive(Debug, Clone, PartialEq, Eq)]
19212pub enum UnaryExpressionArgument<'tree> {
19213 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
19214 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
19215 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
19216 Identifier(::std::boxed::Box<Identifier<'tree>>),
19217 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
19218 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
19219 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
19220}
19221impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
19222 #[allow(clippy::collapsible_else_if)]
19223 fn from_node(
19224 node: ::treesitter_types::tree_sitter::Node<'tree>,
19225 src: &'tree [u8],
19226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19227 match node.kind() {
19228 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
19229 ::treesitter_types::runtime::maybe_grow_stack(|| {
19230 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19231 })?,
19232 ))),
19233 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
19234 ::treesitter_types::runtime::maybe_grow_stack(|| {
19235 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19236 })?,
19237 ))),
19238 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
19239 ::treesitter_types::runtime::maybe_grow_stack(|| {
19240 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19241 })?,
19242 ))),
19243 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19244 ::treesitter_types::runtime::maybe_grow_stack(|| {
19245 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19246 })?,
19247 ))),
19248 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
19249 ::treesitter_types::runtime::maybe_grow_stack(|| {
19250 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19251 })?,
19252 ))),
19253 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
19254 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19255 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
19256 })?),
19257 )),
19258 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
19259 ::treesitter_types::runtime::maybe_grow_stack(|| {
19260 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19261 })?,
19262 ))),
19263 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19264 }
19265 }
19266}
19267impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
19268 fn span(&self) -> ::treesitter_types::Span {
19269 match self {
19270 Self::BinaryExpression(inner) => inner.span(),
19271 Self::BooleanLiteral(inner) => inner.span(),
19272 Self::CharacterLiteral(inner) => inner.span(),
19273 Self::Identifier(inner) => inner.span(),
19274 Self::IntegerLiteral(inner) => inner.span(),
19275 Self::ParenthesizedExpression(inner) => inner.span(),
19276 Self::UnaryExpression(inner) => inner.span(),
19277 }
19278 }
19279}
19280#[derive(Debug, Clone, PartialEq, Eq)]
19281pub enum UnaryExpressionOperator {
19282 Bang(::treesitter_types::Span),
19283}
19284impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
19285 #[allow(clippy::collapsible_else_if)]
19286 fn from_node(
19287 node: ::treesitter_types::tree_sitter::Node<'tree>,
19288 _src: &'tree [u8],
19289 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19290 match node.kind() {
19291 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
19292 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19293 }
19294 }
19295}
19296impl ::treesitter_types::Spanned for UnaryExpressionOperator {
19297 fn span(&self) -> ::treesitter_types::Span {
19298 match self {
19299 Self::Bang(span) => *span,
19300 }
19301 }
19302}
19303#[derive(Debug, Clone, PartialEq, Eq)]
19304pub enum UsingStatementChildren<'tree> {
19305 Expression(::std::boxed::Box<Expression<'tree>>),
19306 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
19307}
19308impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatementChildren<'tree> {
19309 #[allow(clippy::collapsible_else_if)]
19310 fn from_node(
19311 node: ::treesitter_types::tree_sitter::Node<'tree>,
19312 src: &'tree [u8],
19313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19314 match node.kind() {
19315 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
19316 ::treesitter_types::runtime::maybe_grow_stack(|| {
19317 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19318 })?,
19319 ))),
19320 _other => {
19321 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19322 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19323 }) {
19324 Ok(Self::Expression(::std::boxed::Box::new(v)))
19325 } else {
19326 Err(::treesitter_types::ParseError::unexpected_kind(
19327 _other, node,
19328 ))
19329 }
19330 }
19331 }
19332 }
19333}
19334impl ::treesitter_types::Spanned for UsingStatementChildren<'_> {
19335 fn span(&self) -> ::treesitter_types::Span {
19336 match self {
19337 Self::Expression(inner) => inner.span(),
19338 Self::VariableDeclaration(inner) => inner.span(),
19339 }
19340 }
19341}
19342#[derive(Debug, Clone, PartialEq, Eq)]
19343pub enum VarPatternChildren<'tree> {
19344 Discard(::std::boxed::Box<Discard<'tree>>),
19345 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
19346}
19347impl<'tree> ::treesitter_types::FromNode<'tree> for VarPatternChildren<'tree> {
19348 #[allow(clippy::collapsible_else_if)]
19349 fn from_node(
19350 node: ::treesitter_types::tree_sitter::Node<'tree>,
19351 src: &'tree [u8],
19352 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19353 match node.kind() {
19354 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
19355 ::treesitter_types::runtime::maybe_grow_stack(|| {
19356 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
19357 })?,
19358 ))),
19359 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
19360 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19361 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
19362 node, src,
19363 )
19364 })?),
19365 )),
19366 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19367 }
19368 }
19369}
19370impl ::treesitter_types::Spanned for VarPatternChildren<'_> {
19371 fn span(&self) -> ::treesitter_types::Span {
19372 match self {
19373 Self::Discard(inner) => inner.span(),
19374 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
19375 }
19376 }
19377}
19378#[derive(Debug, Clone, PartialEq, Eq)]
19379pub enum VariableDeclaratorChildren<'tree> {
19380 BracketedArgumentList(::std::boxed::Box<BracketedArgumentList<'tree>>),
19381 Expression(::std::boxed::Box<Expression<'tree>>),
19382 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
19383}
19384impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorChildren<'tree> {
19385 #[allow(clippy::collapsible_else_if)]
19386 fn from_node(
19387 node: ::treesitter_types::tree_sitter::Node<'tree>,
19388 src: &'tree [u8],
19389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19390 match node.kind() {
19391 "bracketed_argument_list" => Ok(Self::BracketedArgumentList(::std::boxed::Box::new(
19392 ::treesitter_types::runtime::maybe_grow_stack(|| {
19393 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19394 })?,
19395 ))),
19396 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
19397 ::treesitter_types::runtime::maybe_grow_stack(|| {
19398 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
19399 })?,
19400 ))),
19401 _other => {
19402 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19403 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19404 }) {
19405 Ok(Self::Expression(::std::boxed::Box::new(v)))
19406 } else {
19407 Err(::treesitter_types::ParseError::unexpected_kind(
19408 _other, node,
19409 ))
19410 }
19411 }
19412 }
19413 }
19414}
19415impl ::treesitter_types::Spanned for VariableDeclaratorChildren<'_> {
19416 fn span(&self) -> ::treesitter_types::Span {
19417 match self {
19418 Self::BracketedArgumentList(inner) => inner.span(),
19419 Self::Expression(inner) => inner.span(),
19420 Self::TuplePattern(inner) => inner.span(),
19421 }
19422 }
19423}
19424#[derive(Debug, Clone, PartialEq, Eq)]
19425pub enum WithExpressionChildren<'tree> {
19426 Expression(::std::boxed::Box<Expression<'tree>>),
19427 WithInitializer(::std::boxed::Box<WithInitializer<'tree>>),
19428}
19429impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpressionChildren<'tree> {
19430 #[allow(clippy::collapsible_else_if)]
19431 fn from_node(
19432 node: ::treesitter_types::tree_sitter::Node<'tree>,
19433 src: &'tree [u8],
19434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19435 match node.kind() {
19436 "with_initializer" => Ok(Self::WithInitializer(::std::boxed::Box::new(
19437 ::treesitter_types::runtime::maybe_grow_stack(|| {
19438 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)
19439 })?,
19440 ))),
19441 _other => {
19442 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19443 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19444 }) {
19445 Ok(Self::Expression(::std::boxed::Box::new(v)))
19446 } else {
19447 Err(::treesitter_types::ParseError::unexpected_kind(
19448 _other, node,
19449 ))
19450 }
19451 }
19452 }
19453 }
19454}
19455impl ::treesitter_types::Spanned for WithExpressionChildren<'_> {
19456 fn span(&self) -> ::treesitter_types::Span {
19457 match self {
19458 Self::Expression(inner) => inner.span(),
19459 Self::WithInitializer(inner) => inner.span(),
19460 }
19461 }
19462}
19463#[derive(Debug, Clone, PartialEq, Eq)]
19464pub enum WithInitializerChildren<'tree> {
19465 Expression(::std::boxed::Box<Expression<'tree>>),
19466 Identifier(::std::boxed::Box<Identifier<'tree>>),
19467}
19468impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializerChildren<'tree> {
19469 #[allow(clippy::collapsible_else_if)]
19470 fn from_node(
19471 node: ::treesitter_types::tree_sitter::Node<'tree>,
19472 src: &'tree [u8],
19473 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19474 match node.kind() {
19475 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19476 ::treesitter_types::runtime::maybe_grow_stack(|| {
19477 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19478 })?,
19479 ))),
19480 _other => {
19481 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19482 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19483 }) {
19484 Ok(Self::Expression(::std::boxed::Box::new(v)))
19485 } else {
19486 Err(::treesitter_types::ParseError::unexpected_kind(
19487 _other, node,
19488 ))
19489 }
19490 }
19491 }
19492 }
19493}
19494impl ::treesitter_types::Spanned for WithInitializerChildren<'_> {
19495 fn span(&self) -> ::treesitter_types::Span {
19496 match self {
19497 Self::Expression(inner) => inner.span(),
19498 Self::Identifier(inner) => inner.span(),
19499 }
19500 }
19501}
19502#[derive(Debug, Clone, PartialEq, Eq)]
19503pub enum AnyNode<'tree> {
19504 Declaration(Declaration<'tree>),
19505 Expression(Expression<'tree>),
19506 Literal(Literal<'tree>),
19507 LvalueExpression(LvalueExpression<'tree>),
19508 NonLvalueExpression(NonLvalueExpression<'tree>),
19509 Pattern(Pattern<'tree>),
19510 Statement(Statement<'tree>),
19511 Type(Type<'tree>),
19512 TypeDeclaration(TypeDeclaration<'tree>),
19513 AccessorDeclaration(AccessorDeclaration<'tree>),
19514 AccessorList(AccessorList<'tree>),
19515 AliasQualifiedName(AliasQualifiedName<'tree>),
19516 AndPattern(AndPattern<'tree>),
19517 AnonymousMethodExpression(AnonymousMethodExpression<'tree>),
19518 AnonymousObjectCreationExpression(AnonymousObjectCreationExpression<'tree>),
19519 Argument(Argument<'tree>),
19520 ArgumentList(ArgumentList<'tree>),
19521 ArrayCreationExpression(ArrayCreationExpression<'tree>),
19522 ArrayRankSpecifier(ArrayRankSpecifier<'tree>),
19523 ArrayType(ArrayType<'tree>),
19524 ArrowExpressionClause(ArrowExpressionClause<'tree>),
19525 AsExpression(AsExpression<'tree>),
19526 AssignmentExpression(AssignmentExpression<'tree>),
19527 Attribute(Attribute<'tree>),
19528 AttributeArgument(AttributeArgument<'tree>),
19529 AttributeArgumentList(AttributeArgumentList<'tree>),
19530 AttributeList(AttributeList<'tree>),
19531 AttributeTargetSpecifier(AttributeTargetSpecifier<'tree>),
19532 AwaitExpression(AwaitExpression<'tree>),
19533 BaseList(BaseList<'tree>),
19534 BinaryExpression(BinaryExpression<'tree>),
19535 Block(Block<'tree>),
19536 BooleanLiteral(BooleanLiteral<'tree>),
19537 BracketedArgumentList(BracketedArgumentList<'tree>),
19538 BracketedParameterList(BracketedParameterList<'tree>),
19539 BreakStatement(BreakStatement<'tree>),
19540 CallingConvention(CallingConvention<'tree>),
19541 CastExpression(CastExpression<'tree>),
19542 CatchClause(CatchClause<'tree>),
19543 CatchDeclaration(CatchDeclaration<'tree>),
19544 CatchFilterClause(CatchFilterClause<'tree>),
19545 CharacterLiteral(CharacterLiteral<'tree>),
19546 CheckedExpression(CheckedExpression<'tree>),
19547 CheckedStatement(CheckedStatement<'tree>),
19548 ClassDeclaration(ClassDeclaration<'tree>),
19549 CompilationUnit(CompilationUnit<'tree>),
19550 ConditionalAccessExpression(ConditionalAccessExpression<'tree>),
19551 ConditionalExpression(ConditionalExpression<'tree>),
19552 ConstantPattern(ConstantPattern<'tree>),
19553 ConstructorConstraint(ConstructorConstraint<'tree>),
19554 ConstructorDeclaration(ConstructorDeclaration<'tree>),
19555 ConstructorInitializer(ConstructorInitializer<'tree>),
19556 ContinueStatement(ContinueStatement<'tree>),
19557 ConversionOperatorDeclaration(ConversionOperatorDeclaration<'tree>),
19558 DeclarationExpression(DeclarationExpression<'tree>),
19559 DeclarationList(DeclarationList<'tree>),
19560 DeclarationPattern(DeclarationPattern<'tree>),
19561 DefaultExpression(DefaultExpression<'tree>),
19562 DelegateDeclaration(DelegateDeclaration<'tree>),
19563 DestructorDeclaration(DestructorDeclaration<'tree>),
19564 DoStatement(DoStatement<'tree>),
19565 ElementAccessExpression(ElementAccessExpression<'tree>),
19566 ElementBindingExpression(ElementBindingExpression<'tree>),
19567 EmptyStatement(EmptyStatement<'tree>),
19568 EnumDeclaration(EnumDeclaration<'tree>),
19569 EnumMemberDeclaration(EnumMemberDeclaration<'tree>),
19570 EnumMemberDeclarationList(EnumMemberDeclarationList<'tree>),
19571 EventDeclaration(EventDeclaration<'tree>),
19572 EventFieldDeclaration(EventFieldDeclaration<'tree>),
19573 ExplicitInterfaceSpecifier(ExplicitInterfaceSpecifier<'tree>),
19574 ExpressionStatement(ExpressionStatement<'tree>),
19575 ExternAliasDirective(ExternAliasDirective<'tree>),
19576 FieldDeclaration(FieldDeclaration<'tree>),
19577 FileScopedNamespaceDeclaration(FileScopedNamespaceDeclaration<'tree>),
19578 FinallyClause(FinallyClause<'tree>),
19579 FixedStatement(FixedStatement<'tree>),
19580 ForStatement(ForStatement<'tree>),
19581 ForeachStatement(ForeachStatement<'tree>),
19582 FromClause(FromClause<'tree>),
19583 FunctionPointerParameter(FunctionPointerParameter<'tree>),
19584 FunctionPointerType(FunctionPointerType<'tree>),
19585 GenericName(GenericName<'tree>),
19586 GlobalAttribute(GlobalAttribute<'tree>),
19587 GlobalStatement(GlobalStatement<'tree>),
19588 GotoStatement(GotoStatement<'tree>),
19589 GroupClause(GroupClause<'tree>),
19590 Identifier(Identifier<'tree>),
19591 IfStatement(IfStatement<'tree>),
19592 ImplicitArrayCreationExpression(ImplicitArrayCreationExpression<'tree>),
19593 ImplicitObjectCreationExpression(ImplicitObjectCreationExpression<'tree>),
19594 ImplicitParameter(ImplicitParameter<'tree>),
19595 ImplicitStackallocExpression(ImplicitStackallocExpression<'tree>),
19596 ImplicitType(ImplicitType<'tree>),
19597 IndexerDeclaration(IndexerDeclaration<'tree>),
19598 InitializerExpression(InitializerExpression<'tree>),
19599 InterfaceDeclaration(InterfaceDeclaration<'tree>),
19600 InterpolatedStringExpression(InterpolatedStringExpression<'tree>),
19601 Interpolation(Interpolation<'tree>),
19602 InterpolationAlignmentClause(InterpolationAlignmentClause<'tree>),
19603 InterpolationFormatClause(InterpolationFormatClause<'tree>),
19604 InvocationExpression(InvocationExpression<'tree>),
19605 IsExpression(IsExpression<'tree>),
19606 IsPatternExpression(IsPatternExpression<'tree>),
19607 JoinClause(JoinClause<'tree>),
19608 JoinIntoClause(JoinIntoClause<'tree>),
19609 LabeledStatement(LabeledStatement<'tree>),
19610 LambdaExpression(LambdaExpression<'tree>),
19611 LetClause(LetClause<'tree>),
19612 ListPattern(ListPattern<'tree>),
19613 LocalDeclarationStatement(LocalDeclarationStatement<'tree>),
19614 LocalFunctionStatement(LocalFunctionStatement<'tree>),
19615 LockStatement(LockStatement<'tree>),
19616 MakerefExpression(MakerefExpression<'tree>),
19617 MemberAccessExpression(MemberAccessExpression<'tree>),
19618 MemberBindingExpression(MemberBindingExpression<'tree>),
19619 MethodDeclaration(MethodDeclaration<'tree>),
19620 Modifier(Modifier<'tree>),
19621 NamespaceDeclaration(NamespaceDeclaration<'tree>),
19622 NegatedPattern(NegatedPattern<'tree>),
19623 NullableType(NullableType<'tree>),
19624 ObjectCreationExpression(ObjectCreationExpression<'tree>),
19625 OperatorDeclaration(OperatorDeclaration<'tree>),
19626 OrPattern(OrPattern<'tree>),
19627 OrderByClause(OrderByClause<'tree>),
19628 Parameter(Parameter<'tree>),
19629 ParameterList(ParameterList<'tree>),
19630 ParenthesizedExpression(ParenthesizedExpression<'tree>),
19631 ParenthesizedPattern(ParenthesizedPattern<'tree>),
19632 ParenthesizedVariableDesignation(ParenthesizedVariableDesignation<'tree>),
19633 PointerType(PointerType<'tree>),
19634 PositionalPatternClause(PositionalPatternClause<'tree>),
19635 PostfixUnaryExpression(PostfixUnaryExpression<'tree>),
19636 PrefixUnaryExpression(PrefixUnaryExpression<'tree>),
19637 PreprocDefine(PreprocDefine<'tree>),
19638 PreprocElif(PreprocElif<'tree>),
19639 PreprocElse(PreprocElse<'tree>),
19640 PreprocEndregion(PreprocEndregion<'tree>),
19641 PreprocError(PreprocError<'tree>),
19642 PreprocIf(PreprocIf<'tree>),
19643 PreprocLine(PreprocLine<'tree>),
19644 PreprocNullable(PreprocNullable<'tree>),
19645 PreprocPragma(PreprocPragma<'tree>),
19646 PreprocRegion(PreprocRegion<'tree>),
19647 PreprocUndef(PreprocUndef<'tree>),
19648 PreprocWarning(PreprocWarning<'tree>),
19649 PrimaryConstructorBaseType(PrimaryConstructorBaseType<'tree>),
19650 PropertyDeclaration(PropertyDeclaration<'tree>),
19651 PropertyPatternClause(PropertyPatternClause<'tree>),
19652 QualifiedName(QualifiedName<'tree>),
19653 QueryExpression(QueryExpression<'tree>),
19654 RangeExpression(RangeExpression<'tree>),
19655 RawStringLiteral(RawStringLiteral<'tree>),
19656 RecordDeclaration(RecordDeclaration<'tree>),
19657 RecursivePattern(RecursivePattern<'tree>),
19658 RefExpression(RefExpression<'tree>),
19659 RefType(RefType<'tree>),
19660 ReftypeExpression(ReftypeExpression<'tree>),
19661 RefvalueExpression(RefvalueExpression<'tree>),
19662 RelationalPattern(RelationalPattern<'tree>),
19663 ReturnStatement(ReturnStatement<'tree>),
19664 ScopedType(ScopedType<'tree>),
19665 SelectClause(SelectClause<'tree>),
19666 SizeofExpression(SizeofExpression<'tree>),
19667 StackallocExpression(StackallocExpression<'tree>),
19668 StringLiteral(StringLiteral<'tree>),
19669 StringLiteralContent(StringLiteralContent<'tree>),
19670 StructDeclaration(StructDeclaration<'tree>),
19671 Subpattern(Subpattern<'tree>),
19672 SwitchBody(SwitchBody<'tree>),
19673 SwitchExpression(SwitchExpression<'tree>),
19674 SwitchExpressionArm(SwitchExpressionArm<'tree>),
19675 SwitchSection(SwitchSection<'tree>),
19676 SwitchStatement(SwitchStatement<'tree>),
19677 ThrowExpression(ThrowExpression<'tree>),
19678 ThrowStatement(ThrowStatement<'tree>),
19679 TryStatement(TryStatement<'tree>),
19680 TupleElement(TupleElement<'tree>),
19681 TupleExpression(TupleExpression<'tree>),
19682 TuplePattern(TuplePattern<'tree>),
19683 TupleType(TupleType<'tree>),
19684 TypeArgumentList(TypeArgumentList<'tree>),
19685 TypeParameter(TypeParameter<'tree>),
19686 TypeParameterConstraint(TypeParameterConstraint<'tree>),
19687 TypeParameterConstraintsClause(TypeParameterConstraintsClause<'tree>),
19688 TypeParameterList(TypeParameterList<'tree>),
19689 TypePattern(TypePattern<'tree>),
19690 TypeofExpression(TypeofExpression<'tree>),
19691 UnaryExpression(UnaryExpression<'tree>),
19692 UnsafeStatement(UnsafeStatement<'tree>),
19693 UsingDirective(UsingDirective<'tree>),
19694 UsingStatement(UsingStatement<'tree>),
19695 VarPattern(VarPattern<'tree>),
19696 VariableDeclaration(VariableDeclaration<'tree>),
19697 VariableDeclarator(VariableDeclarator<'tree>),
19698 WhenClause(WhenClause<'tree>),
19699 WhereClause(WhereClause<'tree>),
19700 WhileStatement(WhileStatement<'tree>),
19701 WithExpression(WithExpression<'tree>),
19702 WithInitializer(WithInitializer<'tree>),
19703 YieldStatement(YieldStatement<'tree>),
19704 CharacterLiteralContent(CharacterLiteralContent<'tree>),
19705 Comment(Comment<'tree>),
19706 Discard(Discard<'tree>),
19707 EscapeSequence(EscapeSequence<'tree>),
19708 IntegerLiteral(IntegerLiteral<'tree>),
19709 InterpolationBrace(InterpolationBrace<'tree>),
19710 InterpolationQuote(InterpolationQuote<'tree>),
19711 InterpolationStart(InterpolationStart<'tree>),
19712 NullLiteral(NullLiteral<'tree>),
19713 PredefinedType(PredefinedType<'tree>),
19714 PreprocArg(PreprocArg<'tree>),
19715 RawStringContent(RawStringContent<'tree>),
19716 RawStringEnd(RawStringEnd<'tree>),
19717 RawStringStart(RawStringStart<'tree>),
19718 RealLiteral(RealLiteral<'tree>),
19719 ShebangDirective(ShebangDirective<'tree>),
19720 StringContent(StringContent<'tree>),
19721 StringLiteralEncoding(StringLiteralEncoding<'tree>),
19722 VerbatimStringLiteral(VerbatimStringLiteral<'tree>),
19723 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
19724}
19725impl<'tree> AnyNode<'tree> {
19726 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
19727 match node.kind() {
19728 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19729 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
19730 })
19731 .map(Self::Declaration)
19732 .unwrap_or(Self::Unknown(node)),
19733 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19734 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19735 })
19736 .map(Self::Expression)
19737 .unwrap_or(Self::Unknown(node)),
19738 "literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19739 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
19740 })
19741 .map(Self::Literal)
19742 .unwrap_or(Self::Unknown(node)),
19743 "lvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19744 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
19745 })
19746 .map(Self::LvalueExpression)
19747 .unwrap_or(Self::Unknown(node)),
19748 "non_lvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19749 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
19750 })
19751 .map(Self::NonLvalueExpression)
19752 .unwrap_or(Self::Unknown(node)),
19753 "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19754 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
19755 })
19756 .map(Self::Pattern)
19757 .unwrap_or(Self::Unknown(node)),
19758 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19759 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
19760 })
19761 .map(Self::Statement)
19762 .unwrap_or(Self::Unknown(node)),
19763 "type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19764 <Type as ::treesitter_types::FromNode>::from_node(node, src)
19765 })
19766 .map(Self::Type)
19767 .unwrap_or(Self::Unknown(node)),
19768 "type_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19769 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19770 })
19771 .map(Self::TypeDeclaration)
19772 .unwrap_or(Self::Unknown(node)),
19773 "accessor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19774 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19775 })
19776 .map(Self::AccessorDeclaration)
19777 .unwrap_or(Self::Unknown(node)),
19778 "accessor_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19779 <AccessorList as ::treesitter_types::FromNode>::from_node(node, src)
19780 })
19781 .map(Self::AccessorList)
19782 .unwrap_or(Self::Unknown(node)),
19783 "alias_qualified_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19784 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19785 })
19786 .map(Self::AliasQualifiedName)
19787 .unwrap_or(Self::Unknown(node)),
19788 "and_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19789 <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)
19790 })
19791 .map(Self::AndPattern)
19792 .unwrap_or(Self::Unknown(node)),
19793 "anonymous_method_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19794 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(node, src)
19795 })
19796 .map(Self::AnonymousMethodExpression)
19797 .unwrap_or(Self::Unknown(node)),
19798 "anonymous_object_creation_expression" => {
19799 ::treesitter_types::runtime::maybe_grow_stack(|| {
19800 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
19801 node, src,
19802 )
19803 })
19804 .map(Self::AnonymousObjectCreationExpression)
19805 .unwrap_or(Self::Unknown(node))
19806 }
19807 "argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19808 <Argument as ::treesitter_types::FromNode>::from_node(node, src)
19809 })
19810 .map(Self::Argument)
19811 .unwrap_or(Self::Unknown(node)),
19812 "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19813 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19814 })
19815 .map(Self::ArgumentList)
19816 .unwrap_or(Self::Unknown(node)),
19817 "array_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19818 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
19819 })
19820 .map(Self::ArrayCreationExpression)
19821 .unwrap_or(Self::Unknown(node)),
19822 "array_rank_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19823 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19824 })
19825 .map(Self::ArrayRankSpecifier)
19826 .unwrap_or(Self::Unknown(node)),
19827 "array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19828 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
19829 })
19830 .map(Self::ArrayType)
19831 .unwrap_or(Self::Unknown(node)),
19832 "arrow_expression_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19833 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
19834 })
19835 .map(Self::ArrowExpressionClause)
19836 .unwrap_or(Self::Unknown(node)),
19837 "as_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19838 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
19839 })
19840 .map(Self::AsExpression)
19841 .unwrap_or(Self::Unknown(node)),
19842 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19843 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
19844 })
19845 .map(Self::AssignmentExpression)
19846 .unwrap_or(Self::Unknown(node)),
19847 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19848 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
19849 })
19850 .map(Self::Attribute)
19851 .unwrap_or(Self::Unknown(node)),
19852 "attribute_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19853 <AttributeArgument as ::treesitter_types::FromNode>::from_node(node, src)
19854 })
19855 .map(Self::AttributeArgument)
19856 .unwrap_or(Self::Unknown(node)),
19857 "attribute_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19858 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19859 })
19860 .map(Self::AttributeArgumentList)
19861 .unwrap_or(Self::Unknown(node)),
19862 "attribute_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19863 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19864 })
19865 .map(Self::AttributeList)
19866 .unwrap_or(Self::Unknown(node)),
19867 "attribute_target_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19868 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19869 })
19870 .map(Self::AttributeTargetSpecifier)
19871 .unwrap_or(Self::Unknown(node)),
19872 "await_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19873 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
19874 })
19875 .map(Self::AwaitExpression)
19876 .unwrap_or(Self::Unknown(node)),
19877 "base_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19878 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
19879 })
19880 .map(Self::BaseList)
19881 .unwrap_or(Self::Unknown(node)),
19882 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19883 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19884 })
19885 .map(Self::BinaryExpression)
19886 .unwrap_or(Self::Unknown(node)),
19887 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19888 <Block as ::treesitter_types::FromNode>::from_node(node, src)
19889 })
19890 .map(Self::Block)
19891 .unwrap_or(Self::Unknown(node)),
19892 "boolean_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19893 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19894 })
19895 .map(Self::BooleanLiteral)
19896 .unwrap_or(Self::Unknown(node)),
19897 "bracketed_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19898 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19899 })
19900 .map(Self::BracketedArgumentList)
19901 .unwrap_or(Self::Unknown(node)),
19902 "bracketed_parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19903 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19904 })
19905 .map(Self::BracketedParameterList)
19906 .unwrap_or(Self::Unknown(node)),
19907 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19908 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
19909 })
19910 .map(Self::BreakStatement)
19911 .unwrap_or(Self::Unknown(node)),
19912 "calling_convention" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19913 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
19914 })
19915 .map(Self::CallingConvention)
19916 .unwrap_or(Self::Unknown(node)),
19917 "cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19918 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
19919 })
19920 .map(Self::CastExpression)
19921 .unwrap_or(Self::Unknown(node)),
19922 "catch_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19923 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
19924 })
19925 .map(Self::CatchClause)
19926 .unwrap_or(Self::Unknown(node)),
19927 "catch_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19928 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19929 })
19930 .map(Self::CatchDeclaration)
19931 .unwrap_or(Self::Unknown(node)),
19932 "catch_filter_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19933 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)
19934 })
19935 .map(Self::CatchFilterClause)
19936 .unwrap_or(Self::Unknown(node)),
19937 "character_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19938 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19939 })
19940 .map(Self::CharacterLiteral)
19941 .unwrap_or(Self::Unknown(node)),
19942 "checked_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19943 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)
19944 })
19945 .map(Self::CheckedExpression)
19946 .unwrap_or(Self::Unknown(node)),
19947 "checked_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19948 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)
19949 })
19950 .map(Self::CheckedStatement)
19951 .unwrap_or(Self::Unknown(node)),
19952 "class_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19953 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19954 })
19955 .map(Self::ClassDeclaration)
19956 .unwrap_or(Self::Unknown(node)),
19957 "compilation_unit" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19958 <CompilationUnit as ::treesitter_types::FromNode>::from_node(node, src)
19959 })
19960 .map(Self::CompilationUnit)
19961 .unwrap_or(Self::Unknown(node)),
19962 "conditional_access_expression" => {
19963 ::treesitter_types::runtime::maybe_grow_stack(|| {
19964 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
19965 node, src,
19966 )
19967 })
19968 .map(Self::ConditionalAccessExpression)
19969 .unwrap_or(Self::Unknown(node))
19970 }
19971 "conditional_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19972 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
19973 })
19974 .map(Self::ConditionalExpression)
19975 .unwrap_or(Self::Unknown(node)),
19976 "constant_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19977 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)
19978 })
19979 .map(Self::ConstantPattern)
19980 .unwrap_or(Self::Unknown(node)),
19981 "constructor_constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19982 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(node, src)
19983 })
19984 .map(Self::ConstructorConstraint)
19985 .unwrap_or(Self::Unknown(node)),
19986 "constructor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19987 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19988 })
19989 .map(Self::ConstructorDeclaration)
19990 .unwrap_or(Self::Unknown(node)),
19991 "constructor_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19992 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)
19993 })
19994 .map(Self::ConstructorInitializer)
19995 .unwrap_or(Self::Unknown(node)),
19996 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
19997 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
19998 })
19999 .map(Self::ContinueStatement)
20000 .unwrap_or(Self::Unknown(node)),
20001 "conversion_operator_declaration" => {
20002 ::treesitter_types::runtime::maybe_grow_stack(|| {
20003 <ConversionOperatorDeclaration as ::treesitter_types::FromNode>::from_node(
20004 node, src,
20005 )
20006 })
20007 .map(Self::ConversionOperatorDeclaration)
20008 .unwrap_or(Self::Unknown(node))
20009 }
20010 "declaration_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20011 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)
20012 })
20013 .map(Self::DeclarationExpression)
20014 .unwrap_or(Self::Unknown(node)),
20015 "declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20016 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
20017 })
20018 .map(Self::DeclarationList)
20019 .unwrap_or(Self::Unknown(node)),
20020 "declaration_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20021 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)
20022 })
20023 .map(Self::DeclarationPattern)
20024 .unwrap_or(Self::Unknown(node)),
20025 "default_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20026 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
20027 })
20028 .map(Self::DefaultExpression)
20029 .unwrap_or(Self::Unknown(node)),
20030 "delegate_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20031 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20032 })
20033 .map(Self::DelegateDeclaration)
20034 .unwrap_or(Self::Unknown(node)),
20035 "destructor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20036 <DestructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20037 })
20038 .map(Self::DestructorDeclaration)
20039 .unwrap_or(Self::Unknown(node)),
20040 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20041 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
20042 })
20043 .map(Self::DoStatement)
20044 .unwrap_or(Self::Unknown(node)),
20045 "element_access_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20046 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
20047 })
20048 .map(Self::ElementAccessExpression)
20049 .unwrap_or(Self::Unknown(node)),
20050 "element_binding_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20051 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
20052 })
20053 .map(Self::ElementBindingExpression)
20054 .unwrap_or(Self::Unknown(node)),
20055 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20056 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
20057 })
20058 .map(Self::EmptyStatement)
20059 .unwrap_or(Self::Unknown(node)),
20060 "enum_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20061 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20062 })
20063 .map(Self::EnumDeclaration)
20064 .unwrap_or(Self::Unknown(node)),
20065 "enum_member_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20066 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20067 })
20068 .map(Self::EnumMemberDeclaration)
20069 .unwrap_or(Self::Unknown(node)),
20070 "enum_member_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20071 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
20072 })
20073 .map(Self::EnumMemberDeclarationList)
20074 .unwrap_or(Self::Unknown(node)),
20075 "event_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20076 <EventDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20077 })
20078 .map(Self::EventDeclaration)
20079 .unwrap_or(Self::Unknown(node)),
20080 "event_field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20081 <EventFieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20082 })
20083 .map(Self::EventFieldDeclaration)
20084 .unwrap_or(Self::Unknown(node)),
20085 "explicit_interface_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20086 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20087 })
20088 .map(Self::ExplicitInterfaceSpecifier)
20089 .unwrap_or(Self::Unknown(node)),
20090 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20091 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
20092 })
20093 .map(Self::ExpressionStatement)
20094 .unwrap_or(Self::Unknown(node)),
20095 "extern_alias_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20096 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
20097 })
20098 .map(Self::ExternAliasDirective)
20099 .unwrap_or(Self::Unknown(node)),
20100 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20101 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20102 })
20103 .map(Self::FieldDeclaration)
20104 .unwrap_or(Self::Unknown(node)),
20105 "file_scoped_namespace_declaration" => {
20106 ::treesitter_types::runtime::maybe_grow_stack(|| {
20107 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
20108 node, src,
20109 )
20110 })
20111 .map(Self::FileScopedNamespaceDeclaration)
20112 .unwrap_or(Self::Unknown(node))
20113 }
20114 "finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20115 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
20116 })
20117 .map(Self::FinallyClause)
20118 .unwrap_or(Self::Unknown(node)),
20119 "fixed_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20120 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)
20121 })
20122 .map(Self::FixedStatement)
20123 .unwrap_or(Self::Unknown(node)),
20124 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20125 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
20126 })
20127 .map(Self::ForStatement)
20128 .unwrap_or(Self::Unknown(node)),
20129 "foreach_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20130 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
20131 })
20132 .map(Self::ForeachStatement)
20133 .unwrap_or(Self::Unknown(node)),
20134 "from_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20135 <FromClause as ::treesitter_types::FromNode>::from_node(node, src)
20136 })
20137 .map(Self::FromClause)
20138 .unwrap_or(Self::Unknown(node)),
20139 "function_pointer_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20140 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(node, src)
20141 })
20142 .map(Self::FunctionPointerParameter)
20143 .unwrap_or(Self::Unknown(node)),
20144 "function_pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20145 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
20146 })
20147 .map(Self::FunctionPointerType)
20148 .unwrap_or(Self::Unknown(node)),
20149 "generic_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20150 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
20151 })
20152 .map(Self::GenericName)
20153 .unwrap_or(Self::Unknown(node)),
20154 "global_attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20155 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
20156 })
20157 .map(Self::GlobalAttribute)
20158 .unwrap_or(Self::Unknown(node)),
20159 "global_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20160 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)
20161 })
20162 .map(Self::GlobalStatement)
20163 .unwrap_or(Self::Unknown(node)),
20164 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20165 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
20166 })
20167 .map(Self::GotoStatement)
20168 .unwrap_or(Self::Unknown(node)),
20169 "group_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20170 <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)
20171 })
20172 .map(Self::GroupClause)
20173 .unwrap_or(Self::Unknown(node)),
20174 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20175 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20176 })
20177 .map(Self::Identifier)
20178 .unwrap_or(Self::Unknown(node)),
20179 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20180 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
20181 })
20182 .map(Self::IfStatement)
20183 .unwrap_or(Self::Unknown(node)),
20184 "implicit_array_creation_expression" => {
20185 ::treesitter_types::runtime::maybe_grow_stack(|| {
20186 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
20187 node, src,
20188 )
20189 })
20190 .map(Self::ImplicitArrayCreationExpression)
20191 .unwrap_or(Self::Unknown(node))
20192 }
20193 "implicit_object_creation_expression" => {
20194 ::treesitter_types::runtime::maybe_grow_stack(|| {
20195 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
20196 node, src,
20197 )
20198 })
20199 .map(Self::ImplicitObjectCreationExpression)
20200 .unwrap_or(Self::Unknown(node))
20201 }
20202 "implicit_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20203 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
20204 })
20205 .map(Self::ImplicitParameter)
20206 .unwrap_or(Self::Unknown(node)),
20207 "implicit_stackalloc_expression" => {
20208 ::treesitter_types::runtime::maybe_grow_stack(|| {
20209 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(
20210 node, src,
20211 )
20212 })
20213 .map(Self::ImplicitStackallocExpression)
20214 .unwrap_or(Self::Unknown(node))
20215 }
20216 "implicit_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20217 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
20218 })
20219 .map(Self::ImplicitType)
20220 .unwrap_or(Self::Unknown(node)),
20221 "indexer_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20222 <IndexerDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20223 })
20224 .map(Self::IndexerDeclaration)
20225 .unwrap_or(Self::Unknown(node)),
20226 "initializer_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20227 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
20228 })
20229 .map(Self::InitializerExpression)
20230 .unwrap_or(Self::Unknown(node)),
20231 "interface_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20232 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20233 })
20234 .map(Self::InterfaceDeclaration)
20235 .unwrap_or(Self::Unknown(node)),
20236 "interpolated_string_expression" => {
20237 ::treesitter_types::runtime::maybe_grow_stack(|| {
20238 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
20239 node, src,
20240 )
20241 })
20242 .map(Self::InterpolatedStringExpression)
20243 .unwrap_or(Self::Unknown(node))
20244 }
20245 "interpolation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20246 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
20247 })
20248 .map(Self::Interpolation)
20249 .unwrap_or(Self::Unknown(node)),
20250 "interpolation_alignment_clause" => {
20251 ::treesitter_types::runtime::maybe_grow_stack(|| {
20252 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(
20253 node, src,
20254 )
20255 })
20256 .map(Self::InterpolationAlignmentClause)
20257 .unwrap_or(Self::Unknown(node))
20258 }
20259 "interpolation_format_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20260 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(node, src)
20261 })
20262 .map(Self::InterpolationFormatClause)
20263 .unwrap_or(Self::Unknown(node)),
20264 "invocation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20265 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
20266 })
20267 .map(Self::InvocationExpression)
20268 .unwrap_or(Self::Unknown(node)),
20269 "is_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20270 <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)
20271 })
20272 .map(Self::IsExpression)
20273 .unwrap_or(Self::Unknown(node)),
20274 "is_pattern_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20275 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)
20276 })
20277 .map(Self::IsPatternExpression)
20278 .unwrap_or(Self::Unknown(node)),
20279 "join_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20280 <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)
20281 })
20282 .map(Self::JoinClause)
20283 .unwrap_or(Self::Unknown(node)),
20284 "join_into_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20285 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)
20286 })
20287 .map(Self::JoinIntoClause)
20288 .unwrap_or(Self::Unknown(node)),
20289 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20290 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
20291 })
20292 .map(Self::LabeledStatement)
20293 .unwrap_or(Self::Unknown(node)),
20294 "lambda_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20295 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
20296 })
20297 .map(Self::LambdaExpression)
20298 .unwrap_or(Self::Unknown(node)),
20299 "let_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20300 <LetClause as ::treesitter_types::FromNode>::from_node(node, src)
20301 })
20302 .map(Self::LetClause)
20303 .unwrap_or(Self::Unknown(node)),
20304 "list_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20305 <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)
20306 })
20307 .map(Self::ListPattern)
20308 .unwrap_or(Self::Unknown(node)),
20309 "local_declaration_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20310 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
20311 })
20312 .map(Self::LocalDeclarationStatement)
20313 .unwrap_or(Self::Unknown(node)),
20314 "local_function_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20315 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)
20316 })
20317 .map(Self::LocalFunctionStatement)
20318 .unwrap_or(Self::Unknown(node)),
20319 "lock_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20320 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)
20321 })
20322 .map(Self::LockStatement)
20323 .unwrap_or(Self::Unknown(node)),
20324 "makeref_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20325 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)
20326 })
20327 .map(Self::MakerefExpression)
20328 .unwrap_or(Self::Unknown(node)),
20329 "member_access_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20330 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
20331 })
20332 .map(Self::MemberAccessExpression)
20333 .unwrap_or(Self::Unknown(node)),
20334 "member_binding_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20335 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
20336 })
20337 .map(Self::MemberBindingExpression)
20338 .unwrap_or(Self::Unknown(node)),
20339 "method_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20340 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20341 })
20342 .map(Self::MethodDeclaration)
20343 .unwrap_or(Self::Unknown(node)),
20344 "modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20345 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
20346 })
20347 .map(Self::Modifier)
20348 .unwrap_or(Self::Unknown(node)),
20349 "namespace_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20350 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20351 })
20352 .map(Self::NamespaceDeclaration)
20353 .unwrap_or(Self::Unknown(node)),
20354 "negated_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20355 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)
20356 })
20357 .map(Self::NegatedPattern)
20358 .unwrap_or(Self::Unknown(node)),
20359 "nullable_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20360 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
20361 })
20362 .map(Self::NullableType)
20363 .unwrap_or(Self::Unknown(node)),
20364 "object_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20365 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
20366 })
20367 .map(Self::ObjectCreationExpression)
20368 .unwrap_or(Self::Unknown(node)),
20369 "operator_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20370 <OperatorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20371 })
20372 .map(Self::OperatorDeclaration)
20373 .unwrap_or(Self::Unknown(node)),
20374 "or_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20375 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
20376 })
20377 .map(Self::OrPattern)
20378 .unwrap_or(Self::Unknown(node)),
20379 "order_by_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20380 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)
20381 })
20382 .map(Self::OrderByClause)
20383 .unwrap_or(Self::Unknown(node)),
20384 "parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20385 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
20386 })
20387 .map(Self::Parameter)
20388 .unwrap_or(Self::Unknown(node)),
20389 "parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20390 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
20391 })
20392 .map(Self::ParameterList)
20393 .unwrap_or(Self::Unknown(node)),
20394 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20395 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
20396 })
20397 .map(Self::ParenthesizedExpression)
20398 .unwrap_or(Self::Unknown(node)),
20399 "parenthesized_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20400 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
20401 })
20402 .map(Self::ParenthesizedPattern)
20403 .unwrap_or(Self::Unknown(node)),
20404 "parenthesized_variable_designation" => {
20405 ::treesitter_types::runtime::maybe_grow_stack(|| {
20406 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
20407 node, src,
20408 )
20409 })
20410 .map(Self::ParenthesizedVariableDesignation)
20411 .unwrap_or(Self::Unknown(node))
20412 }
20413 "pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20414 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
20415 })
20416 .map(Self::PointerType)
20417 .unwrap_or(Self::Unknown(node)),
20418 "positional_pattern_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20419 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
20420 })
20421 .map(Self::PositionalPatternClause)
20422 .unwrap_or(Self::Unknown(node)),
20423 "postfix_unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20424 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20425 })
20426 .map(Self::PostfixUnaryExpression)
20427 .unwrap_or(Self::Unknown(node)),
20428 "prefix_unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20429 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20430 })
20431 .map(Self::PrefixUnaryExpression)
20432 .unwrap_or(Self::Unknown(node)),
20433 "preproc_define" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20434 <PreprocDefine as ::treesitter_types::FromNode>::from_node(node, src)
20435 })
20436 .map(Self::PreprocDefine)
20437 .unwrap_or(Self::Unknown(node)),
20438 "preproc_elif" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20439 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
20440 })
20441 .map(Self::PreprocElif)
20442 .unwrap_or(Self::Unknown(node)),
20443 "preproc_else" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20444 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
20445 })
20446 .map(Self::PreprocElse)
20447 .unwrap_or(Self::Unknown(node)),
20448 "preproc_endregion" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20449 <PreprocEndregion as ::treesitter_types::FromNode>::from_node(node, src)
20450 })
20451 .map(Self::PreprocEndregion)
20452 .unwrap_or(Self::Unknown(node)),
20453 "preproc_error" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20454 <PreprocError as ::treesitter_types::FromNode>::from_node(node, src)
20455 })
20456 .map(Self::PreprocError)
20457 .unwrap_or(Self::Unknown(node)),
20458 "preproc_if" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20459 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
20460 })
20461 .map(Self::PreprocIf)
20462 .unwrap_or(Self::Unknown(node)),
20463 "preproc_line" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20464 <PreprocLine as ::treesitter_types::FromNode>::from_node(node, src)
20465 })
20466 .map(Self::PreprocLine)
20467 .unwrap_or(Self::Unknown(node)),
20468 "preproc_nullable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20469 <PreprocNullable as ::treesitter_types::FromNode>::from_node(node, src)
20470 })
20471 .map(Self::PreprocNullable)
20472 .unwrap_or(Self::Unknown(node)),
20473 "preproc_pragma" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20474 <PreprocPragma as ::treesitter_types::FromNode>::from_node(node, src)
20475 })
20476 .map(Self::PreprocPragma)
20477 .unwrap_or(Self::Unknown(node)),
20478 "preproc_region" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20479 <PreprocRegion as ::treesitter_types::FromNode>::from_node(node, src)
20480 })
20481 .map(Self::PreprocRegion)
20482 .unwrap_or(Self::Unknown(node)),
20483 "preproc_undef" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20484 <PreprocUndef as ::treesitter_types::FromNode>::from_node(node, src)
20485 })
20486 .map(Self::PreprocUndef)
20487 .unwrap_or(Self::Unknown(node)),
20488 "preproc_warning" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20489 <PreprocWarning as ::treesitter_types::FromNode>::from_node(node, src)
20490 })
20491 .map(Self::PreprocWarning)
20492 .unwrap_or(Self::Unknown(node)),
20493 "primary_constructor_base_type" => {
20494 ::treesitter_types::runtime::maybe_grow_stack(|| {
20495 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(
20496 node, src,
20497 )
20498 })
20499 .map(Self::PrimaryConstructorBaseType)
20500 .unwrap_or(Self::Unknown(node))
20501 }
20502 "property_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20503 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20504 })
20505 .map(Self::PropertyDeclaration)
20506 .unwrap_or(Self::Unknown(node)),
20507 "property_pattern_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20508 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
20509 })
20510 .map(Self::PropertyPatternClause)
20511 .unwrap_or(Self::Unknown(node)),
20512 "qualified_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20513 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
20514 })
20515 .map(Self::QualifiedName)
20516 .unwrap_or(Self::Unknown(node)),
20517 "query_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20518 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20519 })
20520 .map(Self::QueryExpression)
20521 .unwrap_or(Self::Unknown(node)),
20522 "range_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20523 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
20524 })
20525 .map(Self::RangeExpression)
20526 .unwrap_or(Self::Unknown(node)),
20527 "raw_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20528 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20529 })
20530 .map(Self::RawStringLiteral)
20531 .unwrap_or(Self::Unknown(node)),
20532 "record_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20533 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20534 })
20535 .map(Self::RecordDeclaration)
20536 .unwrap_or(Self::Unknown(node)),
20537 "recursive_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20538 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)
20539 })
20540 .map(Self::RecursivePattern)
20541 .unwrap_or(Self::Unknown(node)),
20542 "ref_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20543 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)
20544 })
20545 .map(Self::RefExpression)
20546 .unwrap_or(Self::Unknown(node)),
20547 "ref_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20548 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
20549 })
20550 .map(Self::RefType)
20551 .unwrap_or(Self::Unknown(node)),
20552 "reftype_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20553 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)
20554 })
20555 .map(Self::ReftypeExpression)
20556 .unwrap_or(Self::Unknown(node)),
20557 "refvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20558 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
20559 })
20560 .map(Self::RefvalueExpression)
20561 .unwrap_or(Self::Unknown(node)),
20562 "relational_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20563 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)
20564 })
20565 .map(Self::RelationalPattern)
20566 .unwrap_or(Self::Unknown(node)),
20567 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20568 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
20569 })
20570 .map(Self::ReturnStatement)
20571 .unwrap_or(Self::Unknown(node)),
20572 "scoped_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20573 <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)
20574 })
20575 .map(Self::ScopedType)
20576 .unwrap_or(Self::Unknown(node)),
20577 "select_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20578 <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)
20579 })
20580 .map(Self::SelectClause)
20581 .unwrap_or(Self::Unknown(node)),
20582 "sizeof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20583 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
20584 })
20585 .map(Self::SizeofExpression)
20586 .unwrap_or(Self::Unknown(node)),
20587 "stackalloc_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20588 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
20589 })
20590 .map(Self::StackallocExpression)
20591 .unwrap_or(Self::Unknown(node)),
20592 "string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20593 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20594 })
20595 .map(Self::StringLiteral)
20596 .unwrap_or(Self::Unknown(node)),
20597 "string_literal_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20598 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
20599 })
20600 .map(Self::StringLiteralContent)
20601 .unwrap_or(Self::Unknown(node)),
20602 "struct_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20603 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20604 })
20605 .map(Self::StructDeclaration)
20606 .unwrap_or(Self::Unknown(node)),
20607 "subpattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20608 <Subpattern as ::treesitter_types::FromNode>::from_node(node, src)
20609 })
20610 .map(Self::Subpattern)
20611 .unwrap_or(Self::Unknown(node)),
20612 "switch_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20613 <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
20614 })
20615 .map(Self::SwitchBody)
20616 .unwrap_or(Self::Unknown(node)),
20617 "switch_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20618 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
20619 })
20620 .map(Self::SwitchExpression)
20621 .unwrap_or(Self::Unknown(node)),
20622 "switch_expression_arm" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20623 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)
20624 })
20625 .map(Self::SwitchExpressionArm)
20626 .unwrap_or(Self::Unknown(node)),
20627 "switch_section" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20628 <SwitchSection as ::treesitter_types::FromNode>::from_node(node, src)
20629 })
20630 .map(Self::SwitchSection)
20631 .unwrap_or(Self::Unknown(node)),
20632 "switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20633 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
20634 })
20635 .map(Self::SwitchStatement)
20636 .unwrap_or(Self::Unknown(node)),
20637 "throw_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20638 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
20639 })
20640 .map(Self::ThrowExpression)
20641 .unwrap_or(Self::Unknown(node)),
20642 "throw_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20643 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
20644 })
20645 .map(Self::ThrowStatement)
20646 .unwrap_or(Self::Unknown(node)),
20647 "try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20648 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
20649 })
20650 .map(Self::TryStatement)
20651 .unwrap_or(Self::Unknown(node)),
20652 "tuple_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20653 <TupleElement as ::treesitter_types::FromNode>::from_node(node, src)
20654 })
20655 .map(Self::TupleElement)
20656 .unwrap_or(Self::Unknown(node)),
20657 "tuple_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20658 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
20659 })
20660 .map(Self::TupleExpression)
20661 .unwrap_or(Self::Unknown(node)),
20662 "tuple_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20663 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
20664 })
20665 .map(Self::TuplePattern)
20666 .unwrap_or(Self::Unknown(node)),
20667 "tuple_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20668 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
20669 })
20670 .map(Self::TupleType)
20671 .unwrap_or(Self::Unknown(node)),
20672 "type_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20673 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20674 })
20675 .map(Self::TypeArgumentList)
20676 .unwrap_or(Self::Unknown(node)),
20677 "type_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20678 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
20679 })
20680 .map(Self::TypeParameter)
20681 .unwrap_or(Self::Unknown(node)),
20682 "type_parameter_constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20683 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(node, src)
20684 })
20685 .map(Self::TypeParameterConstraint)
20686 .unwrap_or(Self::Unknown(node)),
20687 "type_parameter_constraints_clause" => {
20688 ::treesitter_types::runtime::maybe_grow_stack(|| {
20689 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
20690 node, src,
20691 )
20692 })
20693 .map(Self::TypeParameterConstraintsClause)
20694 .unwrap_or(Self::Unknown(node))
20695 }
20696 "type_parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20697 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
20698 })
20699 .map(Self::TypeParameterList)
20700 .unwrap_or(Self::Unknown(node)),
20701 "type_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20702 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
20703 })
20704 .map(Self::TypePattern)
20705 .unwrap_or(Self::Unknown(node)),
20706 "typeof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20707 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
20708 })
20709 .map(Self::TypeofExpression)
20710 .unwrap_or(Self::Unknown(node)),
20711 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20712 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20713 })
20714 .map(Self::UnaryExpression)
20715 .unwrap_or(Self::Unknown(node)),
20716 "unsafe_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20717 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)
20718 })
20719 .map(Self::UnsafeStatement)
20720 .unwrap_or(Self::Unknown(node)),
20721 "using_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20722 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
20723 })
20724 .map(Self::UsingDirective)
20725 .unwrap_or(Self::Unknown(node)),
20726 "using_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20727 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)
20728 })
20729 .map(Self::UsingStatement)
20730 .unwrap_or(Self::Unknown(node)),
20731 "var_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20732 <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)
20733 })
20734 .map(Self::VarPattern)
20735 .unwrap_or(Self::Unknown(node)),
20736 "variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20737 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20738 })
20739 .map(Self::VariableDeclaration)
20740 .unwrap_or(Self::Unknown(node)),
20741 "variable_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20742 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
20743 })
20744 .map(Self::VariableDeclarator)
20745 .unwrap_or(Self::Unknown(node)),
20746 "when_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20747 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
20748 })
20749 .map(Self::WhenClause)
20750 .unwrap_or(Self::Unknown(node)),
20751 "where_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20752 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
20753 })
20754 .map(Self::WhereClause)
20755 .unwrap_or(Self::Unknown(node)),
20756 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20757 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
20758 })
20759 .map(Self::WhileStatement)
20760 .unwrap_or(Self::Unknown(node)),
20761 "with_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20762 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)
20763 })
20764 .map(Self::WithExpression)
20765 .unwrap_or(Self::Unknown(node)),
20766 "with_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20767 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)
20768 })
20769 .map(Self::WithInitializer)
20770 .unwrap_or(Self::Unknown(node)),
20771 "yield_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20772 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
20773 })
20774 .map(Self::YieldStatement)
20775 .unwrap_or(Self::Unknown(node)),
20776 "character_literal_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20777 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
20778 })
20779 .map(Self::CharacterLiteralContent)
20780 .unwrap_or(Self::Unknown(node)),
20781 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20782 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
20783 })
20784 .map(Self::Comment)
20785 .unwrap_or(Self::Unknown(node)),
20786 "discard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20787 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
20788 })
20789 .map(Self::Discard)
20790 .unwrap_or(Self::Unknown(node)),
20791 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20792 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
20793 })
20794 .map(Self::EscapeSequence)
20795 .unwrap_or(Self::Unknown(node)),
20796 "integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20797 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20798 })
20799 .map(Self::IntegerLiteral)
20800 .unwrap_or(Self::Unknown(node)),
20801 "interpolation_brace" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20802 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)
20803 })
20804 .map(Self::InterpolationBrace)
20805 .unwrap_or(Self::Unknown(node)),
20806 "interpolation_quote" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20807 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)
20808 })
20809 .map(Self::InterpolationQuote)
20810 .unwrap_or(Self::Unknown(node)),
20811 "interpolation_start" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20812 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)
20813 })
20814 .map(Self::InterpolationStart)
20815 .unwrap_or(Self::Unknown(node)),
20816 "null_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20817 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20818 })
20819 .map(Self::NullLiteral)
20820 .unwrap_or(Self::Unknown(node)),
20821 "predefined_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20822 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
20823 })
20824 .map(Self::PredefinedType)
20825 .unwrap_or(Self::Unknown(node)),
20826 "preproc_arg" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20827 <PreprocArg as ::treesitter_types::FromNode>::from_node(node, src)
20828 })
20829 .map(Self::PreprocArg)
20830 .unwrap_or(Self::Unknown(node)),
20831 "raw_string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20832 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
20833 })
20834 .map(Self::RawStringContent)
20835 .unwrap_or(Self::Unknown(node)),
20836 "raw_string_end" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20837 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)
20838 })
20839 .map(Self::RawStringEnd)
20840 .unwrap_or(Self::Unknown(node)),
20841 "raw_string_start" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20842 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)
20843 })
20844 .map(Self::RawStringStart)
20845 .unwrap_or(Self::Unknown(node)),
20846 "real_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20847 <RealLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20848 })
20849 .map(Self::RealLiteral)
20850 .unwrap_or(Self::Unknown(node)),
20851 "shebang_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20852 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)
20853 })
20854 .map(Self::ShebangDirective)
20855 .unwrap_or(Self::Unknown(node)),
20856 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20857 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
20858 })
20859 .map(Self::StringContent)
20860 .unwrap_or(Self::Unknown(node)),
20861 "string_literal_encoding" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20862 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)
20863 })
20864 .map(Self::StringLiteralEncoding)
20865 .unwrap_or(Self::Unknown(node)),
20866 "verbatim_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20867 <VerbatimStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20868 })
20869 .map(Self::VerbatimStringLiteral)
20870 .unwrap_or(Self::Unknown(node)),
20871 _ => Self::Unknown(node),
20872 }
20873 }
20874}
20875impl ::treesitter_types::Spanned for AnyNode<'_> {
20876 fn span(&self) -> ::treesitter_types::Span {
20877 match self {
20878 Self::Declaration(inner) => inner.span(),
20879 Self::Expression(inner) => inner.span(),
20880 Self::Literal(inner) => inner.span(),
20881 Self::LvalueExpression(inner) => inner.span(),
20882 Self::NonLvalueExpression(inner) => inner.span(),
20883 Self::Pattern(inner) => inner.span(),
20884 Self::Statement(inner) => inner.span(),
20885 Self::Type(inner) => inner.span(),
20886 Self::TypeDeclaration(inner) => inner.span(),
20887 Self::AccessorDeclaration(inner) => inner.span(),
20888 Self::AccessorList(inner) => inner.span(),
20889 Self::AliasQualifiedName(inner) => inner.span(),
20890 Self::AndPattern(inner) => inner.span(),
20891 Self::AnonymousMethodExpression(inner) => inner.span(),
20892 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
20893 Self::Argument(inner) => inner.span(),
20894 Self::ArgumentList(inner) => inner.span(),
20895 Self::ArrayCreationExpression(inner) => inner.span(),
20896 Self::ArrayRankSpecifier(inner) => inner.span(),
20897 Self::ArrayType(inner) => inner.span(),
20898 Self::ArrowExpressionClause(inner) => inner.span(),
20899 Self::AsExpression(inner) => inner.span(),
20900 Self::AssignmentExpression(inner) => inner.span(),
20901 Self::Attribute(inner) => inner.span(),
20902 Self::AttributeArgument(inner) => inner.span(),
20903 Self::AttributeArgumentList(inner) => inner.span(),
20904 Self::AttributeList(inner) => inner.span(),
20905 Self::AttributeTargetSpecifier(inner) => inner.span(),
20906 Self::AwaitExpression(inner) => inner.span(),
20907 Self::BaseList(inner) => inner.span(),
20908 Self::BinaryExpression(inner) => inner.span(),
20909 Self::Block(inner) => inner.span(),
20910 Self::BooleanLiteral(inner) => inner.span(),
20911 Self::BracketedArgumentList(inner) => inner.span(),
20912 Self::BracketedParameterList(inner) => inner.span(),
20913 Self::BreakStatement(inner) => inner.span(),
20914 Self::CallingConvention(inner) => inner.span(),
20915 Self::CastExpression(inner) => inner.span(),
20916 Self::CatchClause(inner) => inner.span(),
20917 Self::CatchDeclaration(inner) => inner.span(),
20918 Self::CatchFilterClause(inner) => inner.span(),
20919 Self::CharacterLiteral(inner) => inner.span(),
20920 Self::CheckedExpression(inner) => inner.span(),
20921 Self::CheckedStatement(inner) => inner.span(),
20922 Self::ClassDeclaration(inner) => inner.span(),
20923 Self::CompilationUnit(inner) => inner.span(),
20924 Self::ConditionalAccessExpression(inner) => inner.span(),
20925 Self::ConditionalExpression(inner) => inner.span(),
20926 Self::ConstantPattern(inner) => inner.span(),
20927 Self::ConstructorConstraint(inner) => inner.span(),
20928 Self::ConstructorDeclaration(inner) => inner.span(),
20929 Self::ConstructorInitializer(inner) => inner.span(),
20930 Self::ContinueStatement(inner) => inner.span(),
20931 Self::ConversionOperatorDeclaration(inner) => inner.span(),
20932 Self::DeclarationExpression(inner) => inner.span(),
20933 Self::DeclarationList(inner) => inner.span(),
20934 Self::DeclarationPattern(inner) => inner.span(),
20935 Self::DefaultExpression(inner) => inner.span(),
20936 Self::DelegateDeclaration(inner) => inner.span(),
20937 Self::DestructorDeclaration(inner) => inner.span(),
20938 Self::DoStatement(inner) => inner.span(),
20939 Self::ElementAccessExpression(inner) => inner.span(),
20940 Self::ElementBindingExpression(inner) => inner.span(),
20941 Self::EmptyStatement(inner) => inner.span(),
20942 Self::EnumDeclaration(inner) => inner.span(),
20943 Self::EnumMemberDeclaration(inner) => inner.span(),
20944 Self::EnumMemberDeclarationList(inner) => inner.span(),
20945 Self::EventDeclaration(inner) => inner.span(),
20946 Self::EventFieldDeclaration(inner) => inner.span(),
20947 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
20948 Self::ExpressionStatement(inner) => inner.span(),
20949 Self::ExternAliasDirective(inner) => inner.span(),
20950 Self::FieldDeclaration(inner) => inner.span(),
20951 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
20952 Self::FinallyClause(inner) => inner.span(),
20953 Self::FixedStatement(inner) => inner.span(),
20954 Self::ForStatement(inner) => inner.span(),
20955 Self::ForeachStatement(inner) => inner.span(),
20956 Self::FromClause(inner) => inner.span(),
20957 Self::FunctionPointerParameter(inner) => inner.span(),
20958 Self::FunctionPointerType(inner) => inner.span(),
20959 Self::GenericName(inner) => inner.span(),
20960 Self::GlobalAttribute(inner) => inner.span(),
20961 Self::GlobalStatement(inner) => inner.span(),
20962 Self::GotoStatement(inner) => inner.span(),
20963 Self::GroupClause(inner) => inner.span(),
20964 Self::Identifier(inner) => inner.span(),
20965 Self::IfStatement(inner) => inner.span(),
20966 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
20967 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
20968 Self::ImplicitParameter(inner) => inner.span(),
20969 Self::ImplicitStackallocExpression(inner) => inner.span(),
20970 Self::ImplicitType(inner) => inner.span(),
20971 Self::IndexerDeclaration(inner) => inner.span(),
20972 Self::InitializerExpression(inner) => inner.span(),
20973 Self::InterfaceDeclaration(inner) => inner.span(),
20974 Self::InterpolatedStringExpression(inner) => inner.span(),
20975 Self::Interpolation(inner) => inner.span(),
20976 Self::InterpolationAlignmentClause(inner) => inner.span(),
20977 Self::InterpolationFormatClause(inner) => inner.span(),
20978 Self::InvocationExpression(inner) => inner.span(),
20979 Self::IsExpression(inner) => inner.span(),
20980 Self::IsPatternExpression(inner) => inner.span(),
20981 Self::JoinClause(inner) => inner.span(),
20982 Self::JoinIntoClause(inner) => inner.span(),
20983 Self::LabeledStatement(inner) => inner.span(),
20984 Self::LambdaExpression(inner) => inner.span(),
20985 Self::LetClause(inner) => inner.span(),
20986 Self::ListPattern(inner) => inner.span(),
20987 Self::LocalDeclarationStatement(inner) => inner.span(),
20988 Self::LocalFunctionStatement(inner) => inner.span(),
20989 Self::LockStatement(inner) => inner.span(),
20990 Self::MakerefExpression(inner) => inner.span(),
20991 Self::MemberAccessExpression(inner) => inner.span(),
20992 Self::MemberBindingExpression(inner) => inner.span(),
20993 Self::MethodDeclaration(inner) => inner.span(),
20994 Self::Modifier(inner) => inner.span(),
20995 Self::NamespaceDeclaration(inner) => inner.span(),
20996 Self::NegatedPattern(inner) => inner.span(),
20997 Self::NullableType(inner) => inner.span(),
20998 Self::ObjectCreationExpression(inner) => inner.span(),
20999 Self::OperatorDeclaration(inner) => inner.span(),
21000 Self::OrPattern(inner) => inner.span(),
21001 Self::OrderByClause(inner) => inner.span(),
21002 Self::Parameter(inner) => inner.span(),
21003 Self::ParameterList(inner) => inner.span(),
21004 Self::ParenthesizedExpression(inner) => inner.span(),
21005 Self::ParenthesizedPattern(inner) => inner.span(),
21006 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
21007 Self::PointerType(inner) => inner.span(),
21008 Self::PositionalPatternClause(inner) => inner.span(),
21009 Self::PostfixUnaryExpression(inner) => inner.span(),
21010 Self::PrefixUnaryExpression(inner) => inner.span(),
21011 Self::PreprocDefine(inner) => inner.span(),
21012 Self::PreprocElif(inner) => inner.span(),
21013 Self::PreprocElse(inner) => inner.span(),
21014 Self::PreprocEndregion(inner) => inner.span(),
21015 Self::PreprocError(inner) => inner.span(),
21016 Self::PreprocIf(inner) => inner.span(),
21017 Self::PreprocLine(inner) => inner.span(),
21018 Self::PreprocNullable(inner) => inner.span(),
21019 Self::PreprocPragma(inner) => inner.span(),
21020 Self::PreprocRegion(inner) => inner.span(),
21021 Self::PreprocUndef(inner) => inner.span(),
21022 Self::PreprocWarning(inner) => inner.span(),
21023 Self::PrimaryConstructorBaseType(inner) => inner.span(),
21024 Self::PropertyDeclaration(inner) => inner.span(),
21025 Self::PropertyPatternClause(inner) => inner.span(),
21026 Self::QualifiedName(inner) => inner.span(),
21027 Self::QueryExpression(inner) => inner.span(),
21028 Self::RangeExpression(inner) => inner.span(),
21029 Self::RawStringLiteral(inner) => inner.span(),
21030 Self::RecordDeclaration(inner) => inner.span(),
21031 Self::RecursivePattern(inner) => inner.span(),
21032 Self::RefExpression(inner) => inner.span(),
21033 Self::RefType(inner) => inner.span(),
21034 Self::ReftypeExpression(inner) => inner.span(),
21035 Self::RefvalueExpression(inner) => inner.span(),
21036 Self::RelationalPattern(inner) => inner.span(),
21037 Self::ReturnStatement(inner) => inner.span(),
21038 Self::ScopedType(inner) => inner.span(),
21039 Self::SelectClause(inner) => inner.span(),
21040 Self::SizeofExpression(inner) => inner.span(),
21041 Self::StackallocExpression(inner) => inner.span(),
21042 Self::StringLiteral(inner) => inner.span(),
21043 Self::StringLiteralContent(inner) => inner.span(),
21044 Self::StructDeclaration(inner) => inner.span(),
21045 Self::Subpattern(inner) => inner.span(),
21046 Self::SwitchBody(inner) => inner.span(),
21047 Self::SwitchExpression(inner) => inner.span(),
21048 Self::SwitchExpressionArm(inner) => inner.span(),
21049 Self::SwitchSection(inner) => inner.span(),
21050 Self::SwitchStatement(inner) => inner.span(),
21051 Self::ThrowExpression(inner) => inner.span(),
21052 Self::ThrowStatement(inner) => inner.span(),
21053 Self::TryStatement(inner) => inner.span(),
21054 Self::TupleElement(inner) => inner.span(),
21055 Self::TupleExpression(inner) => inner.span(),
21056 Self::TuplePattern(inner) => inner.span(),
21057 Self::TupleType(inner) => inner.span(),
21058 Self::TypeArgumentList(inner) => inner.span(),
21059 Self::TypeParameter(inner) => inner.span(),
21060 Self::TypeParameterConstraint(inner) => inner.span(),
21061 Self::TypeParameterConstraintsClause(inner) => inner.span(),
21062 Self::TypeParameterList(inner) => inner.span(),
21063 Self::TypePattern(inner) => inner.span(),
21064 Self::TypeofExpression(inner) => inner.span(),
21065 Self::UnaryExpression(inner) => inner.span(),
21066 Self::UnsafeStatement(inner) => inner.span(),
21067 Self::UsingDirective(inner) => inner.span(),
21068 Self::UsingStatement(inner) => inner.span(),
21069 Self::VarPattern(inner) => inner.span(),
21070 Self::VariableDeclaration(inner) => inner.span(),
21071 Self::VariableDeclarator(inner) => inner.span(),
21072 Self::WhenClause(inner) => inner.span(),
21073 Self::WhereClause(inner) => inner.span(),
21074 Self::WhileStatement(inner) => inner.span(),
21075 Self::WithExpression(inner) => inner.span(),
21076 Self::WithInitializer(inner) => inner.span(),
21077 Self::YieldStatement(inner) => inner.span(),
21078 Self::CharacterLiteralContent(inner) => inner.span(),
21079 Self::Comment(inner) => inner.span(),
21080 Self::Discard(inner) => inner.span(),
21081 Self::EscapeSequence(inner) => inner.span(),
21082 Self::IntegerLiteral(inner) => inner.span(),
21083 Self::InterpolationBrace(inner) => inner.span(),
21084 Self::InterpolationQuote(inner) => inner.span(),
21085 Self::InterpolationStart(inner) => inner.span(),
21086 Self::NullLiteral(inner) => inner.span(),
21087 Self::PredefinedType(inner) => inner.span(),
21088 Self::PreprocArg(inner) => inner.span(),
21089 Self::RawStringContent(inner) => inner.span(),
21090 Self::RawStringEnd(inner) => inner.span(),
21091 Self::RawStringStart(inner) => inner.span(),
21092 Self::RealLiteral(inner) => inner.span(),
21093 Self::ShebangDirective(inner) => inner.span(),
21094 Self::StringContent(inner) => inner.span(),
21095 Self::StringLiteralEncoding(inner) => inner.span(),
21096 Self::VerbatimStringLiteral(inner) => inner.span(),
21097 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
21098 }
21099 }
21100}