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 CollectionExpression(::std::boxed::Box<CollectionExpression<'tree>>),
361 ConditionalAccessExpression(::std::boxed::Box<ConditionalAccessExpression<'tree>>),
362 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
363 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
364 ImplicitArrayCreationExpression(::std::boxed::Box<ImplicitArrayCreationExpression<'tree>>),
365 ImplicitObjectCreationExpression(::std::boxed::Box<ImplicitObjectCreationExpression<'tree>>),
366 ImplicitStackallocExpression(::std::boxed::Box<ImplicitStackallocExpression<'tree>>),
367 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
368 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
369 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
370 IsExpression(::std::boxed::Box<IsExpression<'tree>>),
371 IsPatternExpression(::std::boxed::Box<IsPatternExpression<'tree>>),
372 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
373 Literal(::std::boxed::Box<Literal<'tree>>),
374 MakerefExpression(::std::boxed::Box<MakerefExpression<'tree>>),
375 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
376 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
377 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
378 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
379 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
380 QueryExpression(::std::boxed::Box<QueryExpression<'tree>>),
381 RangeExpression(::std::boxed::Box<RangeExpression<'tree>>),
382 RefExpression(::std::boxed::Box<RefExpression<'tree>>),
383 ReftypeExpression(::std::boxed::Box<ReftypeExpression<'tree>>),
384 RefvalueExpression(::std::boxed::Box<RefvalueExpression<'tree>>),
385 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
386 StackallocExpression(::std::boxed::Box<StackallocExpression<'tree>>),
387 SwitchExpression(::std::boxed::Box<SwitchExpression<'tree>>),
388 ThrowExpression(::std::boxed::Box<ThrowExpression<'tree>>),
389 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
390 WithExpression(::std::boxed::Box<WithExpression<'tree>>),
391}
392impl<'tree> ::treesitter_types::FromNode<'tree> for NonLvalueExpression<'tree> {
393 #[allow(clippy::collapsible_else_if)]
394 fn from_node(
395 node: ::treesitter_types::tree_sitter::Node<'tree>,
396 src: &'tree [u8],
397 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
398 match node.kind() {
399 "anonymous_method_expression" => Ok(Self::AnonymousMethodExpression(
400 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
401 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(
402 node, src,
403 )
404 })?),
405 )),
406 "anonymous_object_creation_expression" => Ok(Self::AnonymousObjectCreationExpression(
407 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
408 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
409 node, src,
410 )
411 })?),
412 )),
413 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
414 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
415 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
416 })?),
417 )),
418 "as_expression" => Ok(Self::AsExpression(::std::boxed::Box::new(
419 ::treesitter_types::runtime::maybe_grow_stack(|| {
420 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
421 })?,
422 ))),
423 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
424 ::treesitter_types::runtime::maybe_grow_stack(|| {
425 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
426 })?,
427 ))),
428 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
429 ::treesitter_types::runtime::maybe_grow_stack(|| {
430 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
431 })?,
432 ))),
433 "base" => Ok(Self::Base(::treesitter_types::Span::from(node))),
434 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
435 ::treesitter_types::runtime::maybe_grow_stack(|| {
436 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
437 })?,
438 ))),
439 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
440 ::treesitter_types::runtime::maybe_grow_stack(|| {
441 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
442 })?,
443 ))),
444 "checked_expression" => Ok(Self::CheckedExpression(::std::boxed::Box::new(
445 ::treesitter_types::runtime::maybe_grow_stack(|| {
446 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)
447 })?,
448 ))),
449 "collection_expression" => Ok(Self::CollectionExpression(::std::boxed::Box::new(
450 ::treesitter_types::runtime::maybe_grow_stack(|| {
451 <CollectionExpression as ::treesitter_types::FromNode>::from_node(node, src)
452 })?,
453 ))),
454 "conditional_access_expression" => Ok(Self::ConditionalAccessExpression(
455 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
456 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
457 node, src,
458 )
459 })?),
460 )),
461 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
462 ::treesitter_types::runtime::maybe_grow_stack(|| {
463 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
464 })?,
465 ))),
466 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
467 ::treesitter_types::runtime::maybe_grow_stack(|| {
468 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
469 })?,
470 ))),
471 "implicit_array_creation_expression" => Ok(Self::ImplicitArrayCreationExpression(
472 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
473 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
474 node, src,
475 )
476 })?),
477 )),
478 "implicit_object_creation_expression" => Ok(Self::ImplicitObjectCreationExpression(
479 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
480 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
481 node, src,
482 )
483 })?),
484 )),
485 "implicit_stackalloc_expression" => Ok(Self::ImplicitStackallocExpression(
486 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
487 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(
488 node, src,
489 )
490 })?),
491 )),
492 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
493 ::treesitter_types::runtime::maybe_grow_stack(|| {
494 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
495 })?,
496 ))),
497 "interpolated_string_expression" => Ok(Self::InterpolatedStringExpression(
498 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
499 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
500 node, src,
501 )
502 })?),
503 )),
504 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
505 ::treesitter_types::runtime::maybe_grow_stack(|| {
506 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
507 })?,
508 ))),
509 "is_expression" => Ok(Self::IsExpression(::std::boxed::Box::new(
510 ::treesitter_types::runtime::maybe_grow_stack(|| {
511 <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)
512 })?,
513 ))),
514 "is_pattern_expression" => Ok(Self::IsPatternExpression(::std::boxed::Box::new(
515 ::treesitter_types::runtime::maybe_grow_stack(|| {
516 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)
517 })?,
518 ))),
519 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
520 ::treesitter_types::runtime::maybe_grow_stack(|| {
521 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
522 })?,
523 ))),
524 "makeref_expression" => Ok(Self::MakerefExpression(::std::boxed::Box::new(
525 ::treesitter_types::runtime::maybe_grow_stack(|| {
526 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)
527 })?,
528 ))),
529 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
530 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
531 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
532 })?),
533 )),
534 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
535 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
536 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
537 })?),
538 )),
539 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
540 ::treesitter_types::runtime::maybe_grow_stack(|| {
541 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
542 })?,
543 ))),
544 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
545 ::treesitter_types::runtime::maybe_grow_stack(|| {
546 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
547 })?,
548 ))),
549 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
550 ::treesitter_types::runtime::maybe_grow_stack(|| {
551 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
552 })?,
553 ))),
554 "query_expression" => Ok(Self::QueryExpression(::std::boxed::Box::new(
555 ::treesitter_types::runtime::maybe_grow_stack(|| {
556 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)
557 })?,
558 ))),
559 "range_expression" => Ok(Self::RangeExpression(::std::boxed::Box::new(
560 ::treesitter_types::runtime::maybe_grow_stack(|| {
561 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
562 })?,
563 ))),
564 "ref_expression" => Ok(Self::RefExpression(::std::boxed::Box::new(
565 ::treesitter_types::runtime::maybe_grow_stack(|| {
566 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)
567 })?,
568 ))),
569 "reftype_expression" => Ok(Self::ReftypeExpression(::std::boxed::Box::new(
570 ::treesitter_types::runtime::maybe_grow_stack(|| {
571 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)
572 })?,
573 ))),
574 "refvalue_expression" => Ok(Self::RefvalueExpression(::std::boxed::Box::new(
575 ::treesitter_types::runtime::maybe_grow_stack(|| {
576 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
577 })?,
578 ))),
579 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
580 ::treesitter_types::runtime::maybe_grow_stack(|| {
581 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
582 })?,
583 ))),
584 "stackalloc_expression" => Ok(Self::StackallocExpression(::std::boxed::Box::new(
585 ::treesitter_types::runtime::maybe_grow_stack(|| {
586 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
587 })?,
588 ))),
589 "switch_expression" => Ok(Self::SwitchExpression(::std::boxed::Box::new(
590 ::treesitter_types::runtime::maybe_grow_stack(|| {
591 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
592 })?,
593 ))),
594 "throw_expression" => Ok(Self::ThrowExpression(::std::boxed::Box::new(
595 ::treesitter_types::runtime::maybe_grow_stack(|| {
596 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
597 })?,
598 ))),
599 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
600 ::treesitter_types::runtime::maybe_grow_stack(|| {
601 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
602 })?,
603 ))),
604 "with_expression" => Ok(Self::WithExpression(::std::boxed::Box::new(
605 ::treesitter_types::runtime::maybe_grow_stack(|| {
606 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)
607 })?,
608 ))),
609 _other => {
610 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
611 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
612 }) {
613 Ok(Self::Literal(::std::boxed::Box::new(v)))
614 } else {
615 Err(::treesitter_types::ParseError::unexpected_kind(
616 _other, node,
617 ))
618 }
619 }
620 }
621 }
622}
623impl ::treesitter_types::Spanned for NonLvalueExpression<'_> {
624 fn span(&self) -> ::treesitter_types::Span {
625 match self {
626 Self::AnonymousMethodExpression(inner) => inner.span(),
627 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
628 Self::ArrayCreationExpression(inner) => inner.span(),
629 Self::AsExpression(inner) => inner.span(),
630 Self::AssignmentExpression(inner) => inner.span(),
631 Self::AwaitExpression(inner) => inner.span(),
632 Self::Base(span) => *span,
633 Self::BinaryExpression(inner) => inner.span(),
634 Self::CastExpression(inner) => inner.span(),
635 Self::CheckedExpression(inner) => inner.span(),
636 Self::CollectionExpression(inner) => inner.span(),
637 Self::ConditionalAccessExpression(inner) => inner.span(),
638 Self::ConditionalExpression(inner) => inner.span(),
639 Self::DefaultExpression(inner) => inner.span(),
640 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
641 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
642 Self::ImplicitStackallocExpression(inner) => inner.span(),
643 Self::InitializerExpression(inner) => inner.span(),
644 Self::InterpolatedStringExpression(inner) => inner.span(),
645 Self::InvocationExpression(inner) => inner.span(),
646 Self::IsExpression(inner) => inner.span(),
647 Self::IsPatternExpression(inner) => inner.span(),
648 Self::LambdaExpression(inner) => inner.span(),
649 Self::Literal(inner) => inner.span(),
650 Self::MakerefExpression(inner) => inner.span(),
651 Self::ObjectCreationExpression(inner) => inner.span(),
652 Self::ParenthesizedExpression(inner) => inner.span(),
653 Self::PostfixUnaryExpression(inner) => inner.span(),
654 Self::PrefixUnaryExpression(inner) => inner.span(),
655 Self::PreprocIf(inner) => inner.span(),
656 Self::QueryExpression(inner) => inner.span(),
657 Self::RangeExpression(inner) => inner.span(),
658 Self::RefExpression(inner) => inner.span(),
659 Self::ReftypeExpression(inner) => inner.span(),
660 Self::RefvalueExpression(inner) => inner.span(),
661 Self::SizeofExpression(inner) => inner.span(),
662 Self::StackallocExpression(inner) => inner.span(),
663 Self::SwitchExpression(inner) => inner.span(),
664 Self::ThrowExpression(inner) => inner.span(),
665 Self::TypeofExpression(inner) => inner.span(),
666 Self::WithExpression(inner) => inner.span(),
667 }
668 }
669}
670#[derive(Debug, Clone, PartialEq, Eq)]
671pub enum Pattern<'tree> {
672 AndPattern(::std::boxed::Box<AndPattern<'tree>>),
673 ConstantPattern(::std::boxed::Box<ConstantPattern<'tree>>),
674 DeclarationPattern(::std::boxed::Box<DeclarationPattern<'tree>>),
675 Discard(::std::boxed::Box<Discard<'tree>>),
676 ListPattern(::std::boxed::Box<ListPattern<'tree>>),
677 NegatedPattern(::std::boxed::Box<NegatedPattern<'tree>>),
678 OrPattern(::std::boxed::Box<OrPattern<'tree>>),
679 ParenthesizedPattern(::std::boxed::Box<ParenthesizedPattern<'tree>>),
680 RecursivePattern(::std::boxed::Box<RecursivePattern<'tree>>),
681 RelationalPattern(::std::boxed::Box<RelationalPattern<'tree>>),
682 TypePattern(::std::boxed::Box<TypePattern<'tree>>),
683 VarPattern(::std::boxed::Box<VarPattern<'tree>>),
684}
685impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
686 #[allow(clippy::collapsible_else_if)]
687 fn from_node(
688 node: ::treesitter_types::tree_sitter::Node<'tree>,
689 src: &'tree [u8],
690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
691 match node.kind() {
692 "and_pattern" => Ok(Self::AndPattern(::std::boxed::Box::new(
693 ::treesitter_types::runtime::maybe_grow_stack(|| {
694 <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)
695 })?,
696 ))),
697 "constant_pattern" => Ok(Self::ConstantPattern(::std::boxed::Box::new(
698 ::treesitter_types::runtime::maybe_grow_stack(|| {
699 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)
700 })?,
701 ))),
702 "declaration_pattern" => Ok(Self::DeclarationPattern(::std::boxed::Box::new(
703 ::treesitter_types::runtime::maybe_grow_stack(|| {
704 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)
705 })?,
706 ))),
707 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
708 ::treesitter_types::runtime::maybe_grow_stack(|| {
709 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
710 })?,
711 ))),
712 "list_pattern" => Ok(Self::ListPattern(::std::boxed::Box::new(
713 ::treesitter_types::runtime::maybe_grow_stack(|| {
714 <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)
715 })?,
716 ))),
717 "negated_pattern" => Ok(Self::NegatedPattern(::std::boxed::Box::new(
718 ::treesitter_types::runtime::maybe_grow_stack(|| {
719 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)
720 })?,
721 ))),
722 "or_pattern" => Ok(Self::OrPattern(::std::boxed::Box::new(
723 ::treesitter_types::runtime::maybe_grow_stack(|| {
724 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
725 })?,
726 ))),
727 "parenthesized_pattern" => Ok(Self::ParenthesizedPattern(::std::boxed::Box::new(
728 ::treesitter_types::runtime::maybe_grow_stack(|| {
729 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
730 })?,
731 ))),
732 "recursive_pattern" => Ok(Self::RecursivePattern(::std::boxed::Box::new(
733 ::treesitter_types::runtime::maybe_grow_stack(|| {
734 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)
735 })?,
736 ))),
737 "relational_pattern" => Ok(Self::RelationalPattern(::std::boxed::Box::new(
738 ::treesitter_types::runtime::maybe_grow_stack(|| {
739 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)
740 })?,
741 ))),
742 "type_pattern" => Ok(Self::TypePattern(::std::boxed::Box::new(
743 ::treesitter_types::runtime::maybe_grow_stack(|| {
744 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
745 })?,
746 ))),
747 "var_pattern" => Ok(Self::VarPattern(::std::boxed::Box::new(
748 ::treesitter_types::runtime::maybe_grow_stack(|| {
749 <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)
750 })?,
751 ))),
752 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
753 }
754 }
755}
756impl ::treesitter_types::Spanned for Pattern<'_> {
757 fn span(&self) -> ::treesitter_types::Span {
758 match self {
759 Self::AndPattern(inner) => inner.span(),
760 Self::ConstantPattern(inner) => inner.span(),
761 Self::DeclarationPattern(inner) => inner.span(),
762 Self::Discard(inner) => inner.span(),
763 Self::ListPattern(inner) => inner.span(),
764 Self::NegatedPattern(inner) => inner.span(),
765 Self::OrPattern(inner) => inner.span(),
766 Self::ParenthesizedPattern(inner) => inner.span(),
767 Self::RecursivePattern(inner) => inner.span(),
768 Self::RelationalPattern(inner) => inner.span(),
769 Self::TypePattern(inner) => inner.span(),
770 Self::VarPattern(inner) => inner.span(),
771 }
772 }
773}
774#[derive(Debug, Clone, PartialEq, Eq)]
775pub enum Statement<'tree> {
776 Block(::std::boxed::Box<Block<'tree>>),
777 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
778 CheckedStatement(::std::boxed::Box<CheckedStatement<'tree>>),
779 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
780 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
781 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
782 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
783 FixedStatement(::std::boxed::Box<FixedStatement<'tree>>),
784 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
785 ForeachStatement(::std::boxed::Box<ForeachStatement<'tree>>),
786 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
787 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
788 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
789 LocalDeclarationStatement(::std::boxed::Box<LocalDeclarationStatement<'tree>>),
790 LocalFunctionStatement(::std::boxed::Box<LocalFunctionStatement<'tree>>),
791 LockStatement(::std::boxed::Box<LockStatement<'tree>>),
792 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
793 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
794 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
795 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
796 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
797 UnsafeStatement(::std::boxed::Box<UnsafeStatement<'tree>>),
798 UsingStatement(::std::boxed::Box<UsingStatement<'tree>>),
799 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
800 YieldStatement(::std::boxed::Box<YieldStatement<'tree>>),
801}
802impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
803 #[allow(clippy::collapsible_else_if)]
804 fn from_node(
805 node: ::treesitter_types::tree_sitter::Node<'tree>,
806 src: &'tree [u8],
807 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
808 match node.kind() {
809 "block" => Ok(Self::Block(::std::boxed::Box::new(
810 ::treesitter_types::runtime::maybe_grow_stack(|| {
811 <Block as ::treesitter_types::FromNode>::from_node(node, src)
812 })?,
813 ))),
814 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
815 ::treesitter_types::runtime::maybe_grow_stack(|| {
816 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
817 })?,
818 ))),
819 "checked_statement" => Ok(Self::CheckedStatement(::std::boxed::Box::new(
820 ::treesitter_types::runtime::maybe_grow_stack(|| {
821 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)
822 })?,
823 ))),
824 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
825 ::treesitter_types::runtime::maybe_grow_stack(|| {
826 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
827 })?,
828 ))),
829 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
830 ::treesitter_types::runtime::maybe_grow_stack(|| {
831 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
832 })?,
833 ))),
834 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
835 ::treesitter_types::runtime::maybe_grow_stack(|| {
836 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
837 })?,
838 ))),
839 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
840 ::treesitter_types::runtime::maybe_grow_stack(|| {
841 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
842 })?,
843 ))),
844 "fixed_statement" => Ok(Self::FixedStatement(::std::boxed::Box::new(
845 ::treesitter_types::runtime::maybe_grow_stack(|| {
846 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)
847 })?,
848 ))),
849 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
850 ::treesitter_types::runtime::maybe_grow_stack(|| {
851 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
852 })?,
853 ))),
854 "foreach_statement" => Ok(Self::ForeachStatement(::std::boxed::Box::new(
855 ::treesitter_types::runtime::maybe_grow_stack(|| {
856 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
857 })?,
858 ))),
859 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
860 ::treesitter_types::runtime::maybe_grow_stack(|| {
861 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
862 })?,
863 ))),
864 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
865 ::treesitter_types::runtime::maybe_grow_stack(|| {
866 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
867 })?,
868 ))),
869 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
870 ::treesitter_types::runtime::maybe_grow_stack(|| {
871 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
872 })?,
873 ))),
874 "local_declaration_statement" => Ok(Self::LocalDeclarationStatement(
875 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
876 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(
877 node, src,
878 )
879 })?),
880 )),
881 "local_function_statement" => Ok(Self::LocalFunctionStatement(::std::boxed::Box::new(
882 ::treesitter_types::runtime::maybe_grow_stack(|| {
883 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)
884 })?,
885 ))),
886 "lock_statement" => Ok(Self::LockStatement(::std::boxed::Box::new(
887 ::treesitter_types::runtime::maybe_grow_stack(|| {
888 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)
889 })?,
890 ))),
891 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
892 ::treesitter_types::runtime::maybe_grow_stack(|| {
893 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
894 })?,
895 ))),
896 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
897 ::treesitter_types::runtime::maybe_grow_stack(|| {
898 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
899 })?,
900 ))),
901 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
902 ::treesitter_types::runtime::maybe_grow_stack(|| {
903 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
904 })?,
905 ))),
906 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
907 ::treesitter_types::runtime::maybe_grow_stack(|| {
908 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
909 })?,
910 ))),
911 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
912 ::treesitter_types::runtime::maybe_grow_stack(|| {
913 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
914 })?,
915 ))),
916 "unsafe_statement" => Ok(Self::UnsafeStatement(::std::boxed::Box::new(
917 ::treesitter_types::runtime::maybe_grow_stack(|| {
918 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)
919 })?,
920 ))),
921 "using_statement" => Ok(Self::UsingStatement(::std::boxed::Box::new(
922 ::treesitter_types::runtime::maybe_grow_stack(|| {
923 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)
924 })?,
925 ))),
926 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
927 ::treesitter_types::runtime::maybe_grow_stack(|| {
928 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
929 })?,
930 ))),
931 "yield_statement" => Ok(Self::YieldStatement(::std::boxed::Box::new(
932 ::treesitter_types::runtime::maybe_grow_stack(|| {
933 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
934 })?,
935 ))),
936 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
937 }
938 }
939}
940impl ::treesitter_types::Spanned for Statement<'_> {
941 fn span(&self) -> ::treesitter_types::Span {
942 match self {
943 Self::Block(inner) => inner.span(),
944 Self::BreakStatement(inner) => inner.span(),
945 Self::CheckedStatement(inner) => inner.span(),
946 Self::ContinueStatement(inner) => inner.span(),
947 Self::DoStatement(inner) => inner.span(),
948 Self::EmptyStatement(inner) => inner.span(),
949 Self::ExpressionStatement(inner) => inner.span(),
950 Self::FixedStatement(inner) => inner.span(),
951 Self::ForStatement(inner) => inner.span(),
952 Self::ForeachStatement(inner) => inner.span(),
953 Self::GotoStatement(inner) => inner.span(),
954 Self::IfStatement(inner) => inner.span(),
955 Self::LabeledStatement(inner) => inner.span(),
956 Self::LocalDeclarationStatement(inner) => inner.span(),
957 Self::LocalFunctionStatement(inner) => inner.span(),
958 Self::LockStatement(inner) => inner.span(),
959 Self::PreprocIf(inner) => inner.span(),
960 Self::ReturnStatement(inner) => inner.span(),
961 Self::SwitchStatement(inner) => inner.span(),
962 Self::ThrowStatement(inner) => inner.span(),
963 Self::TryStatement(inner) => inner.span(),
964 Self::UnsafeStatement(inner) => inner.span(),
965 Self::UsingStatement(inner) => inner.span(),
966 Self::WhileStatement(inner) => inner.span(),
967 Self::YieldStatement(inner) => inner.span(),
968 }
969 }
970}
971#[derive(Debug, Clone, PartialEq, Eq)]
972pub enum Type<'tree> {
973 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
974 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
975 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
976 GenericName(::std::boxed::Box<GenericName<'tree>>),
977 Identifier(::std::boxed::Box<Identifier<'tree>>),
978 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
979 NullableType(::std::boxed::Box<NullableType<'tree>>),
980 PointerType(::std::boxed::Box<PointerType<'tree>>),
981 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
982 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
983 RefType(::std::boxed::Box<RefType<'tree>>),
984 ScopedType(::std::boxed::Box<ScopedType<'tree>>),
985 TupleType(::std::boxed::Box<TupleType<'tree>>),
986}
987impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
988 #[allow(clippy::collapsible_else_if)]
989 fn from_node(
990 node: ::treesitter_types::tree_sitter::Node<'tree>,
991 src: &'tree [u8],
992 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
993 match node.kind() {
994 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
995 ::treesitter_types::runtime::maybe_grow_stack(|| {
996 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
997 })?,
998 ))),
999 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
1000 ::treesitter_types::runtime::maybe_grow_stack(|| {
1001 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
1002 })?,
1003 ))),
1004 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
1005 ::treesitter_types::runtime::maybe_grow_stack(|| {
1006 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
1007 })?,
1008 ))),
1009 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
1010 ::treesitter_types::runtime::maybe_grow_stack(|| {
1011 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
1012 })?,
1013 ))),
1014 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
1015 ::treesitter_types::runtime::maybe_grow_stack(|| {
1016 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
1017 })?,
1018 ))),
1019 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
1020 ::treesitter_types::runtime::maybe_grow_stack(|| {
1021 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
1022 })?,
1023 ))),
1024 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
1025 ::treesitter_types::runtime::maybe_grow_stack(|| {
1026 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
1027 })?,
1028 ))),
1029 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
1030 ::treesitter_types::runtime::maybe_grow_stack(|| {
1031 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
1032 })?,
1033 ))),
1034 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
1035 ::treesitter_types::runtime::maybe_grow_stack(|| {
1036 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
1037 })?,
1038 ))),
1039 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
1040 ::treesitter_types::runtime::maybe_grow_stack(|| {
1041 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
1042 })?,
1043 ))),
1044 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
1045 ::treesitter_types::runtime::maybe_grow_stack(|| {
1046 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
1047 })?,
1048 ))),
1049 "scoped_type" => Ok(Self::ScopedType(::std::boxed::Box::new(
1050 ::treesitter_types::runtime::maybe_grow_stack(|| {
1051 <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)
1052 })?,
1053 ))),
1054 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
1055 ::treesitter_types::runtime::maybe_grow_stack(|| {
1056 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
1057 })?,
1058 ))),
1059 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1060 }
1061 }
1062}
1063impl ::treesitter_types::Spanned for Type<'_> {
1064 fn span(&self) -> ::treesitter_types::Span {
1065 match self {
1066 Self::AliasQualifiedName(inner) => inner.span(),
1067 Self::ArrayType(inner) => inner.span(),
1068 Self::FunctionPointerType(inner) => inner.span(),
1069 Self::GenericName(inner) => inner.span(),
1070 Self::Identifier(inner) => inner.span(),
1071 Self::ImplicitType(inner) => inner.span(),
1072 Self::NullableType(inner) => inner.span(),
1073 Self::PointerType(inner) => inner.span(),
1074 Self::PredefinedType(inner) => inner.span(),
1075 Self::QualifiedName(inner) => inner.span(),
1076 Self::RefType(inner) => inner.span(),
1077 Self::ScopedType(inner) => inner.span(),
1078 Self::TupleType(inner) => inner.span(),
1079 }
1080 }
1081}
1082#[derive(Debug, Clone, PartialEq, Eq)]
1083pub enum TypeDeclaration<'tree> {
1084 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
1085 DelegateDeclaration(::std::boxed::Box<DelegateDeclaration<'tree>>),
1086 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
1087 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
1088 RecordDeclaration(::std::boxed::Box<RecordDeclaration<'tree>>),
1089 StructDeclaration(::std::boxed::Box<StructDeclaration<'tree>>),
1090}
1091impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclaration<'tree> {
1092 #[allow(clippy::collapsible_else_if)]
1093 fn from_node(
1094 node: ::treesitter_types::tree_sitter::Node<'tree>,
1095 src: &'tree [u8],
1096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1097 match node.kind() {
1098 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
1099 ::treesitter_types::runtime::maybe_grow_stack(|| {
1100 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1101 })?,
1102 ))),
1103 "delegate_declaration" => Ok(Self::DelegateDeclaration(::std::boxed::Box::new(
1104 ::treesitter_types::runtime::maybe_grow_stack(|| {
1105 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1106 })?,
1107 ))),
1108 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
1109 ::treesitter_types::runtime::maybe_grow_stack(|| {
1110 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1111 })?,
1112 ))),
1113 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
1114 ::treesitter_types::runtime::maybe_grow_stack(|| {
1115 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1116 })?,
1117 ))),
1118 "record_declaration" => Ok(Self::RecordDeclaration(::std::boxed::Box::new(
1119 ::treesitter_types::runtime::maybe_grow_stack(|| {
1120 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1121 })?,
1122 ))),
1123 "struct_declaration" => Ok(Self::StructDeclaration(::std::boxed::Box::new(
1124 ::treesitter_types::runtime::maybe_grow_stack(|| {
1125 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
1126 })?,
1127 ))),
1128 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1129 }
1130 }
1131}
1132impl ::treesitter_types::Spanned for TypeDeclaration<'_> {
1133 fn span(&self) -> ::treesitter_types::Span {
1134 match self {
1135 Self::ClassDeclaration(inner) => inner.span(),
1136 Self::DelegateDeclaration(inner) => inner.span(),
1137 Self::EnumDeclaration(inner) => inner.span(),
1138 Self::InterfaceDeclaration(inner) => inner.span(),
1139 Self::RecordDeclaration(inner) => inner.span(),
1140 Self::StructDeclaration(inner) => inner.span(),
1141 }
1142 }
1143}
1144#[derive(Debug, Clone, PartialEq, Eq)]
1145pub struct AccessorDeclaration<'tree> {
1146 pub span: ::treesitter_types::Span,
1147 pub body: ::core::option::Option<AccessorDeclarationBody<'tree>>,
1148 pub name: AccessorDeclarationName<'tree>,
1149 pub children: ::std::vec::Vec<AccessorDeclarationChildren<'tree>>,
1150}
1151impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclaration<'tree> {
1152 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1153 fn from_node(
1154 node: ::treesitter_types::tree_sitter::Node<'tree>,
1155 src: &'tree [u8],
1156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1157 debug_assert_eq!(node.kind(), "accessor_declaration");
1158 Ok(Self {
1159 span: ::treesitter_types::Span::from(node),
1160 body: match node.child_by_field_name("body") {
1161 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1162 <AccessorDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
1163 })?),
1164 None => None,
1165 },
1166 name: {
1167 let child = node
1168 .child_by_field_name("name")
1169 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1170 ::treesitter_types::runtime::maybe_grow_stack(|| {
1171 <AccessorDeclarationName as ::treesitter_types::FromNode>::from_node(child, src)
1172 })?
1173 },
1174 children: {
1175 #[allow(clippy::suspicious_else_formatting)]
1176 let non_field_children = {
1177 let mut cursor = node.walk();
1178 let mut result = ::std::vec::Vec::new();
1179 if cursor.goto_first_child() {
1180 loop {
1181 if cursor.field_name().is_none()
1182 && cursor.node().is_named()
1183 && !cursor.node().is_extra()
1184 {
1185 result.push(cursor.node());
1186 }
1187 if !cursor.goto_next_sibling() {
1188 break;
1189 }
1190 }
1191 }
1192 result
1193 };
1194 let mut items = ::std::vec::Vec::new();
1195 for child in non_field_children {
1196 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1197 <AccessorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
1198 child, src,
1199 )
1200 })?);
1201 }
1202 items
1203 },
1204 })
1205 }
1206}
1207impl ::treesitter_types::Spanned for AccessorDeclaration<'_> {
1208 fn span(&self) -> ::treesitter_types::Span {
1209 self.span
1210 }
1211}
1212#[derive(Debug, Clone, PartialEq, Eq)]
1213pub struct AccessorList<'tree> {
1214 pub span: ::treesitter_types::Span,
1215 pub children: ::std::vec::Vec<AccessorDeclaration<'tree>>,
1216}
1217impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorList<'tree> {
1218 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1219 fn from_node(
1220 node: ::treesitter_types::tree_sitter::Node<'tree>,
1221 src: &'tree [u8],
1222 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1223 debug_assert_eq!(node.kind(), "accessor_list");
1224 Ok(Self {
1225 span: ::treesitter_types::Span::from(node),
1226 children: {
1227 #[allow(clippy::suspicious_else_formatting)]
1228 let non_field_children = {
1229 let mut cursor = node.walk();
1230 let mut result = ::std::vec::Vec::new();
1231 if cursor.goto_first_child() {
1232 loop {
1233 if cursor.field_name().is_none()
1234 && cursor.node().is_named()
1235 && !cursor.node().is_extra()
1236 {
1237 result.push(cursor.node());
1238 }
1239 if !cursor.goto_next_sibling() {
1240 break;
1241 }
1242 }
1243 }
1244 result
1245 };
1246 let mut items = ::std::vec::Vec::new();
1247 for child in non_field_children {
1248 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1249 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(child, src)
1250 })?);
1251 }
1252 items
1253 },
1254 })
1255 }
1256}
1257impl ::treesitter_types::Spanned for AccessorList<'_> {
1258 fn span(&self) -> ::treesitter_types::Span {
1259 self.span
1260 }
1261}
1262#[derive(Debug, Clone, PartialEq, Eq)]
1263pub struct AliasQualifiedName<'tree> {
1264 pub span: ::treesitter_types::Span,
1265 pub alias: Identifier<'tree>,
1266 pub name: AliasQualifiedNameName<'tree>,
1267}
1268impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedName<'tree> {
1269 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1270 fn from_node(
1271 node: ::treesitter_types::tree_sitter::Node<'tree>,
1272 src: &'tree [u8],
1273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1274 debug_assert_eq!(node.kind(), "alias_qualified_name");
1275 Ok(Self {
1276 span: ::treesitter_types::Span::from(node),
1277 alias: {
1278 let child = node
1279 .child_by_field_name("alias")
1280 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
1281 ::treesitter_types::runtime::maybe_grow_stack(|| {
1282 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1283 })?
1284 },
1285 name: {
1286 let child = node
1287 .child_by_field_name("name")
1288 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1289 ::treesitter_types::runtime::maybe_grow_stack(|| {
1290 <AliasQualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)
1291 })?
1292 },
1293 })
1294 }
1295}
1296impl ::treesitter_types::Spanned for AliasQualifiedName<'_> {
1297 fn span(&self) -> ::treesitter_types::Span {
1298 self.span
1299 }
1300}
1301#[derive(Debug, Clone, PartialEq, Eq)]
1302pub struct AndPattern<'tree> {
1303 pub span: ::treesitter_types::Span,
1304 pub left: Pattern<'tree>,
1305 pub operator: AndPatternOperator,
1306 pub right: Pattern<'tree>,
1307}
1308impl<'tree> ::treesitter_types::FromNode<'tree> for AndPattern<'tree> {
1309 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1310 fn from_node(
1311 node: ::treesitter_types::tree_sitter::Node<'tree>,
1312 src: &'tree [u8],
1313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1314 debug_assert_eq!(node.kind(), "and_pattern");
1315 Ok(Self {
1316 span: ::treesitter_types::Span::from(node),
1317 left: {
1318 let child = node
1319 .child_by_field_name("left")
1320 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1321 ::treesitter_types::runtime::maybe_grow_stack(|| {
1322 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
1323 })?
1324 },
1325 operator: {
1326 let child = node.child_by_field_name("operator").ok_or_else(|| {
1327 ::treesitter_types::ParseError::missing_field("operator", node)
1328 })?;
1329 ::treesitter_types::runtime::maybe_grow_stack(|| {
1330 <AndPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)
1331 })?
1332 },
1333 right: {
1334 let child = node
1335 .child_by_field_name("right")
1336 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1337 ::treesitter_types::runtime::maybe_grow_stack(|| {
1338 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
1339 })?
1340 },
1341 })
1342 }
1343}
1344impl ::treesitter_types::Spanned for AndPattern<'_> {
1345 fn span(&self) -> ::treesitter_types::Span {
1346 self.span
1347 }
1348}
1349#[derive(Debug, Clone, PartialEq, Eq)]
1350pub struct AnonymousMethodExpression<'tree> {
1351 pub span: ::treesitter_types::Span,
1352 pub parameters: ::core::option::Option<ParameterList<'tree>>,
1353 pub children: ::std::vec::Vec<AnonymousMethodExpressionChildren<'tree>>,
1354}
1355impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpression<'tree> {
1356 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1357 fn from_node(
1358 node: ::treesitter_types::tree_sitter::Node<'tree>,
1359 src: &'tree [u8],
1360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1361 debug_assert_eq!(node.kind(), "anonymous_method_expression");
1362 Ok(Self {
1363 span: ::treesitter_types::Span::from(node),
1364 parameters: match node.child_by_field_name("parameters") {
1365 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1366 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
1367 })?),
1368 None => None,
1369 },
1370 children: {
1371 #[allow(clippy::suspicious_else_formatting)]
1372 let non_field_children = {
1373 let mut cursor = node.walk();
1374 let mut result = ::std::vec::Vec::new();
1375 if cursor.goto_first_child() {
1376 loop {
1377 if cursor.field_name().is_none()
1378 && cursor.node().is_named()
1379 && !cursor.node().is_extra()
1380 {
1381 result.push(cursor.node());
1382 }
1383 if !cursor.goto_next_sibling() {
1384 break;
1385 }
1386 }
1387 }
1388 result
1389 };
1390 let mut items = ::std::vec::Vec::new();
1391 for child in non_field_children {
1392 items
1393 .push(
1394 ::treesitter_types::runtime::maybe_grow_stack(|| <AnonymousMethodExpressionChildren as ::treesitter_types::FromNode>::from_node(
1395 child,
1396 src,
1397 ))?,
1398 );
1399 }
1400 items
1401 },
1402 })
1403 }
1404}
1405impl ::treesitter_types::Spanned for AnonymousMethodExpression<'_> {
1406 fn span(&self) -> ::treesitter_types::Span {
1407 self.span
1408 }
1409}
1410#[derive(Debug, Clone, PartialEq, Eq)]
1411pub struct AnonymousObjectCreationExpression<'tree> {
1412 pub span: ::treesitter_types::Span,
1413 pub children: ::std::vec::Vec<AnonymousObjectCreationExpressionChildren<'tree>>,
1414}
1415impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousObjectCreationExpression<'tree> {
1416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1417 fn from_node(
1418 node: ::treesitter_types::tree_sitter::Node<'tree>,
1419 src: &'tree [u8],
1420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1421 debug_assert_eq!(node.kind(), "anonymous_object_creation_expression");
1422 Ok(Self {
1423 span: ::treesitter_types::Span::from(node),
1424 children: {
1425 #[allow(clippy::suspicious_else_formatting)]
1426 let non_field_children = {
1427 let mut cursor = node.walk();
1428 let mut result = ::std::vec::Vec::new();
1429 if cursor.goto_first_child() {
1430 loop {
1431 if cursor.field_name().is_none()
1432 && cursor.node().is_named()
1433 && !cursor.node().is_extra()
1434 {
1435 result.push(cursor.node());
1436 }
1437 if !cursor.goto_next_sibling() {
1438 break;
1439 }
1440 }
1441 }
1442 result
1443 };
1444 let mut items = ::std::vec::Vec::new();
1445 for child in non_field_children {
1446 items
1447 .push(
1448 ::treesitter_types::runtime::maybe_grow_stack(|| <AnonymousObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
1449 child,
1450 src,
1451 ))?,
1452 );
1453 }
1454 items
1455 },
1456 })
1457 }
1458}
1459impl ::treesitter_types::Spanned for AnonymousObjectCreationExpression<'_> {
1460 fn span(&self) -> ::treesitter_types::Span {
1461 self.span
1462 }
1463}
1464#[derive(Debug, Clone, PartialEq, Eq)]
1465pub struct Argument<'tree> {
1466 pub span: ::treesitter_types::Span,
1467 pub name: ::core::option::Option<Identifier<'tree>>,
1468 pub children: ArgumentChildren<'tree>,
1469}
1470impl<'tree> ::treesitter_types::FromNode<'tree> for Argument<'tree> {
1471 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1472 fn from_node(
1473 node: ::treesitter_types::tree_sitter::Node<'tree>,
1474 src: &'tree [u8],
1475 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1476 debug_assert_eq!(node.kind(), "argument");
1477 Ok(Self {
1478 span: ::treesitter_types::Span::from(node),
1479 name: match node.child_by_field_name("name") {
1480 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1481 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1482 })?),
1483 None => None,
1484 },
1485 children: {
1486 #[allow(clippy::suspicious_else_formatting)]
1487 let non_field_children = {
1488 let mut cursor = node.walk();
1489 let mut result = ::std::vec::Vec::new();
1490 if cursor.goto_first_child() {
1491 loop {
1492 if cursor.field_name().is_none()
1493 && cursor.node().is_named()
1494 && !cursor.node().is_extra()
1495 {
1496 result.push(cursor.node());
1497 }
1498 if !cursor.goto_next_sibling() {
1499 break;
1500 }
1501 }
1502 }
1503 result
1504 };
1505 let child = if let Some(&c) = non_field_children.first() {
1506 c
1507 } else {
1508 let mut fallback_cursor = node.walk();
1509 let mut fallback_child = None;
1510 if fallback_cursor.goto_first_child() {
1511 loop {
1512 if fallback_cursor.field_name().is_none()
1513 && !fallback_cursor.node().is_extra()
1514 {
1515 let candidate = fallback_cursor.node();
1516 #[allow(clippy::needless_question_mark)]
1517 if (|| -> ::core::result::Result<
1518 _,
1519 ::treesitter_types::ParseError,
1520 > {
1521 let child = candidate;
1522 Ok(
1523 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1524 child,
1525 src,
1526 ))?,
1527 )
1528 })()
1529 .is_ok()
1530 {
1531 fallback_child = Some(candidate);
1532 break;
1533 }
1534 }
1535 if !fallback_cursor.goto_next_sibling() {
1536 break;
1537 }
1538 }
1539 }
1540 if fallback_child.is_none() {
1541 let mut cursor2 = node.walk();
1542 if cursor2.goto_first_child() {
1543 loop {
1544 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1545 let candidate = cursor2.node();
1546 #[allow(clippy::needless_question_mark)]
1547 if (|| -> ::core::result::Result<
1548 _,
1549 ::treesitter_types::ParseError,
1550 > {
1551 let child = candidate;
1552 Ok(
1553 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1554 child,
1555 src,
1556 ))?,
1557 )
1558 })()
1559 .is_ok()
1560 {
1561 fallback_child = Some(candidate);
1562 break;
1563 }
1564 }
1565 if !cursor2.goto_next_sibling() {
1566 break;
1567 }
1568 }
1569 }
1570 }
1571 fallback_child.ok_or_else(|| {
1572 ::treesitter_types::ParseError::missing_field("children", node)
1573 })?
1574 };
1575 ::treesitter_types::runtime::maybe_grow_stack(|| {
1576 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(child, src)
1577 })?
1578 },
1579 })
1580 }
1581}
1582impl ::treesitter_types::Spanned for Argument<'_> {
1583 fn span(&self) -> ::treesitter_types::Span {
1584 self.span
1585 }
1586}
1587#[derive(Debug, Clone, PartialEq, Eq)]
1588pub struct ArgumentList<'tree> {
1589 pub span: ::treesitter_types::Span,
1590 pub children: ::std::vec::Vec<Argument<'tree>>,
1591}
1592impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1594 fn from_node(
1595 node: ::treesitter_types::tree_sitter::Node<'tree>,
1596 src: &'tree [u8],
1597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1598 debug_assert_eq!(node.kind(), "argument_list");
1599 Ok(Self {
1600 span: ::treesitter_types::Span::from(node),
1601 children: {
1602 #[allow(clippy::suspicious_else_formatting)]
1603 let non_field_children = {
1604 let mut cursor = node.walk();
1605 let mut result = ::std::vec::Vec::new();
1606 if cursor.goto_first_child() {
1607 loop {
1608 if cursor.field_name().is_none()
1609 && cursor.node().is_named()
1610 && !cursor.node().is_extra()
1611 {
1612 result.push(cursor.node());
1613 }
1614 if !cursor.goto_next_sibling() {
1615 break;
1616 }
1617 }
1618 }
1619 result
1620 };
1621 let mut items = ::std::vec::Vec::new();
1622 for child in non_field_children {
1623 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1624 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
1625 })?);
1626 }
1627 items
1628 },
1629 })
1630 }
1631}
1632impl ::treesitter_types::Spanned for ArgumentList<'_> {
1633 fn span(&self) -> ::treesitter_types::Span {
1634 self.span
1635 }
1636}
1637#[derive(Debug, Clone, PartialEq, Eq)]
1638pub struct ArrayCreationExpression<'tree> {
1639 pub span: ::treesitter_types::Span,
1640 pub r#type: ArrayType<'tree>,
1641 pub children: ::core::option::Option<InitializerExpression<'tree>>,
1642}
1643impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1644 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1645 fn from_node(
1646 node: ::treesitter_types::tree_sitter::Node<'tree>,
1647 src: &'tree [u8],
1648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1649 debug_assert_eq!(node.kind(), "array_creation_expression");
1650 Ok(Self {
1651 span: ::treesitter_types::Span::from(node),
1652 r#type: {
1653 let child = node
1654 .child_by_field_name("type")
1655 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1656 ::treesitter_types::runtime::maybe_grow_stack(|| {
1657 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)
1658 })?
1659 },
1660 children: {
1661 #[allow(clippy::suspicious_else_formatting)]
1662 let non_field_children = {
1663 let mut cursor = node.walk();
1664 let mut result = ::std::vec::Vec::new();
1665 if cursor.goto_first_child() {
1666 loop {
1667 if cursor.field_name().is_none()
1668 && cursor.node().is_named()
1669 && !cursor.node().is_extra()
1670 {
1671 result.push(cursor.node());
1672 }
1673 if !cursor.goto_next_sibling() {
1674 break;
1675 }
1676 }
1677 }
1678 result
1679 };
1680 match non_field_children.first() {
1681 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1682 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
1683 child, src,
1684 )
1685 })?),
1686 None => None,
1687 }
1688 },
1689 })
1690 }
1691}
1692impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1693 fn span(&self) -> ::treesitter_types::Span {
1694 self.span
1695 }
1696}
1697#[derive(Debug, Clone, PartialEq, Eq)]
1698pub struct ArrayRankSpecifier<'tree> {
1699 pub span: ::treesitter_types::Span,
1700 pub children: ::std::vec::Vec<Expression<'tree>>,
1701}
1702impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayRankSpecifier<'tree> {
1703 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1704 fn from_node(
1705 node: ::treesitter_types::tree_sitter::Node<'tree>,
1706 src: &'tree [u8],
1707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1708 debug_assert_eq!(node.kind(), "array_rank_specifier");
1709 Ok(Self {
1710 span: ::treesitter_types::Span::from(node),
1711 children: {
1712 #[allow(clippy::suspicious_else_formatting)]
1713 let non_field_children = {
1714 let mut cursor = node.walk();
1715 let mut result = ::std::vec::Vec::new();
1716 if cursor.goto_first_child() {
1717 loop {
1718 if cursor.field_name().is_none()
1719 && cursor.node().is_named()
1720 && !cursor.node().is_extra()
1721 {
1722 result.push(cursor.node());
1723 }
1724 if !cursor.goto_next_sibling() {
1725 break;
1726 }
1727 }
1728 }
1729 result
1730 };
1731 let mut items = ::std::vec::Vec::new();
1732 for child in non_field_children {
1733 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1734 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1735 })?);
1736 }
1737 items
1738 },
1739 })
1740 }
1741}
1742impl ::treesitter_types::Spanned for ArrayRankSpecifier<'_> {
1743 fn span(&self) -> ::treesitter_types::Span {
1744 self.span
1745 }
1746}
1747#[derive(Debug, Clone, PartialEq, Eq)]
1748pub struct ArrayType<'tree> {
1749 pub span: ::treesitter_types::Span,
1750 pub rank: ArrayRankSpecifier<'tree>,
1751 pub r#type: ArrayTypeType<'tree>,
1752}
1753impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1754 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1755 fn from_node(
1756 node: ::treesitter_types::tree_sitter::Node<'tree>,
1757 src: &'tree [u8],
1758 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1759 debug_assert_eq!(node.kind(), "array_type");
1760 Ok(Self {
1761 span: ::treesitter_types::Span::from(node),
1762 rank: {
1763 let child = node
1764 .child_by_field_name("rank")
1765 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("rank", node))?;
1766 ::treesitter_types::runtime::maybe_grow_stack(|| {
1767 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
1768 })?
1769 },
1770 r#type: {
1771 let child = node
1772 .child_by_field_name("type")
1773 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1774 ::treesitter_types::runtime::maybe_grow_stack(|| {
1775 <ArrayTypeType as ::treesitter_types::FromNode>::from_node(child, src)
1776 })?
1777 },
1778 })
1779 }
1780}
1781impl ::treesitter_types::Spanned for ArrayType<'_> {
1782 fn span(&self) -> ::treesitter_types::Span {
1783 self.span
1784 }
1785}
1786#[derive(Debug, Clone, PartialEq, Eq)]
1787pub struct ArrowExpressionClause<'tree> {
1788 pub span: ::treesitter_types::Span,
1789 pub children: Expression<'tree>,
1790}
1791impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowExpressionClause<'tree> {
1792 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1793 fn from_node(
1794 node: ::treesitter_types::tree_sitter::Node<'tree>,
1795 src: &'tree [u8],
1796 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1797 debug_assert_eq!(node.kind(), "arrow_expression_clause");
1798 Ok(Self {
1799 span: ::treesitter_types::Span::from(node),
1800 children: {
1801 #[allow(clippy::suspicious_else_formatting)]
1802 let non_field_children = {
1803 let mut cursor = node.walk();
1804 let mut result = ::std::vec::Vec::new();
1805 if cursor.goto_first_child() {
1806 loop {
1807 if cursor.field_name().is_none()
1808 && cursor.node().is_named()
1809 && !cursor.node().is_extra()
1810 {
1811 result.push(cursor.node());
1812 }
1813 if !cursor.goto_next_sibling() {
1814 break;
1815 }
1816 }
1817 }
1818 result
1819 };
1820 let child = if let Some(&c) = non_field_children.first() {
1821 c
1822 } else {
1823 let mut fallback_cursor = node.walk();
1824 let mut fallback_child = None;
1825 if fallback_cursor.goto_first_child() {
1826 loop {
1827 if fallback_cursor.field_name().is_none()
1828 && !fallback_cursor.node().is_extra()
1829 {
1830 let candidate = fallback_cursor.node();
1831 #[allow(clippy::needless_question_mark)]
1832 if (|| -> ::core::result::Result<
1833 _,
1834 ::treesitter_types::ParseError,
1835 > {
1836 let child = candidate;
1837 Ok(
1838 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1839 child,
1840 src,
1841 ))?,
1842 )
1843 })()
1844 .is_ok()
1845 {
1846 fallback_child = Some(candidate);
1847 break;
1848 }
1849 }
1850 if !fallback_cursor.goto_next_sibling() {
1851 break;
1852 }
1853 }
1854 }
1855 if fallback_child.is_none() {
1856 let mut cursor2 = node.walk();
1857 if cursor2.goto_first_child() {
1858 loop {
1859 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1860 let candidate = cursor2.node();
1861 #[allow(clippy::needless_question_mark)]
1862 if (|| -> ::core::result::Result<
1863 _,
1864 ::treesitter_types::ParseError,
1865 > {
1866 let child = candidate;
1867 Ok(
1868 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1869 child,
1870 src,
1871 ))?,
1872 )
1873 })()
1874 .is_ok()
1875 {
1876 fallback_child = Some(candidate);
1877 break;
1878 }
1879 }
1880 if !cursor2.goto_next_sibling() {
1881 break;
1882 }
1883 }
1884 }
1885 }
1886 fallback_child.ok_or_else(|| {
1887 ::treesitter_types::ParseError::missing_field("children", node)
1888 })?
1889 };
1890 ::treesitter_types::runtime::maybe_grow_stack(|| {
1891 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1892 })?
1893 },
1894 })
1895 }
1896}
1897impl ::treesitter_types::Spanned for ArrowExpressionClause<'_> {
1898 fn span(&self) -> ::treesitter_types::Span {
1899 self.span
1900 }
1901}
1902#[derive(Debug, Clone, PartialEq, Eq)]
1903pub struct AsExpression<'tree> {
1904 pub span: ::treesitter_types::Span,
1905 pub left: Expression<'tree>,
1906 pub operator: AsExpressionOperator,
1907 pub right: Type<'tree>,
1908}
1909impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpression<'tree> {
1910 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1911 fn from_node(
1912 node: ::treesitter_types::tree_sitter::Node<'tree>,
1913 src: &'tree [u8],
1914 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1915 debug_assert_eq!(node.kind(), "as_expression");
1916 Ok(Self {
1917 span: ::treesitter_types::Span::from(node),
1918 left: {
1919 let child = node
1920 .child_by_field_name("left")
1921 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1922 ::treesitter_types::runtime::maybe_grow_stack(|| {
1923 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1924 })?
1925 },
1926 operator: {
1927 let child = node.child_by_field_name("operator").ok_or_else(|| {
1928 ::treesitter_types::ParseError::missing_field("operator", node)
1929 })?;
1930 ::treesitter_types::runtime::maybe_grow_stack(|| {
1931 <AsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
1932 })?
1933 },
1934 right: {
1935 let child = node
1936 .child_by_field_name("right")
1937 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1938 ::treesitter_types::runtime::maybe_grow_stack(|| {
1939 <Type as ::treesitter_types::FromNode>::from_node(child, src)
1940 })?
1941 },
1942 })
1943 }
1944}
1945impl ::treesitter_types::Spanned for AsExpression<'_> {
1946 fn span(&self) -> ::treesitter_types::Span {
1947 self.span
1948 }
1949}
1950#[derive(Debug, Clone, PartialEq, Eq)]
1951pub struct AssignmentExpression<'tree> {
1952 pub span: ::treesitter_types::Span,
1953 pub left: LvalueExpression<'tree>,
1954 pub operator: AssignmentExpressionOperator,
1955 pub right: Expression<'tree>,
1956}
1957impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1958 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1959 fn from_node(
1960 node: ::treesitter_types::tree_sitter::Node<'tree>,
1961 src: &'tree [u8],
1962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1963 debug_assert_eq!(node.kind(), "assignment_expression");
1964 Ok(Self {
1965 span: ::treesitter_types::Span::from(node),
1966 left: {
1967 let child = node
1968 .child_by_field_name("left")
1969 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1970 ::treesitter_types::runtime::maybe_grow_stack(|| {
1971 <LvalueExpression as ::treesitter_types::FromNode>::from_node(child, src)
1972 })?
1973 },
1974 operator: {
1975 let child = node.child_by_field_name("operator").ok_or_else(|| {
1976 ::treesitter_types::ParseError::missing_field("operator", node)
1977 })?;
1978 ::treesitter_types::runtime::maybe_grow_stack(|| {
1979 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1980 child, src,
1981 )
1982 })?
1983 },
1984 right: {
1985 let child = node
1986 .child_by_field_name("right")
1987 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1988 ::treesitter_types::runtime::maybe_grow_stack(|| {
1989 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1990 })?
1991 },
1992 })
1993 }
1994}
1995impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1996 fn span(&self) -> ::treesitter_types::Span {
1997 self.span
1998 }
1999}
2000#[derive(Debug, Clone, PartialEq, Eq)]
2001pub struct Attribute<'tree> {
2002 pub span: ::treesitter_types::Span,
2003 pub name: AttributeName<'tree>,
2004 pub children: ::core::option::Option<AttributeArgumentList<'tree>>,
2005}
2006impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
2007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2008 fn from_node(
2009 node: ::treesitter_types::tree_sitter::Node<'tree>,
2010 src: &'tree [u8],
2011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2012 debug_assert_eq!(node.kind(), "attribute");
2013 Ok(Self {
2014 span: ::treesitter_types::Span::from(node),
2015 name: {
2016 let child = node
2017 .child_by_field_name("name")
2018 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2019 ::treesitter_types::runtime::maybe_grow_stack(|| {
2020 <AttributeName as ::treesitter_types::FromNode>::from_node(child, src)
2021 })?
2022 },
2023 children: {
2024 #[allow(clippy::suspicious_else_formatting)]
2025 let non_field_children = {
2026 let mut cursor = node.walk();
2027 let mut result = ::std::vec::Vec::new();
2028 if cursor.goto_first_child() {
2029 loop {
2030 if cursor.field_name().is_none()
2031 && cursor.node().is_named()
2032 && !cursor.node().is_extra()
2033 {
2034 result.push(cursor.node());
2035 }
2036 if !cursor.goto_next_sibling() {
2037 break;
2038 }
2039 }
2040 }
2041 result
2042 };
2043 match non_field_children.first() {
2044 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2045 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(
2046 child, src,
2047 )
2048 })?),
2049 None => None,
2050 }
2051 },
2052 })
2053 }
2054}
2055impl ::treesitter_types::Spanned for Attribute<'_> {
2056 fn span(&self) -> ::treesitter_types::Span {
2057 self.span
2058 }
2059}
2060#[derive(Debug, Clone, PartialEq, Eq)]
2061pub struct AttributeArgument<'tree> {
2062 pub span: ::treesitter_types::Span,
2063 pub name: ::core::option::Option<Identifier<'tree>>,
2064 pub children: Expression<'tree>,
2065}
2066impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgument<'tree> {
2067 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2068 fn from_node(
2069 node: ::treesitter_types::tree_sitter::Node<'tree>,
2070 src: &'tree [u8],
2071 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2072 debug_assert_eq!(node.kind(), "attribute_argument");
2073 Ok(Self {
2074 span: ::treesitter_types::Span::from(node),
2075 name: match node.child_by_field_name("name") {
2076 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2077 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2078 })?),
2079 None => None,
2080 },
2081 children: {
2082 #[allow(clippy::suspicious_else_formatting)]
2083 let non_field_children = {
2084 let mut cursor = node.walk();
2085 let mut result = ::std::vec::Vec::new();
2086 if cursor.goto_first_child() {
2087 loop {
2088 if cursor.field_name().is_none()
2089 && cursor.node().is_named()
2090 && !cursor.node().is_extra()
2091 {
2092 result.push(cursor.node());
2093 }
2094 if !cursor.goto_next_sibling() {
2095 break;
2096 }
2097 }
2098 }
2099 result
2100 };
2101 let child = if let Some(&c) = non_field_children.first() {
2102 c
2103 } else {
2104 let mut fallback_cursor = node.walk();
2105 let mut fallback_child = None;
2106 if fallback_cursor.goto_first_child() {
2107 loop {
2108 if fallback_cursor.field_name().is_none()
2109 && !fallback_cursor.node().is_extra()
2110 {
2111 let candidate = fallback_cursor.node();
2112 #[allow(clippy::needless_question_mark)]
2113 if (|| -> ::core::result::Result<
2114 _,
2115 ::treesitter_types::ParseError,
2116 > {
2117 let child = candidate;
2118 Ok(
2119 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2120 child,
2121 src,
2122 ))?,
2123 )
2124 })()
2125 .is_ok()
2126 {
2127 fallback_child = Some(candidate);
2128 break;
2129 }
2130 }
2131 if !fallback_cursor.goto_next_sibling() {
2132 break;
2133 }
2134 }
2135 }
2136 if fallback_child.is_none() {
2137 let mut cursor2 = node.walk();
2138 if cursor2.goto_first_child() {
2139 loop {
2140 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2141 let candidate = cursor2.node();
2142 #[allow(clippy::needless_question_mark)]
2143 if (|| -> ::core::result::Result<
2144 _,
2145 ::treesitter_types::ParseError,
2146 > {
2147 let child = candidate;
2148 Ok(
2149 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2150 child,
2151 src,
2152 ))?,
2153 )
2154 })()
2155 .is_ok()
2156 {
2157 fallback_child = Some(candidate);
2158 break;
2159 }
2160 }
2161 if !cursor2.goto_next_sibling() {
2162 break;
2163 }
2164 }
2165 }
2166 }
2167 fallback_child.ok_or_else(|| {
2168 ::treesitter_types::ParseError::missing_field("children", node)
2169 })?
2170 };
2171 ::treesitter_types::runtime::maybe_grow_stack(|| {
2172 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2173 })?
2174 },
2175 })
2176 }
2177}
2178impl ::treesitter_types::Spanned for AttributeArgument<'_> {
2179 fn span(&self) -> ::treesitter_types::Span {
2180 self.span
2181 }
2182}
2183#[derive(Debug, Clone, PartialEq, Eq)]
2184pub struct AttributeArgumentList<'tree> {
2185 pub span: ::treesitter_types::Span,
2186 pub children: ::std::vec::Vec<AttributeArgument<'tree>>,
2187}
2188impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeArgumentList<'tree> {
2189 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2190 fn from_node(
2191 node: ::treesitter_types::tree_sitter::Node<'tree>,
2192 src: &'tree [u8],
2193 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2194 debug_assert_eq!(node.kind(), "attribute_argument_list");
2195 Ok(Self {
2196 span: ::treesitter_types::Span::from(node),
2197 children: {
2198 #[allow(clippy::suspicious_else_formatting)]
2199 let non_field_children = {
2200 let mut cursor = node.walk();
2201 let mut result = ::std::vec::Vec::new();
2202 if cursor.goto_first_child() {
2203 loop {
2204 if cursor.field_name().is_none()
2205 && cursor.node().is_named()
2206 && !cursor.node().is_extra()
2207 {
2208 result.push(cursor.node());
2209 }
2210 if !cursor.goto_next_sibling() {
2211 break;
2212 }
2213 }
2214 }
2215 result
2216 };
2217 let mut items = ::std::vec::Vec::new();
2218 for child in non_field_children {
2219 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2220 <AttributeArgument as ::treesitter_types::FromNode>::from_node(child, src)
2221 })?);
2222 }
2223 items
2224 },
2225 })
2226 }
2227}
2228impl ::treesitter_types::Spanned for AttributeArgumentList<'_> {
2229 fn span(&self) -> ::treesitter_types::Span {
2230 self.span
2231 }
2232}
2233#[derive(Debug, Clone, PartialEq, Eq)]
2234pub struct AttributeList<'tree> {
2235 pub span: ::treesitter_types::Span,
2236 pub children: ::std::vec::Vec<AttributeListChildren<'tree>>,
2237}
2238impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeList<'tree> {
2239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2240 fn from_node(
2241 node: ::treesitter_types::tree_sitter::Node<'tree>,
2242 src: &'tree [u8],
2243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2244 debug_assert_eq!(node.kind(), "attribute_list");
2245 Ok(Self {
2246 span: ::treesitter_types::Span::from(node),
2247 children: {
2248 #[allow(clippy::suspicious_else_formatting)]
2249 let non_field_children = {
2250 let mut cursor = node.walk();
2251 let mut result = ::std::vec::Vec::new();
2252 if cursor.goto_first_child() {
2253 loop {
2254 if cursor.field_name().is_none()
2255 && cursor.node().is_named()
2256 && !cursor.node().is_extra()
2257 {
2258 result.push(cursor.node());
2259 }
2260 if !cursor.goto_next_sibling() {
2261 break;
2262 }
2263 }
2264 }
2265 result
2266 };
2267 let mut items = ::std::vec::Vec::new();
2268 for child in non_field_children {
2269 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2270 <AttributeListChildren as ::treesitter_types::FromNode>::from_node(
2271 child, src,
2272 )
2273 })?);
2274 }
2275 items
2276 },
2277 })
2278 }
2279}
2280impl ::treesitter_types::Spanned for AttributeList<'_> {
2281 fn span(&self) -> ::treesitter_types::Span {
2282 self.span
2283 }
2284}
2285#[derive(Debug, Clone, PartialEq, Eq)]
2286pub struct AttributeTargetSpecifier<'tree> {
2287 pub span: ::treesitter_types::Span,
2288 text: &'tree str,
2289}
2290impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeTargetSpecifier<'tree> {
2291 fn from_node(
2292 node: ::treesitter_types::tree_sitter::Node<'tree>,
2293 src: &'tree [u8],
2294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2295 debug_assert_eq!(node.kind(), "attribute_target_specifier");
2296 Ok(Self {
2297 span: ::treesitter_types::Span::from(node),
2298 text: node.utf8_text(src)?,
2299 })
2300 }
2301}
2302impl<'tree> ::treesitter_types::LeafNode<'tree> for AttributeTargetSpecifier<'tree> {
2303 fn text(&self) -> &'tree str {
2304 self.text
2305 }
2306}
2307impl ::treesitter_types::Spanned for AttributeTargetSpecifier<'_> {
2308 fn span(&self) -> ::treesitter_types::Span {
2309 self.span
2310 }
2311}
2312#[derive(Debug, Clone, PartialEq, Eq)]
2313pub struct AwaitExpression<'tree> {
2314 pub span: ::treesitter_types::Span,
2315 pub children: Expression<'tree>,
2316}
2317impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
2318 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2319 fn from_node(
2320 node: ::treesitter_types::tree_sitter::Node<'tree>,
2321 src: &'tree [u8],
2322 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2323 debug_assert_eq!(node.kind(), "await_expression");
2324 Ok(Self {
2325 span: ::treesitter_types::Span::from(node),
2326 children: {
2327 #[allow(clippy::suspicious_else_formatting)]
2328 let non_field_children = {
2329 let mut cursor = node.walk();
2330 let mut result = ::std::vec::Vec::new();
2331 if cursor.goto_first_child() {
2332 loop {
2333 if cursor.field_name().is_none()
2334 && cursor.node().is_named()
2335 && !cursor.node().is_extra()
2336 {
2337 result.push(cursor.node());
2338 }
2339 if !cursor.goto_next_sibling() {
2340 break;
2341 }
2342 }
2343 }
2344 result
2345 };
2346 let child = if let Some(&c) = non_field_children.first() {
2347 c
2348 } else {
2349 let mut fallback_cursor = node.walk();
2350 let mut fallback_child = None;
2351 if fallback_cursor.goto_first_child() {
2352 loop {
2353 if fallback_cursor.field_name().is_none()
2354 && !fallback_cursor.node().is_extra()
2355 {
2356 let candidate = fallback_cursor.node();
2357 #[allow(clippy::needless_question_mark)]
2358 if (|| -> ::core::result::Result<
2359 _,
2360 ::treesitter_types::ParseError,
2361 > {
2362 let child = candidate;
2363 Ok(
2364 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2365 child,
2366 src,
2367 ))?,
2368 )
2369 })()
2370 .is_ok()
2371 {
2372 fallback_child = Some(candidate);
2373 break;
2374 }
2375 }
2376 if !fallback_cursor.goto_next_sibling() {
2377 break;
2378 }
2379 }
2380 }
2381 if fallback_child.is_none() {
2382 let mut cursor2 = node.walk();
2383 if cursor2.goto_first_child() {
2384 loop {
2385 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2386 let candidate = cursor2.node();
2387 #[allow(clippy::needless_question_mark)]
2388 if (|| -> ::core::result::Result<
2389 _,
2390 ::treesitter_types::ParseError,
2391 > {
2392 let child = candidate;
2393 Ok(
2394 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2395 child,
2396 src,
2397 ))?,
2398 )
2399 })()
2400 .is_ok()
2401 {
2402 fallback_child = Some(candidate);
2403 break;
2404 }
2405 }
2406 if !cursor2.goto_next_sibling() {
2407 break;
2408 }
2409 }
2410 }
2411 }
2412 fallback_child.ok_or_else(|| {
2413 ::treesitter_types::ParseError::missing_field("children", node)
2414 })?
2415 };
2416 ::treesitter_types::runtime::maybe_grow_stack(|| {
2417 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2418 })?
2419 },
2420 })
2421 }
2422}
2423impl ::treesitter_types::Spanned for AwaitExpression<'_> {
2424 fn span(&self) -> ::treesitter_types::Span {
2425 self.span
2426 }
2427}
2428#[derive(Debug, Clone, PartialEq, Eq)]
2429pub struct BaseList<'tree> {
2430 pub span: ::treesitter_types::Span,
2431 pub children: ::std::vec::Vec<BaseListChildren<'tree>>,
2432}
2433impl<'tree> ::treesitter_types::FromNode<'tree> for BaseList<'tree> {
2434 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2435 fn from_node(
2436 node: ::treesitter_types::tree_sitter::Node<'tree>,
2437 src: &'tree [u8],
2438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2439 debug_assert_eq!(node.kind(), "base_list");
2440 Ok(Self {
2441 span: ::treesitter_types::Span::from(node),
2442 children: {
2443 #[allow(clippy::suspicious_else_formatting)]
2444 let non_field_children = {
2445 let mut cursor = node.walk();
2446 let mut result = ::std::vec::Vec::new();
2447 if cursor.goto_first_child() {
2448 loop {
2449 if cursor.field_name().is_none()
2450 && cursor.node().is_named()
2451 && !cursor.node().is_extra()
2452 {
2453 result.push(cursor.node());
2454 }
2455 if !cursor.goto_next_sibling() {
2456 break;
2457 }
2458 }
2459 }
2460 result
2461 };
2462 let mut items = ::std::vec::Vec::new();
2463 for child in non_field_children {
2464 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2465 <BaseListChildren as ::treesitter_types::FromNode>::from_node(child, src)
2466 })?);
2467 }
2468 items
2469 },
2470 })
2471 }
2472}
2473impl ::treesitter_types::Spanned for BaseList<'_> {
2474 fn span(&self) -> ::treesitter_types::Span {
2475 self.span
2476 }
2477}
2478#[derive(Debug, Clone, PartialEq, Eq)]
2479pub struct BinaryExpression<'tree> {
2480 pub span: ::treesitter_types::Span,
2481 pub left: BinaryExpressionLeft<'tree>,
2482 pub operator: BinaryExpressionOperator,
2483 pub right: BinaryExpressionRight<'tree>,
2484}
2485impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
2486 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2487 fn from_node(
2488 node: ::treesitter_types::tree_sitter::Node<'tree>,
2489 src: &'tree [u8],
2490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2491 debug_assert_eq!(node.kind(), "binary_expression");
2492 Ok(Self {
2493 span: ::treesitter_types::Span::from(node),
2494 left: {
2495 let child = node
2496 .child_by_field_name("left")
2497 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2498 ::treesitter_types::runtime::maybe_grow_stack(|| {
2499 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
2500 })?
2501 },
2502 operator: {
2503 let child = node.child_by_field_name("operator").ok_or_else(|| {
2504 ::treesitter_types::ParseError::missing_field("operator", node)
2505 })?;
2506 ::treesitter_types::runtime::maybe_grow_stack(|| {
2507 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
2508 child, src,
2509 )
2510 })?
2511 },
2512 right: {
2513 let child = node
2514 .child_by_field_name("right")
2515 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2516 ::treesitter_types::runtime::maybe_grow_stack(|| {
2517 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
2518 })?
2519 },
2520 })
2521 }
2522}
2523impl ::treesitter_types::Spanned for BinaryExpression<'_> {
2524 fn span(&self) -> ::treesitter_types::Span {
2525 self.span
2526 }
2527}
2528#[derive(Debug, Clone, PartialEq, Eq)]
2529pub struct Block<'tree> {
2530 pub span: ::treesitter_types::Span,
2531 pub children: ::std::vec::Vec<Statement<'tree>>,
2532}
2533impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
2534 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2535 fn from_node(
2536 node: ::treesitter_types::tree_sitter::Node<'tree>,
2537 src: &'tree [u8],
2538 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2539 debug_assert_eq!(node.kind(), "block");
2540 Ok(Self {
2541 span: ::treesitter_types::Span::from(node),
2542 children: {
2543 #[allow(clippy::suspicious_else_formatting)]
2544 let non_field_children = {
2545 let mut cursor = node.walk();
2546 let mut result = ::std::vec::Vec::new();
2547 if cursor.goto_first_child() {
2548 loop {
2549 if cursor.field_name().is_none()
2550 && cursor.node().is_named()
2551 && !cursor.node().is_extra()
2552 {
2553 result.push(cursor.node());
2554 }
2555 if !cursor.goto_next_sibling() {
2556 break;
2557 }
2558 }
2559 }
2560 result
2561 };
2562 let mut items = ::std::vec::Vec::new();
2563 for child in non_field_children {
2564 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2565 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2566 })?);
2567 }
2568 items
2569 },
2570 })
2571 }
2572}
2573impl ::treesitter_types::Spanned for Block<'_> {
2574 fn span(&self) -> ::treesitter_types::Span {
2575 self.span
2576 }
2577}
2578#[derive(Debug, Clone, PartialEq, Eq)]
2579pub struct BooleanLiteral<'tree> {
2580 pub span: ::treesitter_types::Span,
2581 text: &'tree str,
2582}
2583impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
2584 fn from_node(
2585 node: ::treesitter_types::tree_sitter::Node<'tree>,
2586 src: &'tree [u8],
2587 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2588 debug_assert_eq!(node.kind(), "boolean_literal");
2589 Ok(Self {
2590 span: ::treesitter_types::Span::from(node),
2591 text: node.utf8_text(src)?,
2592 })
2593 }
2594}
2595impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
2596 fn text(&self) -> &'tree str {
2597 self.text
2598 }
2599}
2600impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
2601 fn span(&self) -> ::treesitter_types::Span {
2602 self.span
2603 }
2604}
2605#[derive(Debug, Clone, PartialEq, Eq)]
2606pub struct BracketedArgumentList<'tree> {
2607 pub span: ::treesitter_types::Span,
2608 pub children: ::std::vec::Vec<Argument<'tree>>,
2609}
2610impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedArgumentList<'tree> {
2611 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2612 fn from_node(
2613 node: ::treesitter_types::tree_sitter::Node<'tree>,
2614 src: &'tree [u8],
2615 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2616 debug_assert_eq!(node.kind(), "bracketed_argument_list");
2617 Ok(Self {
2618 span: ::treesitter_types::Span::from(node),
2619 children: {
2620 #[allow(clippy::suspicious_else_formatting)]
2621 let non_field_children = {
2622 let mut cursor = node.walk();
2623 let mut result = ::std::vec::Vec::new();
2624 if cursor.goto_first_child() {
2625 loop {
2626 if cursor.field_name().is_none()
2627 && cursor.node().is_named()
2628 && !cursor.node().is_extra()
2629 {
2630 result.push(cursor.node());
2631 }
2632 if !cursor.goto_next_sibling() {
2633 break;
2634 }
2635 }
2636 }
2637 result
2638 };
2639 let mut items = ::std::vec::Vec::new();
2640 for child in non_field_children {
2641 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2642 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
2643 })?);
2644 }
2645 items
2646 },
2647 })
2648 }
2649}
2650impl ::treesitter_types::Spanned for BracketedArgumentList<'_> {
2651 fn span(&self) -> ::treesitter_types::Span {
2652 self.span
2653 }
2654}
2655#[derive(Debug, Clone, PartialEq, Eq)]
2656pub struct BracketedParameterList<'tree> {
2657 pub span: ::treesitter_types::Span,
2658 pub name: ::std::vec::Vec<Identifier<'tree>>,
2659 pub r#type: ::std::vec::Vec<Type<'tree>>,
2660 pub children: ::std::vec::Vec<BracketedParameterListChildren<'tree>>,
2661}
2662impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterList<'tree> {
2663 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2664 fn from_node(
2665 node: ::treesitter_types::tree_sitter::Node<'tree>,
2666 src: &'tree [u8],
2667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2668 debug_assert_eq!(node.kind(), "bracketed_parameter_list");
2669 Ok(Self {
2670 span: ::treesitter_types::Span::from(node),
2671 name: {
2672 let mut cursor = node.walk();
2673 let mut items = ::std::vec::Vec::new();
2674 for child in node.children_by_field_name("name", &mut cursor) {
2675 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2676 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2677 })?);
2678 }
2679 items
2680 },
2681 r#type: {
2682 let mut cursor = node.walk();
2683 let mut items = ::std::vec::Vec::new();
2684 for child in node.children_by_field_name("type", &mut cursor) {
2685 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2686 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2687 })?);
2688 }
2689 items
2690 },
2691 children: {
2692 #[allow(clippy::suspicious_else_formatting)]
2693 let non_field_children = {
2694 let mut cursor = node.walk();
2695 let mut result = ::std::vec::Vec::new();
2696 if cursor.goto_first_child() {
2697 loop {
2698 if cursor.field_name().is_none()
2699 && cursor.node().is_named()
2700 && !cursor.node().is_extra()
2701 {
2702 result.push(cursor.node());
2703 }
2704 if !cursor.goto_next_sibling() {
2705 break;
2706 }
2707 }
2708 }
2709 result
2710 };
2711 let mut items = ::std::vec::Vec::new();
2712 for child in non_field_children {
2713 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2714 <BracketedParameterListChildren as ::treesitter_types::FromNode>::from_node(
2715 child, src,
2716 )
2717 })?);
2718 }
2719 items
2720 },
2721 })
2722 }
2723}
2724impl ::treesitter_types::Spanned for BracketedParameterList<'_> {
2725 fn span(&self) -> ::treesitter_types::Span {
2726 self.span
2727 }
2728}
2729#[derive(Debug, Clone, PartialEq, Eq)]
2730pub struct BreakStatement<'tree> {
2731 pub span: ::treesitter_types::Span,
2732 text: &'tree str,
2733}
2734impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
2735 fn from_node(
2736 node: ::treesitter_types::tree_sitter::Node<'tree>,
2737 src: &'tree [u8],
2738 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2739 debug_assert_eq!(node.kind(), "break_statement");
2740 Ok(Self {
2741 span: ::treesitter_types::Span::from(node),
2742 text: node.utf8_text(src)?,
2743 })
2744 }
2745}
2746impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
2747 fn text(&self) -> &'tree str {
2748 self.text
2749 }
2750}
2751impl ::treesitter_types::Spanned for BreakStatement<'_> {
2752 fn span(&self) -> ::treesitter_types::Span {
2753 self.span
2754 }
2755}
2756#[derive(Debug, Clone, PartialEq, Eq)]
2757pub struct CallingConvention<'tree> {
2758 pub span: ::treesitter_types::Span,
2759 pub children: ::std::vec::Vec<Identifier<'tree>>,
2760}
2761impl<'tree> ::treesitter_types::FromNode<'tree> for CallingConvention<'tree> {
2762 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2763 fn from_node(
2764 node: ::treesitter_types::tree_sitter::Node<'tree>,
2765 src: &'tree [u8],
2766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2767 debug_assert_eq!(node.kind(), "calling_convention");
2768 Ok(Self {
2769 span: ::treesitter_types::Span::from(node),
2770 children: {
2771 #[allow(clippy::suspicious_else_formatting)]
2772 let non_field_children = {
2773 let mut cursor = node.walk();
2774 let mut result = ::std::vec::Vec::new();
2775 if cursor.goto_first_child() {
2776 loop {
2777 if cursor.field_name().is_none()
2778 && cursor.node().is_named()
2779 && !cursor.node().is_extra()
2780 {
2781 result.push(cursor.node());
2782 }
2783 if !cursor.goto_next_sibling() {
2784 break;
2785 }
2786 }
2787 }
2788 result
2789 };
2790 let mut items = ::std::vec::Vec::new();
2791 for child in non_field_children {
2792 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2793 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2794 })?);
2795 }
2796 items
2797 },
2798 })
2799 }
2800}
2801impl ::treesitter_types::Spanned for CallingConvention<'_> {
2802 fn span(&self) -> ::treesitter_types::Span {
2803 self.span
2804 }
2805}
2806#[derive(Debug, Clone, PartialEq, Eq)]
2807pub struct CastExpression<'tree> {
2808 pub span: ::treesitter_types::Span,
2809 pub r#type: Type<'tree>,
2810 pub value: Expression<'tree>,
2811}
2812impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
2813 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2814 fn from_node(
2815 node: ::treesitter_types::tree_sitter::Node<'tree>,
2816 src: &'tree [u8],
2817 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2818 debug_assert_eq!(node.kind(), "cast_expression");
2819 Ok(Self {
2820 span: ::treesitter_types::Span::from(node),
2821 r#type: {
2822 let child = node
2823 .child_by_field_name("type")
2824 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2825 ::treesitter_types::runtime::maybe_grow_stack(|| {
2826 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2827 })?
2828 },
2829 value: {
2830 let child = node
2831 .child_by_field_name("value")
2832 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2833 ::treesitter_types::runtime::maybe_grow_stack(|| {
2834 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2835 })?
2836 },
2837 })
2838 }
2839}
2840impl ::treesitter_types::Spanned for CastExpression<'_> {
2841 fn span(&self) -> ::treesitter_types::Span {
2842 self.span
2843 }
2844}
2845#[derive(Debug, Clone, PartialEq, Eq)]
2846pub struct CatchClause<'tree> {
2847 pub span: ::treesitter_types::Span,
2848 pub body: Block<'tree>,
2849 pub children: ::std::vec::Vec<CatchClauseChildren<'tree>>,
2850}
2851impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2852 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2853 fn from_node(
2854 node: ::treesitter_types::tree_sitter::Node<'tree>,
2855 src: &'tree [u8],
2856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2857 debug_assert_eq!(node.kind(), "catch_clause");
2858 Ok(Self {
2859 span: ::treesitter_types::Span::from(node),
2860 body: {
2861 let child = node
2862 .child_by_field_name("body")
2863 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2864 ::treesitter_types::runtime::maybe_grow_stack(|| {
2865 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2866 })?
2867 },
2868 children: {
2869 #[allow(clippy::suspicious_else_formatting)]
2870 let non_field_children = {
2871 let mut cursor = node.walk();
2872 let mut result = ::std::vec::Vec::new();
2873 if cursor.goto_first_child() {
2874 loop {
2875 if cursor.field_name().is_none()
2876 && cursor.node().is_named()
2877 && !cursor.node().is_extra()
2878 {
2879 result.push(cursor.node());
2880 }
2881 if !cursor.goto_next_sibling() {
2882 break;
2883 }
2884 }
2885 }
2886 result
2887 };
2888 let mut items = ::std::vec::Vec::new();
2889 for child in non_field_children {
2890 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2891 <CatchClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2892 })?);
2893 }
2894 items
2895 },
2896 })
2897 }
2898}
2899impl ::treesitter_types::Spanned for CatchClause<'_> {
2900 fn span(&self) -> ::treesitter_types::Span {
2901 self.span
2902 }
2903}
2904#[derive(Debug, Clone, PartialEq, Eq)]
2905pub struct CatchDeclaration<'tree> {
2906 pub span: ::treesitter_types::Span,
2907 pub name: ::core::option::Option<Identifier<'tree>>,
2908 pub r#type: Type<'tree>,
2909}
2910impl<'tree> ::treesitter_types::FromNode<'tree> for CatchDeclaration<'tree> {
2911 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2912 fn from_node(
2913 node: ::treesitter_types::tree_sitter::Node<'tree>,
2914 src: &'tree [u8],
2915 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2916 debug_assert_eq!(node.kind(), "catch_declaration");
2917 Ok(Self {
2918 span: ::treesitter_types::Span::from(node),
2919 name: match node.child_by_field_name("name") {
2920 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2921 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2922 })?),
2923 None => None,
2924 },
2925 r#type: {
2926 let child = node
2927 .child_by_field_name("type")
2928 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2929 ::treesitter_types::runtime::maybe_grow_stack(|| {
2930 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2931 })?
2932 },
2933 })
2934 }
2935}
2936impl ::treesitter_types::Spanned for CatchDeclaration<'_> {
2937 fn span(&self) -> ::treesitter_types::Span {
2938 self.span
2939 }
2940}
2941#[derive(Debug, Clone, PartialEq, Eq)]
2942pub struct CatchFilterClause<'tree> {
2943 pub span: ::treesitter_types::Span,
2944 pub children: Expression<'tree>,
2945}
2946impl<'tree> ::treesitter_types::FromNode<'tree> for CatchFilterClause<'tree> {
2947 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2948 fn from_node(
2949 node: ::treesitter_types::tree_sitter::Node<'tree>,
2950 src: &'tree [u8],
2951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2952 debug_assert_eq!(node.kind(), "catch_filter_clause");
2953 Ok(Self {
2954 span: ::treesitter_types::Span::from(node),
2955 children: {
2956 #[allow(clippy::suspicious_else_formatting)]
2957 let non_field_children = {
2958 let mut cursor = node.walk();
2959 let mut result = ::std::vec::Vec::new();
2960 if cursor.goto_first_child() {
2961 loop {
2962 if cursor.field_name().is_none()
2963 && cursor.node().is_named()
2964 && !cursor.node().is_extra()
2965 {
2966 result.push(cursor.node());
2967 }
2968 if !cursor.goto_next_sibling() {
2969 break;
2970 }
2971 }
2972 }
2973 result
2974 };
2975 let child = if let Some(&c) = non_field_children.first() {
2976 c
2977 } else {
2978 let mut fallback_cursor = node.walk();
2979 let mut fallback_child = None;
2980 if fallback_cursor.goto_first_child() {
2981 loop {
2982 if fallback_cursor.field_name().is_none()
2983 && !fallback_cursor.node().is_extra()
2984 {
2985 let candidate = fallback_cursor.node();
2986 #[allow(clippy::needless_question_mark)]
2987 if (|| -> ::core::result::Result<
2988 _,
2989 ::treesitter_types::ParseError,
2990 > {
2991 let child = candidate;
2992 Ok(
2993 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2994 child,
2995 src,
2996 ))?,
2997 )
2998 })()
2999 .is_ok()
3000 {
3001 fallback_child = Some(candidate);
3002 break;
3003 }
3004 }
3005 if !fallback_cursor.goto_next_sibling() {
3006 break;
3007 }
3008 }
3009 }
3010 if fallback_child.is_none() {
3011 let mut cursor2 = node.walk();
3012 if cursor2.goto_first_child() {
3013 loop {
3014 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3015 let candidate = cursor2.node();
3016 #[allow(clippy::needless_question_mark)]
3017 if (|| -> ::core::result::Result<
3018 _,
3019 ::treesitter_types::ParseError,
3020 > {
3021 let child = candidate;
3022 Ok(
3023 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3024 child,
3025 src,
3026 ))?,
3027 )
3028 })()
3029 .is_ok()
3030 {
3031 fallback_child = Some(candidate);
3032 break;
3033 }
3034 }
3035 if !cursor2.goto_next_sibling() {
3036 break;
3037 }
3038 }
3039 }
3040 }
3041 fallback_child.ok_or_else(|| {
3042 ::treesitter_types::ParseError::missing_field("children", node)
3043 })?
3044 };
3045 ::treesitter_types::runtime::maybe_grow_stack(|| {
3046 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3047 })?
3048 },
3049 })
3050 }
3051}
3052impl ::treesitter_types::Spanned for CatchFilterClause<'_> {
3053 fn span(&self) -> ::treesitter_types::Span {
3054 self.span
3055 }
3056}
3057#[derive(Debug, Clone, PartialEq, Eq)]
3058pub struct CharacterLiteral<'tree> {
3059 pub span: ::treesitter_types::Span,
3060 pub children: CharacterLiteralChildren<'tree>,
3061}
3062impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteral<'tree> {
3063 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3064 fn from_node(
3065 node: ::treesitter_types::tree_sitter::Node<'tree>,
3066 src: &'tree [u8],
3067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3068 debug_assert_eq!(node.kind(), "character_literal");
3069 Ok(Self {
3070 span: ::treesitter_types::Span::from(node),
3071 children: {
3072 #[allow(clippy::suspicious_else_formatting)]
3073 let non_field_children = {
3074 let mut cursor = node.walk();
3075 let mut result = ::std::vec::Vec::new();
3076 if cursor.goto_first_child() {
3077 loop {
3078 if cursor.field_name().is_none()
3079 && cursor.node().is_named()
3080 && !cursor.node().is_extra()
3081 {
3082 result.push(cursor.node());
3083 }
3084 if !cursor.goto_next_sibling() {
3085 break;
3086 }
3087 }
3088 }
3089 result
3090 };
3091 let child = if let Some(&c) = non_field_children.first() {
3092 c
3093 } else {
3094 let mut fallback_cursor = node.walk();
3095 let mut fallback_child = None;
3096 if fallback_cursor.goto_first_child() {
3097 loop {
3098 if fallback_cursor.field_name().is_none()
3099 && !fallback_cursor.node().is_extra()
3100 {
3101 let candidate = fallback_cursor.node();
3102 #[allow(clippy::needless_question_mark)]
3103 if (|| -> ::core::result::Result<
3104 _,
3105 ::treesitter_types::ParseError,
3106 > {
3107 let child = candidate;
3108 Ok(
3109 ::treesitter_types::runtime::maybe_grow_stack(|| <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3110 child,
3111 src,
3112 ))?,
3113 )
3114 })()
3115 .is_ok()
3116 {
3117 fallback_child = Some(candidate);
3118 break;
3119 }
3120 }
3121 if !fallback_cursor.goto_next_sibling() {
3122 break;
3123 }
3124 }
3125 }
3126 if fallback_child.is_none() {
3127 let mut cursor2 = node.walk();
3128 if cursor2.goto_first_child() {
3129 loop {
3130 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3131 let candidate = cursor2.node();
3132 #[allow(clippy::needless_question_mark)]
3133 if (|| -> ::core::result::Result<
3134 _,
3135 ::treesitter_types::ParseError,
3136 > {
3137 let child = candidate;
3138 Ok(
3139 ::treesitter_types::runtime::maybe_grow_stack(|| <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3140 child,
3141 src,
3142 ))?,
3143 )
3144 })()
3145 .is_ok()
3146 {
3147 fallback_child = Some(candidate);
3148 break;
3149 }
3150 }
3151 if !cursor2.goto_next_sibling() {
3152 break;
3153 }
3154 }
3155 }
3156 }
3157 fallback_child.ok_or_else(|| {
3158 ::treesitter_types::ParseError::missing_field("children", node)
3159 })?
3160 };
3161 ::treesitter_types::runtime::maybe_grow_stack(|| {
3162 <CharacterLiteralChildren as ::treesitter_types::FromNode>::from_node(
3163 child, src,
3164 )
3165 })?
3166 },
3167 })
3168 }
3169}
3170impl ::treesitter_types::Spanned for CharacterLiteral<'_> {
3171 fn span(&self) -> ::treesitter_types::Span {
3172 self.span
3173 }
3174}
3175#[derive(Debug, Clone, PartialEq, Eq)]
3176pub struct CheckedExpression<'tree> {
3177 pub span: ::treesitter_types::Span,
3178 pub children: Expression<'tree>,
3179}
3180impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedExpression<'tree> {
3181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3182 fn from_node(
3183 node: ::treesitter_types::tree_sitter::Node<'tree>,
3184 src: &'tree [u8],
3185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3186 debug_assert_eq!(node.kind(), "checked_expression");
3187 Ok(Self {
3188 span: ::treesitter_types::Span::from(node),
3189 children: {
3190 #[allow(clippy::suspicious_else_formatting)]
3191 let non_field_children = {
3192 let mut cursor = node.walk();
3193 let mut result = ::std::vec::Vec::new();
3194 if cursor.goto_first_child() {
3195 loop {
3196 if cursor.field_name().is_none()
3197 && cursor.node().is_named()
3198 && !cursor.node().is_extra()
3199 {
3200 result.push(cursor.node());
3201 }
3202 if !cursor.goto_next_sibling() {
3203 break;
3204 }
3205 }
3206 }
3207 result
3208 };
3209 let child = if let Some(&c) = non_field_children.first() {
3210 c
3211 } else {
3212 let mut fallback_cursor = node.walk();
3213 let mut fallback_child = None;
3214 if fallback_cursor.goto_first_child() {
3215 loop {
3216 if fallback_cursor.field_name().is_none()
3217 && !fallback_cursor.node().is_extra()
3218 {
3219 let candidate = fallback_cursor.node();
3220 #[allow(clippy::needless_question_mark)]
3221 if (|| -> ::core::result::Result<
3222 _,
3223 ::treesitter_types::ParseError,
3224 > {
3225 let child = candidate;
3226 Ok(
3227 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3228 child,
3229 src,
3230 ))?,
3231 )
3232 })()
3233 .is_ok()
3234 {
3235 fallback_child = Some(candidate);
3236 break;
3237 }
3238 }
3239 if !fallback_cursor.goto_next_sibling() {
3240 break;
3241 }
3242 }
3243 }
3244 if fallback_child.is_none() {
3245 let mut cursor2 = node.walk();
3246 if cursor2.goto_first_child() {
3247 loop {
3248 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3249 let candidate = cursor2.node();
3250 #[allow(clippy::needless_question_mark)]
3251 if (|| -> ::core::result::Result<
3252 _,
3253 ::treesitter_types::ParseError,
3254 > {
3255 let child = candidate;
3256 Ok(
3257 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3258 child,
3259 src,
3260 ))?,
3261 )
3262 })()
3263 .is_ok()
3264 {
3265 fallback_child = Some(candidate);
3266 break;
3267 }
3268 }
3269 if !cursor2.goto_next_sibling() {
3270 break;
3271 }
3272 }
3273 }
3274 }
3275 fallback_child.ok_or_else(|| {
3276 ::treesitter_types::ParseError::missing_field("children", node)
3277 })?
3278 };
3279 ::treesitter_types::runtime::maybe_grow_stack(|| {
3280 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3281 })?
3282 },
3283 })
3284 }
3285}
3286impl ::treesitter_types::Spanned for CheckedExpression<'_> {
3287 fn span(&self) -> ::treesitter_types::Span {
3288 self.span
3289 }
3290}
3291#[derive(Debug, Clone, PartialEq, Eq)]
3292pub struct CheckedStatement<'tree> {
3293 pub span: ::treesitter_types::Span,
3294 pub children: Block<'tree>,
3295}
3296impl<'tree> ::treesitter_types::FromNode<'tree> for CheckedStatement<'tree> {
3297 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3298 fn from_node(
3299 node: ::treesitter_types::tree_sitter::Node<'tree>,
3300 src: &'tree [u8],
3301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3302 debug_assert_eq!(node.kind(), "checked_statement");
3303 Ok(Self {
3304 span: ::treesitter_types::Span::from(node),
3305 children: {
3306 #[allow(clippy::suspicious_else_formatting)]
3307 let non_field_children = {
3308 let mut cursor = node.walk();
3309 let mut result = ::std::vec::Vec::new();
3310 if cursor.goto_first_child() {
3311 loop {
3312 if cursor.field_name().is_none()
3313 && cursor.node().is_named()
3314 && !cursor.node().is_extra()
3315 {
3316 result.push(cursor.node());
3317 }
3318 if !cursor.goto_next_sibling() {
3319 break;
3320 }
3321 }
3322 }
3323 result
3324 };
3325 let child = if let Some(&c) = non_field_children.first() {
3326 c
3327 } else {
3328 let mut fallback_cursor = node.walk();
3329 let mut fallback_child = None;
3330 if fallback_cursor.goto_first_child() {
3331 loop {
3332 if fallback_cursor.field_name().is_none()
3333 && !fallback_cursor.node().is_extra()
3334 {
3335 let candidate = fallback_cursor.node();
3336 #[allow(clippy::needless_question_mark)]
3337 if (|| -> ::core::result::Result<
3338 _,
3339 ::treesitter_types::ParseError,
3340 > {
3341 let child = candidate;
3342 Ok(
3343 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3344 child,
3345 src,
3346 ))?,
3347 )
3348 })()
3349 .is_ok()
3350 {
3351 fallback_child = Some(candidate);
3352 break;
3353 }
3354 }
3355 if !fallback_cursor.goto_next_sibling() {
3356 break;
3357 }
3358 }
3359 }
3360 if fallback_child.is_none() {
3361 let mut cursor2 = node.walk();
3362 if cursor2.goto_first_child() {
3363 loop {
3364 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3365 let candidate = cursor2.node();
3366 #[allow(clippy::needless_question_mark)]
3367 if (|| -> ::core::result::Result<
3368 _,
3369 ::treesitter_types::ParseError,
3370 > {
3371 let child = candidate;
3372 Ok(
3373 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
3374 child,
3375 src,
3376 ))?,
3377 )
3378 })()
3379 .is_ok()
3380 {
3381 fallback_child = Some(candidate);
3382 break;
3383 }
3384 }
3385 if !cursor2.goto_next_sibling() {
3386 break;
3387 }
3388 }
3389 }
3390 }
3391 fallback_child.ok_or_else(|| {
3392 ::treesitter_types::ParseError::missing_field("children", node)
3393 })?
3394 };
3395 ::treesitter_types::runtime::maybe_grow_stack(|| {
3396 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3397 })?
3398 },
3399 })
3400 }
3401}
3402impl ::treesitter_types::Spanned for CheckedStatement<'_> {
3403 fn span(&self) -> ::treesitter_types::Span {
3404 self.span
3405 }
3406}
3407#[derive(Debug, Clone, PartialEq, Eq)]
3408pub struct ClassDeclaration<'tree> {
3409 pub span: ::treesitter_types::Span,
3410 pub body: ::core::option::Option<DeclarationList<'tree>>,
3411 pub name: Identifier<'tree>,
3412 pub children: ::std::vec::Vec<ClassDeclarationChildren<'tree>>,
3413}
3414impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
3415 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3416 fn from_node(
3417 node: ::treesitter_types::tree_sitter::Node<'tree>,
3418 src: &'tree [u8],
3419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3420 debug_assert_eq!(node.kind(), "class_declaration");
3421 Ok(Self {
3422 span: ::treesitter_types::Span::from(node),
3423 body: match node.child_by_field_name("body") {
3424 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3425 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
3426 })?),
3427 None => None,
3428 },
3429 name: {
3430 let child = node
3431 .child_by_field_name("name")
3432 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3433 ::treesitter_types::runtime::maybe_grow_stack(|| {
3434 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3435 })?
3436 },
3437 children: {
3438 #[allow(clippy::suspicious_else_formatting)]
3439 let non_field_children = {
3440 let mut cursor = node.walk();
3441 let mut result = ::std::vec::Vec::new();
3442 if cursor.goto_first_child() {
3443 loop {
3444 if cursor.field_name().is_none()
3445 && cursor.node().is_named()
3446 && !cursor.node().is_extra()
3447 {
3448 result.push(cursor.node());
3449 }
3450 if !cursor.goto_next_sibling() {
3451 break;
3452 }
3453 }
3454 }
3455 result
3456 };
3457 let mut items = ::std::vec::Vec::new();
3458 for child in non_field_children {
3459 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3460 <ClassDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3461 child, src,
3462 )
3463 })?);
3464 }
3465 items
3466 },
3467 })
3468 }
3469}
3470impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
3471 fn span(&self) -> ::treesitter_types::Span {
3472 self.span
3473 }
3474}
3475#[derive(Debug, Clone, PartialEq, Eq)]
3476pub struct CollectionElement<'tree> {
3477 pub span: ::treesitter_types::Span,
3478 pub children: CollectionElementChildren<'tree>,
3479}
3480impl<'tree> ::treesitter_types::FromNode<'tree> for CollectionElement<'tree> {
3481 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3482 fn from_node(
3483 node: ::treesitter_types::tree_sitter::Node<'tree>,
3484 src: &'tree [u8],
3485 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3486 debug_assert_eq!(node.kind(), "collection_element");
3487 Ok(Self {
3488 span: ::treesitter_types::Span::from(node),
3489 children: {
3490 #[allow(clippy::suspicious_else_formatting)]
3491 let non_field_children = {
3492 let mut cursor = node.walk();
3493 let mut result = ::std::vec::Vec::new();
3494 if cursor.goto_first_child() {
3495 loop {
3496 if cursor.field_name().is_none()
3497 && cursor.node().is_named()
3498 && !cursor.node().is_extra()
3499 {
3500 result.push(cursor.node());
3501 }
3502 if !cursor.goto_next_sibling() {
3503 break;
3504 }
3505 }
3506 }
3507 result
3508 };
3509 let child = if let Some(&c) = non_field_children.first() {
3510 c
3511 } else {
3512 let mut fallback_cursor = node.walk();
3513 let mut fallback_child = None;
3514 if fallback_cursor.goto_first_child() {
3515 loop {
3516 if fallback_cursor.field_name().is_none()
3517 && !fallback_cursor.node().is_extra()
3518 {
3519 let candidate = fallback_cursor.node();
3520 #[allow(clippy::needless_question_mark)]
3521 if (|| -> ::core::result::Result<
3522 _,
3523 ::treesitter_types::ParseError,
3524 > {
3525 let child = candidate;
3526 Ok(
3527 ::treesitter_types::runtime::maybe_grow_stack(|| <CollectionElementChildren as ::treesitter_types::FromNode>::from_node(
3528 child,
3529 src,
3530 ))?,
3531 )
3532 })()
3533 .is_ok()
3534 {
3535 fallback_child = Some(candidate);
3536 break;
3537 }
3538 }
3539 if !fallback_cursor.goto_next_sibling() {
3540 break;
3541 }
3542 }
3543 }
3544 if fallback_child.is_none() {
3545 let mut cursor2 = node.walk();
3546 if cursor2.goto_first_child() {
3547 loop {
3548 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3549 let candidate = cursor2.node();
3550 #[allow(clippy::needless_question_mark)]
3551 if (|| -> ::core::result::Result<
3552 _,
3553 ::treesitter_types::ParseError,
3554 > {
3555 let child = candidate;
3556 Ok(
3557 ::treesitter_types::runtime::maybe_grow_stack(|| <CollectionElementChildren as ::treesitter_types::FromNode>::from_node(
3558 child,
3559 src,
3560 ))?,
3561 )
3562 })()
3563 .is_ok()
3564 {
3565 fallback_child = Some(candidate);
3566 break;
3567 }
3568 }
3569 if !cursor2.goto_next_sibling() {
3570 break;
3571 }
3572 }
3573 }
3574 }
3575 fallback_child.ok_or_else(|| {
3576 ::treesitter_types::ParseError::missing_field("children", node)
3577 })?
3578 };
3579 ::treesitter_types::runtime::maybe_grow_stack(|| {
3580 <CollectionElementChildren as ::treesitter_types::FromNode>::from_node(
3581 child, src,
3582 )
3583 })?
3584 },
3585 })
3586 }
3587}
3588impl ::treesitter_types::Spanned for CollectionElement<'_> {
3589 fn span(&self) -> ::treesitter_types::Span {
3590 self.span
3591 }
3592}
3593#[derive(Debug, Clone, PartialEq, Eq)]
3594pub struct CollectionExpression<'tree> {
3595 pub span: ::treesitter_types::Span,
3596 pub children: ::std::vec::Vec<CollectionElement<'tree>>,
3597}
3598impl<'tree> ::treesitter_types::FromNode<'tree> for CollectionExpression<'tree> {
3599 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3600 fn from_node(
3601 node: ::treesitter_types::tree_sitter::Node<'tree>,
3602 src: &'tree [u8],
3603 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3604 debug_assert_eq!(node.kind(), "collection_expression");
3605 Ok(Self {
3606 span: ::treesitter_types::Span::from(node),
3607 children: {
3608 #[allow(clippy::suspicious_else_formatting)]
3609 let non_field_children = {
3610 let mut cursor = node.walk();
3611 let mut result = ::std::vec::Vec::new();
3612 if cursor.goto_first_child() {
3613 loop {
3614 if cursor.field_name().is_none()
3615 && cursor.node().is_named()
3616 && !cursor.node().is_extra()
3617 {
3618 result.push(cursor.node());
3619 }
3620 if !cursor.goto_next_sibling() {
3621 break;
3622 }
3623 }
3624 }
3625 result
3626 };
3627 let mut items = ::std::vec::Vec::new();
3628 for child in non_field_children {
3629 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3630 <CollectionElement as ::treesitter_types::FromNode>::from_node(child, src)
3631 })?);
3632 }
3633 items
3634 },
3635 })
3636 }
3637}
3638impl ::treesitter_types::Spanned for CollectionExpression<'_> {
3639 fn span(&self) -> ::treesitter_types::Span {
3640 self.span
3641 }
3642}
3643#[derive(Debug, Clone, PartialEq, Eq)]
3644pub struct CompilationUnit<'tree> {
3645 pub span: ::treesitter_types::Span,
3646 pub children: ::std::vec::Vec<CompilationUnitChildren<'tree>>,
3647}
3648impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnit<'tree> {
3649 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3650 fn from_node(
3651 node: ::treesitter_types::tree_sitter::Node<'tree>,
3652 src: &'tree [u8],
3653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3654 debug_assert_eq!(node.kind(), "compilation_unit");
3655 Ok(Self {
3656 span: ::treesitter_types::Span::from(node),
3657 children: {
3658 #[allow(clippy::suspicious_else_formatting)]
3659 let non_field_children = {
3660 let mut cursor = node.walk();
3661 let mut result = ::std::vec::Vec::new();
3662 if cursor.goto_first_child() {
3663 loop {
3664 if cursor.field_name().is_none()
3665 && cursor.node().is_named()
3666 && !cursor.node().is_extra()
3667 {
3668 result.push(cursor.node());
3669 }
3670 if !cursor.goto_next_sibling() {
3671 break;
3672 }
3673 }
3674 }
3675 result
3676 };
3677 let mut items = ::std::vec::Vec::new();
3678 for child in non_field_children {
3679 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3680 <CompilationUnitChildren as ::treesitter_types::FromNode>::from_node(
3681 child, src,
3682 )
3683 })?);
3684 }
3685 items
3686 },
3687 })
3688 }
3689}
3690impl ::treesitter_types::Spanned for CompilationUnit<'_> {
3691 fn span(&self) -> ::treesitter_types::Span {
3692 self.span
3693 }
3694}
3695#[derive(Debug, Clone, PartialEq, Eq)]
3696pub struct ConditionalAccessExpression<'tree> {
3697 pub span: ::treesitter_types::Span,
3698 pub condition: Expression<'tree>,
3699 pub children: ConditionalAccessExpressionChildren<'tree>,
3700}
3701impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpression<'tree> {
3702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3703 fn from_node(
3704 node: ::treesitter_types::tree_sitter::Node<'tree>,
3705 src: &'tree [u8],
3706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3707 debug_assert_eq!(node.kind(), "conditional_access_expression");
3708 Ok(Self {
3709 span: ::treesitter_types::Span::from(node),
3710 condition: {
3711 let child = node.child_by_field_name("condition").ok_or_else(|| {
3712 ::treesitter_types::ParseError::missing_field("condition", node)
3713 })?;
3714 ::treesitter_types::runtime::maybe_grow_stack(|| {
3715 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3716 })?
3717 },
3718 children: {
3719 #[allow(clippy::suspicious_else_formatting)]
3720 let non_field_children = {
3721 let mut cursor = node.walk();
3722 let mut result = ::std::vec::Vec::new();
3723 if cursor.goto_first_child() {
3724 loop {
3725 if cursor.field_name().is_none()
3726 && cursor.node().is_named()
3727 && !cursor.node().is_extra()
3728 {
3729 result.push(cursor.node());
3730 }
3731 if !cursor.goto_next_sibling() {
3732 break;
3733 }
3734 }
3735 }
3736 result
3737 };
3738 let child = if let Some(&c) = non_field_children.first() {
3739 c
3740 } else {
3741 let mut fallback_cursor = node.walk();
3742 let mut fallback_child = None;
3743 if fallback_cursor.goto_first_child() {
3744 loop {
3745 if fallback_cursor.field_name().is_none()
3746 && !fallback_cursor.node().is_extra()
3747 {
3748 let candidate = fallback_cursor.node();
3749 #[allow(clippy::needless_question_mark)]
3750 if (|| -> ::core::result::Result<
3751 _,
3752 ::treesitter_types::ParseError,
3753 > {
3754 let child = candidate;
3755 Ok(
3756 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3757 child,
3758 src,
3759 ))?,
3760 )
3761 })()
3762 .is_ok()
3763 {
3764 fallback_child = Some(candidate);
3765 break;
3766 }
3767 }
3768 if !fallback_cursor.goto_next_sibling() {
3769 break;
3770 }
3771 }
3772 }
3773 if fallback_child.is_none() {
3774 let mut cursor2 = node.walk();
3775 if cursor2.goto_first_child() {
3776 loop {
3777 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3778 let candidate = cursor2.node();
3779 #[allow(clippy::needless_question_mark)]
3780 if (|| -> ::core::result::Result<
3781 _,
3782 ::treesitter_types::ParseError,
3783 > {
3784 let child = candidate;
3785 Ok(
3786 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3787 child,
3788 src,
3789 ))?,
3790 )
3791 })()
3792 .is_ok()
3793 {
3794 fallback_child = Some(candidate);
3795 break;
3796 }
3797 }
3798 if !cursor2.goto_next_sibling() {
3799 break;
3800 }
3801 }
3802 }
3803 }
3804 fallback_child.ok_or_else(|| {
3805 ::treesitter_types::ParseError::missing_field("children", node)
3806 })?
3807 };
3808 ::treesitter_types::runtime::maybe_grow_stack(|| {
3809 <ConditionalAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
3810 child, src,
3811 )
3812 })?
3813 },
3814 })
3815 }
3816}
3817impl ::treesitter_types::Spanned for ConditionalAccessExpression<'_> {
3818 fn span(&self) -> ::treesitter_types::Span {
3819 self.span
3820 }
3821}
3822#[derive(Debug, Clone, PartialEq, Eq)]
3823pub struct ConditionalExpression<'tree> {
3824 pub span: ::treesitter_types::Span,
3825 pub alternative: Expression<'tree>,
3826 pub condition: Expression<'tree>,
3827 pub consequence: Expression<'tree>,
3828}
3829impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
3830 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3831 fn from_node(
3832 node: ::treesitter_types::tree_sitter::Node<'tree>,
3833 src: &'tree [u8],
3834 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3835 debug_assert_eq!(node.kind(), "conditional_expression");
3836 Ok(Self {
3837 span: ::treesitter_types::Span::from(node),
3838 alternative: {
3839 let child = node.child_by_field_name("alternative").ok_or_else(|| {
3840 ::treesitter_types::ParseError::missing_field("alternative", node)
3841 })?;
3842 ::treesitter_types::runtime::maybe_grow_stack(|| {
3843 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3844 })?
3845 },
3846 condition: {
3847 let child = node.child_by_field_name("condition").ok_or_else(|| {
3848 ::treesitter_types::ParseError::missing_field("condition", node)
3849 })?;
3850 ::treesitter_types::runtime::maybe_grow_stack(|| {
3851 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3852 })?
3853 },
3854 consequence: {
3855 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3856 ::treesitter_types::ParseError::missing_field("consequence", node)
3857 })?;
3858 ::treesitter_types::runtime::maybe_grow_stack(|| {
3859 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3860 })?
3861 },
3862 })
3863 }
3864}
3865impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
3866 fn span(&self) -> ::treesitter_types::Span {
3867 self.span
3868 }
3869}
3870#[derive(Debug, Clone, PartialEq, Eq)]
3871pub struct ConstantPattern<'tree> {
3872 pub span: ::treesitter_types::Span,
3873 pub children: ConstantPatternChildren<'tree>,
3874}
3875impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPattern<'tree> {
3876 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3877 fn from_node(
3878 node: ::treesitter_types::tree_sitter::Node<'tree>,
3879 src: &'tree [u8],
3880 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3881 debug_assert_eq!(node.kind(), "constant_pattern");
3882 Ok(Self {
3883 span: ::treesitter_types::Span::from(node),
3884 children: {
3885 #[allow(clippy::suspicious_else_formatting)]
3886 let non_field_children = {
3887 let mut cursor = node.walk();
3888 let mut result = ::std::vec::Vec::new();
3889 if cursor.goto_first_child() {
3890 loop {
3891 if cursor.field_name().is_none()
3892 && cursor.node().is_named()
3893 && !cursor.node().is_extra()
3894 {
3895 result.push(cursor.node());
3896 }
3897 if !cursor.goto_next_sibling() {
3898 break;
3899 }
3900 }
3901 }
3902 result
3903 };
3904 let child = if let Some(&c) = non_field_children.first() {
3905 c
3906 } else {
3907 let mut fallback_cursor = node.walk();
3908 let mut fallback_child = None;
3909 if fallback_cursor.goto_first_child() {
3910 loop {
3911 if fallback_cursor.field_name().is_none()
3912 && !fallback_cursor.node().is_extra()
3913 {
3914 let candidate = fallback_cursor.node();
3915 #[allow(clippy::needless_question_mark)]
3916 if (|| -> ::core::result::Result<
3917 _,
3918 ::treesitter_types::ParseError,
3919 > {
3920 let child = candidate;
3921 Ok(
3922 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3923 child,
3924 src,
3925 ))?,
3926 )
3927 })()
3928 .is_ok()
3929 {
3930 fallback_child = Some(candidate);
3931 break;
3932 }
3933 }
3934 if !fallback_cursor.goto_next_sibling() {
3935 break;
3936 }
3937 }
3938 }
3939 if fallback_child.is_none() {
3940 let mut cursor2 = node.walk();
3941 if cursor2.goto_first_child() {
3942 loop {
3943 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3944 let candidate = cursor2.node();
3945 #[allow(clippy::needless_question_mark)]
3946 if (|| -> ::core::result::Result<
3947 _,
3948 ::treesitter_types::ParseError,
3949 > {
3950 let child = candidate;
3951 Ok(
3952 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(
3953 child,
3954 src,
3955 ))?,
3956 )
3957 })()
3958 .is_ok()
3959 {
3960 fallback_child = Some(candidate);
3961 break;
3962 }
3963 }
3964 if !cursor2.goto_next_sibling() {
3965 break;
3966 }
3967 }
3968 }
3969 }
3970 fallback_child.ok_or_else(|| {
3971 ::treesitter_types::ParseError::missing_field("children", node)
3972 })?
3973 };
3974 ::treesitter_types::runtime::maybe_grow_stack(|| {
3975 <ConstantPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
3976 })?
3977 },
3978 })
3979 }
3980}
3981impl ::treesitter_types::Spanned for ConstantPattern<'_> {
3982 fn span(&self) -> ::treesitter_types::Span {
3983 self.span
3984 }
3985}
3986#[derive(Debug, Clone, PartialEq, Eq)]
3987pub struct ConstructorConstraint<'tree> {
3988 pub span: ::treesitter_types::Span,
3989 text: &'tree str,
3990}
3991impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorConstraint<'tree> {
3992 fn from_node(
3993 node: ::treesitter_types::tree_sitter::Node<'tree>,
3994 src: &'tree [u8],
3995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3996 debug_assert_eq!(node.kind(), "constructor_constraint");
3997 Ok(Self {
3998 span: ::treesitter_types::Span::from(node),
3999 text: node.utf8_text(src)?,
4000 })
4001 }
4002}
4003impl<'tree> ::treesitter_types::LeafNode<'tree> for ConstructorConstraint<'tree> {
4004 fn text(&self) -> &'tree str {
4005 self.text
4006 }
4007}
4008impl ::treesitter_types::Spanned for ConstructorConstraint<'_> {
4009 fn span(&self) -> ::treesitter_types::Span {
4010 self.span
4011 }
4012}
4013#[derive(Debug, Clone, PartialEq, Eq)]
4014pub struct ConstructorDeclaration<'tree> {
4015 pub span: ::treesitter_types::Span,
4016 pub body: ::core::option::Option<ConstructorDeclarationBody<'tree>>,
4017 pub name: Identifier<'tree>,
4018 pub parameters: ParameterList<'tree>,
4019 pub children: ::std::vec::Vec<ConstructorDeclarationChildren<'tree>>,
4020}
4021impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclaration<'tree> {
4022 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4023 fn from_node(
4024 node: ::treesitter_types::tree_sitter::Node<'tree>,
4025 src: &'tree [u8],
4026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4027 debug_assert_eq!(node.kind(), "constructor_declaration");
4028 Ok(Self {
4029 span: ::treesitter_types::Span::from(node),
4030 body: match node.child_by_field_name("body") {
4031 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4032 <ConstructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4033 child, src,
4034 )
4035 })?),
4036 None => None,
4037 },
4038 name: {
4039 let child = node
4040 .child_by_field_name("name")
4041 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4042 ::treesitter_types::runtime::maybe_grow_stack(|| {
4043 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4044 })?
4045 },
4046 parameters: {
4047 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4048 ::treesitter_types::ParseError::missing_field("parameters", node)
4049 })?;
4050 ::treesitter_types::runtime::maybe_grow_stack(|| {
4051 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4052 })?
4053 },
4054 children: {
4055 #[allow(clippy::suspicious_else_formatting)]
4056 let non_field_children = {
4057 let mut cursor = node.walk();
4058 let mut result = ::std::vec::Vec::new();
4059 if cursor.goto_first_child() {
4060 loop {
4061 if cursor.field_name().is_none()
4062 && cursor.node().is_named()
4063 && !cursor.node().is_extra()
4064 {
4065 result.push(cursor.node());
4066 }
4067 if !cursor.goto_next_sibling() {
4068 break;
4069 }
4070 }
4071 }
4072 result
4073 };
4074 let mut items = ::std::vec::Vec::new();
4075 for child in non_field_children {
4076 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4077 <ConstructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4078 child, src,
4079 )
4080 })?);
4081 }
4082 items
4083 },
4084 })
4085 }
4086}
4087impl ::treesitter_types::Spanned for ConstructorDeclaration<'_> {
4088 fn span(&self) -> ::treesitter_types::Span {
4089 self.span
4090 }
4091}
4092#[derive(Debug, Clone, PartialEq, Eq)]
4093pub struct ConstructorInitializer<'tree> {
4094 pub span: ::treesitter_types::Span,
4095 pub children: ArgumentList<'tree>,
4096}
4097impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorInitializer<'tree> {
4098 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4099 fn from_node(
4100 node: ::treesitter_types::tree_sitter::Node<'tree>,
4101 src: &'tree [u8],
4102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4103 debug_assert_eq!(node.kind(), "constructor_initializer");
4104 Ok(Self {
4105 span: ::treesitter_types::Span::from(node),
4106 children: {
4107 #[allow(clippy::suspicious_else_formatting)]
4108 let non_field_children = {
4109 let mut cursor = node.walk();
4110 let mut result = ::std::vec::Vec::new();
4111 if cursor.goto_first_child() {
4112 loop {
4113 if cursor.field_name().is_none()
4114 && cursor.node().is_named()
4115 && !cursor.node().is_extra()
4116 {
4117 result.push(cursor.node());
4118 }
4119 if !cursor.goto_next_sibling() {
4120 break;
4121 }
4122 }
4123 }
4124 result
4125 };
4126 let child = if let Some(&c) = non_field_children.first() {
4127 c
4128 } else {
4129 let mut fallback_cursor = node.walk();
4130 let mut fallback_child = None;
4131 if fallback_cursor.goto_first_child() {
4132 loop {
4133 if fallback_cursor.field_name().is_none()
4134 && !fallback_cursor.node().is_extra()
4135 {
4136 let candidate = fallback_cursor.node();
4137 #[allow(clippy::needless_question_mark)]
4138 if (|| -> ::core::result::Result<
4139 _,
4140 ::treesitter_types::ParseError,
4141 > {
4142 let child = candidate;
4143 Ok(
4144 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
4145 child,
4146 src,
4147 ))?,
4148 )
4149 })()
4150 .is_ok()
4151 {
4152 fallback_child = Some(candidate);
4153 break;
4154 }
4155 }
4156 if !fallback_cursor.goto_next_sibling() {
4157 break;
4158 }
4159 }
4160 }
4161 if fallback_child.is_none() {
4162 let mut cursor2 = node.walk();
4163 if cursor2.goto_first_child() {
4164 loop {
4165 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4166 let candidate = cursor2.node();
4167 #[allow(clippy::needless_question_mark)]
4168 if (|| -> ::core::result::Result<
4169 _,
4170 ::treesitter_types::ParseError,
4171 > {
4172 let child = candidate;
4173 Ok(
4174 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
4175 child,
4176 src,
4177 ))?,
4178 )
4179 })()
4180 .is_ok()
4181 {
4182 fallback_child = Some(candidate);
4183 break;
4184 }
4185 }
4186 if !cursor2.goto_next_sibling() {
4187 break;
4188 }
4189 }
4190 }
4191 }
4192 fallback_child.ok_or_else(|| {
4193 ::treesitter_types::ParseError::missing_field("children", node)
4194 })?
4195 };
4196 ::treesitter_types::runtime::maybe_grow_stack(|| {
4197 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4198 })?
4199 },
4200 })
4201 }
4202}
4203impl ::treesitter_types::Spanned for ConstructorInitializer<'_> {
4204 fn span(&self) -> ::treesitter_types::Span {
4205 self.span
4206 }
4207}
4208#[derive(Debug, Clone, PartialEq, Eq)]
4209pub struct ContinueStatement<'tree> {
4210 pub span: ::treesitter_types::Span,
4211 text: &'tree str,
4212}
4213impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
4214 fn from_node(
4215 node: ::treesitter_types::tree_sitter::Node<'tree>,
4216 src: &'tree [u8],
4217 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4218 debug_assert_eq!(node.kind(), "continue_statement");
4219 Ok(Self {
4220 span: ::treesitter_types::Span::from(node),
4221 text: node.utf8_text(src)?,
4222 })
4223 }
4224}
4225impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
4226 fn text(&self) -> &'tree str {
4227 self.text
4228 }
4229}
4230impl ::treesitter_types::Spanned for ContinueStatement<'_> {
4231 fn span(&self) -> ::treesitter_types::Span {
4232 self.span
4233 }
4234}
4235#[derive(Debug, Clone, PartialEq, Eq)]
4236pub struct ConversionOperatorDeclaration<'tree> {
4237 pub span: ::treesitter_types::Span,
4238 pub body: ::core::option::Option<ConversionOperatorDeclarationBody<'tree>>,
4239 pub parameters: ParameterList<'tree>,
4240 pub r#type: Type<'tree>,
4241 pub children: ::std::vec::Vec<ConversionOperatorDeclarationChildren<'tree>>,
4242}
4243impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclaration<'tree> {
4244 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4245 fn from_node(
4246 node: ::treesitter_types::tree_sitter::Node<'tree>,
4247 src: &'tree [u8],
4248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4249 debug_assert_eq!(node.kind(), "conversion_operator_declaration");
4250 Ok(Self {
4251 span: ::treesitter_types::Span::from(node),
4252 body: match node.child_by_field_name("body") {
4253 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4254 <ConversionOperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4255 child, src,
4256 )
4257 })?),
4258 None => None,
4259 },
4260 parameters: {
4261 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4262 ::treesitter_types::ParseError::missing_field("parameters", node)
4263 })?;
4264 ::treesitter_types::runtime::maybe_grow_stack(|| {
4265 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4266 })?
4267 },
4268 r#type: {
4269 let child = node
4270 .child_by_field_name("type")
4271 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4272 ::treesitter_types::runtime::maybe_grow_stack(|| {
4273 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4274 })?
4275 },
4276 children: {
4277 #[allow(clippy::suspicious_else_formatting)]
4278 let non_field_children = {
4279 let mut cursor = node.walk();
4280 let mut result = ::std::vec::Vec::new();
4281 if cursor.goto_first_child() {
4282 loop {
4283 if cursor.field_name().is_none()
4284 && cursor.node().is_named()
4285 && !cursor.node().is_extra()
4286 {
4287 result.push(cursor.node());
4288 }
4289 if !cursor.goto_next_sibling() {
4290 break;
4291 }
4292 }
4293 }
4294 result
4295 };
4296 let mut items = ::std::vec::Vec::new();
4297 for child in non_field_children {
4298 items
4299 .push(
4300 ::treesitter_types::runtime::maybe_grow_stack(|| <ConversionOperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4301 child,
4302 src,
4303 ))?,
4304 );
4305 }
4306 items
4307 },
4308 })
4309 }
4310}
4311impl ::treesitter_types::Spanned for ConversionOperatorDeclaration<'_> {
4312 fn span(&self) -> ::treesitter_types::Span {
4313 self.span
4314 }
4315}
4316#[derive(Debug, Clone, PartialEq, Eq)]
4317pub struct DeclarationExpression<'tree> {
4318 pub span: ::treesitter_types::Span,
4319 pub name: Identifier<'tree>,
4320 pub r#type: Type<'tree>,
4321}
4322impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationExpression<'tree> {
4323 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4324 fn from_node(
4325 node: ::treesitter_types::tree_sitter::Node<'tree>,
4326 src: &'tree [u8],
4327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4328 debug_assert_eq!(node.kind(), "declaration_expression");
4329 Ok(Self {
4330 span: ::treesitter_types::Span::from(node),
4331 name: {
4332 let child = node
4333 .child_by_field_name("name")
4334 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4335 ::treesitter_types::runtime::maybe_grow_stack(|| {
4336 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4337 })?
4338 },
4339 r#type: {
4340 let child = node
4341 .child_by_field_name("type")
4342 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4343 ::treesitter_types::runtime::maybe_grow_stack(|| {
4344 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4345 })?
4346 },
4347 })
4348 }
4349}
4350impl ::treesitter_types::Spanned for DeclarationExpression<'_> {
4351 fn span(&self) -> ::treesitter_types::Span {
4352 self.span
4353 }
4354}
4355#[derive(Debug, Clone, PartialEq, Eq)]
4356pub struct DeclarationList<'tree> {
4357 pub span: ::treesitter_types::Span,
4358 pub children: ::std::vec::Vec<Declaration<'tree>>,
4359}
4360impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
4361 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4362 fn from_node(
4363 node: ::treesitter_types::tree_sitter::Node<'tree>,
4364 src: &'tree [u8],
4365 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4366 debug_assert_eq!(node.kind(), "declaration_list");
4367 Ok(Self {
4368 span: ::treesitter_types::Span::from(node),
4369 children: {
4370 #[allow(clippy::suspicious_else_formatting)]
4371 let non_field_children = {
4372 let mut cursor = node.walk();
4373 let mut result = ::std::vec::Vec::new();
4374 if cursor.goto_first_child() {
4375 loop {
4376 if cursor.field_name().is_none()
4377 && cursor.node().is_named()
4378 && !cursor.node().is_extra()
4379 {
4380 result.push(cursor.node());
4381 }
4382 if !cursor.goto_next_sibling() {
4383 break;
4384 }
4385 }
4386 }
4387 result
4388 };
4389 let mut items = ::std::vec::Vec::new();
4390 for child in non_field_children {
4391 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4392 <Declaration as ::treesitter_types::FromNode>::from_node(child, src)
4393 })?);
4394 }
4395 items
4396 },
4397 })
4398 }
4399}
4400impl ::treesitter_types::Spanned for DeclarationList<'_> {
4401 fn span(&self) -> ::treesitter_types::Span {
4402 self.span
4403 }
4404}
4405#[derive(Debug, Clone, PartialEq, Eq)]
4406pub struct DeclarationPattern<'tree> {
4407 pub span: ::treesitter_types::Span,
4408 pub name: ::core::option::Option<Identifier<'tree>>,
4409 pub r#type: Type<'tree>,
4410 pub children: ::core::option::Option<DeclarationPatternChildren<'tree>>,
4411}
4412impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPattern<'tree> {
4413 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4414 fn from_node(
4415 node: ::treesitter_types::tree_sitter::Node<'tree>,
4416 src: &'tree [u8],
4417 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4418 debug_assert_eq!(node.kind(), "declaration_pattern");
4419 Ok(Self {
4420 span: ::treesitter_types::Span::from(node),
4421 name: match node.child_by_field_name("name") {
4422 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4423 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4424 })?),
4425 None => None,
4426 },
4427 r#type: {
4428 let child = node
4429 .child_by_field_name("type")
4430 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4431 ::treesitter_types::runtime::maybe_grow_stack(|| {
4432 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4433 })?
4434 },
4435 children: {
4436 #[allow(clippy::suspicious_else_formatting)]
4437 let non_field_children = {
4438 let mut cursor = node.walk();
4439 let mut result = ::std::vec::Vec::new();
4440 if cursor.goto_first_child() {
4441 loop {
4442 if cursor.field_name().is_none()
4443 && cursor.node().is_named()
4444 && !cursor.node().is_extra()
4445 {
4446 result.push(cursor.node());
4447 }
4448 if !cursor.goto_next_sibling() {
4449 break;
4450 }
4451 }
4452 }
4453 result
4454 };
4455 match non_field_children.first() {
4456 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4457 <DeclarationPatternChildren as ::treesitter_types::FromNode>::from_node(
4458 child, src,
4459 )
4460 })?),
4461 None => None,
4462 }
4463 },
4464 })
4465 }
4466}
4467impl ::treesitter_types::Spanned for DeclarationPattern<'_> {
4468 fn span(&self) -> ::treesitter_types::Span {
4469 self.span
4470 }
4471}
4472#[derive(Debug, Clone, PartialEq, Eq)]
4473pub struct DefaultExpression<'tree> {
4474 pub span: ::treesitter_types::Span,
4475 pub r#type: ::core::option::Option<Type<'tree>>,
4476}
4477impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultExpression<'tree> {
4478 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4479 fn from_node(
4480 node: ::treesitter_types::tree_sitter::Node<'tree>,
4481 src: &'tree [u8],
4482 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4483 debug_assert_eq!(node.kind(), "default_expression");
4484 Ok(Self {
4485 span: ::treesitter_types::Span::from(node),
4486 r#type: match node.child_by_field_name("type") {
4487 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4488 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4489 })?),
4490 None => None,
4491 },
4492 })
4493 }
4494}
4495impl ::treesitter_types::Spanned for DefaultExpression<'_> {
4496 fn span(&self) -> ::treesitter_types::Span {
4497 self.span
4498 }
4499}
4500#[derive(Debug, Clone, PartialEq, Eq)]
4501pub struct DelegateDeclaration<'tree> {
4502 pub span: ::treesitter_types::Span,
4503 pub name: Identifier<'tree>,
4504 pub parameters: ParameterList<'tree>,
4505 pub r#type: Type<'tree>,
4506 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
4507 pub children: ::std::vec::Vec<DelegateDeclarationChildren<'tree>>,
4508}
4509impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclaration<'tree> {
4510 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4511 fn from_node(
4512 node: ::treesitter_types::tree_sitter::Node<'tree>,
4513 src: &'tree [u8],
4514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4515 debug_assert_eq!(node.kind(), "delegate_declaration");
4516 Ok(Self {
4517 span: ::treesitter_types::Span::from(node),
4518 name: {
4519 let child = node
4520 .child_by_field_name("name")
4521 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4522 ::treesitter_types::runtime::maybe_grow_stack(|| {
4523 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4524 })?
4525 },
4526 parameters: {
4527 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4528 ::treesitter_types::ParseError::missing_field("parameters", node)
4529 })?;
4530 ::treesitter_types::runtime::maybe_grow_stack(|| {
4531 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4532 })?
4533 },
4534 r#type: {
4535 let child = node
4536 .child_by_field_name("type")
4537 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4538 ::treesitter_types::runtime::maybe_grow_stack(|| {
4539 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4540 })?
4541 },
4542 type_parameters: match node.child_by_field_name("type_parameters") {
4543 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4544 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4545 })?),
4546 None => None,
4547 },
4548 children: {
4549 #[allow(clippy::suspicious_else_formatting)]
4550 let non_field_children = {
4551 let mut cursor = node.walk();
4552 let mut result = ::std::vec::Vec::new();
4553 if cursor.goto_first_child() {
4554 loop {
4555 if cursor.field_name().is_none()
4556 && cursor.node().is_named()
4557 && !cursor.node().is_extra()
4558 {
4559 result.push(cursor.node());
4560 }
4561 if !cursor.goto_next_sibling() {
4562 break;
4563 }
4564 }
4565 }
4566 result
4567 };
4568 let mut items = ::std::vec::Vec::new();
4569 for child in non_field_children {
4570 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4571 <DelegateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4572 child, src,
4573 )
4574 })?);
4575 }
4576 items
4577 },
4578 })
4579 }
4580}
4581impl ::treesitter_types::Spanned for DelegateDeclaration<'_> {
4582 fn span(&self) -> ::treesitter_types::Span {
4583 self.span
4584 }
4585}
4586#[derive(Debug, Clone, PartialEq, Eq)]
4587pub struct DestructorDeclaration<'tree> {
4588 pub span: ::treesitter_types::Span,
4589 pub body: ::core::option::Option<DestructorDeclarationBody<'tree>>,
4590 pub name: Identifier<'tree>,
4591 pub parameters: ParameterList<'tree>,
4592 pub children: ::std::vec::Vec<DestructorDeclarationChildren<'tree>>,
4593}
4594impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclaration<'tree> {
4595 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4596 fn from_node(
4597 node: ::treesitter_types::tree_sitter::Node<'tree>,
4598 src: &'tree [u8],
4599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4600 debug_assert_eq!(node.kind(), "destructor_declaration");
4601 Ok(Self {
4602 span: ::treesitter_types::Span::from(node),
4603 body: match node.child_by_field_name("body") {
4604 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4605 <DestructorDeclarationBody as ::treesitter_types::FromNode>::from_node(
4606 child, src,
4607 )
4608 })?),
4609 None => None,
4610 },
4611 name: {
4612 let child = node
4613 .child_by_field_name("name")
4614 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4615 ::treesitter_types::runtime::maybe_grow_stack(|| {
4616 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4617 })?
4618 },
4619 parameters: {
4620 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4621 ::treesitter_types::ParseError::missing_field("parameters", node)
4622 })?;
4623 ::treesitter_types::runtime::maybe_grow_stack(|| {
4624 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4625 })?
4626 },
4627 children: {
4628 #[allow(clippy::suspicious_else_formatting)]
4629 let non_field_children = {
4630 let mut cursor = node.walk();
4631 let mut result = ::std::vec::Vec::new();
4632 if cursor.goto_first_child() {
4633 loop {
4634 if cursor.field_name().is_none()
4635 && cursor.node().is_named()
4636 && !cursor.node().is_extra()
4637 {
4638 result.push(cursor.node());
4639 }
4640 if !cursor.goto_next_sibling() {
4641 break;
4642 }
4643 }
4644 }
4645 result
4646 };
4647 let mut items = ::std::vec::Vec::new();
4648 for child in non_field_children {
4649 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4650 <DestructorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4651 child, src,
4652 )
4653 })?);
4654 }
4655 items
4656 },
4657 })
4658 }
4659}
4660impl ::treesitter_types::Spanned for DestructorDeclaration<'_> {
4661 fn span(&self) -> ::treesitter_types::Span {
4662 self.span
4663 }
4664}
4665#[derive(Debug, Clone, PartialEq, Eq)]
4666pub struct DoStatement<'tree> {
4667 pub span: ::treesitter_types::Span,
4668 pub body: Statement<'tree>,
4669 pub condition: Expression<'tree>,
4670}
4671impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
4672 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4673 fn from_node(
4674 node: ::treesitter_types::tree_sitter::Node<'tree>,
4675 src: &'tree [u8],
4676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4677 debug_assert_eq!(node.kind(), "do_statement");
4678 Ok(Self {
4679 span: ::treesitter_types::Span::from(node),
4680 body: {
4681 let child = node
4682 .child_by_field_name("body")
4683 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4684 ::treesitter_types::runtime::maybe_grow_stack(|| {
4685 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4686 })?
4687 },
4688 condition: {
4689 let child = node.child_by_field_name("condition").ok_or_else(|| {
4690 ::treesitter_types::ParseError::missing_field("condition", node)
4691 })?;
4692 ::treesitter_types::runtime::maybe_grow_stack(|| {
4693 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4694 })?
4695 },
4696 })
4697 }
4698}
4699impl ::treesitter_types::Spanned for DoStatement<'_> {
4700 fn span(&self) -> ::treesitter_types::Span {
4701 self.span
4702 }
4703}
4704#[derive(Debug, Clone, PartialEq, Eq)]
4705pub struct ElementAccessExpression<'tree> {
4706 pub span: ::treesitter_types::Span,
4707 pub expression: Expression<'tree>,
4708 pub subscript: BracketedArgumentList<'tree>,
4709}
4710impl<'tree> ::treesitter_types::FromNode<'tree> for ElementAccessExpression<'tree> {
4711 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4712 fn from_node(
4713 node: ::treesitter_types::tree_sitter::Node<'tree>,
4714 src: &'tree [u8],
4715 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4716 debug_assert_eq!(node.kind(), "element_access_expression");
4717 Ok(Self {
4718 span: ::treesitter_types::Span::from(node),
4719 expression: {
4720 let child = node.child_by_field_name("expression").ok_or_else(|| {
4721 ::treesitter_types::ParseError::missing_field("expression", node)
4722 })?;
4723 ::treesitter_types::runtime::maybe_grow_stack(|| {
4724 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4725 })?
4726 },
4727 subscript: {
4728 let child = node.child_by_field_name("subscript").ok_or_else(|| {
4729 ::treesitter_types::ParseError::missing_field("subscript", node)
4730 })?;
4731 ::treesitter_types::runtime::maybe_grow_stack(|| {
4732 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4733 })?
4734 },
4735 })
4736 }
4737}
4738impl ::treesitter_types::Spanned for ElementAccessExpression<'_> {
4739 fn span(&self) -> ::treesitter_types::Span {
4740 self.span
4741 }
4742}
4743#[derive(Debug, Clone, PartialEq, Eq)]
4744pub struct ElementBindingExpression<'tree> {
4745 pub span: ::treesitter_types::Span,
4746 pub children: ::std::vec::Vec<Argument<'tree>>,
4747}
4748impl<'tree> ::treesitter_types::FromNode<'tree> for ElementBindingExpression<'tree> {
4749 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4750 fn from_node(
4751 node: ::treesitter_types::tree_sitter::Node<'tree>,
4752 src: &'tree [u8],
4753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4754 debug_assert_eq!(node.kind(), "element_binding_expression");
4755 Ok(Self {
4756 span: ::treesitter_types::Span::from(node),
4757 children: {
4758 #[allow(clippy::suspicious_else_formatting)]
4759 let non_field_children = {
4760 let mut cursor = node.walk();
4761 let mut result = ::std::vec::Vec::new();
4762 if cursor.goto_first_child() {
4763 loop {
4764 if cursor.field_name().is_none()
4765 && cursor.node().is_named()
4766 && !cursor.node().is_extra()
4767 {
4768 result.push(cursor.node());
4769 }
4770 if !cursor.goto_next_sibling() {
4771 break;
4772 }
4773 }
4774 }
4775 result
4776 };
4777 let mut items = ::std::vec::Vec::new();
4778 for child in non_field_children {
4779 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4780 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
4781 })?);
4782 }
4783 items
4784 },
4785 })
4786 }
4787}
4788impl ::treesitter_types::Spanned for ElementBindingExpression<'_> {
4789 fn span(&self) -> ::treesitter_types::Span {
4790 self.span
4791 }
4792}
4793#[derive(Debug, Clone, PartialEq, Eq)]
4794pub struct EmptyStatement<'tree> {
4795 pub span: ::treesitter_types::Span,
4796 text: &'tree str,
4797}
4798impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
4799 fn from_node(
4800 node: ::treesitter_types::tree_sitter::Node<'tree>,
4801 src: &'tree [u8],
4802 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4803 debug_assert_eq!(node.kind(), "empty_statement");
4804 Ok(Self {
4805 span: ::treesitter_types::Span::from(node),
4806 text: node.utf8_text(src)?,
4807 })
4808 }
4809}
4810impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
4811 fn text(&self) -> &'tree str {
4812 self.text
4813 }
4814}
4815impl ::treesitter_types::Spanned for EmptyStatement<'_> {
4816 fn span(&self) -> ::treesitter_types::Span {
4817 self.span
4818 }
4819}
4820#[derive(Debug, Clone, PartialEq, Eq)]
4821pub struct EnumDeclaration<'tree> {
4822 pub span: ::treesitter_types::Span,
4823 pub body: ::core::option::Option<EnumMemberDeclarationList<'tree>>,
4824 pub name: Identifier<'tree>,
4825 pub children: ::std::vec::Vec<EnumDeclarationChildren<'tree>>,
4826}
4827impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
4828 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4829 fn from_node(
4830 node: ::treesitter_types::tree_sitter::Node<'tree>,
4831 src: &'tree [u8],
4832 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4833 debug_assert_eq!(node.kind(), "enum_declaration");
4834 Ok(Self {
4835 span: ::treesitter_types::Span::from(node),
4836 body: match node.child_by_field_name("body") {
4837 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4838 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(
4839 child, src,
4840 )
4841 })?),
4842 None => None,
4843 },
4844 name: {
4845 let child = node
4846 .child_by_field_name("name")
4847 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4848 ::treesitter_types::runtime::maybe_grow_stack(|| {
4849 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4850 })?
4851 },
4852 children: {
4853 #[allow(clippy::suspicious_else_formatting)]
4854 let non_field_children = {
4855 let mut cursor = node.walk();
4856 let mut result = ::std::vec::Vec::new();
4857 if cursor.goto_first_child() {
4858 loop {
4859 if cursor.field_name().is_none()
4860 && cursor.node().is_named()
4861 && !cursor.node().is_extra()
4862 {
4863 result.push(cursor.node());
4864 }
4865 if !cursor.goto_next_sibling() {
4866 break;
4867 }
4868 }
4869 }
4870 result
4871 };
4872 let mut items = ::std::vec::Vec::new();
4873 for child in non_field_children {
4874 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4875 <EnumDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4876 child, src,
4877 )
4878 })?);
4879 }
4880 items
4881 },
4882 })
4883 }
4884}
4885impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
4886 fn span(&self) -> ::treesitter_types::Span {
4887 self.span
4888 }
4889}
4890#[derive(Debug, Clone, PartialEq, Eq)]
4891pub struct EnumMemberDeclaration<'tree> {
4892 pub span: ::treesitter_types::Span,
4893 pub name: Identifier<'tree>,
4894 pub value: ::core::option::Option<Expression<'tree>>,
4895 pub children: ::std::vec::Vec<EnumMemberDeclarationChildren<'tree>>,
4896}
4897impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclaration<'tree> {
4898 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4899 fn from_node(
4900 node: ::treesitter_types::tree_sitter::Node<'tree>,
4901 src: &'tree [u8],
4902 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4903 debug_assert_eq!(node.kind(), "enum_member_declaration");
4904 Ok(Self {
4905 span: ::treesitter_types::Span::from(node),
4906 name: {
4907 let child = node
4908 .child_by_field_name("name")
4909 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4910 ::treesitter_types::runtime::maybe_grow_stack(|| {
4911 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4912 })?
4913 },
4914 value: match node.child_by_field_name("value") {
4915 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4916 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4917 })?),
4918 None => None,
4919 },
4920 children: {
4921 #[allow(clippy::suspicious_else_formatting)]
4922 let non_field_children = {
4923 let mut cursor = node.walk();
4924 let mut result = ::std::vec::Vec::new();
4925 if cursor.goto_first_child() {
4926 loop {
4927 if cursor.field_name().is_none()
4928 && cursor.node().is_named()
4929 && !cursor.node().is_extra()
4930 {
4931 result.push(cursor.node());
4932 }
4933 if !cursor.goto_next_sibling() {
4934 break;
4935 }
4936 }
4937 }
4938 result
4939 };
4940 let mut items = ::std::vec::Vec::new();
4941 for child in non_field_children {
4942 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4943 <EnumMemberDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4944 child, src,
4945 )
4946 })?);
4947 }
4948 items
4949 },
4950 })
4951 }
4952}
4953impl ::treesitter_types::Spanned for EnumMemberDeclaration<'_> {
4954 fn span(&self) -> ::treesitter_types::Span {
4955 self.span
4956 }
4957}
4958#[derive(Debug, Clone, PartialEq, Eq)]
4959pub struct EnumMemberDeclarationList<'tree> {
4960 pub span: ::treesitter_types::Span,
4961 pub children: ::std::vec::Vec<EnumMemberDeclarationListChildren<'tree>>,
4962}
4963impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationList<'tree> {
4964 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4965 fn from_node(
4966 node: ::treesitter_types::tree_sitter::Node<'tree>,
4967 src: &'tree [u8],
4968 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4969 debug_assert_eq!(node.kind(), "enum_member_declaration_list");
4970 Ok(Self {
4971 span: ::treesitter_types::Span::from(node),
4972 children: {
4973 #[allow(clippy::suspicious_else_formatting)]
4974 let non_field_children = {
4975 let mut cursor = node.walk();
4976 let mut result = ::std::vec::Vec::new();
4977 if cursor.goto_first_child() {
4978 loop {
4979 if cursor.field_name().is_none()
4980 && cursor.node().is_named()
4981 && !cursor.node().is_extra()
4982 {
4983 result.push(cursor.node());
4984 }
4985 if !cursor.goto_next_sibling() {
4986 break;
4987 }
4988 }
4989 }
4990 result
4991 };
4992 let mut items = ::std::vec::Vec::new();
4993 for child in non_field_children {
4994 items
4995 .push(
4996 ::treesitter_types::runtime::maybe_grow_stack(|| <EnumMemberDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
4997 child,
4998 src,
4999 ))?,
5000 );
5001 }
5002 items
5003 },
5004 })
5005 }
5006}
5007impl ::treesitter_types::Spanned for EnumMemberDeclarationList<'_> {
5008 fn span(&self) -> ::treesitter_types::Span {
5009 self.span
5010 }
5011}
5012#[derive(Debug, Clone, PartialEq, Eq)]
5013pub struct EventDeclaration<'tree> {
5014 pub span: ::treesitter_types::Span,
5015 pub accessors: ::core::option::Option<AccessorList<'tree>>,
5016 pub name: Identifier<'tree>,
5017 pub r#type: Type<'tree>,
5018 pub children: ::std::vec::Vec<EventDeclarationChildren<'tree>>,
5019}
5020impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclaration<'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(), "event_declaration");
5027 Ok(Self {
5028 span: ::treesitter_types::Span::from(node),
5029 accessors: match node.child_by_field_name("accessors") {
5030 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5031 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
5032 })?),
5033 None => None,
5034 },
5035 name: {
5036 let child = node
5037 .child_by_field_name("name")
5038 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5039 ::treesitter_types::runtime::maybe_grow_stack(|| {
5040 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5041 })?
5042 },
5043 r#type: {
5044 let child = node
5045 .child_by_field_name("type")
5046 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5047 ::treesitter_types::runtime::maybe_grow_stack(|| {
5048 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5049 })?
5050 },
5051 children: {
5052 #[allow(clippy::suspicious_else_formatting)]
5053 let non_field_children = {
5054 let mut cursor = node.walk();
5055 let mut result = ::std::vec::Vec::new();
5056 if cursor.goto_first_child() {
5057 loop {
5058 if cursor.field_name().is_none()
5059 && cursor.node().is_named()
5060 && !cursor.node().is_extra()
5061 {
5062 result.push(cursor.node());
5063 }
5064 if !cursor.goto_next_sibling() {
5065 break;
5066 }
5067 }
5068 }
5069 result
5070 };
5071 let mut items = ::std::vec::Vec::new();
5072 for child in non_field_children {
5073 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5074 <EventDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5075 child, src,
5076 )
5077 })?);
5078 }
5079 items
5080 },
5081 })
5082 }
5083}
5084impl ::treesitter_types::Spanned for EventDeclaration<'_> {
5085 fn span(&self) -> ::treesitter_types::Span {
5086 self.span
5087 }
5088}
5089#[derive(Debug, Clone, PartialEq, Eq)]
5090pub struct EventFieldDeclaration<'tree> {
5091 pub span: ::treesitter_types::Span,
5092 pub children: ::std::vec::Vec<EventFieldDeclarationChildren<'tree>>,
5093}
5094impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclaration<'tree> {
5095 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5096 fn from_node(
5097 node: ::treesitter_types::tree_sitter::Node<'tree>,
5098 src: &'tree [u8],
5099 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5100 debug_assert_eq!(node.kind(), "event_field_declaration");
5101 Ok(Self {
5102 span: ::treesitter_types::Span::from(node),
5103 children: {
5104 #[allow(clippy::suspicious_else_formatting)]
5105 let non_field_children = {
5106 let mut cursor = node.walk();
5107 let mut result = ::std::vec::Vec::new();
5108 if cursor.goto_first_child() {
5109 loop {
5110 if cursor.field_name().is_none()
5111 && cursor.node().is_named()
5112 && !cursor.node().is_extra()
5113 {
5114 result.push(cursor.node());
5115 }
5116 if !cursor.goto_next_sibling() {
5117 break;
5118 }
5119 }
5120 }
5121 result
5122 };
5123 let mut items = ::std::vec::Vec::new();
5124 for child in non_field_children {
5125 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5126 <EventFieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5127 child, src,
5128 )
5129 })?);
5130 }
5131 items
5132 },
5133 })
5134 }
5135}
5136impl ::treesitter_types::Spanned for EventFieldDeclaration<'_> {
5137 fn span(&self) -> ::treesitter_types::Span {
5138 self.span
5139 }
5140}
5141#[derive(Debug, Clone, PartialEq, Eq)]
5142pub struct ExplicitInterfaceSpecifier<'tree> {
5143 pub span: ::treesitter_types::Span,
5144 pub children: ExplicitInterfaceSpecifierChildren<'tree>,
5145}
5146impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifier<'tree> {
5147 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5148 fn from_node(
5149 node: ::treesitter_types::tree_sitter::Node<'tree>,
5150 src: &'tree [u8],
5151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5152 debug_assert_eq!(node.kind(), "explicit_interface_specifier");
5153 Ok(Self {
5154 span: ::treesitter_types::Span::from(node),
5155 children: {
5156 #[allow(clippy::suspicious_else_formatting)]
5157 let non_field_children = {
5158 let mut cursor = node.walk();
5159 let mut result = ::std::vec::Vec::new();
5160 if cursor.goto_first_child() {
5161 loop {
5162 if cursor.field_name().is_none()
5163 && cursor.node().is_named()
5164 && !cursor.node().is_extra()
5165 {
5166 result.push(cursor.node());
5167 }
5168 if !cursor.goto_next_sibling() {
5169 break;
5170 }
5171 }
5172 }
5173 result
5174 };
5175 let child = if let Some(&c) = non_field_children.first() {
5176 c
5177 } else {
5178 let mut fallback_cursor = node.walk();
5179 let mut fallback_child = None;
5180 if fallback_cursor.goto_first_child() {
5181 loop {
5182 if fallback_cursor.field_name().is_none()
5183 && !fallback_cursor.node().is_extra()
5184 {
5185 let candidate = fallback_cursor.node();
5186 #[allow(clippy::needless_question_mark)]
5187 if (|| -> ::core::result::Result<
5188 _,
5189 ::treesitter_types::ParseError,
5190 > {
5191 let child = candidate;
5192 Ok(
5193 ::treesitter_types::runtime::maybe_grow_stack(|| <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
5194 child,
5195 src,
5196 ))?,
5197 )
5198 })()
5199 .is_ok()
5200 {
5201 fallback_child = Some(candidate);
5202 break;
5203 }
5204 }
5205 if !fallback_cursor.goto_next_sibling() {
5206 break;
5207 }
5208 }
5209 }
5210 if fallback_child.is_none() {
5211 let mut cursor2 = node.walk();
5212 if cursor2.goto_first_child() {
5213 loop {
5214 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5215 let candidate = cursor2.node();
5216 #[allow(clippy::needless_question_mark)]
5217 if (|| -> ::core::result::Result<
5218 _,
5219 ::treesitter_types::ParseError,
5220 > {
5221 let child = candidate;
5222 Ok(
5223 ::treesitter_types::runtime::maybe_grow_stack(|| <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
5224 child,
5225 src,
5226 ))?,
5227 )
5228 })()
5229 .is_ok()
5230 {
5231 fallback_child = Some(candidate);
5232 break;
5233 }
5234 }
5235 if !cursor2.goto_next_sibling() {
5236 break;
5237 }
5238 }
5239 }
5240 }
5241 fallback_child.ok_or_else(|| {
5242 ::treesitter_types::ParseError::missing_field("children", node)
5243 })?
5244 };
5245 ::treesitter_types::runtime::maybe_grow_stack(|| {
5246 <ExplicitInterfaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
5247 child, src,
5248 )
5249 })?
5250 },
5251 })
5252 }
5253}
5254impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifier<'_> {
5255 fn span(&self) -> ::treesitter_types::Span {
5256 self.span
5257 }
5258}
5259#[derive(Debug, Clone, PartialEq, Eq)]
5260pub struct ExpressionElement<'tree> {
5261 pub span: ::treesitter_types::Span,
5262 pub children: Expression<'tree>,
5263}
5264impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionElement<'tree> {
5265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5266 fn from_node(
5267 node: ::treesitter_types::tree_sitter::Node<'tree>,
5268 src: &'tree [u8],
5269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5270 debug_assert_eq!(node.kind(), "expression_element");
5271 Ok(Self {
5272 span: ::treesitter_types::Span::from(node),
5273 children: {
5274 #[allow(clippy::suspicious_else_formatting)]
5275 let non_field_children = {
5276 let mut cursor = node.walk();
5277 let mut result = ::std::vec::Vec::new();
5278 if cursor.goto_first_child() {
5279 loop {
5280 if cursor.field_name().is_none()
5281 && cursor.node().is_named()
5282 && !cursor.node().is_extra()
5283 {
5284 result.push(cursor.node());
5285 }
5286 if !cursor.goto_next_sibling() {
5287 break;
5288 }
5289 }
5290 }
5291 result
5292 };
5293 let child = if let Some(&c) = non_field_children.first() {
5294 c
5295 } else {
5296 let mut fallback_cursor = node.walk();
5297 let mut fallback_child = None;
5298 if fallback_cursor.goto_first_child() {
5299 loop {
5300 if fallback_cursor.field_name().is_none()
5301 && !fallback_cursor.node().is_extra()
5302 {
5303 let candidate = fallback_cursor.node();
5304 #[allow(clippy::needless_question_mark)]
5305 if (|| -> ::core::result::Result<
5306 _,
5307 ::treesitter_types::ParseError,
5308 > {
5309 let child = candidate;
5310 Ok(
5311 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5312 child,
5313 src,
5314 ))?,
5315 )
5316 })()
5317 .is_ok()
5318 {
5319 fallback_child = Some(candidate);
5320 break;
5321 }
5322 }
5323 if !fallback_cursor.goto_next_sibling() {
5324 break;
5325 }
5326 }
5327 }
5328 if fallback_child.is_none() {
5329 let mut cursor2 = node.walk();
5330 if cursor2.goto_first_child() {
5331 loop {
5332 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5333 let candidate = cursor2.node();
5334 #[allow(clippy::needless_question_mark)]
5335 if (|| -> ::core::result::Result<
5336 _,
5337 ::treesitter_types::ParseError,
5338 > {
5339 let child = candidate;
5340 Ok(
5341 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5342 child,
5343 src,
5344 ))?,
5345 )
5346 })()
5347 .is_ok()
5348 {
5349 fallback_child = Some(candidate);
5350 break;
5351 }
5352 }
5353 if !cursor2.goto_next_sibling() {
5354 break;
5355 }
5356 }
5357 }
5358 }
5359 fallback_child.ok_or_else(|| {
5360 ::treesitter_types::ParseError::missing_field("children", node)
5361 })?
5362 };
5363 ::treesitter_types::runtime::maybe_grow_stack(|| {
5364 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5365 })?
5366 },
5367 })
5368 }
5369}
5370impl ::treesitter_types::Spanned for ExpressionElement<'_> {
5371 fn span(&self) -> ::treesitter_types::Span {
5372 self.span
5373 }
5374}
5375#[derive(Debug, Clone, PartialEq, Eq)]
5376pub struct ExpressionStatement<'tree> {
5377 pub span: ::treesitter_types::Span,
5378 pub children: ExpressionStatementChildren<'tree>,
5379}
5380impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
5381 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5382 fn from_node(
5383 node: ::treesitter_types::tree_sitter::Node<'tree>,
5384 src: &'tree [u8],
5385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5386 debug_assert_eq!(node.kind(), "expression_statement");
5387 Ok(Self {
5388 span: ::treesitter_types::Span::from(node),
5389 children: {
5390 #[allow(clippy::suspicious_else_formatting)]
5391 let non_field_children = {
5392 let mut cursor = node.walk();
5393 let mut result = ::std::vec::Vec::new();
5394 if cursor.goto_first_child() {
5395 loop {
5396 if cursor.field_name().is_none()
5397 && cursor.node().is_named()
5398 && !cursor.node().is_extra()
5399 {
5400 result.push(cursor.node());
5401 }
5402 if !cursor.goto_next_sibling() {
5403 break;
5404 }
5405 }
5406 }
5407 result
5408 };
5409 let child = if let Some(&c) = non_field_children.first() {
5410 c
5411 } else {
5412 let mut fallback_cursor = node.walk();
5413 let mut fallback_child = None;
5414 if fallback_cursor.goto_first_child() {
5415 loop {
5416 if fallback_cursor.field_name().is_none()
5417 && !fallback_cursor.node().is_extra()
5418 {
5419 let candidate = fallback_cursor.node();
5420 #[allow(clippy::needless_question_mark)]
5421 if (|| -> ::core::result::Result<
5422 _,
5423 ::treesitter_types::ParseError,
5424 > {
5425 let child = candidate;
5426 Ok(
5427 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5428 child,
5429 src,
5430 ))?,
5431 )
5432 })()
5433 .is_ok()
5434 {
5435 fallback_child = Some(candidate);
5436 break;
5437 }
5438 }
5439 if !fallback_cursor.goto_next_sibling() {
5440 break;
5441 }
5442 }
5443 }
5444 if fallback_child.is_none() {
5445 let mut cursor2 = node.walk();
5446 if cursor2.goto_first_child() {
5447 loop {
5448 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5449 let candidate = cursor2.node();
5450 #[allow(clippy::needless_question_mark)]
5451 if (|| -> ::core::result::Result<
5452 _,
5453 ::treesitter_types::ParseError,
5454 > {
5455 let child = candidate;
5456 Ok(
5457 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5458 child,
5459 src,
5460 ))?,
5461 )
5462 })()
5463 .is_ok()
5464 {
5465 fallback_child = Some(candidate);
5466 break;
5467 }
5468 }
5469 if !cursor2.goto_next_sibling() {
5470 break;
5471 }
5472 }
5473 }
5474 }
5475 fallback_child.ok_or_else(|| {
5476 ::treesitter_types::ParseError::missing_field("children", node)
5477 })?
5478 };
5479 ::treesitter_types::runtime::maybe_grow_stack(|| {
5480 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
5481 child, src,
5482 )
5483 })?
5484 },
5485 })
5486 }
5487}
5488impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
5489 fn span(&self) -> ::treesitter_types::Span {
5490 self.span
5491 }
5492}
5493#[derive(Debug, Clone, PartialEq, Eq)]
5494pub struct ExternAliasDirective<'tree> {
5495 pub span: ::treesitter_types::Span,
5496 pub name: Identifier<'tree>,
5497}
5498impl<'tree> ::treesitter_types::FromNode<'tree> for ExternAliasDirective<'tree> {
5499 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5500 fn from_node(
5501 node: ::treesitter_types::tree_sitter::Node<'tree>,
5502 src: &'tree [u8],
5503 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5504 debug_assert_eq!(node.kind(), "extern_alias_directive");
5505 Ok(Self {
5506 span: ::treesitter_types::Span::from(node),
5507 name: {
5508 let child = node
5509 .child_by_field_name("name")
5510 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5511 ::treesitter_types::runtime::maybe_grow_stack(|| {
5512 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5513 })?
5514 },
5515 })
5516 }
5517}
5518impl ::treesitter_types::Spanned for ExternAliasDirective<'_> {
5519 fn span(&self) -> ::treesitter_types::Span {
5520 self.span
5521 }
5522}
5523#[derive(Debug, Clone, PartialEq, Eq)]
5524pub struct FieldDeclaration<'tree> {
5525 pub span: ::treesitter_types::Span,
5526 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
5527}
5528impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
5529 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5530 fn from_node(
5531 node: ::treesitter_types::tree_sitter::Node<'tree>,
5532 src: &'tree [u8],
5533 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5534 debug_assert_eq!(node.kind(), "field_declaration");
5535 Ok(Self {
5536 span: ::treesitter_types::Span::from(node),
5537 children: {
5538 #[allow(clippy::suspicious_else_formatting)]
5539 let non_field_children = {
5540 let mut cursor = node.walk();
5541 let mut result = ::std::vec::Vec::new();
5542 if cursor.goto_first_child() {
5543 loop {
5544 if cursor.field_name().is_none()
5545 && cursor.node().is_named()
5546 && !cursor.node().is_extra()
5547 {
5548 result.push(cursor.node());
5549 }
5550 if !cursor.goto_next_sibling() {
5551 break;
5552 }
5553 }
5554 }
5555 result
5556 };
5557 let mut items = ::std::vec::Vec::new();
5558 for child in non_field_children {
5559 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5560 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5561 child, src,
5562 )
5563 })?);
5564 }
5565 items
5566 },
5567 })
5568 }
5569}
5570impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
5571 fn span(&self) -> ::treesitter_types::Span {
5572 self.span
5573 }
5574}
5575#[derive(Debug, Clone, PartialEq, Eq)]
5576pub struct FileScopedNamespaceDeclaration<'tree> {
5577 pub span: ::treesitter_types::Span,
5578 pub name: FileScopedNamespaceDeclarationName<'tree>,
5579}
5580impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclaration<'tree> {
5581 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5582 fn from_node(
5583 node: ::treesitter_types::tree_sitter::Node<'tree>,
5584 src: &'tree [u8],
5585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5586 debug_assert_eq!(node.kind(), "file_scoped_namespace_declaration");
5587 Ok(Self {
5588 span: ::treesitter_types::Span::from(node),
5589 name: {
5590 let child = node
5591 .child_by_field_name("name")
5592 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5593 ::treesitter_types::runtime::maybe_grow_stack(|| {
5594 <FileScopedNamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(
5595 child, src,
5596 )
5597 })?
5598 },
5599 })
5600 }
5601}
5602impl ::treesitter_types::Spanned for FileScopedNamespaceDeclaration<'_> {
5603 fn span(&self) -> ::treesitter_types::Span {
5604 self.span
5605 }
5606}
5607#[derive(Debug, Clone, PartialEq, Eq)]
5608pub struct FinallyClause<'tree> {
5609 pub span: ::treesitter_types::Span,
5610 pub children: Block<'tree>,
5611}
5612impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
5613 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5614 fn from_node(
5615 node: ::treesitter_types::tree_sitter::Node<'tree>,
5616 src: &'tree [u8],
5617 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5618 debug_assert_eq!(node.kind(), "finally_clause");
5619 Ok(Self {
5620 span: ::treesitter_types::Span::from(node),
5621 children: {
5622 #[allow(clippy::suspicious_else_formatting)]
5623 let non_field_children = {
5624 let mut cursor = node.walk();
5625 let mut result = ::std::vec::Vec::new();
5626 if cursor.goto_first_child() {
5627 loop {
5628 if cursor.field_name().is_none()
5629 && cursor.node().is_named()
5630 && !cursor.node().is_extra()
5631 {
5632 result.push(cursor.node());
5633 }
5634 if !cursor.goto_next_sibling() {
5635 break;
5636 }
5637 }
5638 }
5639 result
5640 };
5641 let child = if let Some(&c) = non_field_children.first() {
5642 c
5643 } else {
5644 let mut fallback_cursor = node.walk();
5645 let mut fallback_child = None;
5646 if fallback_cursor.goto_first_child() {
5647 loop {
5648 if fallback_cursor.field_name().is_none()
5649 && !fallback_cursor.node().is_extra()
5650 {
5651 let candidate = fallback_cursor.node();
5652 #[allow(clippy::needless_question_mark)]
5653 if (|| -> ::core::result::Result<
5654 _,
5655 ::treesitter_types::ParseError,
5656 > {
5657 let child = candidate;
5658 Ok(
5659 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
5660 child,
5661 src,
5662 ))?,
5663 )
5664 })()
5665 .is_ok()
5666 {
5667 fallback_child = Some(candidate);
5668 break;
5669 }
5670 }
5671 if !fallback_cursor.goto_next_sibling() {
5672 break;
5673 }
5674 }
5675 }
5676 if fallback_child.is_none() {
5677 let mut cursor2 = node.walk();
5678 if cursor2.goto_first_child() {
5679 loop {
5680 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5681 let candidate = cursor2.node();
5682 #[allow(clippy::needless_question_mark)]
5683 if (|| -> ::core::result::Result<
5684 _,
5685 ::treesitter_types::ParseError,
5686 > {
5687 let child = candidate;
5688 Ok(
5689 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
5690 child,
5691 src,
5692 ))?,
5693 )
5694 })()
5695 .is_ok()
5696 {
5697 fallback_child = Some(candidate);
5698 break;
5699 }
5700 }
5701 if !cursor2.goto_next_sibling() {
5702 break;
5703 }
5704 }
5705 }
5706 }
5707 fallback_child.ok_or_else(|| {
5708 ::treesitter_types::ParseError::missing_field("children", node)
5709 })?
5710 };
5711 ::treesitter_types::runtime::maybe_grow_stack(|| {
5712 <Block as ::treesitter_types::FromNode>::from_node(child, src)
5713 })?
5714 },
5715 })
5716 }
5717}
5718impl ::treesitter_types::Spanned for FinallyClause<'_> {
5719 fn span(&self) -> ::treesitter_types::Span {
5720 self.span
5721 }
5722}
5723#[derive(Debug, Clone, PartialEq, Eq)]
5724pub struct FixedStatement<'tree> {
5725 pub span: ::treesitter_types::Span,
5726 pub children: ::std::vec::Vec<FixedStatementChildren<'tree>>,
5727}
5728impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatement<'tree> {
5729 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5730 fn from_node(
5731 node: ::treesitter_types::tree_sitter::Node<'tree>,
5732 src: &'tree [u8],
5733 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5734 debug_assert_eq!(node.kind(), "fixed_statement");
5735 Ok(Self {
5736 span: ::treesitter_types::Span::from(node),
5737 children: {
5738 #[allow(clippy::suspicious_else_formatting)]
5739 let non_field_children = {
5740 let mut cursor = node.walk();
5741 let mut result = ::std::vec::Vec::new();
5742 if cursor.goto_first_child() {
5743 loop {
5744 if cursor.field_name().is_none()
5745 && cursor.node().is_named()
5746 && !cursor.node().is_extra()
5747 {
5748 result.push(cursor.node());
5749 }
5750 if !cursor.goto_next_sibling() {
5751 break;
5752 }
5753 }
5754 }
5755 result
5756 };
5757 let mut items = ::std::vec::Vec::new();
5758 for child in non_field_children {
5759 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5760 <FixedStatementChildren as ::treesitter_types::FromNode>::from_node(
5761 child, src,
5762 )
5763 })?);
5764 }
5765 items
5766 },
5767 })
5768 }
5769}
5770impl ::treesitter_types::Spanned for FixedStatement<'_> {
5771 fn span(&self) -> ::treesitter_types::Span {
5772 self.span
5773 }
5774}
5775#[derive(Debug, Clone, PartialEq, Eq)]
5776pub struct ForStatement<'tree> {
5777 pub span: ::treesitter_types::Span,
5778 pub body: Statement<'tree>,
5779 pub condition: ::core::option::Option<Expression<'tree>>,
5780 pub initializer: ::std::vec::Vec<ForStatementInitializer<'tree>>,
5781 pub update: ::std::vec::Vec<ForStatementUpdate<'tree>>,
5782}
5783impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
5784 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5785 fn from_node(
5786 node: ::treesitter_types::tree_sitter::Node<'tree>,
5787 src: &'tree [u8],
5788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5789 debug_assert_eq!(node.kind(), "for_statement");
5790 Ok(Self {
5791 span: ::treesitter_types::Span::from(node),
5792 body: {
5793 let child = node
5794 .child_by_field_name("body")
5795 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5796 ::treesitter_types::runtime::maybe_grow_stack(|| {
5797 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5798 })?
5799 },
5800 condition: match node.child_by_field_name("condition") {
5801 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5802 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5803 })?),
5804 None => None,
5805 },
5806 initializer: {
5807 let mut cursor = node.walk();
5808 let mut items = ::std::vec::Vec::new();
5809 for child in node.children_by_field_name("initializer", &mut cursor) {
5810 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5811 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(
5812 child, src,
5813 )
5814 })?);
5815 }
5816 items
5817 },
5818 update: {
5819 let mut cursor = node.walk();
5820 let mut items = ::std::vec::Vec::new();
5821 for child in node.children_by_field_name("update", &mut cursor) {
5822 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5823 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)
5824 })?);
5825 }
5826 items
5827 },
5828 })
5829 }
5830}
5831impl ::treesitter_types::Spanned for ForStatement<'_> {
5832 fn span(&self) -> ::treesitter_types::Span {
5833 self.span
5834 }
5835}
5836#[derive(Debug, Clone, PartialEq, Eq)]
5837pub struct ForeachStatement<'tree> {
5838 pub span: ::treesitter_types::Span,
5839 pub body: Statement<'tree>,
5840 pub left: ForeachStatementLeft<'tree>,
5841 pub right: Expression<'tree>,
5842 pub r#type: ::core::option::Option<Type<'tree>>,
5843}
5844impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatement<'tree> {
5845 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5846 fn from_node(
5847 node: ::treesitter_types::tree_sitter::Node<'tree>,
5848 src: &'tree [u8],
5849 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5850 debug_assert_eq!(node.kind(), "foreach_statement");
5851 Ok(Self {
5852 span: ::treesitter_types::Span::from(node),
5853 body: {
5854 let child = node
5855 .child_by_field_name("body")
5856 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5857 ::treesitter_types::runtime::maybe_grow_stack(|| {
5858 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5859 })?
5860 },
5861 left: {
5862 let child = node
5863 .child_by_field_name("left")
5864 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5865 ::treesitter_types::runtime::maybe_grow_stack(|| {
5866 <ForeachStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)
5867 })?
5868 },
5869 right: {
5870 let child = node
5871 .child_by_field_name("right")
5872 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5873 ::treesitter_types::runtime::maybe_grow_stack(|| {
5874 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5875 })?
5876 },
5877 r#type: match node.child_by_field_name("type") {
5878 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5879 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5880 })?),
5881 None => None,
5882 },
5883 })
5884 }
5885}
5886impl ::treesitter_types::Spanned for ForeachStatement<'_> {
5887 fn span(&self) -> ::treesitter_types::Span {
5888 self.span
5889 }
5890}
5891#[derive(Debug, Clone, PartialEq, Eq)]
5892pub struct FromClause<'tree> {
5893 pub span: ::treesitter_types::Span,
5894 pub name: Identifier<'tree>,
5895 pub r#type: ::core::option::Option<Type<'tree>>,
5896 pub children: Expression<'tree>,
5897}
5898impl<'tree> ::treesitter_types::FromNode<'tree> for FromClause<'tree> {
5899 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5900 fn from_node(
5901 node: ::treesitter_types::tree_sitter::Node<'tree>,
5902 src: &'tree [u8],
5903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5904 debug_assert_eq!(node.kind(), "from_clause");
5905 Ok(Self {
5906 span: ::treesitter_types::Span::from(node),
5907 name: {
5908 let child = node
5909 .child_by_field_name("name")
5910 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5911 ::treesitter_types::runtime::maybe_grow_stack(|| {
5912 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5913 })?
5914 },
5915 r#type: match node.child_by_field_name("type") {
5916 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5917 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5918 })?),
5919 None => None,
5920 },
5921 children: {
5922 #[allow(clippy::suspicious_else_formatting)]
5923 let non_field_children = {
5924 let mut cursor = node.walk();
5925 let mut result = ::std::vec::Vec::new();
5926 if cursor.goto_first_child() {
5927 loop {
5928 if cursor.field_name().is_none()
5929 && cursor.node().is_named()
5930 && !cursor.node().is_extra()
5931 {
5932 result.push(cursor.node());
5933 }
5934 if !cursor.goto_next_sibling() {
5935 break;
5936 }
5937 }
5938 }
5939 result
5940 };
5941 let child = if let Some(&c) = non_field_children.first() {
5942 c
5943 } else {
5944 let mut fallback_cursor = node.walk();
5945 let mut fallback_child = None;
5946 if fallback_cursor.goto_first_child() {
5947 loop {
5948 if fallback_cursor.field_name().is_none()
5949 && !fallback_cursor.node().is_extra()
5950 {
5951 let candidate = fallback_cursor.node();
5952 #[allow(clippy::needless_question_mark)]
5953 if (|| -> ::core::result::Result<
5954 _,
5955 ::treesitter_types::ParseError,
5956 > {
5957 let child = candidate;
5958 Ok(
5959 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5960 child,
5961 src,
5962 ))?,
5963 )
5964 })()
5965 .is_ok()
5966 {
5967 fallback_child = Some(candidate);
5968 break;
5969 }
5970 }
5971 if !fallback_cursor.goto_next_sibling() {
5972 break;
5973 }
5974 }
5975 }
5976 if fallback_child.is_none() {
5977 let mut cursor2 = node.walk();
5978 if cursor2.goto_first_child() {
5979 loop {
5980 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5981 let candidate = cursor2.node();
5982 #[allow(clippy::needless_question_mark)]
5983 if (|| -> ::core::result::Result<
5984 _,
5985 ::treesitter_types::ParseError,
5986 > {
5987 let child = candidate;
5988 Ok(
5989 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5990 child,
5991 src,
5992 ))?,
5993 )
5994 })()
5995 .is_ok()
5996 {
5997 fallback_child = Some(candidate);
5998 break;
5999 }
6000 }
6001 if !cursor2.goto_next_sibling() {
6002 break;
6003 }
6004 }
6005 }
6006 }
6007 fallback_child.ok_or_else(|| {
6008 ::treesitter_types::ParseError::missing_field("children", node)
6009 })?
6010 };
6011 ::treesitter_types::runtime::maybe_grow_stack(|| {
6012 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6013 })?
6014 },
6015 })
6016 }
6017}
6018impl ::treesitter_types::Spanned for FromClause<'_> {
6019 fn span(&self) -> ::treesitter_types::Span {
6020 self.span
6021 }
6022}
6023#[derive(Debug, Clone, PartialEq, Eq)]
6024pub struct FunctionPointerParameter<'tree> {
6025 pub span: ::treesitter_types::Span,
6026 pub r#type: FunctionPointerParameterType<'tree>,
6027}
6028impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameter<'tree> {
6029 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6030 fn from_node(
6031 node: ::treesitter_types::tree_sitter::Node<'tree>,
6032 src: &'tree [u8],
6033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6034 debug_assert_eq!(node.kind(), "function_pointer_parameter");
6035 Ok(Self {
6036 span: ::treesitter_types::Span::from(node),
6037 r#type: {
6038 let child = node
6039 .child_by_field_name("type")
6040 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6041 ::treesitter_types::runtime::maybe_grow_stack(|| {
6042 <FunctionPointerParameterType as ::treesitter_types::FromNode>::from_node(
6043 child, src,
6044 )
6045 })?
6046 },
6047 })
6048 }
6049}
6050impl ::treesitter_types::Spanned for FunctionPointerParameter<'_> {
6051 fn span(&self) -> ::treesitter_types::Span {
6052 self.span
6053 }
6054}
6055#[derive(Debug, Clone, PartialEq, Eq)]
6056pub struct FunctionPointerType<'tree> {
6057 pub span: ::treesitter_types::Span,
6058 pub returns: Type<'tree>,
6059 pub children: ::std::vec::Vec<FunctionPointerTypeChildren<'tree>>,
6060}
6061impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerType<'tree> {
6062 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6063 fn from_node(
6064 node: ::treesitter_types::tree_sitter::Node<'tree>,
6065 src: &'tree [u8],
6066 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6067 debug_assert_eq!(node.kind(), "function_pointer_type");
6068 Ok(Self {
6069 span: ::treesitter_types::Span::from(node),
6070 returns: {
6071 let child = node.child_by_field_name("returns").ok_or_else(|| {
6072 ::treesitter_types::ParseError::missing_field("returns", node)
6073 })?;
6074 ::treesitter_types::runtime::maybe_grow_stack(|| {
6075 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6076 })?
6077 },
6078 children: {
6079 #[allow(clippy::suspicious_else_formatting)]
6080 let non_field_children = {
6081 let mut cursor = node.walk();
6082 let mut result = ::std::vec::Vec::new();
6083 if cursor.goto_first_child() {
6084 loop {
6085 if cursor.field_name().is_none()
6086 && cursor.node().is_named()
6087 && !cursor.node().is_extra()
6088 {
6089 result.push(cursor.node());
6090 }
6091 if !cursor.goto_next_sibling() {
6092 break;
6093 }
6094 }
6095 }
6096 result
6097 };
6098 let mut items = ::std::vec::Vec::new();
6099 for child in non_field_children {
6100 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6101 <FunctionPointerTypeChildren as ::treesitter_types::FromNode>::from_node(
6102 child, src,
6103 )
6104 })?);
6105 }
6106 items
6107 },
6108 })
6109 }
6110}
6111impl ::treesitter_types::Spanned for FunctionPointerType<'_> {
6112 fn span(&self) -> ::treesitter_types::Span {
6113 self.span
6114 }
6115}
6116#[derive(Debug, Clone, PartialEq, Eq)]
6117pub struct GenericName<'tree> {
6118 pub span: ::treesitter_types::Span,
6119 pub children: ::std::vec::Vec<GenericNameChildren<'tree>>,
6120}
6121impl<'tree> ::treesitter_types::FromNode<'tree> for GenericName<'tree> {
6122 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6123 fn from_node(
6124 node: ::treesitter_types::tree_sitter::Node<'tree>,
6125 src: &'tree [u8],
6126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6127 debug_assert_eq!(node.kind(), "generic_name");
6128 Ok(Self {
6129 span: ::treesitter_types::Span::from(node),
6130 children: {
6131 #[allow(clippy::suspicious_else_formatting)]
6132 let non_field_children = {
6133 let mut cursor = node.walk();
6134 let mut result = ::std::vec::Vec::new();
6135 if cursor.goto_first_child() {
6136 loop {
6137 if cursor.field_name().is_none()
6138 && cursor.node().is_named()
6139 && !cursor.node().is_extra()
6140 {
6141 result.push(cursor.node());
6142 }
6143 if !cursor.goto_next_sibling() {
6144 break;
6145 }
6146 }
6147 }
6148 result
6149 };
6150 let mut items = ::std::vec::Vec::new();
6151 for child in non_field_children {
6152 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6153 <GenericNameChildren as ::treesitter_types::FromNode>::from_node(child, src)
6154 })?);
6155 }
6156 items
6157 },
6158 })
6159 }
6160}
6161impl ::treesitter_types::Spanned for GenericName<'_> {
6162 fn span(&self) -> ::treesitter_types::Span {
6163 self.span
6164 }
6165}
6166#[derive(Debug, Clone, PartialEq, Eq)]
6167pub struct GlobalAttribute<'tree> {
6168 pub span: ::treesitter_types::Span,
6169 pub children: ::std::vec::Vec<Attribute<'tree>>,
6170}
6171impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalAttribute<'tree> {
6172 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6173 fn from_node(
6174 node: ::treesitter_types::tree_sitter::Node<'tree>,
6175 src: &'tree [u8],
6176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6177 debug_assert_eq!(node.kind(), "global_attribute");
6178 Ok(Self {
6179 span: ::treesitter_types::Span::from(node),
6180 children: {
6181 #[allow(clippy::suspicious_else_formatting)]
6182 let non_field_children = {
6183 let mut cursor = node.walk();
6184 let mut result = ::std::vec::Vec::new();
6185 if cursor.goto_first_child() {
6186 loop {
6187 if cursor.field_name().is_none()
6188 && cursor.node().is_named()
6189 && !cursor.node().is_extra()
6190 {
6191 result.push(cursor.node());
6192 }
6193 if !cursor.goto_next_sibling() {
6194 break;
6195 }
6196 }
6197 }
6198 result
6199 };
6200 let mut items = ::std::vec::Vec::new();
6201 for child in non_field_children {
6202 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6203 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
6204 })?);
6205 }
6206 items
6207 },
6208 })
6209 }
6210}
6211impl ::treesitter_types::Spanned for GlobalAttribute<'_> {
6212 fn span(&self) -> ::treesitter_types::Span {
6213 self.span
6214 }
6215}
6216#[derive(Debug, Clone, PartialEq, Eq)]
6217pub struct GlobalStatement<'tree> {
6218 pub span: ::treesitter_types::Span,
6219 pub children: Statement<'tree>,
6220}
6221impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalStatement<'tree> {
6222 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6223 fn from_node(
6224 node: ::treesitter_types::tree_sitter::Node<'tree>,
6225 src: &'tree [u8],
6226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6227 debug_assert_eq!(node.kind(), "global_statement");
6228 Ok(Self {
6229 span: ::treesitter_types::Span::from(node),
6230 children: {
6231 #[allow(clippy::suspicious_else_formatting)]
6232 let non_field_children = {
6233 let mut cursor = node.walk();
6234 let mut result = ::std::vec::Vec::new();
6235 if cursor.goto_first_child() {
6236 loop {
6237 if cursor.field_name().is_none()
6238 && cursor.node().is_named()
6239 && !cursor.node().is_extra()
6240 {
6241 result.push(cursor.node());
6242 }
6243 if !cursor.goto_next_sibling() {
6244 break;
6245 }
6246 }
6247 }
6248 result
6249 };
6250 let child = if let Some(&c) = non_field_children.first() {
6251 c
6252 } else {
6253 let mut fallback_cursor = node.walk();
6254 let mut fallback_child = None;
6255 if fallback_cursor.goto_first_child() {
6256 loop {
6257 if fallback_cursor.field_name().is_none()
6258 && !fallback_cursor.node().is_extra()
6259 {
6260 let candidate = fallback_cursor.node();
6261 #[allow(clippy::needless_question_mark)]
6262 if (|| -> ::core::result::Result<
6263 _,
6264 ::treesitter_types::ParseError,
6265 > {
6266 let child = candidate;
6267 Ok(
6268 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
6269 child,
6270 src,
6271 ))?,
6272 )
6273 })()
6274 .is_ok()
6275 {
6276 fallback_child = Some(candidate);
6277 break;
6278 }
6279 }
6280 if !fallback_cursor.goto_next_sibling() {
6281 break;
6282 }
6283 }
6284 }
6285 if fallback_child.is_none() {
6286 let mut cursor2 = node.walk();
6287 if cursor2.goto_first_child() {
6288 loop {
6289 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6290 let candidate = cursor2.node();
6291 #[allow(clippy::needless_question_mark)]
6292 if (|| -> ::core::result::Result<
6293 _,
6294 ::treesitter_types::ParseError,
6295 > {
6296 let child = candidate;
6297 Ok(
6298 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
6299 child,
6300 src,
6301 ))?,
6302 )
6303 })()
6304 .is_ok()
6305 {
6306 fallback_child = Some(candidate);
6307 break;
6308 }
6309 }
6310 if !cursor2.goto_next_sibling() {
6311 break;
6312 }
6313 }
6314 }
6315 }
6316 fallback_child.ok_or_else(|| {
6317 ::treesitter_types::ParseError::missing_field("children", node)
6318 })?
6319 };
6320 ::treesitter_types::runtime::maybe_grow_stack(|| {
6321 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6322 })?
6323 },
6324 })
6325 }
6326}
6327impl ::treesitter_types::Spanned for GlobalStatement<'_> {
6328 fn span(&self) -> ::treesitter_types::Span {
6329 self.span
6330 }
6331}
6332#[derive(Debug, Clone, PartialEq, Eq)]
6333pub struct GotoStatement<'tree> {
6334 pub span: ::treesitter_types::Span,
6335 pub children: ::core::option::Option<Expression<'tree>>,
6336}
6337impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
6338 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6339 fn from_node(
6340 node: ::treesitter_types::tree_sitter::Node<'tree>,
6341 src: &'tree [u8],
6342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6343 debug_assert_eq!(node.kind(), "goto_statement");
6344 Ok(Self {
6345 span: ::treesitter_types::Span::from(node),
6346 children: {
6347 #[allow(clippy::suspicious_else_formatting)]
6348 let non_field_children = {
6349 let mut cursor = node.walk();
6350 let mut result = ::std::vec::Vec::new();
6351 if cursor.goto_first_child() {
6352 loop {
6353 if cursor.field_name().is_none()
6354 && cursor.node().is_named()
6355 && !cursor.node().is_extra()
6356 {
6357 result.push(cursor.node());
6358 }
6359 if !cursor.goto_next_sibling() {
6360 break;
6361 }
6362 }
6363 }
6364 result
6365 };
6366 match non_field_children.first() {
6367 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6368 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6369 })?),
6370 None => None,
6371 }
6372 },
6373 })
6374 }
6375}
6376impl ::treesitter_types::Spanned for GotoStatement<'_> {
6377 fn span(&self) -> ::treesitter_types::Span {
6378 self.span
6379 }
6380}
6381#[derive(Debug, Clone, PartialEq, Eq)]
6382pub struct GroupClause<'tree> {
6383 pub span: ::treesitter_types::Span,
6384 pub children: ::std::vec::Vec<Expression<'tree>>,
6385}
6386impl<'tree> ::treesitter_types::FromNode<'tree> for GroupClause<'tree> {
6387 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6388 fn from_node(
6389 node: ::treesitter_types::tree_sitter::Node<'tree>,
6390 src: &'tree [u8],
6391 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6392 debug_assert_eq!(node.kind(), "group_clause");
6393 Ok(Self {
6394 span: ::treesitter_types::Span::from(node),
6395 children: {
6396 #[allow(clippy::suspicious_else_formatting)]
6397 let non_field_children = {
6398 let mut cursor = node.walk();
6399 let mut result = ::std::vec::Vec::new();
6400 if cursor.goto_first_child() {
6401 loop {
6402 if cursor.field_name().is_none()
6403 && cursor.node().is_named()
6404 && !cursor.node().is_extra()
6405 {
6406 result.push(cursor.node());
6407 }
6408 if !cursor.goto_next_sibling() {
6409 break;
6410 }
6411 }
6412 }
6413 result
6414 };
6415 let mut items = ::std::vec::Vec::new();
6416 for child in non_field_children {
6417 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6418 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6419 })?);
6420 }
6421 items
6422 },
6423 })
6424 }
6425}
6426impl ::treesitter_types::Spanned for GroupClause<'_> {
6427 fn span(&self) -> ::treesitter_types::Span {
6428 self.span
6429 }
6430}
6431#[derive(Debug, Clone, PartialEq, Eq)]
6432pub struct Identifier<'tree> {
6433 pub span: ::treesitter_types::Span,
6434 text: &'tree str,
6435}
6436impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
6437 fn from_node(
6438 node: ::treesitter_types::tree_sitter::Node<'tree>,
6439 src: &'tree [u8],
6440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6441 debug_assert_eq!(node.kind(), "identifier");
6442 Ok(Self {
6443 span: ::treesitter_types::Span::from(node),
6444 text: node.utf8_text(src)?,
6445 })
6446 }
6447}
6448impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
6449 fn text(&self) -> &'tree str {
6450 self.text
6451 }
6452}
6453impl ::treesitter_types::Spanned for Identifier<'_> {
6454 fn span(&self) -> ::treesitter_types::Span {
6455 self.span
6456 }
6457}
6458#[derive(Debug, Clone, PartialEq, Eq)]
6459pub struct IfStatement<'tree> {
6460 pub span: ::treesitter_types::Span,
6461 pub alternative: ::core::option::Option<Statement<'tree>>,
6462 pub condition: Expression<'tree>,
6463 pub consequence: Statement<'tree>,
6464}
6465impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
6466 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6467 fn from_node(
6468 node: ::treesitter_types::tree_sitter::Node<'tree>,
6469 src: &'tree [u8],
6470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6471 debug_assert_eq!(node.kind(), "if_statement");
6472 Ok(Self {
6473 span: ::treesitter_types::Span::from(node),
6474 alternative: match node.child_by_field_name("alternative") {
6475 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6476 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6477 })?),
6478 None => None,
6479 },
6480 condition: {
6481 let child = node.child_by_field_name("condition").ok_or_else(|| {
6482 ::treesitter_types::ParseError::missing_field("condition", node)
6483 })?;
6484 ::treesitter_types::runtime::maybe_grow_stack(|| {
6485 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6486 })?
6487 },
6488 consequence: {
6489 let child = node.child_by_field_name("consequence").ok_or_else(|| {
6490 ::treesitter_types::ParseError::missing_field("consequence", node)
6491 })?;
6492 ::treesitter_types::runtime::maybe_grow_stack(|| {
6493 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6494 })?
6495 },
6496 })
6497 }
6498}
6499impl ::treesitter_types::Spanned for IfStatement<'_> {
6500 fn span(&self) -> ::treesitter_types::Span {
6501 self.span
6502 }
6503}
6504#[derive(Debug, Clone, PartialEq, Eq)]
6505pub struct ImplicitArrayCreationExpression<'tree> {
6506 pub span: ::treesitter_types::Span,
6507 pub children: InitializerExpression<'tree>,
6508}
6509impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitArrayCreationExpression<'tree> {
6510 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6511 fn from_node(
6512 node: ::treesitter_types::tree_sitter::Node<'tree>,
6513 src: &'tree [u8],
6514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6515 debug_assert_eq!(node.kind(), "implicit_array_creation_expression");
6516 Ok(Self {
6517 span: ::treesitter_types::Span::from(node),
6518 children: {
6519 #[allow(clippy::suspicious_else_formatting)]
6520 let non_field_children = {
6521 let mut cursor = node.walk();
6522 let mut result = ::std::vec::Vec::new();
6523 if cursor.goto_first_child() {
6524 loop {
6525 if cursor.field_name().is_none()
6526 && cursor.node().is_named()
6527 && !cursor.node().is_extra()
6528 {
6529 result.push(cursor.node());
6530 }
6531 if !cursor.goto_next_sibling() {
6532 break;
6533 }
6534 }
6535 }
6536 result
6537 };
6538 let child = if let Some(&c) = non_field_children.first() {
6539 c
6540 } else {
6541 let mut fallback_cursor = node.walk();
6542 let mut fallback_child = None;
6543 if fallback_cursor.goto_first_child() {
6544 loop {
6545 if fallback_cursor.field_name().is_none()
6546 && !fallback_cursor.node().is_extra()
6547 {
6548 let candidate = fallback_cursor.node();
6549 #[allow(clippy::needless_question_mark)]
6550 if (|| -> ::core::result::Result<
6551 _,
6552 ::treesitter_types::ParseError,
6553 > {
6554 let child = candidate;
6555 Ok(
6556 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6557 child,
6558 src,
6559 ))?,
6560 )
6561 })()
6562 .is_ok()
6563 {
6564 fallback_child = Some(candidate);
6565 break;
6566 }
6567 }
6568 if !fallback_cursor.goto_next_sibling() {
6569 break;
6570 }
6571 }
6572 }
6573 if fallback_child.is_none() {
6574 let mut cursor2 = node.walk();
6575 if cursor2.goto_first_child() {
6576 loop {
6577 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6578 let candidate = cursor2.node();
6579 #[allow(clippy::needless_question_mark)]
6580 if (|| -> ::core::result::Result<
6581 _,
6582 ::treesitter_types::ParseError,
6583 > {
6584 let child = candidate;
6585 Ok(
6586 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6587 child,
6588 src,
6589 ))?,
6590 )
6591 })()
6592 .is_ok()
6593 {
6594 fallback_child = Some(candidate);
6595 break;
6596 }
6597 }
6598 if !cursor2.goto_next_sibling() {
6599 break;
6600 }
6601 }
6602 }
6603 }
6604 fallback_child.ok_or_else(|| {
6605 ::treesitter_types::ParseError::missing_field("children", node)
6606 })?
6607 };
6608 ::treesitter_types::runtime::maybe_grow_stack(|| {
6609 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
6610 })?
6611 },
6612 })
6613 }
6614}
6615impl ::treesitter_types::Spanned for ImplicitArrayCreationExpression<'_> {
6616 fn span(&self) -> ::treesitter_types::Span {
6617 self.span
6618 }
6619}
6620#[derive(Debug, Clone, PartialEq, Eq)]
6621pub struct ImplicitObjectCreationExpression<'tree> {
6622 pub span: ::treesitter_types::Span,
6623 pub children: ::std::vec::Vec<ImplicitObjectCreationExpressionChildren<'tree>>,
6624}
6625impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitObjectCreationExpression<'tree> {
6626 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6627 fn from_node(
6628 node: ::treesitter_types::tree_sitter::Node<'tree>,
6629 src: &'tree [u8],
6630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6631 debug_assert_eq!(node.kind(), "implicit_object_creation_expression");
6632 Ok(Self {
6633 span: ::treesitter_types::Span::from(node),
6634 children: {
6635 #[allow(clippy::suspicious_else_formatting)]
6636 let non_field_children = {
6637 let mut cursor = node.walk();
6638 let mut result = ::std::vec::Vec::new();
6639 if cursor.goto_first_child() {
6640 loop {
6641 if cursor.field_name().is_none()
6642 && cursor.node().is_named()
6643 && !cursor.node().is_extra()
6644 {
6645 result.push(cursor.node());
6646 }
6647 if !cursor.goto_next_sibling() {
6648 break;
6649 }
6650 }
6651 }
6652 result
6653 };
6654 let mut items = ::std::vec::Vec::new();
6655 for child in non_field_children {
6656 items
6657 .push(
6658 ::treesitter_types::runtime::maybe_grow_stack(|| <ImplicitObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
6659 child,
6660 src,
6661 ))?,
6662 );
6663 }
6664 items
6665 },
6666 })
6667 }
6668}
6669impl ::treesitter_types::Spanned for ImplicitObjectCreationExpression<'_> {
6670 fn span(&self) -> ::treesitter_types::Span {
6671 self.span
6672 }
6673}
6674#[derive(Debug, Clone, PartialEq, Eq)]
6675pub struct ImplicitParameter<'tree> {
6676 pub span: ::treesitter_types::Span,
6677 text: &'tree str,
6678}
6679impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitParameter<'tree> {
6680 fn from_node(
6681 node: ::treesitter_types::tree_sitter::Node<'tree>,
6682 src: &'tree [u8],
6683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6684 debug_assert_eq!(node.kind(), "implicit_parameter");
6685 Ok(Self {
6686 span: ::treesitter_types::Span::from(node),
6687 text: node.utf8_text(src)?,
6688 })
6689 }
6690}
6691impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitParameter<'tree> {
6692 fn text(&self) -> &'tree str {
6693 self.text
6694 }
6695}
6696impl ::treesitter_types::Spanned for ImplicitParameter<'_> {
6697 fn span(&self) -> ::treesitter_types::Span {
6698 self.span
6699 }
6700}
6701#[derive(Debug, Clone, PartialEq, Eq)]
6702pub struct ImplicitStackallocExpression<'tree> {
6703 pub span: ::treesitter_types::Span,
6704 pub children: InitializerExpression<'tree>,
6705}
6706impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitStackallocExpression<'tree> {
6707 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6708 fn from_node(
6709 node: ::treesitter_types::tree_sitter::Node<'tree>,
6710 src: &'tree [u8],
6711 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6712 debug_assert_eq!(node.kind(), "implicit_stackalloc_expression");
6713 Ok(Self {
6714 span: ::treesitter_types::Span::from(node),
6715 children: {
6716 #[allow(clippy::suspicious_else_formatting)]
6717 let non_field_children = {
6718 let mut cursor = node.walk();
6719 let mut result = ::std::vec::Vec::new();
6720 if cursor.goto_first_child() {
6721 loop {
6722 if cursor.field_name().is_none()
6723 && cursor.node().is_named()
6724 && !cursor.node().is_extra()
6725 {
6726 result.push(cursor.node());
6727 }
6728 if !cursor.goto_next_sibling() {
6729 break;
6730 }
6731 }
6732 }
6733 result
6734 };
6735 let child = if let Some(&c) = non_field_children.first() {
6736 c
6737 } else {
6738 let mut fallback_cursor = node.walk();
6739 let mut fallback_child = None;
6740 if fallback_cursor.goto_first_child() {
6741 loop {
6742 if fallback_cursor.field_name().is_none()
6743 && !fallback_cursor.node().is_extra()
6744 {
6745 let candidate = fallback_cursor.node();
6746 #[allow(clippy::needless_question_mark)]
6747 if (|| -> ::core::result::Result<
6748 _,
6749 ::treesitter_types::ParseError,
6750 > {
6751 let child = candidate;
6752 Ok(
6753 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6754 child,
6755 src,
6756 ))?,
6757 )
6758 })()
6759 .is_ok()
6760 {
6761 fallback_child = Some(candidate);
6762 break;
6763 }
6764 }
6765 if !fallback_cursor.goto_next_sibling() {
6766 break;
6767 }
6768 }
6769 }
6770 if fallback_child.is_none() {
6771 let mut cursor2 = node.walk();
6772 if cursor2.goto_first_child() {
6773 loop {
6774 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6775 let candidate = cursor2.node();
6776 #[allow(clippy::needless_question_mark)]
6777 if (|| -> ::core::result::Result<
6778 _,
6779 ::treesitter_types::ParseError,
6780 > {
6781 let child = candidate;
6782 Ok(
6783 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerExpression as ::treesitter_types::FromNode>::from_node(
6784 child,
6785 src,
6786 ))?,
6787 )
6788 })()
6789 .is_ok()
6790 {
6791 fallback_child = Some(candidate);
6792 break;
6793 }
6794 }
6795 if !cursor2.goto_next_sibling() {
6796 break;
6797 }
6798 }
6799 }
6800 }
6801 fallback_child.ok_or_else(|| {
6802 ::treesitter_types::ParseError::missing_field("children", node)
6803 })?
6804 };
6805 ::treesitter_types::runtime::maybe_grow_stack(|| {
6806 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
6807 })?
6808 },
6809 })
6810 }
6811}
6812impl ::treesitter_types::Spanned for ImplicitStackallocExpression<'_> {
6813 fn span(&self) -> ::treesitter_types::Span {
6814 self.span
6815 }
6816}
6817#[derive(Debug, Clone, PartialEq, Eq)]
6818pub struct ImplicitType<'tree> {
6819 pub span: ::treesitter_types::Span,
6820 text: &'tree str,
6821}
6822impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitType<'tree> {
6823 fn from_node(
6824 node: ::treesitter_types::tree_sitter::Node<'tree>,
6825 src: &'tree [u8],
6826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6827 debug_assert_eq!(node.kind(), "implicit_type");
6828 Ok(Self {
6829 span: ::treesitter_types::Span::from(node),
6830 text: node.utf8_text(src)?,
6831 })
6832 }
6833}
6834impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitType<'tree> {
6835 fn text(&self) -> &'tree str {
6836 self.text
6837 }
6838}
6839impl ::treesitter_types::Spanned for ImplicitType<'_> {
6840 fn span(&self) -> ::treesitter_types::Span {
6841 self.span
6842 }
6843}
6844#[derive(Debug, Clone, PartialEq, Eq)]
6845pub struct IndexerDeclaration<'tree> {
6846 pub span: ::treesitter_types::Span,
6847 pub accessors: ::core::option::Option<AccessorList<'tree>>,
6848 pub parameters: BracketedParameterList<'tree>,
6849 pub r#type: Type<'tree>,
6850 pub value: ::core::option::Option<ArrowExpressionClause<'tree>>,
6851 pub children: ::std::vec::Vec<IndexerDeclarationChildren<'tree>>,
6852}
6853impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclaration<'tree> {
6854 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6855 fn from_node(
6856 node: ::treesitter_types::tree_sitter::Node<'tree>,
6857 src: &'tree [u8],
6858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6859 debug_assert_eq!(node.kind(), "indexer_declaration");
6860 Ok(Self {
6861 span: ::treesitter_types::Span::from(node),
6862 accessors: match node.child_by_field_name("accessors") {
6863 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6864 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
6865 })?),
6866 None => None,
6867 },
6868 parameters: {
6869 let child = node.child_by_field_name("parameters").ok_or_else(|| {
6870 ::treesitter_types::ParseError::missing_field("parameters", node)
6871 })?;
6872 ::treesitter_types::runtime::maybe_grow_stack(|| {
6873 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(child, src)
6874 })?
6875 },
6876 r#type: {
6877 let child = node
6878 .child_by_field_name("type")
6879 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6880 ::treesitter_types::runtime::maybe_grow_stack(|| {
6881 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6882 })?
6883 },
6884 value: match node.child_by_field_name("value") {
6885 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6886 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(child, src)
6887 })?),
6888 None => None,
6889 },
6890 children: {
6891 #[allow(clippy::suspicious_else_formatting)]
6892 let non_field_children = {
6893 let mut cursor = node.walk();
6894 let mut result = ::std::vec::Vec::new();
6895 if cursor.goto_first_child() {
6896 loop {
6897 if cursor.field_name().is_none()
6898 && cursor.node().is_named()
6899 && !cursor.node().is_extra()
6900 {
6901 result.push(cursor.node());
6902 }
6903 if !cursor.goto_next_sibling() {
6904 break;
6905 }
6906 }
6907 }
6908 result
6909 };
6910 let mut items = ::std::vec::Vec::new();
6911 for child in non_field_children {
6912 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6913 <IndexerDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6914 child, src,
6915 )
6916 })?);
6917 }
6918 items
6919 },
6920 })
6921 }
6922}
6923impl ::treesitter_types::Spanned for IndexerDeclaration<'_> {
6924 fn span(&self) -> ::treesitter_types::Span {
6925 self.span
6926 }
6927}
6928#[derive(Debug, Clone, PartialEq, Eq)]
6929pub struct InitializerExpression<'tree> {
6930 pub span: ::treesitter_types::Span,
6931 pub children: ::std::vec::Vec<Expression<'tree>>,
6932}
6933impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerExpression<'tree> {
6934 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6935 fn from_node(
6936 node: ::treesitter_types::tree_sitter::Node<'tree>,
6937 src: &'tree [u8],
6938 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6939 debug_assert_eq!(node.kind(), "initializer_expression");
6940 Ok(Self {
6941 span: ::treesitter_types::Span::from(node),
6942 children: {
6943 #[allow(clippy::suspicious_else_formatting)]
6944 let non_field_children = {
6945 let mut cursor = node.walk();
6946 let mut result = ::std::vec::Vec::new();
6947 if cursor.goto_first_child() {
6948 loop {
6949 if cursor.field_name().is_none()
6950 && cursor.node().is_named()
6951 && !cursor.node().is_extra()
6952 {
6953 result.push(cursor.node());
6954 }
6955 if !cursor.goto_next_sibling() {
6956 break;
6957 }
6958 }
6959 }
6960 result
6961 };
6962 let mut items = ::std::vec::Vec::new();
6963 for child in non_field_children {
6964 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6965 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6966 })?);
6967 }
6968 items
6969 },
6970 })
6971 }
6972}
6973impl ::treesitter_types::Spanned for InitializerExpression<'_> {
6974 fn span(&self) -> ::treesitter_types::Span {
6975 self.span
6976 }
6977}
6978#[derive(Debug, Clone, PartialEq, Eq)]
6979pub struct InterfaceDeclaration<'tree> {
6980 pub span: ::treesitter_types::Span,
6981 pub body: ::core::option::Option<DeclarationList<'tree>>,
6982 pub name: Identifier<'tree>,
6983 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
6984 pub children: ::std::vec::Vec<InterfaceDeclarationChildren<'tree>>,
6985}
6986impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
6987 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6988 fn from_node(
6989 node: ::treesitter_types::tree_sitter::Node<'tree>,
6990 src: &'tree [u8],
6991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6992 debug_assert_eq!(node.kind(), "interface_declaration");
6993 Ok(Self {
6994 span: ::treesitter_types::Span::from(node),
6995 body: match node.child_by_field_name("body") {
6996 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6997 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
6998 })?),
6999 None => None,
7000 },
7001 name: {
7002 let child = node
7003 .child_by_field_name("name")
7004 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7005 ::treesitter_types::runtime::maybe_grow_stack(|| {
7006 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7007 })?
7008 },
7009 type_parameters: match node.child_by_field_name("type_parameters") {
7010 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7011 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7012 })?),
7013 None => None,
7014 },
7015 children: {
7016 #[allow(clippy::suspicious_else_formatting)]
7017 let non_field_children = {
7018 let mut cursor = node.walk();
7019 let mut result = ::std::vec::Vec::new();
7020 if cursor.goto_first_child() {
7021 loop {
7022 if cursor.field_name().is_none()
7023 && cursor.node().is_named()
7024 && !cursor.node().is_extra()
7025 {
7026 result.push(cursor.node());
7027 }
7028 if !cursor.goto_next_sibling() {
7029 break;
7030 }
7031 }
7032 }
7033 result
7034 };
7035 let mut items = ::std::vec::Vec::new();
7036 for child in non_field_children {
7037 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7038 <InterfaceDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7039 child, src,
7040 )
7041 })?);
7042 }
7043 items
7044 },
7045 })
7046 }
7047}
7048impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
7049 fn span(&self) -> ::treesitter_types::Span {
7050 self.span
7051 }
7052}
7053#[derive(Debug, Clone, PartialEq, Eq)]
7054pub struct InterpolatedStringExpression<'tree> {
7055 pub span: ::treesitter_types::Span,
7056 pub children: ::std::vec::Vec<InterpolatedStringExpressionChildren<'tree>>,
7057}
7058impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpression<'tree> {
7059 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7060 fn from_node(
7061 node: ::treesitter_types::tree_sitter::Node<'tree>,
7062 src: &'tree [u8],
7063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7064 debug_assert_eq!(node.kind(), "interpolated_string_expression");
7065 Ok(Self {
7066 span: ::treesitter_types::Span::from(node),
7067 children: {
7068 #[allow(clippy::suspicious_else_formatting)]
7069 let non_field_children = {
7070 let mut cursor = node.walk();
7071 let mut result = ::std::vec::Vec::new();
7072 if cursor.goto_first_child() {
7073 loop {
7074 if cursor.field_name().is_none()
7075 && cursor.node().is_named()
7076 && !cursor.node().is_extra()
7077 {
7078 result.push(cursor.node());
7079 }
7080 if !cursor.goto_next_sibling() {
7081 break;
7082 }
7083 }
7084 }
7085 result
7086 };
7087 let mut items = ::std::vec::Vec::new();
7088 for child in non_field_children {
7089 items
7090 .push(
7091 ::treesitter_types::runtime::maybe_grow_stack(|| <InterpolatedStringExpressionChildren as ::treesitter_types::FromNode>::from_node(
7092 child,
7093 src,
7094 ))?,
7095 );
7096 }
7097 items
7098 },
7099 })
7100 }
7101}
7102impl ::treesitter_types::Spanned for InterpolatedStringExpression<'_> {
7103 fn span(&self) -> ::treesitter_types::Span {
7104 self.span
7105 }
7106}
7107#[derive(Debug, Clone, PartialEq, Eq)]
7108pub struct Interpolation<'tree> {
7109 pub span: ::treesitter_types::Span,
7110 pub children: ::std::vec::Vec<InterpolationChildren<'tree>>,
7111}
7112impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
7113 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7114 fn from_node(
7115 node: ::treesitter_types::tree_sitter::Node<'tree>,
7116 src: &'tree [u8],
7117 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7118 debug_assert_eq!(node.kind(), "interpolation");
7119 Ok(Self {
7120 span: ::treesitter_types::Span::from(node),
7121 children: {
7122 #[allow(clippy::suspicious_else_formatting)]
7123 let non_field_children = {
7124 let mut cursor = node.walk();
7125 let mut result = ::std::vec::Vec::new();
7126 if cursor.goto_first_child() {
7127 loop {
7128 if cursor.field_name().is_none()
7129 && cursor.node().is_named()
7130 && !cursor.node().is_extra()
7131 {
7132 result.push(cursor.node());
7133 }
7134 if !cursor.goto_next_sibling() {
7135 break;
7136 }
7137 }
7138 }
7139 result
7140 };
7141 let mut items = ::std::vec::Vec::new();
7142 for child in non_field_children {
7143 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7144 <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
7145 child, src,
7146 )
7147 })?);
7148 }
7149 items
7150 },
7151 })
7152 }
7153}
7154impl ::treesitter_types::Spanned for Interpolation<'_> {
7155 fn span(&self) -> ::treesitter_types::Span {
7156 self.span
7157 }
7158}
7159#[derive(Debug, Clone, PartialEq, Eq)]
7160pub struct InterpolationAlignmentClause<'tree> {
7161 pub span: ::treesitter_types::Span,
7162 pub children: Expression<'tree>,
7163}
7164impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationAlignmentClause<'tree> {
7165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7166 fn from_node(
7167 node: ::treesitter_types::tree_sitter::Node<'tree>,
7168 src: &'tree [u8],
7169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7170 debug_assert_eq!(node.kind(), "interpolation_alignment_clause");
7171 Ok(Self {
7172 span: ::treesitter_types::Span::from(node),
7173 children: {
7174 #[allow(clippy::suspicious_else_formatting)]
7175 let non_field_children = {
7176 let mut cursor = node.walk();
7177 let mut result = ::std::vec::Vec::new();
7178 if cursor.goto_first_child() {
7179 loop {
7180 if cursor.field_name().is_none()
7181 && cursor.node().is_named()
7182 && !cursor.node().is_extra()
7183 {
7184 result.push(cursor.node());
7185 }
7186 if !cursor.goto_next_sibling() {
7187 break;
7188 }
7189 }
7190 }
7191 result
7192 };
7193 let child = if let Some(&c) = non_field_children.first() {
7194 c
7195 } else {
7196 let mut fallback_cursor = node.walk();
7197 let mut fallback_child = None;
7198 if fallback_cursor.goto_first_child() {
7199 loop {
7200 if fallback_cursor.field_name().is_none()
7201 && !fallback_cursor.node().is_extra()
7202 {
7203 let candidate = fallback_cursor.node();
7204 #[allow(clippy::needless_question_mark)]
7205 if (|| -> ::core::result::Result<
7206 _,
7207 ::treesitter_types::ParseError,
7208 > {
7209 let child = candidate;
7210 Ok(
7211 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7212 child,
7213 src,
7214 ))?,
7215 )
7216 })()
7217 .is_ok()
7218 {
7219 fallback_child = Some(candidate);
7220 break;
7221 }
7222 }
7223 if !fallback_cursor.goto_next_sibling() {
7224 break;
7225 }
7226 }
7227 }
7228 if fallback_child.is_none() {
7229 let mut cursor2 = node.walk();
7230 if cursor2.goto_first_child() {
7231 loop {
7232 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7233 let candidate = cursor2.node();
7234 #[allow(clippy::needless_question_mark)]
7235 if (|| -> ::core::result::Result<
7236 _,
7237 ::treesitter_types::ParseError,
7238 > {
7239 let child = candidate;
7240 Ok(
7241 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7242 child,
7243 src,
7244 ))?,
7245 )
7246 })()
7247 .is_ok()
7248 {
7249 fallback_child = Some(candidate);
7250 break;
7251 }
7252 }
7253 if !cursor2.goto_next_sibling() {
7254 break;
7255 }
7256 }
7257 }
7258 }
7259 fallback_child.ok_or_else(|| {
7260 ::treesitter_types::ParseError::missing_field("children", node)
7261 })?
7262 };
7263 ::treesitter_types::runtime::maybe_grow_stack(|| {
7264 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7265 })?
7266 },
7267 })
7268 }
7269}
7270impl ::treesitter_types::Spanned for InterpolationAlignmentClause<'_> {
7271 fn span(&self) -> ::treesitter_types::Span {
7272 self.span
7273 }
7274}
7275#[derive(Debug, Clone, PartialEq, Eq)]
7276pub struct InterpolationFormatClause<'tree> {
7277 pub span: ::treesitter_types::Span,
7278 text: &'tree str,
7279}
7280impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationFormatClause<'tree> {
7281 fn from_node(
7282 node: ::treesitter_types::tree_sitter::Node<'tree>,
7283 src: &'tree [u8],
7284 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7285 debug_assert_eq!(node.kind(), "interpolation_format_clause");
7286 Ok(Self {
7287 span: ::treesitter_types::Span::from(node),
7288 text: node.utf8_text(src)?,
7289 })
7290 }
7291}
7292impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationFormatClause<'tree> {
7293 fn text(&self) -> &'tree str {
7294 self.text
7295 }
7296}
7297impl ::treesitter_types::Spanned for InterpolationFormatClause<'_> {
7298 fn span(&self) -> ::treesitter_types::Span {
7299 self.span
7300 }
7301}
7302#[derive(Debug, Clone, PartialEq, Eq)]
7303pub struct InvocationExpression<'tree> {
7304 pub span: ::treesitter_types::Span,
7305 pub arguments: ArgumentList<'tree>,
7306 pub function: InvocationExpressionFunction<'tree>,
7307}
7308impl<'tree> ::treesitter_types::FromNode<'tree> for InvocationExpression<'tree> {
7309 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7310 fn from_node(
7311 node: ::treesitter_types::tree_sitter::Node<'tree>,
7312 src: &'tree [u8],
7313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7314 debug_assert_eq!(node.kind(), "invocation_expression");
7315 Ok(Self {
7316 span: ::treesitter_types::Span::from(node),
7317 arguments: {
7318 let child = node.child_by_field_name("arguments").ok_or_else(|| {
7319 ::treesitter_types::ParseError::missing_field("arguments", node)
7320 })?;
7321 ::treesitter_types::runtime::maybe_grow_stack(|| {
7322 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
7323 })?
7324 },
7325 function: {
7326 let child = node.child_by_field_name("function").ok_or_else(|| {
7327 ::treesitter_types::ParseError::missing_field("function", node)
7328 })?;
7329 ::treesitter_types::runtime::maybe_grow_stack(|| {
7330 <InvocationExpressionFunction as ::treesitter_types::FromNode>::from_node(
7331 child, src,
7332 )
7333 })?
7334 },
7335 })
7336 }
7337}
7338impl ::treesitter_types::Spanned for InvocationExpression<'_> {
7339 fn span(&self) -> ::treesitter_types::Span {
7340 self.span
7341 }
7342}
7343#[derive(Debug, Clone, PartialEq, Eq)]
7344pub struct IsExpression<'tree> {
7345 pub span: ::treesitter_types::Span,
7346 pub left: Expression<'tree>,
7347 pub operator: IsExpressionOperator,
7348 pub right: Type<'tree>,
7349}
7350impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpression<'tree> {
7351 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7352 fn from_node(
7353 node: ::treesitter_types::tree_sitter::Node<'tree>,
7354 src: &'tree [u8],
7355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7356 debug_assert_eq!(node.kind(), "is_expression");
7357 Ok(Self {
7358 span: ::treesitter_types::Span::from(node),
7359 left: {
7360 let child = node
7361 .child_by_field_name("left")
7362 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
7363 ::treesitter_types::runtime::maybe_grow_stack(|| {
7364 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7365 })?
7366 },
7367 operator: {
7368 let child = node.child_by_field_name("operator").ok_or_else(|| {
7369 ::treesitter_types::ParseError::missing_field("operator", node)
7370 })?;
7371 ::treesitter_types::runtime::maybe_grow_stack(|| {
7372 <IsExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
7373 })?
7374 },
7375 right: {
7376 let child = node
7377 .child_by_field_name("right")
7378 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
7379 ::treesitter_types::runtime::maybe_grow_stack(|| {
7380 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7381 })?
7382 },
7383 })
7384 }
7385}
7386impl ::treesitter_types::Spanned for IsExpression<'_> {
7387 fn span(&self) -> ::treesitter_types::Span {
7388 self.span
7389 }
7390}
7391#[derive(Debug, Clone, PartialEq, Eq)]
7392pub struct IsPatternExpression<'tree> {
7393 pub span: ::treesitter_types::Span,
7394 pub expression: Expression<'tree>,
7395 pub pattern: Pattern<'tree>,
7396}
7397impl<'tree> ::treesitter_types::FromNode<'tree> for IsPatternExpression<'tree> {
7398 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7399 fn from_node(
7400 node: ::treesitter_types::tree_sitter::Node<'tree>,
7401 src: &'tree [u8],
7402 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7403 debug_assert_eq!(node.kind(), "is_pattern_expression");
7404 Ok(Self {
7405 span: ::treesitter_types::Span::from(node),
7406 expression: {
7407 let child = node.child_by_field_name("expression").ok_or_else(|| {
7408 ::treesitter_types::ParseError::missing_field("expression", node)
7409 })?;
7410 ::treesitter_types::runtime::maybe_grow_stack(|| {
7411 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7412 })?
7413 },
7414 pattern: {
7415 let child = node.child_by_field_name("pattern").ok_or_else(|| {
7416 ::treesitter_types::ParseError::missing_field("pattern", node)
7417 })?;
7418 ::treesitter_types::runtime::maybe_grow_stack(|| {
7419 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
7420 })?
7421 },
7422 })
7423 }
7424}
7425impl ::treesitter_types::Spanned for IsPatternExpression<'_> {
7426 fn span(&self) -> ::treesitter_types::Span {
7427 self.span
7428 }
7429}
7430#[derive(Debug, Clone, PartialEq, Eq)]
7431pub struct JoinClause<'tree> {
7432 pub span: ::treesitter_types::Span,
7433 pub r#type: ::core::option::Option<Type<'tree>>,
7434 pub children: ::std::vec::Vec<JoinClauseChildren<'tree>>,
7435}
7436impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClause<'tree> {
7437 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7438 fn from_node(
7439 node: ::treesitter_types::tree_sitter::Node<'tree>,
7440 src: &'tree [u8],
7441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7442 debug_assert_eq!(node.kind(), "join_clause");
7443 Ok(Self {
7444 span: ::treesitter_types::Span::from(node),
7445 r#type: match node.child_by_field_name("type") {
7446 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7447 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7448 })?),
7449 None => None,
7450 },
7451 children: {
7452 #[allow(clippy::suspicious_else_formatting)]
7453 let non_field_children = {
7454 let mut cursor = node.walk();
7455 let mut result = ::std::vec::Vec::new();
7456 if cursor.goto_first_child() {
7457 loop {
7458 if cursor.field_name().is_none()
7459 && cursor.node().is_named()
7460 && !cursor.node().is_extra()
7461 {
7462 result.push(cursor.node());
7463 }
7464 if !cursor.goto_next_sibling() {
7465 break;
7466 }
7467 }
7468 }
7469 result
7470 };
7471 let mut items = ::std::vec::Vec::new();
7472 for child in non_field_children {
7473 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7474 <JoinClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
7475 })?);
7476 }
7477 items
7478 },
7479 })
7480 }
7481}
7482impl ::treesitter_types::Spanned for JoinClause<'_> {
7483 fn span(&self) -> ::treesitter_types::Span {
7484 self.span
7485 }
7486}
7487#[derive(Debug, Clone, PartialEq, Eq)]
7488pub struct JoinIntoClause<'tree> {
7489 pub span: ::treesitter_types::Span,
7490 pub children: Identifier<'tree>,
7491}
7492impl<'tree> ::treesitter_types::FromNode<'tree> for JoinIntoClause<'tree> {
7493 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7494 fn from_node(
7495 node: ::treesitter_types::tree_sitter::Node<'tree>,
7496 src: &'tree [u8],
7497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7498 debug_assert_eq!(node.kind(), "join_into_clause");
7499 Ok(Self {
7500 span: ::treesitter_types::Span::from(node),
7501 children: {
7502 #[allow(clippy::suspicious_else_formatting)]
7503 let non_field_children = {
7504 let mut cursor = node.walk();
7505 let mut result = ::std::vec::Vec::new();
7506 if cursor.goto_first_child() {
7507 loop {
7508 if cursor.field_name().is_none()
7509 && cursor.node().is_named()
7510 && !cursor.node().is_extra()
7511 {
7512 result.push(cursor.node());
7513 }
7514 if !cursor.goto_next_sibling() {
7515 break;
7516 }
7517 }
7518 }
7519 result
7520 };
7521 let child = if let Some(&c) = non_field_children.first() {
7522 c
7523 } else {
7524 let mut fallback_cursor = node.walk();
7525 let mut fallback_child = None;
7526 if fallback_cursor.goto_first_child() {
7527 loop {
7528 if fallback_cursor.field_name().is_none()
7529 && !fallback_cursor.node().is_extra()
7530 {
7531 let candidate = fallback_cursor.node();
7532 #[allow(clippy::needless_question_mark)]
7533 if (|| -> ::core::result::Result<
7534 _,
7535 ::treesitter_types::ParseError,
7536 > {
7537 let child = candidate;
7538 Ok(
7539 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
7540 child,
7541 src,
7542 ))?,
7543 )
7544 })()
7545 .is_ok()
7546 {
7547 fallback_child = Some(candidate);
7548 break;
7549 }
7550 }
7551 if !fallback_cursor.goto_next_sibling() {
7552 break;
7553 }
7554 }
7555 }
7556 if fallback_child.is_none() {
7557 let mut cursor2 = node.walk();
7558 if cursor2.goto_first_child() {
7559 loop {
7560 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7561 let candidate = cursor2.node();
7562 #[allow(clippy::needless_question_mark)]
7563 if (|| -> ::core::result::Result<
7564 _,
7565 ::treesitter_types::ParseError,
7566 > {
7567 let child = candidate;
7568 Ok(
7569 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
7570 child,
7571 src,
7572 ))?,
7573 )
7574 })()
7575 .is_ok()
7576 {
7577 fallback_child = Some(candidate);
7578 break;
7579 }
7580 }
7581 if !cursor2.goto_next_sibling() {
7582 break;
7583 }
7584 }
7585 }
7586 }
7587 fallback_child.ok_or_else(|| {
7588 ::treesitter_types::ParseError::missing_field("children", node)
7589 })?
7590 };
7591 ::treesitter_types::runtime::maybe_grow_stack(|| {
7592 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7593 })?
7594 },
7595 })
7596 }
7597}
7598impl ::treesitter_types::Spanned for JoinIntoClause<'_> {
7599 fn span(&self) -> ::treesitter_types::Span {
7600 self.span
7601 }
7602}
7603#[derive(Debug, Clone, PartialEq, Eq)]
7604pub struct LabeledStatement<'tree> {
7605 pub span: ::treesitter_types::Span,
7606 pub children: ::std::vec::Vec<LabeledStatementChildren<'tree>>,
7607}
7608impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
7609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7610 fn from_node(
7611 node: ::treesitter_types::tree_sitter::Node<'tree>,
7612 src: &'tree [u8],
7613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7614 debug_assert_eq!(node.kind(), "labeled_statement");
7615 Ok(Self {
7616 span: ::treesitter_types::Span::from(node),
7617 children: {
7618 #[allow(clippy::suspicious_else_formatting)]
7619 let non_field_children = {
7620 let mut cursor = node.walk();
7621 let mut result = ::std::vec::Vec::new();
7622 if cursor.goto_first_child() {
7623 loop {
7624 if cursor.field_name().is_none()
7625 && cursor.node().is_named()
7626 && !cursor.node().is_extra()
7627 {
7628 result.push(cursor.node());
7629 }
7630 if !cursor.goto_next_sibling() {
7631 break;
7632 }
7633 }
7634 }
7635 result
7636 };
7637 let mut items = ::std::vec::Vec::new();
7638 for child in non_field_children {
7639 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7640 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
7641 child, src,
7642 )
7643 })?);
7644 }
7645 items
7646 },
7647 })
7648 }
7649}
7650impl ::treesitter_types::Spanned for LabeledStatement<'_> {
7651 fn span(&self) -> ::treesitter_types::Span {
7652 self.span
7653 }
7654}
7655#[derive(Debug, Clone, PartialEq, Eq)]
7656pub struct LambdaExpression<'tree> {
7657 pub span: ::treesitter_types::Span,
7658 pub body: LambdaExpressionBody<'tree>,
7659 pub parameters: LambdaExpressionParameters<'tree>,
7660 pub r#type: ::core::option::Option<Type<'tree>>,
7661 pub children: ::std::vec::Vec<LambdaExpressionChildren<'tree>>,
7662}
7663impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
7664 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7665 fn from_node(
7666 node: ::treesitter_types::tree_sitter::Node<'tree>,
7667 src: &'tree [u8],
7668 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7669 debug_assert_eq!(node.kind(), "lambda_expression");
7670 Ok(Self {
7671 span: ::treesitter_types::Span::from(node),
7672 body: {
7673 let child = node
7674 .child_by_field_name("body")
7675 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7676 ::treesitter_types::runtime::maybe_grow_stack(|| {
7677 <LambdaExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)
7678 })?
7679 },
7680 parameters: {
7681 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7682 ::treesitter_types::ParseError::missing_field("parameters", node)
7683 })?;
7684 ::treesitter_types::runtime::maybe_grow_stack(|| {
7685 <LambdaExpressionParameters as ::treesitter_types::FromNode>::from_node(
7686 child, src,
7687 )
7688 })?
7689 },
7690 r#type: match node.child_by_field_name("type") {
7691 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7692 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7693 })?),
7694 None => None,
7695 },
7696 children: {
7697 #[allow(clippy::suspicious_else_formatting)]
7698 let non_field_children = {
7699 let mut cursor = node.walk();
7700 let mut result = ::std::vec::Vec::new();
7701 if cursor.goto_first_child() {
7702 loop {
7703 if cursor.field_name().is_none()
7704 && cursor.node().is_named()
7705 && !cursor.node().is_extra()
7706 {
7707 result.push(cursor.node());
7708 }
7709 if !cursor.goto_next_sibling() {
7710 break;
7711 }
7712 }
7713 }
7714 result
7715 };
7716 let mut items = ::std::vec::Vec::new();
7717 for child in non_field_children {
7718 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7719 <LambdaExpressionChildren as ::treesitter_types::FromNode>::from_node(
7720 child, src,
7721 )
7722 })?);
7723 }
7724 items
7725 },
7726 })
7727 }
7728}
7729impl ::treesitter_types::Spanned for LambdaExpression<'_> {
7730 fn span(&self) -> ::treesitter_types::Span {
7731 self.span
7732 }
7733}
7734#[derive(Debug, Clone, PartialEq, Eq)]
7735pub struct LetClause<'tree> {
7736 pub span: ::treesitter_types::Span,
7737 pub children: ::std::vec::Vec<LetClauseChildren<'tree>>,
7738}
7739impl<'tree> ::treesitter_types::FromNode<'tree> for LetClause<'tree> {
7740 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7741 fn from_node(
7742 node: ::treesitter_types::tree_sitter::Node<'tree>,
7743 src: &'tree [u8],
7744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7745 debug_assert_eq!(node.kind(), "let_clause");
7746 Ok(Self {
7747 span: ::treesitter_types::Span::from(node),
7748 children: {
7749 #[allow(clippy::suspicious_else_formatting)]
7750 let non_field_children = {
7751 let mut cursor = node.walk();
7752 let mut result = ::std::vec::Vec::new();
7753 if cursor.goto_first_child() {
7754 loop {
7755 if cursor.field_name().is_none()
7756 && cursor.node().is_named()
7757 && !cursor.node().is_extra()
7758 {
7759 result.push(cursor.node());
7760 }
7761 if !cursor.goto_next_sibling() {
7762 break;
7763 }
7764 }
7765 }
7766 result
7767 };
7768 let mut items = ::std::vec::Vec::new();
7769 for child in non_field_children {
7770 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7771 <LetClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
7772 })?);
7773 }
7774 items
7775 },
7776 })
7777 }
7778}
7779impl ::treesitter_types::Spanned for LetClause<'_> {
7780 fn span(&self) -> ::treesitter_types::Span {
7781 self.span
7782 }
7783}
7784#[derive(Debug, Clone, PartialEq, Eq)]
7785pub struct ListPattern<'tree> {
7786 pub span: ::treesitter_types::Span,
7787 pub name: ::core::option::Option<Identifier<'tree>>,
7788 pub children: ::std::vec::Vec<ListPatternChildren<'tree>>,
7789}
7790impl<'tree> ::treesitter_types::FromNode<'tree> for ListPattern<'tree> {
7791 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7792 fn from_node(
7793 node: ::treesitter_types::tree_sitter::Node<'tree>,
7794 src: &'tree [u8],
7795 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7796 debug_assert_eq!(node.kind(), "list_pattern");
7797 Ok(Self {
7798 span: ::treesitter_types::Span::from(node),
7799 name: match node.child_by_field_name("name") {
7800 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7801 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7802 })?),
7803 None => None,
7804 },
7805 children: {
7806 #[allow(clippy::suspicious_else_formatting)]
7807 let non_field_children = {
7808 let mut cursor = node.walk();
7809 let mut result = ::std::vec::Vec::new();
7810 if cursor.goto_first_child() {
7811 loop {
7812 if cursor.field_name().is_none()
7813 && cursor.node().is_named()
7814 && !cursor.node().is_extra()
7815 {
7816 result.push(cursor.node());
7817 }
7818 if !cursor.goto_next_sibling() {
7819 break;
7820 }
7821 }
7822 }
7823 result
7824 };
7825 let mut items = ::std::vec::Vec::new();
7826 for child in non_field_children {
7827 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7828 <ListPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
7829 })?);
7830 }
7831 items
7832 },
7833 })
7834 }
7835}
7836impl ::treesitter_types::Spanned for ListPattern<'_> {
7837 fn span(&self) -> ::treesitter_types::Span {
7838 self.span
7839 }
7840}
7841#[derive(Debug, Clone, PartialEq, Eq)]
7842pub struct LocalDeclarationStatement<'tree> {
7843 pub span: ::treesitter_types::Span,
7844 pub children: ::std::vec::Vec<LocalDeclarationStatementChildren<'tree>>,
7845}
7846impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatement<'tree> {
7847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7848 fn from_node(
7849 node: ::treesitter_types::tree_sitter::Node<'tree>,
7850 src: &'tree [u8],
7851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7852 debug_assert_eq!(node.kind(), "local_declaration_statement");
7853 Ok(Self {
7854 span: ::treesitter_types::Span::from(node),
7855 children: {
7856 #[allow(clippy::suspicious_else_formatting)]
7857 let non_field_children = {
7858 let mut cursor = node.walk();
7859 let mut result = ::std::vec::Vec::new();
7860 if cursor.goto_first_child() {
7861 loop {
7862 if cursor.field_name().is_none()
7863 && cursor.node().is_named()
7864 && !cursor.node().is_extra()
7865 {
7866 result.push(cursor.node());
7867 }
7868 if !cursor.goto_next_sibling() {
7869 break;
7870 }
7871 }
7872 }
7873 result
7874 };
7875 let mut items = ::std::vec::Vec::new();
7876 for child in non_field_children {
7877 items
7878 .push(
7879 ::treesitter_types::runtime::maybe_grow_stack(|| <LocalDeclarationStatementChildren as ::treesitter_types::FromNode>::from_node(
7880 child,
7881 src,
7882 ))?,
7883 );
7884 }
7885 items
7886 },
7887 })
7888 }
7889}
7890impl ::treesitter_types::Spanned for LocalDeclarationStatement<'_> {
7891 fn span(&self) -> ::treesitter_types::Span {
7892 self.span
7893 }
7894}
7895#[derive(Debug, Clone, PartialEq, Eq)]
7896pub struct LocalFunctionStatement<'tree> {
7897 pub span: ::treesitter_types::Span,
7898 pub body: ::core::option::Option<LocalFunctionStatementBody<'tree>>,
7899 pub name: Identifier<'tree>,
7900 pub parameters: ParameterList<'tree>,
7901 pub r#type: Type<'tree>,
7902 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
7903 pub children: ::std::vec::Vec<LocalFunctionStatementChildren<'tree>>,
7904}
7905impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatement<'tree> {
7906 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7907 fn from_node(
7908 node: ::treesitter_types::tree_sitter::Node<'tree>,
7909 src: &'tree [u8],
7910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7911 debug_assert_eq!(node.kind(), "local_function_statement");
7912 Ok(Self {
7913 span: ::treesitter_types::Span::from(node),
7914 body: match node.child_by_field_name("body") {
7915 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7916 <LocalFunctionStatementBody as ::treesitter_types::FromNode>::from_node(
7917 child, src,
7918 )
7919 })?),
7920 None => None,
7921 },
7922 name: {
7923 let child = node
7924 .child_by_field_name("name")
7925 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7926 ::treesitter_types::runtime::maybe_grow_stack(|| {
7927 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7928 })?
7929 },
7930 parameters: {
7931 let child = node.child_by_field_name("parameters").ok_or_else(|| {
7932 ::treesitter_types::ParseError::missing_field("parameters", node)
7933 })?;
7934 ::treesitter_types::runtime::maybe_grow_stack(|| {
7935 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7936 })?
7937 },
7938 r#type: {
7939 let child = node
7940 .child_by_field_name("type")
7941 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7942 ::treesitter_types::runtime::maybe_grow_stack(|| {
7943 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7944 })?
7945 },
7946 type_parameters: match node.child_by_field_name("type_parameters") {
7947 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7948 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
7949 })?),
7950 None => None,
7951 },
7952 children: {
7953 #[allow(clippy::suspicious_else_formatting)]
7954 let non_field_children = {
7955 let mut cursor = node.walk();
7956 let mut result = ::std::vec::Vec::new();
7957 if cursor.goto_first_child() {
7958 loop {
7959 if cursor.field_name().is_none()
7960 && cursor.node().is_named()
7961 && !cursor.node().is_extra()
7962 {
7963 result.push(cursor.node());
7964 }
7965 if !cursor.goto_next_sibling() {
7966 break;
7967 }
7968 }
7969 }
7970 result
7971 };
7972 let mut items = ::std::vec::Vec::new();
7973 for child in non_field_children {
7974 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7975 <LocalFunctionStatementChildren as ::treesitter_types::FromNode>::from_node(
7976 child, src,
7977 )
7978 })?);
7979 }
7980 items
7981 },
7982 })
7983 }
7984}
7985impl ::treesitter_types::Spanned for LocalFunctionStatement<'_> {
7986 fn span(&self) -> ::treesitter_types::Span {
7987 self.span
7988 }
7989}
7990#[derive(Debug, Clone, PartialEq, Eq)]
7991pub struct LockStatement<'tree> {
7992 pub span: ::treesitter_types::Span,
7993 pub children: ::std::vec::Vec<LockStatementChildren<'tree>>,
7994}
7995impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatement<'tree> {
7996 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7997 fn from_node(
7998 node: ::treesitter_types::tree_sitter::Node<'tree>,
7999 src: &'tree [u8],
8000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8001 debug_assert_eq!(node.kind(), "lock_statement");
8002 Ok(Self {
8003 span: ::treesitter_types::Span::from(node),
8004 children: {
8005 #[allow(clippy::suspicious_else_formatting)]
8006 let non_field_children = {
8007 let mut cursor = node.walk();
8008 let mut result = ::std::vec::Vec::new();
8009 if cursor.goto_first_child() {
8010 loop {
8011 if cursor.field_name().is_none()
8012 && cursor.node().is_named()
8013 && !cursor.node().is_extra()
8014 {
8015 result.push(cursor.node());
8016 }
8017 if !cursor.goto_next_sibling() {
8018 break;
8019 }
8020 }
8021 }
8022 result
8023 };
8024 let mut items = ::std::vec::Vec::new();
8025 for child in non_field_children {
8026 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8027 <LockStatementChildren as ::treesitter_types::FromNode>::from_node(
8028 child, src,
8029 )
8030 })?);
8031 }
8032 items
8033 },
8034 })
8035 }
8036}
8037impl ::treesitter_types::Spanned for LockStatement<'_> {
8038 fn span(&self) -> ::treesitter_types::Span {
8039 self.span
8040 }
8041}
8042#[derive(Debug, Clone, PartialEq, Eq)]
8043pub struct MakerefExpression<'tree> {
8044 pub span: ::treesitter_types::Span,
8045 pub children: Expression<'tree>,
8046}
8047impl<'tree> ::treesitter_types::FromNode<'tree> for MakerefExpression<'tree> {
8048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8049 fn from_node(
8050 node: ::treesitter_types::tree_sitter::Node<'tree>,
8051 src: &'tree [u8],
8052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8053 debug_assert_eq!(node.kind(), "makeref_expression");
8054 Ok(Self {
8055 span: ::treesitter_types::Span::from(node),
8056 children: {
8057 #[allow(clippy::suspicious_else_formatting)]
8058 let non_field_children = {
8059 let mut cursor = node.walk();
8060 let mut result = ::std::vec::Vec::new();
8061 if cursor.goto_first_child() {
8062 loop {
8063 if cursor.field_name().is_none()
8064 && cursor.node().is_named()
8065 && !cursor.node().is_extra()
8066 {
8067 result.push(cursor.node());
8068 }
8069 if !cursor.goto_next_sibling() {
8070 break;
8071 }
8072 }
8073 }
8074 result
8075 };
8076 let child = if let Some(&c) = non_field_children.first() {
8077 c
8078 } else {
8079 let mut fallback_cursor = node.walk();
8080 let mut fallback_child = None;
8081 if fallback_cursor.goto_first_child() {
8082 loop {
8083 if fallback_cursor.field_name().is_none()
8084 && !fallback_cursor.node().is_extra()
8085 {
8086 let candidate = fallback_cursor.node();
8087 #[allow(clippy::needless_question_mark)]
8088 if (|| -> ::core::result::Result<
8089 _,
8090 ::treesitter_types::ParseError,
8091 > {
8092 let child = candidate;
8093 Ok(
8094 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8095 child,
8096 src,
8097 ))?,
8098 )
8099 })()
8100 .is_ok()
8101 {
8102 fallback_child = Some(candidate);
8103 break;
8104 }
8105 }
8106 if !fallback_cursor.goto_next_sibling() {
8107 break;
8108 }
8109 }
8110 }
8111 if fallback_child.is_none() {
8112 let mut cursor2 = node.walk();
8113 if cursor2.goto_first_child() {
8114 loop {
8115 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8116 let candidate = cursor2.node();
8117 #[allow(clippy::needless_question_mark)]
8118 if (|| -> ::core::result::Result<
8119 _,
8120 ::treesitter_types::ParseError,
8121 > {
8122 let child = candidate;
8123 Ok(
8124 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8125 child,
8126 src,
8127 ))?,
8128 )
8129 })()
8130 .is_ok()
8131 {
8132 fallback_child = Some(candidate);
8133 break;
8134 }
8135 }
8136 if !cursor2.goto_next_sibling() {
8137 break;
8138 }
8139 }
8140 }
8141 }
8142 fallback_child.ok_or_else(|| {
8143 ::treesitter_types::ParseError::missing_field("children", node)
8144 })?
8145 };
8146 ::treesitter_types::runtime::maybe_grow_stack(|| {
8147 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8148 })?
8149 },
8150 })
8151 }
8152}
8153impl ::treesitter_types::Spanned for MakerefExpression<'_> {
8154 fn span(&self) -> ::treesitter_types::Span {
8155 self.span
8156 }
8157}
8158#[derive(Debug, Clone, PartialEq, Eq)]
8159pub struct MemberAccessExpression<'tree> {
8160 pub span: ::treesitter_types::Span,
8161 pub expression: MemberAccessExpressionExpression<'tree>,
8162 pub name: MemberAccessExpressionName<'tree>,
8163}
8164impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpression<'tree> {
8165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8166 fn from_node(
8167 node: ::treesitter_types::tree_sitter::Node<'tree>,
8168 src: &'tree [u8],
8169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8170 debug_assert_eq!(node.kind(), "member_access_expression");
8171 Ok(Self {
8172 span: ::treesitter_types::Span::from(node),
8173 expression: {
8174 let child = node.child_by_field_name("expression").ok_or_else(|| {
8175 ::treesitter_types::ParseError::missing_field("expression", node)
8176 })?;
8177 ::treesitter_types::runtime::maybe_grow_stack(|| {
8178 <MemberAccessExpressionExpression as ::treesitter_types::FromNode>::from_node(
8179 child, src,
8180 )
8181 })?
8182 },
8183 name: {
8184 let child = node
8185 .child_by_field_name("name")
8186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8187 ::treesitter_types::runtime::maybe_grow_stack(|| {
8188 <MemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(
8189 child, src,
8190 )
8191 })?
8192 },
8193 })
8194 }
8195}
8196impl ::treesitter_types::Spanned for MemberAccessExpression<'_> {
8197 fn span(&self) -> ::treesitter_types::Span {
8198 self.span
8199 }
8200}
8201#[derive(Debug, Clone, PartialEq, Eq)]
8202pub struct MemberBindingExpression<'tree> {
8203 pub span: ::treesitter_types::Span,
8204 pub name: MemberBindingExpressionName<'tree>,
8205}
8206impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpression<'tree> {
8207 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8208 fn from_node(
8209 node: ::treesitter_types::tree_sitter::Node<'tree>,
8210 src: &'tree [u8],
8211 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8212 debug_assert_eq!(node.kind(), "member_binding_expression");
8213 Ok(Self {
8214 span: ::treesitter_types::Span::from(node),
8215 name: {
8216 let child = node
8217 .child_by_field_name("name")
8218 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8219 ::treesitter_types::runtime::maybe_grow_stack(|| {
8220 <MemberBindingExpressionName as ::treesitter_types::FromNode>::from_node(
8221 child, src,
8222 )
8223 })?
8224 },
8225 })
8226 }
8227}
8228impl ::treesitter_types::Spanned for MemberBindingExpression<'_> {
8229 fn span(&self) -> ::treesitter_types::Span {
8230 self.span
8231 }
8232}
8233#[derive(Debug, Clone, PartialEq, Eq)]
8234pub struct MethodDeclaration<'tree> {
8235 pub span: ::treesitter_types::Span,
8236 pub body: ::core::option::Option<MethodDeclarationBody<'tree>>,
8237 pub name: Identifier<'tree>,
8238 pub parameters: ParameterList<'tree>,
8239 pub returns: Type<'tree>,
8240 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
8241 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
8242}
8243impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
8244 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8245 fn from_node(
8246 node: ::treesitter_types::tree_sitter::Node<'tree>,
8247 src: &'tree [u8],
8248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8249 debug_assert_eq!(node.kind(), "method_declaration");
8250 Ok(Self {
8251 span: ::treesitter_types::Span::from(node),
8252 body: match node.child_by_field_name("body") {
8253 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8254 <MethodDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
8255 })?),
8256 None => None,
8257 },
8258 name: {
8259 let child = node
8260 .child_by_field_name("name")
8261 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8262 ::treesitter_types::runtime::maybe_grow_stack(|| {
8263 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8264 })?
8265 },
8266 parameters: {
8267 let child = node.child_by_field_name("parameters").ok_or_else(|| {
8268 ::treesitter_types::ParseError::missing_field("parameters", node)
8269 })?;
8270 ::treesitter_types::runtime::maybe_grow_stack(|| {
8271 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
8272 })?
8273 },
8274 returns: {
8275 let child = node.child_by_field_name("returns").ok_or_else(|| {
8276 ::treesitter_types::ParseError::missing_field("returns", node)
8277 })?;
8278 ::treesitter_types::runtime::maybe_grow_stack(|| {
8279 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8280 })?
8281 },
8282 type_parameters: match node.child_by_field_name("type_parameters") {
8283 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8284 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
8285 })?),
8286 None => None,
8287 },
8288 children: {
8289 #[allow(clippy::suspicious_else_formatting)]
8290 let non_field_children = {
8291 let mut cursor = node.walk();
8292 let mut result = ::std::vec::Vec::new();
8293 if cursor.goto_first_child() {
8294 loop {
8295 if cursor.field_name().is_none()
8296 && cursor.node().is_named()
8297 && !cursor.node().is_extra()
8298 {
8299 result.push(cursor.node());
8300 }
8301 if !cursor.goto_next_sibling() {
8302 break;
8303 }
8304 }
8305 }
8306 result
8307 };
8308 let mut items = ::std::vec::Vec::new();
8309 for child in non_field_children {
8310 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8311 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
8312 child, src,
8313 )
8314 })?);
8315 }
8316 items
8317 },
8318 })
8319 }
8320}
8321impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
8322 fn span(&self) -> ::treesitter_types::Span {
8323 self.span
8324 }
8325}
8326#[derive(Debug, Clone, PartialEq, Eq)]
8327pub struct Modifier<'tree> {
8328 pub span: ::treesitter_types::Span,
8329 text: &'tree str,
8330}
8331impl<'tree> ::treesitter_types::FromNode<'tree> for Modifier<'tree> {
8332 fn from_node(
8333 node: ::treesitter_types::tree_sitter::Node<'tree>,
8334 src: &'tree [u8],
8335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8336 debug_assert_eq!(node.kind(), "modifier");
8337 Ok(Self {
8338 span: ::treesitter_types::Span::from(node),
8339 text: node.utf8_text(src)?,
8340 })
8341 }
8342}
8343impl<'tree> ::treesitter_types::LeafNode<'tree> for Modifier<'tree> {
8344 fn text(&self) -> &'tree str {
8345 self.text
8346 }
8347}
8348impl ::treesitter_types::Spanned for Modifier<'_> {
8349 fn span(&self) -> ::treesitter_types::Span {
8350 self.span
8351 }
8352}
8353#[derive(Debug, Clone, PartialEq, Eq)]
8354pub struct NamespaceDeclaration<'tree> {
8355 pub span: ::treesitter_types::Span,
8356 pub body: DeclarationList<'tree>,
8357 pub name: NamespaceDeclarationName<'tree>,
8358}
8359impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclaration<'tree> {
8360 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8361 fn from_node(
8362 node: ::treesitter_types::tree_sitter::Node<'tree>,
8363 src: &'tree [u8],
8364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8365 debug_assert_eq!(node.kind(), "namespace_declaration");
8366 Ok(Self {
8367 span: ::treesitter_types::Span::from(node),
8368 body: {
8369 let child = node
8370 .child_by_field_name("body")
8371 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8372 ::treesitter_types::runtime::maybe_grow_stack(|| {
8373 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
8374 })?
8375 },
8376 name: {
8377 let child = node
8378 .child_by_field_name("name")
8379 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8380 ::treesitter_types::runtime::maybe_grow_stack(|| {
8381 <NamespaceDeclarationName as ::treesitter_types::FromNode>::from_node(
8382 child, src,
8383 )
8384 })?
8385 },
8386 })
8387 }
8388}
8389impl ::treesitter_types::Spanned for NamespaceDeclaration<'_> {
8390 fn span(&self) -> ::treesitter_types::Span {
8391 self.span
8392 }
8393}
8394#[derive(Debug, Clone, PartialEq, Eq)]
8395pub struct NegatedPattern<'tree> {
8396 pub span: ::treesitter_types::Span,
8397 pub children: Pattern<'tree>,
8398}
8399impl<'tree> ::treesitter_types::FromNode<'tree> for NegatedPattern<'tree> {
8400 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8401 fn from_node(
8402 node: ::treesitter_types::tree_sitter::Node<'tree>,
8403 src: &'tree [u8],
8404 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8405 debug_assert_eq!(node.kind(), "negated_pattern");
8406 Ok(Self {
8407 span: ::treesitter_types::Span::from(node),
8408 children: {
8409 #[allow(clippy::suspicious_else_formatting)]
8410 let non_field_children = {
8411 let mut cursor = node.walk();
8412 let mut result = ::std::vec::Vec::new();
8413 if cursor.goto_first_child() {
8414 loop {
8415 if cursor.field_name().is_none()
8416 && cursor.node().is_named()
8417 && !cursor.node().is_extra()
8418 {
8419 result.push(cursor.node());
8420 }
8421 if !cursor.goto_next_sibling() {
8422 break;
8423 }
8424 }
8425 }
8426 result
8427 };
8428 let child = if let Some(&c) = non_field_children.first() {
8429 c
8430 } else {
8431 let mut fallback_cursor = node.walk();
8432 let mut fallback_child = None;
8433 if fallback_cursor.goto_first_child() {
8434 loop {
8435 if fallback_cursor.field_name().is_none()
8436 && !fallback_cursor.node().is_extra()
8437 {
8438 let candidate = fallback_cursor.node();
8439 #[allow(clippy::needless_question_mark)]
8440 if (|| -> ::core::result::Result<
8441 _,
8442 ::treesitter_types::ParseError,
8443 > {
8444 let child = candidate;
8445 Ok(
8446 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8447 child,
8448 src,
8449 ))?,
8450 )
8451 })()
8452 .is_ok()
8453 {
8454 fallback_child = Some(candidate);
8455 break;
8456 }
8457 }
8458 if !fallback_cursor.goto_next_sibling() {
8459 break;
8460 }
8461 }
8462 }
8463 if fallback_child.is_none() {
8464 let mut cursor2 = node.walk();
8465 if cursor2.goto_first_child() {
8466 loop {
8467 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8468 let candidate = cursor2.node();
8469 #[allow(clippy::needless_question_mark)]
8470 if (|| -> ::core::result::Result<
8471 _,
8472 ::treesitter_types::ParseError,
8473 > {
8474 let child = candidate;
8475 Ok(
8476 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
8477 child,
8478 src,
8479 ))?,
8480 )
8481 })()
8482 .is_ok()
8483 {
8484 fallback_child = Some(candidate);
8485 break;
8486 }
8487 }
8488 if !cursor2.goto_next_sibling() {
8489 break;
8490 }
8491 }
8492 }
8493 }
8494 fallback_child.ok_or_else(|| {
8495 ::treesitter_types::ParseError::missing_field("children", node)
8496 })?
8497 };
8498 ::treesitter_types::runtime::maybe_grow_stack(|| {
8499 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8500 })?
8501 },
8502 })
8503 }
8504}
8505impl ::treesitter_types::Spanned for NegatedPattern<'_> {
8506 fn span(&self) -> ::treesitter_types::Span {
8507 self.span
8508 }
8509}
8510#[derive(Debug, Clone, PartialEq, Eq)]
8511pub struct NullableType<'tree> {
8512 pub span: ::treesitter_types::Span,
8513 pub r#type: NullableTypeType<'tree>,
8514}
8515impl<'tree> ::treesitter_types::FromNode<'tree> for NullableType<'tree> {
8516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8517 fn from_node(
8518 node: ::treesitter_types::tree_sitter::Node<'tree>,
8519 src: &'tree [u8],
8520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8521 debug_assert_eq!(node.kind(), "nullable_type");
8522 Ok(Self {
8523 span: ::treesitter_types::Span::from(node),
8524 r#type: {
8525 let child = node
8526 .child_by_field_name("type")
8527 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8528 ::treesitter_types::runtime::maybe_grow_stack(|| {
8529 <NullableTypeType as ::treesitter_types::FromNode>::from_node(child, src)
8530 })?
8531 },
8532 })
8533 }
8534}
8535impl ::treesitter_types::Spanned for NullableType<'_> {
8536 fn span(&self) -> ::treesitter_types::Span {
8537 self.span
8538 }
8539}
8540#[derive(Debug, Clone, PartialEq, Eq)]
8541pub struct ObjectCreationExpression<'tree> {
8542 pub span: ::treesitter_types::Span,
8543 pub arguments: ::core::option::Option<ArgumentList<'tree>>,
8544 pub initializer: ::core::option::Option<InitializerExpression<'tree>>,
8545 pub r#type: Type<'tree>,
8546}
8547impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
8548 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8549 fn from_node(
8550 node: ::treesitter_types::tree_sitter::Node<'tree>,
8551 src: &'tree [u8],
8552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8553 debug_assert_eq!(node.kind(), "object_creation_expression");
8554 Ok(Self {
8555 span: ::treesitter_types::Span::from(node),
8556 arguments: match node.child_by_field_name("arguments") {
8557 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8558 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
8559 })?),
8560 None => None,
8561 },
8562 initializer: match node.child_by_field_name("initializer") {
8563 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8564 <InitializerExpression as ::treesitter_types::FromNode>::from_node(child, src)
8565 })?),
8566 None => None,
8567 },
8568 r#type: {
8569 let child = node
8570 .child_by_field_name("type")
8571 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8572 ::treesitter_types::runtime::maybe_grow_stack(|| {
8573 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8574 })?
8575 },
8576 })
8577 }
8578}
8579impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
8580 fn span(&self) -> ::treesitter_types::Span {
8581 self.span
8582 }
8583}
8584#[derive(Debug, Clone, PartialEq, Eq)]
8585pub struct OperatorDeclaration<'tree> {
8586 pub span: ::treesitter_types::Span,
8587 pub body: ::core::option::Option<OperatorDeclarationBody<'tree>>,
8588 pub operator: OperatorDeclarationOperator,
8589 pub parameters: ParameterList<'tree>,
8590 pub r#type: Type<'tree>,
8591 pub children: ::std::vec::Vec<OperatorDeclarationChildren<'tree>>,
8592}
8593impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclaration<'tree> {
8594 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8595 fn from_node(
8596 node: ::treesitter_types::tree_sitter::Node<'tree>,
8597 src: &'tree [u8],
8598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8599 debug_assert_eq!(node.kind(), "operator_declaration");
8600 Ok(Self {
8601 span: ::treesitter_types::Span::from(node),
8602 body: match node.child_by_field_name("body") {
8603 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8604 <OperatorDeclarationBody as ::treesitter_types::FromNode>::from_node(child, src)
8605 })?),
8606 None => None,
8607 },
8608 operator: {
8609 let child = node.child_by_field_name("operator").ok_or_else(|| {
8610 ::treesitter_types::ParseError::missing_field("operator", node)
8611 })?;
8612 ::treesitter_types::runtime::maybe_grow_stack(|| {
8613 <OperatorDeclarationOperator as ::treesitter_types::FromNode>::from_node(
8614 child, src,
8615 )
8616 })?
8617 },
8618 parameters: {
8619 let child = node.child_by_field_name("parameters").ok_or_else(|| {
8620 ::treesitter_types::ParseError::missing_field("parameters", node)
8621 })?;
8622 ::treesitter_types::runtime::maybe_grow_stack(|| {
8623 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
8624 })?
8625 },
8626 r#type: {
8627 let child = node
8628 .child_by_field_name("type")
8629 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8630 ::treesitter_types::runtime::maybe_grow_stack(|| {
8631 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8632 })?
8633 },
8634 children: {
8635 #[allow(clippy::suspicious_else_formatting)]
8636 let non_field_children = {
8637 let mut cursor = node.walk();
8638 let mut result = ::std::vec::Vec::new();
8639 if cursor.goto_first_child() {
8640 loop {
8641 if cursor.field_name().is_none()
8642 && cursor.node().is_named()
8643 && !cursor.node().is_extra()
8644 {
8645 result.push(cursor.node());
8646 }
8647 if !cursor.goto_next_sibling() {
8648 break;
8649 }
8650 }
8651 }
8652 result
8653 };
8654 let mut items = ::std::vec::Vec::new();
8655 for child in non_field_children {
8656 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8657 <OperatorDeclarationChildren as ::treesitter_types::FromNode>::from_node(
8658 child, src,
8659 )
8660 })?);
8661 }
8662 items
8663 },
8664 })
8665 }
8666}
8667impl ::treesitter_types::Spanned for OperatorDeclaration<'_> {
8668 fn span(&self) -> ::treesitter_types::Span {
8669 self.span
8670 }
8671}
8672#[derive(Debug, Clone, PartialEq, Eq)]
8673pub struct OrPattern<'tree> {
8674 pub span: ::treesitter_types::Span,
8675 pub left: Pattern<'tree>,
8676 pub operator: OrPatternOperator,
8677 pub right: Pattern<'tree>,
8678}
8679impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
8680 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8681 fn from_node(
8682 node: ::treesitter_types::tree_sitter::Node<'tree>,
8683 src: &'tree [u8],
8684 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8685 debug_assert_eq!(node.kind(), "or_pattern");
8686 Ok(Self {
8687 span: ::treesitter_types::Span::from(node),
8688 left: {
8689 let child = node
8690 .child_by_field_name("left")
8691 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
8692 ::treesitter_types::runtime::maybe_grow_stack(|| {
8693 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8694 })?
8695 },
8696 operator: {
8697 let child = node.child_by_field_name("operator").ok_or_else(|| {
8698 ::treesitter_types::ParseError::missing_field("operator", node)
8699 })?;
8700 ::treesitter_types::runtime::maybe_grow_stack(|| {
8701 <OrPatternOperator as ::treesitter_types::FromNode>::from_node(child, src)
8702 })?
8703 },
8704 right: {
8705 let child = node
8706 .child_by_field_name("right")
8707 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
8708 ::treesitter_types::runtime::maybe_grow_stack(|| {
8709 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8710 })?
8711 },
8712 })
8713 }
8714}
8715impl ::treesitter_types::Spanned for OrPattern<'_> {
8716 fn span(&self) -> ::treesitter_types::Span {
8717 self.span
8718 }
8719}
8720#[derive(Debug, Clone, PartialEq, Eq)]
8721pub struct OrderByClause<'tree> {
8722 pub span: ::treesitter_types::Span,
8723 pub children: ::std::vec::Vec<Expression<'tree>>,
8724}
8725impl<'tree> ::treesitter_types::FromNode<'tree> for OrderByClause<'tree> {
8726 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8727 fn from_node(
8728 node: ::treesitter_types::tree_sitter::Node<'tree>,
8729 src: &'tree [u8],
8730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8731 debug_assert_eq!(node.kind(), "order_by_clause");
8732 Ok(Self {
8733 span: ::treesitter_types::Span::from(node),
8734 children: {
8735 #[allow(clippy::suspicious_else_formatting)]
8736 let non_field_children = {
8737 let mut cursor = node.walk();
8738 let mut result = ::std::vec::Vec::new();
8739 if cursor.goto_first_child() {
8740 loop {
8741 if cursor.field_name().is_none()
8742 && cursor.node().is_named()
8743 && !cursor.node().is_extra()
8744 {
8745 result.push(cursor.node());
8746 }
8747 if !cursor.goto_next_sibling() {
8748 break;
8749 }
8750 }
8751 }
8752 result
8753 };
8754 let mut items = ::std::vec::Vec::new();
8755 for child in non_field_children {
8756 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8757 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8758 })?);
8759 }
8760 items
8761 },
8762 })
8763 }
8764}
8765impl ::treesitter_types::Spanned for OrderByClause<'_> {
8766 fn span(&self) -> ::treesitter_types::Span {
8767 self.span
8768 }
8769}
8770#[derive(Debug, Clone, PartialEq, Eq)]
8771pub struct Parameter<'tree> {
8772 pub span: ::treesitter_types::Span,
8773 pub name: Identifier<'tree>,
8774 pub r#type: ::core::option::Option<Type<'tree>>,
8775 pub children: ::std::vec::Vec<ParameterChildren<'tree>>,
8776}
8777impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
8778 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8779 fn from_node(
8780 node: ::treesitter_types::tree_sitter::Node<'tree>,
8781 src: &'tree [u8],
8782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8783 debug_assert_eq!(node.kind(), "parameter");
8784 Ok(Self {
8785 span: ::treesitter_types::Span::from(node),
8786 name: {
8787 let child = node
8788 .child_by_field_name("name")
8789 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8790 ::treesitter_types::runtime::maybe_grow_stack(|| {
8791 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8792 })?
8793 },
8794 r#type: match node.child_by_field_name("type") {
8795 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8796 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8797 })?),
8798 None => None,
8799 },
8800 children: {
8801 #[allow(clippy::suspicious_else_formatting)]
8802 let non_field_children = {
8803 let mut cursor = node.walk();
8804 let mut result = ::std::vec::Vec::new();
8805 if cursor.goto_first_child() {
8806 loop {
8807 if cursor.field_name().is_none()
8808 && cursor.node().is_named()
8809 && !cursor.node().is_extra()
8810 {
8811 result.push(cursor.node());
8812 }
8813 if !cursor.goto_next_sibling() {
8814 break;
8815 }
8816 }
8817 }
8818 result
8819 };
8820 let mut items = ::std::vec::Vec::new();
8821 for child in non_field_children {
8822 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8823 <ParameterChildren as ::treesitter_types::FromNode>::from_node(child, src)
8824 })?);
8825 }
8826 items
8827 },
8828 })
8829 }
8830}
8831impl ::treesitter_types::Spanned for Parameter<'_> {
8832 fn span(&self) -> ::treesitter_types::Span {
8833 self.span
8834 }
8835}
8836#[derive(Debug, Clone, PartialEq, Eq)]
8837pub struct ParameterList<'tree> {
8838 pub span: ::treesitter_types::Span,
8839 pub name: ::std::vec::Vec<Identifier<'tree>>,
8840 pub r#type: ::std::vec::Vec<Type<'tree>>,
8841 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
8842}
8843impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
8844 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8845 fn from_node(
8846 node: ::treesitter_types::tree_sitter::Node<'tree>,
8847 src: &'tree [u8],
8848 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8849 debug_assert_eq!(node.kind(), "parameter_list");
8850 Ok(Self {
8851 span: ::treesitter_types::Span::from(node),
8852 name: {
8853 let mut cursor = node.walk();
8854 let mut items = ::std::vec::Vec::new();
8855 for child in node.children_by_field_name("name", &mut cursor) {
8856 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8857 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8858 })?);
8859 }
8860 items
8861 },
8862 r#type: {
8863 let mut cursor = node.walk();
8864 let mut items = ::std::vec::Vec::new();
8865 for child in node.children_by_field_name("type", &mut cursor) {
8866 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8867 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8868 })?);
8869 }
8870 items
8871 },
8872 children: {
8873 #[allow(clippy::suspicious_else_formatting)]
8874 let non_field_children = {
8875 let mut cursor = node.walk();
8876 let mut result = ::std::vec::Vec::new();
8877 if cursor.goto_first_child() {
8878 loop {
8879 if cursor.field_name().is_none()
8880 && cursor.node().is_named()
8881 && !cursor.node().is_extra()
8882 {
8883 result.push(cursor.node());
8884 }
8885 if !cursor.goto_next_sibling() {
8886 break;
8887 }
8888 }
8889 }
8890 result
8891 };
8892 let mut items = ::std::vec::Vec::new();
8893 for child in non_field_children {
8894 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8895 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
8896 child, src,
8897 )
8898 })?);
8899 }
8900 items
8901 },
8902 })
8903 }
8904}
8905impl ::treesitter_types::Spanned for ParameterList<'_> {
8906 fn span(&self) -> ::treesitter_types::Span {
8907 self.span
8908 }
8909}
8910#[derive(Debug, Clone, PartialEq, Eq)]
8911pub struct ParenthesizedExpression<'tree> {
8912 pub span: ::treesitter_types::Span,
8913 pub children: ParenthesizedExpressionChildren<'tree>,
8914}
8915impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
8916 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8917 fn from_node(
8918 node: ::treesitter_types::tree_sitter::Node<'tree>,
8919 src: &'tree [u8],
8920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8921 debug_assert_eq!(node.kind(), "parenthesized_expression");
8922 Ok(Self {
8923 span: ::treesitter_types::Span::from(node),
8924 children: {
8925 #[allow(clippy::suspicious_else_formatting)]
8926 let non_field_children = {
8927 let mut cursor = node.walk();
8928 let mut result = ::std::vec::Vec::new();
8929 if cursor.goto_first_child() {
8930 loop {
8931 if cursor.field_name().is_none()
8932 && cursor.node().is_named()
8933 && !cursor.node().is_extra()
8934 {
8935 result.push(cursor.node());
8936 }
8937 if !cursor.goto_next_sibling() {
8938 break;
8939 }
8940 }
8941 }
8942 result
8943 };
8944 let child = if let Some(&c) = non_field_children.first() {
8945 c
8946 } else {
8947 let mut fallback_cursor = node.walk();
8948 let mut fallback_child = None;
8949 if fallback_cursor.goto_first_child() {
8950 loop {
8951 if fallback_cursor.field_name().is_none()
8952 && !fallback_cursor.node().is_extra()
8953 {
8954 let candidate = fallback_cursor.node();
8955 #[allow(clippy::needless_question_mark)]
8956 if (|| -> ::core::result::Result<
8957 _,
8958 ::treesitter_types::ParseError,
8959 > {
8960 let child = candidate;
8961 Ok(
8962 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8963 child,
8964 src,
8965 ))?,
8966 )
8967 })()
8968 .is_ok()
8969 {
8970 fallback_child = Some(candidate);
8971 break;
8972 }
8973 }
8974 if !fallback_cursor.goto_next_sibling() {
8975 break;
8976 }
8977 }
8978 }
8979 if fallback_child.is_none() {
8980 let mut cursor2 = node.walk();
8981 if cursor2.goto_first_child() {
8982 loop {
8983 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8984 let candidate = cursor2.node();
8985 #[allow(clippy::needless_question_mark)]
8986 if (|| -> ::core::result::Result<
8987 _,
8988 ::treesitter_types::ParseError,
8989 > {
8990 let child = candidate;
8991 Ok(
8992 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8993 child,
8994 src,
8995 ))?,
8996 )
8997 })()
8998 .is_ok()
8999 {
9000 fallback_child = Some(candidate);
9001 break;
9002 }
9003 }
9004 if !cursor2.goto_next_sibling() {
9005 break;
9006 }
9007 }
9008 }
9009 }
9010 fallback_child.ok_or_else(|| {
9011 ::treesitter_types::ParseError::missing_field("children", node)
9012 })?
9013 };
9014 ::treesitter_types::runtime::maybe_grow_stack(|| {
9015 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
9016 child, src,
9017 )
9018 })?
9019 },
9020 })
9021 }
9022}
9023impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
9024 fn span(&self) -> ::treesitter_types::Span {
9025 self.span
9026 }
9027}
9028#[derive(Debug, Clone, PartialEq, Eq)]
9029pub struct ParenthesizedPattern<'tree> {
9030 pub span: ::treesitter_types::Span,
9031 pub children: Pattern<'tree>,
9032}
9033impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedPattern<'tree> {
9034 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9035 fn from_node(
9036 node: ::treesitter_types::tree_sitter::Node<'tree>,
9037 src: &'tree [u8],
9038 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9039 debug_assert_eq!(node.kind(), "parenthesized_pattern");
9040 Ok(Self {
9041 span: ::treesitter_types::Span::from(node),
9042 children: {
9043 #[allow(clippy::suspicious_else_formatting)]
9044 let non_field_children = {
9045 let mut cursor = node.walk();
9046 let mut result = ::std::vec::Vec::new();
9047 if cursor.goto_first_child() {
9048 loop {
9049 if cursor.field_name().is_none()
9050 && cursor.node().is_named()
9051 && !cursor.node().is_extra()
9052 {
9053 result.push(cursor.node());
9054 }
9055 if !cursor.goto_next_sibling() {
9056 break;
9057 }
9058 }
9059 }
9060 result
9061 };
9062 let child = if let Some(&c) = non_field_children.first() {
9063 c
9064 } else {
9065 let mut fallback_cursor = node.walk();
9066 let mut fallback_child = None;
9067 if fallback_cursor.goto_first_child() {
9068 loop {
9069 if fallback_cursor.field_name().is_none()
9070 && !fallback_cursor.node().is_extra()
9071 {
9072 let candidate = fallback_cursor.node();
9073 #[allow(clippy::needless_question_mark)]
9074 if (|| -> ::core::result::Result<
9075 _,
9076 ::treesitter_types::ParseError,
9077 > {
9078 let child = candidate;
9079 Ok(
9080 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
9081 child,
9082 src,
9083 ))?,
9084 )
9085 })()
9086 .is_ok()
9087 {
9088 fallback_child = Some(candidate);
9089 break;
9090 }
9091 }
9092 if !fallback_cursor.goto_next_sibling() {
9093 break;
9094 }
9095 }
9096 }
9097 if fallback_child.is_none() {
9098 let mut cursor2 = node.walk();
9099 if cursor2.goto_first_child() {
9100 loop {
9101 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9102 let candidate = cursor2.node();
9103 #[allow(clippy::needless_question_mark)]
9104 if (|| -> ::core::result::Result<
9105 _,
9106 ::treesitter_types::ParseError,
9107 > {
9108 let child = candidate;
9109 Ok(
9110 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
9111 child,
9112 src,
9113 ))?,
9114 )
9115 })()
9116 .is_ok()
9117 {
9118 fallback_child = Some(candidate);
9119 break;
9120 }
9121 }
9122 if !cursor2.goto_next_sibling() {
9123 break;
9124 }
9125 }
9126 }
9127 }
9128 fallback_child.ok_or_else(|| {
9129 ::treesitter_types::ParseError::missing_field("children", node)
9130 })?
9131 };
9132 ::treesitter_types::runtime::maybe_grow_stack(|| {
9133 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
9134 })?
9135 },
9136 })
9137 }
9138}
9139impl ::treesitter_types::Spanned for ParenthesizedPattern<'_> {
9140 fn span(&self) -> ::treesitter_types::Span {
9141 self.span
9142 }
9143}
9144#[derive(Debug, Clone, PartialEq, Eq)]
9145pub struct ParenthesizedVariableDesignation<'tree> {
9146 pub span: ::treesitter_types::Span,
9147 pub name: ::std::vec::Vec<Identifier<'tree>>,
9148 pub children: ::std::vec::Vec<ParenthesizedVariableDesignationChildren<'tree>>,
9149}
9150impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedVariableDesignation<'tree> {
9151 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9152 fn from_node(
9153 node: ::treesitter_types::tree_sitter::Node<'tree>,
9154 src: &'tree [u8],
9155 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9156 debug_assert_eq!(node.kind(), "parenthesized_variable_designation");
9157 Ok(Self {
9158 span: ::treesitter_types::Span::from(node),
9159 name: {
9160 let mut cursor = node.walk();
9161 let mut items = ::std::vec::Vec::new();
9162 for child in node.children_by_field_name("name", &mut cursor) {
9163 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9164 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
9165 })?);
9166 }
9167 items
9168 },
9169 children: {
9170 #[allow(clippy::suspicious_else_formatting)]
9171 let non_field_children = {
9172 let mut cursor = node.walk();
9173 let mut result = ::std::vec::Vec::new();
9174 if cursor.goto_first_child() {
9175 loop {
9176 if cursor.field_name().is_none()
9177 && cursor.node().is_named()
9178 && !cursor.node().is_extra()
9179 {
9180 result.push(cursor.node());
9181 }
9182 if !cursor.goto_next_sibling() {
9183 break;
9184 }
9185 }
9186 }
9187 result
9188 };
9189 let mut items = ::std::vec::Vec::new();
9190 for child in non_field_children {
9191 items
9192 .push(
9193 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedVariableDesignationChildren as ::treesitter_types::FromNode>::from_node(
9194 child,
9195 src,
9196 ))?,
9197 );
9198 }
9199 items
9200 },
9201 })
9202 }
9203}
9204impl ::treesitter_types::Spanned for ParenthesizedVariableDesignation<'_> {
9205 fn span(&self) -> ::treesitter_types::Span {
9206 self.span
9207 }
9208}
9209#[derive(Debug, Clone, PartialEq, Eq)]
9210pub struct PointerType<'tree> {
9211 pub span: ::treesitter_types::Span,
9212 pub r#type: PointerTypeType<'tree>,
9213}
9214impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
9215 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9216 fn from_node(
9217 node: ::treesitter_types::tree_sitter::Node<'tree>,
9218 src: &'tree [u8],
9219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9220 debug_assert_eq!(node.kind(), "pointer_type");
9221 Ok(Self {
9222 span: ::treesitter_types::Span::from(node),
9223 r#type: {
9224 let child = node
9225 .child_by_field_name("type")
9226 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9227 ::treesitter_types::runtime::maybe_grow_stack(|| {
9228 <PointerTypeType as ::treesitter_types::FromNode>::from_node(child, src)
9229 })?
9230 },
9231 })
9232 }
9233}
9234impl ::treesitter_types::Spanned for PointerType<'_> {
9235 fn span(&self) -> ::treesitter_types::Span {
9236 self.span
9237 }
9238}
9239#[derive(Debug, Clone, PartialEq, Eq)]
9240pub struct PositionalPatternClause<'tree> {
9241 pub span: ::treesitter_types::Span,
9242 pub children: ::std::vec::Vec<Subpattern<'tree>>,
9243}
9244impl<'tree> ::treesitter_types::FromNode<'tree> for PositionalPatternClause<'tree> {
9245 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9246 fn from_node(
9247 node: ::treesitter_types::tree_sitter::Node<'tree>,
9248 src: &'tree [u8],
9249 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9250 debug_assert_eq!(node.kind(), "positional_pattern_clause");
9251 Ok(Self {
9252 span: ::treesitter_types::Span::from(node),
9253 children: {
9254 #[allow(clippy::suspicious_else_formatting)]
9255 let non_field_children = {
9256 let mut cursor = node.walk();
9257 let mut result = ::std::vec::Vec::new();
9258 if cursor.goto_first_child() {
9259 loop {
9260 if cursor.field_name().is_none()
9261 && cursor.node().is_named()
9262 && !cursor.node().is_extra()
9263 {
9264 result.push(cursor.node());
9265 }
9266 if !cursor.goto_next_sibling() {
9267 break;
9268 }
9269 }
9270 }
9271 result
9272 };
9273 let mut items = ::std::vec::Vec::new();
9274 for child in non_field_children {
9275 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9276 <Subpattern as ::treesitter_types::FromNode>::from_node(child, src)
9277 })?);
9278 }
9279 items
9280 },
9281 })
9282 }
9283}
9284impl ::treesitter_types::Spanned for PositionalPatternClause<'_> {
9285 fn span(&self) -> ::treesitter_types::Span {
9286 self.span
9287 }
9288}
9289#[derive(Debug, Clone, PartialEq, Eq)]
9290pub struct PostfixUnaryExpression<'tree> {
9291 pub span: ::treesitter_types::Span,
9292 pub children: Expression<'tree>,
9293}
9294impl<'tree> ::treesitter_types::FromNode<'tree> for PostfixUnaryExpression<'tree> {
9295 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9296 fn from_node(
9297 node: ::treesitter_types::tree_sitter::Node<'tree>,
9298 src: &'tree [u8],
9299 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9300 debug_assert_eq!(node.kind(), "postfix_unary_expression");
9301 Ok(Self {
9302 span: ::treesitter_types::Span::from(node),
9303 children: {
9304 #[allow(clippy::suspicious_else_formatting)]
9305 let non_field_children = {
9306 let mut cursor = node.walk();
9307 let mut result = ::std::vec::Vec::new();
9308 if cursor.goto_first_child() {
9309 loop {
9310 if cursor.field_name().is_none()
9311 && cursor.node().is_named()
9312 && !cursor.node().is_extra()
9313 {
9314 result.push(cursor.node());
9315 }
9316 if !cursor.goto_next_sibling() {
9317 break;
9318 }
9319 }
9320 }
9321 result
9322 };
9323 let child = if let Some(&c) = non_field_children.first() {
9324 c
9325 } else {
9326 let mut fallback_cursor = node.walk();
9327 let mut fallback_child = None;
9328 if fallback_cursor.goto_first_child() {
9329 loop {
9330 if fallback_cursor.field_name().is_none()
9331 && !fallback_cursor.node().is_extra()
9332 {
9333 let candidate = fallback_cursor.node();
9334 #[allow(clippy::needless_question_mark)]
9335 if (|| -> ::core::result::Result<
9336 _,
9337 ::treesitter_types::ParseError,
9338 > {
9339 let child = candidate;
9340 Ok(
9341 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9342 child,
9343 src,
9344 ))?,
9345 )
9346 })()
9347 .is_ok()
9348 {
9349 fallback_child = Some(candidate);
9350 break;
9351 }
9352 }
9353 if !fallback_cursor.goto_next_sibling() {
9354 break;
9355 }
9356 }
9357 }
9358 if fallback_child.is_none() {
9359 let mut cursor2 = node.walk();
9360 if cursor2.goto_first_child() {
9361 loop {
9362 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9363 let candidate = cursor2.node();
9364 #[allow(clippy::needless_question_mark)]
9365 if (|| -> ::core::result::Result<
9366 _,
9367 ::treesitter_types::ParseError,
9368 > {
9369 let child = candidate;
9370 Ok(
9371 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9372 child,
9373 src,
9374 ))?,
9375 )
9376 })()
9377 .is_ok()
9378 {
9379 fallback_child = Some(candidate);
9380 break;
9381 }
9382 }
9383 if !cursor2.goto_next_sibling() {
9384 break;
9385 }
9386 }
9387 }
9388 }
9389 fallback_child.ok_or_else(|| {
9390 ::treesitter_types::ParseError::missing_field("children", node)
9391 })?
9392 };
9393 ::treesitter_types::runtime::maybe_grow_stack(|| {
9394 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9395 })?
9396 },
9397 })
9398 }
9399}
9400impl ::treesitter_types::Spanned for PostfixUnaryExpression<'_> {
9401 fn span(&self) -> ::treesitter_types::Span {
9402 self.span
9403 }
9404}
9405#[derive(Debug, Clone, PartialEq, Eq)]
9406pub struct PrefixUnaryExpression<'tree> {
9407 pub span: ::treesitter_types::Span,
9408 pub children: Expression<'tree>,
9409}
9410impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnaryExpression<'tree> {
9411 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9412 fn from_node(
9413 node: ::treesitter_types::tree_sitter::Node<'tree>,
9414 src: &'tree [u8],
9415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9416 debug_assert_eq!(node.kind(), "prefix_unary_expression");
9417 Ok(Self {
9418 span: ::treesitter_types::Span::from(node),
9419 children: {
9420 #[allow(clippy::suspicious_else_formatting)]
9421 let non_field_children = {
9422 let mut cursor = node.walk();
9423 let mut result = ::std::vec::Vec::new();
9424 if cursor.goto_first_child() {
9425 loop {
9426 if cursor.field_name().is_none()
9427 && cursor.node().is_named()
9428 && !cursor.node().is_extra()
9429 {
9430 result.push(cursor.node());
9431 }
9432 if !cursor.goto_next_sibling() {
9433 break;
9434 }
9435 }
9436 }
9437 result
9438 };
9439 let child = if let Some(&c) = non_field_children.first() {
9440 c
9441 } else {
9442 let mut fallback_cursor = node.walk();
9443 let mut fallback_child = None;
9444 if fallback_cursor.goto_first_child() {
9445 loop {
9446 if fallback_cursor.field_name().is_none()
9447 && !fallback_cursor.node().is_extra()
9448 {
9449 let candidate = fallback_cursor.node();
9450 #[allow(clippy::needless_question_mark)]
9451 if (|| -> ::core::result::Result<
9452 _,
9453 ::treesitter_types::ParseError,
9454 > {
9455 let child = candidate;
9456 Ok(
9457 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9458 child,
9459 src,
9460 ))?,
9461 )
9462 })()
9463 .is_ok()
9464 {
9465 fallback_child = Some(candidate);
9466 break;
9467 }
9468 }
9469 if !fallback_cursor.goto_next_sibling() {
9470 break;
9471 }
9472 }
9473 }
9474 if fallback_child.is_none() {
9475 let mut cursor2 = node.walk();
9476 if cursor2.goto_first_child() {
9477 loop {
9478 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9479 let candidate = cursor2.node();
9480 #[allow(clippy::needless_question_mark)]
9481 if (|| -> ::core::result::Result<
9482 _,
9483 ::treesitter_types::ParseError,
9484 > {
9485 let child = candidate;
9486 Ok(
9487 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9488 child,
9489 src,
9490 ))?,
9491 )
9492 })()
9493 .is_ok()
9494 {
9495 fallback_child = Some(candidate);
9496 break;
9497 }
9498 }
9499 if !cursor2.goto_next_sibling() {
9500 break;
9501 }
9502 }
9503 }
9504 }
9505 fallback_child.ok_or_else(|| {
9506 ::treesitter_types::ParseError::missing_field("children", node)
9507 })?
9508 };
9509 ::treesitter_types::runtime::maybe_grow_stack(|| {
9510 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9511 })?
9512 },
9513 })
9514 }
9515}
9516impl ::treesitter_types::Spanned for PrefixUnaryExpression<'_> {
9517 fn span(&self) -> ::treesitter_types::Span {
9518 self.span
9519 }
9520}
9521#[derive(Debug, Clone, PartialEq, Eq)]
9522pub struct PreprocDefine<'tree> {
9523 pub span: ::treesitter_types::Span,
9524 pub children: PreprocArg<'tree>,
9525}
9526impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefine<'tree> {
9527 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9528 fn from_node(
9529 node: ::treesitter_types::tree_sitter::Node<'tree>,
9530 src: &'tree [u8],
9531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9532 debug_assert_eq!(node.kind(), "preproc_define");
9533 Ok(Self {
9534 span: ::treesitter_types::Span::from(node),
9535 children: {
9536 #[allow(clippy::suspicious_else_formatting)]
9537 let non_field_children = {
9538 let mut cursor = node.walk();
9539 let mut result = ::std::vec::Vec::new();
9540 if cursor.goto_first_child() {
9541 loop {
9542 if cursor.field_name().is_none()
9543 && cursor.node().is_named()
9544 && !cursor.node().is_extra()
9545 {
9546 result.push(cursor.node());
9547 }
9548 if !cursor.goto_next_sibling() {
9549 break;
9550 }
9551 }
9552 }
9553 result
9554 };
9555 let child = if let Some(&c) = non_field_children.first() {
9556 c
9557 } else {
9558 let mut fallback_cursor = node.walk();
9559 let mut fallback_child = None;
9560 if fallback_cursor.goto_first_child() {
9561 loop {
9562 if fallback_cursor.field_name().is_none()
9563 && !fallback_cursor.node().is_extra()
9564 {
9565 let candidate = fallback_cursor.node();
9566 #[allow(clippy::needless_question_mark)]
9567 if (|| -> ::core::result::Result<
9568 _,
9569 ::treesitter_types::ParseError,
9570 > {
9571 let child = candidate;
9572 Ok(
9573 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9574 child,
9575 src,
9576 ))?,
9577 )
9578 })()
9579 .is_ok()
9580 {
9581 fallback_child = Some(candidate);
9582 break;
9583 }
9584 }
9585 if !fallback_cursor.goto_next_sibling() {
9586 break;
9587 }
9588 }
9589 }
9590 if fallback_child.is_none() {
9591 let mut cursor2 = node.walk();
9592 if cursor2.goto_first_child() {
9593 loop {
9594 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9595 let candidate = cursor2.node();
9596 #[allow(clippy::needless_question_mark)]
9597 if (|| -> ::core::result::Result<
9598 _,
9599 ::treesitter_types::ParseError,
9600 > {
9601 let child = candidate;
9602 Ok(
9603 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9604 child,
9605 src,
9606 ))?,
9607 )
9608 })()
9609 .is_ok()
9610 {
9611 fallback_child = Some(candidate);
9612 break;
9613 }
9614 }
9615 if !cursor2.goto_next_sibling() {
9616 break;
9617 }
9618 }
9619 }
9620 }
9621 fallback_child.ok_or_else(|| {
9622 ::treesitter_types::ParseError::missing_field("children", node)
9623 })?
9624 };
9625 ::treesitter_types::runtime::maybe_grow_stack(|| {
9626 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9627 })?
9628 },
9629 })
9630 }
9631}
9632impl ::treesitter_types::Spanned for PreprocDefine<'_> {
9633 fn span(&self) -> ::treesitter_types::Span {
9634 self.span
9635 }
9636}
9637#[derive(Debug, Clone, PartialEq, Eq)]
9638pub struct PreprocElif<'tree> {
9639 pub span: ::treesitter_types::Span,
9640 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
9641 pub condition: PreprocElifCondition<'tree>,
9642 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
9643}
9644impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
9645 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9646 fn from_node(
9647 node: ::treesitter_types::tree_sitter::Node<'tree>,
9648 src: &'tree [u8],
9649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9650 debug_assert_eq!(node.kind(), "preproc_elif");
9651 Ok(Self {
9652 span: ::treesitter_types::Span::from(node),
9653 alternative: match node.child_by_field_name("alternative") {
9654 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9655 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(child, src)
9656 })?),
9657 None => None,
9658 },
9659 condition: {
9660 let child = node.child_by_field_name("condition").ok_or_else(|| {
9661 ::treesitter_types::ParseError::missing_field("condition", node)
9662 })?;
9663 ::treesitter_types::runtime::maybe_grow_stack(|| {
9664 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)
9665 })?
9666 },
9667 children: {
9668 #[allow(clippy::suspicious_else_formatting)]
9669 let non_field_children = {
9670 let mut cursor = node.walk();
9671 let mut result = ::std::vec::Vec::new();
9672 if cursor.goto_first_child() {
9673 loop {
9674 if cursor.field_name().is_none()
9675 && cursor.node().is_named()
9676 && !cursor.node().is_extra()
9677 {
9678 result.push(cursor.node());
9679 }
9680 if !cursor.goto_next_sibling() {
9681 break;
9682 }
9683 }
9684 }
9685 result
9686 };
9687 let mut items = ::std::vec::Vec::new();
9688 for child in non_field_children {
9689 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9690 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(child, src)
9691 })?);
9692 }
9693 items
9694 },
9695 })
9696 }
9697}
9698impl ::treesitter_types::Spanned for PreprocElif<'_> {
9699 fn span(&self) -> ::treesitter_types::Span {
9700 self.span
9701 }
9702}
9703#[derive(Debug, Clone, PartialEq, Eq)]
9704pub struct PreprocElse<'tree> {
9705 pub span: ::treesitter_types::Span,
9706 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
9707}
9708impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
9709 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9710 fn from_node(
9711 node: ::treesitter_types::tree_sitter::Node<'tree>,
9712 src: &'tree [u8],
9713 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9714 debug_assert_eq!(node.kind(), "preproc_else");
9715 Ok(Self {
9716 span: ::treesitter_types::Span::from(node),
9717 children: {
9718 #[allow(clippy::suspicious_else_formatting)]
9719 let non_field_children = {
9720 let mut cursor = node.walk();
9721 let mut result = ::std::vec::Vec::new();
9722 if cursor.goto_first_child() {
9723 loop {
9724 if cursor.field_name().is_none()
9725 && cursor.node().is_named()
9726 && !cursor.node().is_extra()
9727 {
9728 result.push(cursor.node());
9729 }
9730 if !cursor.goto_next_sibling() {
9731 break;
9732 }
9733 }
9734 }
9735 result
9736 };
9737 let mut items = ::std::vec::Vec::new();
9738 for child in non_field_children {
9739 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9740 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(child, src)
9741 })?);
9742 }
9743 items
9744 },
9745 })
9746 }
9747}
9748impl ::treesitter_types::Spanned for PreprocElse<'_> {
9749 fn span(&self) -> ::treesitter_types::Span {
9750 self.span
9751 }
9752}
9753#[derive(Debug, Clone, PartialEq, Eq)]
9754pub struct PreprocEndregion<'tree> {
9755 pub span: ::treesitter_types::Span,
9756 pub content: ::core::option::Option<PreprocArg<'tree>>,
9757}
9758impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocEndregion<'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_endregion");
9765 Ok(Self {
9766 span: ::treesitter_types::Span::from(node),
9767 content: match node.child_by_field_name("content") {
9768 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9769 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9770 })?),
9771 None => None,
9772 },
9773 })
9774 }
9775}
9776impl ::treesitter_types::Spanned for PreprocEndregion<'_> {
9777 fn span(&self) -> ::treesitter_types::Span {
9778 self.span
9779 }
9780}
9781#[derive(Debug, Clone, PartialEq, Eq)]
9782pub struct PreprocError<'tree> {
9783 pub span: ::treesitter_types::Span,
9784 pub children: PreprocArg<'tree>,
9785}
9786impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocError<'tree> {
9787 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9788 fn from_node(
9789 node: ::treesitter_types::tree_sitter::Node<'tree>,
9790 src: &'tree [u8],
9791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9792 debug_assert_eq!(node.kind(), "preproc_error");
9793 Ok(Self {
9794 span: ::treesitter_types::Span::from(node),
9795 children: {
9796 #[allow(clippy::suspicious_else_formatting)]
9797 let non_field_children = {
9798 let mut cursor = node.walk();
9799 let mut result = ::std::vec::Vec::new();
9800 if cursor.goto_first_child() {
9801 loop {
9802 if cursor.field_name().is_none()
9803 && cursor.node().is_named()
9804 && !cursor.node().is_extra()
9805 {
9806 result.push(cursor.node());
9807 }
9808 if !cursor.goto_next_sibling() {
9809 break;
9810 }
9811 }
9812 }
9813 result
9814 };
9815 let child = if let Some(&c) = non_field_children.first() {
9816 c
9817 } else {
9818 let mut fallback_cursor = node.walk();
9819 let mut fallback_child = None;
9820 if fallback_cursor.goto_first_child() {
9821 loop {
9822 if fallback_cursor.field_name().is_none()
9823 && !fallback_cursor.node().is_extra()
9824 {
9825 let candidate = fallback_cursor.node();
9826 #[allow(clippy::needless_question_mark)]
9827 if (|| -> ::core::result::Result<
9828 _,
9829 ::treesitter_types::ParseError,
9830 > {
9831 let child = candidate;
9832 Ok(
9833 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9834 child,
9835 src,
9836 ))?,
9837 )
9838 })()
9839 .is_ok()
9840 {
9841 fallback_child = Some(candidate);
9842 break;
9843 }
9844 }
9845 if !fallback_cursor.goto_next_sibling() {
9846 break;
9847 }
9848 }
9849 }
9850 if fallback_child.is_none() {
9851 let mut cursor2 = node.walk();
9852 if cursor2.goto_first_child() {
9853 loop {
9854 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9855 let candidate = cursor2.node();
9856 #[allow(clippy::needless_question_mark)]
9857 if (|| -> ::core::result::Result<
9858 _,
9859 ::treesitter_types::ParseError,
9860 > {
9861 let child = candidate;
9862 Ok(
9863 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
9864 child,
9865 src,
9866 ))?,
9867 )
9868 })()
9869 .is_ok()
9870 {
9871 fallback_child = Some(candidate);
9872 break;
9873 }
9874 }
9875 if !cursor2.goto_next_sibling() {
9876 break;
9877 }
9878 }
9879 }
9880 }
9881 fallback_child.ok_or_else(|| {
9882 ::treesitter_types::ParseError::missing_field("children", node)
9883 })?
9884 };
9885 ::treesitter_types::runtime::maybe_grow_stack(|| {
9886 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
9887 })?
9888 },
9889 })
9890 }
9891}
9892impl ::treesitter_types::Spanned for PreprocError<'_> {
9893 fn span(&self) -> ::treesitter_types::Span {
9894 self.span
9895 }
9896}
9897#[derive(Debug, Clone, PartialEq, Eq)]
9898pub struct PreprocIf<'tree> {
9899 pub span: ::treesitter_types::Span,
9900 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
9901 pub condition: PreprocIfCondition<'tree>,
9902 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
9903}
9904impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
9905 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9906 fn from_node(
9907 node: ::treesitter_types::tree_sitter::Node<'tree>,
9908 src: &'tree [u8],
9909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9910 debug_assert_eq!(node.kind(), "preproc_if");
9911 Ok(Self {
9912 span: ::treesitter_types::Span::from(node),
9913 alternative: match node.child_by_field_name("alternative") {
9914 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9915 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)
9916 })?),
9917 None => None,
9918 },
9919 condition: {
9920 let child = node.child_by_field_name("condition").ok_or_else(|| {
9921 ::treesitter_types::ParseError::missing_field("condition", node)
9922 })?;
9923 ::treesitter_types::runtime::maybe_grow_stack(|| {
9924 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)
9925 })?
9926 },
9927 children: {
9928 #[allow(clippy::suspicious_else_formatting)]
9929 let non_field_children = {
9930 let mut cursor = node.walk();
9931 let mut result = ::std::vec::Vec::new();
9932 if cursor.goto_first_child() {
9933 loop {
9934 if cursor.field_name().is_none()
9935 && cursor.node().is_named()
9936 && !cursor.node().is_extra()
9937 {
9938 result.push(cursor.node());
9939 }
9940 if !cursor.goto_next_sibling() {
9941 break;
9942 }
9943 }
9944 }
9945 result
9946 };
9947 let mut items = ::std::vec::Vec::new();
9948 for child in non_field_children {
9949 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9950 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)
9951 })?);
9952 }
9953 items
9954 },
9955 })
9956 }
9957}
9958impl ::treesitter_types::Spanned for PreprocIf<'_> {
9959 fn span(&self) -> ::treesitter_types::Span {
9960 self.span
9961 }
9962}
9963#[derive(Debug, Clone, PartialEq, Eq)]
9964pub struct PreprocIfInAttributeList<'tree> {
9965 pub span: ::treesitter_types::Span,
9966 pub alternative: ::core::option::Option<PreprocIfInAttributeListAlternative<'tree>>,
9967 pub condition: PreprocIfInAttributeListCondition<'tree>,
9968 pub children: ::core::option::Option<AttributeList<'tree>>,
9969}
9970impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfInAttributeList<'tree> {
9971 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9972 fn from_node(
9973 node: ::treesitter_types::tree_sitter::Node<'tree>,
9974 src: &'tree [u8],
9975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9976 debug_assert_eq!(node.kind(), "preproc_if_in_attribute_list");
9977 Ok(Self {
9978 span: ::treesitter_types::Span::from(node),
9979 alternative: match node.child_by_field_name("alternative") {
9980 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9981 <PreprocIfInAttributeListAlternative as ::treesitter_types::FromNode>::from_node(
9982 child, src,
9983 )
9984 })?),
9985 None => None,
9986 },
9987 condition: {
9988 let child = node.child_by_field_name("condition").ok_or_else(|| {
9989 ::treesitter_types::ParseError::missing_field("condition", node)
9990 })?;
9991 ::treesitter_types::runtime::maybe_grow_stack(|| {
9992 <PreprocIfInAttributeListCondition as ::treesitter_types::FromNode>::from_node(
9993 child, src,
9994 )
9995 })?
9996 },
9997 children: {
9998 #[allow(clippy::suspicious_else_formatting)]
9999 let non_field_children = {
10000 let mut cursor = node.walk();
10001 let mut result = ::std::vec::Vec::new();
10002 if cursor.goto_first_child() {
10003 loop {
10004 if cursor.field_name().is_none()
10005 && cursor.node().is_named()
10006 && !cursor.node().is_extra()
10007 {
10008 result.push(cursor.node());
10009 }
10010 if !cursor.goto_next_sibling() {
10011 break;
10012 }
10013 }
10014 }
10015 result
10016 };
10017 match non_field_children.first() {
10018 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10019 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
10020 })?),
10021 None => None,
10022 }
10023 },
10024 })
10025 }
10026}
10027impl ::treesitter_types::Spanned for PreprocIfInAttributeList<'_> {
10028 fn span(&self) -> ::treesitter_types::Span {
10029 self.span
10030 }
10031}
10032#[derive(Debug, Clone, PartialEq, Eq)]
10033pub struct PreprocLine<'tree> {
10034 pub span: ::treesitter_types::Span,
10035 pub children: ::std::vec::Vec<PreprocLineChildren<'tree>>,
10036}
10037impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLine<'tree> {
10038 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10039 fn from_node(
10040 node: ::treesitter_types::tree_sitter::Node<'tree>,
10041 src: &'tree [u8],
10042 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10043 debug_assert_eq!(node.kind(), "preproc_line");
10044 Ok(Self {
10045 span: ::treesitter_types::Span::from(node),
10046 children: {
10047 #[allow(clippy::suspicious_else_formatting)]
10048 let non_field_children = {
10049 let mut cursor = node.walk();
10050 let mut result = ::std::vec::Vec::new();
10051 if cursor.goto_first_child() {
10052 loop {
10053 if cursor.field_name().is_none()
10054 && cursor.node().is_named()
10055 && !cursor.node().is_extra()
10056 {
10057 result.push(cursor.node());
10058 }
10059 if !cursor.goto_next_sibling() {
10060 break;
10061 }
10062 }
10063 }
10064 result
10065 };
10066 let mut items = ::std::vec::Vec::new();
10067 for child in non_field_children {
10068 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10069 <PreprocLineChildren as ::treesitter_types::FromNode>::from_node(child, src)
10070 })?);
10071 }
10072 items
10073 },
10074 })
10075 }
10076}
10077impl ::treesitter_types::Spanned for PreprocLine<'_> {
10078 fn span(&self) -> ::treesitter_types::Span {
10079 self.span
10080 }
10081}
10082#[derive(Debug, Clone, PartialEq, Eq)]
10083pub struct PreprocNullable<'tree> {
10084 pub span: ::treesitter_types::Span,
10085 text: &'tree str,
10086}
10087impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocNullable<'tree> {
10088 fn from_node(
10089 node: ::treesitter_types::tree_sitter::Node<'tree>,
10090 src: &'tree [u8],
10091 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10092 debug_assert_eq!(node.kind(), "preproc_nullable");
10093 Ok(Self {
10094 span: ::treesitter_types::Span::from(node),
10095 text: node.utf8_text(src)?,
10096 })
10097 }
10098}
10099impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocNullable<'tree> {
10100 fn text(&self) -> &'tree str {
10101 self.text
10102 }
10103}
10104impl ::treesitter_types::Spanned for PreprocNullable<'_> {
10105 fn span(&self) -> ::treesitter_types::Span {
10106 self.span
10107 }
10108}
10109#[derive(Debug, Clone, PartialEq, Eq)]
10110pub struct PreprocPragma<'tree> {
10111 pub span: ::treesitter_types::Span,
10112 pub children: ::std::vec::Vec<PreprocPragmaChildren<'tree>>,
10113}
10114impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragma<'tree> {
10115 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10116 fn from_node(
10117 node: ::treesitter_types::tree_sitter::Node<'tree>,
10118 src: &'tree [u8],
10119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10120 debug_assert_eq!(node.kind(), "preproc_pragma");
10121 Ok(Self {
10122 span: ::treesitter_types::Span::from(node),
10123 children: {
10124 #[allow(clippy::suspicious_else_formatting)]
10125 let non_field_children = {
10126 let mut cursor = node.walk();
10127 let mut result = ::std::vec::Vec::new();
10128 if cursor.goto_first_child() {
10129 loop {
10130 if cursor.field_name().is_none()
10131 && cursor.node().is_named()
10132 && !cursor.node().is_extra()
10133 {
10134 result.push(cursor.node());
10135 }
10136 if !cursor.goto_next_sibling() {
10137 break;
10138 }
10139 }
10140 }
10141 result
10142 };
10143 let mut items = ::std::vec::Vec::new();
10144 for child in non_field_children {
10145 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10146 <PreprocPragmaChildren as ::treesitter_types::FromNode>::from_node(
10147 child, src,
10148 )
10149 })?);
10150 }
10151 items
10152 },
10153 })
10154 }
10155}
10156impl ::treesitter_types::Spanned for PreprocPragma<'_> {
10157 fn span(&self) -> ::treesitter_types::Span {
10158 self.span
10159 }
10160}
10161#[derive(Debug, Clone, PartialEq, Eq)]
10162pub struct PreprocRegion<'tree> {
10163 pub span: ::treesitter_types::Span,
10164 pub content: ::core::option::Option<PreprocArg<'tree>>,
10165}
10166impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocRegion<'tree> {
10167 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10168 fn from_node(
10169 node: ::treesitter_types::tree_sitter::Node<'tree>,
10170 src: &'tree [u8],
10171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10172 debug_assert_eq!(node.kind(), "preproc_region");
10173 Ok(Self {
10174 span: ::treesitter_types::Span::from(node),
10175 content: match node.child_by_field_name("content") {
10176 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10177 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
10178 })?),
10179 None => None,
10180 },
10181 })
10182 }
10183}
10184impl ::treesitter_types::Spanned for PreprocRegion<'_> {
10185 fn span(&self) -> ::treesitter_types::Span {
10186 self.span
10187 }
10188}
10189#[derive(Debug, Clone, PartialEq, Eq)]
10190pub struct PreprocUndef<'tree> {
10191 pub span: ::treesitter_types::Span,
10192 pub children: PreprocArg<'tree>,
10193}
10194impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocUndef<'tree> {
10195 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10196 fn from_node(
10197 node: ::treesitter_types::tree_sitter::Node<'tree>,
10198 src: &'tree [u8],
10199 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10200 debug_assert_eq!(node.kind(), "preproc_undef");
10201 Ok(Self {
10202 span: ::treesitter_types::Span::from(node),
10203 children: {
10204 #[allow(clippy::suspicious_else_formatting)]
10205 let non_field_children = {
10206 let mut cursor = node.walk();
10207 let mut result = ::std::vec::Vec::new();
10208 if cursor.goto_first_child() {
10209 loop {
10210 if cursor.field_name().is_none()
10211 && cursor.node().is_named()
10212 && !cursor.node().is_extra()
10213 {
10214 result.push(cursor.node());
10215 }
10216 if !cursor.goto_next_sibling() {
10217 break;
10218 }
10219 }
10220 }
10221 result
10222 };
10223 let child = if let Some(&c) = non_field_children.first() {
10224 c
10225 } else {
10226 let mut fallback_cursor = node.walk();
10227 let mut fallback_child = None;
10228 if fallback_cursor.goto_first_child() {
10229 loop {
10230 if fallback_cursor.field_name().is_none()
10231 && !fallback_cursor.node().is_extra()
10232 {
10233 let candidate = fallback_cursor.node();
10234 #[allow(clippy::needless_question_mark)]
10235 if (|| -> ::core::result::Result<
10236 _,
10237 ::treesitter_types::ParseError,
10238 > {
10239 let child = candidate;
10240 Ok(
10241 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
10242 child,
10243 src,
10244 ))?,
10245 )
10246 })()
10247 .is_ok()
10248 {
10249 fallback_child = Some(candidate);
10250 break;
10251 }
10252 }
10253 if !fallback_cursor.goto_next_sibling() {
10254 break;
10255 }
10256 }
10257 }
10258 if fallback_child.is_none() {
10259 let mut cursor2 = node.walk();
10260 if cursor2.goto_first_child() {
10261 loop {
10262 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10263 let candidate = cursor2.node();
10264 #[allow(clippy::needless_question_mark)]
10265 if (|| -> ::core::result::Result<
10266 _,
10267 ::treesitter_types::ParseError,
10268 > {
10269 let child = candidate;
10270 Ok(
10271 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
10272 child,
10273 src,
10274 ))?,
10275 )
10276 })()
10277 .is_ok()
10278 {
10279 fallback_child = Some(candidate);
10280 break;
10281 }
10282 }
10283 if !cursor2.goto_next_sibling() {
10284 break;
10285 }
10286 }
10287 }
10288 }
10289 fallback_child.ok_or_else(|| {
10290 ::treesitter_types::ParseError::missing_field("children", node)
10291 })?
10292 };
10293 ::treesitter_types::runtime::maybe_grow_stack(|| {
10294 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
10295 })?
10296 },
10297 })
10298 }
10299}
10300impl ::treesitter_types::Spanned for PreprocUndef<'_> {
10301 fn span(&self) -> ::treesitter_types::Span {
10302 self.span
10303 }
10304}
10305#[derive(Debug, Clone, PartialEq, Eq)]
10306pub struct PreprocWarning<'tree> {
10307 pub span: ::treesitter_types::Span,
10308 pub children: PreprocArg<'tree>,
10309}
10310impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocWarning<'tree> {
10311 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10312 fn from_node(
10313 node: ::treesitter_types::tree_sitter::Node<'tree>,
10314 src: &'tree [u8],
10315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10316 debug_assert_eq!(node.kind(), "preproc_warning");
10317 Ok(Self {
10318 span: ::treesitter_types::Span::from(node),
10319 children: {
10320 #[allow(clippy::suspicious_else_formatting)]
10321 let non_field_children = {
10322 let mut cursor = node.walk();
10323 let mut result = ::std::vec::Vec::new();
10324 if cursor.goto_first_child() {
10325 loop {
10326 if cursor.field_name().is_none()
10327 && cursor.node().is_named()
10328 && !cursor.node().is_extra()
10329 {
10330 result.push(cursor.node());
10331 }
10332 if !cursor.goto_next_sibling() {
10333 break;
10334 }
10335 }
10336 }
10337 result
10338 };
10339 let child = if let Some(&c) = non_field_children.first() {
10340 c
10341 } else {
10342 let mut fallback_cursor = node.walk();
10343 let mut fallback_child = None;
10344 if fallback_cursor.goto_first_child() {
10345 loop {
10346 if fallback_cursor.field_name().is_none()
10347 && !fallback_cursor.node().is_extra()
10348 {
10349 let candidate = fallback_cursor.node();
10350 #[allow(clippy::needless_question_mark)]
10351 if (|| -> ::core::result::Result<
10352 _,
10353 ::treesitter_types::ParseError,
10354 > {
10355 let child = candidate;
10356 Ok(
10357 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
10358 child,
10359 src,
10360 ))?,
10361 )
10362 })()
10363 .is_ok()
10364 {
10365 fallback_child = Some(candidate);
10366 break;
10367 }
10368 }
10369 if !fallback_cursor.goto_next_sibling() {
10370 break;
10371 }
10372 }
10373 }
10374 if fallback_child.is_none() {
10375 let mut cursor2 = node.walk();
10376 if cursor2.goto_first_child() {
10377 loop {
10378 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10379 let candidate = cursor2.node();
10380 #[allow(clippy::needless_question_mark)]
10381 if (|| -> ::core::result::Result<
10382 _,
10383 ::treesitter_types::ParseError,
10384 > {
10385 let child = candidate;
10386 Ok(
10387 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
10388 child,
10389 src,
10390 ))?,
10391 )
10392 })()
10393 .is_ok()
10394 {
10395 fallback_child = Some(candidate);
10396 break;
10397 }
10398 }
10399 if !cursor2.goto_next_sibling() {
10400 break;
10401 }
10402 }
10403 }
10404 }
10405 fallback_child.ok_or_else(|| {
10406 ::treesitter_types::ParseError::missing_field("children", node)
10407 })?
10408 };
10409 ::treesitter_types::runtime::maybe_grow_stack(|| {
10410 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
10411 })?
10412 },
10413 })
10414 }
10415}
10416impl ::treesitter_types::Spanned for PreprocWarning<'_> {
10417 fn span(&self) -> ::treesitter_types::Span {
10418 self.span
10419 }
10420}
10421#[derive(Debug, Clone, PartialEq, Eq)]
10422pub struct PrimaryConstructorBaseType<'tree> {
10423 pub span: ::treesitter_types::Span,
10424 pub r#type: PrimaryConstructorBaseTypeType<'tree>,
10425 pub children: ArgumentList<'tree>,
10426}
10427impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseType<'tree> {
10428 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10429 fn from_node(
10430 node: ::treesitter_types::tree_sitter::Node<'tree>,
10431 src: &'tree [u8],
10432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10433 debug_assert_eq!(node.kind(), "primary_constructor_base_type");
10434 Ok(Self {
10435 span: ::treesitter_types::Span::from(node),
10436 r#type: {
10437 let child = node
10438 .child_by_field_name("type")
10439 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10440 ::treesitter_types::runtime::maybe_grow_stack(|| {
10441 <PrimaryConstructorBaseTypeType as ::treesitter_types::FromNode>::from_node(
10442 child, src,
10443 )
10444 })?
10445 },
10446 children: {
10447 #[allow(clippy::suspicious_else_formatting)]
10448 let non_field_children = {
10449 let mut cursor = node.walk();
10450 let mut result = ::std::vec::Vec::new();
10451 if cursor.goto_first_child() {
10452 loop {
10453 if cursor.field_name().is_none()
10454 && cursor.node().is_named()
10455 && !cursor.node().is_extra()
10456 {
10457 result.push(cursor.node());
10458 }
10459 if !cursor.goto_next_sibling() {
10460 break;
10461 }
10462 }
10463 }
10464 result
10465 };
10466 let child = if let Some(&c) = non_field_children.first() {
10467 c
10468 } else {
10469 let mut fallback_cursor = node.walk();
10470 let mut fallback_child = None;
10471 if fallback_cursor.goto_first_child() {
10472 loop {
10473 if fallback_cursor.field_name().is_none()
10474 && !fallback_cursor.node().is_extra()
10475 {
10476 let candidate = fallback_cursor.node();
10477 #[allow(clippy::needless_question_mark)]
10478 if (|| -> ::core::result::Result<
10479 _,
10480 ::treesitter_types::ParseError,
10481 > {
10482 let child = candidate;
10483 Ok(
10484 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
10485 child,
10486 src,
10487 ))?,
10488 )
10489 })()
10490 .is_ok()
10491 {
10492 fallback_child = Some(candidate);
10493 break;
10494 }
10495 }
10496 if !fallback_cursor.goto_next_sibling() {
10497 break;
10498 }
10499 }
10500 }
10501 if fallback_child.is_none() {
10502 let mut cursor2 = node.walk();
10503 if cursor2.goto_first_child() {
10504 loop {
10505 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10506 let candidate = cursor2.node();
10507 #[allow(clippy::needless_question_mark)]
10508 if (|| -> ::core::result::Result<
10509 _,
10510 ::treesitter_types::ParseError,
10511 > {
10512 let child = candidate;
10513 Ok(
10514 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
10515 child,
10516 src,
10517 ))?,
10518 )
10519 })()
10520 .is_ok()
10521 {
10522 fallback_child = Some(candidate);
10523 break;
10524 }
10525 }
10526 if !cursor2.goto_next_sibling() {
10527 break;
10528 }
10529 }
10530 }
10531 }
10532 fallback_child.ok_or_else(|| {
10533 ::treesitter_types::ParseError::missing_field("children", node)
10534 })?
10535 };
10536 ::treesitter_types::runtime::maybe_grow_stack(|| {
10537 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10538 })?
10539 },
10540 })
10541 }
10542}
10543impl ::treesitter_types::Spanned for PrimaryConstructorBaseType<'_> {
10544 fn span(&self) -> ::treesitter_types::Span {
10545 self.span
10546 }
10547}
10548#[derive(Debug, Clone, PartialEq, Eq)]
10549pub struct PropertyDeclaration<'tree> {
10550 pub span: ::treesitter_types::Span,
10551 pub accessors: ::core::option::Option<AccessorList<'tree>>,
10552 pub name: Identifier<'tree>,
10553 pub r#type: Type<'tree>,
10554 pub value: ::core::option::Option<PropertyDeclarationValue<'tree>>,
10555 pub children: ::std::vec::Vec<PropertyDeclarationChildren<'tree>>,
10556}
10557impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclaration<'tree> {
10558 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10559 fn from_node(
10560 node: ::treesitter_types::tree_sitter::Node<'tree>,
10561 src: &'tree [u8],
10562 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10563 debug_assert_eq!(node.kind(), "property_declaration");
10564 Ok(Self {
10565 span: ::treesitter_types::Span::from(node),
10566 accessors: match node.child_by_field_name("accessors") {
10567 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10568 <AccessorList as ::treesitter_types::FromNode>::from_node(child, src)
10569 })?),
10570 None => None,
10571 },
10572 name: {
10573 let child = node
10574 .child_by_field_name("name")
10575 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10576 ::treesitter_types::runtime::maybe_grow_stack(|| {
10577 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10578 })?
10579 },
10580 r#type: {
10581 let child = node
10582 .child_by_field_name("type")
10583 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10584 ::treesitter_types::runtime::maybe_grow_stack(|| {
10585 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10586 })?
10587 },
10588 value: match node.child_by_field_name("value") {
10589 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10590 <PropertyDeclarationValue as ::treesitter_types::FromNode>::from_node(
10591 child, src,
10592 )
10593 })?),
10594 None => None,
10595 },
10596 children: {
10597 #[allow(clippy::suspicious_else_formatting)]
10598 let non_field_children = {
10599 let mut cursor = node.walk();
10600 let mut result = ::std::vec::Vec::new();
10601 if cursor.goto_first_child() {
10602 loop {
10603 if cursor.field_name().is_none()
10604 && cursor.node().is_named()
10605 && !cursor.node().is_extra()
10606 {
10607 result.push(cursor.node());
10608 }
10609 if !cursor.goto_next_sibling() {
10610 break;
10611 }
10612 }
10613 }
10614 result
10615 };
10616 let mut items = ::std::vec::Vec::new();
10617 for child in non_field_children {
10618 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10619 <PropertyDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10620 child, src,
10621 )
10622 })?);
10623 }
10624 items
10625 },
10626 })
10627 }
10628}
10629impl ::treesitter_types::Spanned for PropertyDeclaration<'_> {
10630 fn span(&self) -> ::treesitter_types::Span {
10631 self.span
10632 }
10633}
10634#[derive(Debug, Clone, PartialEq, Eq)]
10635pub struct PropertyPatternClause<'tree> {
10636 pub span: ::treesitter_types::Span,
10637 pub children: ::std::vec::Vec<Subpattern<'tree>>,
10638}
10639impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPatternClause<'tree> {
10640 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10641 fn from_node(
10642 node: ::treesitter_types::tree_sitter::Node<'tree>,
10643 src: &'tree [u8],
10644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10645 debug_assert_eq!(node.kind(), "property_pattern_clause");
10646 Ok(Self {
10647 span: ::treesitter_types::Span::from(node),
10648 children: {
10649 #[allow(clippy::suspicious_else_formatting)]
10650 let non_field_children = {
10651 let mut cursor = node.walk();
10652 let mut result = ::std::vec::Vec::new();
10653 if cursor.goto_first_child() {
10654 loop {
10655 if cursor.field_name().is_none()
10656 && cursor.node().is_named()
10657 && !cursor.node().is_extra()
10658 {
10659 result.push(cursor.node());
10660 }
10661 if !cursor.goto_next_sibling() {
10662 break;
10663 }
10664 }
10665 }
10666 result
10667 };
10668 let mut items = ::std::vec::Vec::new();
10669 for child in non_field_children {
10670 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10671 <Subpattern as ::treesitter_types::FromNode>::from_node(child, src)
10672 })?);
10673 }
10674 items
10675 },
10676 })
10677 }
10678}
10679impl ::treesitter_types::Spanned for PropertyPatternClause<'_> {
10680 fn span(&self) -> ::treesitter_types::Span {
10681 self.span
10682 }
10683}
10684#[derive(Debug, Clone, PartialEq, Eq)]
10685pub struct QualifiedName<'tree> {
10686 pub span: ::treesitter_types::Span,
10687 pub name: QualifiedNameName<'tree>,
10688 pub qualifier: QualifiedNameQualifier<'tree>,
10689}
10690impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedName<'tree> {
10691 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10692 fn from_node(
10693 node: ::treesitter_types::tree_sitter::Node<'tree>,
10694 src: &'tree [u8],
10695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10696 debug_assert_eq!(node.kind(), "qualified_name");
10697 Ok(Self {
10698 span: ::treesitter_types::Span::from(node),
10699 name: {
10700 let child = node
10701 .child_by_field_name("name")
10702 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10703 ::treesitter_types::runtime::maybe_grow_stack(|| {
10704 <QualifiedNameName as ::treesitter_types::FromNode>::from_node(child, src)
10705 })?
10706 },
10707 qualifier: {
10708 let child = node.child_by_field_name("qualifier").ok_or_else(|| {
10709 ::treesitter_types::ParseError::missing_field("qualifier", node)
10710 })?;
10711 ::treesitter_types::runtime::maybe_grow_stack(|| {
10712 <QualifiedNameQualifier as ::treesitter_types::FromNode>::from_node(child, src)
10713 })?
10714 },
10715 })
10716 }
10717}
10718impl ::treesitter_types::Spanned for QualifiedName<'_> {
10719 fn span(&self) -> ::treesitter_types::Span {
10720 self.span
10721 }
10722}
10723#[derive(Debug, Clone, PartialEq, Eq)]
10724pub struct QueryExpression<'tree> {
10725 pub span: ::treesitter_types::Span,
10726 pub children: ::std::vec::Vec<QueryExpressionChildren<'tree>>,
10727}
10728impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpression<'tree> {
10729 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10730 fn from_node(
10731 node: ::treesitter_types::tree_sitter::Node<'tree>,
10732 src: &'tree [u8],
10733 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10734 debug_assert_eq!(node.kind(), "query_expression");
10735 Ok(Self {
10736 span: ::treesitter_types::Span::from(node),
10737 children: {
10738 #[allow(clippy::suspicious_else_formatting)]
10739 let non_field_children = {
10740 let mut cursor = node.walk();
10741 let mut result = ::std::vec::Vec::new();
10742 if cursor.goto_first_child() {
10743 loop {
10744 if cursor.field_name().is_none()
10745 && cursor.node().is_named()
10746 && !cursor.node().is_extra()
10747 {
10748 result.push(cursor.node());
10749 }
10750 if !cursor.goto_next_sibling() {
10751 break;
10752 }
10753 }
10754 }
10755 result
10756 };
10757 let mut items = ::std::vec::Vec::new();
10758 for child in non_field_children {
10759 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10760 <QueryExpressionChildren as ::treesitter_types::FromNode>::from_node(
10761 child, src,
10762 )
10763 })?);
10764 }
10765 items
10766 },
10767 })
10768 }
10769}
10770impl ::treesitter_types::Spanned for QueryExpression<'_> {
10771 fn span(&self) -> ::treesitter_types::Span {
10772 self.span
10773 }
10774}
10775#[derive(Debug, Clone, PartialEq, Eq)]
10776pub struct RangeExpression<'tree> {
10777 pub span: ::treesitter_types::Span,
10778 pub children: ::std::vec::Vec<Expression<'tree>>,
10779}
10780impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
10781 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10782 fn from_node(
10783 node: ::treesitter_types::tree_sitter::Node<'tree>,
10784 src: &'tree [u8],
10785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10786 debug_assert_eq!(node.kind(), "range_expression");
10787 Ok(Self {
10788 span: ::treesitter_types::Span::from(node),
10789 children: {
10790 #[allow(clippy::suspicious_else_formatting)]
10791 let non_field_children = {
10792 let mut cursor = node.walk();
10793 let mut result = ::std::vec::Vec::new();
10794 if cursor.goto_first_child() {
10795 loop {
10796 if cursor.field_name().is_none()
10797 && cursor.node().is_named()
10798 && !cursor.node().is_extra()
10799 {
10800 result.push(cursor.node());
10801 }
10802 if !cursor.goto_next_sibling() {
10803 break;
10804 }
10805 }
10806 }
10807 result
10808 };
10809 let mut items = ::std::vec::Vec::new();
10810 for child in non_field_children {
10811 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10812 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10813 })?);
10814 }
10815 items
10816 },
10817 })
10818 }
10819}
10820impl ::treesitter_types::Spanned for RangeExpression<'_> {
10821 fn span(&self) -> ::treesitter_types::Span {
10822 self.span
10823 }
10824}
10825#[derive(Debug, Clone, PartialEq, Eq)]
10826pub struct RawStringLiteral<'tree> {
10827 pub span: ::treesitter_types::Span,
10828 pub children: ::std::vec::Vec<RawStringLiteralChildren<'tree>>,
10829}
10830impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
10831 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10832 fn from_node(
10833 node: ::treesitter_types::tree_sitter::Node<'tree>,
10834 src: &'tree [u8],
10835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10836 debug_assert_eq!(node.kind(), "raw_string_literal");
10837 Ok(Self {
10838 span: ::treesitter_types::Span::from(node),
10839 children: {
10840 #[allow(clippy::suspicious_else_formatting)]
10841 let non_field_children = {
10842 let mut cursor = node.walk();
10843 let mut result = ::std::vec::Vec::new();
10844 if cursor.goto_first_child() {
10845 loop {
10846 if cursor.field_name().is_none()
10847 && cursor.node().is_named()
10848 && !cursor.node().is_extra()
10849 {
10850 result.push(cursor.node());
10851 }
10852 if !cursor.goto_next_sibling() {
10853 break;
10854 }
10855 }
10856 }
10857 result
10858 };
10859 let mut items = ::std::vec::Vec::new();
10860 for child in non_field_children {
10861 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10862 <RawStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
10863 child, src,
10864 )
10865 })?);
10866 }
10867 items
10868 },
10869 })
10870 }
10871}
10872impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
10873 fn span(&self) -> ::treesitter_types::Span {
10874 self.span
10875 }
10876}
10877#[derive(Debug, Clone, PartialEq, Eq)]
10878pub struct RecordDeclaration<'tree> {
10879 pub span: ::treesitter_types::Span,
10880 pub body: ::core::option::Option<DeclarationList<'tree>>,
10881 pub name: Identifier<'tree>,
10882 pub children: ::std::vec::Vec<RecordDeclarationChildren<'tree>>,
10883}
10884impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclaration<'tree> {
10885 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10886 fn from_node(
10887 node: ::treesitter_types::tree_sitter::Node<'tree>,
10888 src: &'tree [u8],
10889 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10890 debug_assert_eq!(node.kind(), "record_declaration");
10891 Ok(Self {
10892 span: ::treesitter_types::Span::from(node),
10893 body: match node.child_by_field_name("body") {
10894 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10895 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
10896 })?),
10897 None => None,
10898 },
10899 name: {
10900 let child = node
10901 .child_by_field_name("name")
10902 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10903 ::treesitter_types::runtime::maybe_grow_stack(|| {
10904 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10905 })?
10906 },
10907 children: {
10908 #[allow(clippy::suspicious_else_formatting)]
10909 let non_field_children = {
10910 let mut cursor = node.walk();
10911 let mut result = ::std::vec::Vec::new();
10912 if cursor.goto_first_child() {
10913 loop {
10914 if cursor.field_name().is_none()
10915 && cursor.node().is_named()
10916 && !cursor.node().is_extra()
10917 {
10918 result.push(cursor.node());
10919 }
10920 if !cursor.goto_next_sibling() {
10921 break;
10922 }
10923 }
10924 }
10925 result
10926 };
10927 let mut items = ::std::vec::Vec::new();
10928 for child in non_field_children {
10929 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10930 <RecordDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10931 child, src,
10932 )
10933 })?);
10934 }
10935 items
10936 },
10937 })
10938 }
10939}
10940impl ::treesitter_types::Spanned for RecordDeclaration<'_> {
10941 fn span(&self) -> ::treesitter_types::Span {
10942 self.span
10943 }
10944}
10945#[derive(Debug, Clone, PartialEq, Eq)]
10946pub struct RecursivePattern<'tree> {
10947 pub span: ::treesitter_types::Span,
10948 pub name: ::core::option::Option<Identifier<'tree>>,
10949 pub r#type: ::core::option::Option<Type<'tree>>,
10950 pub children: ::std::vec::Vec<RecursivePatternChildren<'tree>>,
10951}
10952impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePattern<'tree> {
10953 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10954 fn from_node(
10955 node: ::treesitter_types::tree_sitter::Node<'tree>,
10956 src: &'tree [u8],
10957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10958 debug_assert_eq!(node.kind(), "recursive_pattern");
10959 Ok(Self {
10960 span: ::treesitter_types::Span::from(node),
10961 name: match node.child_by_field_name("name") {
10962 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10963 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10964 })?),
10965 None => None,
10966 },
10967 r#type: match node.child_by_field_name("type") {
10968 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10969 <Type as ::treesitter_types::FromNode>::from_node(child, src)
10970 })?),
10971 None => None,
10972 },
10973 children: {
10974 #[allow(clippy::suspicious_else_formatting)]
10975 let non_field_children = {
10976 let mut cursor = node.walk();
10977 let mut result = ::std::vec::Vec::new();
10978 if cursor.goto_first_child() {
10979 loop {
10980 if cursor.field_name().is_none()
10981 && cursor.node().is_named()
10982 && !cursor.node().is_extra()
10983 {
10984 result.push(cursor.node());
10985 }
10986 if !cursor.goto_next_sibling() {
10987 break;
10988 }
10989 }
10990 }
10991 result
10992 };
10993 let mut items = ::std::vec::Vec::new();
10994 for child in non_field_children {
10995 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10996 <RecursivePatternChildren as ::treesitter_types::FromNode>::from_node(
10997 child, src,
10998 )
10999 })?);
11000 }
11001 items
11002 },
11003 })
11004 }
11005}
11006impl ::treesitter_types::Spanned for RecursivePattern<'_> {
11007 fn span(&self) -> ::treesitter_types::Span {
11008 self.span
11009 }
11010}
11011#[derive(Debug, Clone, PartialEq, Eq)]
11012pub struct RefExpression<'tree> {
11013 pub span: ::treesitter_types::Span,
11014 pub children: Expression<'tree>,
11015}
11016impl<'tree> ::treesitter_types::FromNode<'tree> for RefExpression<'tree> {
11017 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11018 fn from_node(
11019 node: ::treesitter_types::tree_sitter::Node<'tree>,
11020 src: &'tree [u8],
11021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11022 debug_assert_eq!(node.kind(), "ref_expression");
11023 Ok(Self {
11024 span: ::treesitter_types::Span::from(node),
11025 children: {
11026 #[allow(clippy::suspicious_else_formatting)]
11027 let non_field_children = {
11028 let mut cursor = node.walk();
11029 let mut result = ::std::vec::Vec::new();
11030 if cursor.goto_first_child() {
11031 loop {
11032 if cursor.field_name().is_none()
11033 && cursor.node().is_named()
11034 && !cursor.node().is_extra()
11035 {
11036 result.push(cursor.node());
11037 }
11038 if !cursor.goto_next_sibling() {
11039 break;
11040 }
11041 }
11042 }
11043 result
11044 };
11045 let child = if let Some(&c) = non_field_children.first() {
11046 c
11047 } else {
11048 let mut fallback_cursor = node.walk();
11049 let mut fallback_child = None;
11050 if fallback_cursor.goto_first_child() {
11051 loop {
11052 if fallback_cursor.field_name().is_none()
11053 && !fallback_cursor.node().is_extra()
11054 {
11055 let candidate = fallback_cursor.node();
11056 #[allow(clippy::needless_question_mark)]
11057 if (|| -> ::core::result::Result<
11058 _,
11059 ::treesitter_types::ParseError,
11060 > {
11061 let child = candidate;
11062 Ok(
11063 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11064 child,
11065 src,
11066 ))?,
11067 )
11068 })()
11069 .is_ok()
11070 {
11071 fallback_child = Some(candidate);
11072 break;
11073 }
11074 }
11075 if !fallback_cursor.goto_next_sibling() {
11076 break;
11077 }
11078 }
11079 }
11080 if fallback_child.is_none() {
11081 let mut cursor2 = node.walk();
11082 if cursor2.goto_first_child() {
11083 loop {
11084 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11085 let candidate = cursor2.node();
11086 #[allow(clippy::needless_question_mark)]
11087 if (|| -> ::core::result::Result<
11088 _,
11089 ::treesitter_types::ParseError,
11090 > {
11091 let child = candidate;
11092 Ok(
11093 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11094 child,
11095 src,
11096 ))?,
11097 )
11098 })()
11099 .is_ok()
11100 {
11101 fallback_child = Some(candidate);
11102 break;
11103 }
11104 }
11105 if !cursor2.goto_next_sibling() {
11106 break;
11107 }
11108 }
11109 }
11110 }
11111 fallback_child.ok_or_else(|| {
11112 ::treesitter_types::ParseError::missing_field("children", node)
11113 })?
11114 };
11115 ::treesitter_types::runtime::maybe_grow_stack(|| {
11116 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11117 })?
11118 },
11119 })
11120 }
11121}
11122impl ::treesitter_types::Spanned for RefExpression<'_> {
11123 fn span(&self) -> ::treesitter_types::Span {
11124 self.span
11125 }
11126}
11127#[derive(Debug, Clone, PartialEq, Eq)]
11128pub struct RefType<'tree> {
11129 pub span: ::treesitter_types::Span,
11130 pub r#type: Type<'tree>,
11131}
11132impl<'tree> ::treesitter_types::FromNode<'tree> for RefType<'tree> {
11133 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11134 fn from_node(
11135 node: ::treesitter_types::tree_sitter::Node<'tree>,
11136 src: &'tree [u8],
11137 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11138 debug_assert_eq!(node.kind(), "ref_type");
11139 Ok(Self {
11140 span: ::treesitter_types::Span::from(node),
11141 r#type: {
11142 let child = node
11143 .child_by_field_name("type")
11144 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11145 ::treesitter_types::runtime::maybe_grow_stack(|| {
11146 <Type as ::treesitter_types::FromNode>::from_node(child, src)
11147 })?
11148 },
11149 })
11150 }
11151}
11152impl ::treesitter_types::Spanned for RefType<'_> {
11153 fn span(&self) -> ::treesitter_types::Span {
11154 self.span
11155 }
11156}
11157#[derive(Debug, Clone, PartialEq, Eq)]
11158pub struct ReftypeExpression<'tree> {
11159 pub span: ::treesitter_types::Span,
11160 pub children: Expression<'tree>,
11161}
11162impl<'tree> ::treesitter_types::FromNode<'tree> for ReftypeExpression<'tree> {
11163 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11164 fn from_node(
11165 node: ::treesitter_types::tree_sitter::Node<'tree>,
11166 src: &'tree [u8],
11167 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11168 debug_assert_eq!(node.kind(), "reftype_expression");
11169 Ok(Self {
11170 span: ::treesitter_types::Span::from(node),
11171 children: {
11172 #[allow(clippy::suspicious_else_formatting)]
11173 let non_field_children = {
11174 let mut cursor = node.walk();
11175 let mut result = ::std::vec::Vec::new();
11176 if cursor.goto_first_child() {
11177 loop {
11178 if cursor.field_name().is_none()
11179 && cursor.node().is_named()
11180 && !cursor.node().is_extra()
11181 {
11182 result.push(cursor.node());
11183 }
11184 if !cursor.goto_next_sibling() {
11185 break;
11186 }
11187 }
11188 }
11189 result
11190 };
11191 let child = if let Some(&c) = non_field_children.first() {
11192 c
11193 } else {
11194 let mut fallback_cursor = node.walk();
11195 let mut fallback_child = None;
11196 if fallback_cursor.goto_first_child() {
11197 loop {
11198 if fallback_cursor.field_name().is_none()
11199 && !fallback_cursor.node().is_extra()
11200 {
11201 let candidate = fallback_cursor.node();
11202 #[allow(clippy::needless_question_mark)]
11203 if (|| -> ::core::result::Result<
11204 _,
11205 ::treesitter_types::ParseError,
11206 > {
11207 let child = candidate;
11208 Ok(
11209 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11210 child,
11211 src,
11212 ))?,
11213 )
11214 })()
11215 .is_ok()
11216 {
11217 fallback_child = Some(candidate);
11218 break;
11219 }
11220 }
11221 if !fallback_cursor.goto_next_sibling() {
11222 break;
11223 }
11224 }
11225 }
11226 if fallback_child.is_none() {
11227 let mut cursor2 = node.walk();
11228 if cursor2.goto_first_child() {
11229 loop {
11230 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11231 let candidate = cursor2.node();
11232 #[allow(clippy::needless_question_mark)]
11233 if (|| -> ::core::result::Result<
11234 _,
11235 ::treesitter_types::ParseError,
11236 > {
11237 let child = candidate;
11238 Ok(
11239 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11240 child,
11241 src,
11242 ))?,
11243 )
11244 })()
11245 .is_ok()
11246 {
11247 fallback_child = Some(candidate);
11248 break;
11249 }
11250 }
11251 if !cursor2.goto_next_sibling() {
11252 break;
11253 }
11254 }
11255 }
11256 }
11257 fallback_child.ok_or_else(|| {
11258 ::treesitter_types::ParseError::missing_field("children", node)
11259 })?
11260 };
11261 ::treesitter_types::runtime::maybe_grow_stack(|| {
11262 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11263 })?
11264 },
11265 })
11266 }
11267}
11268impl ::treesitter_types::Spanned for ReftypeExpression<'_> {
11269 fn span(&self) -> ::treesitter_types::Span {
11270 self.span
11271 }
11272}
11273#[derive(Debug, Clone, PartialEq, Eq)]
11274pub struct RefvalueExpression<'tree> {
11275 pub span: ::treesitter_types::Span,
11276 pub r#type: Type<'tree>,
11277 pub value: Expression<'tree>,
11278}
11279impl<'tree> ::treesitter_types::FromNode<'tree> for RefvalueExpression<'tree> {
11280 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11281 fn from_node(
11282 node: ::treesitter_types::tree_sitter::Node<'tree>,
11283 src: &'tree [u8],
11284 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11285 debug_assert_eq!(node.kind(), "refvalue_expression");
11286 Ok(Self {
11287 span: ::treesitter_types::Span::from(node),
11288 r#type: {
11289 let child = node
11290 .child_by_field_name("type")
11291 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11292 ::treesitter_types::runtime::maybe_grow_stack(|| {
11293 <Type as ::treesitter_types::FromNode>::from_node(child, src)
11294 })?
11295 },
11296 value: {
11297 let child = node
11298 .child_by_field_name("value")
11299 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
11300 ::treesitter_types::runtime::maybe_grow_stack(|| {
11301 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11302 })?
11303 },
11304 })
11305 }
11306}
11307impl ::treesitter_types::Spanned for RefvalueExpression<'_> {
11308 fn span(&self) -> ::treesitter_types::Span {
11309 self.span
11310 }
11311}
11312#[derive(Debug, Clone, PartialEq, Eq)]
11313pub struct RelationalPattern<'tree> {
11314 pub span: ::treesitter_types::Span,
11315 pub children: Expression<'tree>,
11316}
11317impl<'tree> ::treesitter_types::FromNode<'tree> for RelationalPattern<'tree> {
11318 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11319 fn from_node(
11320 node: ::treesitter_types::tree_sitter::Node<'tree>,
11321 src: &'tree [u8],
11322 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11323 debug_assert_eq!(node.kind(), "relational_pattern");
11324 Ok(Self {
11325 span: ::treesitter_types::Span::from(node),
11326 children: {
11327 #[allow(clippy::suspicious_else_formatting)]
11328 let non_field_children = {
11329 let mut cursor = node.walk();
11330 let mut result = ::std::vec::Vec::new();
11331 if cursor.goto_first_child() {
11332 loop {
11333 if cursor.field_name().is_none()
11334 && cursor.node().is_named()
11335 && !cursor.node().is_extra()
11336 {
11337 result.push(cursor.node());
11338 }
11339 if !cursor.goto_next_sibling() {
11340 break;
11341 }
11342 }
11343 }
11344 result
11345 };
11346 let child = if let Some(&c) = non_field_children.first() {
11347 c
11348 } else {
11349 let mut fallback_cursor = node.walk();
11350 let mut fallback_child = None;
11351 if fallback_cursor.goto_first_child() {
11352 loop {
11353 if fallback_cursor.field_name().is_none()
11354 && !fallback_cursor.node().is_extra()
11355 {
11356 let candidate = fallback_cursor.node();
11357 #[allow(clippy::needless_question_mark)]
11358 if (|| -> ::core::result::Result<
11359 _,
11360 ::treesitter_types::ParseError,
11361 > {
11362 let child = candidate;
11363 Ok(
11364 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11365 child,
11366 src,
11367 ))?,
11368 )
11369 })()
11370 .is_ok()
11371 {
11372 fallback_child = Some(candidate);
11373 break;
11374 }
11375 }
11376 if !fallback_cursor.goto_next_sibling() {
11377 break;
11378 }
11379 }
11380 }
11381 if fallback_child.is_none() {
11382 let mut cursor2 = node.walk();
11383 if cursor2.goto_first_child() {
11384 loop {
11385 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11386 let candidate = cursor2.node();
11387 #[allow(clippy::needless_question_mark)]
11388 if (|| -> ::core::result::Result<
11389 _,
11390 ::treesitter_types::ParseError,
11391 > {
11392 let child = candidate;
11393 Ok(
11394 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11395 child,
11396 src,
11397 ))?,
11398 )
11399 })()
11400 .is_ok()
11401 {
11402 fallback_child = Some(candidate);
11403 break;
11404 }
11405 }
11406 if !cursor2.goto_next_sibling() {
11407 break;
11408 }
11409 }
11410 }
11411 }
11412 fallback_child.ok_or_else(|| {
11413 ::treesitter_types::ParseError::missing_field("children", node)
11414 })?
11415 };
11416 ::treesitter_types::runtime::maybe_grow_stack(|| {
11417 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11418 })?
11419 },
11420 })
11421 }
11422}
11423impl ::treesitter_types::Spanned for RelationalPattern<'_> {
11424 fn span(&self) -> ::treesitter_types::Span {
11425 self.span
11426 }
11427}
11428#[derive(Debug, Clone, PartialEq, Eq)]
11429pub struct ReturnStatement<'tree> {
11430 pub span: ::treesitter_types::Span,
11431 pub children: ::core::option::Option<Expression<'tree>>,
11432}
11433impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
11434 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11435 fn from_node(
11436 node: ::treesitter_types::tree_sitter::Node<'tree>,
11437 src: &'tree [u8],
11438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11439 debug_assert_eq!(node.kind(), "return_statement");
11440 Ok(Self {
11441 span: ::treesitter_types::Span::from(node),
11442 children: {
11443 #[allow(clippy::suspicious_else_formatting)]
11444 let non_field_children = {
11445 let mut cursor = node.walk();
11446 let mut result = ::std::vec::Vec::new();
11447 if cursor.goto_first_child() {
11448 loop {
11449 if cursor.field_name().is_none()
11450 && cursor.node().is_named()
11451 && !cursor.node().is_extra()
11452 {
11453 result.push(cursor.node());
11454 }
11455 if !cursor.goto_next_sibling() {
11456 break;
11457 }
11458 }
11459 }
11460 result
11461 };
11462 match non_field_children.first() {
11463 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11464 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11465 })?),
11466 None => None,
11467 }
11468 },
11469 })
11470 }
11471}
11472impl ::treesitter_types::Spanned for ReturnStatement<'_> {
11473 fn span(&self) -> ::treesitter_types::Span {
11474 self.span
11475 }
11476}
11477#[derive(Debug, Clone, PartialEq, Eq)]
11478pub struct ScopedType<'tree> {
11479 pub span: ::treesitter_types::Span,
11480 pub r#type: ScopedTypeType<'tree>,
11481}
11482impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedType<'tree> {
11483 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11484 fn from_node(
11485 node: ::treesitter_types::tree_sitter::Node<'tree>,
11486 src: &'tree [u8],
11487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11488 debug_assert_eq!(node.kind(), "scoped_type");
11489 Ok(Self {
11490 span: ::treesitter_types::Span::from(node),
11491 r#type: {
11492 let child = node
11493 .child_by_field_name("type")
11494 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11495 ::treesitter_types::runtime::maybe_grow_stack(|| {
11496 <ScopedTypeType as ::treesitter_types::FromNode>::from_node(child, src)
11497 })?
11498 },
11499 })
11500 }
11501}
11502impl ::treesitter_types::Spanned for ScopedType<'_> {
11503 fn span(&self) -> ::treesitter_types::Span {
11504 self.span
11505 }
11506}
11507#[derive(Debug, Clone, PartialEq, Eq)]
11508pub struct SelectClause<'tree> {
11509 pub span: ::treesitter_types::Span,
11510 pub children: Expression<'tree>,
11511}
11512impl<'tree> ::treesitter_types::FromNode<'tree> for SelectClause<'tree> {
11513 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11514 fn from_node(
11515 node: ::treesitter_types::tree_sitter::Node<'tree>,
11516 src: &'tree [u8],
11517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11518 debug_assert_eq!(node.kind(), "select_clause");
11519 Ok(Self {
11520 span: ::treesitter_types::Span::from(node),
11521 children: {
11522 #[allow(clippy::suspicious_else_formatting)]
11523 let non_field_children = {
11524 let mut cursor = node.walk();
11525 let mut result = ::std::vec::Vec::new();
11526 if cursor.goto_first_child() {
11527 loop {
11528 if cursor.field_name().is_none()
11529 && cursor.node().is_named()
11530 && !cursor.node().is_extra()
11531 {
11532 result.push(cursor.node());
11533 }
11534 if !cursor.goto_next_sibling() {
11535 break;
11536 }
11537 }
11538 }
11539 result
11540 };
11541 let child = if let Some(&c) = non_field_children.first() {
11542 c
11543 } else {
11544 let mut fallback_cursor = node.walk();
11545 let mut fallback_child = None;
11546 if fallback_cursor.goto_first_child() {
11547 loop {
11548 if fallback_cursor.field_name().is_none()
11549 && !fallback_cursor.node().is_extra()
11550 {
11551 let candidate = fallback_cursor.node();
11552 #[allow(clippy::needless_question_mark)]
11553 if (|| -> ::core::result::Result<
11554 _,
11555 ::treesitter_types::ParseError,
11556 > {
11557 let child = candidate;
11558 Ok(
11559 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11560 child,
11561 src,
11562 ))?,
11563 )
11564 })()
11565 .is_ok()
11566 {
11567 fallback_child = Some(candidate);
11568 break;
11569 }
11570 }
11571 if !fallback_cursor.goto_next_sibling() {
11572 break;
11573 }
11574 }
11575 }
11576 if fallback_child.is_none() {
11577 let mut cursor2 = node.walk();
11578 if cursor2.goto_first_child() {
11579 loop {
11580 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11581 let candidate = cursor2.node();
11582 #[allow(clippy::needless_question_mark)]
11583 if (|| -> ::core::result::Result<
11584 _,
11585 ::treesitter_types::ParseError,
11586 > {
11587 let child = candidate;
11588 Ok(
11589 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11590 child,
11591 src,
11592 ))?,
11593 )
11594 })()
11595 .is_ok()
11596 {
11597 fallback_child = Some(candidate);
11598 break;
11599 }
11600 }
11601 if !cursor2.goto_next_sibling() {
11602 break;
11603 }
11604 }
11605 }
11606 }
11607 fallback_child.ok_or_else(|| {
11608 ::treesitter_types::ParseError::missing_field("children", node)
11609 })?
11610 };
11611 ::treesitter_types::runtime::maybe_grow_stack(|| {
11612 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11613 })?
11614 },
11615 })
11616 }
11617}
11618impl ::treesitter_types::Spanned for SelectClause<'_> {
11619 fn span(&self) -> ::treesitter_types::Span {
11620 self.span
11621 }
11622}
11623#[derive(Debug, Clone, PartialEq, Eq)]
11624pub struct SizeofExpression<'tree> {
11625 pub span: ::treesitter_types::Span,
11626 pub r#type: Type<'tree>,
11627}
11628impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
11629 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11630 fn from_node(
11631 node: ::treesitter_types::tree_sitter::Node<'tree>,
11632 src: &'tree [u8],
11633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11634 debug_assert_eq!(node.kind(), "sizeof_expression");
11635 Ok(Self {
11636 span: ::treesitter_types::Span::from(node),
11637 r#type: {
11638 let child = node
11639 .child_by_field_name("type")
11640 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11641 ::treesitter_types::runtime::maybe_grow_stack(|| {
11642 <Type as ::treesitter_types::FromNode>::from_node(child, src)
11643 })?
11644 },
11645 })
11646 }
11647}
11648impl ::treesitter_types::Spanned for SizeofExpression<'_> {
11649 fn span(&self) -> ::treesitter_types::Span {
11650 self.span
11651 }
11652}
11653#[derive(Debug, Clone, PartialEq, Eq)]
11654pub struct SpreadElement<'tree> {
11655 pub span: ::treesitter_types::Span,
11656 pub children: Expression<'tree>,
11657}
11658impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadElement<'tree> {
11659 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11660 fn from_node(
11661 node: ::treesitter_types::tree_sitter::Node<'tree>,
11662 src: &'tree [u8],
11663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11664 debug_assert_eq!(node.kind(), "spread_element");
11665 Ok(Self {
11666 span: ::treesitter_types::Span::from(node),
11667 children: {
11668 #[allow(clippy::suspicious_else_formatting)]
11669 let non_field_children = {
11670 let mut cursor = node.walk();
11671 let mut result = ::std::vec::Vec::new();
11672 if cursor.goto_first_child() {
11673 loop {
11674 if cursor.field_name().is_none()
11675 && cursor.node().is_named()
11676 && !cursor.node().is_extra()
11677 {
11678 result.push(cursor.node());
11679 }
11680 if !cursor.goto_next_sibling() {
11681 break;
11682 }
11683 }
11684 }
11685 result
11686 };
11687 let child = if let Some(&c) = non_field_children.first() {
11688 c
11689 } else {
11690 let mut fallback_cursor = node.walk();
11691 let mut fallback_child = None;
11692 if fallback_cursor.goto_first_child() {
11693 loop {
11694 if fallback_cursor.field_name().is_none()
11695 && !fallback_cursor.node().is_extra()
11696 {
11697 let candidate = fallback_cursor.node();
11698 #[allow(clippy::needless_question_mark)]
11699 if (|| -> ::core::result::Result<
11700 _,
11701 ::treesitter_types::ParseError,
11702 > {
11703 let child = candidate;
11704 Ok(
11705 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11706 child,
11707 src,
11708 ))?,
11709 )
11710 })()
11711 .is_ok()
11712 {
11713 fallback_child = Some(candidate);
11714 break;
11715 }
11716 }
11717 if !fallback_cursor.goto_next_sibling() {
11718 break;
11719 }
11720 }
11721 }
11722 if fallback_child.is_none() {
11723 let mut cursor2 = node.walk();
11724 if cursor2.goto_first_child() {
11725 loop {
11726 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11727 let candidate = cursor2.node();
11728 #[allow(clippy::needless_question_mark)]
11729 if (|| -> ::core::result::Result<
11730 _,
11731 ::treesitter_types::ParseError,
11732 > {
11733 let child = candidate;
11734 Ok(
11735 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
11736 child,
11737 src,
11738 ))?,
11739 )
11740 })()
11741 .is_ok()
11742 {
11743 fallback_child = Some(candidate);
11744 break;
11745 }
11746 }
11747 if !cursor2.goto_next_sibling() {
11748 break;
11749 }
11750 }
11751 }
11752 }
11753 fallback_child.ok_or_else(|| {
11754 ::treesitter_types::ParseError::missing_field("children", node)
11755 })?
11756 };
11757 ::treesitter_types::runtime::maybe_grow_stack(|| {
11758 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11759 })?
11760 },
11761 })
11762 }
11763}
11764impl ::treesitter_types::Spanned for SpreadElement<'_> {
11765 fn span(&self) -> ::treesitter_types::Span {
11766 self.span
11767 }
11768}
11769#[derive(Debug, Clone, PartialEq, Eq)]
11770pub struct StackallocExpression<'tree> {
11771 pub span: ::treesitter_types::Span,
11772 pub r#type: ArrayType<'tree>,
11773 pub children: ::core::option::Option<InitializerExpression<'tree>>,
11774}
11775impl<'tree> ::treesitter_types::FromNode<'tree> for StackallocExpression<'tree> {
11776 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11777 fn from_node(
11778 node: ::treesitter_types::tree_sitter::Node<'tree>,
11779 src: &'tree [u8],
11780 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11781 debug_assert_eq!(node.kind(), "stackalloc_expression");
11782 Ok(Self {
11783 span: ::treesitter_types::Span::from(node),
11784 r#type: {
11785 let child = node
11786 .child_by_field_name("type")
11787 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11788 ::treesitter_types::runtime::maybe_grow_stack(|| {
11789 <ArrayType as ::treesitter_types::FromNode>::from_node(child, src)
11790 })?
11791 },
11792 children: {
11793 #[allow(clippy::suspicious_else_formatting)]
11794 let non_field_children = {
11795 let mut cursor = node.walk();
11796 let mut result = ::std::vec::Vec::new();
11797 if cursor.goto_first_child() {
11798 loop {
11799 if cursor.field_name().is_none()
11800 && cursor.node().is_named()
11801 && !cursor.node().is_extra()
11802 {
11803 result.push(cursor.node());
11804 }
11805 if !cursor.goto_next_sibling() {
11806 break;
11807 }
11808 }
11809 }
11810 result
11811 };
11812 match non_field_children.first() {
11813 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11814 <InitializerExpression as ::treesitter_types::FromNode>::from_node(
11815 child, src,
11816 )
11817 })?),
11818 None => None,
11819 }
11820 },
11821 })
11822 }
11823}
11824impl ::treesitter_types::Spanned for StackallocExpression<'_> {
11825 fn span(&self) -> ::treesitter_types::Span {
11826 self.span
11827 }
11828}
11829#[derive(Debug, Clone, PartialEq, Eq)]
11830pub struct StringLiteral<'tree> {
11831 pub span: ::treesitter_types::Span,
11832 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
11833}
11834impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
11835 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11836 fn from_node(
11837 node: ::treesitter_types::tree_sitter::Node<'tree>,
11838 src: &'tree [u8],
11839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11840 debug_assert_eq!(node.kind(), "string_literal");
11841 Ok(Self {
11842 span: ::treesitter_types::Span::from(node),
11843 children: {
11844 #[allow(clippy::suspicious_else_formatting)]
11845 let non_field_children = {
11846 let mut cursor = node.walk();
11847 let mut result = ::std::vec::Vec::new();
11848 if cursor.goto_first_child() {
11849 loop {
11850 if cursor.field_name().is_none()
11851 && cursor.node().is_named()
11852 && !cursor.node().is_extra()
11853 {
11854 result.push(cursor.node());
11855 }
11856 if !cursor.goto_next_sibling() {
11857 break;
11858 }
11859 }
11860 }
11861 result
11862 };
11863 let mut items = ::std::vec::Vec::new();
11864 for child in non_field_children {
11865 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11866 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
11867 child, src,
11868 )
11869 })?);
11870 }
11871 items
11872 },
11873 })
11874 }
11875}
11876impl ::treesitter_types::Spanned for StringLiteral<'_> {
11877 fn span(&self) -> ::treesitter_types::Span {
11878 self.span
11879 }
11880}
11881#[derive(Debug, Clone, PartialEq, Eq)]
11882pub struct StructDeclaration<'tree> {
11883 pub span: ::treesitter_types::Span,
11884 pub body: ::core::option::Option<DeclarationList<'tree>>,
11885 pub name: Identifier<'tree>,
11886 pub children: ::std::vec::Vec<StructDeclarationChildren<'tree>>,
11887}
11888impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclaration<'tree> {
11889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11890 fn from_node(
11891 node: ::treesitter_types::tree_sitter::Node<'tree>,
11892 src: &'tree [u8],
11893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11894 debug_assert_eq!(node.kind(), "struct_declaration");
11895 Ok(Self {
11896 span: ::treesitter_types::Span::from(node),
11897 body: match node.child_by_field_name("body") {
11898 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11899 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
11900 })?),
11901 None => None,
11902 },
11903 name: {
11904 let child = node
11905 .child_by_field_name("name")
11906 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
11907 ::treesitter_types::runtime::maybe_grow_stack(|| {
11908 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
11909 })?
11910 },
11911 children: {
11912 #[allow(clippy::suspicious_else_formatting)]
11913 let non_field_children = {
11914 let mut cursor = node.walk();
11915 let mut result = ::std::vec::Vec::new();
11916 if cursor.goto_first_child() {
11917 loop {
11918 if cursor.field_name().is_none()
11919 && cursor.node().is_named()
11920 && !cursor.node().is_extra()
11921 {
11922 result.push(cursor.node());
11923 }
11924 if !cursor.goto_next_sibling() {
11925 break;
11926 }
11927 }
11928 }
11929 result
11930 };
11931 let mut items = ::std::vec::Vec::new();
11932 for child in non_field_children {
11933 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11934 <StructDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11935 child, src,
11936 )
11937 })?);
11938 }
11939 items
11940 },
11941 })
11942 }
11943}
11944impl ::treesitter_types::Spanned for StructDeclaration<'_> {
11945 fn span(&self) -> ::treesitter_types::Span {
11946 self.span
11947 }
11948}
11949#[derive(Debug, Clone, PartialEq, Eq)]
11950pub struct Subpattern<'tree> {
11951 pub span: ::treesitter_types::Span,
11952 pub children: ::std::vec::Vec<SubpatternChildren<'tree>>,
11953}
11954impl<'tree> ::treesitter_types::FromNode<'tree> for Subpattern<'tree> {
11955 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11956 fn from_node(
11957 node: ::treesitter_types::tree_sitter::Node<'tree>,
11958 src: &'tree [u8],
11959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11960 debug_assert_eq!(node.kind(), "subpattern");
11961 Ok(Self {
11962 span: ::treesitter_types::Span::from(node),
11963 children: {
11964 #[allow(clippy::suspicious_else_formatting)]
11965 let non_field_children = {
11966 let mut cursor = node.walk();
11967 let mut result = ::std::vec::Vec::new();
11968 if cursor.goto_first_child() {
11969 loop {
11970 if cursor.field_name().is_none()
11971 && cursor.node().is_named()
11972 && !cursor.node().is_extra()
11973 {
11974 result.push(cursor.node());
11975 }
11976 if !cursor.goto_next_sibling() {
11977 break;
11978 }
11979 }
11980 }
11981 result
11982 };
11983 let mut items = ::std::vec::Vec::new();
11984 for child in non_field_children {
11985 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11986 <SubpatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
11987 })?);
11988 }
11989 items
11990 },
11991 })
11992 }
11993}
11994impl ::treesitter_types::Spanned for Subpattern<'_> {
11995 fn span(&self) -> ::treesitter_types::Span {
11996 self.span
11997 }
11998}
11999#[derive(Debug, Clone, PartialEq, Eq)]
12000pub struct SwitchBody<'tree> {
12001 pub span: ::treesitter_types::Span,
12002 pub children: ::std::vec::Vec<SwitchSection<'tree>>,
12003}
12004impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
12005 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12006 fn from_node(
12007 node: ::treesitter_types::tree_sitter::Node<'tree>,
12008 src: &'tree [u8],
12009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12010 debug_assert_eq!(node.kind(), "switch_body");
12011 Ok(Self {
12012 span: ::treesitter_types::Span::from(node),
12013 children: {
12014 #[allow(clippy::suspicious_else_formatting)]
12015 let non_field_children = {
12016 let mut cursor = node.walk();
12017 let mut result = ::std::vec::Vec::new();
12018 if cursor.goto_first_child() {
12019 loop {
12020 if cursor.field_name().is_none()
12021 && cursor.node().is_named()
12022 && !cursor.node().is_extra()
12023 {
12024 result.push(cursor.node());
12025 }
12026 if !cursor.goto_next_sibling() {
12027 break;
12028 }
12029 }
12030 }
12031 result
12032 };
12033 let mut items = ::std::vec::Vec::new();
12034 for child in non_field_children {
12035 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12036 <SwitchSection as ::treesitter_types::FromNode>::from_node(child, src)
12037 })?);
12038 }
12039 items
12040 },
12041 })
12042 }
12043}
12044impl ::treesitter_types::Spanned for SwitchBody<'_> {
12045 fn span(&self) -> ::treesitter_types::Span {
12046 self.span
12047 }
12048}
12049#[derive(Debug, Clone, PartialEq, Eq)]
12050pub struct SwitchExpression<'tree> {
12051 pub span: ::treesitter_types::Span,
12052 pub children: ::std::vec::Vec<SwitchExpressionChildren<'tree>>,
12053}
12054impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpression<'tree> {
12055 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12056 fn from_node(
12057 node: ::treesitter_types::tree_sitter::Node<'tree>,
12058 src: &'tree [u8],
12059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12060 debug_assert_eq!(node.kind(), "switch_expression");
12061 Ok(Self {
12062 span: ::treesitter_types::Span::from(node),
12063 children: {
12064 #[allow(clippy::suspicious_else_formatting)]
12065 let non_field_children = {
12066 let mut cursor = node.walk();
12067 let mut result = ::std::vec::Vec::new();
12068 if cursor.goto_first_child() {
12069 loop {
12070 if cursor.field_name().is_none()
12071 && cursor.node().is_named()
12072 && !cursor.node().is_extra()
12073 {
12074 result.push(cursor.node());
12075 }
12076 if !cursor.goto_next_sibling() {
12077 break;
12078 }
12079 }
12080 }
12081 result
12082 };
12083 let mut items = ::std::vec::Vec::new();
12084 for child in non_field_children {
12085 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12086 <SwitchExpressionChildren as ::treesitter_types::FromNode>::from_node(
12087 child, src,
12088 )
12089 })?);
12090 }
12091 items
12092 },
12093 })
12094 }
12095}
12096impl ::treesitter_types::Spanned for SwitchExpression<'_> {
12097 fn span(&self) -> ::treesitter_types::Span {
12098 self.span
12099 }
12100}
12101#[derive(Debug, Clone, PartialEq, Eq)]
12102pub struct SwitchExpressionArm<'tree> {
12103 pub span: ::treesitter_types::Span,
12104 pub children: ::std::vec::Vec<SwitchExpressionArmChildren<'tree>>,
12105}
12106impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArm<'tree> {
12107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12108 fn from_node(
12109 node: ::treesitter_types::tree_sitter::Node<'tree>,
12110 src: &'tree [u8],
12111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12112 debug_assert_eq!(node.kind(), "switch_expression_arm");
12113 Ok(Self {
12114 span: ::treesitter_types::Span::from(node),
12115 children: {
12116 #[allow(clippy::suspicious_else_formatting)]
12117 let non_field_children = {
12118 let mut cursor = node.walk();
12119 let mut result = ::std::vec::Vec::new();
12120 if cursor.goto_first_child() {
12121 loop {
12122 if cursor.field_name().is_none()
12123 && cursor.node().is_named()
12124 && !cursor.node().is_extra()
12125 {
12126 result.push(cursor.node());
12127 }
12128 if !cursor.goto_next_sibling() {
12129 break;
12130 }
12131 }
12132 }
12133 result
12134 };
12135 let mut items = ::std::vec::Vec::new();
12136 for child in non_field_children {
12137 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12138 <SwitchExpressionArmChildren as ::treesitter_types::FromNode>::from_node(
12139 child, src,
12140 )
12141 })?);
12142 }
12143 items
12144 },
12145 })
12146 }
12147}
12148impl ::treesitter_types::Spanned for SwitchExpressionArm<'_> {
12149 fn span(&self) -> ::treesitter_types::Span {
12150 self.span
12151 }
12152}
12153#[derive(Debug, Clone, PartialEq, Eq)]
12154pub struct SwitchSection<'tree> {
12155 pub span: ::treesitter_types::Span,
12156 pub children: ::std::vec::Vec<SwitchSectionChildren<'tree>>,
12157}
12158impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSection<'tree> {
12159 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12160 fn from_node(
12161 node: ::treesitter_types::tree_sitter::Node<'tree>,
12162 src: &'tree [u8],
12163 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12164 debug_assert_eq!(node.kind(), "switch_section");
12165 Ok(Self {
12166 span: ::treesitter_types::Span::from(node),
12167 children: {
12168 #[allow(clippy::suspicious_else_formatting)]
12169 let non_field_children = {
12170 let mut cursor = node.walk();
12171 let mut result = ::std::vec::Vec::new();
12172 if cursor.goto_first_child() {
12173 loop {
12174 if cursor.field_name().is_none()
12175 && cursor.node().is_named()
12176 && !cursor.node().is_extra()
12177 {
12178 result.push(cursor.node());
12179 }
12180 if !cursor.goto_next_sibling() {
12181 break;
12182 }
12183 }
12184 }
12185 result
12186 };
12187 let mut items = ::std::vec::Vec::new();
12188 for child in non_field_children {
12189 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12190 <SwitchSectionChildren as ::treesitter_types::FromNode>::from_node(
12191 child, src,
12192 )
12193 })?);
12194 }
12195 items
12196 },
12197 })
12198 }
12199}
12200impl ::treesitter_types::Spanned for SwitchSection<'_> {
12201 fn span(&self) -> ::treesitter_types::Span {
12202 self.span
12203 }
12204}
12205#[derive(Debug, Clone, PartialEq, Eq)]
12206pub struct SwitchStatement<'tree> {
12207 pub span: ::treesitter_types::Span,
12208 pub body: SwitchBody<'tree>,
12209 pub value: SwitchStatementValue<'tree>,
12210}
12211impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
12212 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12213 fn from_node(
12214 node: ::treesitter_types::tree_sitter::Node<'tree>,
12215 src: &'tree [u8],
12216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12217 debug_assert_eq!(node.kind(), "switch_statement");
12218 Ok(Self {
12219 span: ::treesitter_types::Span::from(node),
12220 body: {
12221 let child = node
12222 .child_by_field_name("body")
12223 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
12224 ::treesitter_types::runtime::maybe_grow_stack(|| {
12225 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)
12226 })?
12227 },
12228 value: {
12229 let child = node
12230 .child_by_field_name("value")
12231 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
12232 ::treesitter_types::runtime::maybe_grow_stack(|| {
12233 <SwitchStatementValue as ::treesitter_types::FromNode>::from_node(child, src)
12234 })?
12235 },
12236 })
12237 }
12238}
12239impl ::treesitter_types::Spanned for SwitchStatement<'_> {
12240 fn span(&self) -> ::treesitter_types::Span {
12241 self.span
12242 }
12243}
12244#[derive(Debug, Clone, PartialEq, Eq)]
12245pub struct ThrowExpression<'tree> {
12246 pub span: ::treesitter_types::Span,
12247 pub children: Expression<'tree>,
12248}
12249impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowExpression<'tree> {
12250 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12251 fn from_node(
12252 node: ::treesitter_types::tree_sitter::Node<'tree>,
12253 src: &'tree [u8],
12254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12255 debug_assert_eq!(node.kind(), "throw_expression");
12256 Ok(Self {
12257 span: ::treesitter_types::Span::from(node),
12258 children: {
12259 #[allow(clippy::suspicious_else_formatting)]
12260 let non_field_children = {
12261 let mut cursor = node.walk();
12262 let mut result = ::std::vec::Vec::new();
12263 if cursor.goto_first_child() {
12264 loop {
12265 if cursor.field_name().is_none()
12266 && cursor.node().is_named()
12267 && !cursor.node().is_extra()
12268 {
12269 result.push(cursor.node());
12270 }
12271 if !cursor.goto_next_sibling() {
12272 break;
12273 }
12274 }
12275 }
12276 result
12277 };
12278 let child = if let Some(&c) = non_field_children.first() {
12279 c
12280 } else {
12281 let mut fallback_cursor = node.walk();
12282 let mut fallback_child = None;
12283 if fallback_cursor.goto_first_child() {
12284 loop {
12285 if fallback_cursor.field_name().is_none()
12286 && !fallback_cursor.node().is_extra()
12287 {
12288 let candidate = fallback_cursor.node();
12289 #[allow(clippy::needless_question_mark)]
12290 if (|| -> ::core::result::Result<
12291 _,
12292 ::treesitter_types::ParseError,
12293 > {
12294 let child = candidate;
12295 Ok(
12296 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
12297 child,
12298 src,
12299 ))?,
12300 )
12301 })()
12302 .is_ok()
12303 {
12304 fallback_child = Some(candidate);
12305 break;
12306 }
12307 }
12308 if !fallback_cursor.goto_next_sibling() {
12309 break;
12310 }
12311 }
12312 }
12313 if fallback_child.is_none() {
12314 let mut cursor2 = node.walk();
12315 if cursor2.goto_first_child() {
12316 loop {
12317 if cursor2.node().is_named() && !cursor2.node().is_extra() {
12318 let candidate = cursor2.node();
12319 #[allow(clippy::needless_question_mark)]
12320 if (|| -> ::core::result::Result<
12321 _,
12322 ::treesitter_types::ParseError,
12323 > {
12324 let child = candidate;
12325 Ok(
12326 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
12327 child,
12328 src,
12329 ))?,
12330 )
12331 })()
12332 .is_ok()
12333 {
12334 fallback_child = Some(candidate);
12335 break;
12336 }
12337 }
12338 if !cursor2.goto_next_sibling() {
12339 break;
12340 }
12341 }
12342 }
12343 }
12344 fallback_child.ok_or_else(|| {
12345 ::treesitter_types::ParseError::missing_field("children", node)
12346 })?
12347 };
12348 ::treesitter_types::runtime::maybe_grow_stack(|| {
12349 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
12350 })?
12351 },
12352 })
12353 }
12354}
12355impl ::treesitter_types::Spanned for ThrowExpression<'_> {
12356 fn span(&self) -> ::treesitter_types::Span {
12357 self.span
12358 }
12359}
12360#[derive(Debug, Clone, PartialEq, Eq)]
12361pub struct ThrowStatement<'tree> {
12362 pub span: ::treesitter_types::Span,
12363 pub children: ::core::option::Option<Expression<'tree>>,
12364}
12365impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
12366 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12367 fn from_node(
12368 node: ::treesitter_types::tree_sitter::Node<'tree>,
12369 src: &'tree [u8],
12370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12371 debug_assert_eq!(node.kind(), "throw_statement");
12372 Ok(Self {
12373 span: ::treesitter_types::Span::from(node),
12374 children: {
12375 #[allow(clippy::suspicious_else_formatting)]
12376 let non_field_children = {
12377 let mut cursor = node.walk();
12378 let mut result = ::std::vec::Vec::new();
12379 if cursor.goto_first_child() {
12380 loop {
12381 if cursor.field_name().is_none()
12382 && cursor.node().is_named()
12383 && !cursor.node().is_extra()
12384 {
12385 result.push(cursor.node());
12386 }
12387 if !cursor.goto_next_sibling() {
12388 break;
12389 }
12390 }
12391 }
12392 result
12393 };
12394 match non_field_children.first() {
12395 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12396 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
12397 })?),
12398 None => None,
12399 }
12400 },
12401 })
12402 }
12403}
12404impl ::treesitter_types::Spanned for ThrowStatement<'_> {
12405 fn span(&self) -> ::treesitter_types::Span {
12406 self.span
12407 }
12408}
12409#[derive(Debug, Clone, PartialEq, Eq)]
12410pub struct TryStatement<'tree> {
12411 pub span: ::treesitter_types::Span,
12412 pub body: Block<'tree>,
12413 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
12414}
12415impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
12416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12417 fn from_node(
12418 node: ::treesitter_types::tree_sitter::Node<'tree>,
12419 src: &'tree [u8],
12420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12421 debug_assert_eq!(node.kind(), "try_statement");
12422 Ok(Self {
12423 span: ::treesitter_types::Span::from(node),
12424 body: {
12425 let child = node
12426 .child_by_field_name("body")
12427 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
12428 ::treesitter_types::runtime::maybe_grow_stack(|| {
12429 <Block as ::treesitter_types::FromNode>::from_node(child, src)
12430 })?
12431 },
12432 children: {
12433 #[allow(clippy::suspicious_else_formatting)]
12434 let non_field_children = {
12435 let mut cursor = node.walk();
12436 let mut result = ::std::vec::Vec::new();
12437 if cursor.goto_first_child() {
12438 loop {
12439 if cursor.field_name().is_none()
12440 && cursor.node().is_named()
12441 && !cursor.node().is_extra()
12442 {
12443 result.push(cursor.node());
12444 }
12445 if !cursor.goto_next_sibling() {
12446 break;
12447 }
12448 }
12449 }
12450 result
12451 };
12452 let mut items = ::std::vec::Vec::new();
12453 for child in non_field_children {
12454 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12455 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
12456 child, src,
12457 )
12458 })?);
12459 }
12460 items
12461 },
12462 })
12463 }
12464}
12465impl ::treesitter_types::Spanned for TryStatement<'_> {
12466 fn span(&self) -> ::treesitter_types::Span {
12467 self.span
12468 }
12469}
12470#[derive(Debug, Clone, PartialEq, Eq)]
12471pub struct TupleElement<'tree> {
12472 pub span: ::treesitter_types::Span,
12473 pub name: ::core::option::Option<Identifier<'tree>>,
12474 pub r#type: Type<'tree>,
12475}
12476impl<'tree> ::treesitter_types::FromNode<'tree> for TupleElement<'tree> {
12477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12478 fn from_node(
12479 node: ::treesitter_types::tree_sitter::Node<'tree>,
12480 src: &'tree [u8],
12481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12482 debug_assert_eq!(node.kind(), "tuple_element");
12483 Ok(Self {
12484 span: ::treesitter_types::Span::from(node),
12485 name: match node.child_by_field_name("name") {
12486 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12487 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12488 })?),
12489 None => None,
12490 },
12491 r#type: {
12492 let child = node
12493 .child_by_field_name("type")
12494 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12495 ::treesitter_types::runtime::maybe_grow_stack(|| {
12496 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12497 })?
12498 },
12499 })
12500 }
12501}
12502impl ::treesitter_types::Spanned for TupleElement<'_> {
12503 fn span(&self) -> ::treesitter_types::Span {
12504 self.span
12505 }
12506}
12507#[derive(Debug, Clone, PartialEq, Eq)]
12508pub struct TupleExpression<'tree> {
12509 pub span: ::treesitter_types::Span,
12510 pub children: ::std::vec::Vec<Argument<'tree>>,
12511}
12512impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
12513 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12514 fn from_node(
12515 node: ::treesitter_types::tree_sitter::Node<'tree>,
12516 src: &'tree [u8],
12517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12518 debug_assert_eq!(node.kind(), "tuple_expression");
12519 Ok(Self {
12520 span: ::treesitter_types::Span::from(node),
12521 children: {
12522 #[allow(clippy::suspicious_else_formatting)]
12523 let non_field_children = {
12524 let mut cursor = node.walk();
12525 let mut result = ::std::vec::Vec::new();
12526 if cursor.goto_first_child() {
12527 loop {
12528 if cursor.field_name().is_none()
12529 && cursor.node().is_named()
12530 && !cursor.node().is_extra()
12531 {
12532 result.push(cursor.node());
12533 }
12534 if !cursor.goto_next_sibling() {
12535 break;
12536 }
12537 }
12538 }
12539 result
12540 };
12541 let mut items = ::std::vec::Vec::new();
12542 for child in non_field_children {
12543 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12544 <Argument as ::treesitter_types::FromNode>::from_node(child, src)
12545 })?);
12546 }
12547 items
12548 },
12549 })
12550 }
12551}
12552impl ::treesitter_types::Spanned for TupleExpression<'_> {
12553 fn span(&self) -> ::treesitter_types::Span {
12554 self.span
12555 }
12556}
12557#[derive(Debug, Clone, PartialEq, Eq)]
12558pub struct TuplePattern<'tree> {
12559 pub span: ::treesitter_types::Span,
12560 pub name: ::std::vec::Vec<Identifier<'tree>>,
12561 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
12562}
12563impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
12564 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12565 fn from_node(
12566 node: ::treesitter_types::tree_sitter::Node<'tree>,
12567 src: &'tree [u8],
12568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12569 debug_assert_eq!(node.kind(), "tuple_pattern");
12570 Ok(Self {
12571 span: ::treesitter_types::Span::from(node),
12572 name: {
12573 let mut cursor = node.walk();
12574 let mut items = ::std::vec::Vec::new();
12575 for child in node.children_by_field_name("name", &mut cursor) {
12576 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12577 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12578 })?);
12579 }
12580 items
12581 },
12582 children: {
12583 #[allow(clippy::suspicious_else_formatting)]
12584 let non_field_children = {
12585 let mut cursor = node.walk();
12586 let mut result = ::std::vec::Vec::new();
12587 if cursor.goto_first_child() {
12588 loop {
12589 if cursor.field_name().is_none()
12590 && cursor.node().is_named()
12591 && !cursor.node().is_extra()
12592 {
12593 result.push(cursor.node());
12594 }
12595 if !cursor.goto_next_sibling() {
12596 break;
12597 }
12598 }
12599 }
12600 result
12601 };
12602 let mut items = ::std::vec::Vec::new();
12603 for child in non_field_children {
12604 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12605 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
12606 child, src,
12607 )
12608 })?);
12609 }
12610 items
12611 },
12612 })
12613 }
12614}
12615impl ::treesitter_types::Spanned for TuplePattern<'_> {
12616 fn span(&self) -> ::treesitter_types::Span {
12617 self.span
12618 }
12619}
12620#[derive(Debug, Clone, PartialEq, Eq)]
12621pub struct TupleType<'tree> {
12622 pub span: ::treesitter_types::Span,
12623 pub children: ::std::vec::Vec<TupleElement<'tree>>,
12624}
12625impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
12626 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12627 fn from_node(
12628 node: ::treesitter_types::tree_sitter::Node<'tree>,
12629 src: &'tree [u8],
12630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12631 debug_assert_eq!(node.kind(), "tuple_type");
12632 Ok(Self {
12633 span: ::treesitter_types::Span::from(node),
12634 children: {
12635 #[allow(clippy::suspicious_else_formatting)]
12636 let non_field_children = {
12637 let mut cursor = node.walk();
12638 let mut result = ::std::vec::Vec::new();
12639 if cursor.goto_first_child() {
12640 loop {
12641 if cursor.field_name().is_none()
12642 && cursor.node().is_named()
12643 && !cursor.node().is_extra()
12644 {
12645 result.push(cursor.node());
12646 }
12647 if !cursor.goto_next_sibling() {
12648 break;
12649 }
12650 }
12651 }
12652 result
12653 };
12654 let mut items = ::std::vec::Vec::new();
12655 for child in non_field_children {
12656 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12657 <TupleElement as ::treesitter_types::FromNode>::from_node(child, src)
12658 })?);
12659 }
12660 items
12661 },
12662 })
12663 }
12664}
12665impl ::treesitter_types::Spanned for TupleType<'_> {
12666 fn span(&self) -> ::treesitter_types::Span {
12667 self.span
12668 }
12669}
12670#[derive(Debug, Clone, PartialEq, Eq)]
12671pub struct TypeArgumentList<'tree> {
12672 pub span: ::treesitter_types::Span,
12673 pub children: ::std::vec::Vec<Type<'tree>>,
12674}
12675impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentList<'tree> {
12676 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12677 fn from_node(
12678 node: ::treesitter_types::tree_sitter::Node<'tree>,
12679 src: &'tree [u8],
12680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12681 debug_assert_eq!(node.kind(), "type_argument_list");
12682 Ok(Self {
12683 span: ::treesitter_types::Span::from(node),
12684 children: {
12685 #[allow(clippy::suspicious_else_formatting)]
12686 let non_field_children = {
12687 let mut cursor = node.walk();
12688 let mut result = ::std::vec::Vec::new();
12689 if cursor.goto_first_child() {
12690 loop {
12691 if cursor.field_name().is_none()
12692 && cursor.node().is_named()
12693 && !cursor.node().is_extra()
12694 {
12695 result.push(cursor.node());
12696 }
12697 if !cursor.goto_next_sibling() {
12698 break;
12699 }
12700 }
12701 }
12702 result
12703 };
12704 let mut items = ::std::vec::Vec::new();
12705 for child in non_field_children {
12706 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12707 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12708 })?);
12709 }
12710 items
12711 },
12712 })
12713 }
12714}
12715impl ::treesitter_types::Spanned for TypeArgumentList<'_> {
12716 fn span(&self) -> ::treesitter_types::Span {
12717 self.span
12718 }
12719}
12720#[derive(Debug, Clone, PartialEq, Eq)]
12721pub struct TypeParameter<'tree> {
12722 pub span: ::treesitter_types::Span,
12723 pub name: Identifier<'tree>,
12724 pub children: ::std::vec::Vec<TypeParameterChildren<'tree>>,
12725}
12726impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
12727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12728 fn from_node(
12729 node: ::treesitter_types::tree_sitter::Node<'tree>,
12730 src: &'tree [u8],
12731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12732 debug_assert_eq!(node.kind(), "type_parameter");
12733 Ok(Self {
12734 span: ::treesitter_types::Span::from(node),
12735 name: {
12736 let child = node
12737 .child_by_field_name("name")
12738 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
12739 ::treesitter_types::runtime::maybe_grow_stack(|| {
12740 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
12741 })?
12742 },
12743 children: {
12744 #[allow(clippy::suspicious_else_formatting)]
12745 let non_field_children = {
12746 let mut cursor = node.walk();
12747 let mut result = ::std::vec::Vec::new();
12748 if cursor.goto_first_child() {
12749 loop {
12750 if cursor.field_name().is_none()
12751 && cursor.node().is_named()
12752 && !cursor.node().is_extra()
12753 {
12754 result.push(cursor.node());
12755 }
12756 if !cursor.goto_next_sibling() {
12757 break;
12758 }
12759 }
12760 }
12761 result
12762 };
12763 let mut items = ::std::vec::Vec::new();
12764 for child in non_field_children {
12765 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12766 <TypeParameterChildren as ::treesitter_types::FromNode>::from_node(
12767 child, src,
12768 )
12769 })?);
12770 }
12771 items
12772 },
12773 })
12774 }
12775}
12776impl ::treesitter_types::Spanned for TypeParameter<'_> {
12777 fn span(&self) -> ::treesitter_types::Span {
12778 self.span
12779 }
12780}
12781#[derive(Debug, Clone, PartialEq, Eq)]
12782pub struct TypeParameterConstraint<'tree> {
12783 pub span: ::treesitter_types::Span,
12784 pub r#type: ::core::option::Option<Type<'tree>>,
12785 pub children: ::core::option::Option<ConstructorConstraint<'tree>>,
12786}
12787impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraint<'tree> {
12788 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12789 fn from_node(
12790 node: ::treesitter_types::tree_sitter::Node<'tree>,
12791 src: &'tree [u8],
12792 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12793 debug_assert_eq!(node.kind(), "type_parameter_constraint");
12794 Ok(Self {
12795 span: ::treesitter_types::Span::from(node),
12796 r#type: match node.child_by_field_name("type") {
12797 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12798 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12799 })?),
12800 None => None,
12801 },
12802 children: {
12803 #[allow(clippy::suspicious_else_formatting)]
12804 let non_field_children = {
12805 let mut cursor = node.walk();
12806 let mut result = ::std::vec::Vec::new();
12807 if cursor.goto_first_child() {
12808 loop {
12809 if cursor.field_name().is_none()
12810 && cursor.node().is_named()
12811 && !cursor.node().is_extra()
12812 {
12813 result.push(cursor.node());
12814 }
12815 if !cursor.goto_next_sibling() {
12816 break;
12817 }
12818 }
12819 }
12820 result
12821 };
12822 match non_field_children.first() {
12823 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
12824 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(
12825 child, src,
12826 )
12827 })?),
12828 None => None,
12829 }
12830 },
12831 })
12832 }
12833}
12834impl ::treesitter_types::Spanned for TypeParameterConstraint<'_> {
12835 fn span(&self) -> ::treesitter_types::Span {
12836 self.span
12837 }
12838}
12839#[derive(Debug, Clone, PartialEq, Eq)]
12840pub struct TypeParameterConstraintsClause<'tree> {
12841 pub span: ::treesitter_types::Span,
12842 pub children: ::std::vec::Vec<TypeParameterConstraintsClauseChildren<'tree>>,
12843}
12844impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClause<'tree> {
12845 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12846 fn from_node(
12847 node: ::treesitter_types::tree_sitter::Node<'tree>,
12848 src: &'tree [u8],
12849 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12850 debug_assert_eq!(node.kind(), "type_parameter_constraints_clause");
12851 Ok(Self {
12852 span: ::treesitter_types::Span::from(node),
12853 children: {
12854 #[allow(clippy::suspicious_else_formatting)]
12855 let non_field_children = {
12856 let mut cursor = node.walk();
12857 let mut result = ::std::vec::Vec::new();
12858 if cursor.goto_first_child() {
12859 loop {
12860 if cursor.field_name().is_none()
12861 && cursor.node().is_named()
12862 && !cursor.node().is_extra()
12863 {
12864 result.push(cursor.node());
12865 }
12866 if !cursor.goto_next_sibling() {
12867 break;
12868 }
12869 }
12870 }
12871 result
12872 };
12873 let mut items = ::std::vec::Vec::new();
12874 for child in non_field_children {
12875 items
12876 .push(
12877 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeParameterConstraintsClauseChildren as ::treesitter_types::FromNode>::from_node(
12878 child,
12879 src,
12880 ))?,
12881 );
12882 }
12883 items
12884 },
12885 })
12886 }
12887}
12888impl ::treesitter_types::Spanned for TypeParameterConstraintsClause<'_> {
12889 fn span(&self) -> ::treesitter_types::Span {
12890 self.span
12891 }
12892}
12893#[derive(Debug, Clone, PartialEq, Eq)]
12894pub struct TypeParameterList<'tree> {
12895 pub span: ::treesitter_types::Span,
12896 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
12897}
12898impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterList<'tree> {
12899 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12900 fn from_node(
12901 node: ::treesitter_types::tree_sitter::Node<'tree>,
12902 src: &'tree [u8],
12903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12904 debug_assert_eq!(node.kind(), "type_parameter_list");
12905 Ok(Self {
12906 span: ::treesitter_types::Span::from(node),
12907 children: {
12908 #[allow(clippy::suspicious_else_formatting)]
12909 let non_field_children = {
12910 let mut cursor = node.walk();
12911 let mut result = ::std::vec::Vec::new();
12912 if cursor.goto_first_child() {
12913 loop {
12914 if cursor.field_name().is_none()
12915 && cursor.node().is_named()
12916 && !cursor.node().is_extra()
12917 {
12918 result.push(cursor.node());
12919 }
12920 if !cursor.goto_next_sibling() {
12921 break;
12922 }
12923 }
12924 }
12925 result
12926 };
12927 let mut items = ::std::vec::Vec::new();
12928 for child in non_field_children {
12929 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
12930 <TypeParameter as ::treesitter_types::FromNode>::from_node(child, src)
12931 })?);
12932 }
12933 items
12934 },
12935 })
12936 }
12937}
12938impl ::treesitter_types::Spanned for TypeParameterList<'_> {
12939 fn span(&self) -> ::treesitter_types::Span {
12940 self.span
12941 }
12942}
12943#[derive(Debug, Clone, PartialEq, Eq)]
12944pub struct TypePattern<'tree> {
12945 pub span: ::treesitter_types::Span,
12946 pub r#type: Type<'tree>,
12947}
12948impl<'tree> ::treesitter_types::FromNode<'tree> for TypePattern<'tree> {
12949 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12950 fn from_node(
12951 node: ::treesitter_types::tree_sitter::Node<'tree>,
12952 src: &'tree [u8],
12953 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12954 debug_assert_eq!(node.kind(), "type_pattern");
12955 Ok(Self {
12956 span: ::treesitter_types::Span::from(node),
12957 r#type: {
12958 let child = node
12959 .child_by_field_name("type")
12960 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12961 ::treesitter_types::runtime::maybe_grow_stack(|| {
12962 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12963 })?
12964 },
12965 })
12966 }
12967}
12968impl ::treesitter_types::Spanned for TypePattern<'_> {
12969 fn span(&self) -> ::treesitter_types::Span {
12970 self.span
12971 }
12972}
12973#[derive(Debug, Clone, PartialEq, Eq)]
12974pub struct TypeofExpression<'tree> {
12975 pub span: ::treesitter_types::Span,
12976 pub r#type: Type<'tree>,
12977}
12978impl<'tree> ::treesitter_types::FromNode<'tree> for TypeofExpression<'tree> {
12979 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
12980 fn from_node(
12981 node: ::treesitter_types::tree_sitter::Node<'tree>,
12982 src: &'tree [u8],
12983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12984 debug_assert_eq!(node.kind(), "typeof_expression");
12985 Ok(Self {
12986 span: ::treesitter_types::Span::from(node),
12987 r#type: {
12988 let child = node
12989 .child_by_field_name("type")
12990 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
12991 ::treesitter_types::runtime::maybe_grow_stack(|| {
12992 <Type as ::treesitter_types::FromNode>::from_node(child, src)
12993 })?
12994 },
12995 })
12996 }
12997}
12998impl ::treesitter_types::Spanned for TypeofExpression<'_> {
12999 fn span(&self) -> ::treesitter_types::Span {
13000 self.span
13001 }
13002}
13003#[derive(Debug, Clone, PartialEq, Eq)]
13004pub struct UnaryExpression<'tree> {
13005 pub span: ::treesitter_types::Span,
13006 pub argument: UnaryExpressionArgument<'tree>,
13007 pub operator: UnaryExpressionOperator,
13008}
13009impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
13010 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13011 fn from_node(
13012 node: ::treesitter_types::tree_sitter::Node<'tree>,
13013 src: &'tree [u8],
13014 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13015 debug_assert_eq!(node.kind(), "unary_expression");
13016 Ok(Self {
13017 span: ::treesitter_types::Span::from(node),
13018 argument: {
13019 let child = node.child_by_field_name("argument").ok_or_else(|| {
13020 ::treesitter_types::ParseError::missing_field("argument", node)
13021 })?;
13022 ::treesitter_types::runtime::maybe_grow_stack(|| {
13023 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)
13024 })?
13025 },
13026 operator: {
13027 let child = node.child_by_field_name("operator").ok_or_else(|| {
13028 ::treesitter_types::ParseError::missing_field("operator", node)
13029 })?;
13030 ::treesitter_types::runtime::maybe_grow_stack(|| {
13031 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
13032 })?
13033 },
13034 })
13035 }
13036}
13037impl ::treesitter_types::Spanned for UnaryExpression<'_> {
13038 fn span(&self) -> ::treesitter_types::Span {
13039 self.span
13040 }
13041}
13042#[derive(Debug, Clone, PartialEq, Eq)]
13043pub struct UnsafeStatement<'tree> {
13044 pub span: ::treesitter_types::Span,
13045 pub children: Block<'tree>,
13046}
13047impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeStatement<'tree> {
13048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13049 fn from_node(
13050 node: ::treesitter_types::tree_sitter::Node<'tree>,
13051 src: &'tree [u8],
13052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13053 debug_assert_eq!(node.kind(), "unsafe_statement");
13054 Ok(Self {
13055 span: ::treesitter_types::Span::from(node),
13056 children: {
13057 #[allow(clippy::suspicious_else_formatting)]
13058 let non_field_children = {
13059 let mut cursor = node.walk();
13060 let mut result = ::std::vec::Vec::new();
13061 if cursor.goto_first_child() {
13062 loop {
13063 if cursor.field_name().is_none()
13064 && cursor.node().is_named()
13065 && !cursor.node().is_extra()
13066 {
13067 result.push(cursor.node());
13068 }
13069 if !cursor.goto_next_sibling() {
13070 break;
13071 }
13072 }
13073 }
13074 result
13075 };
13076 let child = if let Some(&c) = non_field_children.first() {
13077 c
13078 } else {
13079 let mut fallback_cursor = node.walk();
13080 let mut fallback_child = None;
13081 if fallback_cursor.goto_first_child() {
13082 loop {
13083 if fallback_cursor.field_name().is_none()
13084 && !fallback_cursor.node().is_extra()
13085 {
13086 let candidate = fallback_cursor.node();
13087 #[allow(clippy::needless_question_mark)]
13088 if (|| -> ::core::result::Result<
13089 _,
13090 ::treesitter_types::ParseError,
13091 > {
13092 let child = candidate;
13093 Ok(
13094 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
13095 child,
13096 src,
13097 ))?,
13098 )
13099 })()
13100 .is_ok()
13101 {
13102 fallback_child = Some(candidate);
13103 break;
13104 }
13105 }
13106 if !fallback_cursor.goto_next_sibling() {
13107 break;
13108 }
13109 }
13110 }
13111 if fallback_child.is_none() {
13112 let mut cursor2 = node.walk();
13113 if cursor2.goto_first_child() {
13114 loop {
13115 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13116 let candidate = cursor2.node();
13117 #[allow(clippy::needless_question_mark)]
13118 if (|| -> ::core::result::Result<
13119 _,
13120 ::treesitter_types::ParseError,
13121 > {
13122 let child = candidate;
13123 Ok(
13124 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
13125 child,
13126 src,
13127 ))?,
13128 )
13129 })()
13130 .is_ok()
13131 {
13132 fallback_child = Some(candidate);
13133 break;
13134 }
13135 }
13136 if !cursor2.goto_next_sibling() {
13137 break;
13138 }
13139 }
13140 }
13141 }
13142 fallback_child.ok_or_else(|| {
13143 ::treesitter_types::ParseError::missing_field("children", node)
13144 })?
13145 };
13146 ::treesitter_types::runtime::maybe_grow_stack(|| {
13147 <Block as ::treesitter_types::FromNode>::from_node(child, src)
13148 })?
13149 },
13150 })
13151 }
13152}
13153impl ::treesitter_types::Spanned for UnsafeStatement<'_> {
13154 fn span(&self) -> ::treesitter_types::Span {
13155 self.span
13156 }
13157}
13158#[derive(Debug, Clone, PartialEq, Eq)]
13159pub struct UsingDirective<'tree> {
13160 pub span: ::treesitter_types::Span,
13161 pub name: ::core::option::Option<Identifier<'tree>>,
13162 pub children: Type<'tree>,
13163}
13164impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDirective<'tree> {
13165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13166 fn from_node(
13167 node: ::treesitter_types::tree_sitter::Node<'tree>,
13168 src: &'tree [u8],
13169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13170 debug_assert_eq!(node.kind(), "using_directive");
13171 Ok(Self {
13172 span: ::treesitter_types::Span::from(node),
13173 name: match node.child_by_field_name("name") {
13174 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13175 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
13176 })?),
13177 None => None,
13178 },
13179 children: {
13180 #[allow(clippy::suspicious_else_formatting)]
13181 let non_field_children = {
13182 let mut cursor = node.walk();
13183 let mut result = ::std::vec::Vec::new();
13184 if cursor.goto_first_child() {
13185 loop {
13186 if cursor.field_name().is_none()
13187 && cursor.node().is_named()
13188 && !cursor.node().is_extra()
13189 {
13190 result.push(cursor.node());
13191 }
13192 if !cursor.goto_next_sibling() {
13193 break;
13194 }
13195 }
13196 }
13197 result
13198 };
13199 let child = if let Some(&c) = non_field_children.first() {
13200 c
13201 } else {
13202 let mut fallback_cursor = node.walk();
13203 let mut fallback_child = None;
13204 if fallback_cursor.goto_first_child() {
13205 loop {
13206 if fallback_cursor.field_name().is_none()
13207 && !fallback_cursor.node().is_extra()
13208 {
13209 let candidate = fallback_cursor.node();
13210 #[allow(clippy::needless_question_mark)]
13211 if (|| -> ::core::result::Result<
13212 _,
13213 ::treesitter_types::ParseError,
13214 > {
13215 let child = candidate;
13216 Ok(
13217 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
13218 child,
13219 src,
13220 ))?,
13221 )
13222 })()
13223 .is_ok()
13224 {
13225 fallback_child = Some(candidate);
13226 break;
13227 }
13228 }
13229 if !fallback_cursor.goto_next_sibling() {
13230 break;
13231 }
13232 }
13233 }
13234 if fallback_child.is_none() {
13235 let mut cursor2 = node.walk();
13236 if cursor2.goto_first_child() {
13237 loop {
13238 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13239 let candidate = cursor2.node();
13240 #[allow(clippy::needless_question_mark)]
13241 if (|| -> ::core::result::Result<
13242 _,
13243 ::treesitter_types::ParseError,
13244 > {
13245 let child = candidate;
13246 Ok(
13247 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
13248 child,
13249 src,
13250 ))?,
13251 )
13252 })()
13253 .is_ok()
13254 {
13255 fallback_child = Some(candidate);
13256 break;
13257 }
13258 }
13259 if !cursor2.goto_next_sibling() {
13260 break;
13261 }
13262 }
13263 }
13264 }
13265 fallback_child.ok_or_else(|| {
13266 ::treesitter_types::ParseError::missing_field("children", node)
13267 })?
13268 };
13269 ::treesitter_types::runtime::maybe_grow_stack(|| {
13270 <Type as ::treesitter_types::FromNode>::from_node(child, src)
13271 })?
13272 },
13273 })
13274 }
13275}
13276impl ::treesitter_types::Spanned for UsingDirective<'_> {
13277 fn span(&self) -> ::treesitter_types::Span {
13278 self.span
13279 }
13280}
13281#[derive(Debug, Clone, PartialEq, Eq)]
13282pub struct UsingStatement<'tree> {
13283 pub span: ::treesitter_types::Span,
13284 pub body: Statement<'tree>,
13285 pub children: UsingStatementChildren<'tree>,
13286}
13287impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatement<'tree> {
13288 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13289 fn from_node(
13290 node: ::treesitter_types::tree_sitter::Node<'tree>,
13291 src: &'tree [u8],
13292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13293 debug_assert_eq!(node.kind(), "using_statement");
13294 Ok(Self {
13295 span: ::treesitter_types::Span::from(node),
13296 body: {
13297 let child = node
13298 .child_by_field_name("body")
13299 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
13300 ::treesitter_types::runtime::maybe_grow_stack(|| {
13301 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
13302 })?
13303 },
13304 children: {
13305 #[allow(clippy::suspicious_else_formatting)]
13306 let non_field_children = {
13307 let mut cursor = node.walk();
13308 let mut result = ::std::vec::Vec::new();
13309 if cursor.goto_first_child() {
13310 loop {
13311 if cursor.field_name().is_none()
13312 && cursor.node().is_named()
13313 && !cursor.node().is_extra()
13314 {
13315 result.push(cursor.node());
13316 }
13317 if !cursor.goto_next_sibling() {
13318 break;
13319 }
13320 }
13321 }
13322 result
13323 };
13324 let child = if let Some(&c) = non_field_children.first() {
13325 c
13326 } else {
13327 let mut fallback_cursor = node.walk();
13328 let mut fallback_child = None;
13329 if fallback_cursor.goto_first_child() {
13330 loop {
13331 if fallback_cursor.field_name().is_none()
13332 && !fallback_cursor.node().is_extra()
13333 {
13334 let candidate = fallback_cursor.node();
13335 #[allow(clippy::needless_question_mark)]
13336 if (|| -> ::core::result::Result<
13337 _,
13338 ::treesitter_types::ParseError,
13339 > {
13340 let child = candidate;
13341 Ok(
13342 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
13343 child,
13344 src,
13345 ))?,
13346 )
13347 })()
13348 .is_ok()
13349 {
13350 fallback_child = Some(candidate);
13351 break;
13352 }
13353 }
13354 if !fallback_cursor.goto_next_sibling() {
13355 break;
13356 }
13357 }
13358 }
13359 if fallback_child.is_none() {
13360 let mut cursor2 = node.walk();
13361 if cursor2.goto_first_child() {
13362 loop {
13363 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13364 let candidate = cursor2.node();
13365 #[allow(clippy::needless_question_mark)]
13366 if (|| -> ::core::result::Result<
13367 _,
13368 ::treesitter_types::ParseError,
13369 > {
13370 let child = candidate;
13371 Ok(
13372 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(
13373 child,
13374 src,
13375 ))?,
13376 )
13377 })()
13378 .is_ok()
13379 {
13380 fallback_child = Some(candidate);
13381 break;
13382 }
13383 }
13384 if !cursor2.goto_next_sibling() {
13385 break;
13386 }
13387 }
13388 }
13389 }
13390 fallback_child.ok_or_else(|| {
13391 ::treesitter_types::ParseError::missing_field("children", node)
13392 })?
13393 };
13394 ::treesitter_types::runtime::maybe_grow_stack(|| {
13395 <UsingStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
13396 })?
13397 },
13398 })
13399 }
13400}
13401impl ::treesitter_types::Spanned for UsingStatement<'_> {
13402 fn span(&self) -> ::treesitter_types::Span {
13403 self.span
13404 }
13405}
13406#[derive(Debug, Clone, PartialEq, Eq)]
13407pub struct VarPattern<'tree> {
13408 pub span: ::treesitter_types::Span,
13409 pub name: ::core::option::Option<Identifier<'tree>>,
13410 pub children: ::core::option::Option<VarPatternChildren<'tree>>,
13411}
13412impl<'tree> ::treesitter_types::FromNode<'tree> for VarPattern<'tree> {
13413 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13414 fn from_node(
13415 node: ::treesitter_types::tree_sitter::Node<'tree>,
13416 src: &'tree [u8],
13417 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13418 debug_assert_eq!(node.kind(), "var_pattern");
13419 Ok(Self {
13420 span: ::treesitter_types::Span::from(node),
13421 name: match node.child_by_field_name("name") {
13422 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13423 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
13424 })?),
13425 None => None,
13426 },
13427 children: {
13428 #[allow(clippy::suspicious_else_formatting)]
13429 let non_field_children = {
13430 let mut cursor = node.walk();
13431 let mut result = ::std::vec::Vec::new();
13432 if cursor.goto_first_child() {
13433 loop {
13434 if cursor.field_name().is_none()
13435 && cursor.node().is_named()
13436 && !cursor.node().is_extra()
13437 {
13438 result.push(cursor.node());
13439 }
13440 if !cursor.goto_next_sibling() {
13441 break;
13442 }
13443 }
13444 }
13445 result
13446 };
13447 match non_field_children.first() {
13448 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13449 <VarPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
13450 })?),
13451 None => None,
13452 }
13453 },
13454 })
13455 }
13456}
13457impl ::treesitter_types::Spanned for VarPattern<'_> {
13458 fn span(&self) -> ::treesitter_types::Span {
13459 self.span
13460 }
13461}
13462#[derive(Debug, Clone, PartialEq, Eq)]
13463pub struct VariableDeclaration<'tree> {
13464 pub span: ::treesitter_types::Span,
13465 pub r#type: Type<'tree>,
13466 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
13467}
13468impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
13469 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13470 fn from_node(
13471 node: ::treesitter_types::tree_sitter::Node<'tree>,
13472 src: &'tree [u8],
13473 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13474 debug_assert_eq!(node.kind(), "variable_declaration");
13475 Ok(Self {
13476 span: ::treesitter_types::Span::from(node),
13477 r#type: {
13478 let child = node
13479 .child_by_field_name("type")
13480 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
13481 ::treesitter_types::runtime::maybe_grow_stack(|| {
13482 <Type as ::treesitter_types::FromNode>::from_node(child, src)
13483 })?
13484 },
13485 children: {
13486 #[allow(clippy::suspicious_else_formatting)]
13487 let non_field_children = {
13488 let mut cursor = node.walk();
13489 let mut result = ::std::vec::Vec::new();
13490 if cursor.goto_first_child() {
13491 loop {
13492 if cursor.field_name().is_none()
13493 && cursor.node().is_named()
13494 && !cursor.node().is_extra()
13495 {
13496 result.push(cursor.node());
13497 }
13498 if !cursor.goto_next_sibling() {
13499 break;
13500 }
13501 }
13502 }
13503 result
13504 };
13505 let mut items = ::std::vec::Vec::new();
13506 for child in non_field_children {
13507 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13508 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
13509 })?);
13510 }
13511 items
13512 },
13513 })
13514 }
13515}
13516impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
13517 fn span(&self) -> ::treesitter_types::Span {
13518 self.span
13519 }
13520}
13521#[derive(Debug, Clone, PartialEq, Eq)]
13522pub struct VariableDeclarator<'tree> {
13523 pub span: ::treesitter_types::Span,
13524 pub name: ::core::option::Option<Identifier<'tree>>,
13525 pub children: ::std::vec::Vec<VariableDeclaratorChildren<'tree>>,
13526}
13527impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
13528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13529 fn from_node(
13530 node: ::treesitter_types::tree_sitter::Node<'tree>,
13531 src: &'tree [u8],
13532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13533 debug_assert_eq!(node.kind(), "variable_declarator");
13534 Ok(Self {
13535 span: ::treesitter_types::Span::from(node),
13536 name: match node.child_by_field_name("name") {
13537 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13538 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
13539 })?),
13540 None => None,
13541 },
13542 children: {
13543 #[allow(clippy::suspicious_else_formatting)]
13544 let non_field_children = {
13545 let mut cursor = node.walk();
13546 let mut result = ::std::vec::Vec::new();
13547 if cursor.goto_first_child() {
13548 loop {
13549 if cursor.field_name().is_none()
13550 && cursor.node().is_named()
13551 && !cursor.node().is_extra()
13552 {
13553 result.push(cursor.node());
13554 }
13555 if !cursor.goto_next_sibling() {
13556 break;
13557 }
13558 }
13559 }
13560 result
13561 };
13562 let mut items = ::std::vec::Vec::new();
13563 for child in non_field_children {
13564 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13565 <VariableDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
13566 child, src,
13567 )
13568 })?);
13569 }
13570 items
13571 },
13572 })
13573 }
13574}
13575impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
13576 fn span(&self) -> ::treesitter_types::Span {
13577 self.span
13578 }
13579}
13580#[derive(Debug, Clone, PartialEq, Eq)]
13581pub struct WhenClause<'tree> {
13582 pub span: ::treesitter_types::Span,
13583 pub children: Expression<'tree>,
13584}
13585impl<'tree> ::treesitter_types::FromNode<'tree> for WhenClause<'tree> {
13586 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13587 fn from_node(
13588 node: ::treesitter_types::tree_sitter::Node<'tree>,
13589 src: &'tree [u8],
13590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13591 debug_assert_eq!(node.kind(), "when_clause");
13592 Ok(Self {
13593 span: ::treesitter_types::Span::from(node),
13594 children: {
13595 #[allow(clippy::suspicious_else_formatting)]
13596 let non_field_children = {
13597 let mut cursor = node.walk();
13598 let mut result = ::std::vec::Vec::new();
13599 if cursor.goto_first_child() {
13600 loop {
13601 if cursor.field_name().is_none()
13602 && cursor.node().is_named()
13603 && !cursor.node().is_extra()
13604 {
13605 result.push(cursor.node());
13606 }
13607 if !cursor.goto_next_sibling() {
13608 break;
13609 }
13610 }
13611 }
13612 result
13613 };
13614 let child = if let Some(&c) = non_field_children.first() {
13615 c
13616 } else {
13617 let mut fallback_cursor = node.walk();
13618 let mut fallback_child = None;
13619 if fallback_cursor.goto_first_child() {
13620 loop {
13621 if fallback_cursor.field_name().is_none()
13622 && !fallback_cursor.node().is_extra()
13623 {
13624 let candidate = fallback_cursor.node();
13625 #[allow(clippy::needless_question_mark)]
13626 if (|| -> ::core::result::Result<
13627 _,
13628 ::treesitter_types::ParseError,
13629 > {
13630 let child = candidate;
13631 Ok(
13632 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13633 child,
13634 src,
13635 ))?,
13636 )
13637 })()
13638 .is_ok()
13639 {
13640 fallback_child = Some(candidate);
13641 break;
13642 }
13643 }
13644 if !fallback_cursor.goto_next_sibling() {
13645 break;
13646 }
13647 }
13648 }
13649 if fallback_child.is_none() {
13650 let mut cursor2 = node.walk();
13651 if cursor2.goto_first_child() {
13652 loop {
13653 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13654 let candidate = cursor2.node();
13655 #[allow(clippy::needless_question_mark)]
13656 if (|| -> ::core::result::Result<
13657 _,
13658 ::treesitter_types::ParseError,
13659 > {
13660 let child = candidate;
13661 Ok(
13662 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13663 child,
13664 src,
13665 ))?,
13666 )
13667 })()
13668 .is_ok()
13669 {
13670 fallback_child = Some(candidate);
13671 break;
13672 }
13673 }
13674 if !cursor2.goto_next_sibling() {
13675 break;
13676 }
13677 }
13678 }
13679 }
13680 fallback_child.ok_or_else(|| {
13681 ::treesitter_types::ParseError::missing_field("children", node)
13682 })?
13683 };
13684 ::treesitter_types::runtime::maybe_grow_stack(|| {
13685 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13686 })?
13687 },
13688 })
13689 }
13690}
13691impl ::treesitter_types::Spanned for WhenClause<'_> {
13692 fn span(&self) -> ::treesitter_types::Span {
13693 self.span
13694 }
13695}
13696#[derive(Debug, Clone, PartialEq, Eq)]
13697pub struct WhereClause<'tree> {
13698 pub span: ::treesitter_types::Span,
13699 pub children: Expression<'tree>,
13700}
13701impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
13702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13703 fn from_node(
13704 node: ::treesitter_types::tree_sitter::Node<'tree>,
13705 src: &'tree [u8],
13706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13707 debug_assert_eq!(node.kind(), "where_clause");
13708 Ok(Self {
13709 span: ::treesitter_types::Span::from(node),
13710 children: {
13711 #[allow(clippy::suspicious_else_formatting)]
13712 let non_field_children = {
13713 let mut cursor = node.walk();
13714 let mut result = ::std::vec::Vec::new();
13715 if cursor.goto_first_child() {
13716 loop {
13717 if cursor.field_name().is_none()
13718 && cursor.node().is_named()
13719 && !cursor.node().is_extra()
13720 {
13721 result.push(cursor.node());
13722 }
13723 if !cursor.goto_next_sibling() {
13724 break;
13725 }
13726 }
13727 }
13728 result
13729 };
13730 let child = if let Some(&c) = non_field_children.first() {
13731 c
13732 } else {
13733 let mut fallback_cursor = node.walk();
13734 let mut fallback_child = None;
13735 if fallback_cursor.goto_first_child() {
13736 loop {
13737 if fallback_cursor.field_name().is_none()
13738 && !fallback_cursor.node().is_extra()
13739 {
13740 let candidate = fallback_cursor.node();
13741 #[allow(clippy::needless_question_mark)]
13742 if (|| -> ::core::result::Result<
13743 _,
13744 ::treesitter_types::ParseError,
13745 > {
13746 let child = candidate;
13747 Ok(
13748 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13749 child,
13750 src,
13751 ))?,
13752 )
13753 })()
13754 .is_ok()
13755 {
13756 fallback_child = Some(candidate);
13757 break;
13758 }
13759 }
13760 if !fallback_cursor.goto_next_sibling() {
13761 break;
13762 }
13763 }
13764 }
13765 if fallback_child.is_none() {
13766 let mut cursor2 = node.walk();
13767 if cursor2.goto_first_child() {
13768 loop {
13769 if cursor2.node().is_named() && !cursor2.node().is_extra() {
13770 let candidate = cursor2.node();
13771 #[allow(clippy::needless_question_mark)]
13772 if (|| -> ::core::result::Result<
13773 _,
13774 ::treesitter_types::ParseError,
13775 > {
13776 let child = candidate;
13777 Ok(
13778 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
13779 child,
13780 src,
13781 ))?,
13782 )
13783 })()
13784 .is_ok()
13785 {
13786 fallback_child = Some(candidate);
13787 break;
13788 }
13789 }
13790 if !cursor2.goto_next_sibling() {
13791 break;
13792 }
13793 }
13794 }
13795 }
13796 fallback_child.ok_or_else(|| {
13797 ::treesitter_types::ParseError::missing_field("children", node)
13798 })?
13799 };
13800 ::treesitter_types::runtime::maybe_grow_stack(|| {
13801 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13802 })?
13803 },
13804 })
13805 }
13806}
13807impl ::treesitter_types::Spanned for WhereClause<'_> {
13808 fn span(&self) -> ::treesitter_types::Span {
13809 self.span
13810 }
13811}
13812#[derive(Debug, Clone, PartialEq, Eq)]
13813pub struct WhileStatement<'tree> {
13814 pub span: ::treesitter_types::Span,
13815 pub body: Statement<'tree>,
13816 pub condition: Expression<'tree>,
13817}
13818impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
13819 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13820 fn from_node(
13821 node: ::treesitter_types::tree_sitter::Node<'tree>,
13822 src: &'tree [u8],
13823 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13824 debug_assert_eq!(node.kind(), "while_statement");
13825 Ok(Self {
13826 span: ::treesitter_types::Span::from(node),
13827 body: {
13828 let child = node
13829 .child_by_field_name("body")
13830 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
13831 ::treesitter_types::runtime::maybe_grow_stack(|| {
13832 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
13833 })?
13834 },
13835 condition: {
13836 let child = node.child_by_field_name("condition").ok_or_else(|| {
13837 ::treesitter_types::ParseError::missing_field("condition", node)
13838 })?;
13839 ::treesitter_types::runtime::maybe_grow_stack(|| {
13840 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13841 })?
13842 },
13843 })
13844 }
13845}
13846impl ::treesitter_types::Spanned for WhileStatement<'_> {
13847 fn span(&self) -> ::treesitter_types::Span {
13848 self.span
13849 }
13850}
13851#[derive(Debug, Clone, PartialEq, Eq)]
13852pub struct WithExpression<'tree> {
13853 pub span: ::treesitter_types::Span,
13854 pub children: ::std::vec::Vec<WithExpressionChildren<'tree>>,
13855}
13856impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpression<'tree> {
13857 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13858 fn from_node(
13859 node: ::treesitter_types::tree_sitter::Node<'tree>,
13860 src: &'tree [u8],
13861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13862 debug_assert_eq!(node.kind(), "with_expression");
13863 Ok(Self {
13864 span: ::treesitter_types::Span::from(node),
13865 children: {
13866 #[allow(clippy::suspicious_else_formatting)]
13867 let non_field_children = {
13868 let mut cursor = node.walk();
13869 let mut result = ::std::vec::Vec::new();
13870 if cursor.goto_first_child() {
13871 loop {
13872 if cursor.field_name().is_none()
13873 && cursor.node().is_named()
13874 && !cursor.node().is_extra()
13875 {
13876 result.push(cursor.node());
13877 }
13878 if !cursor.goto_next_sibling() {
13879 break;
13880 }
13881 }
13882 }
13883 result
13884 };
13885 let mut items = ::std::vec::Vec::new();
13886 for child in non_field_children {
13887 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13888 <WithExpressionChildren as ::treesitter_types::FromNode>::from_node(
13889 child, src,
13890 )
13891 })?);
13892 }
13893 items
13894 },
13895 })
13896 }
13897}
13898impl ::treesitter_types::Spanned for WithExpression<'_> {
13899 fn span(&self) -> ::treesitter_types::Span {
13900 self.span
13901 }
13902}
13903#[derive(Debug, Clone, PartialEq, Eq)]
13904pub struct WithInitializer<'tree> {
13905 pub span: ::treesitter_types::Span,
13906 pub children: ::std::vec::Vec<WithInitializerChildren<'tree>>,
13907}
13908impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializer<'tree> {
13909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13910 fn from_node(
13911 node: ::treesitter_types::tree_sitter::Node<'tree>,
13912 src: &'tree [u8],
13913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13914 debug_assert_eq!(node.kind(), "with_initializer");
13915 Ok(Self {
13916 span: ::treesitter_types::Span::from(node),
13917 children: {
13918 #[allow(clippy::suspicious_else_formatting)]
13919 let non_field_children = {
13920 let mut cursor = node.walk();
13921 let mut result = ::std::vec::Vec::new();
13922 if cursor.goto_first_child() {
13923 loop {
13924 if cursor.field_name().is_none()
13925 && cursor.node().is_named()
13926 && !cursor.node().is_extra()
13927 {
13928 result.push(cursor.node());
13929 }
13930 if !cursor.goto_next_sibling() {
13931 break;
13932 }
13933 }
13934 }
13935 result
13936 };
13937 let mut items = ::std::vec::Vec::new();
13938 for child in non_field_children {
13939 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
13940 <WithInitializerChildren as ::treesitter_types::FromNode>::from_node(
13941 child, src,
13942 )
13943 })?);
13944 }
13945 items
13946 },
13947 })
13948 }
13949}
13950impl ::treesitter_types::Spanned for WithInitializer<'_> {
13951 fn span(&self) -> ::treesitter_types::Span {
13952 self.span
13953 }
13954}
13955#[derive(Debug, Clone, PartialEq, Eq)]
13956pub struct YieldStatement<'tree> {
13957 pub span: ::treesitter_types::Span,
13958 pub children: ::core::option::Option<Expression<'tree>>,
13959}
13960impl<'tree> ::treesitter_types::FromNode<'tree> for YieldStatement<'tree> {
13961 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
13962 fn from_node(
13963 node: ::treesitter_types::tree_sitter::Node<'tree>,
13964 src: &'tree [u8],
13965 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13966 debug_assert_eq!(node.kind(), "yield_statement");
13967 Ok(Self {
13968 span: ::treesitter_types::Span::from(node),
13969 children: {
13970 #[allow(clippy::suspicious_else_formatting)]
13971 let non_field_children = {
13972 let mut cursor = node.walk();
13973 let mut result = ::std::vec::Vec::new();
13974 if cursor.goto_first_child() {
13975 loop {
13976 if cursor.field_name().is_none()
13977 && cursor.node().is_named()
13978 && !cursor.node().is_extra()
13979 {
13980 result.push(cursor.node());
13981 }
13982 if !cursor.goto_next_sibling() {
13983 break;
13984 }
13985 }
13986 }
13987 result
13988 };
13989 match non_field_children.first() {
13990 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
13991 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
13992 })?),
13993 None => None,
13994 }
13995 },
13996 })
13997 }
13998}
13999impl ::treesitter_types::Spanned for YieldStatement<'_> {
14000 fn span(&self) -> ::treesitter_types::Span {
14001 self.span
14002 }
14003}
14004#[derive(Debug, Clone, PartialEq, Eq)]
14005pub struct CharacterLiteralContent<'tree> {
14006 pub span: ::treesitter_types::Span,
14007 text: &'tree str,
14008}
14009impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralContent<'tree> {
14010 fn from_node(
14011 node: ::treesitter_types::tree_sitter::Node<'tree>,
14012 src: &'tree [u8],
14013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14014 debug_assert_eq!(node.kind(), "character_literal_content");
14015 Ok(Self {
14016 span: ::treesitter_types::Span::from(node),
14017 text: node.utf8_text(src)?,
14018 })
14019 }
14020}
14021impl<'tree> ::treesitter_types::LeafNode<'tree> for CharacterLiteralContent<'tree> {
14022 fn text(&self) -> &'tree str {
14023 self.text
14024 }
14025}
14026impl ::treesitter_types::Spanned for CharacterLiteralContent<'_> {
14027 fn span(&self) -> ::treesitter_types::Span {
14028 self.span
14029 }
14030}
14031#[derive(Debug, Clone, PartialEq, Eq)]
14032pub struct Comment<'tree> {
14033 pub span: ::treesitter_types::Span,
14034 text: &'tree str,
14035}
14036impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
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 debug_assert_eq!(node.kind(), "comment");
14042 Ok(Self {
14043 span: ::treesitter_types::Span::from(node),
14044 text: node.utf8_text(src)?,
14045 })
14046 }
14047}
14048impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
14049 fn text(&self) -> &'tree str {
14050 self.text
14051 }
14052}
14053impl ::treesitter_types::Spanned for Comment<'_> {
14054 fn span(&self) -> ::treesitter_types::Span {
14055 self.span
14056 }
14057}
14058#[derive(Debug, Clone, PartialEq, Eq)]
14059pub struct Discard<'tree> {
14060 pub span: ::treesitter_types::Span,
14061 text: &'tree str,
14062}
14063impl<'tree> ::treesitter_types::FromNode<'tree> for Discard<'tree> {
14064 fn from_node(
14065 node: ::treesitter_types::tree_sitter::Node<'tree>,
14066 src: &'tree [u8],
14067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14068 debug_assert_eq!(node.kind(), "discard");
14069 Ok(Self {
14070 span: ::treesitter_types::Span::from(node),
14071 text: node.utf8_text(src)?,
14072 })
14073 }
14074}
14075impl<'tree> ::treesitter_types::LeafNode<'tree> for Discard<'tree> {
14076 fn text(&self) -> &'tree str {
14077 self.text
14078 }
14079}
14080impl ::treesitter_types::Spanned for Discard<'_> {
14081 fn span(&self) -> ::treesitter_types::Span {
14082 self.span
14083 }
14084}
14085#[derive(Debug, Clone, PartialEq, Eq)]
14086pub struct EscapeSequence<'tree> {
14087 pub span: ::treesitter_types::Span,
14088 text: &'tree str,
14089}
14090impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
14091 fn from_node(
14092 node: ::treesitter_types::tree_sitter::Node<'tree>,
14093 src: &'tree [u8],
14094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14095 debug_assert_eq!(node.kind(), "escape_sequence");
14096 Ok(Self {
14097 span: ::treesitter_types::Span::from(node),
14098 text: node.utf8_text(src)?,
14099 })
14100 }
14101}
14102impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
14103 fn text(&self) -> &'tree str {
14104 self.text
14105 }
14106}
14107impl ::treesitter_types::Spanned for EscapeSequence<'_> {
14108 fn span(&self) -> ::treesitter_types::Span {
14109 self.span
14110 }
14111}
14112#[derive(Debug, Clone, PartialEq, Eq)]
14113pub struct IntegerLiteral<'tree> {
14114 pub span: ::treesitter_types::Span,
14115 text: &'tree str,
14116}
14117impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
14118 fn from_node(
14119 node: ::treesitter_types::tree_sitter::Node<'tree>,
14120 src: &'tree [u8],
14121 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14122 debug_assert_eq!(node.kind(), "integer_literal");
14123 Ok(Self {
14124 span: ::treesitter_types::Span::from(node),
14125 text: node.utf8_text(src)?,
14126 })
14127 }
14128}
14129impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
14130 fn text(&self) -> &'tree str {
14131 self.text
14132 }
14133}
14134impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
14135 fn span(&self) -> ::treesitter_types::Span {
14136 self.span
14137 }
14138}
14139#[derive(Debug, Clone, PartialEq, Eq)]
14140pub struct InterpolationBrace<'tree> {
14141 pub span: ::treesitter_types::Span,
14142 text: &'tree str,
14143}
14144impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationBrace<'tree> {
14145 fn from_node(
14146 node: ::treesitter_types::tree_sitter::Node<'tree>,
14147 src: &'tree [u8],
14148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14149 debug_assert_eq!(node.kind(), "interpolation_brace");
14150 Ok(Self {
14151 span: ::treesitter_types::Span::from(node),
14152 text: node.utf8_text(src)?,
14153 })
14154 }
14155}
14156impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationBrace<'tree> {
14157 fn text(&self) -> &'tree str {
14158 self.text
14159 }
14160}
14161impl ::treesitter_types::Spanned for InterpolationBrace<'_> {
14162 fn span(&self) -> ::treesitter_types::Span {
14163 self.span
14164 }
14165}
14166#[derive(Debug, Clone, PartialEq, Eq)]
14167pub struct InterpolationQuote<'tree> {
14168 pub span: ::treesitter_types::Span,
14169 text: &'tree str,
14170}
14171impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationQuote<'tree> {
14172 fn from_node(
14173 node: ::treesitter_types::tree_sitter::Node<'tree>,
14174 src: &'tree [u8],
14175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14176 debug_assert_eq!(node.kind(), "interpolation_quote");
14177 Ok(Self {
14178 span: ::treesitter_types::Span::from(node),
14179 text: node.utf8_text(src)?,
14180 })
14181 }
14182}
14183impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationQuote<'tree> {
14184 fn text(&self) -> &'tree str {
14185 self.text
14186 }
14187}
14188impl ::treesitter_types::Spanned for InterpolationQuote<'_> {
14189 fn span(&self) -> ::treesitter_types::Span {
14190 self.span
14191 }
14192}
14193#[derive(Debug, Clone, PartialEq, Eq)]
14194pub struct InterpolationStart<'tree> {
14195 pub span: ::treesitter_types::Span,
14196 text: &'tree str,
14197}
14198impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationStart<'tree> {
14199 fn from_node(
14200 node: ::treesitter_types::tree_sitter::Node<'tree>,
14201 src: &'tree [u8],
14202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14203 debug_assert_eq!(node.kind(), "interpolation_start");
14204 Ok(Self {
14205 span: ::treesitter_types::Span::from(node),
14206 text: node.utf8_text(src)?,
14207 })
14208 }
14209}
14210impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpolationStart<'tree> {
14211 fn text(&self) -> &'tree str {
14212 self.text
14213 }
14214}
14215impl ::treesitter_types::Spanned for InterpolationStart<'_> {
14216 fn span(&self) -> ::treesitter_types::Span {
14217 self.span
14218 }
14219}
14220#[derive(Debug, Clone, PartialEq, Eq)]
14221pub struct NullLiteral<'tree> {
14222 pub span: ::treesitter_types::Span,
14223 text: &'tree str,
14224}
14225impl<'tree> ::treesitter_types::FromNode<'tree> for NullLiteral<'tree> {
14226 fn from_node(
14227 node: ::treesitter_types::tree_sitter::Node<'tree>,
14228 src: &'tree [u8],
14229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14230 debug_assert_eq!(node.kind(), "null_literal");
14231 Ok(Self {
14232 span: ::treesitter_types::Span::from(node),
14233 text: node.utf8_text(src)?,
14234 })
14235 }
14236}
14237impl<'tree> ::treesitter_types::LeafNode<'tree> for NullLiteral<'tree> {
14238 fn text(&self) -> &'tree str {
14239 self.text
14240 }
14241}
14242impl ::treesitter_types::Spanned for NullLiteral<'_> {
14243 fn span(&self) -> ::treesitter_types::Span {
14244 self.span
14245 }
14246}
14247#[derive(Debug, Clone, PartialEq, Eq)]
14248pub struct PredefinedType<'tree> {
14249 pub span: ::treesitter_types::Span,
14250 text: &'tree str,
14251}
14252impl<'tree> ::treesitter_types::FromNode<'tree> for PredefinedType<'tree> {
14253 fn from_node(
14254 node: ::treesitter_types::tree_sitter::Node<'tree>,
14255 src: &'tree [u8],
14256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14257 debug_assert_eq!(node.kind(), "predefined_type");
14258 Ok(Self {
14259 span: ::treesitter_types::Span::from(node),
14260 text: node.utf8_text(src)?,
14261 })
14262 }
14263}
14264impl<'tree> ::treesitter_types::LeafNode<'tree> for PredefinedType<'tree> {
14265 fn text(&self) -> &'tree str {
14266 self.text
14267 }
14268}
14269impl ::treesitter_types::Spanned for PredefinedType<'_> {
14270 fn span(&self) -> ::treesitter_types::Span {
14271 self.span
14272 }
14273}
14274#[derive(Debug, Clone, PartialEq, Eq)]
14275pub struct PreprocArg<'tree> {
14276 pub span: ::treesitter_types::Span,
14277 text: &'tree str,
14278}
14279impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
14280 fn from_node(
14281 node: ::treesitter_types::tree_sitter::Node<'tree>,
14282 src: &'tree [u8],
14283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14284 debug_assert_eq!(node.kind(), "preproc_arg");
14285 Ok(Self {
14286 span: ::treesitter_types::Span::from(node),
14287 text: node.utf8_text(src)?,
14288 })
14289 }
14290}
14291impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
14292 fn text(&self) -> &'tree str {
14293 self.text
14294 }
14295}
14296impl ::treesitter_types::Spanned for PreprocArg<'_> {
14297 fn span(&self) -> ::treesitter_types::Span {
14298 self.span
14299 }
14300}
14301#[derive(Debug, Clone, PartialEq, Eq)]
14302pub struct RawStringContent<'tree> {
14303 pub span: ::treesitter_types::Span,
14304 text: &'tree str,
14305}
14306impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringContent<'tree> {
14307 fn from_node(
14308 node: ::treesitter_types::tree_sitter::Node<'tree>,
14309 src: &'tree [u8],
14310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14311 debug_assert_eq!(node.kind(), "raw_string_content");
14312 Ok(Self {
14313 span: ::treesitter_types::Span::from(node),
14314 text: node.utf8_text(src)?,
14315 })
14316 }
14317}
14318impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringContent<'tree> {
14319 fn text(&self) -> &'tree str {
14320 self.text
14321 }
14322}
14323impl ::treesitter_types::Spanned for RawStringContent<'_> {
14324 fn span(&self) -> ::treesitter_types::Span {
14325 self.span
14326 }
14327}
14328#[derive(Debug, Clone, PartialEq, Eq)]
14329pub struct RawStringEnd<'tree> {
14330 pub span: ::treesitter_types::Span,
14331 text: &'tree str,
14332}
14333impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringEnd<'tree> {
14334 fn from_node(
14335 node: ::treesitter_types::tree_sitter::Node<'tree>,
14336 src: &'tree [u8],
14337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14338 debug_assert_eq!(node.kind(), "raw_string_end");
14339 Ok(Self {
14340 span: ::treesitter_types::Span::from(node),
14341 text: node.utf8_text(src)?,
14342 })
14343 }
14344}
14345impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringEnd<'tree> {
14346 fn text(&self) -> &'tree str {
14347 self.text
14348 }
14349}
14350impl ::treesitter_types::Spanned for RawStringEnd<'_> {
14351 fn span(&self) -> ::treesitter_types::Span {
14352 self.span
14353 }
14354}
14355#[derive(Debug, Clone, PartialEq, Eq)]
14356pub struct RawStringStart<'tree> {
14357 pub span: ::treesitter_types::Span,
14358 text: &'tree str,
14359}
14360impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringStart<'tree> {
14361 fn from_node(
14362 node: ::treesitter_types::tree_sitter::Node<'tree>,
14363 src: &'tree [u8],
14364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14365 debug_assert_eq!(node.kind(), "raw_string_start");
14366 Ok(Self {
14367 span: ::treesitter_types::Span::from(node),
14368 text: node.utf8_text(src)?,
14369 })
14370 }
14371}
14372impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringStart<'tree> {
14373 fn text(&self) -> &'tree str {
14374 self.text
14375 }
14376}
14377impl ::treesitter_types::Spanned for RawStringStart<'_> {
14378 fn span(&self) -> ::treesitter_types::Span {
14379 self.span
14380 }
14381}
14382#[derive(Debug, Clone, PartialEq, Eq)]
14383pub struct RealLiteral<'tree> {
14384 pub span: ::treesitter_types::Span,
14385 text: &'tree str,
14386}
14387impl<'tree> ::treesitter_types::FromNode<'tree> for RealLiteral<'tree> {
14388 fn from_node(
14389 node: ::treesitter_types::tree_sitter::Node<'tree>,
14390 src: &'tree [u8],
14391 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14392 debug_assert_eq!(node.kind(), "real_literal");
14393 Ok(Self {
14394 span: ::treesitter_types::Span::from(node),
14395 text: node.utf8_text(src)?,
14396 })
14397 }
14398}
14399impl<'tree> ::treesitter_types::LeafNode<'tree> for RealLiteral<'tree> {
14400 fn text(&self) -> &'tree str {
14401 self.text
14402 }
14403}
14404impl ::treesitter_types::Spanned for RealLiteral<'_> {
14405 fn span(&self) -> ::treesitter_types::Span {
14406 self.span
14407 }
14408}
14409#[derive(Debug, Clone, PartialEq, Eq)]
14410pub struct ShebangDirective<'tree> {
14411 pub span: ::treesitter_types::Span,
14412 text: &'tree str,
14413}
14414impl<'tree> ::treesitter_types::FromNode<'tree> for ShebangDirective<'tree> {
14415 fn from_node(
14416 node: ::treesitter_types::tree_sitter::Node<'tree>,
14417 src: &'tree [u8],
14418 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14419 debug_assert_eq!(node.kind(), "shebang_directive");
14420 Ok(Self {
14421 span: ::treesitter_types::Span::from(node),
14422 text: node.utf8_text(src)?,
14423 })
14424 }
14425}
14426impl<'tree> ::treesitter_types::LeafNode<'tree> for ShebangDirective<'tree> {
14427 fn text(&self) -> &'tree str {
14428 self.text
14429 }
14430}
14431impl ::treesitter_types::Spanned for ShebangDirective<'_> {
14432 fn span(&self) -> ::treesitter_types::Span {
14433 self.span
14434 }
14435}
14436#[derive(Debug, Clone, PartialEq, Eq)]
14437pub struct StringContent<'tree> {
14438 pub span: ::treesitter_types::Span,
14439 text: &'tree str,
14440}
14441impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
14442 fn from_node(
14443 node: ::treesitter_types::tree_sitter::Node<'tree>,
14444 src: &'tree [u8],
14445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14446 debug_assert_eq!(node.kind(), "string_content");
14447 Ok(Self {
14448 span: ::treesitter_types::Span::from(node),
14449 text: node.utf8_text(src)?,
14450 })
14451 }
14452}
14453impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
14454 fn text(&self) -> &'tree str {
14455 self.text
14456 }
14457}
14458impl ::treesitter_types::Spanned for StringContent<'_> {
14459 fn span(&self) -> ::treesitter_types::Span {
14460 self.span
14461 }
14462}
14463#[derive(Debug, Clone, PartialEq, Eq)]
14464pub struct StringLiteralContent<'tree> {
14465 pub span: ::treesitter_types::Span,
14466 text: &'tree str,
14467}
14468impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralContent<'tree> {
14469 fn from_node(
14470 node: ::treesitter_types::tree_sitter::Node<'tree>,
14471 src: &'tree [u8],
14472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14473 debug_assert_eq!(node.kind(), "string_literal_content");
14474 Ok(Self {
14475 span: ::treesitter_types::Span::from(node),
14476 text: node.utf8_text(src)?,
14477 })
14478 }
14479}
14480impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralContent<'tree> {
14481 fn text(&self) -> &'tree str {
14482 self.text
14483 }
14484}
14485impl ::treesitter_types::Spanned for StringLiteralContent<'_> {
14486 fn span(&self) -> ::treesitter_types::Span {
14487 self.span
14488 }
14489}
14490#[derive(Debug, Clone, PartialEq, Eq)]
14491pub struct StringLiteralEncoding<'tree> {
14492 pub span: ::treesitter_types::Span,
14493 text: &'tree str,
14494}
14495impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralEncoding<'tree> {
14496 fn from_node(
14497 node: ::treesitter_types::tree_sitter::Node<'tree>,
14498 src: &'tree [u8],
14499 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14500 debug_assert_eq!(node.kind(), "string_literal_encoding");
14501 Ok(Self {
14502 span: ::treesitter_types::Span::from(node),
14503 text: node.utf8_text(src)?,
14504 })
14505 }
14506}
14507impl<'tree> ::treesitter_types::LeafNode<'tree> for StringLiteralEncoding<'tree> {
14508 fn text(&self) -> &'tree str {
14509 self.text
14510 }
14511}
14512impl ::treesitter_types::Spanned for StringLiteralEncoding<'_> {
14513 fn span(&self) -> ::treesitter_types::Span {
14514 self.span
14515 }
14516}
14517#[derive(Debug, Clone, PartialEq, Eq)]
14518pub struct VerbatimStringLiteral<'tree> {
14519 pub span: ::treesitter_types::Span,
14520 text: &'tree str,
14521}
14522impl<'tree> ::treesitter_types::FromNode<'tree> for VerbatimStringLiteral<'tree> {
14523 fn from_node(
14524 node: ::treesitter_types::tree_sitter::Node<'tree>,
14525 src: &'tree [u8],
14526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14527 debug_assert_eq!(node.kind(), "verbatim_string_literal");
14528 Ok(Self {
14529 span: ::treesitter_types::Span::from(node),
14530 text: node.utf8_text(src)?,
14531 })
14532 }
14533}
14534impl<'tree> ::treesitter_types::LeafNode<'tree> for VerbatimStringLiteral<'tree> {
14535 fn text(&self) -> &'tree str {
14536 self.text
14537 }
14538}
14539impl ::treesitter_types::Spanned for VerbatimStringLiteral<'_> {
14540 fn span(&self) -> ::treesitter_types::Span {
14541 self.span
14542 }
14543}
14544#[derive(Debug, Clone, PartialEq, Eq)]
14545pub enum AccessorDeclarationBody<'tree> {
14546 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
14547 Block(::std::boxed::Box<Block<'tree>>),
14548}
14549impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationBody<'tree> {
14550 #[allow(clippy::collapsible_else_if)]
14551 fn from_node(
14552 node: ::treesitter_types::tree_sitter::Node<'tree>,
14553 src: &'tree [u8],
14554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14555 match node.kind() {
14556 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
14557 ::treesitter_types::runtime::maybe_grow_stack(|| {
14558 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
14559 })?,
14560 ))),
14561 "block" => Ok(Self::Block(::std::boxed::Box::new(
14562 ::treesitter_types::runtime::maybe_grow_stack(|| {
14563 <Block as ::treesitter_types::FromNode>::from_node(node, src)
14564 })?,
14565 ))),
14566 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14567 }
14568 }
14569}
14570impl ::treesitter_types::Spanned for AccessorDeclarationBody<'_> {
14571 fn span(&self) -> ::treesitter_types::Span {
14572 match self {
14573 Self::ArrowExpressionClause(inner) => inner.span(),
14574 Self::Block(inner) => inner.span(),
14575 }
14576 }
14577}
14578#[derive(Debug, Clone, PartialEq, Eq)]
14579pub enum AccessorDeclarationName<'tree> {
14580 Add(::treesitter_types::Span),
14581 Get(::treesitter_types::Span),
14582 Identifier(::std::boxed::Box<Identifier<'tree>>),
14583 Init(::treesitter_types::Span),
14584 Remove(::treesitter_types::Span),
14585 Set(::treesitter_types::Span),
14586}
14587impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationName<'tree> {
14588 #[allow(clippy::collapsible_else_if)]
14589 fn from_node(
14590 node: ::treesitter_types::tree_sitter::Node<'tree>,
14591 src: &'tree [u8],
14592 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14593 match node.kind() {
14594 "add" => Ok(Self::Add(::treesitter_types::Span::from(node))),
14595 "get" => Ok(Self::Get(::treesitter_types::Span::from(node))),
14596 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14597 ::treesitter_types::runtime::maybe_grow_stack(|| {
14598 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14599 })?,
14600 ))),
14601 "init" => Ok(Self::Init(::treesitter_types::Span::from(node))),
14602 "remove" => Ok(Self::Remove(::treesitter_types::Span::from(node))),
14603 "set" => Ok(Self::Set(::treesitter_types::Span::from(node))),
14604 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14605 }
14606 }
14607}
14608impl ::treesitter_types::Spanned for AccessorDeclarationName<'_> {
14609 fn span(&self) -> ::treesitter_types::Span {
14610 match self {
14611 Self::Add(span) => *span,
14612 Self::Get(span) => *span,
14613 Self::Identifier(inner) => inner.span(),
14614 Self::Init(span) => *span,
14615 Self::Remove(span) => *span,
14616 Self::Set(span) => *span,
14617 }
14618 }
14619}
14620#[derive(Debug, Clone, PartialEq, Eq)]
14621pub enum AccessorDeclarationChildren<'tree> {
14622 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
14623 Modifier(::std::boxed::Box<Modifier<'tree>>),
14624 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
14625}
14626impl<'tree> ::treesitter_types::FromNode<'tree> for AccessorDeclarationChildren<'tree> {
14627 #[allow(clippy::collapsible_else_if)]
14628 fn from_node(
14629 node: ::treesitter_types::tree_sitter::Node<'tree>,
14630 src: &'tree [u8],
14631 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14632 match node.kind() {
14633 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
14634 ::treesitter_types::runtime::maybe_grow_stack(|| {
14635 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
14636 })?,
14637 ))),
14638 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14639 ::treesitter_types::runtime::maybe_grow_stack(|| {
14640 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
14641 })?,
14642 ))),
14643 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
14644 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14645 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
14646 })?),
14647 )),
14648 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14649 }
14650 }
14651}
14652impl ::treesitter_types::Spanned for AccessorDeclarationChildren<'_> {
14653 fn span(&self) -> ::treesitter_types::Span {
14654 match self {
14655 Self::AttributeList(inner) => inner.span(),
14656 Self::Modifier(inner) => inner.span(),
14657 Self::PreprocIfInAttributeList(inner) => inner.span(),
14658 }
14659 }
14660}
14661#[derive(Debug, Clone, PartialEq, Eq)]
14662pub enum AliasQualifiedNameName<'tree> {
14663 GenericName(::std::boxed::Box<GenericName<'tree>>),
14664 Identifier(::std::boxed::Box<Identifier<'tree>>),
14665}
14666impl<'tree> ::treesitter_types::FromNode<'tree> for AliasQualifiedNameName<'tree> {
14667 #[allow(clippy::collapsible_else_if)]
14668 fn from_node(
14669 node: ::treesitter_types::tree_sitter::Node<'tree>,
14670 src: &'tree [u8],
14671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14672 match node.kind() {
14673 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14674 ::treesitter_types::runtime::maybe_grow_stack(|| {
14675 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
14676 })?,
14677 ))),
14678 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14679 ::treesitter_types::runtime::maybe_grow_stack(|| {
14680 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14681 })?,
14682 ))),
14683 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14684 }
14685 }
14686}
14687impl ::treesitter_types::Spanned for AliasQualifiedNameName<'_> {
14688 fn span(&self) -> ::treesitter_types::Span {
14689 match self {
14690 Self::GenericName(inner) => inner.span(),
14691 Self::Identifier(inner) => inner.span(),
14692 }
14693 }
14694}
14695#[derive(Debug, Clone, PartialEq, Eq)]
14696pub enum AndPatternOperator {
14697 And(::treesitter_types::Span),
14698}
14699impl<'tree> ::treesitter_types::FromNode<'tree> for AndPatternOperator {
14700 #[allow(clippy::collapsible_else_if)]
14701 fn from_node(
14702 node: ::treesitter_types::tree_sitter::Node<'tree>,
14703 _src: &'tree [u8],
14704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14705 match node.kind() {
14706 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
14707 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14708 }
14709 }
14710}
14711impl ::treesitter_types::Spanned for AndPatternOperator {
14712 fn span(&self) -> ::treesitter_types::Span {
14713 match self {
14714 Self::And(span) => *span,
14715 }
14716 }
14717}
14718#[derive(Debug, Clone, PartialEq, Eq)]
14719pub enum AnonymousMethodExpressionChildren<'tree> {
14720 Block(::std::boxed::Box<Block<'tree>>),
14721 Modifier(::std::boxed::Box<Modifier<'tree>>),
14722}
14723impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousMethodExpressionChildren<'tree> {
14724 #[allow(clippy::collapsible_else_if)]
14725 fn from_node(
14726 node: ::treesitter_types::tree_sitter::Node<'tree>,
14727 src: &'tree [u8],
14728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14729 match node.kind() {
14730 "block" => Ok(Self::Block(::std::boxed::Box::new(
14731 ::treesitter_types::runtime::maybe_grow_stack(|| {
14732 <Block as ::treesitter_types::FromNode>::from_node(node, src)
14733 })?,
14734 ))),
14735 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
14736 ::treesitter_types::runtime::maybe_grow_stack(|| {
14737 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
14738 })?,
14739 ))),
14740 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14741 }
14742 }
14743}
14744impl ::treesitter_types::Spanned for AnonymousMethodExpressionChildren<'_> {
14745 fn span(&self) -> ::treesitter_types::Span {
14746 match self {
14747 Self::Block(inner) => inner.span(),
14748 Self::Modifier(inner) => inner.span(),
14749 }
14750 }
14751}
14752#[derive(Debug, Clone, PartialEq, Eq)]
14753pub enum AnonymousObjectCreationExpressionChildren<'tree> {
14754 Expression(::std::boxed::Box<Expression<'tree>>),
14755 Identifier(::std::boxed::Box<Identifier<'tree>>),
14756}
14757impl<'tree> ::treesitter_types::FromNode<'tree>
14758 for AnonymousObjectCreationExpressionChildren<'tree>
14759{
14760 #[allow(clippy::collapsible_else_if)]
14761 fn from_node(
14762 node: ::treesitter_types::tree_sitter::Node<'tree>,
14763 src: &'tree [u8],
14764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14765 match node.kind() {
14766 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14767 ::treesitter_types::runtime::maybe_grow_stack(|| {
14768 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14769 })?,
14770 ))),
14771 _other => {
14772 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14773 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14774 }) {
14775 Ok(Self::Expression(::std::boxed::Box::new(v)))
14776 } else {
14777 Err(::treesitter_types::ParseError::unexpected_kind(
14778 _other, node,
14779 ))
14780 }
14781 }
14782 }
14783 }
14784}
14785impl ::treesitter_types::Spanned for AnonymousObjectCreationExpressionChildren<'_> {
14786 fn span(&self) -> ::treesitter_types::Span {
14787 match self {
14788 Self::Expression(inner) => inner.span(),
14789 Self::Identifier(inner) => inner.span(),
14790 }
14791 }
14792}
14793#[derive(Debug, Clone, PartialEq, Eq)]
14794pub enum ArgumentChildren<'tree> {
14795 DeclarationExpression(::std::boxed::Box<DeclarationExpression<'tree>>),
14796 Expression(::std::boxed::Box<Expression<'tree>>),
14797}
14798impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentChildren<'tree> {
14799 #[allow(clippy::collapsible_else_if)]
14800 fn from_node(
14801 node: ::treesitter_types::tree_sitter::Node<'tree>,
14802 src: &'tree [u8],
14803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14804 match node.kind() {
14805 "declaration_expression" => Ok(Self::DeclarationExpression(::std::boxed::Box::new(
14806 ::treesitter_types::runtime::maybe_grow_stack(|| {
14807 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14808 })?,
14809 ))),
14810 _other => {
14811 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14812 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14813 }) {
14814 Ok(Self::Expression(::std::boxed::Box::new(v)))
14815 } else {
14816 Err(::treesitter_types::ParseError::unexpected_kind(
14817 _other, node,
14818 ))
14819 }
14820 }
14821 }
14822 }
14823}
14824impl ::treesitter_types::Spanned for ArgumentChildren<'_> {
14825 fn span(&self) -> ::treesitter_types::Span {
14826 match self {
14827 Self::DeclarationExpression(inner) => inner.span(),
14828 Self::Expression(inner) => inner.span(),
14829 }
14830 }
14831}
14832#[derive(Debug, Clone, PartialEq, Eq)]
14833pub enum ArrayTypeType<'tree> {
14834 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
14835 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
14836 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
14837 GenericName(::std::boxed::Box<GenericName<'tree>>),
14838 Identifier(::std::boxed::Box<Identifier<'tree>>),
14839 NullableType(::std::boxed::Box<NullableType<'tree>>),
14840 PointerType(::std::boxed::Box<PointerType<'tree>>),
14841 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
14842 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14843 TupleType(::std::boxed::Box<TupleType<'tree>>),
14844}
14845impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayTypeType<'tree> {
14846 #[allow(clippy::collapsible_else_if)]
14847 fn from_node(
14848 node: ::treesitter_types::tree_sitter::Node<'tree>,
14849 src: &'tree [u8],
14850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14851 match node.kind() {
14852 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
14853 ::treesitter_types::runtime::maybe_grow_stack(|| {
14854 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14855 })?,
14856 ))),
14857 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
14858 ::treesitter_types::runtime::maybe_grow_stack(|| {
14859 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
14860 })?,
14861 ))),
14862 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
14863 ::treesitter_types::runtime::maybe_grow_stack(|| {
14864 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
14865 })?,
14866 ))),
14867 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
14868 ::treesitter_types::runtime::maybe_grow_stack(|| {
14869 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
14870 })?,
14871 ))),
14872 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14873 ::treesitter_types::runtime::maybe_grow_stack(|| {
14874 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14875 })?,
14876 ))),
14877 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
14878 ::treesitter_types::runtime::maybe_grow_stack(|| {
14879 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
14880 })?,
14881 ))),
14882 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
14883 ::treesitter_types::runtime::maybe_grow_stack(|| {
14884 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
14885 })?,
14886 ))),
14887 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
14888 ::treesitter_types::runtime::maybe_grow_stack(|| {
14889 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
14890 })?,
14891 ))),
14892 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14893 ::treesitter_types::runtime::maybe_grow_stack(|| {
14894 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14895 })?,
14896 ))),
14897 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
14898 ::treesitter_types::runtime::maybe_grow_stack(|| {
14899 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
14900 })?,
14901 ))),
14902 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14903 }
14904 }
14905}
14906impl ::treesitter_types::Spanned for ArrayTypeType<'_> {
14907 fn span(&self) -> ::treesitter_types::Span {
14908 match self {
14909 Self::AliasQualifiedName(inner) => inner.span(),
14910 Self::ArrayType(inner) => inner.span(),
14911 Self::FunctionPointerType(inner) => inner.span(),
14912 Self::GenericName(inner) => inner.span(),
14913 Self::Identifier(inner) => inner.span(),
14914 Self::NullableType(inner) => inner.span(),
14915 Self::PointerType(inner) => inner.span(),
14916 Self::PredefinedType(inner) => inner.span(),
14917 Self::QualifiedName(inner) => inner.span(),
14918 Self::TupleType(inner) => inner.span(),
14919 }
14920 }
14921}
14922#[derive(Debug, Clone, PartialEq, Eq)]
14923pub enum AsExpressionOperator {
14924 As(::treesitter_types::Span),
14925}
14926impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpressionOperator {
14927 #[allow(clippy::collapsible_else_if)]
14928 fn from_node(
14929 node: ::treesitter_types::tree_sitter::Node<'tree>,
14930 _src: &'tree [u8],
14931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14932 match node.kind() {
14933 "as" => Ok(Self::As(::treesitter_types::Span::from(node))),
14934 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14935 }
14936 }
14937}
14938impl ::treesitter_types::Spanned for AsExpressionOperator {
14939 fn span(&self) -> ::treesitter_types::Span {
14940 match self {
14941 Self::As(span) => *span,
14942 }
14943 }
14944}
14945#[derive(Debug, Clone, PartialEq, Eq)]
14946pub enum AssignmentExpressionOperator {
14947 PercentEq(::treesitter_types::Span),
14948 AmpEq(::treesitter_types::Span),
14949 StarEq(::treesitter_types::Span),
14950 PlusEq(::treesitter_types::Span),
14951 MinusEq(::treesitter_types::Span),
14952 SlashEq(::treesitter_types::Span),
14953 ShlEq(::treesitter_types::Span),
14954 Eq(::treesitter_types::Span),
14955 ShrEq(::treesitter_types::Span),
14956 GtGtGtEq(::treesitter_types::Span),
14957 QuestionQuestionEq(::treesitter_types::Span),
14958 CaretEq(::treesitter_types::Span),
14959 PipeEq(::treesitter_types::Span),
14960}
14961impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
14962 #[allow(clippy::collapsible_else_if)]
14963 fn from_node(
14964 node: ::treesitter_types::tree_sitter::Node<'tree>,
14965 _src: &'tree [u8],
14966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14967 match node.kind() {
14968 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
14969 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
14970 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
14971 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
14972 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
14973 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
14974 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
14975 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
14976 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
14977 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
14978 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
14979 node,
14980 ))),
14981 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
14982 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
14983 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14984 }
14985 }
14986}
14987impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
14988 fn span(&self) -> ::treesitter_types::Span {
14989 match self {
14990 Self::PercentEq(span) => *span,
14991 Self::AmpEq(span) => *span,
14992 Self::StarEq(span) => *span,
14993 Self::PlusEq(span) => *span,
14994 Self::MinusEq(span) => *span,
14995 Self::SlashEq(span) => *span,
14996 Self::ShlEq(span) => *span,
14997 Self::Eq(span) => *span,
14998 Self::ShrEq(span) => *span,
14999 Self::GtGtGtEq(span) => *span,
15000 Self::QuestionQuestionEq(span) => *span,
15001 Self::CaretEq(span) => *span,
15002 Self::PipeEq(span) => *span,
15003 }
15004 }
15005}
15006#[derive(Debug, Clone, PartialEq, Eq)]
15007pub enum AttributeName<'tree> {
15008 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
15009 GenericName(::std::boxed::Box<GenericName<'tree>>),
15010 Identifier(::std::boxed::Box<Identifier<'tree>>),
15011 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15012}
15013impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeName<'tree> {
15014 #[allow(clippy::collapsible_else_if)]
15015 fn from_node(
15016 node: ::treesitter_types::tree_sitter::Node<'tree>,
15017 src: &'tree [u8],
15018 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15019 match node.kind() {
15020 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
15021 ::treesitter_types::runtime::maybe_grow_stack(|| {
15022 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15023 })?,
15024 ))),
15025 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15026 ::treesitter_types::runtime::maybe_grow_stack(|| {
15027 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
15028 })?,
15029 ))),
15030 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15031 ::treesitter_types::runtime::maybe_grow_stack(|| {
15032 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15033 })?,
15034 ))),
15035 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15036 ::treesitter_types::runtime::maybe_grow_stack(|| {
15037 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15038 })?,
15039 ))),
15040 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15041 }
15042 }
15043}
15044impl ::treesitter_types::Spanned for AttributeName<'_> {
15045 fn span(&self) -> ::treesitter_types::Span {
15046 match self {
15047 Self::AliasQualifiedName(inner) => inner.span(),
15048 Self::GenericName(inner) => inner.span(),
15049 Self::Identifier(inner) => inner.span(),
15050 Self::QualifiedName(inner) => inner.span(),
15051 }
15052 }
15053}
15054#[derive(Debug, Clone, PartialEq, Eq)]
15055pub enum AttributeListChildren<'tree> {
15056 Attribute(::std::boxed::Box<Attribute<'tree>>),
15057 AttributeTargetSpecifier(::std::boxed::Box<AttributeTargetSpecifier<'tree>>),
15058}
15059impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeListChildren<'tree> {
15060 #[allow(clippy::collapsible_else_if)]
15061 fn from_node(
15062 node: ::treesitter_types::tree_sitter::Node<'tree>,
15063 src: &'tree [u8],
15064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15065 match node.kind() {
15066 "attribute" => Ok(Self::Attribute(::std::boxed::Box::new(
15067 ::treesitter_types::runtime::maybe_grow_stack(|| {
15068 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
15069 })?,
15070 ))),
15071 "attribute_target_specifier" => Ok(Self::AttributeTargetSpecifier(
15072 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15073 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15074 })?),
15075 )),
15076 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15077 }
15078 }
15079}
15080impl ::treesitter_types::Spanned for AttributeListChildren<'_> {
15081 fn span(&self) -> ::treesitter_types::Span {
15082 match self {
15083 Self::Attribute(inner) => inner.span(),
15084 Self::AttributeTargetSpecifier(inner) => inner.span(),
15085 }
15086 }
15087}
15088#[derive(Debug, Clone, PartialEq, Eq)]
15089pub enum BaseListChildren<'tree> {
15090 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
15091 PrimaryConstructorBaseType(::std::boxed::Box<PrimaryConstructorBaseType<'tree>>),
15092 Type(::std::boxed::Box<Type<'tree>>),
15093}
15094impl<'tree> ::treesitter_types::FromNode<'tree> for BaseListChildren<'tree> {
15095 #[allow(clippy::collapsible_else_if)]
15096 fn from_node(
15097 node: ::treesitter_types::tree_sitter::Node<'tree>,
15098 src: &'tree [u8],
15099 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15100 match node.kind() {
15101 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
15102 ::treesitter_types::runtime::maybe_grow_stack(|| {
15103 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
15104 })?,
15105 ))),
15106 "primary_constructor_base_type" => Ok(Self::PrimaryConstructorBaseType(
15107 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15108 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(
15109 node, src,
15110 )
15111 })?),
15112 )),
15113 _other => {
15114 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15115 <Type as ::treesitter_types::FromNode>::from_node(node, src)
15116 }) {
15117 Ok(Self::Type(::std::boxed::Box::new(v)))
15118 } else {
15119 Err(::treesitter_types::ParseError::unexpected_kind(
15120 _other, node,
15121 ))
15122 }
15123 }
15124 }
15125 }
15126}
15127impl ::treesitter_types::Spanned for BaseListChildren<'_> {
15128 fn span(&self) -> ::treesitter_types::Span {
15129 match self {
15130 Self::ArgumentList(inner) => inner.span(),
15131 Self::PrimaryConstructorBaseType(inner) => inner.span(),
15132 Self::Type(inner) => inner.span(),
15133 }
15134 }
15135}
15136#[derive(Debug, Clone, PartialEq, Eq)]
15137pub enum BinaryExpressionLeft<'tree> {
15138 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
15139 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
15140 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
15141 Expression(::std::boxed::Box<Expression<'tree>>),
15142 Identifier(::std::boxed::Box<Identifier<'tree>>),
15143 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
15144 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15145 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
15146}
15147impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
15148 #[allow(clippy::collapsible_else_if)]
15149 fn from_node(
15150 node: ::treesitter_types::tree_sitter::Node<'tree>,
15151 src: &'tree [u8],
15152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15153 match node.kind() {
15154 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
15155 ::treesitter_types::runtime::maybe_grow_stack(|| {
15156 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15157 })?,
15158 ))),
15159 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
15160 ::treesitter_types::runtime::maybe_grow_stack(|| {
15161 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15162 })?,
15163 ))),
15164 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
15165 ::treesitter_types::runtime::maybe_grow_stack(|| {
15166 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15167 })?,
15168 ))),
15169 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15170 ::treesitter_types::runtime::maybe_grow_stack(|| {
15171 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15172 })?,
15173 ))),
15174 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
15175 ::treesitter_types::runtime::maybe_grow_stack(|| {
15176 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15177 })?,
15178 ))),
15179 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15180 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15181 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15182 })?),
15183 )),
15184 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
15185 ::treesitter_types::runtime::maybe_grow_stack(|| {
15186 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15187 })?,
15188 ))),
15189 _other => {
15190 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15191 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15192 }) {
15193 Ok(Self::Expression(::std::boxed::Box::new(v)))
15194 } else {
15195 Err(::treesitter_types::ParseError::unexpected_kind(
15196 _other, node,
15197 ))
15198 }
15199 }
15200 }
15201 }
15202}
15203impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
15204 fn span(&self) -> ::treesitter_types::Span {
15205 match self {
15206 Self::BinaryExpression(inner) => inner.span(),
15207 Self::BooleanLiteral(inner) => inner.span(),
15208 Self::CharacterLiteral(inner) => inner.span(),
15209 Self::Expression(inner) => inner.span(),
15210 Self::Identifier(inner) => inner.span(),
15211 Self::IntegerLiteral(inner) => inner.span(),
15212 Self::ParenthesizedExpression(inner) => inner.span(),
15213 Self::UnaryExpression(inner) => inner.span(),
15214 }
15215 }
15216}
15217#[derive(Debug, Clone, PartialEq, Eq)]
15218pub enum BinaryExpressionOperator {
15219 NotEq(::treesitter_types::Span),
15220 Percent(::treesitter_types::Span),
15221 Amp(::treesitter_types::Span),
15222 AmpAmp(::treesitter_types::Span),
15223 Star(::treesitter_types::Span),
15224 Plus(::treesitter_types::Span),
15225 Minus(::treesitter_types::Span),
15226 Slash(::treesitter_types::Span),
15227 Lt(::treesitter_types::Span),
15228 Shl(::treesitter_types::Span),
15229 LtEq(::treesitter_types::Span),
15230 EqEq(::treesitter_types::Span),
15231 Gt(::treesitter_types::Span),
15232 GtEq(::treesitter_types::Span),
15233 Shr(::treesitter_types::Span),
15234 GtGtGt(::treesitter_types::Span),
15235 QuestionQuestion(::treesitter_types::Span),
15236 Caret(::treesitter_types::Span),
15237 Pipe(::treesitter_types::Span),
15238 PipePipe(::treesitter_types::Span),
15239}
15240impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
15241 #[allow(clippy::collapsible_else_if)]
15242 fn from_node(
15243 node: ::treesitter_types::tree_sitter::Node<'tree>,
15244 _src: &'tree [u8],
15245 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15246 match node.kind() {
15247 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
15248 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
15249 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
15250 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
15251 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
15252 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
15253 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
15254 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
15255 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
15256 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
15257 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
15258 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
15259 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
15260 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
15261 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
15262 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
15263 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
15264 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
15265 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
15266 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
15267 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15268 }
15269 }
15270}
15271impl ::treesitter_types::Spanned for BinaryExpressionOperator {
15272 fn span(&self) -> ::treesitter_types::Span {
15273 match self {
15274 Self::NotEq(span) => *span,
15275 Self::Percent(span) => *span,
15276 Self::Amp(span) => *span,
15277 Self::AmpAmp(span) => *span,
15278 Self::Star(span) => *span,
15279 Self::Plus(span) => *span,
15280 Self::Minus(span) => *span,
15281 Self::Slash(span) => *span,
15282 Self::Lt(span) => *span,
15283 Self::Shl(span) => *span,
15284 Self::LtEq(span) => *span,
15285 Self::EqEq(span) => *span,
15286 Self::Gt(span) => *span,
15287 Self::GtEq(span) => *span,
15288 Self::Shr(span) => *span,
15289 Self::GtGtGt(span) => *span,
15290 Self::QuestionQuestion(span) => *span,
15291 Self::Caret(span) => *span,
15292 Self::Pipe(span) => *span,
15293 Self::PipePipe(span) => *span,
15294 }
15295 }
15296}
15297#[derive(Debug, Clone, PartialEq, Eq)]
15298pub enum BinaryExpressionRight<'tree> {
15299 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
15300 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
15301 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
15302 Expression(::std::boxed::Box<Expression<'tree>>),
15303 Identifier(::std::boxed::Box<Identifier<'tree>>),
15304 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
15305 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15306 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
15307}
15308impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
15309 #[allow(clippy::collapsible_else_if)]
15310 fn from_node(
15311 node: ::treesitter_types::tree_sitter::Node<'tree>,
15312 src: &'tree [u8],
15313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15314 match node.kind() {
15315 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
15316 ::treesitter_types::runtime::maybe_grow_stack(|| {
15317 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15318 })?,
15319 ))),
15320 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
15321 ::treesitter_types::runtime::maybe_grow_stack(|| {
15322 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15323 })?,
15324 ))),
15325 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
15326 ::treesitter_types::runtime::maybe_grow_stack(|| {
15327 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15328 })?,
15329 ))),
15330 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15331 ::treesitter_types::runtime::maybe_grow_stack(|| {
15332 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15333 })?,
15334 ))),
15335 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
15336 ::treesitter_types::runtime::maybe_grow_stack(|| {
15337 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15338 })?,
15339 ))),
15340 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15341 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15342 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15343 })?),
15344 )),
15345 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
15346 ::treesitter_types::runtime::maybe_grow_stack(|| {
15347 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15348 })?,
15349 ))),
15350 _other => {
15351 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15352 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15353 }) {
15354 Ok(Self::Expression(::std::boxed::Box::new(v)))
15355 } else {
15356 Err(::treesitter_types::ParseError::unexpected_kind(
15357 _other, node,
15358 ))
15359 }
15360 }
15361 }
15362 }
15363}
15364impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
15365 fn span(&self) -> ::treesitter_types::Span {
15366 match self {
15367 Self::BinaryExpression(inner) => inner.span(),
15368 Self::BooleanLiteral(inner) => inner.span(),
15369 Self::CharacterLiteral(inner) => inner.span(),
15370 Self::Expression(inner) => inner.span(),
15371 Self::Identifier(inner) => inner.span(),
15372 Self::IntegerLiteral(inner) => inner.span(),
15373 Self::ParenthesizedExpression(inner) => inner.span(),
15374 Self::UnaryExpression(inner) => inner.span(),
15375 }
15376 }
15377}
15378#[derive(Debug, Clone, PartialEq, Eq)]
15379pub enum BracketedParameterListChildren<'tree> {
15380 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15381 Parameter(::std::boxed::Box<Parameter<'tree>>),
15382 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
15383}
15384impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedParameterListChildren<'tree> {
15385 #[allow(clippy::collapsible_else_if)]
15386 fn from_node(
15387 node: ::treesitter_types::tree_sitter::Node<'tree>,
15388 src: &'tree [u8],
15389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15390 match node.kind() {
15391 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15392 ::treesitter_types::runtime::maybe_grow_stack(|| {
15393 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15394 })?,
15395 ))),
15396 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
15397 ::treesitter_types::runtime::maybe_grow_stack(|| {
15398 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
15399 })?,
15400 ))),
15401 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
15402 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15403 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15404 })?),
15405 )),
15406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15407 }
15408 }
15409}
15410impl ::treesitter_types::Spanned for BracketedParameterListChildren<'_> {
15411 fn span(&self) -> ::treesitter_types::Span {
15412 match self {
15413 Self::AttributeList(inner) => inner.span(),
15414 Self::Parameter(inner) => inner.span(),
15415 Self::PreprocIfInAttributeList(inner) => inner.span(),
15416 }
15417 }
15418}
15419#[derive(Debug, Clone, PartialEq, Eq)]
15420pub enum CatchClauseChildren<'tree> {
15421 CatchDeclaration(::std::boxed::Box<CatchDeclaration<'tree>>),
15422 CatchFilterClause(::std::boxed::Box<CatchFilterClause<'tree>>),
15423}
15424impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseChildren<'tree> {
15425 #[allow(clippy::collapsible_else_if)]
15426 fn from_node(
15427 node: ::treesitter_types::tree_sitter::Node<'tree>,
15428 src: &'tree [u8],
15429 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15430 match node.kind() {
15431 "catch_declaration" => Ok(Self::CatchDeclaration(::std::boxed::Box::new(
15432 ::treesitter_types::runtime::maybe_grow_stack(|| {
15433 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15434 })?,
15435 ))),
15436 "catch_filter_clause" => Ok(Self::CatchFilterClause(::std::boxed::Box::new(
15437 ::treesitter_types::runtime::maybe_grow_stack(|| {
15438 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)
15439 })?,
15440 ))),
15441 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15442 }
15443 }
15444}
15445impl ::treesitter_types::Spanned for CatchClauseChildren<'_> {
15446 fn span(&self) -> ::treesitter_types::Span {
15447 match self {
15448 Self::CatchDeclaration(inner) => inner.span(),
15449 Self::CatchFilterClause(inner) => inner.span(),
15450 }
15451 }
15452}
15453#[derive(Debug, Clone, PartialEq, Eq)]
15454pub enum CharacterLiteralChildren<'tree> {
15455 CharacterLiteralContent(::std::boxed::Box<CharacterLiteralContent<'tree>>),
15456 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
15457}
15458impl<'tree> ::treesitter_types::FromNode<'tree> for CharacterLiteralChildren<'tree> {
15459 #[allow(clippy::collapsible_else_if)]
15460 fn from_node(
15461 node: ::treesitter_types::tree_sitter::Node<'tree>,
15462 src: &'tree [u8],
15463 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15464 match node.kind() {
15465 "character_literal_content" => Ok(Self::CharacterLiteralContent(
15466 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15467 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
15468 })?),
15469 )),
15470 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
15471 ::treesitter_types::runtime::maybe_grow_stack(|| {
15472 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
15473 })?,
15474 ))),
15475 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15476 }
15477 }
15478}
15479impl ::treesitter_types::Spanned for CharacterLiteralChildren<'_> {
15480 fn span(&self) -> ::treesitter_types::Span {
15481 match self {
15482 Self::CharacterLiteralContent(inner) => inner.span(),
15483 Self::EscapeSequence(inner) => inner.span(),
15484 }
15485 }
15486}
15487#[derive(Debug, Clone, PartialEq, Eq)]
15488pub enum ClassDeclarationChildren<'tree> {
15489 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15490 BaseList(::std::boxed::Box<BaseList<'tree>>),
15491 Modifier(::std::boxed::Box<Modifier<'tree>>),
15492 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
15493 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
15494 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
15495 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
15496}
15497impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarationChildren<'tree> {
15498 #[allow(clippy::collapsible_else_if)]
15499 fn from_node(
15500 node: ::treesitter_types::tree_sitter::Node<'tree>,
15501 src: &'tree [u8],
15502 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15503 match node.kind() {
15504 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15505 ::treesitter_types::runtime::maybe_grow_stack(|| {
15506 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15507 })?,
15508 ))),
15509 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
15510 ::treesitter_types::runtime::maybe_grow_stack(|| {
15511 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
15512 })?,
15513 ))),
15514 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15515 ::treesitter_types::runtime::maybe_grow_stack(|| {
15516 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15517 })?,
15518 ))),
15519 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
15520 ::treesitter_types::runtime::maybe_grow_stack(|| {
15521 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
15522 })?,
15523 ))),
15524 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
15525 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15526 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15527 })?),
15528 )),
15529 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
15530 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15531 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
15532 node, src,
15533 )
15534 })?),
15535 )),
15536 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
15537 ::treesitter_types::runtime::maybe_grow_stack(|| {
15538 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
15539 })?,
15540 ))),
15541 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15542 }
15543 }
15544}
15545impl ::treesitter_types::Spanned for ClassDeclarationChildren<'_> {
15546 fn span(&self) -> ::treesitter_types::Span {
15547 match self {
15548 Self::AttributeList(inner) => inner.span(),
15549 Self::BaseList(inner) => inner.span(),
15550 Self::Modifier(inner) => inner.span(),
15551 Self::ParameterList(inner) => inner.span(),
15552 Self::PreprocIfInAttributeList(inner) => inner.span(),
15553 Self::TypeParameterConstraintsClause(inner) => inner.span(),
15554 Self::TypeParameterList(inner) => inner.span(),
15555 }
15556 }
15557}
15558#[derive(Debug, Clone, PartialEq, Eq)]
15559pub enum CollectionElementChildren<'tree> {
15560 ExpressionElement(::std::boxed::Box<ExpressionElement<'tree>>),
15561 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
15562}
15563impl<'tree> ::treesitter_types::FromNode<'tree> for CollectionElementChildren<'tree> {
15564 #[allow(clippy::collapsible_else_if)]
15565 fn from_node(
15566 node: ::treesitter_types::tree_sitter::Node<'tree>,
15567 src: &'tree [u8],
15568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15569 match node.kind() {
15570 "expression_element" => Ok(Self::ExpressionElement(::std::boxed::Box::new(
15571 ::treesitter_types::runtime::maybe_grow_stack(|| {
15572 <ExpressionElement as ::treesitter_types::FromNode>::from_node(node, src)
15573 })?,
15574 ))),
15575 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
15576 ::treesitter_types::runtime::maybe_grow_stack(|| {
15577 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
15578 })?,
15579 ))),
15580 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15581 }
15582 }
15583}
15584impl ::treesitter_types::Spanned for CollectionElementChildren<'_> {
15585 fn span(&self) -> ::treesitter_types::Span {
15586 match self {
15587 Self::ExpressionElement(inner) => inner.span(),
15588 Self::SpreadElement(inner) => inner.span(),
15589 }
15590 }
15591}
15592#[derive(Debug, Clone, PartialEq, Eq)]
15593pub enum CompilationUnitChildren<'tree> {
15594 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
15595 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
15596 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
15597 GlobalStatement(::std::boxed::Box<GlobalStatement<'tree>>),
15598 NamespaceDeclaration(::std::boxed::Box<NamespaceDeclaration<'tree>>),
15599 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
15600 ShebangDirective(::std::boxed::Box<ShebangDirective<'tree>>),
15601 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
15602 UsingDirective(::std::boxed::Box<UsingDirective<'tree>>),
15603}
15604impl<'tree> ::treesitter_types::FromNode<'tree> for CompilationUnitChildren<'tree> {
15605 #[allow(clippy::collapsible_else_if)]
15606 fn from_node(
15607 node: ::treesitter_types::tree_sitter::Node<'tree>,
15608 src: &'tree [u8],
15609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15610 match node.kind() {
15611 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
15612 ::treesitter_types::runtime::maybe_grow_stack(|| {
15613 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
15614 })?,
15615 ))),
15616 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
15617 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15618 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
15619 node, src,
15620 )
15621 })?),
15622 )),
15623 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
15624 ::treesitter_types::runtime::maybe_grow_stack(|| {
15625 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
15626 })?,
15627 ))),
15628 "global_statement" => Ok(Self::GlobalStatement(::std::boxed::Box::new(
15629 ::treesitter_types::runtime::maybe_grow_stack(|| {
15630 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)
15631 })?,
15632 ))),
15633 "namespace_declaration" => Ok(Self::NamespaceDeclaration(::std::boxed::Box::new(
15634 ::treesitter_types::runtime::maybe_grow_stack(|| {
15635 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15636 })?,
15637 ))),
15638 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
15639 ::treesitter_types::runtime::maybe_grow_stack(|| {
15640 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
15641 })?,
15642 ))),
15643 "shebang_directive" => Ok(Self::ShebangDirective(::std::boxed::Box::new(
15644 ::treesitter_types::runtime::maybe_grow_stack(|| {
15645 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)
15646 })?,
15647 ))),
15648 "using_directive" => Ok(Self::UsingDirective(::std::boxed::Box::new(
15649 ::treesitter_types::runtime::maybe_grow_stack(|| {
15650 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
15651 })?,
15652 ))),
15653 _other => {
15654 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15655 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15656 }) {
15657 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
15658 } else {
15659 Err(::treesitter_types::ParseError::unexpected_kind(
15660 _other, node,
15661 ))
15662 }
15663 }
15664 }
15665 }
15666}
15667impl ::treesitter_types::Spanned for CompilationUnitChildren<'_> {
15668 fn span(&self) -> ::treesitter_types::Span {
15669 match self {
15670 Self::ExternAliasDirective(inner) => inner.span(),
15671 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
15672 Self::GlobalAttribute(inner) => inner.span(),
15673 Self::GlobalStatement(inner) => inner.span(),
15674 Self::NamespaceDeclaration(inner) => inner.span(),
15675 Self::PreprocIf(inner) => inner.span(),
15676 Self::ShebangDirective(inner) => inner.span(),
15677 Self::TypeDeclaration(inner) => inner.span(),
15678 Self::UsingDirective(inner) => inner.span(),
15679 }
15680 }
15681}
15682#[derive(Debug, Clone, PartialEq, Eq)]
15683pub enum ConditionalAccessExpressionChildren<'tree> {
15684 ElementBindingExpression(::std::boxed::Box<ElementBindingExpression<'tree>>),
15685 MemberBindingExpression(::std::boxed::Box<MemberBindingExpression<'tree>>),
15686}
15687impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalAccessExpressionChildren<'tree> {
15688 #[allow(clippy::collapsible_else_if)]
15689 fn from_node(
15690 node: ::treesitter_types::tree_sitter::Node<'tree>,
15691 src: &'tree [u8],
15692 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15693 match node.kind() {
15694 "element_binding_expression" => Ok(Self::ElementBindingExpression(
15695 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15696 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
15697 })?),
15698 )),
15699 "member_binding_expression" => Ok(Self::MemberBindingExpression(
15700 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15701 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
15702 })?),
15703 )),
15704 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15705 }
15706 }
15707}
15708impl ::treesitter_types::Spanned for ConditionalAccessExpressionChildren<'_> {
15709 fn span(&self) -> ::treesitter_types::Span {
15710 match self {
15711 Self::ElementBindingExpression(inner) => inner.span(),
15712 Self::MemberBindingExpression(inner) => inner.span(),
15713 }
15714 }
15715}
15716#[derive(Debug, Clone, PartialEq, Eq)]
15717pub enum ConstantPatternChildren<'tree> {
15718 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
15719 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
15720 DefaultExpression(::std::boxed::Box<DefaultExpression<'tree>>),
15721 GenericName(::std::boxed::Box<GenericName<'tree>>),
15722 Identifier(::std::boxed::Box<Identifier<'tree>>),
15723 InterpolatedStringExpression(::std::boxed::Box<InterpolatedStringExpression<'tree>>),
15724 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
15725 Literal(::std::boxed::Box<Literal<'tree>>),
15726 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
15727 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15728 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
15729 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
15730 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
15731 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
15732 TypeofExpression(::std::boxed::Box<TypeofExpression<'tree>>),
15733}
15734impl<'tree> ::treesitter_types::FromNode<'tree> for ConstantPatternChildren<'tree> {
15735 #[allow(clippy::collapsible_else_if)]
15736 fn from_node(
15737 node: ::treesitter_types::tree_sitter::Node<'tree>,
15738 src: &'tree [u8],
15739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15740 match node.kind() {
15741 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
15742 ::treesitter_types::runtime::maybe_grow_stack(|| {
15743 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15744 })?,
15745 ))),
15746 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
15747 ::treesitter_types::runtime::maybe_grow_stack(|| {
15748 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15749 })?,
15750 ))),
15751 "default_expression" => Ok(Self::DefaultExpression(::std::boxed::Box::new(
15752 ::treesitter_types::runtime::maybe_grow_stack(|| {
15753 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
15754 })?,
15755 ))),
15756 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
15757 ::treesitter_types::runtime::maybe_grow_stack(|| {
15758 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
15759 })?,
15760 ))),
15761 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15762 ::treesitter_types::runtime::maybe_grow_stack(|| {
15763 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15764 })?,
15765 ))),
15766 "interpolated_string_expression" => Ok(Self::InterpolatedStringExpression(
15767 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15768 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
15769 node, src,
15770 )
15771 })?),
15772 )),
15773 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
15774 ::treesitter_types::runtime::maybe_grow_stack(|| {
15775 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15776 })?,
15777 ))),
15778 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
15779 ::treesitter_types::runtime::maybe_grow_stack(|| {
15780 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15781 })?,
15782 ))),
15783 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15784 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15785 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15786 })?),
15787 )),
15788 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
15789 ::treesitter_types::runtime::maybe_grow_stack(|| {
15790 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15791 })?,
15792 ))),
15793 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
15794 ::treesitter_types::runtime::maybe_grow_stack(|| {
15795 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15796 })?,
15797 ))),
15798 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
15799 ::treesitter_types::runtime::maybe_grow_stack(|| {
15800 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
15801 })?,
15802 ))),
15803 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
15804 ::treesitter_types::runtime::maybe_grow_stack(|| {
15805 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
15806 })?,
15807 ))),
15808 "typeof_expression" => Ok(Self::TypeofExpression(::std::boxed::Box::new(
15809 ::treesitter_types::runtime::maybe_grow_stack(|| {
15810 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
15811 })?,
15812 ))),
15813 _other => {
15814 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15815 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
15816 }) {
15817 Ok(Self::Literal(::std::boxed::Box::new(v)))
15818 } else {
15819 Err(::treesitter_types::ParseError::unexpected_kind(
15820 _other, node,
15821 ))
15822 }
15823 }
15824 }
15825 }
15826}
15827impl ::treesitter_types::Spanned for ConstantPatternChildren<'_> {
15828 fn span(&self) -> ::treesitter_types::Span {
15829 match self {
15830 Self::BinaryExpression(inner) => inner.span(),
15831 Self::CastExpression(inner) => inner.span(),
15832 Self::DefaultExpression(inner) => inner.span(),
15833 Self::GenericName(inner) => inner.span(),
15834 Self::Identifier(inner) => inner.span(),
15835 Self::InterpolatedStringExpression(inner) => inner.span(),
15836 Self::InvocationExpression(inner) => inner.span(),
15837 Self::Literal(inner) => inner.span(),
15838 Self::MemberAccessExpression(inner) => inner.span(),
15839 Self::ParenthesizedExpression(inner) => inner.span(),
15840 Self::PostfixUnaryExpression(inner) => inner.span(),
15841 Self::PrefixUnaryExpression(inner) => inner.span(),
15842 Self::SizeofExpression(inner) => inner.span(),
15843 Self::TupleExpression(inner) => inner.span(),
15844 Self::TypeofExpression(inner) => inner.span(),
15845 }
15846 }
15847}
15848#[derive(Debug, Clone, PartialEq, Eq)]
15849pub enum ConstructorDeclarationBody<'tree> {
15850 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15851 Block(::std::boxed::Box<Block<'tree>>),
15852}
15853impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationBody<'tree> {
15854 #[allow(clippy::collapsible_else_if)]
15855 fn from_node(
15856 node: ::treesitter_types::tree_sitter::Node<'tree>,
15857 src: &'tree [u8],
15858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15859 match node.kind() {
15860 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15861 ::treesitter_types::runtime::maybe_grow_stack(|| {
15862 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
15863 })?,
15864 ))),
15865 "block" => Ok(Self::Block(::std::boxed::Box::new(
15866 ::treesitter_types::runtime::maybe_grow_stack(|| {
15867 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15868 })?,
15869 ))),
15870 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15871 }
15872 }
15873}
15874impl ::treesitter_types::Spanned for ConstructorDeclarationBody<'_> {
15875 fn span(&self) -> ::treesitter_types::Span {
15876 match self {
15877 Self::ArrowExpressionClause(inner) => inner.span(),
15878 Self::Block(inner) => inner.span(),
15879 }
15880 }
15881}
15882#[derive(Debug, Clone, PartialEq, Eq)]
15883pub enum ConstructorDeclarationChildren<'tree> {
15884 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15885 ConstructorInitializer(::std::boxed::Box<ConstructorInitializer<'tree>>),
15886 Modifier(::std::boxed::Box<Modifier<'tree>>),
15887 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
15888}
15889impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorDeclarationChildren<'tree> {
15890 #[allow(clippy::collapsible_else_if)]
15891 fn from_node(
15892 node: ::treesitter_types::tree_sitter::Node<'tree>,
15893 src: &'tree [u8],
15894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15895 match node.kind() {
15896 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15897 ::treesitter_types::runtime::maybe_grow_stack(|| {
15898 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15899 })?,
15900 ))),
15901 "constructor_initializer" => Ok(Self::ConstructorInitializer(::std::boxed::Box::new(
15902 ::treesitter_types::runtime::maybe_grow_stack(|| {
15903 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15904 })?,
15905 ))),
15906 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15907 ::treesitter_types::runtime::maybe_grow_stack(|| {
15908 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15909 })?,
15910 ))),
15911 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
15912 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15913 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15914 })?),
15915 )),
15916 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15917 }
15918 }
15919}
15920impl ::treesitter_types::Spanned for ConstructorDeclarationChildren<'_> {
15921 fn span(&self) -> ::treesitter_types::Span {
15922 match self {
15923 Self::AttributeList(inner) => inner.span(),
15924 Self::ConstructorInitializer(inner) => inner.span(),
15925 Self::Modifier(inner) => inner.span(),
15926 Self::PreprocIfInAttributeList(inner) => inner.span(),
15927 }
15928 }
15929}
15930#[derive(Debug, Clone, PartialEq, Eq)]
15931pub enum ConversionOperatorDeclarationBody<'tree> {
15932 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
15933 Block(::std::boxed::Box<Block<'tree>>),
15934}
15935impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationBody<'tree> {
15936 #[allow(clippy::collapsible_else_if)]
15937 fn from_node(
15938 node: ::treesitter_types::tree_sitter::Node<'tree>,
15939 src: &'tree [u8],
15940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15941 match node.kind() {
15942 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
15943 ::treesitter_types::runtime::maybe_grow_stack(|| {
15944 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
15945 })?,
15946 ))),
15947 "block" => Ok(Self::Block(::std::boxed::Box::new(
15948 ::treesitter_types::runtime::maybe_grow_stack(|| {
15949 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15950 })?,
15951 ))),
15952 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15953 }
15954 }
15955}
15956impl ::treesitter_types::Spanned for ConversionOperatorDeclarationBody<'_> {
15957 fn span(&self) -> ::treesitter_types::Span {
15958 match self {
15959 Self::ArrowExpressionClause(inner) => inner.span(),
15960 Self::Block(inner) => inner.span(),
15961 }
15962 }
15963}
15964#[derive(Debug, Clone, PartialEq, Eq)]
15965pub enum ConversionOperatorDeclarationChildren<'tree> {
15966 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
15967 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
15968 Modifier(::std::boxed::Box<Modifier<'tree>>),
15969 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
15970}
15971impl<'tree> ::treesitter_types::FromNode<'tree> for ConversionOperatorDeclarationChildren<'tree> {
15972 #[allow(clippy::collapsible_else_if)]
15973 fn from_node(
15974 node: ::treesitter_types::tree_sitter::Node<'tree>,
15975 src: &'tree [u8],
15976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15977 match node.kind() {
15978 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
15979 ::treesitter_types::runtime::maybe_grow_stack(|| {
15980 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15981 })?,
15982 ))),
15983 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
15984 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15985 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
15986 node, src,
15987 )
15988 })?),
15989 )),
15990 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
15991 ::treesitter_types::runtime::maybe_grow_stack(|| {
15992 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15993 })?,
15994 ))),
15995 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
15996 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15997 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
15998 })?),
15999 )),
16000 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16001 }
16002 }
16003}
16004impl ::treesitter_types::Spanned for ConversionOperatorDeclarationChildren<'_> {
16005 fn span(&self) -> ::treesitter_types::Span {
16006 match self {
16007 Self::AttributeList(inner) => inner.span(),
16008 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
16009 Self::Modifier(inner) => inner.span(),
16010 Self::PreprocIfInAttributeList(inner) => inner.span(),
16011 }
16012 }
16013}
16014#[derive(Debug, Clone, PartialEq, Eq)]
16015pub enum DeclarationPatternChildren<'tree> {
16016 Discard(::std::boxed::Box<Discard<'tree>>),
16017 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
16018}
16019impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationPatternChildren<'tree> {
16020 #[allow(clippy::collapsible_else_if)]
16021 fn from_node(
16022 node: ::treesitter_types::tree_sitter::Node<'tree>,
16023 src: &'tree [u8],
16024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16025 match node.kind() {
16026 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
16027 ::treesitter_types::runtime::maybe_grow_stack(|| {
16028 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
16029 })?,
16030 ))),
16031 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
16032 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16033 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
16034 node, src,
16035 )
16036 })?),
16037 )),
16038 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16039 }
16040 }
16041}
16042impl ::treesitter_types::Spanned for DeclarationPatternChildren<'_> {
16043 fn span(&self) -> ::treesitter_types::Span {
16044 match self {
16045 Self::Discard(inner) => inner.span(),
16046 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
16047 }
16048 }
16049}
16050#[derive(Debug, Clone, PartialEq, Eq)]
16051pub enum DelegateDeclarationChildren<'tree> {
16052 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16053 Modifier(::std::boxed::Box<Modifier<'tree>>),
16054 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16055 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
16056}
16057impl<'tree> ::treesitter_types::FromNode<'tree> for DelegateDeclarationChildren<'tree> {
16058 #[allow(clippy::collapsible_else_if)]
16059 fn from_node(
16060 node: ::treesitter_types::tree_sitter::Node<'tree>,
16061 src: &'tree [u8],
16062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16063 match node.kind() {
16064 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16065 ::treesitter_types::runtime::maybe_grow_stack(|| {
16066 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16067 })?,
16068 ))),
16069 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16070 ::treesitter_types::runtime::maybe_grow_stack(|| {
16071 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16072 })?,
16073 ))),
16074 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16075 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16076 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16077 })?),
16078 )),
16079 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
16080 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16081 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
16082 node, src,
16083 )
16084 })?),
16085 )),
16086 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16087 }
16088 }
16089}
16090impl ::treesitter_types::Spanned for DelegateDeclarationChildren<'_> {
16091 fn span(&self) -> ::treesitter_types::Span {
16092 match self {
16093 Self::AttributeList(inner) => inner.span(),
16094 Self::Modifier(inner) => inner.span(),
16095 Self::PreprocIfInAttributeList(inner) => inner.span(),
16096 Self::TypeParameterConstraintsClause(inner) => inner.span(),
16097 }
16098 }
16099}
16100#[derive(Debug, Clone, PartialEq, Eq)]
16101pub enum DestructorDeclarationBody<'tree> {
16102 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
16103 Block(::std::boxed::Box<Block<'tree>>),
16104}
16105impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclarationBody<'tree> {
16106 #[allow(clippy::collapsible_else_if)]
16107 fn from_node(
16108 node: ::treesitter_types::tree_sitter::Node<'tree>,
16109 src: &'tree [u8],
16110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16111 match node.kind() {
16112 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
16113 ::treesitter_types::runtime::maybe_grow_stack(|| {
16114 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
16115 })?,
16116 ))),
16117 "block" => Ok(Self::Block(::std::boxed::Box::new(
16118 ::treesitter_types::runtime::maybe_grow_stack(|| {
16119 <Block as ::treesitter_types::FromNode>::from_node(node, src)
16120 })?,
16121 ))),
16122 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16123 }
16124 }
16125}
16126impl ::treesitter_types::Spanned for DestructorDeclarationBody<'_> {
16127 fn span(&self) -> ::treesitter_types::Span {
16128 match self {
16129 Self::ArrowExpressionClause(inner) => inner.span(),
16130 Self::Block(inner) => inner.span(),
16131 }
16132 }
16133}
16134#[derive(Debug, Clone, PartialEq, Eq)]
16135pub enum DestructorDeclarationChildren<'tree> {
16136 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16137 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16138}
16139impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorDeclarationChildren<'tree> {
16140 #[allow(clippy::collapsible_else_if)]
16141 fn from_node(
16142 node: ::treesitter_types::tree_sitter::Node<'tree>,
16143 src: &'tree [u8],
16144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16145 match node.kind() {
16146 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16147 ::treesitter_types::runtime::maybe_grow_stack(|| {
16148 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16149 })?,
16150 ))),
16151 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16152 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16153 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16154 })?),
16155 )),
16156 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16157 }
16158 }
16159}
16160impl ::treesitter_types::Spanned for DestructorDeclarationChildren<'_> {
16161 fn span(&self) -> ::treesitter_types::Span {
16162 match self {
16163 Self::AttributeList(inner) => inner.span(),
16164 Self::PreprocIfInAttributeList(inner) => inner.span(),
16165 }
16166 }
16167}
16168#[derive(Debug, Clone, PartialEq, Eq)]
16169pub enum EnumDeclarationChildren<'tree> {
16170 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16171 BaseList(::std::boxed::Box<BaseList<'tree>>),
16172 Modifier(::std::boxed::Box<Modifier<'tree>>),
16173 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16174}
16175impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationChildren<'tree> {
16176 #[allow(clippy::collapsible_else_if)]
16177 fn from_node(
16178 node: ::treesitter_types::tree_sitter::Node<'tree>,
16179 src: &'tree [u8],
16180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16181 match node.kind() {
16182 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16183 ::treesitter_types::runtime::maybe_grow_stack(|| {
16184 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16185 })?,
16186 ))),
16187 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
16188 ::treesitter_types::runtime::maybe_grow_stack(|| {
16189 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
16190 })?,
16191 ))),
16192 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16193 ::treesitter_types::runtime::maybe_grow_stack(|| {
16194 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16195 })?,
16196 ))),
16197 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16198 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16199 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16200 })?),
16201 )),
16202 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16203 }
16204 }
16205}
16206impl ::treesitter_types::Spanned for EnumDeclarationChildren<'_> {
16207 fn span(&self) -> ::treesitter_types::Span {
16208 match self {
16209 Self::AttributeList(inner) => inner.span(),
16210 Self::BaseList(inner) => inner.span(),
16211 Self::Modifier(inner) => inner.span(),
16212 Self::PreprocIfInAttributeList(inner) => inner.span(),
16213 }
16214 }
16215}
16216#[derive(Debug, Clone, PartialEq, Eq)]
16217pub enum EnumMemberDeclarationChildren<'tree> {
16218 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16219 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16220}
16221impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationChildren<'tree> {
16222 #[allow(clippy::collapsible_else_if)]
16223 fn from_node(
16224 node: ::treesitter_types::tree_sitter::Node<'tree>,
16225 src: &'tree [u8],
16226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16227 match node.kind() {
16228 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16229 ::treesitter_types::runtime::maybe_grow_stack(|| {
16230 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16231 })?,
16232 ))),
16233 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16234 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16235 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16236 })?),
16237 )),
16238 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16239 }
16240 }
16241}
16242impl ::treesitter_types::Spanned for EnumMemberDeclarationChildren<'_> {
16243 fn span(&self) -> ::treesitter_types::Span {
16244 match self {
16245 Self::AttributeList(inner) => inner.span(),
16246 Self::PreprocIfInAttributeList(inner) => inner.span(),
16247 }
16248 }
16249}
16250#[derive(Debug, Clone, PartialEq, Eq)]
16251pub enum EnumMemberDeclarationListChildren<'tree> {
16252 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
16253 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
16254}
16255impl<'tree> ::treesitter_types::FromNode<'tree> for EnumMemberDeclarationListChildren<'tree> {
16256 #[allow(clippy::collapsible_else_if)]
16257 fn from_node(
16258 node: ::treesitter_types::tree_sitter::Node<'tree>,
16259 src: &'tree [u8],
16260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16261 match node.kind() {
16262 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
16263 ::treesitter_types::runtime::maybe_grow_stack(|| {
16264 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16265 })?,
16266 ))),
16267 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
16268 ::treesitter_types::runtime::maybe_grow_stack(|| {
16269 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
16270 })?,
16271 ))),
16272 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16273 }
16274 }
16275}
16276impl ::treesitter_types::Spanned for EnumMemberDeclarationListChildren<'_> {
16277 fn span(&self) -> ::treesitter_types::Span {
16278 match self {
16279 Self::EnumMemberDeclaration(inner) => inner.span(),
16280 Self::PreprocIf(inner) => inner.span(),
16281 }
16282 }
16283}
16284#[derive(Debug, Clone, PartialEq, Eq)]
16285pub enum EventDeclarationChildren<'tree> {
16286 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16287 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
16288 Modifier(::std::boxed::Box<Modifier<'tree>>),
16289 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16290}
16291impl<'tree> ::treesitter_types::FromNode<'tree> for EventDeclarationChildren<'tree> {
16292 #[allow(clippy::collapsible_else_if)]
16293 fn from_node(
16294 node: ::treesitter_types::tree_sitter::Node<'tree>,
16295 src: &'tree [u8],
16296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16297 match node.kind() {
16298 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16299 ::treesitter_types::runtime::maybe_grow_stack(|| {
16300 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16301 })?,
16302 ))),
16303 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
16304 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16305 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
16306 node, src,
16307 )
16308 })?),
16309 )),
16310 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16311 ::treesitter_types::runtime::maybe_grow_stack(|| {
16312 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16313 })?,
16314 ))),
16315 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16316 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16317 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16318 })?),
16319 )),
16320 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16321 }
16322 }
16323}
16324impl ::treesitter_types::Spanned for EventDeclarationChildren<'_> {
16325 fn span(&self) -> ::treesitter_types::Span {
16326 match self {
16327 Self::AttributeList(inner) => inner.span(),
16328 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
16329 Self::Modifier(inner) => inner.span(),
16330 Self::PreprocIfInAttributeList(inner) => inner.span(),
16331 }
16332 }
16333}
16334#[derive(Debug, Clone, PartialEq, Eq)]
16335pub enum EventFieldDeclarationChildren<'tree> {
16336 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16337 Modifier(::std::boxed::Box<Modifier<'tree>>),
16338 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16339 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
16340}
16341impl<'tree> ::treesitter_types::FromNode<'tree> for EventFieldDeclarationChildren<'tree> {
16342 #[allow(clippy::collapsible_else_if)]
16343 fn from_node(
16344 node: ::treesitter_types::tree_sitter::Node<'tree>,
16345 src: &'tree [u8],
16346 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16347 match node.kind() {
16348 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16349 ::treesitter_types::runtime::maybe_grow_stack(|| {
16350 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16351 })?,
16352 ))),
16353 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16354 ::treesitter_types::runtime::maybe_grow_stack(|| {
16355 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16356 })?,
16357 ))),
16358 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16359 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16360 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16361 })?),
16362 )),
16363 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
16364 ::treesitter_types::runtime::maybe_grow_stack(|| {
16365 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16366 })?,
16367 ))),
16368 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16369 }
16370 }
16371}
16372impl ::treesitter_types::Spanned for EventFieldDeclarationChildren<'_> {
16373 fn span(&self) -> ::treesitter_types::Span {
16374 match self {
16375 Self::AttributeList(inner) => inner.span(),
16376 Self::Modifier(inner) => inner.span(),
16377 Self::PreprocIfInAttributeList(inner) => inner.span(),
16378 Self::VariableDeclaration(inner) => inner.span(),
16379 }
16380 }
16381}
16382#[derive(Debug, Clone, PartialEq, Eq)]
16383pub enum ExplicitInterfaceSpecifierChildren<'tree> {
16384 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16385 GenericName(::std::boxed::Box<GenericName<'tree>>),
16386 Identifier(::std::boxed::Box<Identifier<'tree>>),
16387 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16388}
16389impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitInterfaceSpecifierChildren<'tree> {
16390 #[allow(clippy::collapsible_else_if)]
16391 fn from_node(
16392 node: ::treesitter_types::tree_sitter::Node<'tree>,
16393 src: &'tree [u8],
16394 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16395 match node.kind() {
16396 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16397 ::treesitter_types::runtime::maybe_grow_stack(|| {
16398 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16399 })?,
16400 ))),
16401 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16402 ::treesitter_types::runtime::maybe_grow_stack(|| {
16403 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16404 })?,
16405 ))),
16406 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16407 ::treesitter_types::runtime::maybe_grow_stack(|| {
16408 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16409 })?,
16410 ))),
16411 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16412 ::treesitter_types::runtime::maybe_grow_stack(|| {
16413 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16414 })?,
16415 ))),
16416 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16417 }
16418 }
16419}
16420impl ::treesitter_types::Spanned for ExplicitInterfaceSpecifierChildren<'_> {
16421 fn span(&self) -> ::treesitter_types::Span {
16422 match self {
16423 Self::AliasQualifiedName(inner) => inner.span(),
16424 Self::GenericName(inner) => inner.span(),
16425 Self::Identifier(inner) => inner.span(),
16426 Self::QualifiedName(inner) => inner.span(),
16427 }
16428 }
16429}
16430#[derive(Debug, Clone, PartialEq, Eq)]
16431pub enum ExpressionStatementChildren<'tree> {
16432 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
16433 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
16434 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
16435 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
16436 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
16437 PostfixUnaryExpression(::std::boxed::Box<PostfixUnaryExpression<'tree>>),
16438 PrefixUnaryExpression(::std::boxed::Box<PrefixUnaryExpression<'tree>>),
16439}
16440impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
16441 #[allow(clippy::collapsible_else_if)]
16442 fn from_node(
16443 node: ::treesitter_types::tree_sitter::Node<'tree>,
16444 src: &'tree [u8],
16445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16446 match node.kind() {
16447 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
16448 ::treesitter_types::runtime::maybe_grow_stack(|| {
16449 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
16450 })?,
16451 ))),
16452 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
16453 ::treesitter_types::runtime::maybe_grow_stack(|| {
16454 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
16455 })?,
16456 ))),
16457 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
16458 ::treesitter_types::runtime::maybe_grow_stack(|| {
16459 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
16460 })?,
16461 ))),
16462 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
16463 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16464 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
16465 })?),
16466 )),
16467 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
16468 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16469 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
16470 })?),
16471 )),
16472 "postfix_unary_expression" => Ok(Self::PostfixUnaryExpression(::std::boxed::Box::new(
16473 ::treesitter_types::runtime::maybe_grow_stack(|| {
16474 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
16475 })?,
16476 ))),
16477 "prefix_unary_expression" => Ok(Self::PrefixUnaryExpression(::std::boxed::Box::new(
16478 ::treesitter_types::runtime::maybe_grow_stack(|| {
16479 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
16480 })?,
16481 ))),
16482 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16483 }
16484 }
16485}
16486impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
16487 fn span(&self) -> ::treesitter_types::Span {
16488 match self {
16489 Self::AssignmentExpression(inner) => inner.span(),
16490 Self::AwaitExpression(inner) => inner.span(),
16491 Self::InvocationExpression(inner) => inner.span(),
16492 Self::ObjectCreationExpression(inner) => inner.span(),
16493 Self::ParenthesizedExpression(inner) => inner.span(),
16494 Self::PostfixUnaryExpression(inner) => inner.span(),
16495 Self::PrefixUnaryExpression(inner) => inner.span(),
16496 }
16497 }
16498}
16499#[derive(Debug, Clone, PartialEq, Eq)]
16500pub enum FieldDeclarationChildren<'tree> {
16501 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16502 Modifier(::std::boxed::Box<Modifier<'tree>>),
16503 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16504 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
16505}
16506impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
16507 #[allow(clippy::collapsible_else_if)]
16508 fn from_node(
16509 node: ::treesitter_types::tree_sitter::Node<'tree>,
16510 src: &'tree [u8],
16511 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16512 match node.kind() {
16513 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16514 ::treesitter_types::runtime::maybe_grow_stack(|| {
16515 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16516 })?,
16517 ))),
16518 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16519 ::treesitter_types::runtime::maybe_grow_stack(|| {
16520 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16521 })?,
16522 ))),
16523 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16524 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16525 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16526 })?),
16527 )),
16528 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
16529 ::treesitter_types::runtime::maybe_grow_stack(|| {
16530 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16531 })?,
16532 ))),
16533 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16534 }
16535 }
16536}
16537impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
16538 fn span(&self) -> ::treesitter_types::Span {
16539 match self {
16540 Self::AttributeList(inner) => inner.span(),
16541 Self::Modifier(inner) => inner.span(),
16542 Self::PreprocIfInAttributeList(inner) => inner.span(),
16543 Self::VariableDeclaration(inner) => inner.span(),
16544 }
16545 }
16546}
16547#[derive(Debug, Clone, PartialEq, Eq)]
16548pub enum FileScopedNamespaceDeclarationName<'tree> {
16549 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16550 GenericName(::std::boxed::Box<GenericName<'tree>>),
16551 Identifier(::std::boxed::Box<Identifier<'tree>>),
16552 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16553}
16554impl<'tree> ::treesitter_types::FromNode<'tree> for FileScopedNamespaceDeclarationName<'tree> {
16555 #[allow(clippy::collapsible_else_if)]
16556 fn from_node(
16557 node: ::treesitter_types::tree_sitter::Node<'tree>,
16558 src: &'tree [u8],
16559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16560 match node.kind() {
16561 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16562 ::treesitter_types::runtime::maybe_grow_stack(|| {
16563 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16564 })?,
16565 ))),
16566 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16567 ::treesitter_types::runtime::maybe_grow_stack(|| {
16568 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16569 })?,
16570 ))),
16571 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16572 ::treesitter_types::runtime::maybe_grow_stack(|| {
16573 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16574 })?,
16575 ))),
16576 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16577 ::treesitter_types::runtime::maybe_grow_stack(|| {
16578 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16579 })?,
16580 ))),
16581 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16582 }
16583 }
16584}
16585impl ::treesitter_types::Spanned for FileScopedNamespaceDeclarationName<'_> {
16586 fn span(&self) -> ::treesitter_types::Span {
16587 match self {
16588 Self::AliasQualifiedName(inner) => inner.span(),
16589 Self::GenericName(inner) => inner.span(),
16590 Self::Identifier(inner) => inner.span(),
16591 Self::QualifiedName(inner) => inner.span(),
16592 }
16593 }
16594}
16595#[derive(Debug, Clone, PartialEq, Eq)]
16596pub enum FixedStatementChildren<'tree> {
16597 Statement(::std::boxed::Box<Statement<'tree>>),
16598 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
16599}
16600impl<'tree> ::treesitter_types::FromNode<'tree> for FixedStatementChildren<'tree> {
16601 #[allow(clippy::collapsible_else_if)]
16602 fn from_node(
16603 node: ::treesitter_types::tree_sitter::Node<'tree>,
16604 src: &'tree [u8],
16605 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16606 match node.kind() {
16607 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
16608 ::treesitter_types::runtime::maybe_grow_stack(|| {
16609 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16610 })?,
16611 ))),
16612 _other => {
16613 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16614 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16615 }) {
16616 Ok(Self::Statement(::std::boxed::Box::new(v)))
16617 } else {
16618 Err(::treesitter_types::ParseError::unexpected_kind(
16619 _other, node,
16620 ))
16621 }
16622 }
16623 }
16624 }
16625}
16626impl ::treesitter_types::Spanned for FixedStatementChildren<'_> {
16627 fn span(&self) -> ::treesitter_types::Span {
16628 match self {
16629 Self::Statement(inner) => inner.span(),
16630 Self::VariableDeclaration(inner) => inner.span(),
16631 }
16632 }
16633}
16634#[derive(Debug, Clone, PartialEq, Eq)]
16635pub enum ForStatementInitializer<'tree> {
16636 Comma(::treesitter_types::Span),
16637 Expression(::std::boxed::Box<Expression<'tree>>),
16638 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
16639}
16640impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
16641 #[allow(clippy::collapsible_else_if)]
16642 fn from_node(
16643 node: ::treesitter_types::tree_sitter::Node<'tree>,
16644 src: &'tree [u8],
16645 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16646 match node.kind() {
16647 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
16648 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
16649 ::treesitter_types::runtime::maybe_grow_stack(|| {
16650 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16651 })?,
16652 ))),
16653 _other => {
16654 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16655 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16656 }) {
16657 Ok(Self::Expression(::std::boxed::Box::new(v)))
16658 } else {
16659 Err(::treesitter_types::ParseError::unexpected_kind(
16660 _other, node,
16661 ))
16662 }
16663 }
16664 }
16665 }
16666}
16667impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
16668 fn span(&self) -> ::treesitter_types::Span {
16669 match self {
16670 Self::Comma(span) => *span,
16671 Self::Expression(inner) => inner.span(),
16672 Self::VariableDeclaration(inner) => inner.span(),
16673 }
16674 }
16675}
16676#[derive(Debug, Clone, PartialEq, Eq)]
16677pub enum ForStatementUpdate<'tree> {
16678 Comma(::treesitter_types::Span),
16679 Expression(::std::boxed::Box<Expression<'tree>>),
16680}
16681impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
16682 #[allow(clippy::collapsible_else_if)]
16683 fn from_node(
16684 node: ::treesitter_types::tree_sitter::Node<'tree>,
16685 src: &'tree [u8],
16686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16687 match node.kind() {
16688 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
16689 _other => {
16690 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16691 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16692 }) {
16693 Ok(Self::Expression(::std::boxed::Box::new(v)))
16694 } else {
16695 Err(::treesitter_types::ParseError::unexpected_kind(
16696 _other, node,
16697 ))
16698 }
16699 }
16700 }
16701 }
16702}
16703impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
16704 fn span(&self) -> ::treesitter_types::Span {
16705 match self {
16706 Self::Comma(span) => *span,
16707 Self::Expression(inner) => inner.span(),
16708 }
16709 }
16710}
16711#[derive(Debug, Clone, PartialEq, Eq)]
16712pub enum ForeachStatementLeft<'tree> {
16713 Expression(::std::boxed::Box<Expression<'tree>>),
16714 Identifier(::std::boxed::Box<Identifier<'tree>>),
16715 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
16716}
16717impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementLeft<'tree> {
16718 #[allow(clippy::collapsible_else_if)]
16719 fn from_node(
16720 node: ::treesitter_types::tree_sitter::Node<'tree>,
16721 src: &'tree [u8],
16722 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16723 match node.kind() {
16724 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16725 ::treesitter_types::runtime::maybe_grow_stack(|| {
16726 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16727 })?,
16728 ))),
16729 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
16730 ::treesitter_types::runtime::maybe_grow_stack(|| {
16731 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
16732 })?,
16733 ))),
16734 _other => {
16735 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16736 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16737 }) {
16738 Ok(Self::Expression(::std::boxed::Box::new(v)))
16739 } else {
16740 Err(::treesitter_types::ParseError::unexpected_kind(
16741 _other, node,
16742 ))
16743 }
16744 }
16745 }
16746 }
16747}
16748impl ::treesitter_types::Spanned for ForeachStatementLeft<'_> {
16749 fn span(&self) -> ::treesitter_types::Span {
16750 match self {
16751 Self::Expression(inner) => inner.span(),
16752 Self::Identifier(inner) => inner.span(),
16753 Self::TuplePattern(inner) => inner.span(),
16754 }
16755 }
16756}
16757#[derive(Debug, Clone, PartialEq, Eq)]
16758pub enum FunctionPointerParameterType<'tree> {
16759 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
16760 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
16761 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
16762 GenericName(::std::boxed::Box<GenericName<'tree>>),
16763 Identifier(::std::boxed::Box<Identifier<'tree>>),
16764 ImplicitType(::std::boxed::Box<ImplicitType<'tree>>),
16765 NullableType(::std::boxed::Box<NullableType<'tree>>),
16766 PointerType(::std::boxed::Box<PointerType<'tree>>),
16767 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
16768 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
16769 TupleType(::std::boxed::Box<TupleType<'tree>>),
16770}
16771impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerParameterType<'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 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
16779 ::treesitter_types::runtime::maybe_grow_stack(|| {
16780 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16781 })?,
16782 ))),
16783 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
16784 ::treesitter_types::runtime::maybe_grow_stack(|| {
16785 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
16786 })?,
16787 ))),
16788 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
16789 ::treesitter_types::runtime::maybe_grow_stack(|| {
16790 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
16791 })?,
16792 ))),
16793 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
16794 ::treesitter_types::runtime::maybe_grow_stack(|| {
16795 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
16796 })?,
16797 ))),
16798 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16799 ::treesitter_types::runtime::maybe_grow_stack(|| {
16800 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16801 })?,
16802 ))),
16803 "implicit_type" => Ok(Self::ImplicitType(::std::boxed::Box::new(
16804 ::treesitter_types::runtime::maybe_grow_stack(|| {
16805 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
16806 })?,
16807 ))),
16808 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
16809 ::treesitter_types::runtime::maybe_grow_stack(|| {
16810 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
16811 })?,
16812 ))),
16813 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
16814 ::treesitter_types::runtime::maybe_grow_stack(|| {
16815 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
16816 })?,
16817 ))),
16818 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
16819 ::treesitter_types::runtime::maybe_grow_stack(|| {
16820 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
16821 })?,
16822 ))),
16823 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
16824 ::treesitter_types::runtime::maybe_grow_stack(|| {
16825 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16826 })?,
16827 ))),
16828 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
16829 ::treesitter_types::runtime::maybe_grow_stack(|| {
16830 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
16831 })?,
16832 ))),
16833 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16834 }
16835 }
16836}
16837impl ::treesitter_types::Spanned for FunctionPointerParameterType<'_> {
16838 fn span(&self) -> ::treesitter_types::Span {
16839 match self {
16840 Self::AliasQualifiedName(inner) => inner.span(),
16841 Self::ArrayType(inner) => inner.span(),
16842 Self::FunctionPointerType(inner) => inner.span(),
16843 Self::GenericName(inner) => inner.span(),
16844 Self::Identifier(inner) => inner.span(),
16845 Self::ImplicitType(inner) => inner.span(),
16846 Self::NullableType(inner) => inner.span(),
16847 Self::PointerType(inner) => inner.span(),
16848 Self::PredefinedType(inner) => inner.span(),
16849 Self::QualifiedName(inner) => inner.span(),
16850 Self::TupleType(inner) => inner.span(),
16851 }
16852 }
16853}
16854#[derive(Debug, Clone, PartialEq, Eq)]
16855pub enum FunctionPointerTypeChildren<'tree> {
16856 CallingConvention(::std::boxed::Box<CallingConvention<'tree>>),
16857 FunctionPointerParameter(::std::boxed::Box<FunctionPointerParameter<'tree>>),
16858}
16859impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionPointerTypeChildren<'tree> {
16860 #[allow(clippy::collapsible_else_if)]
16861 fn from_node(
16862 node: ::treesitter_types::tree_sitter::Node<'tree>,
16863 src: &'tree [u8],
16864 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16865 match node.kind() {
16866 "calling_convention" => Ok(Self::CallingConvention(::std::boxed::Box::new(
16867 ::treesitter_types::runtime::maybe_grow_stack(|| {
16868 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
16869 })?,
16870 ))),
16871 "function_pointer_parameter" => Ok(Self::FunctionPointerParameter(
16872 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16873 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(node, src)
16874 })?),
16875 )),
16876 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16877 }
16878 }
16879}
16880impl ::treesitter_types::Spanned for FunctionPointerTypeChildren<'_> {
16881 fn span(&self) -> ::treesitter_types::Span {
16882 match self {
16883 Self::CallingConvention(inner) => inner.span(),
16884 Self::FunctionPointerParameter(inner) => inner.span(),
16885 }
16886 }
16887}
16888#[derive(Debug, Clone, PartialEq, Eq)]
16889pub enum GenericNameChildren<'tree> {
16890 Identifier(::std::boxed::Box<Identifier<'tree>>),
16891 TypeArgumentList(::std::boxed::Box<TypeArgumentList<'tree>>),
16892}
16893impl<'tree> ::treesitter_types::FromNode<'tree> for GenericNameChildren<'tree> {
16894 #[allow(clippy::collapsible_else_if)]
16895 fn from_node(
16896 node: ::treesitter_types::tree_sitter::Node<'tree>,
16897 src: &'tree [u8],
16898 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16899 match node.kind() {
16900 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16901 ::treesitter_types::runtime::maybe_grow_stack(|| {
16902 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16903 })?,
16904 ))),
16905 "type_argument_list" => Ok(Self::TypeArgumentList(::std::boxed::Box::new(
16906 ::treesitter_types::runtime::maybe_grow_stack(|| {
16907 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16908 })?,
16909 ))),
16910 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16911 }
16912 }
16913}
16914impl ::treesitter_types::Spanned for GenericNameChildren<'_> {
16915 fn span(&self) -> ::treesitter_types::Span {
16916 match self {
16917 Self::Identifier(inner) => inner.span(),
16918 Self::TypeArgumentList(inner) => inner.span(),
16919 }
16920 }
16921}
16922#[derive(Debug, Clone, PartialEq, Eq)]
16923pub enum ImplicitObjectCreationExpressionChildren<'tree> {
16924 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
16925 InitializerExpression(::std::boxed::Box<InitializerExpression<'tree>>),
16926}
16927impl<'tree> ::treesitter_types::FromNode<'tree>
16928 for ImplicitObjectCreationExpressionChildren<'tree>
16929{
16930 #[allow(clippy::collapsible_else_if)]
16931 fn from_node(
16932 node: ::treesitter_types::tree_sitter::Node<'tree>,
16933 src: &'tree [u8],
16934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16935 match node.kind() {
16936 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
16937 ::treesitter_types::runtime::maybe_grow_stack(|| {
16938 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16939 })?,
16940 ))),
16941 "initializer_expression" => Ok(Self::InitializerExpression(::std::boxed::Box::new(
16942 ::treesitter_types::runtime::maybe_grow_stack(|| {
16943 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
16944 })?,
16945 ))),
16946 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16947 }
16948 }
16949}
16950impl ::treesitter_types::Spanned for ImplicitObjectCreationExpressionChildren<'_> {
16951 fn span(&self) -> ::treesitter_types::Span {
16952 match self {
16953 Self::ArgumentList(inner) => inner.span(),
16954 Self::InitializerExpression(inner) => inner.span(),
16955 }
16956 }
16957}
16958#[derive(Debug, Clone, PartialEq, Eq)]
16959pub enum IndexerDeclarationChildren<'tree> {
16960 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
16961 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
16962 Modifier(::std::boxed::Box<Modifier<'tree>>),
16963 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
16964}
16965impl<'tree> ::treesitter_types::FromNode<'tree> for IndexerDeclarationChildren<'tree> {
16966 #[allow(clippy::collapsible_else_if)]
16967 fn from_node(
16968 node: ::treesitter_types::tree_sitter::Node<'tree>,
16969 src: &'tree [u8],
16970 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16971 match node.kind() {
16972 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
16973 ::treesitter_types::runtime::maybe_grow_stack(|| {
16974 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16975 })?,
16976 ))),
16977 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
16978 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16979 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
16980 node, src,
16981 )
16982 })?),
16983 )),
16984 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
16985 ::treesitter_types::runtime::maybe_grow_stack(|| {
16986 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
16987 })?,
16988 ))),
16989 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
16990 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16991 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16992 })?),
16993 )),
16994 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16995 }
16996 }
16997}
16998impl ::treesitter_types::Spanned for IndexerDeclarationChildren<'_> {
16999 fn span(&self) -> ::treesitter_types::Span {
17000 match self {
17001 Self::AttributeList(inner) => inner.span(),
17002 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
17003 Self::Modifier(inner) => inner.span(),
17004 Self::PreprocIfInAttributeList(inner) => inner.span(),
17005 }
17006 }
17007}
17008#[derive(Debug, Clone, PartialEq, Eq)]
17009pub enum InterfaceDeclarationChildren<'tree> {
17010 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17011 BaseList(::std::boxed::Box<BaseList<'tree>>),
17012 Modifier(::std::boxed::Box<Modifier<'tree>>),
17013 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
17014 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17015}
17016impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclarationChildren<'tree> {
17017 #[allow(clippy::collapsible_else_if)]
17018 fn from_node(
17019 node: ::treesitter_types::tree_sitter::Node<'tree>,
17020 src: &'tree [u8],
17021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17022 match node.kind() {
17023 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17024 ::treesitter_types::runtime::maybe_grow_stack(|| {
17025 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17026 })?,
17027 ))),
17028 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
17029 ::treesitter_types::runtime::maybe_grow_stack(|| {
17030 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
17031 })?,
17032 ))),
17033 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17034 ::treesitter_types::runtime::maybe_grow_stack(|| {
17035 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17036 })?,
17037 ))),
17038 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
17039 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17040 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17041 })?),
17042 )),
17043 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17044 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17045 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17046 node, src,
17047 )
17048 })?),
17049 )),
17050 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17051 }
17052 }
17053}
17054impl ::treesitter_types::Spanned for InterfaceDeclarationChildren<'_> {
17055 fn span(&self) -> ::treesitter_types::Span {
17056 match self {
17057 Self::AttributeList(inner) => inner.span(),
17058 Self::BaseList(inner) => inner.span(),
17059 Self::Modifier(inner) => inner.span(),
17060 Self::PreprocIfInAttributeList(inner) => inner.span(),
17061 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17062 }
17063 }
17064}
17065#[derive(Debug, Clone, PartialEq, Eq)]
17066pub enum InterpolatedStringExpressionChildren<'tree> {
17067 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
17068 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
17069 InterpolationQuote(::std::boxed::Box<InterpolationQuote<'tree>>),
17070 InterpolationStart(::std::boxed::Box<InterpolationStart<'tree>>),
17071 StringContent(::std::boxed::Box<StringContent<'tree>>),
17072}
17073impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolatedStringExpressionChildren<'tree> {
17074 #[allow(clippy::collapsible_else_if)]
17075 fn from_node(
17076 node: ::treesitter_types::tree_sitter::Node<'tree>,
17077 src: &'tree [u8],
17078 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17079 match node.kind() {
17080 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
17081 ::treesitter_types::runtime::maybe_grow_stack(|| {
17082 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
17083 })?,
17084 ))),
17085 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
17086 ::treesitter_types::runtime::maybe_grow_stack(|| {
17087 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
17088 })?,
17089 ))),
17090 "interpolation_quote" => Ok(Self::InterpolationQuote(::std::boxed::Box::new(
17091 ::treesitter_types::runtime::maybe_grow_stack(|| {
17092 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)
17093 })?,
17094 ))),
17095 "interpolation_start" => Ok(Self::InterpolationStart(::std::boxed::Box::new(
17096 ::treesitter_types::runtime::maybe_grow_stack(|| {
17097 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)
17098 })?,
17099 ))),
17100 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
17101 ::treesitter_types::runtime::maybe_grow_stack(|| {
17102 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
17103 })?,
17104 ))),
17105 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17106 }
17107 }
17108}
17109impl ::treesitter_types::Spanned for InterpolatedStringExpressionChildren<'_> {
17110 fn span(&self) -> ::treesitter_types::Span {
17111 match self {
17112 Self::EscapeSequence(inner) => inner.span(),
17113 Self::Interpolation(inner) => inner.span(),
17114 Self::InterpolationQuote(inner) => inner.span(),
17115 Self::InterpolationStart(inner) => inner.span(),
17116 Self::StringContent(inner) => inner.span(),
17117 }
17118 }
17119}
17120#[derive(Debug, Clone, PartialEq, Eq)]
17121pub enum InterpolationChildren<'tree> {
17122 Expression(::std::boxed::Box<Expression<'tree>>),
17123 InterpolationAlignmentClause(::std::boxed::Box<InterpolationAlignmentClause<'tree>>),
17124 InterpolationBrace(::std::boxed::Box<InterpolationBrace<'tree>>),
17125 InterpolationFormatClause(::std::boxed::Box<InterpolationFormatClause<'tree>>),
17126}
17127impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
17128 #[allow(clippy::collapsible_else_if)]
17129 fn from_node(
17130 node: ::treesitter_types::tree_sitter::Node<'tree>,
17131 src: &'tree [u8],
17132 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17133 match node.kind() {
17134 "interpolation_alignment_clause" => Ok(Self::InterpolationAlignmentClause(
17135 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17136 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(
17137 node, src,
17138 )
17139 })?),
17140 )),
17141 "interpolation_brace" => Ok(Self::InterpolationBrace(::std::boxed::Box::new(
17142 ::treesitter_types::runtime::maybe_grow_stack(|| {
17143 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)
17144 })?,
17145 ))),
17146 "interpolation_format_clause" => Ok(Self::InterpolationFormatClause(
17147 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17148 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(
17149 node, src,
17150 )
17151 })?),
17152 )),
17153 _other => {
17154 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17155 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17156 }) {
17157 Ok(Self::Expression(::std::boxed::Box::new(v)))
17158 } else {
17159 Err(::treesitter_types::ParseError::unexpected_kind(
17160 _other, node,
17161 ))
17162 }
17163 }
17164 }
17165 }
17166}
17167impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
17168 fn span(&self) -> ::treesitter_types::Span {
17169 match self {
17170 Self::Expression(inner) => inner.span(),
17171 Self::InterpolationAlignmentClause(inner) => inner.span(),
17172 Self::InterpolationBrace(inner) => inner.span(),
17173 Self::InterpolationFormatClause(inner) => inner.span(),
17174 }
17175 }
17176}
17177#[derive(Debug, Clone, PartialEq, Eq)]
17178pub enum InvocationExpressionFunction<'tree> {
17179 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17180 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
17181 ConditionalAccessExpression(::std::boxed::Box<ConditionalAccessExpression<'tree>>),
17182 ElementAccessExpression(::std::boxed::Box<ElementAccessExpression<'tree>>),
17183 Expression(::std::boxed::Box<Expression<'tree>>),
17184 GenericName(::std::boxed::Box<GenericName<'tree>>),
17185 Identifier(::std::boxed::Box<Identifier<'tree>>),
17186 InvocationExpression(::std::boxed::Box<InvocationExpression<'tree>>),
17187 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
17188 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17189 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17190}
17191impl<'tree> ::treesitter_types::FromNode<'tree> for InvocationExpressionFunction<'tree> {
17192 #[allow(clippy::collapsible_else_if)]
17193 fn from_node(
17194 node: ::treesitter_types::tree_sitter::Node<'tree>,
17195 src: &'tree [u8],
17196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17197 match node.kind() {
17198 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17199 ::treesitter_types::runtime::maybe_grow_stack(|| {
17200 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17201 })?,
17202 ))),
17203 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
17204 ::treesitter_types::runtime::maybe_grow_stack(|| {
17205 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
17206 })?,
17207 ))),
17208 "conditional_access_expression" => Ok(Self::ConditionalAccessExpression(
17209 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17210 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
17211 node, src,
17212 )
17213 })?),
17214 )),
17215 "element_access_expression" => Ok(Self::ElementAccessExpression(
17216 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17217 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
17218 })?),
17219 )),
17220 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17221 ::treesitter_types::runtime::maybe_grow_stack(|| {
17222 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17223 })?,
17224 ))),
17225 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17226 ::treesitter_types::runtime::maybe_grow_stack(|| {
17227 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17228 })?,
17229 ))),
17230 "invocation_expression" => Ok(Self::InvocationExpression(::std::boxed::Box::new(
17231 ::treesitter_types::runtime::maybe_grow_stack(|| {
17232 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
17233 })?,
17234 ))),
17235 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
17236 ::treesitter_types::runtime::maybe_grow_stack(|| {
17237 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
17238 })?,
17239 ))),
17240 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
17241 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17242 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
17243 })?),
17244 )),
17245 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17246 ::treesitter_types::runtime::maybe_grow_stack(|| {
17247 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17248 })?,
17249 ))),
17250 _other => {
17251 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17252 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17253 }) {
17254 Ok(Self::Expression(::std::boxed::Box::new(v)))
17255 } else {
17256 Err(::treesitter_types::ParseError::unexpected_kind(
17257 _other, node,
17258 ))
17259 }
17260 }
17261 }
17262 }
17263}
17264impl ::treesitter_types::Spanned for InvocationExpressionFunction<'_> {
17265 fn span(&self) -> ::treesitter_types::Span {
17266 match self {
17267 Self::AliasQualifiedName(inner) => inner.span(),
17268 Self::CastExpression(inner) => inner.span(),
17269 Self::ConditionalAccessExpression(inner) => inner.span(),
17270 Self::ElementAccessExpression(inner) => inner.span(),
17271 Self::Expression(inner) => inner.span(),
17272 Self::GenericName(inner) => inner.span(),
17273 Self::Identifier(inner) => inner.span(),
17274 Self::InvocationExpression(inner) => inner.span(),
17275 Self::MemberAccessExpression(inner) => inner.span(),
17276 Self::ParenthesizedExpression(inner) => inner.span(),
17277 Self::QualifiedName(inner) => inner.span(),
17278 }
17279 }
17280}
17281#[derive(Debug, Clone, PartialEq, Eq)]
17282pub enum IsExpressionOperator {
17283 Is(::treesitter_types::Span),
17284}
17285impl<'tree> ::treesitter_types::FromNode<'tree> for IsExpressionOperator {
17286 #[allow(clippy::collapsible_else_if)]
17287 fn from_node(
17288 node: ::treesitter_types::tree_sitter::Node<'tree>,
17289 _src: &'tree [u8],
17290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17291 match node.kind() {
17292 "is" => Ok(Self::Is(::treesitter_types::Span::from(node))),
17293 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17294 }
17295 }
17296}
17297impl ::treesitter_types::Spanned for IsExpressionOperator {
17298 fn span(&self) -> ::treesitter_types::Span {
17299 match self {
17300 Self::Is(span) => *span,
17301 }
17302 }
17303}
17304#[derive(Debug, Clone, PartialEq, Eq)]
17305pub enum JoinClauseChildren<'tree> {
17306 Expression(::std::boxed::Box<Expression<'tree>>),
17307 Identifier(::std::boxed::Box<Identifier<'tree>>),
17308 JoinIntoClause(::std::boxed::Box<JoinIntoClause<'tree>>),
17309}
17310impl<'tree> ::treesitter_types::FromNode<'tree> for JoinClauseChildren<'tree> {
17311 #[allow(clippy::collapsible_else_if)]
17312 fn from_node(
17313 node: ::treesitter_types::tree_sitter::Node<'tree>,
17314 src: &'tree [u8],
17315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17316 match node.kind() {
17317 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17318 ::treesitter_types::runtime::maybe_grow_stack(|| {
17319 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17320 })?,
17321 ))),
17322 "join_into_clause" => Ok(Self::JoinIntoClause(::std::boxed::Box::new(
17323 ::treesitter_types::runtime::maybe_grow_stack(|| {
17324 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)
17325 })?,
17326 ))),
17327 _other => {
17328 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17329 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17330 }) {
17331 Ok(Self::Expression(::std::boxed::Box::new(v)))
17332 } else {
17333 Err(::treesitter_types::ParseError::unexpected_kind(
17334 _other, node,
17335 ))
17336 }
17337 }
17338 }
17339 }
17340}
17341impl ::treesitter_types::Spanned for JoinClauseChildren<'_> {
17342 fn span(&self) -> ::treesitter_types::Span {
17343 match self {
17344 Self::Expression(inner) => inner.span(),
17345 Self::Identifier(inner) => inner.span(),
17346 Self::JoinIntoClause(inner) => inner.span(),
17347 }
17348 }
17349}
17350#[derive(Debug, Clone, PartialEq, Eq)]
17351pub enum LabeledStatementChildren<'tree> {
17352 Identifier(::std::boxed::Box<Identifier<'tree>>),
17353 Statement(::std::boxed::Box<Statement<'tree>>),
17354}
17355impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
17356 #[allow(clippy::collapsible_else_if)]
17357 fn from_node(
17358 node: ::treesitter_types::tree_sitter::Node<'tree>,
17359 src: &'tree [u8],
17360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17361 match node.kind() {
17362 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17363 ::treesitter_types::runtime::maybe_grow_stack(|| {
17364 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17365 })?,
17366 ))),
17367 _other => {
17368 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17369 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17370 }) {
17371 Ok(Self::Statement(::std::boxed::Box::new(v)))
17372 } else {
17373 Err(::treesitter_types::ParseError::unexpected_kind(
17374 _other, node,
17375 ))
17376 }
17377 }
17378 }
17379 }
17380}
17381impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
17382 fn span(&self) -> ::treesitter_types::Span {
17383 match self {
17384 Self::Identifier(inner) => inner.span(),
17385 Self::Statement(inner) => inner.span(),
17386 }
17387 }
17388}
17389#[derive(Debug, Clone, PartialEq, Eq)]
17390pub enum LambdaExpressionBody<'tree> {
17391 Block(::std::boxed::Box<Block<'tree>>),
17392 Expression(::std::boxed::Box<Expression<'tree>>),
17393}
17394impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionBody<'tree> {
17395 #[allow(clippy::collapsible_else_if)]
17396 fn from_node(
17397 node: ::treesitter_types::tree_sitter::Node<'tree>,
17398 src: &'tree [u8],
17399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17400 match node.kind() {
17401 "block" => Ok(Self::Block(::std::boxed::Box::new(
17402 ::treesitter_types::runtime::maybe_grow_stack(|| {
17403 <Block as ::treesitter_types::FromNode>::from_node(node, src)
17404 })?,
17405 ))),
17406 _other => {
17407 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17408 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17409 }) {
17410 Ok(Self::Expression(::std::boxed::Box::new(v)))
17411 } else {
17412 Err(::treesitter_types::ParseError::unexpected_kind(
17413 _other, node,
17414 ))
17415 }
17416 }
17417 }
17418 }
17419}
17420impl ::treesitter_types::Spanned for LambdaExpressionBody<'_> {
17421 fn span(&self) -> ::treesitter_types::Span {
17422 match self {
17423 Self::Block(inner) => inner.span(),
17424 Self::Expression(inner) => inner.span(),
17425 }
17426 }
17427}
17428#[derive(Debug, Clone, PartialEq, Eq)]
17429pub enum LambdaExpressionParameters<'tree> {
17430 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
17431 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
17432}
17433impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionParameters<'tree> {
17434 #[allow(clippy::collapsible_else_if)]
17435 fn from_node(
17436 node: ::treesitter_types::tree_sitter::Node<'tree>,
17437 src: &'tree [u8],
17438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17439 match node.kind() {
17440 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
17441 ::treesitter_types::runtime::maybe_grow_stack(|| {
17442 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
17443 })?,
17444 ))),
17445 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
17446 ::treesitter_types::runtime::maybe_grow_stack(|| {
17447 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
17448 })?,
17449 ))),
17450 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17451 }
17452 }
17453}
17454impl ::treesitter_types::Spanned for LambdaExpressionParameters<'_> {
17455 fn span(&self) -> ::treesitter_types::Span {
17456 match self {
17457 Self::ImplicitParameter(inner) => inner.span(),
17458 Self::ParameterList(inner) => inner.span(),
17459 }
17460 }
17461}
17462#[derive(Debug, Clone, PartialEq, Eq)]
17463pub enum LambdaExpressionChildren<'tree> {
17464 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17465 Modifier(::std::boxed::Box<Modifier<'tree>>),
17466 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
17467}
17468impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpressionChildren<'tree> {
17469 #[allow(clippy::collapsible_else_if)]
17470 fn from_node(
17471 node: ::treesitter_types::tree_sitter::Node<'tree>,
17472 src: &'tree [u8],
17473 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17474 match node.kind() {
17475 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17476 ::treesitter_types::runtime::maybe_grow_stack(|| {
17477 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17478 })?,
17479 ))),
17480 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17481 ::treesitter_types::runtime::maybe_grow_stack(|| {
17482 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17483 })?,
17484 ))),
17485 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
17486 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17487 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17488 })?),
17489 )),
17490 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17491 }
17492 }
17493}
17494impl ::treesitter_types::Spanned for LambdaExpressionChildren<'_> {
17495 fn span(&self) -> ::treesitter_types::Span {
17496 match self {
17497 Self::AttributeList(inner) => inner.span(),
17498 Self::Modifier(inner) => inner.span(),
17499 Self::PreprocIfInAttributeList(inner) => inner.span(),
17500 }
17501 }
17502}
17503#[derive(Debug, Clone, PartialEq, Eq)]
17504pub enum LetClauseChildren<'tree> {
17505 Expression(::std::boxed::Box<Expression<'tree>>),
17506 Identifier(::std::boxed::Box<Identifier<'tree>>),
17507}
17508impl<'tree> ::treesitter_types::FromNode<'tree> for LetClauseChildren<'tree> {
17509 #[allow(clippy::collapsible_else_if)]
17510 fn from_node(
17511 node: ::treesitter_types::tree_sitter::Node<'tree>,
17512 src: &'tree [u8],
17513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17514 match node.kind() {
17515 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17516 ::treesitter_types::runtime::maybe_grow_stack(|| {
17517 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17518 })?,
17519 ))),
17520 _other => {
17521 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17522 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17523 }) {
17524 Ok(Self::Expression(::std::boxed::Box::new(v)))
17525 } else {
17526 Err(::treesitter_types::ParseError::unexpected_kind(
17527 _other, node,
17528 ))
17529 }
17530 }
17531 }
17532 }
17533}
17534impl ::treesitter_types::Spanned for LetClauseChildren<'_> {
17535 fn span(&self) -> ::treesitter_types::Span {
17536 match self {
17537 Self::Expression(inner) => inner.span(),
17538 Self::Identifier(inner) => inner.span(),
17539 }
17540 }
17541}
17542#[derive(Debug, Clone, PartialEq, Eq)]
17543pub enum ListPatternChildren<'tree> {
17544 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
17545 Pattern(::std::boxed::Box<Pattern<'tree>>),
17546}
17547impl<'tree> ::treesitter_types::FromNode<'tree> for ListPatternChildren<'tree> {
17548 #[allow(clippy::collapsible_else_if)]
17549 fn from_node(
17550 node: ::treesitter_types::tree_sitter::Node<'tree>,
17551 src: &'tree [u8],
17552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17553 match node.kind() {
17554 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
17555 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17556 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
17557 node, src,
17558 )
17559 })?),
17560 )),
17561 _other => {
17562 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17563 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
17564 }) {
17565 Ok(Self::Pattern(::std::boxed::Box::new(v)))
17566 } else {
17567 Err(::treesitter_types::ParseError::unexpected_kind(
17568 _other, node,
17569 ))
17570 }
17571 }
17572 }
17573 }
17574}
17575impl ::treesitter_types::Spanned for ListPatternChildren<'_> {
17576 fn span(&self) -> ::treesitter_types::Span {
17577 match self {
17578 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
17579 Self::Pattern(inner) => inner.span(),
17580 }
17581 }
17582}
17583#[derive(Debug, Clone, PartialEq, Eq)]
17584pub enum LocalDeclarationStatementChildren<'tree> {
17585 Modifier(::std::boxed::Box<Modifier<'tree>>),
17586 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
17587}
17588impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDeclarationStatementChildren<'tree> {
17589 #[allow(clippy::collapsible_else_if)]
17590 fn from_node(
17591 node: ::treesitter_types::tree_sitter::Node<'tree>,
17592 src: &'tree [u8],
17593 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17594 match node.kind() {
17595 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17596 ::treesitter_types::runtime::maybe_grow_stack(|| {
17597 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17598 })?,
17599 ))),
17600 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
17601 ::treesitter_types::runtime::maybe_grow_stack(|| {
17602 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17603 })?,
17604 ))),
17605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17606 }
17607 }
17608}
17609impl ::treesitter_types::Spanned for LocalDeclarationStatementChildren<'_> {
17610 fn span(&self) -> ::treesitter_types::Span {
17611 match self {
17612 Self::Modifier(inner) => inner.span(),
17613 Self::VariableDeclaration(inner) => inner.span(),
17614 }
17615 }
17616}
17617#[derive(Debug, Clone, PartialEq, Eq)]
17618pub enum LocalFunctionStatementBody<'tree> {
17619 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
17620 Block(::std::boxed::Box<Block<'tree>>),
17621}
17622impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementBody<'tree> {
17623 #[allow(clippy::collapsible_else_if)]
17624 fn from_node(
17625 node: ::treesitter_types::tree_sitter::Node<'tree>,
17626 src: &'tree [u8],
17627 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17628 match node.kind() {
17629 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
17630 ::treesitter_types::runtime::maybe_grow_stack(|| {
17631 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
17632 })?,
17633 ))),
17634 "block" => Ok(Self::Block(::std::boxed::Box::new(
17635 ::treesitter_types::runtime::maybe_grow_stack(|| {
17636 <Block as ::treesitter_types::FromNode>::from_node(node, src)
17637 })?,
17638 ))),
17639 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17640 }
17641 }
17642}
17643impl ::treesitter_types::Spanned for LocalFunctionStatementBody<'_> {
17644 fn span(&self) -> ::treesitter_types::Span {
17645 match self {
17646 Self::ArrowExpressionClause(inner) => inner.span(),
17647 Self::Block(inner) => inner.span(),
17648 }
17649 }
17650}
17651#[derive(Debug, Clone, PartialEq, Eq)]
17652pub enum LocalFunctionStatementChildren<'tree> {
17653 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17654 Modifier(::std::boxed::Box<Modifier<'tree>>),
17655 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
17656 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17657}
17658impl<'tree> ::treesitter_types::FromNode<'tree> for LocalFunctionStatementChildren<'tree> {
17659 #[allow(clippy::collapsible_else_if)]
17660 fn from_node(
17661 node: ::treesitter_types::tree_sitter::Node<'tree>,
17662 src: &'tree [u8],
17663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17664 match node.kind() {
17665 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17666 ::treesitter_types::runtime::maybe_grow_stack(|| {
17667 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17668 })?,
17669 ))),
17670 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17671 ::treesitter_types::runtime::maybe_grow_stack(|| {
17672 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17673 })?,
17674 ))),
17675 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
17676 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17677 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17678 })?),
17679 )),
17680 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17681 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17682 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17683 node, src,
17684 )
17685 })?),
17686 )),
17687 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17688 }
17689 }
17690}
17691impl ::treesitter_types::Spanned for LocalFunctionStatementChildren<'_> {
17692 fn span(&self) -> ::treesitter_types::Span {
17693 match self {
17694 Self::AttributeList(inner) => inner.span(),
17695 Self::Modifier(inner) => inner.span(),
17696 Self::PreprocIfInAttributeList(inner) => inner.span(),
17697 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17698 }
17699 }
17700}
17701#[derive(Debug, Clone, PartialEq, Eq)]
17702pub enum LockStatementChildren<'tree> {
17703 Expression(::std::boxed::Box<Expression<'tree>>),
17704 Statement(::std::boxed::Box<Statement<'tree>>),
17705}
17706impl<'tree> ::treesitter_types::FromNode<'tree> for LockStatementChildren<'tree> {
17707 #[allow(clippy::collapsible_else_if)]
17708 fn from_node(
17709 node: ::treesitter_types::tree_sitter::Node<'tree>,
17710 src: &'tree [u8],
17711 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17712 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17713 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17714 }) {
17715 Ok(Self::Expression(::std::boxed::Box::new(v)))
17716 } else {
17717 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17718 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17719 }) {
17720 Ok(Self::Statement(::std::boxed::Box::new(v)))
17721 } else {
17722 Err(::treesitter_types::ParseError::unexpected_kind(
17723 node.kind(),
17724 node,
17725 ))
17726 }
17727 }
17728 }
17729}
17730impl ::treesitter_types::Spanned for LockStatementChildren<'_> {
17731 fn span(&self) -> ::treesitter_types::Span {
17732 match self {
17733 Self::Expression(inner) => inner.span(),
17734 Self::Statement(inner) => inner.span(),
17735 }
17736 }
17737}
17738#[derive(Debug, Clone, PartialEq, Eq)]
17739pub enum MemberAccessExpressionExpression<'tree> {
17740 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17741 Expression(::std::boxed::Box<Expression<'tree>>),
17742 GenericName(::std::boxed::Box<GenericName<'tree>>),
17743 Identifier(::std::boxed::Box<Identifier<'tree>>),
17744 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
17745 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17746}
17747impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionExpression<'tree> {
17748 #[allow(clippy::collapsible_else_if)]
17749 fn from_node(
17750 node: ::treesitter_types::tree_sitter::Node<'tree>,
17751 src: &'tree [u8],
17752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17753 match node.kind() {
17754 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17755 ::treesitter_types::runtime::maybe_grow_stack(|| {
17756 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17757 })?,
17758 ))),
17759 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17760 ::treesitter_types::runtime::maybe_grow_stack(|| {
17761 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17762 })?,
17763 ))),
17764 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17765 ::treesitter_types::runtime::maybe_grow_stack(|| {
17766 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17767 })?,
17768 ))),
17769 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
17770 ::treesitter_types::runtime::maybe_grow_stack(|| {
17771 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
17772 })?,
17773 ))),
17774 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17775 ::treesitter_types::runtime::maybe_grow_stack(|| {
17776 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17777 })?,
17778 ))),
17779 _other => {
17780 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17781 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17782 }) {
17783 Ok(Self::Expression(::std::boxed::Box::new(v)))
17784 } else {
17785 Err(::treesitter_types::ParseError::unexpected_kind(
17786 _other, node,
17787 ))
17788 }
17789 }
17790 }
17791 }
17792}
17793impl ::treesitter_types::Spanned for MemberAccessExpressionExpression<'_> {
17794 fn span(&self) -> ::treesitter_types::Span {
17795 match self {
17796 Self::AliasQualifiedName(inner) => inner.span(),
17797 Self::Expression(inner) => inner.span(),
17798 Self::GenericName(inner) => inner.span(),
17799 Self::Identifier(inner) => inner.span(),
17800 Self::PredefinedType(inner) => inner.span(),
17801 Self::QualifiedName(inner) => inner.span(),
17802 }
17803 }
17804}
17805#[derive(Debug, Clone, PartialEq, Eq)]
17806pub enum MemberAccessExpressionName<'tree> {
17807 GenericName(::std::boxed::Box<GenericName<'tree>>),
17808 Identifier(::std::boxed::Box<Identifier<'tree>>),
17809}
17810impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionName<'tree> {
17811 #[allow(clippy::collapsible_else_if)]
17812 fn from_node(
17813 node: ::treesitter_types::tree_sitter::Node<'tree>,
17814 src: &'tree [u8],
17815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17816 match node.kind() {
17817 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17818 ::treesitter_types::runtime::maybe_grow_stack(|| {
17819 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17820 })?,
17821 ))),
17822 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17823 ::treesitter_types::runtime::maybe_grow_stack(|| {
17824 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17825 })?,
17826 ))),
17827 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17828 }
17829 }
17830}
17831impl ::treesitter_types::Spanned for MemberAccessExpressionName<'_> {
17832 fn span(&self) -> ::treesitter_types::Span {
17833 match self {
17834 Self::GenericName(inner) => inner.span(),
17835 Self::Identifier(inner) => inner.span(),
17836 }
17837 }
17838}
17839#[derive(Debug, Clone, PartialEq, Eq)]
17840pub enum MemberBindingExpressionName<'tree> {
17841 GenericName(::std::boxed::Box<GenericName<'tree>>),
17842 Identifier(::std::boxed::Box<Identifier<'tree>>),
17843}
17844impl<'tree> ::treesitter_types::FromNode<'tree> for MemberBindingExpressionName<'tree> {
17845 #[allow(clippy::collapsible_else_if)]
17846 fn from_node(
17847 node: ::treesitter_types::tree_sitter::Node<'tree>,
17848 src: &'tree [u8],
17849 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17850 match node.kind() {
17851 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17852 ::treesitter_types::runtime::maybe_grow_stack(|| {
17853 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17854 })?,
17855 ))),
17856 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17857 ::treesitter_types::runtime::maybe_grow_stack(|| {
17858 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17859 })?,
17860 ))),
17861 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17862 }
17863 }
17864}
17865impl ::treesitter_types::Spanned for MemberBindingExpressionName<'_> {
17866 fn span(&self) -> ::treesitter_types::Span {
17867 match self {
17868 Self::GenericName(inner) => inner.span(),
17869 Self::Identifier(inner) => inner.span(),
17870 }
17871 }
17872}
17873#[derive(Debug, Clone, PartialEq, Eq)]
17874pub enum MethodDeclarationBody<'tree> {
17875 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
17876 Block(::std::boxed::Box<Block<'tree>>),
17877}
17878impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationBody<'tree> {
17879 #[allow(clippy::collapsible_else_if)]
17880 fn from_node(
17881 node: ::treesitter_types::tree_sitter::Node<'tree>,
17882 src: &'tree [u8],
17883 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17884 match node.kind() {
17885 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
17886 ::treesitter_types::runtime::maybe_grow_stack(|| {
17887 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
17888 })?,
17889 ))),
17890 "block" => Ok(Self::Block(::std::boxed::Box::new(
17891 ::treesitter_types::runtime::maybe_grow_stack(|| {
17892 <Block as ::treesitter_types::FromNode>::from_node(node, src)
17893 })?,
17894 ))),
17895 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17896 }
17897 }
17898}
17899impl ::treesitter_types::Spanned for MethodDeclarationBody<'_> {
17900 fn span(&self) -> ::treesitter_types::Span {
17901 match self {
17902 Self::ArrowExpressionClause(inner) => inner.span(),
17903 Self::Block(inner) => inner.span(),
17904 }
17905 }
17906}
17907#[derive(Debug, Clone, PartialEq, Eq)]
17908pub enum MethodDeclarationChildren<'tree> {
17909 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
17910 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
17911 Modifier(::std::boxed::Box<Modifier<'tree>>),
17912 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
17913 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
17914}
17915impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
17916 #[allow(clippy::collapsible_else_if)]
17917 fn from_node(
17918 node: ::treesitter_types::tree_sitter::Node<'tree>,
17919 src: &'tree [u8],
17920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17921 match node.kind() {
17922 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
17923 ::treesitter_types::runtime::maybe_grow_stack(|| {
17924 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17925 })?,
17926 ))),
17927 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
17928 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17929 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
17930 node, src,
17931 )
17932 })?),
17933 )),
17934 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
17935 ::treesitter_types::runtime::maybe_grow_stack(|| {
17936 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17937 })?,
17938 ))),
17939 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
17940 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17941 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
17942 })?),
17943 )),
17944 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
17945 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17946 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
17947 node, src,
17948 )
17949 })?),
17950 )),
17951 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17952 }
17953 }
17954}
17955impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
17956 fn span(&self) -> ::treesitter_types::Span {
17957 match self {
17958 Self::AttributeList(inner) => inner.span(),
17959 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
17960 Self::Modifier(inner) => inner.span(),
17961 Self::PreprocIfInAttributeList(inner) => inner.span(),
17962 Self::TypeParameterConstraintsClause(inner) => inner.span(),
17963 }
17964 }
17965}
17966#[derive(Debug, Clone, PartialEq, Eq)]
17967pub enum NamespaceDeclarationName<'tree> {
17968 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
17969 GenericName(::std::boxed::Box<GenericName<'tree>>),
17970 Identifier(::std::boxed::Box<Identifier<'tree>>),
17971 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
17972}
17973impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDeclarationName<'tree> {
17974 #[allow(clippy::collapsible_else_if)]
17975 fn from_node(
17976 node: ::treesitter_types::tree_sitter::Node<'tree>,
17977 src: &'tree [u8],
17978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17979 match node.kind() {
17980 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
17981 ::treesitter_types::runtime::maybe_grow_stack(|| {
17982 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17983 })?,
17984 ))),
17985 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
17986 ::treesitter_types::runtime::maybe_grow_stack(|| {
17987 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
17988 })?,
17989 ))),
17990 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17991 ::treesitter_types::runtime::maybe_grow_stack(|| {
17992 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17993 })?,
17994 ))),
17995 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
17996 ::treesitter_types::runtime::maybe_grow_stack(|| {
17997 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
17998 })?,
17999 ))),
18000 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18001 }
18002 }
18003}
18004impl ::treesitter_types::Spanned for NamespaceDeclarationName<'_> {
18005 fn span(&self) -> ::treesitter_types::Span {
18006 match self {
18007 Self::AliasQualifiedName(inner) => inner.span(),
18008 Self::GenericName(inner) => inner.span(),
18009 Self::Identifier(inner) => inner.span(),
18010 Self::QualifiedName(inner) => inner.span(),
18011 }
18012 }
18013}
18014#[derive(Debug, Clone, PartialEq, Eq)]
18015pub enum NullableTypeType<'tree> {
18016 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
18017 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
18018 GenericName(::std::boxed::Box<GenericName<'tree>>),
18019 Identifier(::std::boxed::Box<Identifier<'tree>>),
18020 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
18021 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
18022 TupleType(::std::boxed::Box<TupleType<'tree>>),
18023}
18024impl<'tree> ::treesitter_types::FromNode<'tree> for NullableTypeType<'tree> {
18025 #[allow(clippy::collapsible_else_if)]
18026 fn from_node(
18027 node: ::treesitter_types::tree_sitter::Node<'tree>,
18028 src: &'tree [u8],
18029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18030 match node.kind() {
18031 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
18032 ::treesitter_types::runtime::maybe_grow_stack(|| {
18033 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18034 })?,
18035 ))),
18036 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
18037 ::treesitter_types::runtime::maybe_grow_stack(|| {
18038 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
18039 })?,
18040 ))),
18041 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18042 ::treesitter_types::runtime::maybe_grow_stack(|| {
18043 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18044 })?,
18045 ))),
18046 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18047 ::treesitter_types::runtime::maybe_grow_stack(|| {
18048 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18049 })?,
18050 ))),
18051 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
18052 ::treesitter_types::runtime::maybe_grow_stack(|| {
18053 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
18054 })?,
18055 ))),
18056 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
18057 ::treesitter_types::runtime::maybe_grow_stack(|| {
18058 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18059 })?,
18060 ))),
18061 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
18062 ::treesitter_types::runtime::maybe_grow_stack(|| {
18063 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
18064 })?,
18065 ))),
18066 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18067 }
18068 }
18069}
18070impl ::treesitter_types::Spanned for NullableTypeType<'_> {
18071 fn span(&self) -> ::treesitter_types::Span {
18072 match self {
18073 Self::AliasQualifiedName(inner) => inner.span(),
18074 Self::ArrayType(inner) => inner.span(),
18075 Self::GenericName(inner) => inner.span(),
18076 Self::Identifier(inner) => inner.span(),
18077 Self::PredefinedType(inner) => inner.span(),
18078 Self::QualifiedName(inner) => inner.span(),
18079 Self::TupleType(inner) => inner.span(),
18080 }
18081 }
18082}
18083#[derive(Debug, Clone, PartialEq, Eq)]
18084pub enum OperatorDeclarationBody<'tree> {
18085 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
18086 Block(::std::boxed::Box<Block<'tree>>),
18087}
18088impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationBody<'tree> {
18089 #[allow(clippy::collapsible_else_if)]
18090 fn from_node(
18091 node: ::treesitter_types::tree_sitter::Node<'tree>,
18092 src: &'tree [u8],
18093 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18094 match node.kind() {
18095 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
18096 ::treesitter_types::runtime::maybe_grow_stack(|| {
18097 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
18098 })?,
18099 ))),
18100 "block" => Ok(Self::Block(::std::boxed::Box::new(
18101 ::treesitter_types::runtime::maybe_grow_stack(|| {
18102 <Block as ::treesitter_types::FromNode>::from_node(node, src)
18103 })?,
18104 ))),
18105 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18106 }
18107 }
18108}
18109impl ::treesitter_types::Spanned for OperatorDeclarationBody<'_> {
18110 fn span(&self) -> ::treesitter_types::Span {
18111 match self {
18112 Self::ArrowExpressionClause(inner) => inner.span(),
18113 Self::Block(inner) => inner.span(),
18114 }
18115 }
18116}
18117#[derive(Debug, Clone, PartialEq, Eq)]
18118pub enum OperatorDeclarationOperator {
18119 Bang(::treesitter_types::Span),
18120 NotEq(::treesitter_types::Span),
18121 Percent(::treesitter_types::Span),
18122 Amp(::treesitter_types::Span),
18123 Star(::treesitter_types::Span),
18124 Plus(::treesitter_types::Span),
18125 PlusPlus(::treesitter_types::Span),
18126 Minus(::treesitter_types::Span),
18127 MinusMinus(::treesitter_types::Span),
18128 Slash(::treesitter_types::Span),
18129 Lt(::treesitter_types::Span),
18130 Shl(::treesitter_types::Span),
18131 LtEq(::treesitter_types::Span),
18132 EqEq(::treesitter_types::Span),
18133 Gt(::treesitter_types::Span),
18134 GtEq(::treesitter_types::Span),
18135 Shr(::treesitter_types::Span),
18136 GtGtGt(::treesitter_types::Span),
18137 Caret(::treesitter_types::Span),
18138 False(::treesitter_types::Span),
18139 True(::treesitter_types::Span),
18140 Pipe(::treesitter_types::Span),
18141 Tilde(::treesitter_types::Span),
18142}
18143impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationOperator {
18144 #[allow(clippy::collapsible_else_if)]
18145 fn from_node(
18146 node: ::treesitter_types::tree_sitter::Node<'tree>,
18147 _src: &'tree [u8],
18148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18149 match node.kind() {
18150 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
18151 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
18152 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
18153 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
18154 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
18155 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
18156 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
18157 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
18158 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
18159 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
18160 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
18161 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
18162 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
18163 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
18164 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
18165 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
18166 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
18167 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
18168 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
18169 "false" => Ok(Self::False(::treesitter_types::Span::from(node))),
18170 "true" => Ok(Self::True(::treesitter_types::Span::from(node))),
18171 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
18172 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
18173 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18174 }
18175 }
18176}
18177impl ::treesitter_types::Spanned for OperatorDeclarationOperator {
18178 fn span(&self) -> ::treesitter_types::Span {
18179 match self {
18180 Self::Bang(span) => *span,
18181 Self::NotEq(span) => *span,
18182 Self::Percent(span) => *span,
18183 Self::Amp(span) => *span,
18184 Self::Star(span) => *span,
18185 Self::Plus(span) => *span,
18186 Self::PlusPlus(span) => *span,
18187 Self::Minus(span) => *span,
18188 Self::MinusMinus(span) => *span,
18189 Self::Slash(span) => *span,
18190 Self::Lt(span) => *span,
18191 Self::Shl(span) => *span,
18192 Self::LtEq(span) => *span,
18193 Self::EqEq(span) => *span,
18194 Self::Gt(span) => *span,
18195 Self::GtEq(span) => *span,
18196 Self::Shr(span) => *span,
18197 Self::GtGtGt(span) => *span,
18198 Self::Caret(span) => *span,
18199 Self::False(span) => *span,
18200 Self::True(span) => *span,
18201 Self::Pipe(span) => *span,
18202 Self::Tilde(span) => *span,
18203 }
18204 }
18205}
18206#[derive(Debug, Clone, PartialEq, Eq)]
18207pub enum OperatorDeclarationChildren<'tree> {
18208 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18209 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
18210 Modifier(::std::boxed::Box<Modifier<'tree>>),
18211 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
18212}
18213impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorDeclarationChildren<'tree> {
18214 #[allow(clippy::collapsible_else_if)]
18215 fn from_node(
18216 node: ::treesitter_types::tree_sitter::Node<'tree>,
18217 src: &'tree [u8],
18218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18219 match node.kind() {
18220 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18221 ::treesitter_types::runtime::maybe_grow_stack(|| {
18222 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18223 })?,
18224 ))),
18225 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
18226 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18227 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
18228 node, src,
18229 )
18230 })?),
18231 )),
18232 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
18233 ::treesitter_types::runtime::maybe_grow_stack(|| {
18234 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
18235 })?,
18236 ))),
18237 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
18238 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18239 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18240 })?),
18241 )),
18242 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18243 }
18244 }
18245}
18246impl ::treesitter_types::Spanned for OperatorDeclarationChildren<'_> {
18247 fn span(&self) -> ::treesitter_types::Span {
18248 match self {
18249 Self::AttributeList(inner) => inner.span(),
18250 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
18251 Self::Modifier(inner) => inner.span(),
18252 Self::PreprocIfInAttributeList(inner) => inner.span(),
18253 }
18254 }
18255}
18256#[derive(Debug, Clone, PartialEq, Eq)]
18257pub enum OrPatternOperator {
18258 Or(::treesitter_types::Span),
18259}
18260impl<'tree> ::treesitter_types::FromNode<'tree> for OrPatternOperator {
18261 #[allow(clippy::collapsible_else_if)]
18262 fn from_node(
18263 node: ::treesitter_types::tree_sitter::Node<'tree>,
18264 _src: &'tree [u8],
18265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18266 match node.kind() {
18267 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
18268 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18269 }
18270 }
18271}
18272impl ::treesitter_types::Spanned for OrPatternOperator {
18273 fn span(&self) -> ::treesitter_types::Span {
18274 match self {
18275 Self::Or(span) => *span,
18276 }
18277 }
18278}
18279#[derive(Debug, Clone, PartialEq, Eq)]
18280pub enum ParameterChildren<'tree> {
18281 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18282 Expression(::std::boxed::Box<Expression<'tree>>),
18283 Modifier(::std::boxed::Box<Modifier<'tree>>),
18284 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
18285}
18286impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterChildren<'tree> {
18287 #[allow(clippy::collapsible_else_if)]
18288 fn from_node(
18289 node: ::treesitter_types::tree_sitter::Node<'tree>,
18290 src: &'tree [u8],
18291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18292 match node.kind() {
18293 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18294 ::treesitter_types::runtime::maybe_grow_stack(|| {
18295 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18296 })?,
18297 ))),
18298 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
18299 ::treesitter_types::runtime::maybe_grow_stack(|| {
18300 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
18301 })?,
18302 ))),
18303 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
18304 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18305 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18306 })?),
18307 )),
18308 _other => {
18309 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18310 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18311 }) {
18312 Ok(Self::Expression(::std::boxed::Box::new(v)))
18313 } else {
18314 Err(::treesitter_types::ParseError::unexpected_kind(
18315 _other, node,
18316 ))
18317 }
18318 }
18319 }
18320 }
18321}
18322impl ::treesitter_types::Spanned for ParameterChildren<'_> {
18323 fn span(&self) -> ::treesitter_types::Span {
18324 match self {
18325 Self::AttributeList(inner) => inner.span(),
18326 Self::Expression(inner) => inner.span(),
18327 Self::Modifier(inner) => inner.span(),
18328 Self::PreprocIfInAttributeList(inner) => inner.span(),
18329 }
18330 }
18331}
18332#[derive(Debug, Clone, PartialEq, Eq)]
18333pub enum ParameterListChildren<'tree> {
18334 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18335 Parameter(::std::boxed::Box<Parameter<'tree>>),
18336 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
18337}
18338impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
18339 #[allow(clippy::collapsible_else_if)]
18340 fn from_node(
18341 node: ::treesitter_types::tree_sitter::Node<'tree>,
18342 src: &'tree [u8],
18343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18344 match node.kind() {
18345 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18346 ::treesitter_types::runtime::maybe_grow_stack(|| {
18347 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18348 })?,
18349 ))),
18350 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
18351 ::treesitter_types::runtime::maybe_grow_stack(|| {
18352 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
18353 })?,
18354 ))),
18355 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
18356 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18357 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18358 })?),
18359 )),
18360 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18361 }
18362 }
18363}
18364impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
18365 fn span(&self) -> ::treesitter_types::Span {
18366 match self {
18367 Self::AttributeList(inner) => inner.span(),
18368 Self::Parameter(inner) => inner.span(),
18369 Self::PreprocIfInAttributeList(inner) => inner.span(),
18370 }
18371 }
18372}
18373#[derive(Debug, Clone, PartialEq, Eq)]
18374pub enum ParenthesizedExpressionChildren<'tree> {
18375 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
18376 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
18377 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18378 LvalueExpression(::std::boxed::Box<LvalueExpression<'tree>>),
18379 NonLvalueExpression(::std::boxed::Box<NonLvalueExpression<'tree>>),
18380 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18381}
18382impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'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 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
18390 ::treesitter_types::runtime::maybe_grow_stack(|| {
18391 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18392 })?,
18393 ))),
18394 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
18395 ::treesitter_types::runtime::maybe_grow_stack(|| {
18396 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18397 })?,
18398 ))),
18399 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18400 ::treesitter_types::runtime::maybe_grow_stack(|| {
18401 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18402 })?,
18403 ))),
18404 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18405 ::treesitter_types::runtime::maybe_grow_stack(|| {
18406 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18407 })?,
18408 ))),
18409 _other => {
18410 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18411 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
18412 }) {
18413 Ok(Self::LvalueExpression(::std::boxed::Box::new(v)))
18414 } else {
18415 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18416 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
18417 }) {
18418 Ok(Self::NonLvalueExpression(::std::boxed::Box::new(v)))
18419 } else {
18420 Err(::treesitter_types::ParseError::unexpected_kind(
18421 _other, node,
18422 ))
18423 }
18424 }
18425 }
18426 }
18427 }
18428}
18429impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
18430 fn span(&self) -> ::treesitter_types::Span {
18431 match self {
18432 Self::BooleanLiteral(inner) => inner.span(),
18433 Self::CharacterLiteral(inner) => inner.span(),
18434 Self::IntegerLiteral(inner) => inner.span(),
18435 Self::LvalueExpression(inner) => inner.span(),
18436 Self::NonLvalueExpression(inner) => inner.span(),
18437 Self::UnaryExpression(inner) => inner.span(),
18438 }
18439 }
18440}
18441#[derive(Debug, Clone, PartialEq, Eq)]
18442pub enum ParenthesizedVariableDesignationChildren<'tree> {
18443 Discard(::std::boxed::Box<Discard<'tree>>),
18444 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
18445}
18446impl<'tree> ::treesitter_types::FromNode<'tree>
18447 for ParenthesizedVariableDesignationChildren<'tree>
18448{
18449 #[allow(clippy::collapsible_else_if)]
18450 fn from_node(
18451 node: ::treesitter_types::tree_sitter::Node<'tree>,
18452 src: &'tree [u8],
18453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18454 match node.kind() {
18455 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
18456 ::treesitter_types::runtime::maybe_grow_stack(|| {
18457 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
18458 })?,
18459 ))),
18460 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
18461 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18462 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
18463 node, src,
18464 )
18465 })?),
18466 )),
18467 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18468 }
18469 }
18470}
18471impl ::treesitter_types::Spanned for ParenthesizedVariableDesignationChildren<'_> {
18472 fn span(&self) -> ::treesitter_types::Span {
18473 match self {
18474 Self::Discard(inner) => inner.span(),
18475 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
18476 }
18477 }
18478}
18479#[derive(Debug, Clone, PartialEq, Eq)]
18480pub enum PointerTypeType<'tree> {
18481 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
18482 FunctionPointerType(::std::boxed::Box<FunctionPointerType<'tree>>),
18483 GenericName(::std::boxed::Box<GenericName<'tree>>),
18484 Identifier(::std::boxed::Box<Identifier<'tree>>),
18485 NullableType(::std::boxed::Box<NullableType<'tree>>),
18486 PointerType(::std::boxed::Box<PointerType<'tree>>),
18487 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
18488 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
18489 TupleType(::std::boxed::Box<TupleType<'tree>>),
18490}
18491impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeType<'tree> {
18492 #[allow(clippy::collapsible_else_if)]
18493 fn from_node(
18494 node: ::treesitter_types::tree_sitter::Node<'tree>,
18495 src: &'tree [u8],
18496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18497 match node.kind() {
18498 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
18499 ::treesitter_types::runtime::maybe_grow_stack(|| {
18500 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18501 })?,
18502 ))),
18503 "function_pointer_type" => Ok(Self::FunctionPointerType(::std::boxed::Box::new(
18504 ::treesitter_types::runtime::maybe_grow_stack(|| {
18505 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
18506 })?,
18507 ))),
18508 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
18509 ::treesitter_types::runtime::maybe_grow_stack(|| {
18510 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
18511 })?,
18512 ))),
18513 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18514 ::treesitter_types::runtime::maybe_grow_stack(|| {
18515 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18516 })?,
18517 ))),
18518 "nullable_type" => Ok(Self::NullableType(::std::boxed::Box::new(
18519 ::treesitter_types::runtime::maybe_grow_stack(|| {
18520 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
18521 })?,
18522 ))),
18523 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
18524 ::treesitter_types::runtime::maybe_grow_stack(|| {
18525 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
18526 })?,
18527 ))),
18528 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
18529 ::treesitter_types::runtime::maybe_grow_stack(|| {
18530 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
18531 })?,
18532 ))),
18533 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
18534 ::treesitter_types::runtime::maybe_grow_stack(|| {
18535 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
18536 })?,
18537 ))),
18538 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
18539 ::treesitter_types::runtime::maybe_grow_stack(|| {
18540 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
18541 })?,
18542 ))),
18543 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18544 }
18545 }
18546}
18547impl ::treesitter_types::Spanned for PointerTypeType<'_> {
18548 fn span(&self) -> ::treesitter_types::Span {
18549 match self {
18550 Self::AliasQualifiedName(inner) => inner.span(),
18551 Self::FunctionPointerType(inner) => inner.span(),
18552 Self::GenericName(inner) => inner.span(),
18553 Self::Identifier(inner) => inner.span(),
18554 Self::NullableType(inner) => inner.span(),
18555 Self::PointerType(inner) => inner.span(),
18556 Self::PredefinedType(inner) => inner.span(),
18557 Self::QualifiedName(inner) => inner.span(),
18558 Self::TupleType(inner) => inner.span(),
18559 }
18560 }
18561}
18562#[derive(Debug, Clone, PartialEq, Eq)]
18563pub enum PreprocElifAlternative<'tree> {
18564 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
18565 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
18566}
18567impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
18568 #[allow(clippy::collapsible_else_if)]
18569 fn from_node(
18570 node: ::treesitter_types::tree_sitter::Node<'tree>,
18571 src: &'tree [u8],
18572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18573 match node.kind() {
18574 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
18575 ::treesitter_types::runtime::maybe_grow_stack(|| {
18576 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
18577 })?,
18578 ))),
18579 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
18580 ::treesitter_types::runtime::maybe_grow_stack(|| {
18581 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
18582 })?,
18583 ))),
18584 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18585 }
18586 }
18587}
18588impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
18589 fn span(&self) -> ::treesitter_types::Span {
18590 match self {
18591 Self::PreprocElif(inner) => inner.span(),
18592 Self::PreprocElse(inner) => inner.span(),
18593 }
18594 }
18595}
18596#[derive(Debug, Clone, PartialEq, Eq)]
18597pub enum PreprocElifCondition<'tree> {
18598 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
18599 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
18600 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
18601 Identifier(::std::boxed::Box<Identifier<'tree>>),
18602 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18603 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
18604 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18605}
18606impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
18607 #[allow(clippy::collapsible_else_if)]
18608 fn from_node(
18609 node: ::treesitter_types::tree_sitter::Node<'tree>,
18610 src: &'tree [u8],
18611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18612 match node.kind() {
18613 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
18614 ::treesitter_types::runtime::maybe_grow_stack(|| {
18615 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18616 })?,
18617 ))),
18618 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
18619 ::treesitter_types::runtime::maybe_grow_stack(|| {
18620 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18621 })?,
18622 ))),
18623 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
18624 ::treesitter_types::runtime::maybe_grow_stack(|| {
18625 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18626 })?,
18627 ))),
18628 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18629 ::treesitter_types::runtime::maybe_grow_stack(|| {
18630 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18631 })?,
18632 ))),
18633 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18634 ::treesitter_types::runtime::maybe_grow_stack(|| {
18635 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18636 })?,
18637 ))),
18638 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
18639 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18640 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
18641 })?),
18642 )),
18643 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18644 ::treesitter_types::runtime::maybe_grow_stack(|| {
18645 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18646 })?,
18647 ))),
18648 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18649 }
18650 }
18651}
18652impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
18653 fn span(&self) -> ::treesitter_types::Span {
18654 match self {
18655 Self::BinaryExpression(inner) => inner.span(),
18656 Self::BooleanLiteral(inner) => inner.span(),
18657 Self::CharacterLiteral(inner) => inner.span(),
18658 Self::Identifier(inner) => inner.span(),
18659 Self::IntegerLiteral(inner) => inner.span(),
18660 Self::ParenthesizedExpression(inner) => inner.span(),
18661 Self::UnaryExpression(inner) => inner.span(),
18662 }
18663 }
18664}
18665#[derive(Debug, Clone, PartialEq, Eq)]
18666pub enum PreprocElifChildren<'tree> {
18667 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18668 Declaration(::std::boxed::Box<Declaration<'tree>>),
18669 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
18670 Expression(::std::boxed::Box<Expression<'tree>>),
18671 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
18672 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
18673 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
18674 Statement(::std::boxed::Box<Statement<'tree>>),
18675 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
18676}
18677impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
18678 #[allow(clippy::collapsible_else_if)]
18679 fn from_node(
18680 node: ::treesitter_types::tree_sitter::Node<'tree>,
18681 src: &'tree [u8],
18682 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18683 match node.kind() {
18684 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18685 ::treesitter_types::runtime::maybe_grow_stack(|| {
18686 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18687 })?,
18688 ))),
18689 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
18690 ::treesitter_types::runtime::maybe_grow_stack(|| {
18691 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18692 })?,
18693 ))),
18694 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
18695 ::treesitter_types::runtime::maybe_grow_stack(|| {
18696 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
18697 })?,
18698 ))),
18699 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
18700 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18701 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
18702 node, src,
18703 )
18704 })?),
18705 )),
18706 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
18707 ::treesitter_types::runtime::maybe_grow_stack(|| {
18708 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
18709 })?,
18710 ))),
18711 _other => {
18712 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18713 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18714 }) {
18715 Ok(Self::Declaration(::std::boxed::Box::new(v)))
18716 } else {
18717 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18718 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18719 }) {
18720 Ok(Self::Expression(::std::boxed::Box::new(v)))
18721 } else {
18722 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18723 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18724 }) {
18725 Ok(Self::Statement(::std::boxed::Box::new(v)))
18726 } else {
18727 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18728 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
18729 node, src,
18730 )
18731 }) {
18732 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
18733 } else {
18734 Err(::treesitter_types::ParseError::unexpected_kind(
18735 _other, node,
18736 ))
18737 }
18738 }
18739 }
18740 }
18741 }
18742 }
18743 }
18744}
18745impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
18746 fn span(&self) -> ::treesitter_types::Span {
18747 match self {
18748 Self::AttributeList(inner) => inner.span(),
18749 Self::Declaration(inner) => inner.span(),
18750 Self::EnumMemberDeclaration(inner) => inner.span(),
18751 Self::Expression(inner) => inner.span(),
18752 Self::ExternAliasDirective(inner) => inner.span(),
18753 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
18754 Self::GlobalAttribute(inner) => inner.span(),
18755 Self::Statement(inner) => inner.span(),
18756 Self::TypeDeclaration(inner) => inner.span(),
18757 }
18758 }
18759}
18760#[derive(Debug, Clone, PartialEq, Eq)]
18761pub enum PreprocElseChildren<'tree> {
18762 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
18763 Declaration(::std::boxed::Box<Declaration<'tree>>),
18764 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
18765 Expression(::std::boxed::Box<Expression<'tree>>),
18766 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
18767 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
18768 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
18769 Statement(::std::boxed::Box<Statement<'tree>>),
18770 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
18771}
18772impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
18773 #[allow(clippy::collapsible_else_if)]
18774 fn from_node(
18775 node: ::treesitter_types::tree_sitter::Node<'tree>,
18776 src: &'tree [u8],
18777 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18778 match node.kind() {
18779 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
18780 ::treesitter_types::runtime::maybe_grow_stack(|| {
18781 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
18782 })?,
18783 ))),
18784 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
18785 ::treesitter_types::runtime::maybe_grow_stack(|| {
18786 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18787 })?,
18788 ))),
18789 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
18790 ::treesitter_types::runtime::maybe_grow_stack(|| {
18791 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
18792 })?,
18793 ))),
18794 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
18795 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18796 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
18797 node, src,
18798 )
18799 })?),
18800 )),
18801 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
18802 ::treesitter_types::runtime::maybe_grow_stack(|| {
18803 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
18804 })?,
18805 ))),
18806 _other => {
18807 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18808 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18809 }) {
18810 Ok(Self::Declaration(::std::boxed::Box::new(v)))
18811 } else {
18812 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18813 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
18814 }) {
18815 Ok(Self::Expression(::std::boxed::Box::new(v)))
18816 } else {
18817 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18818 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18819 }) {
18820 Ok(Self::Statement(::std::boxed::Box::new(v)))
18821 } else {
18822 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18823 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
18824 node, src,
18825 )
18826 }) {
18827 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
18828 } else {
18829 Err(::treesitter_types::ParseError::unexpected_kind(
18830 _other, node,
18831 ))
18832 }
18833 }
18834 }
18835 }
18836 }
18837 }
18838 }
18839}
18840impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
18841 fn span(&self) -> ::treesitter_types::Span {
18842 match self {
18843 Self::AttributeList(inner) => inner.span(),
18844 Self::Declaration(inner) => inner.span(),
18845 Self::EnumMemberDeclaration(inner) => inner.span(),
18846 Self::Expression(inner) => inner.span(),
18847 Self::ExternAliasDirective(inner) => inner.span(),
18848 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
18849 Self::GlobalAttribute(inner) => inner.span(),
18850 Self::Statement(inner) => inner.span(),
18851 Self::TypeDeclaration(inner) => inner.span(),
18852 }
18853 }
18854}
18855#[derive(Debug, Clone, PartialEq, Eq)]
18856pub enum PreprocIfAlternative<'tree> {
18857 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
18858 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
18859}
18860impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
18861 #[allow(clippy::collapsible_else_if)]
18862 fn from_node(
18863 node: ::treesitter_types::tree_sitter::Node<'tree>,
18864 src: &'tree [u8],
18865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18866 match node.kind() {
18867 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
18868 ::treesitter_types::runtime::maybe_grow_stack(|| {
18869 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
18870 })?,
18871 ))),
18872 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
18873 ::treesitter_types::runtime::maybe_grow_stack(|| {
18874 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
18875 })?,
18876 ))),
18877 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18878 }
18879 }
18880}
18881impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
18882 fn span(&self) -> ::treesitter_types::Span {
18883 match self {
18884 Self::PreprocElif(inner) => inner.span(),
18885 Self::PreprocElse(inner) => inner.span(),
18886 }
18887 }
18888}
18889#[derive(Debug, Clone, PartialEq, Eq)]
18890pub enum PreprocIfCondition<'tree> {
18891 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
18892 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
18893 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
18894 Identifier(::std::boxed::Box<Identifier<'tree>>),
18895 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
18896 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
18897 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18898}
18899impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
18900 #[allow(clippy::collapsible_else_if)]
18901 fn from_node(
18902 node: ::treesitter_types::tree_sitter::Node<'tree>,
18903 src: &'tree [u8],
18904 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18905 match node.kind() {
18906 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
18907 ::treesitter_types::runtime::maybe_grow_stack(|| {
18908 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18909 })?,
18910 ))),
18911 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
18912 ::treesitter_types::runtime::maybe_grow_stack(|| {
18913 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18914 })?,
18915 ))),
18916 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
18917 ::treesitter_types::runtime::maybe_grow_stack(|| {
18918 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18919 })?,
18920 ))),
18921 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18922 ::treesitter_types::runtime::maybe_grow_stack(|| {
18923 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18924 })?,
18925 ))),
18926 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
18927 ::treesitter_types::runtime::maybe_grow_stack(|| {
18928 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18929 })?,
18930 ))),
18931 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
18932 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18933 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
18934 })?),
18935 )),
18936 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18937 ::treesitter_types::runtime::maybe_grow_stack(|| {
18938 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18939 })?,
18940 ))),
18941 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18942 }
18943 }
18944}
18945impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
18946 fn span(&self) -> ::treesitter_types::Span {
18947 match self {
18948 Self::BinaryExpression(inner) => inner.span(),
18949 Self::BooleanLiteral(inner) => inner.span(),
18950 Self::CharacterLiteral(inner) => inner.span(),
18951 Self::Identifier(inner) => inner.span(),
18952 Self::IntegerLiteral(inner) => inner.span(),
18953 Self::ParenthesizedExpression(inner) => inner.span(),
18954 Self::UnaryExpression(inner) => inner.span(),
18955 }
18956 }
18957}
18958#[derive(Debug, Clone, PartialEq, Eq)]
18959pub enum PreprocIfChildren<'tree> {
18960 Declaration(::std::boxed::Box<Declaration<'tree>>),
18961 EnumMemberDeclaration(::std::boxed::Box<EnumMemberDeclaration<'tree>>),
18962 Expression(::std::boxed::Box<Expression<'tree>>),
18963 ExternAliasDirective(::std::boxed::Box<ExternAliasDirective<'tree>>),
18964 FileScopedNamespaceDeclaration(::std::boxed::Box<FileScopedNamespaceDeclaration<'tree>>),
18965 GlobalAttribute(::std::boxed::Box<GlobalAttribute<'tree>>),
18966 Statement(::std::boxed::Box<Statement<'tree>>),
18967 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
18968}
18969impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
18970 #[allow(clippy::collapsible_else_if)]
18971 fn from_node(
18972 node: ::treesitter_types::tree_sitter::Node<'tree>,
18973 src: &'tree [u8],
18974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18975 match node.kind() {
18976 "enum_member_declaration" => Ok(Self::EnumMemberDeclaration(::std::boxed::Box::new(
18977 ::treesitter_types::runtime::maybe_grow_stack(|| {
18978 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18979 })?,
18980 ))),
18981 "extern_alias_directive" => Ok(Self::ExternAliasDirective(::std::boxed::Box::new(
18982 ::treesitter_types::runtime::maybe_grow_stack(|| {
18983 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
18984 })?,
18985 ))),
18986 "file_scoped_namespace_declaration" => Ok(Self::FileScopedNamespaceDeclaration(
18987 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18988 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
18989 node, src,
18990 )
18991 })?),
18992 )),
18993 "global_attribute" => Ok(Self::GlobalAttribute(::std::boxed::Box::new(
18994 ::treesitter_types::runtime::maybe_grow_stack(|| {
18995 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
18996 })?,
18997 ))),
18998 _other => {
18999 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19000 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
19001 }) {
19002 Ok(Self::Declaration(::std::boxed::Box::new(v)))
19003 } else {
19004 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19005 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19006 }) {
19007 Ok(Self::Expression(::std::boxed::Box::new(v)))
19008 } else {
19009 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19010 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
19011 }) {
19012 Ok(Self::Statement(::std::boxed::Box::new(v)))
19013 } else {
19014 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19015 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(
19016 node, src,
19017 )
19018 }) {
19019 Ok(Self::TypeDeclaration(::std::boxed::Box::new(v)))
19020 } else {
19021 Err(::treesitter_types::ParseError::unexpected_kind(
19022 _other, node,
19023 ))
19024 }
19025 }
19026 }
19027 }
19028 }
19029 }
19030 }
19031}
19032impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
19033 fn span(&self) -> ::treesitter_types::Span {
19034 match self {
19035 Self::Declaration(inner) => inner.span(),
19036 Self::EnumMemberDeclaration(inner) => inner.span(),
19037 Self::Expression(inner) => inner.span(),
19038 Self::ExternAliasDirective(inner) => inner.span(),
19039 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
19040 Self::GlobalAttribute(inner) => inner.span(),
19041 Self::Statement(inner) => inner.span(),
19042 Self::TypeDeclaration(inner) => inner.span(),
19043 }
19044 }
19045}
19046#[derive(Debug, Clone, PartialEq, Eq)]
19047pub enum PreprocIfInAttributeListAlternative<'tree> {
19048 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
19049 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
19050}
19051impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfInAttributeListAlternative<'tree> {
19052 #[allow(clippy::collapsible_else_if)]
19053 fn from_node(
19054 node: ::treesitter_types::tree_sitter::Node<'tree>,
19055 src: &'tree [u8],
19056 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19057 match node.kind() {
19058 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
19059 ::treesitter_types::runtime::maybe_grow_stack(|| {
19060 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
19061 })?,
19062 ))),
19063 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
19064 ::treesitter_types::runtime::maybe_grow_stack(|| {
19065 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
19066 })?,
19067 ))),
19068 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19069 }
19070 }
19071}
19072impl ::treesitter_types::Spanned for PreprocIfInAttributeListAlternative<'_> {
19073 fn span(&self) -> ::treesitter_types::Span {
19074 match self {
19075 Self::PreprocElif(inner) => inner.span(),
19076 Self::PreprocElse(inner) => inner.span(),
19077 }
19078 }
19079}
19080#[derive(Debug, Clone, PartialEq, Eq)]
19081pub enum PreprocIfInAttributeListCondition<'tree> {
19082 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
19083 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
19084 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
19085 Identifier(::std::boxed::Box<Identifier<'tree>>),
19086 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
19087 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
19088 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
19089}
19090impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfInAttributeListCondition<'tree> {
19091 #[allow(clippy::collapsible_else_if)]
19092 fn from_node(
19093 node: ::treesitter_types::tree_sitter::Node<'tree>,
19094 src: &'tree [u8],
19095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19096 match node.kind() {
19097 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
19098 ::treesitter_types::runtime::maybe_grow_stack(|| {
19099 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19100 })?,
19101 ))),
19102 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
19103 ::treesitter_types::runtime::maybe_grow_stack(|| {
19104 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19105 })?,
19106 ))),
19107 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
19108 ::treesitter_types::runtime::maybe_grow_stack(|| {
19109 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19110 })?,
19111 ))),
19112 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19113 ::treesitter_types::runtime::maybe_grow_stack(|| {
19114 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19115 })?,
19116 ))),
19117 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
19118 ::treesitter_types::runtime::maybe_grow_stack(|| {
19119 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19120 })?,
19121 ))),
19122 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
19123 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19124 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
19125 })?),
19126 )),
19127 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
19128 ::treesitter_types::runtime::maybe_grow_stack(|| {
19129 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19130 })?,
19131 ))),
19132 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19133 }
19134 }
19135}
19136impl ::treesitter_types::Spanned for PreprocIfInAttributeListCondition<'_> {
19137 fn span(&self) -> ::treesitter_types::Span {
19138 match self {
19139 Self::BinaryExpression(inner) => inner.span(),
19140 Self::BooleanLiteral(inner) => inner.span(),
19141 Self::CharacterLiteral(inner) => inner.span(),
19142 Self::Identifier(inner) => inner.span(),
19143 Self::IntegerLiteral(inner) => inner.span(),
19144 Self::ParenthesizedExpression(inner) => inner.span(),
19145 Self::UnaryExpression(inner) => inner.span(),
19146 }
19147 }
19148}
19149#[derive(Debug, Clone, PartialEq, Eq)]
19150pub enum PreprocLineChildren<'tree> {
19151 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
19152 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
19153}
19154impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocLineChildren<'tree> {
19155 #[allow(clippy::collapsible_else_if)]
19156 fn from_node(
19157 node: ::treesitter_types::tree_sitter::Node<'tree>,
19158 src: &'tree [u8],
19159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19160 match node.kind() {
19161 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
19162 ::treesitter_types::runtime::maybe_grow_stack(|| {
19163 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19164 })?,
19165 ))),
19166 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
19167 ::treesitter_types::runtime::maybe_grow_stack(|| {
19168 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19169 })?,
19170 ))),
19171 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19172 }
19173 }
19174}
19175impl ::treesitter_types::Spanned for PreprocLineChildren<'_> {
19176 fn span(&self) -> ::treesitter_types::Span {
19177 match self {
19178 Self::IntegerLiteral(inner) => inner.span(),
19179 Self::StringLiteral(inner) => inner.span(),
19180 }
19181 }
19182}
19183#[derive(Debug, Clone, PartialEq, Eq)]
19184pub enum PreprocPragmaChildren<'tree> {
19185 Identifier(::std::boxed::Box<Identifier<'tree>>),
19186 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
19187 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
19188}
19189impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocPragmaChildren<'tree> {
19190 #[allow(clippy::collapsible_else_if)]
19191 fn from_node(
19192 node: ::treesitter_types::tree_sitter::Node<'tree>,
19193 src: &'tree [u8],
19194 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19195 match node.kind() {
19196 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19197 ::treesitter_types::runtime::maybe_grow_stack(|| {
19198 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19199 })?,
19200 ))),
19201 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
19202 ::treesitter_types::runtime::maybe_grow_stack(|| {
19203 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19204 })?,
19205 ))),
19206 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
19207 ::treesitter_types::runtime::maybe_grow_stack(|| {
19208 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19209 })?,
19210 ))),
19211 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19212 }
19213 }
19214}
19215impl ::treesitter_types::Spanned for PreprocPragmaChildren<'_> {
19216 fn span(&self) -> ::treesitter_types::Span {
19217 match self {
19218 Self::Identifier(inner) => inner.span(),
19219 Self::IntegerLiteral(inner) => inner.span(),
19220 Self::StringLiteral(inner) => inner.span(),
19221 }
19222 }
19223}
19224#[derive(Debug, Clone, PartialEq, Eq)]
19225pub enum PrimaryConstructorBaseTypeType<'tree> {
19226 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
19227 GenericName(::std::boxed::Box<GenericName<'tree>>),
19228 Identifier(::std::boxed::Box<Identifier<'tree>>),
19229 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
19230}
19231impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryConstructorBaseTypeType<'tree> {
19232 #[allow(clippy::collapsible_else_if)]
19233 fn from_node(
19234 node: ::treesitter_types::tree_sitter::Node<'tree>,
19235 src: &'tree [u8],
19236 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19237 match node.kind() {
19238 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
19239 ::treesitter_types::runtime::maybe_grow_stack(|| {
19240 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19241 })?,
19242 ))),
19243 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
19244 ::treesitter_types::runtime::maybe_grow_stack(|| {
19245 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
19246 })?,
19247 ))),
19248 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19249 ::treesitter_types::runtime::maybe_grow_stack(|| {
19250 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19251 })?,
19252 ))),
19253 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
19254 ::treesitter_types::runtime::maybe_grow_stack(|| {
19255 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19256 })?,
19257 ))),
19258 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19259 }
19260 }
19261}
19262impl ::treesitter_types::Spanned for PrimaryConstructorBaseTypeType<'_> {
19263 fn span(&self) -> ::treesitter_types::Span {
19264 match self {
19265 Self::AliasQualifiedName(inner) => inner.span(),
19266 Self::GenericName(inner) => inner.span(),
19267 Self::Identifier(inner) => inner.span(),
19268 Self::QualifiedName(inner) => inner.span(),
19269 }
19270 }
19271}
19272#[derive(Debug, Clone, PartialEq, Eq)]
19273pub enum PropertyDeclarationValue<'tree> {
19274 ArrowExpressionClause(::std::boxed::Box<ArrowExpressionClause<'tree>>),
19275 Expression(::std::boxed::Box<Expression<'tree>>),
19276}
19277impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationValue<'tree> {
19278 #[allow(clippy::collapsible_else_if)]
19279 fn from_node(
19280 node: ::treesitter_types::tree_sitter::Node<'tree>,
19281 src: &'tree [u8],
19282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19283 match node.kind() {
19284 "arrow_expression_clause" => Ok(Self::ArrowExpressionClause(::std::boxed::Box::new(
19285 ::treesitter_types::runtime::maybe_grow_stack(|| {
19286 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
19287 })?,
19288 ))),
19289 _other => {
19290 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19291 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19292 }) {
19293 Ok(Self::Expression(::std::boxed::Box::new(v)))
19294 } else {
19295 Err(::treesitter_types::ParseError::unexpected_kind(
19296 _other, node,
19297 ))
19298 }
19299 }
19300 }
19301 }
19302}
19303impl ::treesitter_types::Spanned for PropertyDeclarationValue<'_> {
19304 fn span(&self) -> ::treesitter_types::Span {
19305 match self {
19306 Self::ArrowExpressionClause(inner) => inner.span(),
19307 Self::Expression(inner) => inner.span(),
19308 }
19309 }
19310}
19311#[derive(Debug, Clone, PartialEq, Eq)]
19312pub enum PropertyDeclarationChildren<'tree> {
19313 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
19314 ExplicitInterfaceSpecifier(::std::boxed::Box<ExplicitInterfaceSpecifier<'tree>>),
19315 Modifier(::std::boxed::Box<Modifier<'tree>>),
19316 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
19317}
19318impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationChildren<'tree> {
19319 #[allow(clippy::collapsible_else_if)]
19320 fn from_node(
19321 node: ::treesitter_types::tree_sitter::Node<'tree>,
19322 src: &'tree [u8],
19323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19324 match node.kind() {
19325 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
19326 ::treesitter_types::runtime::maybe_grow_stack(|| {
19327 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19328 })?,
19329 ))),
19330 "explicit_interface_specifier" => Ok(Self::ExplicitInterfaceSpecifier(
19331 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19332 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(
19333 node, src,
19334 )
19335 })?),
19336 )),
19337 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
19338 ::treesitter_types::runtime::maybe_grow_stack(|| {
19339 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
19340 })?,
19341 ))),
19342 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
19343 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19344 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19345 })?),
19346 )),
19347 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19348 }
19349 }
19350}
19351impl ::treesitter_types::Spanned for PropertyDeclarationChildren<'_> {
19352 fn span(&self) -> ::treesitter_types::Span {
19353 match self {
19354 Self::AttributeList(inner) => inner.span(),
19355 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
19356 Self::Modifier(inner) => inner.span(),
19357 Self::PreprocIfInAttributeList(inner) => inner.span(),
19358 }
19359 }
19360}
19361#[derive(Debug, Clone, PartialEq, Eq)]
19362pub enum QualifiedNameName<'tree> {
19363 GenericName(::std::boxed::Box<GenericName<'tree>>),
19364 Identifier(::std::boxed::Box<Identifier<'tree>>),
19365}
19366impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameName<'tree> {
19367 #[allow(clippy::collapsible_else_if)]
19368 fn from_node(
19369 node: ::treesitter_types::tree_sitter::Node<'tree>,
19370 src: &'tree [u8],
19371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19372 match node.kind() {
19373 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
19374 ::treesitter_types::runtime::maybe_grow_stack(|| {
19375 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
19376 })?,
19377 ))),
19378 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19379 ::treesitter_types::runtime::maybe_grow_stack(|| {
19380 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19381 })?,
19382 ))),
19383 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19384 }
19385 }
19386}
19387impl ::treesitter_types::Spanned for QualifiedNameName<'_> {
19388 fn span(&self) -> ::treesitter_types::Span {
19389 match self {
19390 Self::GenericName(inner) => inner.span(),
19391 Self::Identifier(inner) => inner.span(),
19392 }
19393 }
19394}
19395#[derive(Debug, Clone, PartialEq, Eq)]
19396pub enum QualifiedNameQualifier<'tree> {
19397 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
19398 GenericName(::std::boxed::Box<GenericName<'tree>>),
19399 Identifier(::std::boxed::Box<Identifier<'tree>>),
19400 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
19401}
19402impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNameQualifier<'tree> {
19403 #[allow(clippy::collapsible_else_if)]
19404 fn from_node(
19405 node: ::treesitter_types::tree_sitter::Node<'tree>,
19406 src: &'tree [u8],
19407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19408 match node.kind() {
19409 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
19410 ::treesitter_types::runtime::maybe_grow_stack(|| {
19411 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19412 })?,
19413 ))),
19414 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
19415 ::treesitter_types::runtime::maybe_grow_stack(|| {
19416 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
19417 })?,
19418 ))),
19419 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19420 ::treesitter_types::runtime::maybe_grow_stack(|| {
19421 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19422 })?,
19423 ))),
19424 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
19425 ::treesitter_types::runtime::maybe_grow_stack(|| {
19426 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19427 })?,
19428 ))),
19429 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19430 }
19431 }
19432}
19433impl ::treesitter_types::Spanned for QualifiedNameQualifier<'_> {
19434 fn span(&self) -> ::treesitter_types::Span {
19435 match self {
19436 Self::AliasQualifiedName(inner) => inner.span(),
19437 Self::GenericName(inner) => inner.span(),
19438 Self::Identifier(inner) => inner.span(),
19439 Self::QualifiedName(inner) => inner.span(),
19440 }
19441 }
19442}
19443#[derive(Debug, Clone, PartialEq, Eq)]
19444pub enum QueryExpressionChildren<'tree> {
19445 FromClause(::std::boxed::Box<FromClause<'tree>>),
19446 GroupClause(::std::boxed::Box<GroupClause<'tree>>),
19447 Identifier(::std::boxed::Box<Identifier<'tree>>),
19448 JoinClause(::std::boxed::Box<JoinClause<'tree>>),
19449 LetClause(::std::boxed::Box<LetClause<'tree>>),
19450 OrderByClause(::std::boxed::Box<OrderByClause<'tree>>),
19451 SelectClause(::std::boxed::Box<SelectClause<'tree>>),
19452 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
19453}
19454impl<'tree> ::treesitter_types::FromNode<'tree> for QueryExpressionChildren<'tree> {
19455 #[allow(clippy::collapsible_else_if)]
19456 fn from_node(
19457 node: ::treesitter_types::tree_sitter::Node<'tree>,
19458 src: &'tree [u8],
19459 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19460 match node.kind() {
19461 "from_clause" => Ok(Self::FromClause(::std::boxed::Box::new(
19462 ::treesitter_types::runtime::maybe_grow_stack(|| {
19463 <FromClause as ::treesitter_types::FromNode>::from_node(node, src)
19464 })?,
19465 ))),
19466 "group_clause" => Ok(Self::GroupClause(::std::boxed::Box::new(
19467 ::treesitter_types::runtime::maybe_grow_stack(|| {
19468 <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)
19469 })?,
19470 ))),
19471 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19472 ::treesitter_types::runtime::maybe_grow_stack(|| {
19473 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19474 })?,
19475 ))),
19476 "join_clause" => Ok(Self::JoinClause(::std::boxed::Box::new(
19477 ::treesitter_types::runtime::maybe_grow_stack(|| {
19478 <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)
19479 })?,
19480 ))),
19481 "let_clause" => Ok(Self::LetClause(::std::boxed::Box::new(
19482 ::treesitter_types::runtime::maybe_grow_stack(|| {
19483 <LetClause as ::treesitter_types::FromNode>::from_node(node, src)
19484 })?,
19485 ))),
19486 "order_by_clause" => Ok(Self::OrderByClause(::std::boxed::Box::new(
19487 ::treesitter_types::runtime::maybe_grow_stack(|| {
19488 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)
19489 })?,
19490 ))),
19491 "select_clause" => Ok(Self::SelectClause(::std::boxed::Box::new(
19492 ::treesitter_types::runtime::maybe_grow_stack(|| {
19493 <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)
19494 })?,
19495 ))),
19496 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
19497 ::treesitter_types::runtime::maybe_grow_stack(|| {
19498 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
19499 })?,
19500 ))),
19501 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19502 }
19503 }
19504}
19505impl ::treesitter_types::Spanned for QueryExpressionChildren<'_> {
19506 fn span(&self) -> ::treesitter_types::Span {
19507 match self {
19508 Self::FromClause(inner) => inner.span(),
19509 Self::GroupClause(inner) => inner.span(),
19510 Self::Identifier(inner) => inner.span(),
19511 Self::JoinClause(inner) => inner.span(),
19512 Self::LetClause(inner) => inner.span(),
19513 Self::OrderByClause(inner) => inner.span(),
19514 Self::SelectClause(inner) => inner.span(),
19515 Self::WhereClause(inner) => inner.span(),
19516 }
19517 }
19518}
19519#[derive(Debug, Clone, PartialEq, Eq)]
19520pub enum RawStringLiteralChildren<'tree> {
19521 RawStringContent(::std::boxed::Box<RawStringContent<'tree>>),
19522 RawStringEnd(::std::boxed::Box<RawStringEnd<'tree>>),
19523 RawStringStart(::std::boxed::Box<RawStringStart<'tree>>),
19524}
19525impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralChildren<'tree> {
19526 #[allow(clippy::collapsible_else_if)]
19527 fn from_node(
19528 node: ::treesitter_types::tree_sitter::Node<'tree>,
19529 src: &'tree [u8],
19530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19531 match node.kind() {
19532 "raw_string_content" => Ok(Self::RawStringContent(::std::boxed::Box::new(
19533 ::treesitter_types::runtime::maybe_grow_stack(|| {
19534 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
19535 })?,
19536 ))),
19537 "raw_string_end" => Ok(Self::RawStringEnd(::std::boxed::Box::new(
19538 ::treesitter_types::runtime::maybe_grow_stack(|| {
19539 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)
19540 })?,
19541 ))),
19542 "raw_string_start" => Ok(Self::RawStringStart(::std::boxed::Box::new(
19543 ::treesitter_types::runtime::maybe_grow_stack(|| {
19544 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)
19545 })?,
19546 ))),
19547 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19548 }
19549 }
19550}
19551impl ::treesitter_types::Spanned for RawStringLiteralChildren<'_> {
19552 fn span(&self) -> ::treesitter_types::Span {
19553 match self {
19554 Self::RawStringContent(inner) => inner.span(),
19555 Self::RawStringEnd(inner) => inner.span(),
19556 Self::RawStringStart(inner) => inner.span(),
19557 }
19558 }
19559}
19560#[derive(Debug, Clone, PartialEq, Eq)]
19561pub enum RecordDeclarationChildren<'tree> {
19562 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
19563 BaseList(::std::boxed::Box<BaseList<'tree>>),
19564 Modifier(::std::boxed::Box<Modifier<'tree>>),
19565 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
19566 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
19567 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
19568 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
19569}
19570impl<'tree> ::treesitter_types::FromNode<'tree> for RecordDeclarationChildren<'tree> {
19571 #[allow(clippy::collapsible_else_if)]
19572 fn from_node(
19573 node: ::treesitter_types::tree_sitter::Node<'tree>,
19574 src: &'tree [u8],
19575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19576 match node.kind() {
19577 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
19578 ::treesitter_types::runtime::maybe_grow_stack(|| {
19579 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19580 })?,
19581 ))),
19582 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
19583 ::treesitter_types::runtime::maybe_grow_stack(|| {
19584 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
19585 })?,
19586 ))),
19587 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
19588 ::treesitter_types::runtime::maybe_grow_stack(|| {
19589 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
19590 })?,
19591 ))),
19592 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
19593 ::treesitter_types::runtime::maybe_grow_stack(|| {
19594 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19595 })?,
19596 ))),
19597 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
19598 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19599 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19600 })?),
19601 )),
19602 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
19603 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19604 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
19605 node, src,
19606 )
19607 })?),
19608 )),
19609 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
19610 ::treesitter_types::runtime::maybe_grow_stack(|| {
19611 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19612 })?,
19613 ))),
19614 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19615 }
19616 }
19617}
19618impl ::treesitter_types::Spanned for RecordDeclarationChildren<'_> {
19619 fn span(&self) -> ::treesitter_types::Span {
19620 match self {
19621 Self::AttributeList(inner) => inner.span(),
19622 Self::BaseList(inner) => inner.span(),
19623 Self::Modifier(inner) => inner.span(),
19624 Self::ParameterList(inner) => inner.span(),
19625 Self::PreprocIfInAttributeList(inner) => inner.span(),
19626 Self::TypeParameterConstraintsClause(inner) => inner.span(),
19627 Self::TypeParameterList(inner) => inner.span(),
19628 }
19629 }
19630}
19631#[derive(Debug, Clone, PartialEq, Eq)]
19632pub enum RecursivePatternChildren<'tree> {
19633 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
19634 Pattern(::std::boxed::Box<Pattern<'tree>>),
19635 PositionalPatternClause(::std::boxed::Box<PositionalPatternClause<'tree>>),
19636 PropertyPatternClause(::std::boxed::Box<PropertyPatternClause<'tree>>),
19637}
19638impl<'tree> ::treesitter_types::FromNode<'tree> for RecursivePatternChildren<'tree> {
19639 #[allow(clippy::collapsible_else_if)]
19640 fn from_node(
19641 node: ::treesitter_types::tree_sitter::Node<'tree>,
19642 src: &'tree [u8],
19643 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19644 match node.kind() {
19645 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
19646 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19647 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
19648 node, src,
19649 )
19650 })?),
19651 )),
19652 "positional_pattern_clause" => Ok(Self::PositionalPatternClause(
19653 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19654 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
19655 })?),
19656 )),
19657 "property_pattern_clause" => Ok(Self::PropertyPatternClause(::std::boxed::Box::new(
19658 ::treesitter_types::runtime::maybe_grow_stack(|| {
19659 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
19660 })?,
19661 ))),
19662 _other => {
19663 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19664 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
19665 }) {
19666 Ok(Self::Pattern(::std::boxed::Box::new(v)))
19667 } else {
19668 Err(::treesitter_types::ParseError::unexpected_kind(
19669 _other, node,
19670 ))
19671 }
19672 }
19673 }
19674 }
19675}
19676impl ::treesitter_types::Spanned for RecursivePatternChildren<'_> {
19677 fn span(&self) -> ::treesitter_types::Span {
19678 match self {
19679 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
19680 Self::Pattern(inner) => inner.span(),
19681 Self::PositionalPatternClause(inner) => inner.span(),
19682 Self::PropertyPatternClause(inner) => inner.span(),
19683 }
19684 }
19685}
19686#[derive(Debug, Clone, PartialEq, Eq)]
19687pub enum ScopedTypeType<'tree> {
19688 AliasQualifiedName(::std::boxed::Box<AliasQualifiedName<'tree>>),
19689 GenericName(::std::boxed::Box<GenericName<'tree>>),
19690 Identifier(::std::boxed::Box<Identifier<'tree>>),
19691 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
19692 RefType(::std::boxed::Box<RefType<'tree>>),
19693}
19694impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeType<'tree> {
19695 #[allow(clippy::collapsible_else_if)]
19696 fn from_node(
19697 node: ::treesitter_types::tree_sitter::Node<'tree>,
19698 src: &'tree [u8],
19699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19700 match node.kind() {
19701 "alias_qualified_name" => Ok(Self::AliasQualifiedName(::std::boxed::Box::new(
19702 ::treesitter_types::runtime::maybe_grow_stack(|| {
19703 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19704 })?,
19705 ))),
19706 "generic_name" => Ok(Self::GenericName(::std::boxed::Box::new(
19707 ::treesitter_types::runtime::maybe_grow_stack(|| {
19708 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
19709 })?,
19710 ))),
19711 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19712 ::treesitter_types::runtime::maybe_grow_stack(|| {
19713 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19714 })?,
19715 ))),
19716 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
19717 ::treesitter_types::runtime::maybe_grow_stack(|| {
19718 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
19719 })?,
19720 ))),
19721 "ref_type" => Ok(Self::RefType(::std::boxed::Box::new(
19722 ::treesitter_types::runtime::maybe_grow_stack(|| {
19723 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
19724 })?,
19725 ))),
19726 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19727 }
19728 }
19729}
19730impl ::treesitter_types::Spanned for ScopedTypeType<'_> {
19731 fn span(&self) -> ::treesitter_types::Span {
19732 match self {
19733 Self::AliasQualifiedName(inner) => inner.span(),
19734 Self::GenericName(inner) => inner.span(),
19735 Self::Identifier(inner) => inner.span(),
19736 Self::QualifiedName(inner) => inner.span(),
19737 Self::RefType(inner) => inner.span(),
19738 }
19739 }
19740}
19741#[derive(Debug, Clone, PartialEq, Eq)]
19742pub enum StringLiteralChildren<'tree> {
19743 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
19744 StringLiteralContent(::std::boxed::Box<StringLiteralContent<'tree>>),
19745 StringLiteralEncoding(::std::boxed::Box<StringLiteralEncoding<'tree>>),
19746}
19747impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
19748 #[allow(clippy::collapsible_else_if)]
19749 fn from_node(
19750 node: ::treesitter_types::tree_sitter::Node<'tree>,
19751 src: &'tree [u8],
19752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19753 match node.kind() {
19754 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
19755 ::treesitter_types::runtime::maybe_grow_stack(|| {
19756 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
19757 })?,
19758 ))),
19759 "string_literal_content" => Ok(Self::StringLiteralContent(::std::boxed::Box::new(
19760 ::treesitter_types::runtime::maybe_grow_stack(|| {
19761 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
19762 })?,
19763 ))),
19764 "string_literal_encoding" => Ok(Self::StringLiteralEncoding(::std::boxed::Box::new(
19765 ::treesitter_types::runtime::maybe_grow_stack(|| {
19766 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)
19767 })?,
19768 ))),
19769 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19770 }
19771 }
19772}
19773impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
19774 fn span(&self) -> ::treesitter_types::Span {
19775 match self {
19776 Self::EscapeSequence(inner) => inner.span(),
19777 Self::StringLiteralContent(inner) => inner.span(),
19778 Self::StringLiteralEncoding(inner) => inner.span(),
19779 }
19780 }
19781}
19782#[derive(Debug, Clone, PartialEq, Eq)]
19783pub enum StructDeclarationChildren<'tree> {
19784 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
19785 BaseList(::std::boxed::Box<BaseList<'tree>>),
19786 Modifier(::std::boxed::Box<Modifier<'tree>>),
19787 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
19788 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
19789 TypeParameterConstraintsClause(::std::boxed::Box<TypeParameterConstraintsClause<'tree>>),
19790 TypeParameterList(::std::boxed::Box<TypeParameterList<'tree>>),
19791}
19792impl<'tree> ::treesitter_types::FromNode<'tree> for StructDeclarationChildren<'tree> {
19793 #[allow(clippy::collapsible_else_if)]
19794 fn from_node(
19795 node: ::treesitter_types::tree_sitter::Node<'tree>,
19796 src: &'tree [u8],
19797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19798 match node.kind() {
19799 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
19800 ::treesitter_types::runtime::maybe_grow_stack(|| {
19801 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19802 })?,
19803 ))),
19804 "base_list" => Ok(Self::BaseList(::std::boxed::Box::new(
19805 ::treesitter_types::runtime::maybe_grow_stack(|| {
19806 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
19807 })?,
19808 ))),
19809 "modifier" => Ok(Self::Modifier(::std::boxed::Box::new(
19810 ::treesitter_types::runtime::maybe_grow_stack(|| {
19811 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
19812 })?,
19813 ))),
19814 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
19815 ::treesitter_types::runtime::maybe_grow_stack(|| {
19816 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19817 })?,
19818 ))),
19819 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
19820 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19821 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
19822 })?),
19823 )),
19824 "type_parameter_constraints_clause" => Ok(Self::TypeParameterConstraintsClause(
19825 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19826 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
19827 node, src,
19828 )
19829 })?),
19830 )),
19831 "type_parameter_list" => Ok(Self::TypeParameterList(::std::boxed::Box::new(
19832 ::treesitter_types::runtime::maybe_grow_stack(|| {
19833 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19834 })?,
19835 ))),
19836 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19837 }
19838 }
19839}
19840impl ::treesitter_types::Spanned for StructDeclarationChildren<'_> {
19841 fn span(&self) -> ::treesitter_types::Span {
19842 match self {
19843 Self::AttributeList(inner) => inner.span(),
19844 Self::BaseList(inner) => inner.span(),
19845 Self::Modifier(inner) => inner.span(),
19846 Self::ParameterList(inner) => inner.span(),
19847 Self::PreprocIfInAttributeList(inner) => inner.span(),
19848 Self::TypeParameterConstraintsClause(inner) => inner.span(),
19849 Self::TypeParameterList(inner) => inner.span(),
19850 }
19851 }
19852}
19853#[derive(Debug, Clone, PartialEq, Eq)]
19854pub enum SubpatternChildren<'tree> {
19855 Expression(::std::boxed::Box<Expression<'tree>>),
19856 Identifier(::std::boxed::Box<Identifier<'tree>>),
19857 Pattern(::std::boxed::Box<Pattern<'tree>>),
19858}
19859impl<'tree> ::treesitter_types::FromNode<'tree> for SubpatternChildren<'tree> {
19860 #[allow(clippy::collapsible_else_if)]
19861 fn from_node(
19862 node: ::treesitter_types::tree_sitter::Node<'tree>,
19863 src: &'tree [u8],
19864 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19865 match node.kind() {
19866 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19867 ::treesitter_types::runtime::maybe_grow_stack(|| {
19868 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
19869 })?,
19870 ))),
19871 _other => {
19872 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19873 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19874 }) {
19875 Ok(Self::Expression(::std::boxed::Box::new(v)))
19876 } else {
19877 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19878 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
19879 }) {
19880 Ok(Self::Pattern(::std::boxed::Box::new(v)))
19881 } else {
19882 Err(::treesitter_types::ParseError::unexpected_kind(
19883 _other, node,
19884 ))
19885 }
19886 }
19887 }
19888 }
19889 }
19890}
19891impl ::treesitter_types::Spanned for SubpatternChildren<'_> {
19892 fn span(&self) -> ::treesitter_types::Span {
19893 match self {
19894 Self::Expression(inner) => inner.span(),
19895 Self::Identifier(inner) => inner.span(),
19896 Self::Pattern(inner) => inner.span(),
19897 }
19898 }
19899}
19900#[derive(Debug, Clone, PartialEq, Eq)]
19901pub enum SwitchExpressionChildren<'tree> {
19902 Expression(::std::boxed::Box<Expression<'tree>>),
19903 SwitchExpressionArm(::std::boxed::Box<SwitchExpressionArm<'tree>>),
19904}
19905impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionChildren<'tree> {
19906 #[allow(clippy::collapsible_else_if)]
19907 fn from_node(
19908 node: ::treesitter_types::tree_sitter::Node<'tree>,
19909 src: &'tree [u8],
19910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19911 match node.kind() {
19912 "switch_expression_arm" => Ok(Self::SwitchExpressionArm(::std::boxed::Box::new(
19913 ::treesitter_types::runtime::maybe_grow_stack(|| {
19914 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)
19915 })?,
19916 ))),
19917 _other => {
19918 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19919 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19920 }) {
19921 Ok(Self::Expression(::std::boxed::Box::new(v)))
19922 } else {
19923 Err(::treesitter_types::ParseError::unexpected_kind(
19924 _other, node,
19925 ))
19926 }
19927 }
19928 }
19929 }
19930}
19931impl ::treesitter_types::Spanned for SwitchExpressionChildren<'_> {
19932 fn span(&self) -> ::treesitter_types::Span {
19933 match self {
19934 Self::Expression(inner) => inner.span(),
19935 Self::SwitchExpressionArm(inner) => inner.span(),
19936 }
19937 }
19938}
19939#[derive(Debug, Clone, PartialEq, Eq)]
19940pub enum SwitchExpressionArmChildren<'tree> {
19941 Expression(::std::boxed::Box<Expression<'tree>>),
19942 Pattern(::std::boxed::Box<Pattern<'tree>>),
19943 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
19944}
19945impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchExpressionArmChildren<'tree> {
19946 #[allow(clippy::collapsible_else_if)]
19947 fn from_node(
19948 node: ::treesitter_types::tree_sitter::Node<'tree>,
19949 src: &'tree [u8],
19950 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19951 match node.kind() {
19952 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
19953 ::treesitter_types::runtime::maybe_grow_stack(|| {
19954 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
19955 })?,
19956 ))),
19957 _other => {
19958 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19959 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19960 }) {
19961 Ok(Self::Expression(::std::boxed::Box::new(v)))
19962 } else {
19963 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19964 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
19965 }) {
19966 Ok(Self::Pattern(::std::boxed::Box::new(v)))
19967 } else {
19968 Err(::treesitter_types::ParseError::unexpected_kind(
19969 _other, node,
19970 ))
19971 }
19972 }
19973 }
19974 }
19975 }
19976}
19977impl ::treesitter_types::Spanned for SwitchExpressionArmChildren<'_> {
19978 fn span(&self) -> ::treesitter_types::Span {
19979 match self {
19980 Self::Expression(inner) => inner.span(),
19981 Self::Pattern(inner) => inner.span(),
19982 Self::WhenClause(inner) => inner.span(),
19983 }
19984 }
19985}
19986#[derive(Debug, Clone, PartialEq, Eq)]
19987pub enum SwitchSectionChildren<'tree> {
19988 Expression(::std::boxed::Box<Expression<'tree>>),
19989 Pattern(::std::boxed::Box<Pattern<'tree>>),
19990 Statement(::std::boxed::Box<Statement<'tree>>),
19991 WhenClause(::std::boxed::Box<WhenClause<'tree>>),
19992}
19993impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchSectionChildren<'tree> {
19994 #[allow(clippy::collapsible_else_if)]
19995 fn from_node(
19996 node: ::treesitter_types::tree_sitter::Node<'tree>,
19997 src: &'tree [u8],
19998 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19999 match node.kind() {
20000 "when_clause" => Ok(Self::WhenClause(::std::boxed::Box::new(
20001 ::treesitter_types::runtime::maybe_grow_stack(|| {
20002 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
20003 })?,
20004 ))),
20005 _other => {
20006 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20007 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20008 }) {
20009 Ok(Self::Expression(::std::boxed::Box::new(v)))
20010 } else {
20011 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20012 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
20013 }) {
20014 Ok(Self::Pattern(::std::boxed::Box::new(v)))
20015 } else {
20016 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20017 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
20018 }) {
20019 Ok(Self::Statement(::std::boxed::Box::new(v)))
20020 } else {
20021 Err(::treesitter_types::ParseError::unexpected_kind(
20022 _other, node,
20023 ))
20024 }
20025 }
20026 }
20027 }
20028 }
20029 }
20030}
20031impl ::treesitter_types::Spanned for SwitchSectionChildren<'_> {
20032 fn span(&self) -> ::treesitter_types::Span {
20033 match self {
20034 Self::Expression(inner) => inner.span(),
20035 Self::Pattern(inner) => inner.span(),
20036 Self::Statement(inner) => inner.span(),
20037 Self::WhenClause(inner) => inner.span(),
20038 }
20039 }
20040}
20041#[derive(Debug, Clone, PartialEq, Eq)]
20042pub enum SwitchStatementValue<'tree> {
20043 Expression(::std::boxed::Box<Expression<'tree>>),
20044 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
20045}
20046impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatementValue<'tree> {
20047 #[allow(clippy::collapsible_else_if)]
20048 fn from_node(
20049 node: ::treesitter_types::tree_sitter::Node<'tree>,
20050 src: &'tree [u8],
20051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20052 match node.kind() {
20053 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
20054 ::treesitter_types::runtime::maybe_grow_stack(|| {
20055 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
20056 })?,
20057 ))),
20058 _other => {
20059 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20060 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20061 }) {
20062 Ok(Self::Expression(::std::boxed::Box::new(v)))
20063 } else {
20064 Err(::treesitter_types::ParseError::unexpected_kind(
20065 _other, node,
20066 ))
20067 }
20068 }
20069 }
20070 }
20071}
20072impl ::treesitter_types::Spanned for SwitchStatementValue<'_> {
20073 fn span(&self) -> ::treesitter_types::Span {
20074 match self {
20075 Self::Expression(inner) => inner.span(),
20076 Self::TupleExpression(inner) => inner.span(),
20077 }
20078 }
20079}
20080#[derive(Debug, Clone, PartialEq, Eq)]
20081pub enum TryStatementChildren<'tree> {
20082 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
20083 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
20084}
20085impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
20086 #[allow(clippy::collapsible_else_if)]
20087 fn from_node(
20088 node: ::treesitter_types::tree_sitter::Node<'tree>,
20089 src: &'tree [u8],
20090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20091 match node.kind() {
20092 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
20093 ::treesitter_types::runtime::maybe_grow_stack(|| {
20094 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
20095 })?,
20096 ))),
20097 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
20098 ::treesitter_types::runtime::maybe_grow_stack(|| {
20099 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
20100 })?,
20101 ))),
20102 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20103 }
20104 }
20105}
20106impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
20107 fn span(&self) -> ::treesitter_types::Span {
20108 match self {
20109 Self::CatchClause(inner) => inner.span(),
20110 Self::FinallyClause(inner) => inner.span(),
20111 }
20112 }
20113}
20114#[derive(Debug, Clone, PartialEq, Eq)]
20115pub enum TuplePatternChildren<'tree> {
20116 Discard(::std::boxed::Box<Discard<'tree>>),
20117 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
20118}
20119impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
20120 #[allow(clippy::collapsible_else_if)]
20121 fn from_node(
20122 node: ::treesitter_types::tree_sitter::Node<'tree>,
20123 src: &'tree [u8],
20124 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20125 match node.kind() {
20126 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
20127 ::treesitter_types::runtime::maybe_grow_stack(|| {
20128 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
20129 })?,
20130 ))),
20131 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
20132 ::treesitter_types::runtime::maybe_grow_stack(|| {
20133 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
20134 })?,
20135 ))),
20136 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20137 }
20138 }
20139}
20140impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
20141 fn span(&self) -> ::treesitter_types::Span {
20142 match self {
20143 Self::Discard(inner) => inner.span(),
20144 Self::TuplePattern(inner) => inner.span(),
20145 }
20146 }
20147}
20148#[derive(Debug, Clone, PartialEq, Eq)]
20149pub enum TypeParameterChildren<'tree> {
20150 AttributeList(::std::boxed::Box<AttributeList<'tree>>),
20151 PreprocIfInAttributeList(::std::boxed::Box<PreprocIfInAttributeList<'tree>>),
20152}
20153impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterChildren<'tree> {
20154 #[allow(clippy::collapsible_else_if)]
20155 fn from_node(
20156 node: ::treesitter_types::tree_sitter::Node<'tree>,
20157 src: &'tree [u8],
20158 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20159 match node.kind() {
20160 "attribute_list" => Ok(Self::AttributeList(::std::boxed::Box::new(
20161 ::treesitter_types::runtime::maybe_grow_stack(|| {
20162 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
20163 })?,
20164 ))),
20165 "preproc_if_in_attribute_list" => Ok(Self::PreprocIfInAttributeList(
20166 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20167 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
20168 })?),
20169 )),
20170 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20171 }
20172 }
20173}
20174impl ::treesitter_types::Spanned for TypeParameterChildren<'_> {
20175 fn span(&self) -> ::treesitter_types::Span {
20176 match self {
20177 Self::AttributeList(inner) => inner.span(),
20178 Self::PreprocIfInAttributeList(inner) => inner.span(),
20179 }
20180 }
20181}
20182#[derive(Debug, Clone, PartialEq, Eq)]
20183pub enum TypeParameterConstraintsClauseChildren<'tree> {
20184 Identifier(::std::boxed::Box<Identifier<'tree>>),
20185 TypeParameterConstraint(::std::boxed::Box<TypeParameterConstraint<'tree>>),
20186}
20187impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterConstraintsClauseChildren<'tree> {
20188 #[allow(clippy::collapsible_else_if)]
20189 fn from_node(
20190 node: ::treesitter_types::tree_sitter::Node<'tree>,
20191 src: &'tree [u8],
20192 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20193 match node.kind() {
20194 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
20195 ::treesitter_types::runtime::maybe_grow_stack(|| {
20196 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20197 })?,
20198 ))),
20199 "type_parameter_constraint" => Ok(Self::TypeParameterConstraint(
20200 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20201 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(node, src)
20202 })?),
20203 )),
20204 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20205 }
20206 }
20207}
20208impl ::treesitter_types::Spanned for TypeParameterConstraintsClauseChildren<'_> {
20209 fn span(&self) -> ::treesitter_types::Span {
20210 match self {
20211 Self::Identifier(inner) => inner.span(),
20212 Self::TypeParameterConstraint(inner) => inner.span(),
20213 }
20214 }
20215}
20216#[derive(Debug, Clone, PartialEq, Eq)]
20217pub enum UnaryExpressionArgument<'tree> {
20218 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
20219 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
20220 CharacterLiteral(::std::boxed::Box<CharacterLiteral<'tree>>),
20221 Identifier(::std::boxed::Box<Identifier<'tree>>),
20222 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
20223 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
20224 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
20225}
20226impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
20227 #[allow(clippy::collapsible_else_if)]
20228 fn from_node(
20229 node: ::treesitter_types::tree_sitter::Node<'tree>,
20230 src: &'tree [u8],
20231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20232 match node.kind() {
20233 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
20234 ::treesitter_types::runtime::maybe_grow_stack(|| {
20235 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20236 })?,
20237 ))),
20238 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
20239 ::treesitter_types::runtime::maybe_grow_stack(|| {
20240 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20241 })?,
20242 ))),
20243 "character_literal" => Ok(Self::CharacterLiteral(::std::boxed::Box::new(
20244 ::treesitter_types::runtime::maybe_grow_stack(|| {
20245 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20246 })?,
20247 ))),
20248 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
20249 ::treesitter_types::runtime::maybe_grow_stack(|| {
20250 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20251 })?,
20252 ))),
20253 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
20254 ::treesitter_types::runtime::maybe_grow_stack(|| {
20255 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20256 })?,
20257 ))),
20258 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
20259 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20260 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
20261 })?),
20262 )),
20263 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
20264 ::treesitter_types::runtime::maybe_grow_stack(|| {
20265 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20266 })?,
20267 ))),
20268 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20269 }
20270 }
20271}
20272impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
20273 fn span(&self) -> ::treesitter_types::Span {
20274 match self {
20275 Self::BinaryExpression(inner) => inner.span(),
20276 Self::BooleanLiteral(inner) => inner.span(),
20277 Self::CharacterLiteral(inner) => inner.span(),
20278 Self::Identifier(inner) => inner.span(),
20279 Self::IntegerLiteral(inner) => inner.span(),
20280 Self::ParenthesizedExpression(inner) => inner.span(),
20281 Self::UnaryExpression(inner) => inner.span(),
20282 }
20283 }
20284}
20285#[derive(Debug, Clone, PartialEq, Eq)]
20286pub enum UnaryExpressionOperator {
20287 Bang(::treesitter_types::Span),
20288}
20289impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
20290 #[allow(clippy::collapsible_else_if)]
20291 fn from_node(
20292 node: ::treesitter_types::tree_sitter::Node<'tree>,
20293 _src: &'tree [u8],
20294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20295 match node.kind() {
20296 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
20297 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20298 }
20299 }
20300}
20301impl ::treesitter_types::Spanned for UnaryExpressionOperator {
20302 fn span(&self) -> ::treesitter_types::Span {
20303 match self {
20304 Self::Bang(span) => *span,
20305 }
20306 }
20307}
20308#[derive(Debug, Clone, PartialEq, Eq)]
20309pub enum UsingStatementChildren<'tree> {
20310 Expression(::std::boxed::Box<Expression<'tree>>),
20311 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
20312}
20313impl<'tree> ::treesitter_types::FromNode<'tree> for UsingStatementChildren<'tree> {
20314 #[allow(clippy::collapsible_else_if)]
20315 fn from_node(
20316 node: ::treesitter_types::tree_sitter::Node<'tree>,
20317 src: &'tree [u8],
20318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20319 match node.kind() {
20320 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
20321 ::treesitter_types::runtime::maybe_grow_stack(|| {
20322 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20323 })?,
20324 ))),
20325 _other => {
20326 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20327 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20328 }) {
20329 Ok(Self::Expression(::std::boxed::Box::new(v)))
20330 } else {
20331 Err(::treesitter_types::ParseError::unexpected_kind(
20332 _other, node,
20333 ))
20334 }
20335 }
20336 }
20337 }
20338}
20339impl ::treesitter_types::Spanned for UsingStatementChildren<'_> {
20340 fn span(&self) -> ::treesitter_types::Span {
20341 match self {
20342 Self::Expression(inner) => inner.span(),
20343 Self::VariableDeclaration(inner) => inner.span(),
20344 }
20345 }
20346}
20347#[derive(Debug, Clone, PartialEq, Eq)]
20348pub enum VarPatternChildren<'tree> {
20349 Discard(::std::boxed::Box<Discard<'tree>>),
20350 ParenthesizedVariableDesignation(::std::boxed::Box<ParenthesizedVariableDesignation<'tree>>),
20351}
20352impl<'tree> ::treesitter_types::FromNode<'tree> for VarPatternChildren<'tree> {
20353 #[allow(clippy::collapsible_else_if)]
20354 fn from_node(
20355 node: ::treesitter_types::tree_sitter::Node<'tree>,
20356 src: &'tree [u8],
20357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20358 match node.kind() {
20359 "discard" => Ok(Self::Discard(::std::boxed::Box::new(
20360 ::treesitter_types::runtime::maybe_grow_stack(|| {
20361 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
20362 })?,
20363 ))),
20364 "parenthesized_variable_designation" => Ok(Self::ParenthesizedVariableDesignation(
20365 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20366 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
20367 node, src,
20368 )
20369 })?),
20370 )),
20371 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20372 }
20373 }
20374}
20375impl ::treesitter_types::Spanned for VarPatternChildren<'_> {
20376 fn span(&self) -> ::treesitter_types::Span {
20377 match self {
20378 Self::Discard(inner) => inner.span(),
20379 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
20380 }
20381 }
20382}
20383#[derive(Debug, Clone, PartialEq, Eq)]
20384pub enum VariableDeclaratorChildren<'tree> {
20385 BracketedArgumentList(::std::boxed::Box<BracketedArgumentList<'tree>>),
20386 Expression(::std::boxed::Box<Expression<'tree>>),
20387 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
20388}
20389impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorChildren<'tree> {
20390 #[allow(clippy::collapsible_else_if)]
20391 fn from_node(
20392 node: ::treesitter_types::tree_sitter::Node<'tree>,
20393 src: &'tree [u8],
20394 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20395 match node.kind() {
20396 "bracketed_argument_list" => Ok(Self::BracketedArgumentList(::std::boxed::Box::new(
20397 ::treesitter_types::runtime::maybe_grow_stack(|| {
20398 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20399 })?,
20400 ))),
20401 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
20402 ::treesitter_types::runtime::maybe_grow_stack(|| {
20403 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
20404 })?,
20405 ))),
20406 _other => {
20407 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20408 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20409 }) {
20410 Ok(Self::Expression(::std::boxed::Box::new(v)))
20411 } else {
20412 Err(::treesitter_types::ParseError::unexpected_kind(
20413 _other, node,
20414 ))
20415 }
20416 }
20417 }
20418 }
20419}
20420impl ::treesitter_types::Spanned for VariableDeclaratorChildren<'_> {
20421 fn span(&self) -> ::treesitter_types::Span {
20422 match self {
20423 Self::BracketedArgumentList(inner) => inner.span(),
20424 Self::Expression(inner) => inner.span(),
20425 Self::TuplePattern(inner) => inner.span(),
20426 }
20427 }
20428}
20429#[derive(Debug, Clone, PartialEq, Eq)]
20430pub enum WithExpressionChildren<'tree> {
20431 Expression(::std::boxed::Box<Expression<'tree>>),
20432 WithInitializer(::std::boxed::Box<WithInitializer<'tree>>),
20433}
20434impl<'tree> ::treesitter_types::FromNode<'tree> for WithExpressionChildren<'tree> {
20435 #[allow(clippy::collapsible_else_if)]
20436 fn from_node(
20437 node: ::treesitter_types::tree_sitter::Node<'tree>,
20438 src: &'tree [u8],
20439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20440 match node.kind() {
20441 "with_initializer" => Ok(Self::WithInitializer(::std::boxed::Box::new(
20442 ::treesitter_types::runtime::maybe_grow_stack(|| {
20443 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)
20444 })?,
20445 ))),
20446 _other => {
20447 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20448 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20449 }) {
20450 Ok(Self::Expression(::std::boxed::Box::new(v)))
20451 } else {
20452 Err(::treesitter_types::ParseError::unexpected_kind(
20453 _other, node,
20454 ))
20455 }
20456 }
20457 }
20458 }
20459}
20460impl ::treesitter_types::Spanned for WithExpressionChildren<'_> {
20461 fn span(&self) -> ::treesitter_types::Span {
20462 match self {
20463 Self::Expression(inner) => inner.span(),
20464 Self::WithInitializer(inner) => inner.span(),
20465 }
20466 }
20467}
20468#[derive(Debug, Clone, PartialEq, Eq)]
20469pub enum WithInitializerChildren<'tree> {
20470 Expression(::std::boxed::Box<Expression<'tree>>),
20471 Identifier(::std::boxed::Box<Identifier<'tree>>),
20472}
20473impl<'tree> ::treesitter_types::FromNode<'tree> for WithInitializerChildren<'tree> {
20474 #[allow(clippy::collapsible_else_if)]
20475 fn from_node(
20476 node: ::treesitter_types::tree_sitter::Node<'tree>,
20477 src: &'tree [u8],
20478 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20479 match node.kind() {
20480 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
20481 ::treesitter_types::runtime::maybe_grow_stack(|| {
20482 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20483 })?,
20484 ))),
20485 _other => {
20486 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20487 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20488 }) {
20489 Ok(Self::Expression(::std::boxed::Box::new(v)))
20490 } else {
20491 Err(::treesitter_types::ParseError::unexpected_kind(
20492 _other, node,
20493 ))
20494 }
20495 }
20496 }
20497 }
20498}
20499impl ::treesitter_types::Spanned for WithInitializerChildren<'_> {
20500 fn span(&self) -> ::treesitter_types::Span {
20501 match self {
20502 Self::Expression(inner) => inner.span(),
20503 Self::Identifier(inner) => inner.span(),
20504 }
20505 }
20506}
20507#[derive(Debug, Clone, PartialEq, Eq)]
20508pub enum AnyNode<'tree> {
20509 Declaration(Declaration<'tree>),
20510 Expression(Expression<'tree>),
20511 Literal(Literal<'tree>),
20512 LvalueExpression(LvalueExpression<'tree>),
20513 NonLvalueExpression(NonLvalueExpression<'tree>),
20514 Pattern(Pattern<'tree>),
20515 Statement(Statement<'tree>),
20516 Type(Type<'tree>),
20517 TypeDeclaration(TypeDeclaration<'tree>),
20518 AccessorDeclaration(AccessorDeclaration<'tree>),
20519 AccessorList(AccessorList<'tree>),
20520 AliasQualifiedName(AliasQualifiedName<'tree>),
20521 AndPattern(AndPattern<'tree>),
20522 AnonymousMethodExpression(AnonymousMethodExpression<'tree>),
20523 AnonymousObjectCreationExpression(AnonymousObjectCreationExpression<'tree>),
20524 Argument(Argument<'tree>),
20525 ArgumentList(ArgumentList<'tree>),
20526 ArrayCreationExpression(ArrayCreationExpression<'tree>),
20527 ArrayRankSpecifier(ArrayRankSpecifier<'tree>),
20528 ArrayType(ArrayType<'tree>),
20529 ArrowExpressionClause(ArrowExpressionClause<'tree>),
20530 AsExpression(AsExpression<'tree>),
20531 AssignmentExpression(AssignmentExpression<'tree>),
20532 Attribute(Attribute<'tree>),
20533 AttributeArgument(AttributeArgument<'tree>),
20534 AttributeArgumentList(AttributeArgumentList<'tree>),
20535 AttributeList(AttributeList<'tree>),
20536 AttributeTargetSpecifier(AttributeTargetSpecifier<'tree>),
20537 AwaitExpression(AwaitExpression<'tree>),
20538 BaseList(BaseList<'tree>),
20539 BinaryExpression(BinaryExpression<'tree>),
20540 Block(Block<'tree>),
20541 BooleanLiteral(BooleanLiteral<'tree>),
20542 BracketedArgumentList(BracketedArgumentList<'tree>),
20543 BracketedParameterList(BracketedParameterList<'tree>),
20544 BreakStatement(BreakStatement<'tree>),
20545 CallingConvention(CallingConvention<'tree>),
20546 CastExpression(CastExpression<'tree>),
20547 CatchClause(CatchClause<'tree>),
20548 CatchDeclaration(CatchDeclaration<'tree>),
20549 CatchFilterClause(CatchFilterClause<'tree>),
20550 CharacterLiteral(CharacterLiteral<'tree>),
20551 CheckedExpression(CheckedExpression<'tree>),
20552 CheckedStatement(CheckedStatement<'tree>),
20553 ClassDeclaration(ClassDeclaration<'tree>),
20554 CollectionElement(CollectionElement<'tree>),
20555 CollectionExpression(CollectionExpression<'tree>),
20556 CompilationUnit(CompilationUnit<'tree>),
20557 ConditionalAccessExpression(ConditionalAccessExpression<'tree>),
20558 ConditionalExpression(ConditionalExpression<'tree>),
20559 ConstantPattern(ConstantPattern<'tree>),
20560 ConstructorConstraint(ConstructorConstraint<'tree>),
20561 ConstructorDeclaration(ConstructorDeclaration<'tree>),
20562 ConstructorInitializer(ConstructorInitializer<'tree>),
20563 ContinueStatement(ContinueStatement<'tree>),
20564 ConversionOperatorDeclaration(ConversionOperatorDeclaration<'tree>),
20565 DeclarationExpression(DeclarationExpression<'tree>),
20566 DeclarationList(DeclarationList<'tree>),
20567 DeclarationPattern(DeclarationPattern<'tree>),
20568 DefaultExpression(DefaultExpression<'tree>),
20569 DelegateDeclaration(DelegateDeclaration<'tree>),
20570 DestructorDeclaration(DestructorDeclaration<'tree>),
20571 DoStatement(DoStatement<'tree>),
20572 ElementAccessExpression(ElementAccessExpression<'tree>),
20573 ElementBindingExpression(ElementBindingExpression<'tree>),
20574 EmptyStatement(EmptyStatement<'tree>),
20575 EnumDeclaration(EnumDeclaration<'tree>),
20576 EnumMemberDeclaration(EnumMemberDeclaration<'tree>),
20577 EnumMemberDeclarationList(EnumMemberDeclarationList<'tree>),
20578 EventDeclaration(EventDeclaration<'tree>),
20579 EventFieldDeclaration(EventFieldDeclaration<'tree>),
20580 ExplicitInterfaceSpecifier(ExplicitInterfaceSpecifier<'tree>),
20581 ExpressionElement(ExpressionElement<'tree>),
20582 ExpressionStatement(ExpressionStatement<'tree>),
20583 ExternAliasDirective(ExternAliasDirective<'tree>),
20584 FieldDeclaration(FieldDeclaration<'tree>),
20585 FileScopedNamespaceDeclaration(FileScopedNamespaceDeclaration<'tree>),
20586 FinallyClause(FinallyClause<'tree>),
20587 FixedStatement(FixedStatement<'tree>),
20588 ForStatement(ForStatement<'tree>),
20589 ForeachStatement(ForeachStatement<'tree>),
20590 FromClause(FromClause<'tree>),
20591 FunctionPointerParameter(FunctionPointerParameter<'tree>),
20592 FunctionPointerType(FunctionPointerType<'tree>),
20593 GenericName(GenericName<'tree>),
20594 GlobalAttribute(GlobalAttribute<'tree>),
20595 GlobalStatement(GlobalStatement<'tree>),
20596 GotoStatement(GotoStatement<'tree>),
20597 GroupClause(GroupClause<'tree>),
20598 Identifier(Identifier<'tree>),
20599 IfStatement(IfStatement<'tree>),
20600 ImplicitArrayCreationExpression(ImplicitArrayCreationExpression<'tree>),
20601 ImplicitObjectCreationExpression(ImplicitObjectCreationExpression<'tree>),
20602 ImplicitParameter(ImplicitParameter<'tree>),
20603 ImplicitStackallocExpression(ImplicitStackallocExpression<'tree>),
20604 ImplicitType(ImplicitType<'tree>),
20605 IndexerDeclaration(IndexerDeclaration<'tree>),
20606 InitializerExpression(InitializerExpression<'tree>),
20607 InterfaceDeclaration(InterfaceDeclaration<'tree>),
20608 InterpolatedStringExpression(InterpolatedStringExpression<'tree>),
20609 Interpolation(Interpolation<'tree>),
20610 InterpolationAlignmentClause(InterpolationAlignmentClause<'tree>),
20611 InterpolationFormatClause(InterpolationFormatClause<'tree>),
20612 InvocationExpression(InvocationExpression<'tree>),
20613 IsExpression(IsExpression<'tree>),
20614 IsPatternExpression(IsPatternExpression<'tree>),
20615 JoinClause(JoinClause<'tree>),
20616 JoinIntoClause(JoinIntoClause<'tree>),
20617 LabeledStatement(LabeledStatement<'tree>),
20618 LambdaExpression(LambdaExpression<'tree>),
20619 LetClause(LetClause<'tree>),
20620 ListPattern(ListPattern<'tree>),
20621 LocalDeclarationStatement(LocalDeclarationStatement<'tree>),
20622 LocalFunctionStatement(LocalFunctionStatement<'tree>),
20623 LockStatement(LockStatement<'tree>),
20624 MakerefExpression(MakerefExpression<'tree>),
20625 MemberAccessExpression(MemberAccessExpression<'tree>),
20626 MemberBindingExpression(MemberBindingExpression<'tree>),
20627 MethodDeclaration(MethodDeclaration<'tree>),
20628 Modifier(Modifier<'tree>),
20629 NamespaceDeclaration(NamespaceDeclaration<'tree>),
20630 NegatedPattern(NegatedPattern<'tree>),
20631 NullableType(NullableType<'tree>),
20632 ObjectCreationExpression(ObjectCreationExpression<'tree>),
20633 OperatorDeclaration(OperatorDeclaration<'tree>),
20634 OrPattern(OrPattern<'tree>),
20635 OrderByClause(OrderByClause<'tree>),
20636 Parameter(Parameter<'tree>),
20637 ParameterList(ParameterList<'tree>),
20638 ParenthesizedExpression(ParenthesizedExpression<'tree>),
20639 ParenthesizedPattern(ParenthesizedPattern<'tree>),
20640 ParenthesizedVariableDesignation(ParenthesizedVariableDesignation<'tree>),
20641 PointerType(PointerType<'tree>),
20642 PositionalPatternClause(PositionalPatternClause<'tree>),
20643 PostfixUnaryExpression(PostfixUnaryExpression<'tree>),
20644 PrefixUnaryExpression(PrefixUnaryExpression<'tree>),
20645 PreprocDefine(PreprocDefine<'tree>),
20646 PreprocElif(PreprocElif<'tree>),
20647 PreprocElse(PreprocElse<'tree>),
20648 PreprocEndregion(PreprocEndregion<'tree>),
20649 PreprocError(PreprocError<'tree>),
20650 PreprocIf(PreprocIf<'tree>),
20651 PreprocIfInAttributeList(PreprocIfInAttributeList<'tree>),
20652 PreprocLine(PreprocLine<'tree>),
20653 PreprocNullable(PreprocNullable<'tree>),
20654 PreprocPragma(PreprocPragma<'tree>),
20655 PreprocRegion(PreprocRegion<'tree>),
20656 PreprocUndef(PreprocUndef<'tree>),
20657 PreprocWarning(PreprocWarning<'tree>),
20658 PrimaryConstructorBaseType(PrimaryConstructorBaseType<'tree>),
20659 PropertyDeclaration(PropertyDeclaration<'tree>),
20660 PropertyPatternClause(PropertyPatternClause<'tree>),
20661 QualifiedName(QualifiedName<'tree>),
20662 QueryExpression(QueryExpression<'tree>),
20663 RangeExpression(RangeExpression<'tree>),
20664 RawStringLiteral(RawStringLiteral<'tree>),
20665 RecordDeclaration(RecordDeclaration<'tree>),
20666 RecursivePattern(RecursivePattern<'tree>),
20667 RefExpression(RefExpression<'tree>),
20668 RefType(RefType<'tree>),
20669 ReftypeExpression(ReftypeExpression<'tree>),
20670 RefvalueExpression(RefvalueExpression<'tree>),
20671 RelationalPattern(RelationalPattern<'tree>),
20672 ReturnStatement(ReturnStatement<'tree>),
20673 ScopedType(ScopedType<'tree>),
20674 SelectClause(SelectClause<'tree>),
20675 SizeofExpression(SizeofExpression<'tree>),
20676 SpreadElement(SpreadElement<'tree>),
20677 StackallocExpression(StackallocExpression<'tree>),
20678 StringLiteral(StringLiteral<'tree>),
20679 StructDeclaration(StructDeclaration<'tree>),
20680 Subpattern(Subpattern<'tree>),
20681 SwitchBody(SwitchBody<'tree>),
20682 SwitchExpression(SwitchExpression<'tree>),
20683 SwitchExpressionArm(SwitchExpressionArm<'tree>),
20684 SwitchSection(SwitchSection<'tree>),
20685 SwitchStatement(SwitchStatement<'tree>),
20686 ThrowExpression(ThrowExpression<'tree>),
20687 ThrowStatement(ThrowStatement<'tree>),
20688 TryStatement(TryStatement<'tree>),
20689 TupleElement(TupleElement<'tree>),
20690 TupleExpression(TupleExpression<'tree>),
20691 TuplePattern(TuplePattern<'tree>),
20692 TupleType(TupleType<'tree>),
20693 TypeArgumentList(TypeArgumentList<'tree>),
20694 TypeParameter(TypeParameter<'tree>),
20695 TypeParameterConstraint(TypeParameterConstraint<'tree>),
20696 TypeParameterConstraintsClause(TypeParameterConstraintsClause<'tree>),
20697 TypeParameterList(TypeParameterList<'tree>),
20698 TypePattern(TypePattern<'tree>),
20699 TypeofExpression(TypeofExpression<'tree>),
20700 UnaryExpression(UnaryExpression<'tree>),
20701 UnsafeStatement(UnsafeStatement<'tree>),
20702 UsingDirective(UsingDirective<'tree>),
20703 UsingStatement(UsingStatement<'tree>),
20704 VarPattern(VarPattern<'tree>),
20705 VariableDeclaration(VariableDeclaration<'tree>),
20706 VariableDeclarator(VariableDeclarator<'tree>),
20707 WhenClause(WhenClause<'tree>),
20708 WhereClause(WhereClause<'tree>),
20709 WhileStatement(WhileStatement<'tree>),
20710 WithExpression(WithExpression<'tree>),
20711 WithInitializer(WithInitializer<'tree>),
20712 YieldStatement(YieldStatement<'tree>),
20713 CharacterLiteralContent(CharacterLiteralContent<'tree>),
20714 Comment(Comment<'tree>),
20715 Discard(Discard<'tree>),
20716 EscapeSequence(EscapeSequence<'tree>),
20717 IntegerLiteral(IntegerLiteral<'tree>),
20718 InterpolationBrace(InterpolationBrace<'tree>),
20719 InterpolationQuote(InterpolationQuote<'tree>),
20720 InterpolationStart(InterpolationStart<'tree>),
20721 NullLiteral(NullLiteral<'tree>),
20722 PredefinedType(PredefinedType<'tree>),
20723 PreprocArg(PreprocArg<'tree>),
20724 RawStringContent(RawStringContent<'tree>),
20725 RawStringEnd(RawStringEnd<'tree>),
20726 RawStringStart(RawStringStart<'tree>),
20727 RealLiteral(RealLiteral<'tree>),
20728 ShebangDirective(ShebangDirective<'tree>),
20729 StringContent(StringContent<'tree>),
20730 StringLiteralContent(StringLiteralContent<'tree>),
20731 StringLiteralEncoding(StringLiteralEncoding<'tree>),
20732 VerbatimStringLiteral(VerbatimStringLiteral<'tree>),
20733 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
20734}
20735impl<'tree> AnyNode<'tree> {
20736 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
20737 match node.kind() {
20738 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20739 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
20740 })
20741 .map(Self::Declaration)
20742 .unwrap_or(Self::Unknown(node)),
20743 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20744 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20745 })
20746 .map(Self::Expression)
20747 .unwrap_or(Self::Unknown(node)),
20748 "literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20749 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
20750 })
20751 .map(Self::Literal)
20752 .unwrap_or(Self::Unknown(node)),
20753 "lvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20754 <LvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
20755 })
20756 .map(Self::LvalueExpression)
20757 .unwrap_or(Self::Unknown(node)),
20758 "non_lvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20759 <NonLvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
20760 })
20761 .map(Self::NonLvalueExpression)
20762 .unwrap_or(Self::Unknown(node)),
20763 "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20764 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
20765 })
20766 .map(Self::Pattern)
20767 .unwrap_or(Self::Unknown(node)),
20768 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20769 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
20770 })
20771 .map(Self::Statement)
20772 .unwrap_or(Self::Unknown(node)),
20773 "type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20774 <Type as ::treesitter_types::FromNode>::from_node(node, src)
20775 })
20776 .map(Self::Type)
20777 .unwrap_or(Self::Unknown(node)),
20778 "type_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20779 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20780 })
20781 .map(Self::TypeDeclaration)
20782 .unwrap_or(Self::Unknown(node)),
20783 "accessor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20784 <AccessorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20785 })
20786 .map(Self::AccessorDeclaration)
20787 .unwrap_or(Self::Unknown(node)),
20788 "accessor_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20789 <AccessorList as ::treesitter_types::FromNode>::from_node(node, src)
20790 })
20791 .map(Self::AccessorList)
20792 .unwrap_or(Self::Unknown(node)),
20793 "alias_qualified_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20794 <AliasQualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
20795 })
20796 .map(Self::AliasQualifiedName)
20797 .unwrap_or(Self::Unknown(node)),
20798 "and_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20799 <AndPattern as ::treesitter_types::FromNode>::from_node(node, src)
20800 })
20801 .map(Self::AndPattern)
20802 .unwrap_or(Self::Unknown(node)),
20803 "anonymous_method_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20804 <AnonymousMethodExpression as ::treesitter_types::FromNode>::from_node(node, src)
20805 })
20806 .map(Self::AnonymousMethodExpression)
20807 .unwrap_or(Self::Unknown(node)),
20808 "anonymous_object_creation_expression" => {
20809 ::treesitter_types::runtime::maybe_grow_stack(|| {
20810 <AnonymousObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
20811 node, src,
20812 )
20813 })
20814 .map(Self::AnonymousObjectCreationExpression)
20815 .unwrap_or(Self::Unknown(node))
20816 }
20817 "argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20818 <Argument as ::treesitter_types::FromNode>::from_node(node, src)
20819 })
20820 .map(Self::Argument)
20821 .unwrap_or(Self::Unknown(node)),
20822 "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20823 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20824 })
20825 .map(Self::ArgumentList)
20826 .unwrap_or(Self::Unknown(node)),
20827 "array_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20828 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
20829 })
20830 .map(Self::ArrayCreationExpression)
20831 .unwrap_or(Self::Unknown(node)),
20832 "array_rank_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20833 <ArrayRankSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20834 })
20835 .map(Self::ArrayRankSpecifier)
20836 .unwrap_or(Self::Unknown(node)),
20837 "array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20838 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
20839 })
20840 .map(Self::ArrayType)
20841 .unwrap_or(Self::Unknown(node)),
20842 "arrow_expression_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20843 <ArrowExpressionClause as ::treesitter_types::FromNode>::from_node(node, src)
20844 })
20845 .map(Self::ArrowExpressionClause)
20846 .unwrap_or(Self::Unknown(node)),
20847 "as_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20848 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
20849 })
20850 .map(Self::AsExpression)
20851 .unwrap_or(Self::Unknown(node)),
20852 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20853 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
20854 })
20855 .map(Self::AssignmentExpression)
20856 .unwrap_or(Self::Unknown(node)),
20857 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20858 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
20859 })
20860 .map(Self::Attribute)
20861 .unwrap_or(Self::Unknown(node)),
20862 "attribute_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20863 <AttributeArgument as ::treesitter_types::FromNode>::from_node(node, src)
20864 })
20865 .map(Self::AttributeArgument)
20866 .unwrap_or(Self::Unknown(node)),
20867 "attribute_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20868 <AttributeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20869 })
20870 .map(Self::AttributeArgumentList)
20871 .unwrap_or(Self::Unknown(node)),
20872 "attribute_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20873 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
20874 })
20875 .map(Self::AttributeList)
20876 .unwrap_or(Self::Unknown(node)),
20877 "attribute_target_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20878 <AttributeTargetSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20879 })
20880 .map(Self::AttributeTargetSpecifier)
20881 .unwrap_or(Self::Unknown(node)),
20882 "await_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20883 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
20884 })
20885 .map(Self::AwaitExpression)
20886 .unwrap_or(Self::Unknown(node)),
20887 "base_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20888 <BaseList as ::treesitter_types::FromNode>::from_node(node, src)
20889 })
20890 .map(Self::BaseList)
20891 .unwrap_or(Self::Unknown(node)),
20892 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20893 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20894 })
20895 .map(Self::BinaryExpression)
20896 .unwrap_or(Self::Unknown(node)),
20897 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20898 <Block as ::treesitter_types::FromNode>::from_node(node, src)
20899 })
20900 .map(Self::Block)
20901 .unwrap_or(Self::Unknown(node)),
20902 "boolean_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20903 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20904 })
20905 .map(Self::BooleanLiteral)
20906 .unwrap_or(Self::Unknown(node)),
20907 "bracketed_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20908 <BracketedArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20909 })
20910 .map(Self::BracketedArgumentList)
20911 .unwrap_or(Self::Unknown(node)),
20912 "bracketed_parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20913 <BracketedParameterList as ::treesitter_types::FromNode>::from_node(node, src)
20914 })
20915 .map(Self::BracketedParameterList)
20916 .unwrap_or(Self::Unknown(node)),
20917 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20918 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
20919 })
20920 .map(Self::BreakStatement)
20921 .unwrap_or(Self::Unknown(node)),
20922 "calling_convention" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20923 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
20924 })
20925 .map(Self::CallingConvention)
20926 .unwrap_or(Self::Unknown(node)),
20927 "cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20928 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
20929 })
20930 .map(Self::CastExpression)
20931 .unwrap_or(Self::Unknown(node)),
20932 "catch_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20933 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
20934 })
20935 .map(Self::CatchClause)
20936 .unwrap_or(Self::Unknown(node)),
20937 "catch_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20938 <CatchDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20939 })
20940 .map(Self::CatchDeclaration)
20941 .unwrap_or(Self::Unknown(node)),
20942 "catch_filter_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20943 <CatchFilterClause as ::treesitter_types::FromNode>::from_node(node, src)
20944 })
20945 .map(Self::CatchFilterClause)
20946 .unwrap_or(Self::Unknown(node)),
20947 "character_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20948 <CharacterLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20949 })
20950 .map(Self::CharacterLiteral)
20951 .unwrap_or(Self::Unknown(node)),
20952 "checked_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20953 <CheckedExpression as ::treesitter_types::FromNode>::from_node(node, src)
20954 })
20955 .map(Self::CheckedExpression)
20956 .unwrap_or(Self::Unknown(node)),
20957 "checked_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20958 <CheckedStatement as ::treesitter_types::FromNode>::from_node(node, src)
20959 })
20960 .map(Self::CheckedStatement)
20961 .unwrap_or(Self::Unknown(node)),
20962 "class_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20963 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20964 })
20965 .map(Self::ClassDeclaration)
20966 .unwrap_or(Self::Unknown(node)),
20967 "collection_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20968 <CollectionElement as ::treesitter_types::FromNode>::from_node(node, src)
20969 })
20970 .map(Self::CollectionElement)
20971 .unwrap_or(Self::Unknown(node)),
20972 "collection_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20973 <CollectionExpression as ::treesitter_types::FromNode>::from_node(node, src)
20974 })
20975 .map(Self::CollectionExpression)
20976 .unwrap_or(Self::Unknown(node)),
20977 "compilation_unit" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20978 <CompilationUnit as ::treesitter_types::FromNode>::from_node(node, src)
20979 })
20980 .map(Self::CompilationUnit)
20981 .unwrap_or(Self::Unknown(node)),
20982 "conditional_access_expression" => {
20983 ::treesitter_types::runtime::maybe_grow_stack(|| {
20984 <ConditionalAccessExpression as ::treesitter_types::FromNode>::from_node(
20985 node, src,
20986 )
20987 })
20988 .map(Self::ConditionalAccessExpression)
20989 .unwrap_or(Self::Unknown(node))
20990 }
20991 "conditional_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20992 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
20993 })
20994 .map(Self::ConditionalExpression)
20995 .unwrap_or(Self::Unknown(node)),
20996 "constant_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
20997 <ConstantPattern as ::treesitter_types::FromNode>::from_node(node, src)
20998 })
20999 .map(Self::ConstantPattern)
21000 .unwrap_or(Self::Unknown(node)),
21001 "constructor_constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21002 <ConstructorConstraint as ::treesitter_types::FromNode>::from_node(node, src)
21003 })
21004 .map(Self::ConstructorConstraint)
21005 .unwrap_or(Self::Unknown(node)),
21006 "constructor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21007 <ConstructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21008 })
21009 .map(Self::ConstructorDeclaration)
21010 .unwrap_or(Self::Unknown(node)),
21011 "constructor_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21012 <ConstructorInitializer as ::treesitter_types::FromNode>::from_node(node, src)
21013 })
21014 .map(Self::ConstructorInitializer)
21015 .unwrap_or(Self::Unknown(node)),
21016 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21017 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
21018 })
21019 .map(Self::ContinueStatement)
21020 .unwrap_or(Self::Unknown(node)),
21021 "conversion_operator_declaration" => {
21022 ::treesitter_types::runtime::maybe_grow_stack(|| {
21023 <ConversionOperatorDeclaration as ::treesitter_types::FromNode>::from_node(
21024 node, src,
21025 )
21026 })
21027 .map(Self::ConversionOperatorDeclaration)
21028 .unwrap_or(Self::Unknown(node))
21029 }
21030 "declaration_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21031 <DeclarationExpression as ::treesitter_types::FromNode>::from_node(node, src)
21032 })
21033 .map(Self::DeclarationExpression)
21034 .unwrap_or(Self::Unknown(node)),
21035 "declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21036 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
21037 })
21038 .map(Self::DeclarationList)
21039 .unwrap_or(Self::Unknown(node)),
21040 "declaration_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21041 <DeclarationPattern as ::treesitter_types::FromNode>::from_node(node, src)
21042 })
21043 .map(Self::DeclarationPattern)
21044 .unwrap_or(Self::Unknown(node)),
21045 "default_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21046 <DefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
21047 })
21048 .map(Self::DefaultExpression)
21049 .unwrap_or(Self::Unknown(node)),
21050 "delegate_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21051 <DelegateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21052 })
21053 .map(Self::DelegateDeclaration)
21054 .unwrap_or(Self::Unknown(node)),
21055 "destructor_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21056 <DestructorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21057 })
21058 .map(Self::DestructorDeclaration)
21059 .unwrap_or(Self::Unknown(node)),
21060 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21061 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
21062 })
21063 .map(Self::DoStatement)
21064 .unwrap_or(Self::Unknown(node)),
21065 "element_access_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21066 <ElementAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
21067 })
21068 .map(Self::ElementAccessExpression)
21069 .unwrap_or(Self::Unknown(node)),
21070 "element_binding_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21071 <ElementBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
21072 })
21073 .map(Self::ElementBindingExpression)
21074 .unwrap_or(Self::Unknown(node)),
21075 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21076 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
21077 })
21078 .map(Self::EmptyStatement)
21079 .unwrap_or(Self::Unknown(node)),
21080 "enum_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21081 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21082 })
21083 .map(Self::EnumDeclaration)
21084 .unwrap_or(Self::Unknown(node)),
21085 "enum_member_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21086 <EnumMemberDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21087 })
21088 .map(Self::EnumMemberDeclaration)
21089 .unwrap_or(Self::Unknown(node)),
21090 "enum_member_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21091 <EnumMemberDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
21092 })
21093 .map(Self::EnumMemberDeclarationList)
21094 .unwrap_or(Self::Unknown(node)),
21095 "event_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21096 <EventDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21097 })
21098 .map(Self::EventDeclaration)
21099 .unwrap_or(Self::Unknown(node)),
21100 "event_field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21101 <EventFieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21102 })
21103 .map(Self::EventFieldDeclaration)
21104 .unwrap_or(Self::Unknown(node)),
21105 "explicit_interface_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21106 <ExplicitInterfaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
21107 })
21108 .map(Self::ExplicitInterfaceSpecifier)
21109 .unwrap_or(Self::Unknown(node)),
21110 "expression_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21111 <ExpressionElement as ::treesitter_types::FromNode>::from_node(node, src)
21112 })
21113 .map(Self::ExpressionElement)
21114 .unwrap_or(Self::Unknown(node)),
21115 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21116 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
21117 })
21118 .map(Self::ExpressionStatement)
21119 .unwrap_or(Self::Unknown(node)),
21120 "extern_alias_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21121 <ExternAliasDirective as ::treesitter_types::FromNode>::from_node(node, src)
21122 })
21123 .map(Self::ExternAliasDirective)
21124 .unwrap_or(Self::Unknown(node)),
21125 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21126 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21127 })
21128 .map(Self::FieldDeclaration)
21129 .unwrap_or(Self::Unknown(node)),
21130 "file_scoped_namespace_declaration" => {
21131 ::treesitter_types::runtime::maybe_grow_stack(|| {
21132 <FileScopedNamespaceDeclaration as ::treesitter_types::FromNode>::from_node(
21133 node, src,
21134 )
21135 })
21136 .map(Self::FileScopedNamespaceDeclaration)
21137 .unwrap_or(Self::Unknown(node))
21138 }
21139 "finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21140 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
21141 })
21142 .map(Self::FinallyClause)
21143 .unwrap_or(Self::Unknown(node)),
21144 "fixed_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21145 <FixedStatement as ::treesitter_types::FromNode>::from_node(node, src)
21146 })
21147 .map(Self::FixedStatement)
21148 .unwrap_or(Self::Unknown(node)),
21149 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21150 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
21151 })
21152 .map(Self::ForStatement)
21153 .unwrap_or(Self::Unknown(node)),
21154 "foreach_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21155 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
21156 })
21157 .map(Self::ForeachStatement)
21158 .unwrap_or(Self::Unknown(node)),
21159 "from_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21160 <FromClause as ::treesitter_types::FromNode>::from_node(node, src)
21161 })
21162 .map(Self::FromClause)
21163 .unwrap_or(Self::Unknown(node)),
21164 "function_pointer_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21165 <FunctionPointerParameter as ::treesitter_types::FromNode>::from_node(node, src)
21166 })
21167 .map(Self::FunctionPointerParameter)
21168 .unwrap_or(Self::Unknown(node)),
21169 "function_pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21170 <FunctionPointerType as ::treesitter_types::FromNode>::from_node(node, src)
21171 })
21172 .map(Self::FunctionPointerType)
21173 .unwrap_or(Self::Unknown(node)),
21174 "generic_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21175 <GenericName as ::treesitter_types::FromNode>::from_node(node, src)
21176 })
21177 .map(Self::GenericName)
21178 .unwrap_or(Self::Unknown(node)),
21179 "global_attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21180 <GlobalAttribute as ::treesitter_types::FromNode>::from_node(node, src)
21181 })
21182 .map(Self::GlobalAttribute)
21183 .unwrap_or(Self::Unknown(node)),
21184 "global_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21185 <GlobalStatement as ::treesitter_types::FromNode>::from_node(node, src)
21186 })
21187 .map(Self::GlobalStatement)
21188 .unwrap_or(Self::Unknown(node)),
21189 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21190 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
21191 })
21192 .map(Self::GotoStatement)
21193 .unwrap_or(Self::Unknown(node)),
21194 "group_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21195 <GroupClause as ::treesitter_types::FromNode>::from_node(node, src)
21196 })
21197 .map(Self::GroupClause)
21198 .unwrap_or(Self::Unknown(node)),
21199 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21200 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
21201 })
21202 .map(Self::Identifier)
21203 .unwrap_or(Self::Unknown(node)),
21204 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21205 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
21206 })
21207 .map(Self::IfStatement)
21208 .unwrap_or(Self::Unknown(node)),
21209 "implicit_array_creation_expression" => {
21210 ::treesitter_types::runtime::maybe_grow_stack(|| {
21211 <ImplicitArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
21212 node, src,
21213 )
21214 })
21215 .map(Self::ImplicitArrayCreationExpression)
21216 .unwrap_or(Self::Unknown(node))
21217 }
21218 "implicit_object_creation_expression" => {
21219 ::treesitter_types::runtime::maybe_grow_stack(|| {
21220 <ImplicitObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
21221 node, src,
21222 )
21223 })
21224 .map(Self::ImplicitObjectCreationExpression)
21225 .unwrap_or(Self::Unknown(node))
21226 }
21227 "implicit_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21228 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
21229 })
21230 .map(Self::ImplicitParameter)
21231 .unwrap_or(Self::Unknown(node)),
21232 "implicit_stackalloc_expression" => {
21233 ::treesitter_types::runtime::maybe_grow_stack(|| {
21234 <ImplicitStackallocExpression as ::treesitter_types::FromNode>::from_node(
21235 node, src,
21236 )
21237 })
21238 .map(Self::ImplicitStackallocExpression)
21239 .unwrap_or(Self::Unknown(node))
21240 }
21241 "implicit_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21242 <ImplicitType as ::treesitter_types::FromNode>::from_node(node, src)
21243 })
21244 .map(Self::ImplicitType)
21245 .unwrap_or(Self::Unknown(node)),
21246 "indexer_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21247 <IndexerDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21248 })
21249 .map(Self::IndexerDeclaration)
21250 .unwrap_or(Self::Unknown(node)),
21251 "initializer_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21252 <InitializerExpression as ::treesitter_types::FromNode>::from_node(node, src)
21253 })
21254 .map(Self::InitializerExpression)
21255 .unwrap_or(Self::Unknown(node)),
21256 "interface_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21257 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21258 })
21259 .map(Self::InterfaceDeclaration)
21260 .unwrap_or(Self::Unknown(node)),
21261 "interpolated_string_expression" => {
21262 ::treesitter_types::runtime::maybe_grow_stack(|| {
21263 <InterpolatedStringExpression as ::treesitter_types::FromNode>::from_node(
21264 node, src,
21265 )
21266 })
21267 .map(Self::InterpolatedStringExpression)
21268 .unwrap_or(Self::Unknown(node))
21269 }
21270 "interpolation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21271 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
21272 })
21273 .map(Self::Interpolation)
21274 .unwrap_or(Self::Unknown(node)),
21275 "interpolation_alignment_clause" => {
21276 ::treesitter_types::runtime::maybe_grow_stack(|| {
21277 <InterpolationAlignmentClause as ::treesitter_types::FromNode>::from_node(
21278 node, src,
21279 )
21280 })
21281 .map(Self::InterpolationAlignmentClause)
21282 .unwrap_or(Self::Unknown(node))
21283 }
21284 "interpolation_format_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21285 <InterpolationFormatClause as ::treesitter_types::FromNode>::from_node(node, src)
21286 })
21287 .map(Self::InterpolationFormatClause)
21288 .unwrap_or(Self::Unknown(node)),
21289 "invocation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21290 <InvocationExpression as ::treesitter_types::FromNode>::from_node(node, src)
21291 })
21292 .map(Self::InvocationExpression)
21293 .unwrap_or(Self::Unknown(node)),
21294 "is_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21295 <IsExpression as ::treesitter_types::FromNode>::from_node(node, src)
21296 })
21297 .map(Self::IsExpression)
21298 .unwrap_or(Self::Unknown(node)),
21299 "is_pattern_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21300 <IsPatternExpression as ::treesitter_types::FromNode>::from_node(node, src)
21301 })
21302 .map(Self::IsPatternExpression)
21303 .unwrap_or(Self::Unknown(node)),
21304 "join_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21305 <JoinClause as ::treesitter_types::FromNode>::from_node(node, src)
21306 })
21307 .map(Self::JoinClause)
21308 .unwrap_or(Self::Unknown(node)),
21309 "join_into_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21310 <JoinIntoClause as ::treesitter_types::FromNode>::from_node(node, src)
21311 })
21312 .map(Self::JoinIntoClause)
21313 .unwrap_or(Self::Unknown(node)),
21314 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21315 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
21316 })
21317 .map(Self::LabeledStatement)
21318 .unwrap_or(Self::Unknown(node)),
21319 "lambda_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21320 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
21321 })
21322 .map(Self::LambdaExpression)
21323 .unwrap_or(Self::Unknown(node)),
21324 "let_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21325 <LetClause as ::treesitter_types::FromNode>::from_node(node, src)
21326 })
21327 .map(Self::LetClause)
21328 .unwrap_or(Self::Unknown(node)),
21329 "list_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21330 <ListPattern as ::treesitter_types::FromNode>::from_node(node, src)
21331 })
21332 .map(Self::ListPattern)
21333 .unwrap_or(Self::Unknown(node)),
21334 "local_declaration_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21335 <LocalDeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
21336 })
21337 .map(Self::LocalDeclarationStatement)
21338 .unwrap_or(Self::Unknown(node)),
21339 "local_function_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21340 <LocalFunctionStatement as ::treesitter_types::FromNode>::from_node(node, src)
21341 })
21342 .map(Self::LocalFunctionStatement)
21343 .unwrap_or(Self::Unknown(node)),
21344 "lock_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21345 <LockStatement as ::treesitter_types::FromNode>::from_node(node, src)
21346 })
21347 .map(Self::LockStatement)
21348 .unwrap_or(Self::Unknown(node)),
21349 "makeref_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21350 <MakerefExpression as ::treesitter_types::FromNode>::from_node(node, src)
21351 })
21352 .map(Self::MakerefExpression)
21353 .unwrap_or(Self::Unknown(node)),
21354 "member_access_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21355 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
21356 })
21357 .map(Self::MemberAccessExpression)
21358 .unwrap_or(Self::Unknown(node)),
21359 "member_binding_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21360 <MemberBindingExpression as ::treesitter_types::FromNode>::from_node(node, src)
21361 })
21362 .map(Self::MemberBindingExpression)
21363 .unwrap_or(Self::Unknown(node)),
21364 "method_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21365 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21366 })
21367 .map(Self::MethodDeclaration)
21368 .unwrap_or(Self::Unknown(node)),
21369 "modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21370 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
21371 })
21372 .map(Self::Modifier)
21373 .unwrap_or(Self::Unknown(node)),
21374 "namespace_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21375 <NamespaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21376 })
21377 .map(Self::NamespaceDeclaration)
21378 .unwrap_or(Self::Unknown(node)),
21379 "negated_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21380 <NegatedPattern as ::treesitter_types::FromNode>::from_node(node, src)
21381 })
21382 .map(Self::NegatedPattern)
21383 .unwrap_or(Self::Unknown(node)),
21384 "nullable_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21385 <NullableType as ::treesitter_types::FromNode>::from_node(node, src)
21386 })
21387 .map(Self::NullableType)
21388 .unwrap_or(Self::Unknown(node)),
21389 "object_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21390 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
21391 })
21392 .map(Self::ObjectCreationExpression)
21393 .unwrap_or(Self::Unknown(node)),
21394 "operator_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21395 <OperatorDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21396 })
21397 .map(Self::OperatorDeclaration)
21398 .unwrap_or(Self::Unknown(node)),
21399 "or_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21400 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
21401 })
21402 .map(Self::OrPattern)
21403 .unwrap_or(Self::Unknown(node)),
21404 "order_by_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21405 <OrderByClause as ::treesitter_types::FromNode>::from_node(node, src)
21406 })
21407 .map(Self::OrderByClause)
21408 .unwrap_or(Self::Unknown(node)),
21409 "parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21410 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
21411 })
21412 .map(Self::Parameter)
21413 .unwrap_or(Self::Unknown(node)),
21414 "parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21415 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
21416 })
21417 .map(Self::ParameterList)
21418 .unwrap_or(Self::Unknown(node)),
21419 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21420 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
21421 })
21422 .map(Self::ParenthesizedExpression)
21423 .unwrap_or(Self::Unknown(node)),
21424 "parenthesized_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21425 <ParenthesizedPattern as ::treesitter_types::FromNode>::from_node(node, src)
21426 })
21427 .map(Self::ParenthesizedPattern)
21428 .unwrap_or(Self::Unknown(node)),
21429 "parenthesized_variable_designation" => {
21430 ::treesitter_types::runtime::maybe_grow_stack(|| {
21431 <ParenthesizedVariableDesignation as ::treesitter_types::FromNode>::from_node(
21432 node, src,
21433 )
21434 })
21435 .map(Self::ParenthesizedVariableDesignation)
21436 .unwrap_or(Self::Unknown(node))
21437 }
21438 "pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21439 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
21440 })
21441 .map(Self::PointerType)
21442 .unwrap_or(Self::Unknown(node)),
21443 "positional_pattern_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21444 <PositionalPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
21445 })
21446 .map(Self::PositionalPatternClause)
21447 .unwrap_or(Self::Unknown(node)),
21448 "postfix_unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21449 <PostfixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
21450 })
21451 .map(Self::PostfixUnaryExpression)
21452 .unwrap_or(Self::Unknown(node)),
21453 "prefix_unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21454 <PrefixUnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
21455 })
21456 .map(Self::PrefixUnaryExpression)
21457 .unwrap_or(Self::Unknown(node)),
21458 "preproc_define" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21459 <PreprocDefine as ::treesitter_types::FromNode>::from_node(node, src)
21460 })
21461 .map(Self::PreprocDefine)
21462 .unwrap_or(Self::Unknown(node)),
21463 "preproc_elif" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21464 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
21465 })
21466 .map(Self::PreprocElif)
21467 .unwrap_or(Self::Unknown(node)),
21468 "preproc_else" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21469 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
21470 })
21471 .map(Self::PreprocElse)
21472 .unwrap_or(Self::Unknown(node)),
21473 "preproc_endregion" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21474 <PreprocEndregion as ::treesitter_types::FromNode>::from_node(node, src)
21475 })
21476 .map(Self::PreprocEndregion)
21477 .unwrap_or(Self::Unknown(node)),
21478 "preproc_error" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21479 <PreprocError as ::treesitter_types::FromNode>::from_node(node, src)
21480 })
21481 .map(Self::PreprocError)
21482 .unwrap_or(Self::Unknown(node)),
21483 "preproc_if" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21484 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
21485 })
21486 .map(Self::PreprocIf)
21487 .unwrap_or(Self::Unknown(node)),
21488 "preproc_if_in_attribute_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21489 <PreprocIfInAttributeList as ::treesitter_types::FromNode>::from_node(node, src)
21490 })
21491 .map(Self::PreprocIfInAttributeList)
21492 .unwrap_or(Self::Unknown(node)),
21493 "preproc_line" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21494 <PreprocLine as ::treesitter_types::FromNode>::from_node(node, src)
21495 })
21496 .map(Self::PreprocLine)
21497 .unwrap_or(Self::Unknown(node)),
21498 "preproc_nullable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21499 <PreprocNullable as ::treesitter_types::FromNode>::from_node(node, src)
21500 })
21501 .map(Self::PreprocNullable)
21502 .unwrap_or(Self::Unknown(node)),
21503 "preproc_pragma" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21504 <PreprocPragma as ::treesitter_types::FromNode>::from_node(node, src)
21505 })
21506 .map(Self::PreprocPragma)
21507 .unwrap_or(Self::Unknown(node)),
21508 "preproc_region" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21509 <PreprocRegion as ::treesitter_types::FromNode>::from_node(node, src)
21510 })
21511 .map(Self::PreprocRegion)
21512 .unwrap_or(Self::Unknown(node)),
21513 "preproc_undef" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21514 <PreprocUndef as ::treesitter_types::FromNode>::from_node(node, src)
21515 })
21516 .map(Self::PreprocUndef)
21517 .unwrap_or(Self::Unknown(node)),
21518 "preproc_warning" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21519 <PreprocWarning as ::treesitter_types::FromNode>::from_node(node, src)
21520 })
21521 .map(Self::PreprocWarning)
21522 .unwrap_or(Self::Unknown(node)),
21523 "primary_constructor_base_type" => {
21524 ::treesitter_types::runtime::maybe_grow_stack(|| {
21525 <PrimaryConstructorBaseType as ::treesitter_types::FromNode>::from_node(
21526 node, src,
21527 )
21528 })
21529 .map(Self::PrimaryConstructorBaseType)
21530 .unwrap_or(Self::Unknown(node))
21531 }
21532 "property_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21533 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21534 })
21535 .map(Self::PropertyDeclaration)
21536 .unwrap_or(Self::Unknown(node)),
21537 "property_pattern_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21538 <PropertyPatternClause as ::treesitter_types::FromNode>::from_node(node, src)
21539 })
21540 .map(Self::PropertyPatternClause)
21541 .unwrap_or(Self::Unknown(node)),
21542 "qualified_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21543 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
21544 })
21545 .map(Self::QualifiedName)
21546 .unwrap_or(Self::Unknown(node)),
21547 "query_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21548 <QueryExpression as ::treesitter_types::FromNode>::from_node(node, src)
21549 })
21550 .map(Self::QueryExpression)
21551 .unwrap_or(Self::Unknown(node)),
21552 "range_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21553 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
21554 })
21555 .map(Self::RangeExpression)
21556 .unwrap_or(Self::Unknown(node)),
21557 "raw_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21558 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21559 })
21560 .map(Self::RawStringLiteral)
21561 .unwrap_or(Self::Unknown(node)),
21562 "record_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21563 <RecordDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21564 })
21565 .map(Self::RecordDeclaration)
21566 .unwrap_or(Self::Unknown(node)),
21567 "recursive_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21568 <RecursivePattern as ::treesitter_types::FromNode>::from_node(node, src)
21569 })
21570 .map(Self::RecursivePattern)
21571 .unwrap_or(Self::Unknown(node)),
21572 "ref_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21573 <RefExpression as ::treesitter_types::FromNode>::from_node(node, src)
21574 })
21575 .map(Self::RefExpression)
21576 .unwrap_or(Self::Unknown(node)),
21577 "ref_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21578 <RefType as ::treesitter_types::FromNode>::from_node(node, src)
21579 })
21580 .map(Self::RefType)
21581 .unwrap_or(Self::Unknown(node)),
21582 "reftype_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21583 <ReftypeExpression as ::treesitter_types::FromNode>::from_node(node, src)
21584 })
21585 .map(Self::ReftypeExpression)
21586 .unwrap_or(Self::Unknown(node)),
21587 "refvalue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21588 <RefvalueExpression as ::treesitter_types::FromNode>::from_node(node, src)
21589 })
21590 .map(Self::RefvalueExpression)
21591 .unwrap_or(Self::Unknown(node)),
21592 "relational_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21593 <RelationalPattern as ::treesitter_types::FromNode>::from_node(node, src)
21594 })
21595 .map(Self::RelationalPattern)
21596 .unwrap_or(Self::Unknown(node)),
21597 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21598 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
21599 })
21600 .map(Self::ReturnStatement)
21601 .unwrap_or(Self::Unknown(node)),
21602 "scoped_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21603 <ScopedType as ::treesitter_types::FromNode>::from_node(node, src)
21604 })
21605 .map(Self::ScopedType)
21606 .unwrap_or(Self::Unknown(node)),
21607 "select_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21608 <SelectClause as ::treesitter_types::FromNode>::from_node(node, src)
21609 })
21610 .map(Self::SelectClause)
21611 .unwrap_or(Self::Unknown(node)),
21612 "sizeof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21613 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
21614 })
21615 .map(Self::SizeofExpression)
21616 .unwrap_or(Self::Unknown(node)),
21617 "spread_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21618 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
21619 })
21620 .map(Self::SpreadElement)
21621 .unwrap_or(Self::Unknown(node)),
21622 "stackalloc_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21623 <StackallocExpression as ::treesitter_types::FromNode>::from_node(node, src)
21624 })
21625 .map(Self::StackallocExpression)
21626 .unwrap_or(Self::Unknown(node)),
21627 "string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21628 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21629 })
21630 .map(Self::StringLiteral)
21631 .unwrap_or(Self::Unknown(node)),
21632 "struct_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21633 <StructDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21634 })
21635 .map(Self::StructDeclaration)
21636 .unwrap_or(Self::Unknown(node)),
21637 "subpattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21638 <Subpattern as ::treesitter_types::FromNode>::from_node(node, src)
21639 })
21640 .map(Self::Subpattern)
21641 .unwrap_or(Self::Unknown(node)),
21642 "switch_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21643 <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
21644 })
21645 .map(Self::SwitchBody)
21646 .unwrap_or(Self::Unknown(node)),
21647 "switch_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21648 <SwitchExpression as ::treesitter_types::FromNode>::from_node(node, src)
21649 })
21650 .map(Self::SwitchExpression)
21651 .unwrap_or(Self::Unknown(node)),
21652 "switch_expression_arm" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21653 <SwitchExpressionArm as ::treesitter_types::FromNode>::from_node(node, src)
21654 })
21655 .map(Self::SwitchExpressionArm)
21656 .unwrap_or(Self::Unknown(node)),
21657 "switch_section" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21658 <SwitchSection as ::treesitter_types::FromNode>::from_node(node, src)
21659 })
21660 .map(Self::SwitchSection)
21661 .unwrap_or(Self::Unknown(node)),
21662 "switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21663 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
21664 })
21665 .map(Self::SwitchStatement)
21666 .unwrap_or(Self::Unknown(node)),
21667 "throw_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21668 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
21669 })
21670 .map(Self::ThrowExpression)
21671 .unwrap_or(Self::Unknown(node)),
21672 "throw_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21673 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
21674 })
21675 .map(Self::ThrowStatement)
21676 .unwrap_or(Self::Unknown(node)),
21677 "try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21678 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
21679 })
21680 .map(Self::TryStatement)
21681 .unwrap_or(Self::Unknown(node)),
21682 "tuple_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21683 <TupleElement as ::treesitter_types::FromNode>::from_node(node, src)
21684 })
21685 .map(Self::TupleElement)
21686 .unwrap_or(Self::Unknown(node)),
21687 "tuple_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21688 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
21689 })
21690 .map(Self::TupleExpression)
21691 .unwrap_or(Self::Unknown(node)),
21692 "tuple_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21693 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
21694 })
21695 .map(Self::TuplePattern)
21696 .unwrap_or(Self::Unknown(node)),
21697 "tuple_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21698 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
21699 })
21700 .map(Self::TupleType)
21701 .unwrap_or(Self::Unknown(node)),
21702 "type_argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21703 <TypeArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
21704 })
21705 .map(Self::TypeArgumentList)
21706 .unwrap_or(Self::Unknown(node)),
21707 "type_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21708 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
21709 })
21710 .map(Self::TypeParameter)
21711 .unwrap_or(Self::Unknown(node)),
21712 "type_parameter_constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21713 <TypeParameterConstraint as ::treesitter_types::FromNode>::from_node(node, src)
21714 })
21715 .map(Self::TypeParameterConstraint)
21716 .unwrap_or(Self::Unknown(node)),
21717 "type_parameter_constraints_clause" => {
21718 ::treesitter_types::runtime::maybe_grow_stack(|| {
21719 <TypeParameterConstraintsClause as ::treesitter_types::FromNode>::from_node(
21720 node, src,
21721 )
21722 })
21723 .map(Self::TypeParameterConstraintsClause)
21724 .unwrap_or(Self::Unknown(node))
21725 }
21726 "type_parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21727 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
21728 })
21729 .map(Self::TypeParameterList)
21730 .unwrap_or(Self::Unknown(node)),
21731 "type_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21732 <TypePattern as ::treesitter_types::FromNode>::from_node(node, src)
21733 })
21734 .map(Self::TypePattern)
21735 .unwrap_or(Self::Unknown(node)),
21736 "typeof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21737 <TypeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
21738 })
21739 .map(Self::TypeofExpression)
21740 .unwrap_or(Self::Unknown(node)),
21741 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21742 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
21743 })
21744 .map(Self::UnaryExpression)
21745 .unwrap_or(Self::Unknown(node)),
21746 "unsafe_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21747 <UnsafeStatement as ::treesitter_types::FromNode>::from_node(node, src)
21748 })
21749 .map(Self::UnsafeStatement)
21750 .unwrap_or(Self::Unknown(node)),
21751 "using_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21752 <UsingDirective as ::treesitter_types::FromNode>::from_node(node, src)
21753 })
21754 .map(Self::UsingDirective)
21755 .unwrap_or(Self::Unknown(node)),
21756 "using_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21757 <UsingStatement as ::treesitter_types::FromNode>::from_node(node, src)
21758 })
21759 .map(Self::UsingStatement)
21760 .unwrap_or(Self::Unknown(node)),
21761 "var_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21762 <VarPattern as ::treesitter_types::FromNode>::from_node(node, src)
21763 })
21764 .map(Self::VarPattern)
21765 .unwrap_or(Self::Unknown(node)),
21766 "variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21767 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
21768 })
21769 .map(Self::VariableDeclaration)
21770 .unwrap_or(Self::Unknown(node)),
21771 "variable_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21772 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
21773 })
21774 .map(Self::VariableDeclarator)
21775 .unwrap_or(Self::Unknown(node)),
21776 "when_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21777 <WhenClause as ::treesitter_types::FromNode>::from_node(node, src)
21778 })
21779 .map(Self::WhenClause)
21780 .unwrap_or(Self::Unknown(node)),
21781 "where_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21782 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
21783 })
21784 .map(Self::WhereClause)
21785 .unwrap_or(Self::Unknown(node)),
21786 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21787 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
21788 })
21789 .map(Self::WhileStatement)
21790 .unwrap_or(Self::Unknown(node)),
21791 "with_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21792 <WithExpression as ::treesitter_types::FromNode>::from_node(node, src)
21793 })
21794 .map(Self::WithExpression)
21795 .unwrap_or(Self::Unknown(node)),
21796 "with_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21797 <WithInitializer as ::treesitter_types::FromNode>::from_node(node, src)
21798 })
21799 .map(Self::WithInitializer)
21800 .unwrap_or(Self::Unknown(node)),
21801 "yield_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21802 <YieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
21803 })
21804 .map(Self::YieldStatement)
21805 .unwrap_or(Self::Unknown(node)),
21806 "character_literal_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21807 <CharacterLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
21808 })
21809 .map(Self::CharacterLiteralContent)
21810 .unwrap_or(Self::Unknown(node)),
21811 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21812 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
21813 })
21814 .map(Self::Comment)
21815 .unwrap_or(Self::Unknown(node)),
21816 "discard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21817 <Discard as ::treesitter_types::FromNode>::from_node(node, src)
21818 })
21819 .map(Self::Discard)
21820 .unwrap_or(Self::Unknown(node)),
21821 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21822 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
21823 })
21824 .map(Self::EscapeSequence)
21825 .unwrap_or(Self::Unknown(node)),
21826 "integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21827 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21828 })
21829 .map(Self::IntegerLiteral)
21830 .unwrap_or(Self::Unknown(node)),
21831 "interpolation_brace" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21832 <InterpolationBrace as ::treesitter_types::FromNode>::from_node(node, src)
21833 })
21834 .map(Self::InterpolationBrace)
21835 .unwrap_or(Self::Unknown(node)),
21836 "interpolation_quote" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21837 <InterpolationQuote as ::treesitter_types::FromNode>::from_node(node, src)
21838 })
21839 .map(Self::InterpolationQuote)
21840 .unwrap_or(Self::Unknown(node)),
21841 "interpolation_start" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21842 <InterpolationStart as ::treesitter_types::FromNode>::from_node(node, src)
21843 })
21844 .map(Self::InterpolationStart)
21845 .unwrap_or(Self::Unknown(node)),
21846 "null_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21847 <NullLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21848 })
21849 .map(Self::NullLiteral)
21850 .unwrap_or(Self::Unknown(node)),
21851 "predefined_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21852 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
21853 })
21854 .map(Self::PredefinedType)
21855 .unwrap_or(Self::Unknown(node)),
21856 "preproc_arg" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21857 <PreprocArg as ::treesitter_types::FromNode>::from_node(node, src)
21858 })
21859 .map(Self::PreprocArg)
21860 .unwrap_or(Self::Unknown(node)),
21861 "raw_string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21862 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
21863 })
21864 .map(Self::RawStringContent)
21865 .unwrap_or(Self::Unknown(node)),
21866 "raw_string_end" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21867 <RawStringEnd as ::treesitter_types::FromNode>::from_node(node, src)
21868 })
21869 .map(Self::RawStringEnd)
21870 .unwrap_or(Self::Unknown(node)),
21871 "raw_string_start" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21872 <RawStringStart as ::treesitter_types::FromNode>::from_node(node, src)
21873 })
21874 .map(Self::RawStringStart)
21875 .unwrap_or(Self::Unknown(node)),
21876 "real_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21877 <RealLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21878 })
21879 .map(Self::RealLiteral)
21880 .unwrap_or(Self::Unknown(node)),
21881 "shebang_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21882 <ShebangDirective as ::treesitter_types::FromNode>::from_node(node, src)
21883 })
21884 .map(Self::ShebangDirective)
21885 .unwrap_or(Self::Unknown(node)),
21886 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21887 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
21888 })
21889 .map(Self::StringContent)
21890 .unwrap_or(Self::Unknown(node)),
21891 "string_literal_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21892 <StringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
21893 })
21894 .map(Self::StringLiteralContent)
21895 .unwrap_or(Self::Unknown(node)),
21896 "string_literal_encoding" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21897 <StringLiteralEncoding as ::treesitter_types::FromNode>::from_node(node, src)
21898 })
21899 .map(Self::StringLiteralEncoding)
21900 .unwrap_or(Self::Unknown(node)),
21901 "verbatim_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
21902 <VerbatimStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
21903 })
21904 .map(Self::VerbatimStringLiteral)
21905 .unwrap_or(Self::Unknown(node)),
21906 _ => Self::Unknown(node),
21907 }
21908 }
21909}
21910impl ::treesitter_types::Spanned for AnyNode<'_> {
21911 fn span(&self) -> ::treesitter_types::Span {
21912 match self {
21913 Self::Declaration(inner) => inner.span(),
21914 Self::Expression(inner) => inner.span(),
21915 Self::Literal(inner) => inner.span(),
21916 Self::LvalueExpression(inner) => inner.span(),
21917 Self::NonLvalueExpression(inner) => inner.span(),
21918 Self::Pattern(inner) => inner.span(),
21919 Self::Statement(inner) => inner.span(),
21920 Self::Type(inner) => inner.span(),
21921 Self::TypeDeclaration(inner) => inner.span(),
21922 Self::AccessorDeclaration(inner) => inner.span(),
21923 Self::AccessorList(inner) => inner.span(),
21924 Self::AliasQualifiedName(inner) => inner.span(),
21925 Self::AndPattern(inner) => inner.span(),
21926 Self::AnonymousMethodExpression(inner) => inner.span(),
21927 Self::AnonymousObjectCreationExpression(inner) => inner.span(),
21928 Self::Argument(inner) => inner.span(),
21929 Self::ArgumentList(inner) => inner.span(),
21930 Self::ArrayCreationExpression(inner) => inner.span(),
21931 Self::ArrayRankSpecifier(inner) => inner.span(),
21932 Self::ArrayType(inner) => inner.span(),
21933 Self::ArrowExpressionClause(inner) => inner.span(),
21934 Self::AsExpression(inner) => inner.span(),
21935 Self::AssignmentExpression(inner) => inner.span(),
21936 Self::Attribute(inner) => inner.span(),
21937 Self::AttributeArgument(inner) => inner.span(),
21938 Self::AttributeArgumentList(inner) => inner.span(),
21939 Self::AttributeList(inner) => inner.span(),
21940 Self::AttributeTargetSpecifier(inner) => inner.span(),
21941 Self::AwaitExpression(inner) => inner.span(),
21942 Self::BaseList(inner) => inner.span(),
21943 Self::BinaryExpression(inner) => inner.span(),
21944 Self::Block(inner) => inner.span(),
21945 Self::BooleanLiteral(inner) => inner.span(),
21946 Self::BracketedArgumentList(inner) => inner.span(),
21947 Self::BracketedParameterList(inner) => inner.span(),
21948 Self::BreakStatement(inner) => inner.span(),
21949 Self::CallingConvention(inner) => inner.span(),
21950 Self::CastExpression(inner) => inner.span(),
21951 Self::CatchClause(inner) => inner.span(),
21952 Self::CatchDeclaration(inner) => inner.span(),
21953 Self::CatchFilterClause(inner) => inner.span(),
21954 Self::CharacterLiteral(inner) => inner.span(),
21955 Self::CheckedExpression(inner) => inner.span(),
21956 Self::CheckedStatement(inner) => inner.span(),
21957 Self::ClassDeclaration(inner) => inner.span(),
21958 Self::CollectionElement(inner) => inner.span(),
21959 Self::CollectionExpression(inner) => inner.span(),
21960 Self::CompilationUnit(inner) => inner.span(),
21961 Self::ConditionalAccessExpression(inner) => inner.span(),
21962 Self::ConditionalExpression(inner) => inner.span(),
21963 Self::ConstantPattern(inner) => inner.span(),
21964 Self::ConstructorConstraint(inner) => inner.span(),
21965 Self::ConstructorDeclaration(inner) => inner.span(),
21966 Self::ConstructorInitializer(inner) => inner.span(),
21967 Self::ContinueStatement(inner) => inner.span(),
21968 Self::ConversionOperatorDeclaration(inner) => inner.span(),
21969 Self::DeclarationExpression(inner) => inner.span(),
21970 Self::DeclarationList(inner) => inner.span(),
21971 Self::DeclarationPattern(inner) => inner.span(),
21972 Self::DefaultExpression(inner) => inner.span(),
21973 Self::DelegateDeclaration(inner) => inner.span(),
21974 Self::DestructorDeclaration(inner) => inner.span(),
21975 Self::DoStatement(inner) => inner.span(),
21976 Self::ElementAccessExpression(inner) => inner.span(),
21977 Self::ElementBindingExpression(inner) => inner.span(),
21978 Self::EmptyStatement(inner) => inner.span(),
21979 Self::EnumDeclaration(inner) => inner.span(),
21980 Self::EnumMemberDeclaration(inner) => inner.span(),
21981 Self::EnumMemberDeclarationList(inner) => inner.span(),
21982 Self::EventDeclaration(inner) => inner.span(),
21983 Self::EventFieldDeclaration(inner) => inner.span(),
21984 Self::ExplicitInterfaceSpecifier(inner) => inner.span(),
21985 Self::ExpressionElement(inner) => inner.span(),
21986 Self::ExpressionStatement(inner) => inner.span(),
21987 Self::ExternAliasDirective(inner) => inner.span(),
21988 Self::FieldDeclaration(inner) => inner.span(),
21989 Self::FileScopedNamespaceDeclaration(inner) => inner.span(),
21990 Self::FinallyClause(inner) => inner.span(),
21991 Self::FixedStatement(inner) => inner.span(),
21992 Self::ForStatement(inner) => inner.span(),
21993 Self::ForeachStatement(inner) => inner.span(),
21994 Self::FromClause(inner) => inner.span(),
21995 Self::FunctionPointerParameter(inner) => inner.span(),
21996 Self::FunctionPointerType(inner) => inner.span(),
21997 Self::GenericName(inner) => inner.span(),
21998 Self::GlobalAttribute(inner) => inner.span(),
21999 Self::GlobalStatement(inner) => inner.span(),
22000 Self::GotoStatement(inner) => inner.span(),
22001 Self::GroupClause(inner) => inner.span(),
22002 Self::Identifier(inner) => inner.span(),
22003 Self::IfStatement(inner) => inner.span(),
22004 Self::ImplicitArrayCreationExpression(inner) => inner.span(),
22005 Self::ImplicitObjectCreationExpression(inner) => inner.span(),
22006 Self::ImplicitParameter(inner) => inner.span(),
22007 Self::ImplicitStackallocExpression(inner) => inner.span(),
22008 Self::ImplicitType(inner) => inner.span(),
22009 Self::IndexerDeclaration(inner) => inner.span(),
22010 Self::InitializerExpression(inner) => inner.span(),
22011 Self::InterfaceDeclaration(inner) => inner.span(),
22012 Self::InterpolatedStringExpression(inner) => inner.span(),
22013 Self::Interpolation(inner) => inner.span(),
22014 Self::InterpolationAlignmentClause(inner) => inner.span(),
22015 Self::InterpolationFormatClause(inner) => inner.span(),
22016 Self::InvocationExpression(inner) => inner.span(),
22017 Self::IsExpression(inner) => inner.span(),
22018 Self::IsPatternExpression(inner) => inner.span(),
22019 Self::JoinClause(inner) => inner.span(),
22020 Self::JoinIntoClause(inner) => inner.span(),
22021 Self::LabeledStatement(inner) => inner.span(),
22022 Self::LambdaExpression(inner) => inner.span(),
22023 Self::LetClause(inner) => inner.span(),
22024 Self::ListPattern(inner) => inner.span(),
22025 Self::LocalDeclarationStatement(inner) => inner.span(),
22026 Self::LocalFunctionStatement(inner) => inner.span(),
22027 Self::LockStatement(inner) => inner.span(),
22028 Self::MakerefExpression(inner) => inner.span(),
22029 Self::MemberAccessExpression(inner) => inner.span(),
22030 Self::MemberBindingExpression(inner) => inner.span(),
22031 Self::MethodDeclaration(inner) => inner.span(),
22032 Self::Modifier(inner) => inner.span(),
22033 Self::NamespaceDeclaration(inner) => inner.span(),
22034 Self::NegatedPattern(inner) => inner.span(),
22035 Self::NullableType(inner) => inner.span(),
22036 Self::ObjectCreationExpression(inner) => inner.span(),
22037 Self::OperatorDeclaration(inner) => inner.span(),
22038 Self::OrPattern(inner) => inner.span(),
22039 Self::OrderByClause(inner) => inner.span(),
22040 Self::Parameter(inner) => inner.span(),
22041 Self::ParameterList(inner) => inner.span(),
22042 Self::ParenthesizedExpression(inner) => inner.span(),
22043 Self::ParenthesizedPattern(inner) => inner.span(),
22044 Self::ParenthesizedVariableDesignation(inner) => inner.span(),
22045 Self::PointerType(inner) => inner.span(),
22046 Self::PositionalPatternClause(inner) => inner.span(),
22047 Self::PostfixUnaryExpression(inner) => inner.span(),
22048 Self::PrefixUnaryExpression(inner) => inner.span(),
22049 Self::PreprocDefine(inner) => inner.span(),
22050 Self::PreprocElif(inner) => inner.span(),
22051 Self::PreprocElse(inner) => inner.span(),
22052 Self::PreprocEndregion(inner) => inner.span(),
22053 Self::PreprocError(inner) => inner.span(),
22054 Self::PreprocIf(inner) => inner.span(),
22055 Self::PreprocIfInAttributeList(inner) => inner.span(),
22056 Self::PreprocLine(inner) => inner.span(),
22057 Self::PreprocNullable(inner) => inner.span(),
22058 Self::PreprocPragma(inner) => inner.span(),
22059 Self::PreprocRegion(inner) => inner.span(),
22060 Self::PreprocUndef(inner) => inner.span(),
22061 Self::PreprocWarning(inner) => inner.span(),
22062 Self::PrimaryConstructorBaseType(inner) => inner.span(),
22063 Self::PropertyDeclaration(inner) => inner.span(),
22064 Self::PropertyPatternClause(inner) => inner.span(),
22065 Self::QualifiedName(inner) => inner.span(),
22066 Self::QueryExpression(inner) => inner.span(),
22067 Self::RangeExpression(inner) => inner.span(),
22068 Self::RawStringLiteral(inner) => inner.span(),
22069 Self::RecordDeclaration(inner) => inner.span(),
22070 Self::RecursivePattern(inner) => inner.span(),
22071 Self::RefExpression(inner) => inner.span(),
22072 Self::RefType(inner) => inner.span(),
22073 Self::ReftypeExpression(inner) => inner.span(),
22074 Self::RefvalueExpression(inner) => inner.span(),
22075 Self::RelationalPattern(inner) => inner.span(),
22076 Self::ReturnStatement(inner) => inner.span(),
22077 Self::ScopedType(inner) => inner.span(),
22078 Self::SelectClause(inner) => inner.span(),
22079 Self::SizeofExpression(inner) => inner.span(),
22080 Self::SpreadElement(inner) => inner.span(),
22081 Self::StackallocExpression(inner) => inner.span(),
22082 Self::StringLiteral(inner) => inner.span(),
22083 Self::StructDeclaration(inner) => inner.span(),
22084 Self::Subpattern(inner) => inner.span(),
22085 Self::SwitchBody(inner) => inner.span(),
22086 Self::SwitchExpression(inner) => inner.span(),
22087 Self::SwitchExpressionArm(inner) => inner.span(),
22088 Self::SwitchSection(inner) => inner.span(),
22089 Self::SwitchStatement(inner) => inner.span(),
22090 Self::ThrowExpression(inner) => inner.span(),
22091 Self::ThrowStatement(inner) => inner.span(),
22092 Self::TryStatement(inner) => inner.span(),
22093 Self::TupleElement(inner) => inner.span(),
22094 Self::TupleExpression(inner) => inner.span(),
22095 Self::TuplePattern(inner) => inner.span(),
22096 Self::TupleType(inner) => inner.span(),
22097 Self::TypeArgumentList(inner) => inner.span(),
22098 Self::TypeParameter(inner) => inner.span(),
22099 Self::TypeParameterConstraint(inner) => inner.span(),
22100 Self::TypeParameterConstraintsClause(inner) => inner.span(),
22101 Self::TypeParameterList(inner) => inner.span(),
22102 Self::TypePattern(inner) => inner.span(),
22103 Self::TypeofExpression(inner) => inner.span(),
22104 Self::UnaryExpression(inner) => inner.span(),
22105 Self::UnsafeStatement(inner) => inner.span(),
22106 Self::UsingDirective(inner) => inner.span(),
22107 Self::UsingStatement(inner) => inner.span(),
22108 Self::VarPattern(inner) => inner.span(),
22109 Self::VariableDeclaration(inner) => inner.span(),
22110 Self::VariableDeclarator(inner) => inner.span(),
22111 Self::WhenClause(inner) => inner.span(),
22112 Self::WhereClause(inner) => inner.span(),
22113 Self::WhileStatement(inner) => inner.span(),
22114 Self::WithExpression(inner) => inner.span(),
22115 Self::WithInitializer(inner) => inner.span(),
22116 Self::YieldStatement(inner) => inner.span(),
22117 Self::CharacterLiteralContent(inner) => inner.span(),
22118 Self::Comment(inner) => inner.span(),
22119 Self::Discard(inner) => inner.span(),
22120 Self::EscapeSequence(inner) => inner.span(),
22121 Self::IntegerLiteral(inner) => inner.span(),
22122 Self::InterpolationBrace(inner) => inner.span(),
22123 Self::InterpolationQuote(inner) => inner.span(),
22124 Self::InterpolationStart(inner) => inner.span(),
22125 Self::NullLiteral(inner) => inner.span(),
22126 Self::PredefinedType(inner) => inner.span(),
22127 Self::PreprocArg(inner) => inner.span(),
22128 Self::RawStringContent(inner) => inner.span(),
22129 Self::RawStringEnd(inner) => inner.span(),
22130 Self::RawStringStart(inner) => inner.span(),
22131 Self::RealLiteral(inner) => inner.span(),
22132 Self::ShebangDirective(inner) => inner.span(),
22133 Self::StringContent(inner) => inner.span(),
22134 Self::StringLiteralContent(inner) => inner.span(),
22135 Self::StringLiteralEncoding(inner) => inner.span(),
22136 Self::VerbatimStringLiteral(inner) => inner.span(),
22137 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
22138 }
22139 }
22140}