1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum DeclarationStatement<'tree> {
3 AssociatedType(::std::boxed::Box<AssociatedType<'tree>>),
4 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
5 ConstItem(::std::boxed::Box<ConstItem<'tree>>),
6 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7 EnumItem(::std::boxed::Box<EnumItem<'tree>>),
8 ExternCrateDeclaration(::std::boxed::Box<ExternCrateDeclaration<'tree>>),
9 ForeignModItem(::std::boxed::Box<ForeignModItem<'tree>>),
10 FunctionItem(::std::boxed::Box<FunctionItem<'tree>>),
11 FunctionSignatureItem(::std::boxed::Box<FunctionSignatureItem<'tree>>),
12 ImplItem(::std::boxed::Box<ImplItem<'tree>>),
13 InnerAttributeItem(::std::boxed::Box<InnerAttributeItem<'tree>>),
14 LetDeclaration(::std::boxed::Box<LetDeclaration<'tree>>),
15 MacroDefinition(::std::boxed::Box<MacroDefinition<'tree>>),
16 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
17 ModItem(::std::boxed::Box<ModItem<'tree>>),
18 StaticItem(::std::boxed::Box<StaticItem<'tree>>),
19 StructItem(::std::boxed::Box<StructItem<'tree>>),
20 TraitItem(::std::boxed::Box<TraitItem<'tree>>),
21 TypeItem(::std::boxed::Box<TypeItem<'tree>>),
22 UnionItem(::std::boxed::Box<UnionItem<'tree>>),
23 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
24}
25impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationStatement<'tree> {
26 #[allow(clippy::collapsible_else_if)]
27 fn from_node(
28 node: ::treesitter_types::tree_sitter::Node<'tree>,
29 src: &'tree [u8],
30 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
31 match node.kind() {
32 "associated_type" => Ok(Self::AssociatedType(::std::boxed::Box::new(
33 ::treesitter_types::runtime::maybe_grow_stack(|| {
34 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
35 })?,
36 ))),
37 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
38 ::treesitter_types::runtime::maybe_grow_stack(|| {
39 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
40 })?,
41 ))),
42 "const_item" => Ok(Self::ConstItem(::std::boxed::Box::new(
43 ::treesitter_types::runtime::maybe_grow_stack(|| {
44 <ConstItem as ::treesitter_types::FromNode>::from_node(node, src)
45 })?,
46 ))),
47 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
48 ::treesitter_types::runtime::maybe_grow_stack(|| {
49 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
50 })?,
51 ))),
52 "enum_item" => Ok(Self::EnumItem(::std::boxed::Box::new(
53 ::treesitter_types::runtime::maybe_grow_stack(|| {
54 <EnumItem as ::treesitter_types::FromNode>::from_node(node, src)
55 })?,
56 ))),
57 "extern_crate_declaration" => Ok(Self::ExternCrateDeclaration(::std::boxed::Box::new(
58 ::treesitter_types::runtime::maybe_grow_stack(|| {
59 <ExternCrateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
60 })?,
61 ))),
62 "foreign_mod_item" => Ok(Self::ForeignModItem(::std::boxed::Box::new(
63 ::treesitter_types::runtime::maybe_grow_stack(|| {
64 <ForeignModItem as ::treesitter_types::FromNode>::from_node(node, src)
65 })?,
66 ))),
67 "function_item" => Ok(Self::FunctionItem(::std::boxed::Box::new(
68 ::treesitter_types::runtime::maybe_grow_stack(|| {
69 <FunctionItem as ::treesitter_types::FromNode>::from_node(node, src)
70 })?,
71 ))),
72 "function_signature_item" => Ok(Self::FunctionSignatureItem(::std::boxed::Box::new(
73 ::treesitter_types::runtime::maybe_grow_stack(|| {
74 <FunctionSignatureItem as ::treesitter_types::FromNode>::from_node(node, src)
75 })?,
76 ))),
77 "impl_item" => Ok(Self::ImplItem(::std::boxed::Box::new(
78 ::treesitter_types::runtime::maybe_grow_stack(|| {
79 <ImplItem as ::treesitter_types::FromNode>::from_node(node, src)
80 })?,
81 ))),
82 "inner_attribute_item" => Ok(Self::InnerAttributeItem(::std::boxed::Box::new(
83 ::treesitter_types::runtime::maybe_grow_stack(|| {
84 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
85 })?,
86 ))),
87 "let_declaration" => Ok(Self::LetDeclaration(::std::boxed::Box::new(
88 ::treesitter_types::runtime::maybe_grow_stack(|| {
89 <LetDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
90 })?,
91 ))),
92 "macro_definition" => Ok(Self::MacroDefinition(::std::boxed::Box::new(
93 ::treesitter_types::runtime::maybe_grow_stack(|| {
94 <MacroDefinition as ::treesitter_types::FromNode>::from_node(node, src)
95 })?,
96 ))),
97 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
98 ::treesitter_types::runtime::maybe_grow_stack(|| {
99 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
100 })?,
101 ))),
102 "mod_item" => Ok(Self::ModItem(::std::boxed::Box::new(
103 ::treesitter_types::runtime::maybe_grow_stack(|| {
104 <ModItem as ::treesitter_types::FromNode>::from_node(node, src)
105 })?,
106 ))),
107 "static_item" => Ok(Self::StaticItem(::std::boxed::Box::new(
108 ::treesitter_types::runtime::maybe_grow_stack(|| {
109 <StaticItem as ::treesitter_types::FromNode>::from_node(node, src)
110 })?,
111 ))),
112 "struct_item" => Ok(Self::StructItem(::std::boxed::Box::new(
113 ::treesitter_types::runtime::maybe_grow_stack(|| {
114 <StructItem as ::treesitter_types::FromNode>::from_node(node, src)
115 })?,
116 ))),
117 "trait_item" => Ok(Self::TraitItem(::std::boxed::Box::new(
118 ::treesitter_types::runtime::maybe_grow_stack(|| {
119 <TraitItem as ::treesitter_types::FromNode>::from_node(node, src)
120 })?,
121 ))),
122 "type_item" => Ok(Self::TypeItem(::std::boxed::Box::new(
123 ::treesitter_types::runtime::maybe_grow_stack(|| {
124 <TypeItem as ::treesitter_types::FromNode>::from_node(node, src)
125 })?,
126 ))),
127 "union_item" => Ok(Self::UnionItem(::std::boxed::Box::new(
128 ::treesitter_types::runtime::maybe_grow_stack(|| {
129 <UnionItem as ::treesitter_types::FromNode>::from_node(node, src)
130 })?,
131 ))),
132 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
133 ::treesitter_types::runtime::maybe_grow_stack(|| {
134 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
135 })?,
136 ))),
137 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
138 }
139 }
140}
141impl ::treesitter_types::Spanned for DeclarationStatement<'_> {
142 fn span(&self) -> ::treesitter_types::Span {
143 match self {
144 Self::AssociatedType(inner) => inner.span(),
145 Self::AttributeItem(inner) => inner.span(),
146 Self::ConstItem(inner) => inner.span(),
147 Self::EmptyStatement(inner) => inner.span(),
148 Self::EnumItem(inner) => inner.span(),
149 Self::ExternCrateDeclaration(inner) => inner.span(),
150 Self::ForeignModItem(inner) => inner.span(),
151 Self::FunctionItem(inner) => inner.span(),
152 Self::FunctionSignatureItem(inner) => inner.span(),
153 Self::ImplItem(inner) => inner.span(),
154 Self::InnerAttributeItem(inner) => inner.span(),
155 Self::LetDeclaration(inner) => inner.span(),
156 Self::MacroDefinition(inner) => inner.span(),
157 Self::MacroInvocation(inner) => inner.span(),
158 Self::ModItem(inner) => inner.span(),
159 Self::StaticItem(inner) => inner.span(),
160 Self::StructItem(inner) => inner.span(),
161 Self::TraitItem(inner) => inner.span(),
162 Self::TypeItem(inner) => inner.span(),
163 Self::UnionItem(inner) => inner.span(),
164 Self::UseDeclaration(inner) => inner.span(),
165 }
166 }
167}
168#[derive(Debug, Clone, PartialEq, Eq)]
169pub enum Expression<'tree> {
170 Literal(::std::boxed::Box<Literal<'tree>>),
171 ArrayExpression(::std::boxed::Box<ArrayExpression<'tree>>),
172 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
173 AsyncBlock(::std::boxed::Box<AsyncBlock<'tree>>),
174 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
175 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
176 Block(::std::boxed::Box<Block<'tree>>),
177 BreakExpression(::std::boxed::Box<BreakExpression<'tree>>),
178 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
179 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
180 CompoundAssignmentExpr(::std::boxed::Box<CompoundAssignmentExpr<'tree>>),
181 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
182 ContinueExpression(::std::boxed::Box<ContinueExpression<'tree>>),
183 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
184 ForExpression(::std::boxed::Box<ForExpression<'tree>>),
185 GenBlock(::std::boxed::Box<GenBlock<'tree>>),
186 GenericFunction(::std::boxed::Box<GenericFunction<'tree>>),
187 Identifier(::std::boxed::Box<Identifier<'tree>>),
188 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
189 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
190 LoopExpression(::std::boxed::Box<LoopExpression<'tree>>),
191 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
192 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
193 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
194 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
195 RangeExpression(::std::boxed::Box<RangeExpression<'tree>>),
196 ReferenceExpression(::std::boxed::Box<ReferenceExpression<'tree>>),
197 ReturnExpression(::std::boxed::Box<ReturnExpression<'tree>>),
198 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
199 SelfType(::std::boxed::Box<SelfType<'tree>>),
200 StructExpression(::std::boxed::Box<StructExpression<'tree>>),
201 TryBlock(::std::boxed::Box<TryBlock<'tree>>),
202 TryExpression(::std::boxed::Box<TryExpression<'tree>>),
203 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
204 TypeCastExpression(::std::boxed::Box<TypeCastExpression<'tree>>),
205 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
206 UnitExpression(::std::boxed::Box<UnitExpression<'tree>>),
207 UnsafeBlock(::std::boxed::Box<UnsafeBlock<'tree>>),
208 WhileExpression(::std::boxed::Box<WhileExpression<'tree>>),
209 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
210}
211impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
212 #[allow(clippy::collapsible_else_if)]
213 fn from_node(
214 node: ::treesitter_types::tree_sitter::Node<'tree>,
215 src: &'tree [u8],
216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
217 match node.kind() {
218 "array_expression" => Ok(Self::ArrayExpression(::std::boxed::Box::new(
219 ::treesitter_types::runtime::maybe_grow_stack(|| {
220 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)
221 })?,
222 ))),
223 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
224 ::treesitter_types::runtime::maybe_grow_stack(|| {
225 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
226 })?,
227 ))),
228 "async_block" => Ok(Self::AsyncBlock(::std::boxed::Box::new(
229 ::treesitter_types::runtime::maybe_grow_stack(|| {
230 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)
231 })?,
232 ))),
233 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
234 ::treesitter_types::runtime::maybe_grow_stack(|| {
235 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
236 })?,
237 ))),
238 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
239 ::treesitter_types::runtime::maybe_grow_stack(|| {
240 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
241 })?,
242 ))),
243 "block" => Ok(Self::Block(::std::boxed::Box::new(
244 ::treesitter_types::runtime::maybe_grow_stack(|| {
245 <Block as ::treesitter_types::FromNode>::from_node(node, src)
246 })?,
247 ))),
248 "break_expression" => Ok(Self::BreakExpression(::std::boxed::Box::new(
249 ::treesitter_types::runtime::maybe_grow_stack(|| {
250 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)
251 })?,
252 ))),
253 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
254 ::treesitter_types::runtime::maybe_grow_stack(|| {
255 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
256 })?,
257 ))),
258 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
259 ::treesitter_types::runtime::maybe_grow_stack(|| {
260 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
261 })?,
262 ))),
263 "compound_assignment_expr" => Ok(Self::CompoundAssignmentExpr(::std::boxed::Box::new(
264 ::treesitter_types::runtime::maybe_grow_stack(|| {
265 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)
266 })?,
267 ))),
268 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
269 ::treesitter_types::runtime::maybe_grow_stack(|| {
270 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
271 })?,
272 ))),
273 "continue_expression" => Ok(Self::ContinueExpression(::std::boxed::Box::new(
274 ::treesitter_types::runtime::maybe_grow_stack(|| {
275 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)
276 })?,
277 ))),
278 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
279 ::treesitter_types::runtime::maybe_grow_stack(|| {
280 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
281 })?,
282 ))),
283 "for_expression" => Ok(Self::ForExpression(::std::boxed::Box::new(
284 ::treesitter_types::runtime::maybe_grow_stack(|| {
285 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)
286 })?,
287 ))),
288 "gen_block" => Ok(Self::GenBlock(::std::boxed::Box::new(
289 ::treesitter_types::runtime::maybe_grow_stack(|| {
290 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)
291 })?,
292 ))),
293 "generic_function" => Ok(Self::GenericFunction(::std::boxed::Box::new(
294 ::treesitter_types::runtime::maybe_grow_stack(|| {
295 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)
296 })?,
297 ))),
298 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
299 ::treesitter_types::runtime::maybe_grow_stack(|| {
300 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
301 })?,
302 ))),
303 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
304 ::treesitter_types::runtime::maybe_grow_stack(|| {
305 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
306 })?,
307 ))),
308 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
309 ::treesitter_types::runtime::maybe_grow_stack(|| {
310 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
311 })?,
312 ))),
313 "loop_expression" => Ok(Self::LoopExpression(::std::boxed::Box::new(
314 ::treesitter_types::runtime::maybe_grow_stack(|| {
315 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)
316 })?,
317 ))),
318 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
319 ::treesitter_types::runtime::maybe_grow_stack(|| {
320 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
321 })?,
322 ))),
323 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
324 ::treesitter_types::runtime::maybe_grow_stack(|| {
325 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
326 })?,
327 ))),
328 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
329 ::treesitter_types::runtime::maybe_grow_stack(|| {
330 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
331 })?,
332 ))),
333 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
334 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
335 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
336 })?),
337 )),
338 "range_expression" => Ok(Self::RangeExpression(::std::boxed::Box::new(
339 ::treesitter_types::runtime::maybe_grow_stack(|| {
340 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
341 })?,
342 ))),
343 "reference_expression" => Ok(Self::ReferenceExpression(::std::boxed::Box::new(
344 ::treesitter_types::runtime::maybe_grow_stack(|| {
345 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
346 })?,
347 ))),
348 "return_expression" => Ok(Self::ReturnExpression(::std::boxed::Box::new(
349 ::treesitter_types::runtime::maybe_grow_stack(|| {
350 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)
351 })?,
352 ))),
353 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
354 ::treesitter_types::runtime::maybe_grow_stack(|| {
355 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
356 })?,
357 ))),
358 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
359 ::treesitter_types::runtime::maybe_grow_stack(|| {
360 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
361 })?,
362 ))),
363 "struct_expression" => Ok(Self::StructExpression(::std::boxed::Box::new(
364 ::treesitter_types::runtime::maybe_grow_stack(|| {
365 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)
366 })?,
367 ))),
368 "try_block" => Ok(Self::TryBlock(::std::boxed::Box::new(
369 ::treesitter_types::runtime::maybe_grow_stack(|| {
370 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)
371 })?,
372 ))),
373 "try_expression" => Ok(Self::TryExpression(::std::boxed::Box::new(
374 ::treesitter_types::runtime::maybe_grow_stack(|| {
375 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)
376 })?,
377 ))),
378 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
379 ::treesitter_types::runtime::maybe_grow_stack(|| {
380 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
381 })?,
382 ))),
383 "type_cast_expression" => Ok(Self::TypeCastExpression(::std::boxed::Box::new(
384 ::treesitter_types::runtime::maybe_grow_stack(|| {
385 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)
386 })?,
387 ))),
388 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
389 ::treesitter_types::runtime::maybe_grow_stack(|| {
390 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
391 })?,
392 ))),
393 "unit_expression" => Ok(Self::UnitExpression(::std::boxed::Box::new(
394 ::treesitter_types::runtime::maybe_grow_stack(|| {
395 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)
396 })?,
397 ))),
398 "unsafe_block" => Ok(Self::UnsafeBlock(::std::boxed::Box::new(
399 ::treesitter_types::runtime::maybe_grow_stack(|| {
400 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)
401 })?,
402 ))),
403 "while_expression" => Ok(Self::WhileExpression(::std::boxed::Box::new(
404 ::treesitter_types::runtime::maybe_grow_stack(|| {
405 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)
406 })?,
407 ))),
408 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
409 ::treesitter_types::runtime::maybe_grow_stack(|| {
410 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
411 })?,
412 ))),
413 _other => {
414 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
415 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
416 }) {
417 Ok(Self::Literal(::std::boxed::Box::new(v)))
418 } else {
419 Err(::treesitter_types::ParseError::unexpected_kind(
420 _other, node,
421 ))
422 }
423 }
424 }
425 }
426}
427impl ::treesitter_types::Spanned for Expression<'_> {
428 fn span(&self) -> ::treesitter_types::Span {
429 match self {
430 Self::Literal(inner) => inner.span(),
431 Self::ArrayExpression(inner) => inner.span(),
432 Self::AssignmentExpression(inner) => inner.span(),
433 Self::AsyncBlock(inner) => inner.span(),
434 Self::AwaitExpression(inner) => inner.span(),
435 Self::BinaryExpression(inner) => inner.span(),
436 Self::Block(inner) => inner.span(),
437 Self::BreakExpression(inner) => inner.span(),
438 Self::CallExpression(inner) => inner.span(),
439 Self::ClosureExpression(inner) => inner.span(),
440 Self::CompoundAssignmentExpr(inner) => inner.span(),
441 Self::ConstBlock(inner) => inner.span(),
442 Self::ContinueExpression(inner) => inner.span(),
443 Self::FieldExpression(inner) => inner.span(),
444 Self::ForExpression(inner) => inner.span(),
445 Self::GenBlock(inner) => inner.span(),
446 Self::GenericFunction(inner) => inner.span(),
447 Self::Identifier(inner) => inner.span(),
448 Self::IfExpression(inner) => inner.span(),
449 Self::IndexExpression(inner) => inner.span(),
450 Self::LoopExpression(inner) => inner.span(),
451 Self::MacroInvocation(inner) => inner.span(),
452 Self::MatchExpression(inner) => inner.span(),
453 Self::Metavariable(inner) => inner.span(),
454 Self::ParenthesizedExpression(inner) => inner.span(),
455 Self::RangeExpression(inner) => inner.span(),
456 Self::ReferenceExpression(inner) => inner.span(),
457 Self::ReturnExpression(inner) => inner.span(),
458 Self::ScopedIdentifier(inner) => inner.span(),
459 Self::SelfType(inner) => inner.span(),
460 Self::StructExpression(inner) => inner.span(),
461 Self::TryBlock(inner) => inner.span(),
462 Self::TryExpression(inner) => inner.span(),
463 Self::TupleExpression(inner) => inner.span(),
464 Self::TypeCastExpression(inner) => inner.span(),
465 Self::UnaryExpression(inner) => inner.span(),
466 Self::UnitExpression(inner) => inner.span(),
467 Self::UnsafeBlock(inner) => inner.span(),
468 Self::WhileExpression(inner) => inner.span(),
469 Self::YieldExpression(inner) => inner.span(),
470 }
471 }
472}
473#[derive(Debug, Clone, PartialEq, Eq)]
474pub enum Literal<'tree> {
475 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
476 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
477 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
478 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
479 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
480 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
481}
482impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
483 #[allow(clippy::collapsible_else_if)]
484 fn from_node(
485 node: ::treesitter_types::tree_sitter::Node<'tree>,
486 src: &'tree [u8],
487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
488 match node.kind() {
489 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
490 ::treesitter_types::runtime::maybe_grow_stack(|| {
491 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
492 })?,
493 ))),
494 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
495 ::treesitter_types::runtime::maybe_grow_stack(|| {
496 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
497 })?,
498 ))),
499 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
500 ::treesitter_types::runtime::maybe_grow_stack(|| {
501 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
502 })?,
503 ))),
504 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
505 ::treesitter_types::runtime::maybe_grow_stack(|| {
506 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
507 })?,
508 ))),
509 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
510 ::treesitter_types::runtime::maybe_grow_stack(|| {
511 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
512 })?,
513 ))),
514 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
515 ::treesitter_types::runtime::maybe_grow_stack(|| {
516 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
517 })?,
518 ))),
519 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
520 }
521 }
522}
523impl ::treesitter_types::Spanned for Literal<'_> {
524 fn span(&self) -> ::treesitter_types::Span {
525 match self {
526 Self::BooleanLiteral(inner) => inner.span(),
527 Self::CharLiteral(inner) => inner.span(),
528 Self::FloatLiteral(inner) => inner.span(),
529 Self::IntegerLiteral(inner) => inner.span(),
530 Self::RawStringLiteral(inner) => inner.span(),
531 Self::StringLiteral(inner) => inner.span(),
532 }
533 }
534}
535#[derive(Debug, Clone, PartialEq, Eq)]
536pub enum LiteralPattern<'tree> {
537 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
538 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
539 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
540 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
541 NegativeLiteral(::std::boxed::Box<NegativeLiteral<'tree>>),
542 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
543 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
544}
545impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralPattern<'tree> {
546 #[allow(clippy::collapsible_else_if)]
547 fn from_node(
548 node: ::treesitter_types::tree_sitter::Node<'tree>,
549 src: &'tree [u8],
550 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
551 match node.kind() {
552 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
553 ::treesitter_types::runtime::maybe_grow_stack(|| {
554 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
555 })?,
556 ))),
557 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
558 ::treesitter_types::runtime::maybe_grow_stack(|| {
559 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
560 })?,
561 ))),
562 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
563 ::treesitter_types::runtime::maybe_grow_stack(|| {
564 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
565 })?,
566 ))),
567 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
568 ::treesitter_types::runtime::maybe_grow_stack(|| {
569 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
570 })?,
571 ))),
572 "negative_literal" => Ok(Self::NegativeLiteral(::std::boxed::Box::new(
573 ::treesitter_types::runtime::maybe_grow_stack(|| {
574 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
575 })?,
576 ))),
577 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
578 ::treesitter_types::runtime::maybe_grow_stack(|| {
579 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
580 })?,
581 ))),
582 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
583 ::treesitter_types::runtime::maybe_grow_stack(|| {
584 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
585 })?,
586 ))),
587 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
588 }
589 }
590}
591impl ::treesitter_types::Spanned for LiteralPattern<'_> {
592 fn span(&self) -> ::treesitter_types::Span {
593 match self {
594 Self::BooleanLiteral(inner) => inner.span(),
595 Self::CharLiteral(inner) => inner.span(),
596 Self::FloatLiteral(inner) => inner.span(),
597 Self::IntegerLiteral(inner) => inner.span(),
598 Self::NegativeLiteral(inner) => inner.span(),
599 Self::RawStringLiteral(inner) => inner.span(),
600 Self::StringLiteral(inner) => inner.span(),
601 }
602 }
603}
604#[derive(Debug, Clone, PartialEq, Eq)]
605pub enum Pattern<'tree> {
606 Blank(::treesitter_types::Span),
607 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
608 CapturedPattern(::std::boxed::Box<CapturedPattern<'tree>>),
609 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
610 GenericPattern(::std::boxed::Box<GenericPattern<'tree>>),
611 Identifier(::std::boxed::Box<Identifier<'tree>>),
612 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
613 MutPattern(::std::boxed::Box<MutPattern<'tree>>),
614 OrPattern(::std::boxed::Box<OrPattern<'tree>>),
615 RangePattern(::std::boxed::Box<RangePattern<'tree>>),
616 RefPattern(::std::boxed::Box<RefPattern<'tree>>),
617 ReferencePattern(::std::boxed::Box<ReferencePattern<'tree>>),
618 RemainingFieldPattern(::std::boxed::Box<RemainingFieldPattern<'tree>>),
619 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
620 SlicePattern(::std::boxed::Box<SlicePattern<'tree>>),
621 StructPattern(::std::boxed::Box<StructPattern<'tree>>),
622 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
623 TupleStructPattern(::std::boxed::Box<TupleStructPattern<'tree>>),
624}
625impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
626 #[allow(clippy::collapsible_else_if)]
627 fn from_node(
628 node: ::treesitter_types::tree_sitter::Node<'tree>,
629 src: &'tree [u8],
630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
631 match node.kind() {
632 "_" => Ok(Self::Blank(::treesitter_types::Span::from(node))),
633 "captured_pattern" => Ok(Self::CapturedPattern(::std::boxed::Box::new(
634 ::treesitter_types::runtime::maybe_grow_stack(|| {
635 <CapturedPattern as ::treesitter_types::FromNode>::from_node(node, src)
636 })?,
637 ))),
638 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
639 ::treesitter_types::runtime::maybe_grow_stack(|| {
640 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
641 })?,
642 ))),
643 "generic_pattern" => Ok(Self::GenericPattern(::std::boxed::Box::new(
644 ::treesitter_types::runtime::maybe_grow_stack(|| {
645 <GenericPattern as ::treesitter_types::FromNode>::from_node(node, src)
646 })?,
647 ))),
648 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
649 ::treesitter_types::runtime::maybe_grow_stack(|| {
650 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
651 })?,
652 ))),
653 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
654 ::treesitter_types::runtime::maybe_grow_stack(|| {
655 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
656 })?,
657 ))),
658 "mut_pattern" => Ok(Self::MutPattern(::std::boxed::Box::new(
659 ::treesitter_types::runtime::maybe_grow_stack(|| {
660 <MutPattern as ::treesitter_types::FromNode>::from_node(node, src)
661 })?,
662 ))),
663 "or_pattern" => Ok(Self::OrPattern(::std::boxed::Box::new(
664 ::treesitter_types::runtime::maybe_grow_stack(|| {
665 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
666 })?,
667 ))),
668 "range_pattern" => Ok(Self::RangePattern(::std::boxed::Box::new(
669 ::treesitter_types::runtime::maybe_grow_stack(|| {
670 <RangePattern as ::treesitter_types::FromNode>::from_node(node, src)
671 })?,
672 ))),
673 "ref_pattern" => Ok(Self::RefPattern(::std::boxed::Box::new(
674 ::treesitter_types::runtime::maybe_grow_stack(|| {
675 <RefPattern as ::treesitter_types::FromNode>::from_node(node, src)
676 })?,
677 ))),
678 "reference_pattern" => Ok(Self::ReferencePattern(::std::boxed::Box::new(
679 ::treesitter_types::runtime::maybe_grow_stack(|| {
680 <ReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
681 })?,
682 ))),
683 "remaining_field_pattern" => Ok(Self::RemainingFieldPattern(::std::boxed::Box::new(
684 ::treesitter_types::runtime::maybe_grow_stack(|| {
685 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
686 })?,
687 ))),
688 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
689 ::treesitter_types::runtime::maybe_grow_stack(|| {
690 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
691 })?,
692 ))),
693 "slice_pattern" => Ok(Self::SlicePattern(::std::boxed::Box::new(
694 ::treesitter_types::runtime::maybe_grow_stack(|| {
695 <SlicePattern as ::treesitter_types::FromNode>::from_node(node, src)
696 })?,
697 ))),
698 "struct_pattern" => Ok(Self::StructPattern(::std::boxed::Box::new(
699 ::treesitter_types::runtime::maybe_grow_stack(|| {
700 <StructPattern as ::treesitter_types::FromNode>::from_node(node, src)
701 })?,
702 ))),
703 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
704 ::treesitter_types::runtime::maybe_grow_stack(|| {
705 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
706 })?,
707 ))),
708 "tuple_struct_pattern" => Ok(Self::TupleStructPattern(::std::boxed::Box::new(
709 ::treesitter_types::runtime::maybe_grow_stack(|| {
710 <TupleStructPattern as ::treesitter_types::FromNode>::from_node(node, src)
711 })?,
712 ))),
713 _other => {
714 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
715 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
716 }) {
717 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
718 } else {
719 Err(::treesitter_types::ParseError::unexpected_kind(
720 _other, node,
721 ))
722 }
723 }
724 }
725 }
726}
727impl ::treesitter_types::Spanned for Pattern<'_> {
728 fn span(&self) -> ::treesitter_types::Span {
729 match self {
730 Self::Blank(span) => *span,
731 Self::LiteralPattern(inner) => inner.span(),
732 Self::CapturedPattern(inner) => inner.span(),
733 Self::ConstBlock(inner) => inner.span(),
734 Self::GenericPattern(inner) => inner.span(),
735 Self::Identifier(inner) => inner.span(),
736 Self::MacroInvocation(inner) => inner.span(),
737 Self::MutPattern(inner) => inner.span(),
738 Self::OrPattern(inner) => inner.span(),
739 Self::RangePattern(inner) => inner.span(),
740 Self::RefPattern(inner) => inner.span(),
741 Self::ReferencePattern(inner) => inner.span(),
742 Self::RemainingFieldPattern(inner) => inner.span(),
743 Self::ScopedIdentifier(inner) => inner.span(),
744 Self::SlicePattern(inner) => inner.span(),
745 Self::StructPattern(inner) => inner.span(),
746 Self::TuplePattern(inner) => inner.span(),
747 Self::TupleStructPattern(inner) => inner.span(),
748 }
749 }
750}
751#[derive(Debug, Clone, PartialEq, Eq)]
752pub enum Type<'tree> {
753 AbstractType(::std::boxed::Box<AbstractType<'tree>>),
754 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
755 BoundedType(::std::boxed::Box<BoundedType<'tree>>),
756 DynamicType(::std::boxed::Box<DynamicType<'tree>>),
757 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
758 GenericType(::std::boxed::Box<GenericType<'tree>>),
759 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
760 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
761 NeverType(::std::boxed::Box<NeverType<'tree>>),
762 PointerType(::std::boxed::Box<PointerType<'tree>>),
763 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
764 ReferenceType(::std::boxed::Box<ReferenceType<'tree>>),
765 RemovedTraitBound(::std::boxed::Box<RemovedTraitBound<'tree>>),
766 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
767 TupleType(::std::boxed::Box<TupleType<'tree>>),
768 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
769 UnitType(::std::boxed::Box<UnitType<'tree>>),
770}
771impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
772 #[allow(clippy::collapsible_else_if)]
773 fn from_node(
774 node: ::treesitter_types::tree_sitter::Node<'tree>,
775 src: &'tree [u8],
776 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
777 match node.kind() {
778 "abstract_type" => Ok(Self::AbstractType(::std::boxed::Box::new(
779 ::treesitter_types::runtime::maybe_grow_stack(|| {
780 <AbstractType as ::treesitter_types::FromNode>::from_node(node, src)
781 })?,
782 ))),
783 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
784 ::treesitter_types::runtime::maybe_grow_stack(|| {
785 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
786 })?,
787 ))),
788 "bounded_type" => Ok(Self::BoundedType(::std::boxed::Box::new(
789 ::treesitter_types::runtime::maybe_grow_stack(|| {
790 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)
791 })?,
792 ))),
793 "dynamic_type" => Ok(Self::DynamicType(::std::boxed::Box::new(
794 ::treesitter_types::runtime::maybe_grow_stack(|| {
795 <DynamicType as ::treesitter_types::FromNode>::from_node(node, src)
796 })?,
797 ))),
798 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
799 ::treesitter_types::runtime::maybe_grow_stack(|| {
800 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
801 })?,
802 ))),
803 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
804 ::treesitter_types::runtime::maybe_grow_stack(|| {
805 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
806 })?,
807 ))),
808 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
809 ::treesitter_types::runtime::maybe_grow_stack(|| {
810 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
811 })?,
812 ))),
813 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
814 ::treesitter_types::runtime::maybe_grow_stack(|| {
815 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
816 })?,
817 ))),
818 "never_type" => Ok(Self::NeverType(::std::boxed::Box::new(
819 ::treesitter_types::runtime::maybe_grow_stack(|| {
820 <NeverType as ::treesitter_types::FromNode>::from_node(node, src)
821 })?,
822 ))),
823 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
824 ::treesitter_types::runtime::maybe_grow_stack(|| {
825 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
826 })?,
827 ))),
828 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
829 ::treesitter_types::runtime::maybe_grow_stack(|| {
830 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
831 })?,
832 ))),
833 "reference_type" => Ok(Self::ReferenceType(::std::boxed::Box::new(
834 ::treesitter_types::runtime::maybe_grow_stack(|| {
835 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)
836 })?,
837 ))),
838 "removed_trait_bound" => Ok(Self::RemovedTraitBound(::std::boxed::Box::new(
839 ::treesitter_types::runtime::maybe_grow_stack(|| {
840 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
841 })?,
842 ))),
843 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
844 ::treesitter_types::runtime::maybe_grow_stack(|| {
845 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
846 })?,
847 ))),
848 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
849 ::treesitter_types::runtime::maybe_grow_stack(|| {
850 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
851 })?,
852 ))),
853 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
854 ::treesitter_types::runtime::maybe_grow_stack(|| {
855 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
856 })?,
857 ))),
858 "unit_type" => Ok(Self::UnitType(::std::boxed::Box::new(
859 ::treesitter_types::runtime::maybe_grow_stack(|| {
860 <UnitType as ::treesitter_types::FromNode>::from_node(node, src)
861 })?,
862 ))),
863 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
864 }
865 }
866}
867impl ::treesitter_types::Spanned for Type<'_> {
868 fn span(&self) -> ::treesitter_types::Span {
869 match self {
870 Self::AbstractType(inner) => inner.span(),
871 Self::ArrayType(inner) => inner.span(),
872 Self::BoundedType(inner) => inner.span(),
873 Self::DynamicType(inner) => inner.span(),
874 Self::FunctionType(inner) => inner.span(),
875 Self::GenericType(inner) => inner.span(),
876 Self::MacroInvocation(inner) => inner.span(),
877 Self::Metavariable(inner) => inner.span(),
878 Self::NeverType(inner) => inner.span(),
879 Self::PointerType(inner) => inner.span(),
880 Self::PrimitiveType(inner) => inner.span(),
881 Self::ReferenceType(inner) => inner.span(),
882 Self::RemovedTraitBound(inner) => inner.span(),
883 Self::ScopedTypeIdentifier(inner) => inner.span(),
884 Self::TupleType(inner) => inner.span(),
885 Self::TypeIdentifier(inner) => inner.span(),
886 Self::UnitType(inner) => inner.span(),
887 }
888 }
889}
890#[derive(Debug, Clone, PartialEq, Eq)]
891pub struct AbstractType<'tree> {
892 pub span: ::treesitter_types::Span,
893 pub r#trait: AbstractTypeTrait<'tree>,
894 pub children: ::core::option::Option<TypeParameters<'tree>>,
895}
896impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractType<'tree> {
897 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
898 fn from_node(
899 node: ::treesitter_types::tree_sitter::Node<'tree>,
900 src: &'tree [u8],
901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
902 debug_assert_eq!(node.kind(), "abstract_type");
903 Ok(Self {
904 span: ::treesitter_types::Span::from(node),
905 r#trait: {
906 let child = node
907 .child_by_field_name("trait")
908 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("trait", node))?;
909 ::treesitter_types::runtime::maybe_grow_stack(|| {
910 <AbstractTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)
911 })?
912 },
913 children: {
914 #[allow(clippy::suspicious_else_formatting)]
915 let non_field_children = {
916 let mut cursor = node.walk();
917 let mut result = ::std::vec::Vec::new();
918 if cursor.goto_first_child() {
919 loop {
920 if cursor.field_name().is_none()
921 && cursor.node().is_named()
922 && !cursor.node().is_extra()
923 {
924 result.push(cursor.node());
925 }
926 if !cursor.goto_next_sibling() {
927 break;
928 }
929 }
930 }
931 result
932 };
933 match non_field_children.first() {
934 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
935 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
936 })?),
937 None => None,
938 }
939 },
940 })
941 }
942}
943impl ::treesitter_types::Spanned for AbstractType<'_> {
944 fn span(&self) -> ::treesitter_types::Span {
945 self.span
946 }
947}
948#[derive(Debug, Clone, PartialEq, Eq)]
949pub struct Arguments<'tree> {
950 pub span: ::treesitter_types::Span,
951 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
952}
953impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
955 fn from_node(
956 node: ::treesitter_types::tree_sitter::Node<'tree>,
957 src: &'tree [u8],
958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
959 debug_assert_eq!(node.kind(), "arguments");
960 Ok(Self {
961 span: ::treesitter_types::Span::from(node),
962 children: {
963 #[allow(clippy::suspicious_else_formatting)]
964 let non_field_children = {
965 let mut cursor = node.walk();
966 let mut result = ::std::vec::Vec::new();
967 if cursor.goto_first_child() {
968 loop {
969 if cursor.field_name().is_none()
970 && cursor.node().is_named()
971 && !cursor.node().is_extra()
972 {
973 result.push(cursor.node());
974 }
975 if !cursor.goto_next_sibling() {
976 break;
977 }
978 }
979 }
980 result
981 };
982 let mut items = ::std::vec::Vec::new();
983 for child in non_field_children {
984 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
985 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)
986 })?);
987 }
988 items
989 },
990 })
991 }
992}
993impl ::treesitter_types::Spanned for Arguments<'_> {
994 fn span(&self) -> ::treesitter_types::Span {
995 self.span
996 }
997}
998#[derive(Debug, Clone, PartialEq, Eq)]
999pub struct ArrayExpression<'tree> {
1000 pub span: ::treesitter_types::Span,
1001 pub length: ::core::option::Option<Expression<'tree>>,
1002 pub children: ::std::vec::Vec<ArrayExpressionChildren<'tree>>,
1003}
1004impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayExpression<'tree> {
1005 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1006 fn from_node(
1007 node: ::treesitter_types::tree_sitter::Node<'tree>,
1008 src: &'tree [u8],
1009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1010 debug_assert_eq!(node.kind(), "array_expression");
1011 Ok(Self {
1012 span: ::treesitter_types::Span::from(node),
1013 length: match node.child_by_field_name("length") {
1014 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1015 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1016 })?),
1017 None => None,
1018 },
1019 children: {
1020 #[allow(clippy::suspicious_else_formatting)]
1021 let non_field_children = {
1022 let mut cursor = node.walk();
1023 let mut result = ::std::vec::Vec::new();
1024 if cursor.goto_first_child() {
1025 loop {
1026 if cursor.field_name().is_none()
1027 && cursor.node().is_named()
1028 && !cursor.node().is_extra()
1029 {
1030 result.push(cursor.node());
1031 }
1032 if !cursor.goto_next_sibling() {
1033 break;
1034 }
1035 }
1036 }
1037 result
1038 };
1039 let mut items = ::std::vec::Vec::new();
1040 for child in non_field_children {
1041 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1042 <ArrayExpressionChildren as ::treesitter_types::FromNode>::from_node(
1043 child, src,
1044 )
1045 })?);
1046 }
1047 items
1048 },
1049 })
1050 }
1051}
1052impl ::treesitter_types::Spanned for ArrayExpression<'_> {
1053 fn span(&self) -> ::treesitter_types::Span {
1054 self.span
1055 }
1056}
1057#[derive(Debug, Clone, PartialEq, Eq)]
1058pub struct ArrayType<'tree> {
1059 pub span: ::treesitter_types::Span,
1060 pub element: Type<'tree>,
1061 pub length: ::core::option::Option<Expression<'tree>>,
1062}
1063impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1064 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1065 fn from_node(
1066 node: ::treesitter_types::tree_sitter::Node<'tree>,
1067 src: &'tree [u8],
1068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1069 debug_assert_eq!(node.kind(), "array_type");
1070 Ok(Self {
1071 span: ::treesitter_types::Span::from(node),
1072 element: {
1073 let child = node.child_by_field_name("element").ok_or_else(|| {
1074 ::treesitter_types::ParseError::missing_field("element", node)
1075 })?;
1076 ::treesitter_types::runtime::maybe_grow_stack(|| {
1077 <Type as ::treesitter_types::FromNode>::from_node(child, src)
1078 })?
1079 },
1080 length: match node.child_by_field_name("length") {
1081 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1082 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1083 })?),
1084 None => None,
1085 },
1086 })
1087 }
1088}
1089impl ::treesitter_types::Spanned for ArrayType<'_> {
1090 fn span(&self) -> ::treesitter_types::Span {
1091 self.span
1092 }
1093}
1094#[derive(Debug, Clone, PartialEq, Eq)]
1095pub struct AssignmentExpression<'tree> {
1096 pub span: ::treesitter_types::Span,
1097 pub left: Expression<'tree>,
1098 pub right: Expression<'tree>,
1099}
1100impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1101 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1102 fn from_node(
1103 node: ::treesitter_types::tree_sitter::Node<'tree>,
1104 src: &'tree [u8],
1105 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1106 debug_assert_eq!(node.kind(), "assignment_expression");
1107 Ok(Self {
1108 span: ::treesitter_types::Span::from(node),
1109 left: {
1110 let child = node
1111 .child_by_field_name("left")
1112 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1113 ::treesitter_types::runtime::maybe_grow_stack(|| {
1114 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1115 })?
1116 },
1117 right: {
1118 let child = node
1119 .child_by_field_name("right")
1120 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1121 ::treesitter_types::runtime::maybe_grow_stack(|| {
1122 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1123 })?
1124 },
1125 })
1126 }
1127}
1128impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1129 fn span(&self) -> ::treesitter_types::Span {
1130 self.span
1131 }
1132}
1133#[derive(Debug, Clone, PartialEq, Eq)]
1134pub struct AssociatedType<'tree> {
1135 pub span: ::treesitter_types::Span,
1136 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
1137 pub name: TypeIdentifier<'tree>,
1138 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1139 pub children: ::core::option::Option<WhereClause<'tree>>,
1140}
1141impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedType<'tree> {
1142 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1143 fn from_node(
1144 node: ::treesitter_types::tree_sitter::Node<'tree>,
1145 src: &'tree [u8],
1146 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1147 debug_assert_eq!(node.kind(), "associated_type");
1148 Ok(Self {
1149 span: ::treesitter_types::Span::from(node),
1150 bounds: match node.child_by_field_name("bounds") {
1151 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1152 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)
1153 })?),
1154 None => None,
1155 },
1156 name: {
1157 let child = node
1158 .child_by_field_name("name")
1159 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1160 ::treesitter_types::runtime::maybe_grow_stack(|| {
1161 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
1162 })?
1163 },
1164 type_parameters: match node.child_by_field_name("type_parameters") {
1165 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1166 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
1167 })?),
1168 None => None,
1169 },
1170 children: {
1171 #[allow(clippy::suspicious_else_formatting)]
1172 let non_field_children = {
1173 let mut cursor = node.walk();
1174 let mut result = ::std::vec::Vec::new();
1175 if cursor.goto_first_child() {
1176 loop {
1177 if cursor.field_name().is_none()
1178 && cursor.node().is_named()
1179 && !cursor.node().is_extra()
1180 {
1181 result.push(cursor.node());
1182 }
1183 if !cursor.goto_next_sibling() {
1184 break;
1185 }
1186 }
1187 }
1188 result
1189 };
1190 match non_field_children.first() {
1191 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1192 <WhereClause as ::treesitter_types::FromNode>::from_node(child, src)
1193 })?),
1194 None => None,
1195 }
1196 },
1197 })
1198 }
1199}
1200impl ::treesitter_types::Spanned for AssociatedType<'_> {
1201 fn span(&self) -> ::treesitter_types::Span {
1202 self.span
1203 }
1204}
1205#[derive(Debug, Clone, PartialEq, Eq)]
1206pub struct AsyncBlock<'tree> {
1207 pub span: ::treesitter_types::Span,
1208 pub children: Block<'tree>,
1209}
1210impl<'tree> ::treesitter_types::FromNode<'tree> for AsyncBlock<'tree> {
1211 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1212 fn from_node(
1213 node: ::treesitter_types::tree_sitter::Node<'tree>,
1214 src: &'tree [u8],
1215 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1216 debug_assert_eq!(node.kind(), "async_block");
1217 Ok(Self {
1218 span: ::treesitter_types::Span::from(node),
1219 children: {
1220 #[allow(clippy::suspicious_else_formatting)]
1221 let non_field_children = {
1222 let mut cursor = node.walk();
1223 let mut result = ::std::vec::Vec::new();
1224 if cursor.goto_first_child() {
1225 loop {
1226 if cursor.field_name().is_none()
1227 && cursor.node().is_named()
1228 && !cursor.node().is_extra()
1229 {
1230 result.push(cursor.node());
1231 }
1232 if !cursor.goto_next_sibling() {
1233 break;
1234 }
1235 }
1236 }
1237 result
1238 };
1239 let child = if let Some(&c) = non_field_children.first() {
1240 c
1241 } else {
1242 let mut fallback_cursor = node.walk();
1243 let mut fallback_child = None;
1244 if fallback_cursor.goto_first_child() {
1245 loop {
1246 if fallback_cursor.field_name().is_none()
1247 && !fallback_cursor.node().is_extra()
1248 {
1249 let candidate = fallback_cursor.node();
1250 #[allow(clippy::needless_question_mark)]
1251 if (|| -> ::core::result::Result<
1252 _,
1253 ::treesitter_types::ParseError,
1254 > {
1255 let child = candidate;
1256 Ok(
1257 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
1258 child,
1259 src,
1260 ))?,
1261 )
1262 })()
1263 .is_ok()
1264 {
1265 fallback_child = Some(candidate);
1266 break;
1267 }
1268 }
1269 if !fallback_cursor.goto_next_sibling() {
1270 break;
1271 }
1272 }
1273 }
1274 if fallback_child.is_none() {
1275 let mut cursor2 = node.walk();
1276 if cursor2.goto_first_child() {
1277 loop {
1278 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1279 let candidate = cursor2.node();
1280 #[allow(clippy::needless_question_mark)]
1281 if (|| -> ::core::result::Result<
1282 _,
1283 ::treesitter_types::ParseError,
1284 > {
1285 let child = candidate;
1286 Ok(
1287 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
1288 child,
1289 src,
1290 ))?,
1291 )
1292 })()
1293 .is_ok()
1294 {
1295 fallback_child = Some(candidate);
1296 break;
1297 }
1298 }
1299 if !cursor2.goto_next_sibling() {
1300 break;
1301 }
1302 }
1303 }
1304 }
1305 fallback_child.ok_or_else(|| {
1306 ::treesitter_types::ParseError::missing_field("children", node)
1307 })?
1308 };
1309 ::treesitter_types::runtime::maybe_grow_stack(|| {
1310 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1311 })?
1312 },
1313 })
1314 }
1315}
1316impl ::treesitter_types::Spanned for AsyncBlock<'_> {
1317 fn span(&self) -> ::treesitter_types::Span {
1318 self.span
1319 }
1320}
1321#[derive(Debug, Clone, PartialEq, Eq)]
1322pub struct Attribute<'tree> {
1323 pub span: ::treesitter_types::Span,
1324 pub arguments: ::core::option::Option<TokenTree<'tree>>,
1325 pub value: ::core::option::Option<Expression<'tree>>,
1326 pub children: AttributeChildren<'tree>,
1327}
1328impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1329 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1330 fn from_node(
1331 node: ::treesitter_types::tree_sitter::Node<'tree>,
1332 src: &'tree [u8],
1333 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1334 debug_assert_eq!(node.kind(), "attribute");
1335 Ok(Self {
1336 span: ::treesitter_types::Span::from(node),
1337 arguments: match node.child_by_field_name("arguments") {
1338 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1339 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)
1340 })?),
1341 None => None,
1342 },
1343 value: match node.child_by_field_name("value") {
1344 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1345 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1346 })?),
1347 None => None,
1348 },
1349 children: {
1350 #[allow(clippy::suspicious_else_formatting)]
1351 let non_field_children = {
1352 let mut cursor = node.walk();
1353 let mut result = ::std::vec::Vec::new();
1354 if cursor.goto_first_child() {
1355 loop {
1356 if cursor.field_name().is_none()
1357 && cursor.node().is_named()
1358 && !cursor.node().is_extra()
1359 {
1360 result.push(cursor.node());
1361 }
1362 if !cursor.goto_next_sibling() {
1363 break;
1364 }
1365 }
1366 }
1367 result
1368 };
1369 let child = if let Some(&c) = non_field_children.first() {
1370 c
1371 } else {
1372 let mut fallback_cursor = node.walk();
1373 let mut fallback_child = None;
1374 if fallback_cursor.goto_first_child() {
1375 loop {
1376 if fallback_cursor.field_name().is_none()
1377 && !fallback_cursor.node().is_extra()
1378 {
1379 let candidate = fallback_cursor.node();
1380 #[allow(clippy::needless_question_mark)]
1381 if (|| -> ::core::result::Result<
1382 _,
1383 ::treesitter_types::ParseError,
1384 > {
1385 let child = candidate;
1386 Ok(
1387 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1388 child,
1389 src,
1390 ))?,
1391 )
1392 })()
1393 .is_ok()
1394 {
1395 fallback_child = Some(candidate);
1396 break;
1397 }
1398 }
1399 if !fallback_cursor.goto_next_sibling() {
1400 break;
1401 }
1402 }
1403 }
1404 if fallback_child.is_none() {
1405 let mut cursor2 = node.walk();
1406 if cursor2.goto_first_child() {
1407 loop {
1408 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1409 let candidate = cursor2.node();
1410 #[allow(clippy::needless_question_mark)]
1411 if (|| -> ::core::result::Result<
1412 _,
1413 ::treesitter_types::ParseError,
1414 > {
1415 let child = candidate;
1416 Ok(
1417 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1418 child,
1419 src,
1420 ))?,
1421 )
1422 })()
1423 .is_ok()
1424 {
1425 fallback_child = Some(candidate);
1426 break;
1427 }
1428 }
1429 if !cursor2.goto_next_sibling() {
1430 break;
1431 }
1432 }
1433 }
1434 }
1435 fallback_child.ok_or_else(|| {
1436 ::treesitter_types::ParseError::missing_field("children", node)
1437 })?
1438 };
1439 ::treesitter_types::runtime::maybe_grow_stack(|| {
1440 <AttributeChildren as ::treesitter_types::FromNode>::from_node(child, src)
1441 })?
1442 },
1443 })
1444 }
1445}
1446impl ::treesitter_types::Spanned for Attribute<'_> {
1447 fn span(&self) -> ::treesitter_types::Span {
1448 self.span
1449 }
1450}
1451#[derive(Debug, Clone, PartialEq, Eq)]
1452pub struct AttributeItem<'tree> {
1453 pub span: ::treesitter_types::Span,
1454 pub children: Attribute<'tree>,
1455}
1456impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeItem<'tree> {
1457 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1458 fn from_node(
1459 node: ::treesitter_types::tree_sitter::Node<'tree>,
1460 src: &'tree [u8],
1461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1462 debug_assert_eq!(node.kind(), "attribute_item");
1463 Ok(Self {
1464 span: ::treesitter_types::Span::from(node),
1465 children: {
1466 #[allow(clippy::suspicious_else_formatting)]
1467 let non_field_children = {
1468 let mut cursor = node.walk();
1469 let mut result = ::std::vec::Vec::new();
1470 if cursor.goto_first_child() {
1471 loop {
1472 if cursor.field_name().is_none()
1473 && cursor.node().is_named()
1474 && !cursor.node().is_extra()
1475 {
1476 result.push(cursor.node());
1477 }
1478 if !cursor.goto_next_sibling() {
1479 break;
1480 }
1481 }
1482 }
1483 result
1484 };
1485 let child = if let Some(&c) = non_field_children.first() {
1486 c
1487 } else {
1488 let mut fallback_cursor = node.walk();
1489 let mut fallback_child = None;
1490 if fallback_cursor.goto_first_child() {
1491 loop {
1492 if fallback_cursor.field_name().is_none()
1493 && !fallback_cursor.node().is_extra()
1494 {
1495 let candidate = fallback_cursor.node();
1496 #[allow(clippy::needless_question_mark)]
1497 if (|| -> ::core::result::Result<
1498 _,
1499 ::treesitter_types::ParseError,
1500 > {
1501 let child = candidate;
1502 Ok(
1503 ::treesitter_types::runtime::maybe_grow_stack(|| <Attribute as ::treesitter_types::FromNode>::from_node(
1504 child,
1505 src,
1506 ))?,
1507 )
1508 })()
1509 .is_ok()
1510 {
1511 fallback_child = Some(candidate);
1512 break;
1513 }
1514 }
1515 if !fallback_cursor.goto_next_sibling() {
1516 break;
1517 }
1518 }
1519 }
1520 if fallback_child.is_none() {
1521 let mut cursor2 = node.walk();
1522 if cursor2.goto_first_child() {
1523 loop {
1524 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1525 let candidate = cursor2.node();
1526 #[allow(clippy::needless_question_mark)]
1527 if (|| -> ::core::result::Result<
1528 _,
1529 ::treesitter_types::ParseError,
1530 > {
1531 let child = candidate;
1532 Ok(
1533 ::treesitter_types::runtime::maybe_grow_stack(|| <Attribute as ::treesitter_types::FromNode>::from_node(
1534 child,
1535 src,
1536 ))?,
1537 )
1538 })()
1539 .is_ok()
1540 {
1541 fallback_child = Some(candidate);
1542 break;
1543 }
1544 }
1545 if !cursor2.goto_next_sibling() {
1546 break;
1547 }
1548 }
1549 }
1550 }
1551 fallback_child.ok_or_else(|| {
1552 ::treesitter_types::ParseError::missing_field("children", node)
1553 })?
1554 };
1555 ::treesitter_types::runtime::maybe_grow_stack(|| {
1556 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
1557 })?
1558 },
1559 })
1560 }
1561}
1562impl ::treesitter_types::Spanned for AttributeItem<'_> {
1563 fn span(&self) -> ::treesitter_types::Span {
1564 self.span
1565 }
1566}
1567#[derive(Debug, Clone, PartialEq, Eq)]
1568pub struct AwaitExpression<'tree> {
1569 pub span: ::treesitter_types::Span,
1570 pub children: Expression<'tree>,
1571}
1572impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
1573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1574 fn from_node(
1575 node: ::treesitter_types::tree_sitter::Node<'tree>,
1576 src: &'tree [u8],
1577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1578 debug_assert_eq!(node.kind(), "await_expression");
1579 Ok(Self {
1580 span: ::treesitter_types::Span::from(node),
1581 children: {
1582 #[allow(clippy::suspicious_else_formatting)]
1583 let non_field_children = {
1584 let mut cursor = node.walk();
1585 let mut result = ::std::vec::Vec::new();
1586 if cursor.goto_first_child() {
1587 loop {
1588 if cursor.field_name().is_none()
1589 && cursor.node().is_named()
1590 && !cursor.node().is_extra()
1591 {
1592 result.push(cursor.node());
1593 }
1594 if !cursor.goto_next_sibling() {
1595 break;
1596 }
1597 }
1598 }
1599 result
1600 };
1601 let child = if let Some(&c) = non_field_children.first() {
1602 c
1603 } else {
1604 let mut fallback_cursor = node.walk();
1605 let mut fallback_child = None;
1606 if fallback_cursor.goto_first_child() {
1607 loop {
1608 if fallback_cursor.field_name().is_none()
1609 && !fallback_cursor.node().is_extra()
1610 {
1611 let candidate = fallback_cursor.node();
1612 #[allow(clippy::needless_question_mark)]
1613 if (|| -> ::core::result::Result<
1614 _,
1615 ::treesitter_types::ParseError,
1616 > {
1617 let child = candidate;
1618 Ok(
1619 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1620 child,
1621 src,
1622 ))?,
1623 )
1624 })()
1625 .is_ok()
1626 {
1627 fallback_child = Some(candidate);
1628 break;
1629 }
1630 }
1631 if !fallback_cursor.goto_next_sibling() {
1632 break;
1633 }
1634 }
1635 }
1636 if fallback_child.is_none() {
1637 let mut cursor2 = node.walk();
1638 if cursor2.goto_first_child() {
1639 loop {
1640 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1641 let candidate = cursor2.node();
1642 #[allow(clippy::needless_question_mark)]
1643 if (|| -> ::core::result::Result<
1644 _,
1645 ::treesitter_types::ParseError,
1646 > {
1647 let child = candidate;
1648 Ok(
1649 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1650 child,
1651 src,
1652 ))?,
1653 )
1654 })()
1655 .is_ok()
1656 {
1657 fallback_child = Some(candidate);
1658 break;
1659 }
1660 }
1661 if !cursor2.goto_next_sibling() {
1662 break;
1663 }
1664 }
1665 }
1666 }
1667 fallback_child.ok_or_else(|| {
1668 ::treesitter_types::ParseError::missing_field("children", node)
1669 })?
1670 };
1671 ::treesitter_types::runtime::maybe_grow_stack(|| {
1672 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1673 })?
1674 },
1675 })
1676 }
1677}
1678impl ::treesitter_types::Spanned for AwaitExpression<'_> {
1679 fn span(&self) -> ::treesitter_types::Span {
1680 self.span
1681 }
1682}
1683#[derive(Debug, Clone, PartialEq, Eq)]
1684pub struct BaseFieldInitializer<'tree> {
1685 pub span: ::treesitter_types::Span,
1686 pub children: Expression<'tree>,
1687}
1688impl<'tree> ::treesitter_types::FromNode<'tree> for BaseFieldInitializer<'tree> {
1689 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1690 fn from_node(
1691 node: ::treesitter_types::tree_sitter::Node<'tree>,
1692 src: &'tree [u8],
1693 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1694 debug_assert_eq!(node.kind(), "base_field_initializer");
1695 Ok(Self {
1696 span: ::treesitter_types::Span::from(node),
1697 children: {
1698 #[allow(clippy::suspicious_else_formatting)]
1699 let non_field_children = {
1700 let mut cursor = node.walk();
1701 let mut result = ::std::vec::Vec::new();
1702 if cursor.goto_first_child() {
1703 loop {
1704 if cursor.field_name().is_none()
1705 && cursor.node().is_named()
1706 && !cursor.node().is_extra()
1707 {
1708 result.push(cursor.node());
1709 }
1710 if !cursor.goto_next_sibling() {
1711 break;
1712 }
1713 }
1714 }
1715 result
1716 };
1717 let child = if let Some(&c) = non_field_children.first() {
1718 c
1719 } else {
1720 let mut fallback_cursor = node.walk();
1721 let mut fallback_child = None;
1722 if fallback_cursor.goto_first_child() {
1723 loop {
1724 if fallback_cursor.field_name().is_none()
1725 && !fallback_cursor.node().is_extra()
1726 {
1727 let candidate = fallback_cursor.node();
1728 #[allow(clippy::needless_question_mark)]
1729 if (|| -> ::core::result::Result<
1730 _,
1731 ::treesitter_types::ParseError,
1732 > {
1733 let child = candidate;
1734 Ok(
1735 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1736 child,
1737 src,
1738 ))?,
1739 )
1740 })()
1741 .is_ok()
1742 {
1743 fallback_child = Some(candidate);
1744 break;
1745 }
1746 }
1747 if !fallback_cursor.goto_next_sibling() {
1748 break;
1749 }
1750 }
1751 }
1752 if fallback_child.is_none() {
1753 let mut cursor2 = node.walk();
1754 if cursor2.goto_first_child() {
1755 loop {
1756 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1757 let candidate = cursor2.node();
1758 #[allow(clippy::needless_question_mark)]
1759 if (|| -> ::core::result::Result<
1760 _,
1761 ::treesitter_types::ParseError,
1762 > {
1763 let child = candidate;
1764 Ok(
1765 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1766 child,
1767 src,
1768 ))?,
1769 )
1770 })()
1771 .is_ok()
1772 {
1773 fallback_child = Some(candidate);
1774 break;
1775 }
1776 }
1777 if !cursor2.goto_next_sibling() {
1778 break;
1779 }
1780 }
1781 }
1782 }
1783 fallback_child.ok_or_else(|| {
1784 ::treesitter_types::ParseError::missing_field("children", node)
1785 })?
1786 };
1787 ::treesitter_types::runtime::maybe_grow_stack(|| {
1788 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1789 })?
1790 },
1791 })
1792 }
1793}
1794impl ::treesitter_types::Spanned for BaseFieldInitializer<'_> {
1795 fn span(&self) -> ::treesitter_types::Span {
1796 self.span
1797 }
1798}
1799#[derive(Debug, Clone, PartialEq, Eq)]
1800pub struct BinaryExpression<'tree> {
1801 pub span: ::treesitter_types::Span,
1802 pub left: Expression<'tree>,
1803 pub operator: BinaryExpressionOperator,
1804 pub right: Expression<'tree>,
1805}
1806impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1807 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1808 fn from_node(
1809 node: ::treesitter_types::tree_sitter::Node<'tree>,
1810 src: &'tree [u8],
1811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1812 debug_assert_eq!(node.kind(), "binary_expression");
1813 Ok(Self {
1814 span: ::treesitter_types::Span::from(node),
1815 left: {
1816 let child = node
1817 .child_by_field_name("left")
1818 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1819 ::treesitter_types::runtime::maybe_grow_stack(|| {
1820 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1821 })?
1822 },
1823 operator: {
1824 let child = node.child_by_field_name("operator").ok_or_else(|| {
1825 ::treesitter_types::ParseError::missing_field("operator", node)
1826 })?;
1827 ::treesitter_types::runtime::maybe_grow_stack(|| {
1828 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
1829 child, src,
1830 )
1831 })?
1832 },
1833 right: {
1834 let child = node
1835 .child_by_field_name("right")
1836 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1837 ::treesitter_types::runtime::maybe_grow_stack(|| {
1838 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1839 })?
1840 },
1841 })
1842 }
1843}
1844impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1845 fn span(&self) -> ::treesitter_types::Span {
1846 self.span
1847 }
1848}
1849#[derive(Debug, Clone, PartialEq, Eq)]
1850pub struct Block<'tree> {
1851 pub span: ::treesitter_types::Span,
1852 pub children: ::std::vec::Vec<BlockChildren<'tree>>,
1853}
1854impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1855 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1856 fn from_node(
1857 node: ::treesitter_types::tree_sitter::Node<'tree>,
1858 src: &'tree [u8],
1859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1860 debug_assert_eq!(node.kind(), "block");
1861 Ok(Self {
1862 span: ::treesitter_types::Span::from(node),
1863 children: {
1864 #[allow(clippy::suspicious_else_formatting)]
1865 let non_field_children = {
1866 let mut cursor = node.walk();
1867 let mut result = ::std::vec::Vec::new();
1868 if cursor.goto_first_child() {
1869 loop {
1870 if cursor.field_name().is_none()
1871 && cursor.node().is_named()
1872 && !cursor.node().is_extra()
1873 {
1874 result.push(cursor.node());
1875 }
1876 if !cursor.goto_next_sibling() {
1877 break;
1878 }
1879 }
1880 }
1881 result
1882 };
1883 let mut items = ::std::vec::Vec::new();
1884 for child in non_field_children {
1885 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1886 <BlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
1887 })?);
1888 }
1889 items
1890 },
1891 })
1892 }
1893}
1894impl ::treesitter_types::Spanned for Block<'_> {
1895 fn span(&self) -> ::treesitter_types::Span {
1896 self.span
1897 }
1898}
1899#[derive(Debug, Clone, PartialEq, Eq)]
1900pub struct BlockComment<'tree> {
1901 pub span: ::treesitter_types::Span,
1902 pub doc: ::core::option::Option<DocComment<'tree>>,
1903 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
1904 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
1905}
1906impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
1907 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1908 fn from_node(
1909 node: ::treesitter_types::tree_sitter::Node<'tree>,
1910 src: &'tree [u8],
1911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1912 debug_assert_eq!(node.kind(), "block_comment");
1913 Ok(Self {
1914 span: ::treesitter_types::Span::from(node),
1915 doc: match node.child_by_field_name("doc") {
1916 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1917 <DocComment as ::treesitter_types::FromNode>::from_node(child, src)
1918 })?),
1919 None => None,
1920 },
1921 inner: match node.child_by_field_name("inner") {
1922 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1923 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)
1924 })?),
1925 None => None,
1926 },
1927 outer: match node.child_by_field_name("outer") {
1928 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1929 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)
1930 })?),
1931 None => None,
1932 },
1933 })
1934 }
1935}
1936impl ::treesitter_types::Spanned for BlockComment<'_> {
1937 fn span(&self) -> ::treesitter_types::Span {
1938 self.span
1939 }
1940}
1941#[derive(Debug, Clone, PartialEq, Eq)]
1942pub struct BooleanLiteral<'tree> {
1943 pub span: ::treesitter_types::Span,
1944 text: &'tree str,
1945}
1946impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
1947 fn from_node(
1948 node: ::treesitter_types::tree_sitter::Node<'tree>,
1949 src: &'tree [u8],
1950 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1951 debug_assert_eq!(node.kind(), "boolean_literal");
1952 Ok(Self {
1953 span: ::treesitter_types::Span::from(node),
1954 text: node.utf8_text(src)?,
1955 })
1956 }
1957}
1958impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
1959 fn text(&self) -> &'tree str {
1960 self.text
1961 }
1962}
1963impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
1964 fn span(&self) -> ::treesitter_types::Span {
1965 self.span
1966 }
1967}
1968#[derive(Debug, Clone, PartialEq, Eq)]
1969pub struct BoundedType<'tree> {
1970 pub span: ::treesitter_types::Span,
1971 pub children: ::std::vec::Vec<BoundedTypeChildren<'tree>>,
1972}
1973impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedType<'tree> {
1974 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1975 fn from_node(
1976 node: ::treesitter_types::tree_sitter::Node<'tree>,
1977 src: &'tree [u8],
1978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1979 debug_assert_eq!(node.kind(), "bounded_type");
1980 Ok(Self {
1981 span: ::treesitter_types::Span::from(node),
1982 children: {
1983 #[allow(clippy::suspicious_else_formatting)]
1984 let non_field_children = {
1985 let mut cursor = node.walk();
1986 let mut result = ::std::vec::Vec::new();
1987 if cursor.goto_first_child() {
1988 loop {
1989 if cursor.field_name().is_none()
1990 && cursor.node().is_named()
1991 && !cursor.node().is_extra()
1992 {
1993 result.push(cursor.node());
1994 }
1995 if !cursor.goto_next_sibling() {
1996 break;
1997 }
1998 }
1999 }
2000 result
2001 };
2002 let mut items = ::std::vec::Vec::new();
2003 for child in non_field_children {
2004 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2005 <BoundedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
2006 })?);
2007 }
2008 items
2009 },
2010 })
2011 }
2012}
2013impl ::treesitter_types::Spanned for BoundedType<'_> {
2014 fn span(&self) -> ::treesitter_types::Span {
2015 self.span
2016 }
2017}
2018#[derive(Debug, Clone, PartialEq, Eq)]
2019pub struct BracketedType<'tree> {
2020 pub span: ::treesitter_types::Span,
2021 pub children: BracketedTypeChildren<'tree>,
2022}
2023impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedType<'tree> {
2024 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2025 fn from_node(
2026 node: ::treesitter_types::tree_sitter::Node<'tree>,
2027 src: &'tree [u8],
2028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2029 debug_assert_eq!(node.kind(), "bracketed_type");
2030 Ok(Self {
2031 span: ::treesitter_types::Span::from(node),
2032 children: {
2033 #[allow(clippy::suspicious_else_formatting)]
2034 let non_field_children = {
2035 let mut cursor = node.walk();
2036 let mut result = ::std::vec::Vec::new();
2037 if cursor.goto_first_child() {
2038 loop {
2039 if cursor.field_name().is_none()
2040 && cursor.node().is_named()
2041 && !cursor.node().is_extra()
2042 {
2043 result.push(cursor.node());
2044 }
2045 if !cursor.goto_next_sibling() {
2046 break;
2047 }
2048 }
2049 }
2050 result
2051 };
2052 let child = if let Some(&c) = non_field_children.first() {
2053 c
2054 } else {
2055 let mut fallback_cursor = node.walk();
2056 let mut fallback_child = None;
2057 if fallback_cursor.goto_first_child() {
2058 loop {
2059 if fallback_cursor.field_name().is_none()
2060 && !fallback_cursor.node().is_extra()
2061 {
2062 let candidate = fallback_cursor.node();
2063 #[allow(clippy::needless_question_mark)]
2064 if (|| -> ::core::result::Result<
2065 _,
2066 ::treesitter_types::ParseError,
2067 > {
2068 let child = candidate;
2069 Ok(
2070 ::treesitter_types::runtime::maybe_grow_stack(|| <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(
2071 child,
2072 src,
2073 ))?,
2074 )
2075 })()
2076 .is_ok()
2077 {
2078 fallback_child = Some(candidate);
2079 break;
2080 }
2081 }
2082 if !fallback_cursor.goto_next_sibling() {
2083 break;
2084 }
2085 }
2086 }
2087 if fallback_child.is_none() {
2088 let mut cursor2 = node.walk();
2089 if cursor2.goto_first_child() {
2090 loop {
2091 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2092 let candidate = cursor2.node();
2093 #[allow(clippy::needless_question_mark)]
2094 if (|| -> ::core::result::Result<
2095 _,
2096 ::treesitter_types::ParseError,
2097 > {
2098 let child = candidate;
2099 Ok(
2100 ::treesitter_types::runtime::maybe_grow_stack(|| <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(
2101 child,
2102 src,
2103 ))?,
2104 )
2105 })()
2106 .is_ok()
2107 {
2108 fallback_child = Some(candidate);
2109 break;
2110 }
2111 }
2112 if !cursor2.goto_next_sibling() {
2113 break;
2114 }
2115 }
2116 }
2117 }
2118 fallback_child.ok_or_else(|| {
2119 ::treesitter_types::ParseError::missing_field("children", node)
2120 })?
2121 };
2122 ::treesitter_types::runtime::maybe_grow_stack(|| {
2123 <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
2124 })?
2125 },
2126 })
2127 }
2128}
2129impl ::treesitter_types::Spanned for BracketedType<'_> {
2130 fn span(&self) -> ::treesitter_types::Span {
2131 self.span
2132 }
2133}
2134#[derive(Debug, Clone, PartialEq, Eq)]
2135pub struct BreakExpression<'tree> {
2136 pub span: ::treesitter_types::Span,
2137 pub children: ::std::vec::Vec<BreakExpressionChildren<'tree>>,
2138}
2139impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpression<'tree> {
2140 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2141 fn from_node(
2142 node: ::treesitter_types::tree_sitter::Node<'tree>,
2143 src: &'tree [u8],
2144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2145 debug_assert_eq!(node.kind(), "break_expression");
2146 Ok(Self {
2147 span: ::treesitter_types::Span::from(node),
2148 children: {
2149 #[allow(clippy::suspicious_else_formatting)]
2150 let non_field_children = {
2151 let mut cursor = node.walk();
2152 let mut result = ::std::vec::Vec::new();
2153 if cursor.goto_first_child() {
2154 loop {
2155 if cursor.field_name().is_none()
2156 && cursor.node().is_named()
2157 && !cursor.node().is_extra()
2158 {
2159 result.push(cursor.node());
2160 }
2161 if !cursor.goto_next_sibling() {
2162 break;
2163 }
2164 }
2165 }
2166 result
2167 };
2168 let mut items = ::std::vec::Vec::new();
2169 for child in non_field_children {
2170 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2171 <BreakExpressionChildren as ::treesitter_types::FromNode>::from_node(
2172 child, src,
2173 )
2174 })?);
2175 }
2176 items
2177 },
2178 })
2179 }
2180}
2181impl ::treesitter_types::Spanned for BreakExpression<'_> {
2182 fn span(&self) -> ::treesitter_types::Span {
2183 self.span
2184 }
2185}
2186#[derive(Debug, Clone, PartialEq, Eq)]
2187pub struct CallExpression<'tree> {
2188 pub span: ::treesitter_types::Span,
2189 pub arguments: Arguments<'tree>,
2190 pub function: CallExpressionFunction<'tree>,
2191}
2192impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
2193 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2194 fn from_node(
2195 node: ::treesitter_types::tree_sitter::Node<'tree>,
2196 src: &'tree [u8],
2197 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2198 debug_assert_eq!(node.kind(), "call_expression");
2199 Ok(Self {
2200 span: ::treesitter_types::Span::from(node),
2201 arguments: {
2202 let child = node.child_by_field_name("arguments").ok_or_else(|| {
2203 ::treesitter_types::ParseError::missing_field("arguments", node)
2204 })?;
2205 ::treesitter_types::runtime::maybe_grow_stack(|| {
2206 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
2207 })?
2208 },
2209 function: {
2210 let child = node.child_by_field_name("function").ok_or_else(|| {
2211 ::treesitter_types::ParseError::missing_field("function", node)
2212 })?;
2213 ::treesitter_types::runtime::maybe_grow_stack(|| {
2214 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)
2215 })?
2216 },
2217 })
2218 }
2219}
2220impl ::treesitter_types::Spanned for CallExpression<'_> {
2221 fn span(&self) -> ::treesitter_types::Span {
2222 self.span
2223 }
2224}
2225#[derive(Debug, Clone, PartialEq, Eq)]
2226pub struct CapturedPattern<'tree> {
2227 pub span: ::treesitter_types::Span,
2228 pub children: ::std::vec::Vec<Pattern<'tree>>,
2229}
2230impl<'tree> ::treesitter_types::FromNode<'tree> for CapturedPattern<'tree> {
2231 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2232 fn from_node(
2233 node: ::treesitter_types::tree_sitter::Node<'tree>,
2234 src: &'tree [u8],
2235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2236 debug_assert_eq!(node.kind(), "captured_pattern");
2237 Ok(Self {
2238 span: ::treesitter_types::Span::from(node),
2239 children: {
2240 #[allow(clippy::suspicious_else_formatting)]
2241 let non_field_children = {
2242 let mut cursor = node.walk();
2243 let mut result = ::std::vec::Vec::new();
2244 if cursor.goto_first_child() {
2245 loop {
2246 if cursor.field_name().is_none()
2247 && cursor.node().is_named()
2248 && !cursor.node().is_extra()
2249 {
2250 result.push(cursor.node());
2251 }
2252 if !cursor.goto_next_sibling() {
2253 break;
2254 }
2255 }
2256 }
2257 result
2258 };
2259 let mut items = ::std::vec::Vec::new();
2260 for child in non_field_children {
2261 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2262 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
2263 })?);
2264 }
2265 items
2266 },
2267 })
2268 }
2269}
2270impl ::treesitter_types::Spanned for CapturedPattern<'_> {
2271 fn span(&self) -> ::treesitter_types::Span {
2272 self.span
2273 }
2274}
2275#[derive(Debug, Clone, PartialEq, Eq)]
2276pub struct ClosureExpression<'tree> {
2277 pub span: ::treesitter_types::Span,
2278 pub body: ClosureExpressionBody<'tree>,
2279 pub parameters: ClosureParameters<'tree>,
2280 pub return_type: ::core::option::Option<Type<'tree>>,
2281}
2282impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpression<'tree> {
2283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2284 fn from_node(
2285 node: ::treesitter_types::tree_sitter::Node<'tree>,
2286 src: &'tree [u8],
2287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2288 debug_assert_eq!(node.kind(), "closure_expression");
2289 Ok(Self {
2290 span: ::treesitter_types::Span::from(node),
2291 body: {
2292 let child = node
2293 .child_by_field_name("body")
2294 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2295 ::treesitter_types::runtime::maybe_grow_stack(|| {
2296 <ClosureExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)
2297 })?
2298 },
2299 parameters: {
2300 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2301 ::treesitter_types::ParseError::missing_field("parameters", node)
2302 })?;
2303 ::treesitter_types::runtime::maybe_grow_stack(|| {
2304 <ClosureParameters as ::treesitter_types::FromNode>::from_node(child, src)
2305 })?
2306 },
2307 return_type: match node.child_by_field_name("return_type") {
2308 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2309 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2310 })?),
2311 None => None,
2312 },
2313 })
2314 }
2315}
2316impl ::treesitter_types::Spanned for ClosureExpression<'_> {
2317 fn span(&self) -> ::treesitter_types::Span {
2318 self.span
2319 }
2320}
2321#[derive(Debug, Clone, PartialEq, Eq)]
2322pub struct ClosureParameters<'tree> {
2323 pub span: ::treesitter_types::Span,
2324 pub children: ::std::vec::Vec<ClosureParametersChildren<'tree>>,
2325}
2326impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParameters<'tree> {
2327 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2328 fn from_node(
2329 node: ::treesitter_types::tree_sitter::Node<'tree>,
2330 src: &'tree [u8],
2331 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2332 debug_assert_eq!(node.kind(), "closure_parameters");
2333 Ok(Self {
2334 span: ::treesitter_types::Span::from(node),
2335 children: {
2336 #[allow(clippy::suspicious_else_formatting)]
2337 let non_field_children = {
2338 let mut cursor = node.walk();
2339 let mut result = ::std::vec::Vec::new();
2340 if cursor.goto_first_child() {
2341 loop {
2342 if cursor.field_name().is_none()
2343 && cursor.node().is_named()
2344 && !cursor.node().is_extra()
2345 {
2346 result.push(cursor.node());
2347 }
2348 if !cursor.goto_next_sibling() {
2349 break;
2350 }
2351 }
2352 }
2353 result
2354 };
2355 let mut items = ::std::vec::Vec::new();
2356 for child in non_field_children {
2357 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2358 <ClosureParametersChildren as ::treesitter_types::FromNode>::from_node(
2359 child, src,
2360 )
2361 })?);
2362 }
2363 items
2364 },
2365 })
2366 }
2367}
2368impl ::treesitter_types::Spanned for ClosureParameters<'_> {
2369 fn span(&self) -> ::treesitter_types::Span {
2370 self.span
2371 }
2372}
2373#[derive(Debug, Clone, PartialEq, Eq)]
2374pub struct CompoundAssignmentExpr<'tree> {
2375 pub span: ::treesitter_types::Span,
2376 pub left: Expression<'tree>,
2377 pub operator: CompoundAssignmentExprOperator,
2378 pub right: Expression<'tree>,
2379}
2380impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExpr<'tree> {
2381 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2382 fn from_node(
2383 node: ::treesitter_types::tree_sitter::Node<'tree>,
2384 src: &'tree [u8],
2385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2386 debug_assert_eq!(node.kind(), "compound_assignment_expr");
2387 Ok(Self {
2388 span: ::treesitter_types::Span::from(node),
2389 left: {
2390 let child = node
2391 .child_by_field_name("left")
2392 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2393 ::treesitter_types::runtime::maybe_grow_stack(|| {
2394 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2395 })?
2396 },
2397 operator: {
2398 let child = node.child_by_field_name("operator").ok_or_else(|| {
2399 ::treesitter_types::ParseError::missing_field("operator", node)
2400 })?;
2401 ::treesitter_types::runtime::maybe_grow_stack(|| {
2402 <CompoundAssignmentExprOperator as ::treesitter_types::FromNode>::from_node(
2403 child, src,
2404 )
2405 })?
2406 },
2407 right: {
2408 let child = node
2409 .child_by_field_name("right")
2410 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2411 ::treesitter_types::runtime::maybe_grow_stack(|| {
2412 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2413 })?
2414 },
2415 })
2416 }
2417}
2418impl ::treesitter_types::Spanned for CompoundAssignmentExpr<'_> {
2419 fn span(&self) -> ::treesitter_types::Span {
2420 self.span
2421 }
2422}
2423#[derive(Debug, Clone, PartialEq, Eq)]
2424pub struct ConstBlock<'tree> {
2425 pub span: ::treesitter_types::Span,
2426 pub body: Block<'tree>,
2427}
2428impl<'tree> ::treesitter_types::FromNode<'tree> for ConstBlock<'tree> {
2429 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2430 fn from_node(
2431 node: ::treesitter_types::tree_sitter::Node<'tree>,
2432 src: &'tree [u8],
2433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2434 debug_assert_eq!(node.kind(), "const_block");
2435 Ok(Self {
2436 span: ::treesitter_types::Span::from(node),
2437 body: {
2438 let child = node
2439 .child_by_field_name("body")
2440 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2441 ::treesitter_types::runtime::maybe_grow_stack(|| {
2442 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2443 })?
2444 },
2445 })
2446 }
2447}
2448impl ::treesitter_types::Spanned for ConstBlock<'_> {
2449 fn span(&self) -> ::treesitter_types::Span {
2450 self.span
2451 }
2452}
2453#[derive(Debug, Clone, PartialEq, Eq)]
2454pub struct ConstItem<'tree> {
2455 pub span: ::treesitter_types::Span,
2456 pub name: Identifier<'tree>,
2457 pub r#type: Type<'tree>,
2458 pub value: ::core::option::Option<Expression<'tree>>,
2459 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2460}
2461impl<'tree> ::treesitter_types::FromNode<'tree> for ConstItem<'tree> {
2462 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2463 fn from_node(
2464 node: ::treesitter_types::tree_sitter::Node<'tree>,
2465 src: &'tree [u8],
2466 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2467 debug_assert_eq!(node.kind(), "const_item");
2468 Ok(Self {
2469 span: ::treesitter_types::Span::from(node),
2470 name: {
2471 let child = node
2472 .child_by_field_name("name")
2473 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2474 ::treesitter_types::runtime::maybe_grow_stack(|| {
2475 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2476 })?
2477 },
2478 r#type: {
2479 let child = node
2480 .child_by_field_name("type")
2481 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2482 ::treesitter_types::runtime::maybe_grow_stack(|| {
2483 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2484 })?
2485 },
2486 value: match node.child_by_field_name("value") {
2487 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2488 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2489 })?),
2490 None => None,
2491 },
2492 children: {
2493 #[allow(clippy::suspicious_else_formatting)]
2494 let non_field_children = {
2495 let mut cursor = node.walk();
2496 let mut result = ::std::vec::Vec::new();
2497 if cursor.goto_first_child() {
2498 loop {
2499 if cursor.field_name().is_none()
2500 && cursor.node().is_named()
2501 && !cursor.node().is_extra()
2502 {
2503 result.push(cursor.node());
2504 }
2505 if !cursor.goto_next_sibling() {
2506 break;
2507 }
2508 }
2509 }
2510 result
2511 };
2512 match non_field_children.first() {
2513 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2514 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
2515 })?),
2516 None => None,
2517 }
2518 },
2519 })
2520 }
2521}
2522impl ::treesitter_types::Spanned for ConstItem<'_> {
2523 fn span(&self) -> ::treesitter_types::Span {
2524 self.span
2525 }
2526}
2527#[derive(Debug, Clone, PartialEq, Eq)]
2528pub struct ConstParameter<'tree> {
2529 pub span: ::treesitter_types::Span,
2530 pub name: Identifier<'tree>,
2531 pub r#type: Type<'tree>,
2532 pub value: ::core::option::Option<ConstParameterValue<'tree>>,
2533}
2534impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameter<'tree> {
2535 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2536 fn from_node(
2537 node: ::treesitter_types::tree_sitter::Node<'tree>,
2538 src: &'tree [u8],
2539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2540 debug_assert_eq!(node.kind(), "const_parameter");
2541 Ok(Self {
2542 span: ::treesitter_types::Span::from(node),
2543 name: {
2544 let child = node
2545 .child_by_field_name("name")
2546 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2547 ::treesitter_types::runtime::maybe_grow_stack(|| {
2548 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2549 })?
2550 },
2551 r#type: {
2552 let child = node
2553 .child_by_field_name("type")
2554 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2555 ::treesitter_types::runtime::maybe_grow_stack(|| {
2556 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2557 })?
2558 },
2559 value: match node.child_by_field_name("value") {
2560 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2561 <ConstParameterValue as ::treesitter_types::FromNode>::from_node(child, src)
2562 })?),
2563 None => None,
2564 },
2565 })
2566 }
2567}
2568impl ::treesitter_types::Spanned for ConstParameter<'_> {
2569 fn span(&self) -> ::treesitter_types::Span {
2570 self.span
2571 }
2572}
2573#[derive(Debug, Clone, PartialEq, Eq)]
2574pub struct ContinueExpression<'tree> {
2575 pub span: ::treesitter_types::Span,
2576 pub children: ::core::option::Option<Label<'tree>>,
2577}
2578impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueExpression<'tree> {
2579 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2580 fn from_node(
2581 node: ::treesitter_types::tree_sitter::Node<'tree>,
2582 src: &'tree [u8],
2583 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2584 debug_assert_eq!(node.kind(), "continue_expression");
2585 Ok(Self {
2586 span: ::treesitter_types::Span::from(node),
2587 children: {
2588 #[allow(clippy::suspicious_else_formatting)]
2589 let non_field_children = {
2590 let mut cursor = node.walk();
2591 let mut result = ::std::vec::Vec::new();
2592 if cursor.goto_first_child() {
2593 loop {
2594 if cursor.field_name().is_none()
2595 && cursor.node().is_named()
2596 && !cursor.node().is_extra()
2597 {
2598 result.push(cursor.node());
2599 }
2600 if !cursor.goto_next_sibling() {
2601 break;
2602 }
2603 }
2604 }
2605 result
2606 };
2607 match non_field_children.first() {
2608 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2609 <Label as ::treesitter_types::FromNode>::from_node(child, src)
2610 })?),
2611 None => None,
2612 }
2613 },
2614 })
2615 }
2616}
2617impl ::treesitter_types::Spanned for ContinueExpression<'_> {
2618 fn span(&self) -> ::treesitter_types::Span {
2619 self.span
2620 }
2621}
2622#[derive(Debug, Clone, PartialEq, Eq)]
2623pub struct DeclarationList<'tree> {
2624 pub span: ::treesitter_types::Span,
2625 pub children: ::std::vec::Vec<DeclarationStatement<'tree>>,
2626}
2627impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2628 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2629 fn from_node(
2630 node: ::treesitter_types::tree_sitter::Node<'tree>,
2631 src: &'tree [u8],
2632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2633 debug_assert_eq!(node.kind(), "declaration_list");
2634 Ok(Self {
2635 span: ::treesitter_types::Span::from(node),
2636 children: {
2637 #[allow(clippy::suspicious_else_formatting)]
2638 let non_field_children = {
2639 let mut cursor = node.walk();
2640 let mut result = ::std::vec::Vec::new();
2641 if cursor.goto_first_child() {
2642 loop {
2643 if cursor.field_name().is_none()
2644 && cursor.node().is_named()
2645 && !cursor.node().is_extra()
2646 {
2647 result.push(cursor.node());
2648 }
2649 if !cursor.goto_next_sibling() {
2650 break;
2651 }
2652 }
2653 }
2654 result
2655 };
2656 let mut items = ::std::vec::Vec::new();
2657 for child in non_field_children {
2658 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2659 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(
2660 child, src,
2661 )
2662 })?);
2663 }
2664 items
2665 },
2666 })
2667 }
2668}
2669impl ::treesitter_types::Spanned for DeclarationList<'_> {
2670 fn span(&self) -> ::treesitter_types::Span {
2671 self.span
2672 }
2673}
2674#[derive(Debug, Clone, PartialEq, Eq)]
2675pub struct DynamicType<'tree> {
2676 pub span: ::treesitter_types::Span,
2677 pub r#trait: DynamicTypeTrait<'tree>,
2678}
2679impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicType<'tree> {
2680 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2681 fn from_node(
2682 node: ::treesitter_types::tree_sitter::Node<'tree>,
2683 src: &'tree [u8],
2684 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2685 debug_assert_eq!(node.kind(), "dynamic_type");
2686 Ok(Self {
2687 span: ::treesitter_types::Span::from(node),
2688 r#trait: {
2689 let child = node
2690 .child_by_field_name("trait")
2691 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("trait", node))?;
2692 ::treesitter_types::runtime::maybe_grow_stack(|| {
2693 <DynamicTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)
2694 })?
2695 },
2696 })
2697 }
2698}
2699impl ::treesitter_types::Spanned for DynamicType<'_> {
2700 fn span(&self) -> ::treesitter_types::Span {
2701 self.span
2702 }
2703}
2704#[derive(Debug, Clone, PartialEq, Eq)]
2705pub struct ElseClause<'tree> {
2706 pub span: ::treesitter_types::Span,
2707 pub children: ElseClauseChildren<'tree>,
2708}
2709impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
2710 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2711 fn from_node(
2712 node: ::treesitter_types::tree_sitter::Node<'tree>,
2713 src: &'tree [u8],
2714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2715 debug_assert_eq!(node.kind(), "else_clause");
2716 Ok(Self {
2717 span: ::treesitter_types::Span::from(node),
2718 children: {
2719 #[allow(clippy::suspicious_else_formatting)]
2720 let non_field_children = {
2721 let mut cursor = node.walk();
2722 let mut result = ::std::vec::Vec::new();
2723 if cursor.goto_first_child() {
2724 loop {
2725 if cursor.field_name().is_none()
2726 && cursor.node().is_named()
2727 && !cursor.node().is_extra()
2728 {
2729 result.push(cursor.node());
2730 }
2731 if !cursor.goto_next_sibling() {
2732 break;
2733 }
2734 }
2735 }
2736 result
2737 };
2738 let child = if let Some(&c) = non_field_children.first() {
2739 c
2740 } else {
2741 let mut fallback_cursor = node.walk();
2742 let mut fallback_child = None;
2743 if fallback_cursor.goto_first_child() {
2744 loop {
2745 if fallback_cursor.field_name().is_none()
2746 && !fallback_cursor.node().is_extra()
2747 {
2748 let candidate = fallback_cursor.node();
2749 #[allow(clippy::needless_question_mark)]
2750 if (|| -> ::core::result::Result<
2751 _,
2752 ::treesitter_types::ParseError,
2753 > {
2754 let child = candidate;
2755 Ok(
2756 ::treesitter_types::runtime::maybe_grow_stack(|| <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(
2757 child,
2758 src,
2759 ))?,
2760 )
2761 })()
2762 .is_ok()
2763 {
2764 fallback_child = Some(candidate);
2765 break;
2766 }
2767 }
2768 if !fallback_cursor.goto_next_sibling() {
2769 break;
2770 }
2771 }
2772 }
2773 if fallback_child.is_none() {
2774 let mut cursor2 = node.walk();
2775 if cursor2.goto_first_child() {
2776 loop {
2777 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2778 let candidate = cursor2.node();
2779 #[allow(clippy::needless_question_mark)]
2780 if (|| -> ::core::result::Result<
2781 _,
2782 ::treesitter_types::ParseError,
2783 > {
2784 let child = candidate;
2785 Ok(
2786 ::treesitter_types::runtime::maybe_grow_stack(|| <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(
2787 child,
2788 src,
2789 ))?,
2790 )
2791 })()
2792 .is_ok()
2793 {
2794 fallback_child = Some(candidate);
2795 break;
2796 }
2797 }
2798 if !cursor2.goto_next_sibling() {
2799 break;
2800 }
2801 }
2802 }
2803 }
2804 fallback_child.ok_or_else(|| {
2805 ::treesitter_types::ParseError::missing_field("children", node)
2806 })?
2807 };
2808 ::treesitter_types::runtime::maybe_grow_stack(|| {
2809 <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2810 })?
2811 },
2812 })
2813 }
2814}
2815impl ::treesitter_types::Spanned for ElseClause<'_> {
2816 fn span(&self) -> ::treesitter_types::Span {
2817 self.span
2818 }
2819}
2820#[derive(Debug, Clone, PartialEq, Eq)]
2821pub struct EmptyStatement<'tree> {
2822 pub span: ::treesitter_types::Span,
2823 text: &'tree str,
2824}
2825impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
2826 fn from_node(
2827 node: ::treesitter_types::tree_sitter::Node<'tree>,
2828 src: &'tree [u8],
2829 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2830 debug_assert_eq!(node.kind(), "empty_statement");
2831 Ok(Self {
2832 span: ::treesitter_types::Span::from(node),
2833 text: node.utf8_text(src)?,
2834 })
2835 }
2836}
2837impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
2838 fn text(&self) -> &'tree str {
2839 self.text
2840 }
2841}
2842impl ::treesitter_types::Spanned for EmptyStatement<'_> {
2843 fn span(&self) -> ::treesitter_types::Span {
2844 self.span
2845 }
2846}
2847#[derive(Debug, Clone, PartialEq, Eq)]
2848pub struct EnumItem<'tree> {
2849 pub span: ::treesitter_types::Span,
2850 pub body: EnumVariantList<'tree>,
2851 pub name: TypeIdentifier<'tree>,
2852 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2853 pub children: ::std::vec::Vec<EnumItemChildren<'tree>>,
2854}
2855impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItem<'tree> {
2856 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2857 fn from_node(
2858 node: ::treesitter_types::tree_sitter::Node<'tree>,
2859 src: &'tree [u8],
2860 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2861 debug_assert_eq!(node.kind(), "enum_item");
2862 Ok(Self {
2863 span: ::treesitter_types::Span::from(node),
2864 body: {
2865 let child = node
2866 .child_by_field_name("body")
2867 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2868 ::treesitter_types::runtime::maybe_grow_stack(|| {
2869 <EnumVariantList as ::treesitter_types::FromNode>::from_node(child, src)
2870 })?
2871 },
2872 name: {
2873 let child = node
2874 .child_by_field_name("name")
2875 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2876 ::treesitter_types::runtime::maybe_grow_stack(|| {
2877 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
2878 })?
2879 },
2880 type_parameters: match node.child_by_field_name("type_parameters") {
2881 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2882 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
2883 })?),
2884 None => None,
2885 },
2886 children: {
2887 #[allow(clippy::suspicious_else_formatting)]
2888 let non_field_children = {
2889 let mut cursor = node.walk();
2890 let mut result = ::std::vec::Vec::new();
2891 if cursor.goto_first_child() {
2892 loop {
2893 if cursor.field_name().is_none()
2894 && cursor.node().is_named()
2895 && !cursor.node().is_extra()
2896 {
2897 result.push(cursor.node());
2898 }
2899 if !cursor.goto_next_sibling() {
2900 break;
2901 }
2902 }
2903 }
2904 result
2905 };
2906 let mut items = ::std::vec::Vec::new();
2907 for child in non_field_children {
2908 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2909 <EnumItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
2910 })?);
2911 }
2912 items
2913 },
2914 })
2915 }
2916}
2917impl ::treesitter_types::Spanned for EnumItem<'_> {
2918 fn span(&self) -> ::treesitter_types::Span {
2919 self.span
2920 }
2921}
2922#[derive(Debug, Clone, PartialEq, Eq)]
2923pub struct EnumVariant<'tree> {
2924 pub span: ::treesitter_types::Span,
2925 pub body: ::core::option::Option<EnumVariantBody<'tree>>,
2926 pub name: Identifier<'tree>,
2927 pub value: ::core::option::Option<Expression<'tree>>,
2928 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2929}
2930impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariant<'tree> {
2931 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2932 fn from_node(
2933 node: ::treesitter_types::tree_sitter::Node<'tree>,
2934 src: &'tree [u8],
2935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2936 debug_assert_eq!(node.kind(), "enum_variant");
2937 Ok(Self {
2938 span: ::treesitter_types::Span::from(node),
2939 body: match node.child_by_field_name("body") {
2940 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2941 <EnumVariantBody as ::treesitter_types::FromNode>::from_node(child, src)
2942 })?),
2943 None => None,
2944 },
2945 name: {
2946 let child = node
2947 .child_by_field_name("name")
2948 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2949 ::treesitter_types::runtime::maybe_grow_stack(|| {
2950 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2951 })?
2952 },
2953 value: match node.child_by_field_name("value") {
2954 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2955 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2956 })?),
2957 None => None,
2958 },
2959 children: {
2960 #[allow(clippy::suspicious_else_formatting)]
2961 let non_field_children = {
2962 let mut cursor = node.walk();
2963 let mut result = ::std::vec::Vec::new();
2964 if cursor.goto_first_child() {
2965 loop {
2966 if cursor.field_name().is_none()
2967 && cursor.node().is_named()
2968 && !cursor.node().is_extra()
2969 {
2970 result.push(cursor.node());
2971 }
2972 if !cursor.goto_next_sibling() {
2973 break;
2974 }
2975 }
2976 }
2977 result
2978 };
2979 match non_field_children.first() {
2980 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2981 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
2982 })?),
2983 None => None,
2984 }
2985 },
2986 })
2987 }
2988}
2989impl ::treesitter_types::Spanned for EnumVariant<'_> {
2990 fn span(&self) -> ::treesitter_types::Span {
2991 self.span
2992 }
2993}
2994#[derive(Debug, Clone, PartialEq, Eq)]
2995pub struct EnumVariantList<'tree> {
2996 pub span: ::treesitter_types::Span,
2997 pub children: ::std::vec::Vec<EnumVariantListChildren<'tree>>,
2998}
2999impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantList<'tree> {
3000 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3001 fn from_node(
3002 node: ::treesitter_types::tree_sitter::Node<'tree>,
3003 src: &'tree [u8],
3004 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3005 debug_assert_eq!(node.kind(), "enum_variant_list");
3006 Ok(Self {
3007 span: ::treesitter_types::Span::from(node),
3008 children: {
3009 #[allow(clippy::suspicious_else_formatting)]
3010 let non_field_children = {
3011 let mut cursor = node.walk();
3012 let mut result = ::std::vec::Vec::new();
3013 if cursor.goto_first_child() {
3014 loop {
3015 if cursor.field_name().is_none()
3016 && cursor.node().is_named()
3017 && !cursor.node().is_extra()
3018 {
3019 result.push(cursor.node());
3020 }
3021 if !cursor.goto_next_sibling() {
3022 break;
3023 }
3024 }
3025 }
3026 result
3027 };
3028 let mut items = ::std::vec::Vec::new();
3029 for child in non_field_children {
3030 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3031 <EnumVariantListChildren as ::treesitter_types::FromNode>::from_node(
3032 child, src,
3033 )
3034 })?);
3035 }
3036 items
3037 },
3038 })
3039 }
3040}
3041impl ::treesitter_types::Spanned for EnumVariantList<'_> {
3042 fn span(&self) -> ::treesitter_types::Span {
3043 self.span
3044 }
3045}
3046#[derive(Debug, Clone, PartialEq, Eq)]
3047pub struct ExpressionStatement<'tree> {
3048 pub span: ::treesitter_types::Span,
3049 pub children: Expression<'tree>,
3050}
3051impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3052 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3053 fn from_node(
3054 node: ::treesitter_types::tree_sitter::Node<'tree>,
3055 src: &'tree [u8],
3056 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3057 debug_assert_eq!(node.kind(), "expression_statement");
3058 Ok(Self {
3059 span: ::treesitter_types::Span::from(node),
3060 children: {
3061 #[allow(clippy::suspicious_else_formatting)]
3062 let non_field_children = {
3063 let mut cursor = node.walk();
3064 let mut result = ::std::vec::Vec::new();
3065 if cursor.goto_first_child() {
3066 loop {
3067 if cursor.field_name().is_none()
3068 && cursor.node().is_named()
3069 && !cursor.node().is_extra()
3070 {
3071 result.push(cursor.node());
3072 }
3073 if !cursor.goto_next_sibling() {
3074 break;
3075 }
3076 }
3077 }
3078 result
3079 };
3080 let child = if let Some(&c) = non_field_children.first() {
3081 c
3082 } else {
3083 let mut fallback_cursor = node.walk();
3084 let mut fallback_child = None;
3085 if fallback_cursor.goto_first_child() {
3086 loop {
3087 if fallback_cursor.field_name().is_none()
3088 && !fallback_cursor.node().is_extra()
3089 {
3090 let candidate = fallback_cursor.node();
3091 #[allow(clippy::needless_question_mark)]
3092 if (|| -> ::core::result::Result<
3093 _,
3094 ::treesitter_types::ParseError,
3095 > {
3096 let child = candidate;
3097 Ok(
3098 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3099 child,
3100 src,
3101 ))?,
3102 )
3103 })()
3104 .is_ok()
3105 {
3106 fallback_child = Some(candidate);
3107 break;
3108 }
3109 }
3110 if !fallback_cursor.goto_next_sibling() {
3111 break;
3112 }
3113 }
3114 }
3115 if fallback_child.is_none() {
3116 let mut cursor2 = node.walk();
3117 if cursor2.goto_first_child() {
3118 loop {
3119 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3120 let candidate = cursor2.node();
3121 #[allow(clippy::needless_question_mark)]
3122 if (|| -> ::core::result::Result<
3123 _,
3124 ::treesitter_types::ParseError,
3125 > {
3126 let child = candidate;
3127 Ok(
3128 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3129 child,
3130 src,
3131 ))?,
3132 )
3133 })()
3134 .is_ok()
3135 {
3136 fallback_child = Some(candidate);
3137 break;
3138 }
3139 }
3140 if !cursor2.goto_next_sibling() {
3141 break;
3142 }
3143 }
3144 }
3145 }
3146 fallback_child.ok_or_else(|| {
3147 ::treesitter_types::ParseError::missing_field("children", node)
3148 })?
3149 };
3150 ::treesitter_types::runtime::maybe_grow_stack(|| {
3151 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3152 })?
3153 },
3154 })
3155 }
3156}
3157impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3158 fn span(&self) -> ::treesitter_types::Span {
3159 self.span
3160 }
3161}
3162#[derive(Debug, Clone, PartialEq, Eq)]
3163pub struct ExternCrateDeclaration<'tree> {
3164 pub span: ::treesitter_types::Span,
3165 pub alias: ::core::option::Option<Identifier<'tree>>,
3166 pub name: Identifier<'tree>,
3167 pub children: ::std::vec::Vec<ExternCrateDeclarationChildren<'tree>>,
3168}
3169impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclaration<'tree> {
3170 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3171 fn from_node(
3172 node: ::treesitter_types::tree_sitter::Node<'tree>,
3173 src: &'tree [u8],
3174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3175 debug_assert_eq!(node.kind(), "extern_crate_declaration");
3176 Ok(Self {
3177 span: ::treesitter_types::Span::from(node),
3178 alias: match node.child_by_field_name("alias") {
3179 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3180 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3181 })?),
3182 None => None,
3183 },
3184 name: {
3185 let child = node
3186 .child_by_field_name("name")
3187 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3188 ::treesitter_types::runtime::maybe_grow_stack(|| {
3189 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3190 })?
3191 },
3192 children: {
3193 #[allow(clippy::suspicious_else_formatting)]
3194 let non_field_children = {
3195 let mut cursor = node.walk();
3196 let mut result = ::std::vec::Vec::new();
3197 if cursor.goto_first_child() {
3198 loop {
3199 if cursor.field_name().is_none()
3200 && cursor.node().is_named()
3201 && !cursor.node().is_extra()
3202 {
3203 result.push(cursor.node());
3204 }
3205 if !cursor.goto_next_sibling() {
3206 break;
3207 }
3208 }
3209 }
3210 result
3211 };
3212 let mut items = ::std::vec::Vec::new();
3213 for child in non_field_children {
3214 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3215 <ExternCrateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3216 child, src,
3217 )
3218 })?);
3219 }
3220 items
3221 },
3222 })
3223 }
3224}
3225impl ::treesitter_types::Spanned for ExternCrateDeclaration<'_> {
3226 fn span(&self) -> ::treesitter_types::Span {
3227 self.span
3228 }
3229}
3230#[derive(Debug, Clone, PartialEq, Eq)]
3231pub struct ExternModifier<'tree> {
3232 pub span: ::treesitter_types::Span,
3233 pub children: ::core::option::Option<StringLiteral<'tree>>,
3234}
3235impl<'tree> ::treesitter_types::FromNode<'tree> for ExternModifier<'tree> {
3236 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3237 fn from_node(
3238 node: ::treesitter_types::tree_sitter::Node<'tree>,
3239 src: &'tree [u8],
3240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3241 debug_assert_eq!(node.kind(), "extern_modifier");
3242 Ok(Self {
3243 span: ::treesitter_types::Span::from(node),
3244 children: {
3245 #[allow(clippy::suspicious_else_formatting)]
3246 let non_field_children = {
3247 let mut cursor = node.walk();
3248 let mut result = ::std::vec::Vec::new();
3249 if cursor.goto_first_child() {
3250 loop {
3251 if cursor.field_name().is_none()
3252 && cursor.node().is_named()
3253 && !cursor.node().is_extra()
3254 {
3255 result.push(cursor.node());
3256 }
3257 if !cursor.goto_next_sibling() {
3258 break;
3259 }
3260 }
3261 }
3262 result
3263 };
3264 match non_field_children.first() {
3265 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3266 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
3267 })?),
3268 None => None,
3269 }
3270 },
3271 })
3272 }
3273}
3274impl ::treesitter_types::Spanned for ExternModifier<'_> {
3275 fn span(&self) -> ::treesitter_types::Span {
3276 self.span
3277 }
3278}
3279#[derive(Debug, Clone, PartialEq, Eq)]
3280pub struct FieldDeclaration<'tree> {
3281 pub span: ::treesitter_types::Span,
3282 pub name: FieldIdentifier<'tree>,
3283 pub r#type: Type<'tree>,
3284 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
3285}
3286impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
3287 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3288 fn from_node(
3289 node: ::treesitter_types::tree_sitter::Node<'tree>,
3290 src: &'tree [u8],
3291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3292 debug_assert_eq!(node.kind(), "field_declaration");
3293 Ok(Self {
3294 span: ::treesitter_types::Span::from(node),
3295 name: {
3296 let child = node
3297 .child_by_field_name("name")
3298 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3299 ::treesitter_types::runtime::maybe_grow_stack(|| {
3300 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3301 })?
3302 },
3303 r#type: {
3304 let child = node
3305 .child_by_field_name("type")
3306 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3307 ::treesitter_types::runtime::maybe_grow_stack(|| {
3308 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3309 })?
3310 },
3311 children: {
3312 #[allow(clippy::suspicious_else_formatting)]
3313 let non_field_children = {
3314 let mut cursor = node.walk();
3315 let mut result = ::std::vec::Vec::new();
3316 if cursor.goto_first_child() {
3317 loop {
3318 if cursor.field_name().is_none()
3319 && cursor.node().is_named()
3320 && !cursor.node().is_extra()
3321 {
3322 result.push(cursor.node());
3323 }
3324 if !cursor.goto_next_sibling() {
3325 break;
3326 }
3327 }
3328 }
3329 result
3330 };
3331 match non_field_children.first() {
3332 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3333 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
3334 })?),
3335 None => None,
3336 }
3337 },
3338 })
3339 }
3340}
3341impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
3342 fn span(&self) -> ::treesitter_types::Span {
3343 self.span
3344 }
3345}
3346#[derive(Debug, Clone, PartialEq, Eq)]
3347pub struct FieldDeclarationList<'tree> {
3348 pub span: ::treesitter_types::Span,
3349 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
3350}
3351impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
3352 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3353 fn from_node(
3354 node: ::treesitter_types::tree_sitter::Node<'tree>,
3355 src: &'tree [u8],
3356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3357 debug_assert_eq!(node.kind(), "field_declaration_list");
3358 Ok(Self {
3359 span: ::treesitter_types::Span::from(node),
3360 children: {
3361 #[allow(clippy::suspicious_else_formatting)]
3362 let non_field_children = {
3363 let mut cursor = node.walk();
3364 let mut result = ::std::vec::Vec::new();
3365 if cursor.goto_first_child() {
3366 loop {
3367 if cursor.field_name().is_none()
3368 && cursor.node().is_named()
3369 && !cursor.node().is_extra()
3370 {
3371 result.push(cursor.node());
3372 }
3373 if !cursor.goto_next_sibling() {
3374 break;
3375 }
3376 }
3377 }
3378 result
3379 };
3380 let mut items = ::std::vec::Vec::new();
3381 for child in non_field_children {
3382 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3383 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3384 child, src,
3385 )
3386 })?);
3387 }
3388 items
3389 },
3390 })
3391 }
3392}
3393impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
3394 fn span(&self) -> ::treesitter_types::Span {
3395 self.span
3396 }
3397}
3398#[derive(Debug, Clone, PartialEq, Eq)]
3399pub struct FieldExpression<'tree> {
3400 pub span: ::treesitter_types::Span,
3401 pub field: FieldExpressionField<'tree>,
3402 pub value: Expression<'tree>,
3403}
3404impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
3405 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3406 fn from_node(
3407 node: ::treesitter_types::tree_sitter::Node<'tree>,
3408 src: &'tree [u8],
3409 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3410 debug_assert_eq!(node.kind(), "field_expression");
3411 Ok(Self {
3412 span: ::treesitter_types::Span::from(node),
3413 field: {
3414 let child = node
3415 .child_by_field_name("field")
3416 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3417 ::treesitter_types::runtime::maybe_grow_stack(|| {
3418 <FieldExpressionField as ::treesitter_types::FromNode>::from_node(child, src)
3419 })?
3420 },
3421 value: {
3422 let child = node
3423 .child_by_field_name("value")
3424 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3425 ::treesitter_types::runtime::maybe_grow_stack(|| {
3426 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3427 })?
3428 },
3429 })
3430 }
3431}
3432impl ::treesitter_types::Spanned for FieldExpression<'_> {
3433 fn span(&self) -> ::treesitter_types::Span {
3434 self.span
3435 }
3436}
3437#[derive(Debug, Clone, PartialEq, Eq)]
3438pub struct FieldInitializer<'tree> {
3439 pub span: ::treesitter_types::Span,
3440 pub field: FieldInitializerField<'tree>,
3441 pub value: Expression<'tree>,
3442 pub children: ::std::vec::Vec<AttributeItem<'tree>>,
3443}
3444impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializer<'tree> {
3445 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3446 fn from_node(
3447 node: ::treesitter_types::tree_sitter::Node<'tree>,
3448 src: &'tree [u8],
3449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3450 debug_assert_eq!(node.kind(), "field_initializer");
3451 Ok(Self {
3452 span: ::treesitter_types::Span::from(node),
3453 field: {
3454 let child = node
3455 .child_by_field_name("field")
3456 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3457 ::treesitter_types::runtime::maybe_grow_stack(|| {
3458 <FieldInitializerField as ::treesitter_types::FromNode>::from_node(child, src)
3459 })?
3460 },
3461 value: {
3462 let child = node
3463 .child_by_field_name("value")
3464 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3465 ::treesitter_types::runtime::maybe_grow_stack(|| {
3466 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3467 })?
3468 },
3469 children: {
3470 #[allow(clippy::suspicious_else_formatting)]
3471 let non_field_children = {
3472 let mut cursor = node.walk();
3473 let mut result = ::std::vec::Vec::new();
3474 if cursor.goto_first_child() {
3475 loop {
3476 if cursor.field_name().is_none()
3477 && cursor.node().is_named()
3478 && !cursor.node().is_extra()
3479 {
3480 result.push(cursor.node());
3481 }
3482 if !cursor.goto_next_sibling() {
3483 break;
3484 }
3485 }
3486 }
3487 result
3488 };
3489 let mut items = ::std::vec::Vec::new();
3490 for child in non_field_children {
3491 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3492 <AttributeItem as ::treesitter_types::FromNode>::from_node(child, src)
3493 })?);
3494 }
3495 items
3496 },
3497 })
3498 }
3499}
3500impl ::treesitter_types::Spanned for FieldInitializer<'_> {
3501 fn span(&self) -> ::treesitter_types::Span {
3502 self.span
3503 }
3504}
3505#[derive(Debug, Clone, PartialEq, Eq)]
3506pub struct FieldInitializerList<'tree> {
3507 pub span: ::treesitter_types::Span,
3508 pub children: ::std::vec::Vec<FieldInitializerListChildren<'tree>>,
3509}
3510impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerList<'tree> {
3511 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3512 fn from_node(
3513 node: ::treesitter_types::tree_sitter::Node<'tree>,
3514 src: &'tree [u8],
3515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3516 debug_assert_eq!(node.kind(), "field_initializer_list");
3517 Ok(Self {
3518 span: ::treesitter_types::Span::from(node),
3519 children: {
3520 #[allow(clippy::suspicious_else_formatting)]
3521 let non_field_children = {
3522 let mut cursor = node.walk();
3523 let mut result = ::std::vec::Vec::new();
3524 if cursor.goto_first_child() {
3525 loop {
3526 if cursor.field_name().is_none()
3527 && cursor.node().is_named()
3528 && !cursor.node().is_extra()
3529 {
3530 result.push(cursor.node());
3531 }
3532 if !cursor.goto_next_sibling() {
3533 break;
3534 }
3535 }
3536 }
3537 result
3538 };
3539 let mut items = ::std::vec::Vec::new();
3540 for child in non_field_children {
3541 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3542 <FieldInitializerListChildren as ::treesitter_types::FromNode>::from_node(
3543 child, src,
3544 )
3545 })?);
3546 }
3547 items
3548 },
3549 })
3550 }
3551}
3552impl ::treesitter_types::Spanned for FieldInitializerList<'_> {
3553 fn span(&self) -> ::treesitter_types::Span {
3554 self.span
3555 }
3556}
3557#[derive(Debug, Clone, PartialEq, Eq)]
3558pub struct FieldPattern<'tree> {
3559 pub span: ::treesitter_types::Span,
3560 pub name: FieldPatternName<'tree>,
3561 pub pattern: ::core::option::Option<Pattern<'tree>>,
3562 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
3563}
3564impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPattern<'tree> {
3565 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3566 fn from_node(
3567 node: ::treesitter_types::tree_sitter::Node<'tree>,
3568 src: &'tree [u8],
3569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3570 debug_assert_eq!(node.kind(), "field_pattern");
3571 Ok(Self {
3572 span: ::treesitter_types::Span::from(node),
3573 name: {
3574 let child = node
3575 .child_by_field_name("name")
3576 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3577 ::treesitter_types::runtime::maybe_grow_stack(|| {
3578 <FieldPatternName as ::treesitter_types::FromNode>::from_node(child, src)
3579 })?
3580 },
3581 pattern: match node.child_by_field_name("pattern") {
3582 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3583 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
3584 })?),
3585 None => None,
3586 },
3587 children: {
3588 #[allow(clippy::suspicious_else_formatting)]
3589 let non_field_children = {
3590 let mut cursor = node.walk();
3591 let mut result = ::std::vec::Vec::new();
3592 if cursor.goto_first_child() {
3593 loop {
3594 if cursor.field_name().is_none()
3595 && cursor.node().is_named()
3596 && !cursor.node().is_extra()
3597 {
3598 result.push(cursor.node());
3599 }
3600 if !cursor.goto_next_sibling() {
3601 break;
3602 }
3603 }
3604 }
3605 result
3606 };
3607 match non_field_children.first() {
3608 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3609 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
3610 })?),
3611 None => None,
3612 }
3613 },
3614 })
3615 }
3616}
3617impl ::treesitter_types::Spanned for FieldPattern<'_> {
3618 fn span(&self) -> ::treesitter_types::Span {
3619 self.span
3620 }
3621}
3622#[derive(Debug, Clone, PartialEq, Eq)]
3623pub struct ForExpression<'tree> {
3624 pub span: ::treesitter_types::Span,
3625 pub body: Block<'tree>,
3626 pub pattern: Pattern<'tree>,
3627 pub value: Expression<'tree>,
3628 pub children: ::core::option::Option<Label<'tree>>,
3629}
3630impl<'tree> ::treesitter_types::FromNode<'tree> for ForExpression<'tree> {
3631 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3632 fn from_node(
3633 node: ::treesitter_types::tree_sitter::Node<'tree>,
3634 src: &'tree [u8],
3635 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3636 debug_assert_eq!(node.kind(), "for_expression");
3637 Ok(Self {
3638 span: ::treesitter_types::Span::from(node),
3639 body: {
3640 let child = node
3641 .child_by_field_name("body")
3642 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3643 ::treesitter_types::runtime::maybe_grow_stack(|| {
3644 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3645 })?
3646 },
3647 pattern: {
3648 let child = node.child_by_field_name("pattern").ok_or_else(|| {
3649 ::treesitter_types::ParseError::missing_field("pattern", node)
3650 })?;
3651 ::treesitter_types::runtime::maybe_grow_stack(|| {
3652 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
3653 })?
3654 },
3655 value: {
3656 let child = node
3657 .child_by_field_name("value")
3658 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3659 ::treesitter_types::runtime::maybe_grow_stack(|| {
3660 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3661 })?
3662 },
3663 children: {
3664 #[allow(clippy::suspicious_else_formatting)]
3665 let non_field_children = {
3666 let mut cursor = node.walk();
3667 let mut result = ::std::vec::Vec::new();
3668 if cursor.goto_first_child() {
3669 loop {
3670 if cursor.field_name().is_none()
3671 && cursor.node().is_named()
3672 && !cursor.node().is_extra()
3673 {
3674 result.push(cursor.node());
3675 }
3676 if !cursor.goto_next_sibling() {
3677 break;
3678 }
3679 }
3680 }
3681 result
3682 };
3683 match non_field_children.first() {
3684 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3685 <Label as ::treesitter_types::FromNode>::from_node(child, src)
3686 })?),
3687 None => None,
3688 }
3689 },
3690 })
3691 }
3692}
3693impl ::treesitter_types::Spanned for ForExpression<'_> {
3694 fn span(&self) -> ::treesitter_types::Span {
3695 self.span
3696 }
3697}
3698#[derive(Debug, Clone, PartialEq, Eq)]
3699pub struct ForLifetimes<'tree> {
3700 pub span: ::treesitter_types::Span,
3701 pub children: ::std::vec::Vec<Lifetime<'tree>>,
3702}
3703impl<'tree> ::treesitter_types::FromNode<'tree> for ForLifetimes<'tree> {
3704 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3705 fn from_node(
3706 node: ::treesitter_types::tree_sitter::Node<'tree>,
3707 src: &'tree [u8],
3708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3709 debug_assert_eq!(node.kind(), "for_lifetimes");
3710 Ok(Self {
3711 span: ::treesitter_types::Span::from(node),
3712 children: {
3713 #[allow(clippy::suspicious_else_formatting)]
3714 let non_field_children = {
3715 let mut cursor = node.walk();
3716 let mut result = ::std::vec::Vec::new();
3717 if cursor.goto_first_child() {
3718 loop {
3719 if cursor.field_name().is_none()
3720 && cursor.node().is_named()
3721 && !cursor.node().is_extra()
3722 {
3723 result.push(cursor.node());
3724 }
3725 if !cursor.goto_next_sibling() {
3726 break;
3727 }
3728 }
3729 }
3730 result
3731 };
3732 let mut items = ::std::vec::Vec::new();
3733 for child in non_field_children {
3734 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3735 <Lifetime as ::treesitter_types::FromNode>::from_node(child, src)
3736 })?);
3737 }
3738 items
3739 },
3740 })
3741 }
3742}
3743impl ::treesitter_types::Spanned for ForLifetimes<'_> {
3744 fn span(&self) -> ::treesitter_types::Span {
3745 self.span
3746 }
3747}
3748#[derive(Debug, Clone, PartialEq, Eq)]
3749pub struct ForeignModItem<'tree> {
3750 pub span: ::treesitter_types::Span,
3751 pub body: ::core::option::Option<DeclarationList<'tree>>,
3752 pub children: ExternModifier<'tree>,
3753}
3754impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignModItem<'tree> {
3755 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3756 fn from_node(
3757 node: ::treesitter_types::tree_sitter::Node<'tree>,
3758 src: &'tree [u8],
3759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3760 debug_assert_eq!(node.kind(), "foreign_mod_item");
3761 Ok(Self {
3762 span: ::treesitter_types::Span::from(node),
3763 body: match node.child_by_field_name("body") {
3764 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3765 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
3766 })?),
3767 None => None,
3768 },
3769 children: {
3770 #[allow(clippy::suspicious_else_formatting)]
3771 let non_field_children = {
3772 let mut cursor = node.walk();
3773 let mut result = ::std::vec::Vec::new();
3774 if cursor.goto_first_child() {
3775 loop {
3776 if cursor.field_name().is_none()
3777 && cursor.node().is_named()
3778 && !cursor.node().is_extra()
3779 {
3780 result.push(cursor.node());
3781 }
3782 if !cursor.goto_next_sibling() {
3783 break;
3784 }
3785 }
3786 }
3787 result
3788 };
3789 let child = if let Some(&c) = non_field_children.first() {
3790 c
3791 } else {
3792 let mut fallback_cursor = node.walk();
3793 let mut fallback_child = None;
3794 if fallback_cursor.goto_first_child() {
3795 loop {
3796 if fallback_cursor.field_name().is_none()
3797 && !fallback_cursor.node().is_extra()
3798 {
3799 let candidate = fallback_cursor.node();
3800 #[allow(clippy::needless_question_mark)]
3801 if (|| -> ::core::result::Result<
3802 _,
3803 ::treesitter_types::ParseError,
3804 > {
3805 let child = candidate;
3806 Ok(
3807 ::treesitter_types::runtime::maybe_grow_stack(|| <ExternModifier as ::treesitter_types::FromNode>::from_node(
3808 child,
3809 src,
3810 ))?,
3811 )
3812 })()
3813 .is_ok()
3814 {
3815 fallback_child = Some(candidate);
3816 break;
3817 }
3818 }
3819 if !fallback_cursor.goto_next_sibling() {
3820 break;
3821 }
3822 }
3823 }
3824 if fallback_child.is_none() {
3825 let mut cursor2 = node.walk();
3826 if cursor2.goto_first_child() {
3827 loop {
3828 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3829 let candidate = cursor2.node();
3830 #[allow(clippy::needless_question_mark)]
3831 if (|| -> ::core::result::Result<
3832 _,
3833 ::treesitter_types::ParseError,
3834 > {
3835 let child = candidate;
3836 Ok(
3837 ::treesitter_types::runtime::maybe_grow_stack(|| <ExternModifier as ::treesitter_types::FromNode>::from_node(
3838 child,
3839 src,
3840 ))?,
3841 )
3842 })()
3843 .is_ok()
3844 {
3845 fallback_child = Some(candidate);
3846 break;
3847 }
3848 }
3849 if !cursor2.goto_next_sibling() {
3850 break;
3851 }
3852 }
3853 }
3854 }
3855 fallback_child.ok_or_else(|| {
3856 ::treesitter_types::ParseError::missing_field("children", node)
3857 })?
3858 };
3859 ::treesitter_types::runtime::maybe_grow_stack(|| {
3860 <ExternModifier as ::treesitter_types::FromNode>::from_node(child, src)
3861 })?
3862 },
3863 })
3864 }
3865}
3866impl ::treesitter_types::Spanned for ForeignModItem<'_> {
3867 fn span(&self) -> ::treesitter_types::Span {
3868 self.span
3869 }
3870}
3871#[derive(Debug, Clone, PartialEq, Eq)]
3872pub struct FragmentSpecifier<'tree> {
3873 pub span: ::treesitter_types::Span,
3874 text: &'tree str,
3875}
3876impl<'tree> ::treesitter_types::FromNode<'tree> for FragmentSpecifier<'tree> {
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(), "fragment_specifier");
3882 Ok(Self {
3883 span: ::treesitter_types::Span::from(node),
3884 text: node.utf8_text(src)?,
3885 })
3886 }
3887}
3888impl<'tree> ::treesitter_types::LeafNode<'tree> for FragmentSpecifier<'tree> {
3889 fn text(&self) -> &'tree str {
3890 self.text
3891 }
3892}
3893impl ::treesitter_types::Spanned for FragmentSpecifier<'_> {
3894 fn span(&self) -> ::treesitter_types::Span {
3895 self.span
3896 }
3897}
3898#[derive(Debug, Clone, PartialEq, Eq)]
3899pub struct FunctionItem<'tree> {
3900 pub span: ::treesitter_types::Span,
3901 pub body: Block<'tree>,
3902 pub name: FunctionItemName<'tree>,
3903 pub parameters: Parameters<'tree>,
3904 pub return_type: ::core::option::Option<Type<'tree>>,
3905 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3906 pub children: ::std::vec::Vec<FunctionItemChildren<'tree>>,
3907}
3908impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItem<'tree> {
3909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3910 fn from_node(
3911 node: ::treesitter_types::tree_sitter::Node<'tree>,
3912 src: &'tree [u8],
3913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3914 debug_assert_eq!(node.kind(), "function_item");
3915 Ok(Self {
3916 span: ::treesitter_types::Span::from(node),
3917 body: {
3918 let child = node
3919 .child_by_field_name("body")
3920 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3921 ::treesitter_types::runtime::maybe_grow_stack(|| {
3922 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3923 })?
3924 },
3925 name: {
3926 let child = node
3927 .child_by_field_name("name")
3928 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3929 ::treesitter_types::runtime::maybe_grow_stack(|| {
3930 <FunctionItemName as ::treesitter_types::FromNode>::from_node(child, src)
3931 })?
3932 },
3933 parameters: {
3934 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3935 ::treesitter_types::ParseError::missing_field("parameters", node)
3936 })?;
3937 ::treesitter_types::runtime::maybe_grow_stack(|| {
3938 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)
3939 })?
3940 },
3941 return_type: match node.child_by_field_name("return_type") {
3942 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3943 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3944 })?),
3945 None => None,
3946 },
3947 type_parameters: match node.child_by_field_name("type_parameters") {
3948 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3949 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
3950 })?),
3951 None => None,
3952 },
3953 children: {
3954 #[allow(clippy::suspicious_else_formatting)]
3955 let non_field_children = {
3956 let mut cursor = node.walk();
3957 let mut result = ::std::vec::Vec::new();
3958 if cursor.goto_first_child() {
3959 loop {
3960 if cursor.field_name().is_none()
3961 && cursor.node().is_named()
3962 && !cursor.node().is_extra()
3963 {
3964 result.push(cursor.node());
3965 }
3966 if !cursor.goto_next_sibling() {
3967 break;
3968 }
3969 }
3970 }
3971 result
3972 };
3973 let mut items = ::std::vec::Vec::new();
3974 for child in non_field_children {
3975 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3976 <FunctionItemChildren as ::treesitter_types::FromNode>::from_node(
3977 child, src,
3978 )
3979 })?);
3980 }
3981 items
3982 },
3983 })
3984 }
3985}
3986impl ::treesitter_types::Spanned for FunctionItem<'_> {
3987 fn span(&self) -> ::treesitter_types::Span {
3988 self.span
3989 }
3990}
3991#[derive(Debug, Clone, PartialEq, Eq)]
3992pub struct FunctionModifiers<'tree> {
3993 pub span: ::treesitter_types::Span,
3994 pub children: ::std::vec::Vec<ExternModifier<'tree>>,
3995}
3996impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionModifiers<'tree> {
3997 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3998 fn from_node(
3999 node: ::treesitter_types::tree_sitter::Node<'tree>,
4000 src: &'tree [u8],
4001 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4002 debug_assert_eq!(node.kind(), "function_modifiers");
4003 Ok(Self {
4004 span: ::treesitter_types::Span::from(node),
4005 children: {
4006 #[allow(clippy::suspicious_else_formatting)]
4007 let non_field_children = {
4008 let mut cursor = node.walk();
4009 let mut result = ::std::vec::Vec::new();
4010 if cursor.goto_first_child() {
4011 loop {
4012 if cursor.field_name().is_none()
4013 && cursor.node().is_named()
4014 && !cursor.node().is_extra()
4015 {
4016 result.push(cursor.node());
4017 }
4018 if !cursor.goto_next_sibling() {
4019 break;
4020 }
4021 }
4022 }
4023 result
4024 };
4025 let mut items = ::std::vec::Vec::new();
4026 for child in non_field_children {
4027 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4028 <ExternModifier as ::treesitter_types::FromNode>::from_node(child, src)
4029 })?);
4030 }
4031 items
4032 },
4033 })
4034 }
4035}
4036impl ::treesitter_types::Spanned for FunctionModifiers<'_> {
4037 fn span(&self) -> ::treesitter_types::Span {
4038 self.span
4039 }
4040}
4041#[derive(Debug, Clone, PartialEq, Eq)]
4042pub struct FunctionSignatureItem<'tree> {
4043 pub span: ::treesitter_types::Span,
4044 pub name: FunctionSignatureItemName<'tree>,
4045 pub parameters: Parameters<'tree>,
4046 pub return_type: ::core::option::Option<Type<'tree>>,
4047 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4048 pub children: ::std::vec::Vec<FunctionSignatureItemChildren<'tree>>,
4049}
4050impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItem<'tree> {
4051 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4052 fn from_node(
4053 node: ::treesitter_types::tree_sitter::Node<'tree>,
4054 src: &'tree [u8],
4055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4056 debug_assert_eq!(node.kind(), "function_signature_item");
4057 Ok(Self {
4058 span: ::treesitter_types::Span::from(node),
4059 name: {
4060 let child = node
4061 .child_by_field_name("name")
4062 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4063 ::treesitter_types::runtime::maybe_grow_stack(|| {
4064 <FunctionSignatureItemName as ::treesitter_types::FromNode>::from_node(
4065 child, src,
4066 )
4067 })?
4068 },
4069 parameters: {
4070 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4071 ::treesitter_types::ParseError::missing_field("parameters", node)
4072 })?;
4073 ::treesitter_types::runtime::maybe_grow_stack(|| {
4074 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)
4075 })?
4076 },
4077 return_type: match node.child_by_field_name("return_type") {
4078 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4079 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4080 })?),
4081 None => None,
4082 },
4083 type_parameters: match node.child_by_field_name("type_parameters") {
4084 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4085 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
4086 })?),
4087 None => None,
4088 },
4089 children: {
4090 #[allow(clippy::suspicious_else_formatting)]
4091 let non_field_children = {
4092 let mut cursor = node.walk();
4093 let mut result = ::std::vec::Vec::new();
4094 if cursor.goto_first_child() {
4095 loop {
4096 if cursor.field_name().is_none()
4097 && cursor.node().is_named()
4098 && !cursor.node().is_extra()
4099 {
4100 result.push(cursor.node());
4101 }
4102 if !cursor.goto_next_sibling() {
4103 break;
4104 }
4105 }
4106 }
4107 result
4108 };
4109 let mut items = ::std::vec::Vec::new();
4110 for child in non_field_children {
4111 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4112 <FunctionSignatureItemChildren as ::treesitter_types::FromNode>::from_node(
4113 child, src,
4114 )
4115 })?);
4116 }
4117 items
4118 },
4119 })
4120 }
4121}
4122impl ::treesitter_types::Spanned for FunctionSignatureItem<'_> {
4123 fn span(&self) -> ::treesitter_types::Span {
4124 self.span
4125 }
4126}
4127#[derive(Debug, Clone, PartialEq, Eq)]
4128pub struct FunctionType<'tree> {
4129 pub span: ::treesitter_types::Span,
4130 pub parameters: Parameters<'tree>,
4131 pub return_type: ::core::option::Option<Type<'tree>>,
4132 pub r#trait: ::core::option::Option<FunctionTypeTrait<'tree>>,
4133 pub children: ::std::vec::Vec<FunctionTypeChildren<'tree>>,
4134}
4135impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
4136 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4137 fn from_node(
4138 node: ::treesitter_types::tree_sitter::Node<'tree>,
4139 src: &'tree [u8],
4140 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4141 debug_assert_eq!(node.kind(), "function_type");
4142 Ok(Self {
4143 span: ::treesitter_types::Span::from(node),
4144 parameters: {
4145 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4146 ::treesitter_types::ParseError::missing_field("parameters", node)
4147 })?;
4148 ::treesitter_types::runtime::maybe_grow_stack(|| {
4149 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)
4150 })?
4151 },
4152 return_type: match node.child_by_field_name("return_type") {
4153 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4154 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4155 })?),
4156 None => None,
4157 },
4158 r#trait: match node.child_by_field_name("trait") {
4159 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4160 <FunctionTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)
4161 })?),
4162 None => None,
4163 },
4164 children: {
4165 #[allow(clippy::suspicious_else_formatting)]
4166 let non_field_children = {
4167 let mut cursor = node.walk();
4168 let mut result = ::std::vec::Vec::new();
4169 if cursor.goto_first_child() {
4170 loop {
4171 if cursor.field_name().is_none()
4172 && cursor.node().is_named()
4173 && !cursor.node().is_extra()
4174 {
4175 result.push(cursor.node());
4176 }
4177 if !cursor.goto_next_sibling() {
4178 break;
4179 }
4180 }
4181 }
4182 result
4183 };
4184 let mut items = ::std::vec::Vec::new();
4185 for child in non_field_children {
4186 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4187 <FunctionTypeChildren as ::treesitter_types::FromNode>::from_node(
4188 child, src,
4189 )
4190 })?);
4191 }
4192 items
4193 },
4194 })
4195 }
4196}
4197impl ::treesitter_types::Spanned for FunctionType<'_> {
4198 fn span(&self) -> ::treesitter_types::Span {
4199 self.span
4200 }
4201}
4202#[derive(Debug, Clone, PartialEq, Eq)]
4203pub struct GenBlock<'tree> {
4204 pub span: ::treesitter_types::Span,
4205 pub children: Block<'tree>,
4206}
4207impl<'tree> ::treesitter_types::FromNode<'tree> for GenBlock<'tree> {
4208 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4209 fn from_node(
4210 node: ::treesitter_types::tree_sitter::Node<'tree>,
4211 src: &'tree [u8],
4212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4213 debug_assert_eq!(node.kind(), "gen_block");
4214 Ok(Self {
4215 span: ::treesitter_types::Span::from(node),
4216 children: {
4217 #[allow(clippy::suspicious_else_formatting)]
4218 let non_field_children = {
4219 let mut cursor = node.walk();
4220 let mut result = ::std::vec::Vec::new();
4221 if cursor.goto_first_child() {
4222 loop {
4223 if cursor.field_name().is_none()
4224 && cursor.node().is_named()
4225 && !cursor.node().is_extra()
4226 {
4227 result.push(cursor.node());
4228 }
4229 if !cursor.goto_next_sibling() {
4230 break;
4231 }
4232 }
4233 }
4234 result
4235 };
4236 let child = if let Some(&c) = non_field_children.first() {
4237 c
4238 } else {
4239 let mut fallback_cursor = node.walk();
4240 let mut fallback_child = None;
4241 if fallback_cursor.goto_first_child() {
4242 loop {
4243 if fallback_cursor.field_name().is_none()
4244 && !fallback_cursor.node().is_extra()
4245 {
4246 let candidate = fallback_cursor.node();
4247 #[allow(clippy::needless_question_mark)]
4248 if (|| -> ::core::result::Result<
4249 _,
4250 ::treesitter_types::ParseError,
4251 > {
4252 let child = candidate;
4253 Ok(
4254 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
4255 child,
4256 src,
4257 ))?,
4258 )
4259 })()
4260 .is_ok()
4261 {
4262 fallback_child = Some(candidate);
4263 break;
4264 }
4265 }
4266 if !fallback_cursor.goto_next_sibling() {
4267 break;
4268 }
4269 }
4270 }
4271 if fallback_child.is_none() {
4272 let mut cursor2 = node.walk();
4273 if cursor2.goto_first_child() {
4274 loop {
4275 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4276 let candidate = cursor2.node();
4277 #[allow(clippy::needless_question_mark)]
4278 if (|| -> ::core::result::Result<
4279 _,
4280 ::treesitter_types::ParseError,
4281 > {
4282 let child = candidate;
4283 Ok(
4284 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
4285 child,
4286 src,
4287 ))?,
4288 )
4289 })()
4290 .is_ok()
4291 {
4292 fallback_child = Some(candidate);
4293 break;
4294 }
4295 }
4296 if !cursor2.goto_next_sibling() {
4297 break;
4298 }
4299 }
4300 }
4301 }
4302 fallback_child.ok_or_else(|| {
4303 ::treesitter_types::ParseError::missing_field("children", node)
4304 })?
4305 };
4306 ::treesitter_types::runtime::maybe_grow_stack(|| {
4307 <Block as ::treesitter_types::FromNode>::from_node(child, src)
4308 })?
4309 },
4310 })
4311 }
4312}
4313impl ::treesitter_types::Spanned for GenBlock<'_> {
4314 fn span(&self) -> ::treesitter_types::Span {
4315 self.span
4316 }
4317}
4318#[derive(Debug, Clone, PartialEq, Eq)]
4319pub struct GenericFunction<'tree> {
4320 pub span: ::treesitter_types::Span,
4321 pub function: GenericFunctionFunction<'tree>,
4322 pub type_arguments: TypeArguments<'tree>,
4323}
4324impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunction<'tree> {
4325 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4326 fn from_node(
4327 node: ::treesitter_types::tree_sitter::Node<'tree>,
4328 src: &'tree [u8],
4329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4330 debug_assert_eq!(node.kind(), "generic_function");
4331 Ok(Self {
4332 span: ::treesitter_types::Span::from(node),
4333 function: {
4334 let child = node.child_by_field_name("function").ok_or_else(|| {
4335 ::treesitter_types::ParseError::missing_field("function", node)
4336 })?;
4337 ::treesitter_types::runtime::maybe_grow_stack(|| {
4338 <GenericFunctionFunction as ::treesitter_types::FromNode>::from_node(child, src)
4339 })?
4340 },
4341 type_arguments: {
4342 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4343 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4344 })?;
4345 ::treesitter_types::runtime::maybe_grow_stack(|| {
4346 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
4347 })?
4348 },
4349 })
4350 }
4351}
4352impl ::treesitter_types::Spanned for GenericFunction<'_> {
4353 fn span(&self) -> ::treesitter_types::Span {
4354 self.span
4355 }
4356}
4357#[derive(Debug, Clone, PartialEq, Eq)]
4358pub struct GenericPattern<'tree> {
4359 pub span: ::treesitter_types::Span,
4360 pub type_arguments: TypeArguments<'tree>,
4361 pub children: GenericPatternChildren<'tree>,
4362}
4363impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPattern<'tree> {
4364 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4365 fn from_node(
4366 node: ::treesitter_types::tree_sitter::Node<'tree>,
4367 src: &'tree [u8],
4368 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4369 debug_assert_eq!(node.kind(), "generic_pattern");
4370 Ok(Self {
4371 span: ::treesitter_types::Span::from(node),
4372 type_arguments: {
4373 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4374 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4375 })?;
4376 ::treesitter_types::runtime::maybe_grow_stack(|| {
4377 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
4378 })?
4379 },
4380 children: {
4381 #[allow(clippy::suspicious_else_formatting)]
4382 let non_field_children = {
4383 let mut cursor = node.walk();
4384 let mut result = ::std::vec::Vec::new();
4385 if cursor.goto_first_child() {
4386 loop {
4387 if cursor.field_name().is_none()
4388 && cursor.node().is_named()
4389 && !cursor.node().is_extra()
4390 {
4391 result.push(cursor.node());
4392 }
4393 if !cursor.goto_next_sibling() {
4394 break;
4395 }
4396 }
4397 }
4398 result
4399 };
4400 let child = if let Some(&c) = non_field_children.first() {
4401 c
4402 } else {
4403 let mut fallback_cursor = node.walk();
4404 let mut fallback_child = None;
4405 if fallback_cursor.goto_first_child() {
4406 loop {
4407 if fallback_cursor.field_name().is_none()
4408 && !fallback_cursor.node().is_extra()
4409 {
4410 let candidate = fallback_cursor.node();
4411 #[allow(clippy::needless_question_mark)]
4412 if (|| -> ::core::result::Result<
4413 _,
4414 ::treesitter_types::ParseError,
4415 > {
4416 let child = candidate;
4417 Ok(
4418 ::treesitter_types::runtime::maybe_grow_stack(|| <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(
4419 child,
4420 src,
4421 ))?,
4422 )
4423 })()
4424 .is_ok()
4425 {
4426 fallback_child = Some(candidate);
4427 break;
4428 }
4429 }
4430 if !fallback_cursor.goto_next_sibling() {
4431 break;
4432 }
4433 }
4434 }
4435 if fallback_child.is_none() {
4436 let mut cursor2 = node.walk();
4437 if cursor2.goto_first_child() {
4438 loop {
4439 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4440 let candidate = cursor2.node();
4441 #[allow(clippy::needless_question_mark)]
4442 if (|| -> ::core::result::Result<
4443 _,
4444 ::treesitter_types::ParseError,
4445 > {
4446 let child = candidate;
4447 Ok(
4448 ::treesitter_types::runtime::maybe_grow_stack(|| <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(
4449 child,
4450 src,
4451 ))?,
4452 )
4453 })()
4454 .is_ok()
4455 {
4456 fallback_child = Some(candidate);
4457 break;
4458 }
4459 }
4460 if !cursor2.goto_next_sibling() {
4461 break;
4462 }
4463 }
4464 }
4465 }
4466 fallback_child.ok_or_else(|| {
4467 ::treesitter_types::ParseError::missing_field("children", node)
4468 })?
4469 };
4470 ::treesitter_types::runtime::maybe_grow_stack(|| {
4471 <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
4472 })?
4473 },
4474 })
4475 }
4476}
4477impl ::treesitter_types::Spanned for GenericPattern<'_> {
4478 fn span(&self) -> ::treesitter_types::Span {
4479 self.span
4480 }
4481}
4482#[derive(Debug, Clone, PartialEq, Eq)]
4483pub struct GenericType<'tree> {
4484 pub span: ::treesitter_types::Span,
4485 pub r#type: GenericTypeType<'tree>,
4486 pub type_arguments: TypeArguments<'tree>,
4487}
4488impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
4489 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4490 fn from_node(
4491 node: ::treesitter_types::tree_sitter::Node<'tree>,
4492 src: &'tree [u8],
4493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4494 debug_assert_eq!(node.kind(), "generic_type");
4495 Ok(Self {
4496 span: ::treesitter_types::Span::from(node),
4497 r#type: {
4498 let child = node
4499 .child_by_field_name("type")
4500 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4501 ::treesitter_types::runtime::maybe_grow_stack(|| {
4502 <GenericTypeType as ::treesitter_types::FromNode>::from_node(child, src)
4503 })?
4504 },
4505 type_arguments: {
4506 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4507 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4508 })?;
4509 ::treesitter_types::runtime::maybe_grow_stack(|| {
4510 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
4511 })?
4512 },
4513 })
4514 }
4515}
4516impl ::treesitter_types::Spanned for GenericType<'_> {
4517 fn span(&self) -> ::treesitter_types::Span {
4518 self.span
4519 }
4520}
4521#[derive(Debug, Clone, PartialEq, Eq)]
4522pub struct GenericTypeWithTurbofish<'tree> {
4523 pub span: ::treesitter_types::Span,
4524 pub r#type: GenericTypeWithTurbofishType<'tree>,
4525 pub type_arguments: TypeArguments<'tree>,
4526}
4527impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofish<'tree> {
4528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4529 fn from_node(
4530 node: ::treesitter_types::tree_sitter::Node<'tree>,
4531 src: &'tree [u8],
4532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4533 debug_assert_eq!(node.kind(), "generic_type_with_turbofish");
4534 Ok(Self {
4535 span: ::treesitter_types::Span::from(node),
4536 r#type: {
4537 let child = node
4538 .child_by_field_name("type")
4539 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4540 ::treesitter_types::runtime::maybe_grow_stack(|| {
4541 <GenericTypeWithTurbofishType as ::treesitter_types::FromNode>::from_node(
4542 child, src,
4543 )
4544 })?
4545 },
4546 type_arguments: {
4547 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4548 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4549 })?;
4550 ::treesitter_types::runtime::maybe_grow_stack(|| {
4551 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
4552 })?
4553 },
4554 })
4555 }
4556}
4557impl ::treesitter_types::Spanned for GenericTypeWithTurbofish<'_> {
4558 fn span(&self) -> ::treesitter_types::Span {
4559 self.span
4560 }
4561}
4562#[derive(Debug, Clone, PartialEq, Eq)]
4563pub struct HigherRankedTraitBound<'tree> {
4564 pub span: ::treesitter_types::Span,
4565 pub r#type: Type<'tree>,
4566 pub type_parameters: TypeParameters<'tree>,
4567}
4568impl<'tree> ::treesitter_types::FromNode<'tree> for HigherRankedTraitBound<'tree> {
4569 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4570 fn from_node(
4571 node: ::treesitter_types::tree_sitter::Node<'tree>,
4572 src: &'tree [u8],
4573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4574 debug_assert_eq!(node.kind(), "higher_ranked_trait_bound");
4575 Ok(Self {
4576 span: ::treesitter_types::Span::from(node),
4577 r#type: {
4578 let child = node
4579 .child_by_field_name("type")
4580 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4581 ::treesitter_types::runtime::maybe_grow_stack(|| {
4582 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4583 })?
4584 },
4585 type_parameters: {
4586 let child = node.child_by_field_name("type_parameters").ok_or_else(|| {
4587 ::treesitter_types::ParseError::missing_field("type_parameters", node)
4588 })?;
4589 ::treesitter_types::runtime::maybe_grow_stack(|| {
4590 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
4591 })?
4592 },
4593 })
4594 }
4595}
4596impl ::treesitter_types::Spanned for HigherRankedTraitBound<'_> {
4597 fn span(&self) -> ::treesitter_types::Span {
4598 self.span
4599 }
4600}
4601#[derive(Debug, Clone, PartialEq, Eq)]
4602pub struct IfExpression<'tree> {
4603 pub span: ::treesitter_types::Span,
4604 pub alternative: ::core::option::Option<ElseClause<'tree>>,
4605 pub condition: IfExpressionCondition<'tree>,
4606 pub consequence: Block<'tree>,
4607}
4608impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpression<'tree> {
4609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4610 fn from_node(
4611 node: ::treesitter_types::tree_sitter::Node<'tree>,
4612 src: &'tree [u8],
4613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4614 debug_assert_eq!(node.kind(), "if_expression");
4615 Ok(Self {
4616 span: ::treesitter_types::Span::from(node),
4617 alternative: match node.child_by_field_name("alternative") {
4618 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4619 <ElseClause as ::treesitter_types::FromNode>::from_node(child, src)
4620 })?),
4621 None => None,
4622 },
4623 condition: {
4624 let child = node.child_by_field_name("condition").ok_or_else(|| {
4625 ::treesitter_types::ParseError::missing_field("condition", node)
4626 })?;
4627 ::treesitter_types::runtime::maybe_grow_stack(|| {
4628 <IfExpressionCondition as ::treesitter_types::FromNode>::from_node(child, src)
4629 })?
4630 },
4631 consequence: {
4632 let child = node.child_by_field_name("consequence").ok_or_else(|| {
4633 ::treesitter_types::ParseError::missing_field("consequence", node)
4634 })?;
4635 ::treesitter_types::runtime::maybe_grow_stack(|| {
4636 <Block as ::treesitter_types::FromNode>::from_node(child, src)
4637 })?
4638 },
4639 })
4640 }
4641}
4642impl ::treesitter_types::Spanned for IfExpression<'_> {
4643 fn span(&self) -> ::treesitter_types::Span {
4644 self.span
4645 }
4646}
4647#[derive(Debug, Clone, PartialEq, Eq)]
4648pub struct ImplItem<'tree> {
4649 pub span: ::treesitter_types::Span,
4650 pub body: ::core::option::Option<DeclarationList<'tree>>,
4651 pub r#trait: ::core::option::Option<ImplItemTrait<'tree>>,
4652 pub r#type: Type<'tree>,
4653 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4654 pub children: ::core::option::Option<WhereClause<'tree>>,
4655}
4656impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItem<'tree> {
4657 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4658 fn from_node(
4659 node: ::treesitter_types::tree_sitter::Node<'tree>,
4660 src: &'tree [u8],
4661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4662 debug_assert_eq!(node.kind(), "impl_item");
4663 Ok(Self {
4664 span: ::treesitter_types::Span::from(node),
4665 body: match node.child_by_field_name("body") {
4666 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4667 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
4668 })?),
4669 None => None,
4670 },
4671 r#trait: match node.child_by_field_name("trait") {
4672 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4673 <ImplItemTrait as ::treesitter_types::FromNode>::from_node(child, src)
4674 })?),
4675 None => None,
4676 },
4677 r#type: {
4678 let child = node
4679 .child_by_field_name("type")
4680 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4681 ::treesitter_types::runtime::maybe_grow_stack(|| {
4682 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4683 })?
4684 },
4685 type_parameters: match node.child_by_field_name("type_parameters") {
4686 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4687 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
4688 })?),
4689 None => None,
4690 },
4691 children: {
4692 #[allow(clippy::suspicious_else_formatting)]
4693 let non_field_children = {
4694 let mut cursor = node.walk();
4695 let mut result = ::std::vec::Vec::new();
4696 if cursor.goto_first_child() {
4697 loop {
4698 if cursor.field_name().is_none()
4699 && cursor.node().is_named()
4700 && !cursor.node().is_extra()
4701 {
4702 result.push(cursor.node());
4703 }
4704 if !cursor.goto_next_sibling() {
4705 break;
4706 }
4707 }
4708 }
4709 result
4710 };
4711 match non_field_children.first() {
4712 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4713 <WhereClause as ::treesitter_types::FromNode>::from_node(child, src)
4714 })?),
4715 None => None,
4716 }
4717 },
4718 })
4719 }
4720}
4721impl ::treesitter_types::Spanned for ImplItem<'_> {
4722 fn span(&self) -> ::treesitter_types::Span {
4723 self.span
4724 }
4725}
4726#[derive(Debug, Clone, PartialEq, Eq)]
4727pub struct IndexExpression<'tree> {
4728 pub span: ::treesitter_types::Span,
4729 pub children: ::std::vec::Vec<Expression<'tree>>,
4730}
4731impl<'tree> ::treesitter_types::FromNode<'tree> for IndexExpression<'tree> {
4732 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4733 fn from_node(
4734 node: ::treesitter_types::tree_sitter::Node<'tree>,
4735 src: &'tree [u8],
4736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4737 debug_assert_eq!(node.kind(), "index_expression");
4738 Ok(Self {
4739 span: ::treesitter_types::Span::from(node),
4740 children: {
4741 #[allow(clippy::suspicious_else_formatting)]
4742 let non_field_children = {
4743 let mut cursor = node.walk();
4744 let mut result = ::std::vec::Vec::new();
4745 if cursor.goto_first_child() {
4746 loop {
4747 if cursor.field_name().is_none()
4748 && cursor.node().is_named()
4749 && !cursor.node().is_extra()
4750 {
4751 result.push(cursor.node());
4752 }
4753 if !cursor.goto_next_sibling() {
4754 break;
4755 }
4756 }
4757 }
4758 result
4759 };
4760 let mut items = ::std::vec::Vec::new();
4761 for child in non_field_children {
4762 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4763 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4764 })?);
4765 }
4766 items
4767 },
4768 })
4769 }
4770}
4771impl ::treesitter_types::Spanned for IndexExpression<'_> {
4772 fn span(&self) -> ::treesitter_types::Span {
4773 self.span
4774 }
4775}
4776#[derive(Debug, Clone, PartialEq, Eq)]
4777pub struct InnerAttributeItem<'tree> {
4778 pub span: ::treesitter_types::Span,
4779 pub children: Attribute<'tree>,
4780}
4781impl<'tree> ::treesitter_types::FromNode<'tree> for InnerAttributeItem<'tree> {
4782 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4783 fn from_node(
4784 node: ::treesitter_types::tree_sitter::Node<'tree>,
4785 src: &'tree [u8],
4786 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4787 debug_assert_eq!(node.kind(), "inner_attribute_item");
4788 Ok(Self {
4789 span: ::treesitter_types::Span::from(node),
4790 children: {
4791 #[allow(clippy::suspicious_else_formatting)]
4792 let non_field_children = {
4793 let mut cursor = node.walk();
4794 let mut result = ::std::vec::Vec::new();
4795 if cursor.goto_first_child() {
4796 loop {
4797 if cursor.field_name().is_none()
4798 && cursor.node().is_named()
4799 && !cursor.node().is_extra()
4800 {
4801 result.push(cursor.node());
4802 }
4803 if !cursor.goto_next_sibling() {
4804 break;
4805 }
4806 }
4807 }
4808 result
4809 };
4810 let child = if let Some(&c) = non_field_children.first() {
4811 c
4812 } else {
4813 let mut fallback_cursor = node.walk();
4814 let mut fallback_child = None;
4815 if fallback_cursor.goto_first_child() {
4816 loop {
4817 if fallback_cursor.field_name().is_none()
4818 && !fallback_cursor.node().is_extra()
4819 {
4820 let candidate = fallback_cursor.node();
4821 #[allow(clippy::needless_question_mark)]
4822 if (|| -> ::core::result::Result<
4823 _,
4824 ::treesitter_types::ParseError,
4825 > {
4826 let child = candidate;
4827 Ok(
4828 ::treesitter_types::runtime::maybe_grow_stack(|| <Attribute as ::treesitter_types::FromNode>::from_node(
4829 child,
4830 src,
4831 ))?,
4832 )
4833 })()
4834 .is_ok()
4835 {
4836 fallback_child = Some(candidate);
4837 break;
4838 }
4839 }
4840 if !fallback_cursor.goto_next_sibling() {
4841 break;
4842 }
4843 }
4844 }
4845 if fallback_child.is_none() {
4846 let mut cursor2 = node.walk();
4847 if cursor2.goto_first_child() {
4848 loop {
4849 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4850 let candidate = cursor2.node();
4851 #[allow(clippy::needless_question_mark)]
4852 if (|| -> ::core::result::Result<
4853 _,
4854 ::treesitter_types::ParseError,
4855 > {
4856 let child = candidate;
4857 Ok(
4858 ::treesitter_types::runtime::maybe_grow_stack(|| <Attribute as ::treesitter_types::FromNode>::from_node(
4859 child,
4860 src,
4861 ))?,
4862 )
4863 })()
4864 .is_ok()
4865 {
4866 fallback_child = Some(candidate);
4867 break;
4868 }
4869 }
4870 if !cursor2.goto_next_sibling() {
4871 break;
4872 }
4873 }
4874 }
4875 }
4876 fallback_child.ok_or_else(|| {
4877 ::treesitter_types::ParseError::missing_field("children", node)
4878 })?
4879 };
4880 ::treesitter_types::runtime::maybe_grow_stack(|| {
4881 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
4882 })?
4883 },
4884 })
4885 }
4886}
4887impl ::treesitter_types::Spanned for InnerAttributeItem<'_> {
4888 fn span(&self) -> ::treesitter_types::Span {
4889 self.span
4890 }
4891}
4892#[derive(Debug, Clone, PartialEq, Eq)]
4893pub struct InnerDocCommentMarker<'tree> {
4894 pub span: ::treesitter_types::Span,
4895 text: &'tree str,
4896}
4897impl<'tree> ::treesitter_types::FromNode<'tree> for InnerDocCommentMarker<'tree> {
4898 fn from_node(
4899 node: ::treesitter_types::tree_sitter::Node<'tree>,
4900 src: &'tree [u8],
4901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4902 debug_assert_eq!(node.kind(), "inner_doc_comment_marker");
4903 Ok(Self {
4904 span: ::treesitter_types::Span::from(node),
4905 text: node.utf8_text(src)?,
4906 })
4907 }
4908}
4909impl<'tree> ::treesitter_types::LeafNode<'tree> for InnerDocCommentMarker<'tree> {
4910 fn text(&self) -> &'tree str {
4911 self.text
4912 }
4913}
4914impl ::treesitter_types::Spanned for InnerDocCommentMarker<'_> {
4915 fn span(&self) -> ::treesitter_types::Span {
4916 self.span
4917 }
4918}
4919#[derive(Debug, Clone, PartialEq, Eq)]
4920pub struct Label<'tree> {
4921 pub span: ::treesitter_types::Span,
4922 pub children: Identifier<'tree>,
4923}
4924impl<'tree> ::treesitter_types::FromNode<'tree> for Label<'tree> {
4925 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4926 fn from_node(
4927 node: ::treesitter_types::tree_sitter::Node<'tree>,
4928 src: &'tree [u8],
4929 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4930 debug_assert_eq!(node.kind(), "label");
4931 Ok(Self {
4932 span: ::treesitter_types::Span::from(node),
4933 children: {
4934 #[allow(clippy::suspicious_else_formatting)]
4935 let non_field_children = {
4936 let mut cursor = node.walk();
4937 let mut result = ::std::vec::Vec::new();
4938 if cursor.goto_first_child() {
4939 loop {
4940 if cursor.field_name().is_none()
4941 && cursor.node().is_named()
4942 && !cursor.node().is_extra()
4943 {
4944 result.push(cursor.node());
4945 }
4946 if !cursor.goto_next_sibling() {
4947 break;
4948 }
4949 }
4950 }
4951 result
4952 };
4953 let child = if let Some(&c) = non_field_children.first() {
4954 c
4955 } else {
4956 let mut fallback_cursor = node.walk();
4957 let mut fallback_child = None;
4958 if fallback_cursor.goto_first_child() {
4959 loop {
4960 if fallback_cursor.field_name().is_none()
4961 && !fallback_cursor.node().is_extra()
4962 {
4963 let candidate = fallback_cursor.node();
4964 #[allow(clippy::needless_question_mark)]
4965 if (|| -> ::core::result::Result<
4966 _,
4967 ::treesitter_types::ParseError,
4968 > {
4969 let child = candidate;
4970 Ok(
4971 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
4972 child,
4973 src,
4974 ))?,
4975 )
4976 })()
4977 .is_ok()
4978 {
4979 fallback_child = Some(candidate);
4980 break;
4981 }
4982 }
4983 if !fallback_cursor.goto_next_sibling() {
4984 break;
4985 }
4986 }
4987 }
4988 if fallback_child.is_none() {
4989 let mut cursor2 = node.walk();
4990 if cursor2.goto_first_child() {
4991 loop {
4992 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4993 let candidate = cursor2.node();
4994 #[allow(clippy::needless_question_mark)]
4995 if (|| -> ::core::result::Result<
4996 _,
4997 ::treesitter_types::ParseError,
4998 > {
4999 let child = candidate;
5000 Ok(
5001 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
5002 child,
5003 src,
5004 ))?,
5005 )
5006 })()
5007 .is_ok()
5008 {
5009 fallback_child = Some(candidate);
5010 break;
5011 }
5012 }
5013 if !cursor2.goto_next_sibling() {
5014 break;
5015 }
5016 }
5017 }
5018 }
5019 fallback_child.ok_or_else(|| {
5020 ::treesitter_types::ParseError::missing_field("children", node)
5021 })?
5022 };
5023 ::treesitter_types::runtime::maybe_grow_stack(|| {
5024 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5025 })?
5026 },
5027 })
5028 }
5029}
5030impl ::treesitter_types::Spanned for Label<'_> {
5031 fn span(&self) -> ::treesitter_types::Span {
5032 self.span
5033 }
5034}
5035#[derive(Debug, Clone, PartialEq, Eq)]
5036pub struct LetChain<'tree> {
5037 pub span: ::treesitter_types::Span,
5038 pub children: ::std::vec::Vec<LetChainChildren<'tree>>,
5039}
5040impl<'tree> ::treesitter_types::FromNode<'tree> for LetChain<'tree> {
5041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5042 fn from_node(
5043 node: ::treesitter_types::tree_sitter::Node<'tree>,
5044 src: &'tree [u8],
5045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5046 debug_assert_eq!(node.kind(), "let_chain");
5047 Ok(Self {
5048 span: ::treesitter_types::Span::from(node),
5049 children: {
5050 #[allow(clippy::suspicious_else_formatting)]
5051 let non_field_children = {
5052 let mut cursor = node.walk();
5053 let mut result = ::std::vec::Vec::new();
5054 if cursor.goto_first_child() {
5055 loop {
5056 if cursor.field_name().is_none()
5057 && cursor.node().is_named()
5058 && !cursor.node().is_extra()
5059 {
5060 result.push(cursor.node());
5061 }
5062 if !cursor.goto_next_sibling() {
5063 break;
5064 }
5065 }
5066 }
5067 result
5068 };
5069 let mut items = ::std::vec::Vec::new();
5070 for child in non_field_children {
5071 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5072 <LetChainChildren as ::treesitter_types::FromNode>::from_node(child, src)
5073 })?);
5074 }
5075 items
5076 },
5077 })
5078 }
5079}
5080impl ::treesitter_types::Spanned for LetChain<'_> {
5081 fn span(&self) -> ::treesitter_types::Span {
5082 self.span
5083 }
5084}
5085#[derive(Debug, Clone, PartialEq, Eq)]
5086pub struct LetCondition<'tree> {
5087 pub span: ::treesitter_types::Span,
5088 pub pattern: Pattern<'tree>,
5089 pub value: Expression<'tree>,
5090}
5091impl<'tree> ::treesitter_types::FromNode<'tree> for LetCondition<'tree> {
5092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5093 fn from_node(
5094 node: ::treesitter_types::tree_sitter::Node<'tree>,
5095 src: &'tree [u8],
5096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5097 debug_assert_eq!(node.kind(), "let_condition");
5098 Ok(Self {
5099 span: ::treesitter_types::Span::from(node),
5100 pattern: {
5101 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5102 ::treesitter_types::ParseError::missing_field("pattern", node)
5103 })?;
5104 ::treesitter_types::runtime::maybe_grow_stack(|| {
5105 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
5106 })?
5107 },
5108 value: {
5109 let child = node
5110 .child_by_field_name("value")
5111 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5112 ::treesitter_types::runtime::maybe_grow_stack(|| {
5113 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5114 })?
5115 },
5116 })
5117 }
5118}
5119impl ::treesitter_types::Spanned for LetCondition<'_> {
5120 fn span(&self) -> ::treesitter_types::Span {
5121 self.span
5122 }
5123}
5124#[derive(Debug, Clone, PartialEq, Eq)]
5125pub struct LetDeclaration<'tree> {
5126 pub span: ::treesitter_types::Span,
5127 pub alternative: ::core::option::Option<Block<'tree>>,
5128 pub pattern: Pattern<'tree>,
5129 pub r#type: ::core::option::Option<Type<'tree>>,
5130 pub value: ::core::option::Option<Expression<'tree>>,
5131 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
5132}
5133impl<'tree> ::treesitter_types::FromNode<'tree> for LetDeclaration<'tree> {
5134 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5135 fn from_node(
5136 node: ::treesitter_types::tree_sitter::Node<'tree>,
5137 src: &'tree [u8],
5138 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5139 debug_assert_eq!(node.kind(), "let_declaration");
5140 Ok(Self {
5141 span: ::treesitter_types::Span::from(node),
5142 alternative: match node.child_by_field_name("alternative") {
5143 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5144 <Block as ::treesitter_types::FromNode>::from_node(child, src)
5145 })?),
5146 None => None,
5147 },
5148 pattern: {
5149 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5150 ::treesitter_types::ParseError::missing_field("pattern", node)
5151 })?;
5152 ::treesitter_types::runtime::maybe_grow_stack(|| {
5153 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
5154 })?
5155 },
5156 r#type: match node.child_by_field_name("type") {
5157 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5158 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5159 })?),
5160 None => None,
5161 },
5162 value: match node.child_by_field_name("value") {
5163 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5164 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5165 })?),
5166 None => None,
5167 },
5168 children: {
5169 #[allow(clippy::suspicious_else_formatting)]
5170 let non_field_children = {
5171 let mut cursor = node.walk();
5172 let mut result = ::std::vec::Vec::new();
5173 if cursor.goto_first_child() {
5174 loop {
5175 if cursor.field_name().is_none()
5176 && cursor.node().is_named()
5177 && !cursor.node().is_extra()
5178 {
5179 result.push(cursor.node());
5180 }
5181 if !cursor.goto_next_sibling() {
5182 break;
5183 }
5184 }
5185 }
5186 result
5187 };
5188 match non_field_children.first() {
5189 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5190 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
5191 })?),
5192 None => None,
5193 }
5194 },
5195 })
5196 }
5197}
5198impl ::treesitter_types::Spanned for LetDeclaration<'_> {
5199 fn span(&self) -> ::treesitter_types::Span {
5200 self.span
5201 }
5202}
5203#[derive(Debug, Clone, PartialEq, Eq)]
5204pub struct Lifetime<'tree> {
5205 pub span: ::treesitter_types::Span,
5206 pub children: Identifier<'tree>,
5207}
5208impl<'tree> ::treesitter_types::FromNode<'tree> for Lifetime<'tree> {
5209 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5210 fn from_node(
5211 node: ::treesitter_types::tree_sitter::Node<'tree>,
5212 src: &'tree [u8],
5213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5214 debug_assert_eq!(node.kind(), "lifetime");
5215 Ok(Self {
5216 span: ::treesitter_types::Span::from(node),
5217 children: {
5218 #[allow(clippy::suspicious_else_formatting)]
5219 let non_field_children = {
5220 let mut cursor = node.walk();
5221 let mut result = ::std::vec::Vec::new();
5222 if cursor.goto_first_child() {
5223 loop {
5224 if cursor.field_name().is_none()
5225 && cursor.node().is_named()
5226 && !cursor.node().is_extra()
5227 {
5228 result.push(cursor.node());
5229 }
5230 if !cursor.goto_next_sibling() {
5231 break;
5232 }
5233 }
5234 }
5235 result
5236 };
5237 let child = if let Some(&c) = non_field_children.first() {
5238 c
5239 } else {
5240 let mut fallback_cursor = node.walk();
5241 let mut fallback_child = None;
5242 if fallback_cursor.goto_first_child() {
5243 loop {
5244 if fallback_cursor.field_name().is_none()
5245 && !fallback_cursor.node().is_extra()
5246 {
5247 let candidate = fallback_cursor.node();
5248 #[allow(clippy::needless_question_mark)]
5249 if (|| -> ::core::result::Result<
5250 _,
5251 ::treesitter_types::ParseError,
5252 > {
5253 let child = candidate;
5254 Ok(
5255 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
5256 child,
5257 src,
5258 ))?,
5259 )
5260 })()
5261 .is_ok()
5262 {
5263 fallback_child = Some(candidate);
5264 break;
5265 }
5266 }
5267 if !fallback_cursor.goto_next_sibling() {
5268 break;
5269 }
5270 }
5271 }
5272 if fallback_child.is_none() {
5273 let mut cursor2 = node.walk();
5274 if cursor2.goto_first_child() {
5275 loop {
5276 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5277 let candidate = cursor2.node();
5278 #[allow(clippy::needless_question_mark)]
5279 if (|| -> ::core::result::Result<
5280 _,
5281 ::treesitter_types::ParseError,
5282 > {
5283 let child = candidate;
5284 Ok(
5285 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
5286 child,
5287 src,
5288 ))?,
5289 )
5290 })()
5291 .is_ok()
5292 {
5293 fallback_child = Some(candidate);
5294 break;
5295 }
5296 }
5297 if !cursor2.goto_next_sibling() {
5298 break;
5299 }
5300 }
5301 }
5302 }
5303 fallback_child.ok_or_else(|| {
5304 ::treesitter_types::ParseError::missing_field("children", node)
5305 })?
5306 };
5307 ::treesitter_types::runtime::maybe_grow_stack(|| {
5308 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5309 })?
5310 },
5311 })
5312 }
5313}
5314impl ::treesitter_types::Spanned for Lifetime<'_> {
5315 fn span(&self) -> ::treesitter_types::Span {
5316 self.span
5317 }
5318}
5319#[derive(Debug, Clone, PartialEq, Eq)]
5320pub struct LifetimeParameter<'tree> {
5321 pub span: ::treesitter_types::Span,
5322 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
5323 pub name: Lifetime<'tree>,
5324}
5325impl<'tree> ::treesitter_types::FromNode<'tree> for LifetimeParameter<'tree> {
5326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5327 fn from_node(
5328 node: ::treesitter_types::tree_sitter::Node<'tree>,
5329 src: &'tree [u8],
5330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5331 debug_assert_eq!(node.kind(), "lifetime_parameter");
5332 Ok(Self {
5333 span: ::treesitter_types::Span::from(node),
5334 bounds: match node.child_by_field_name("bounds") {
5335 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5336 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)
5337 })?),
5338 None => None,
5339 },
5340 name: {
5341 let child = node
5342 .child_by_field_name("name")
5343 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5344 ::treesitter_types::runtime::maybe_grow_stack(|| {
5345 <Lifetime as ::treesitter_types::FromNode>::from_node(child, src)
5346 })?
5347 },
5348 })
5349 }
5350}
5351impl ::treesitter_types::Spanned for LifetimeParameter<'_> {
5352 fn span(&self) -> ::treesitter_types::Span {
5353 self.span
5354 }
5355}
5356#[derive(Debug, Clone, PartialEq, Eq)]
5357pub struct LineComment<'tree> {
5358 pub span: ::treesitter_types::Span,
5359 pub doc: ::core::option::Option<DocComment<'tree>>,
5360 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
5361 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
5362}
5363impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
5364 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5365 fn from_node(
5366 node: ::treesitter_types::tree_sitter::Node<'tree>,
5367 src: &'tree [u8],
5368 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5369 debug_assert_eq!(node.kind(), "line_comment");
5370 Ok(Self {
5371 span: ::treesitter_types::Span::from(node),
5372 doc: match node.child_by_field_name("doc") {
5373 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5374 <DocComment as ::treesitter_types::FromNode>::from_node(child, src)
5375 })?),
5376 None => None,
5377 },
5378 inner: match node.child_by_field_name("inner") {
5379 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5380 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)
5381 })?),
5382 None => None,
5383 },
5384 outer: match node.child_by_field_name("outer") {
5385 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5386 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)
5387 })?),
5388 None => None,
5389 },
5390 })
5391 }
5392}
5393impl ::treesitter_types::Spanned for LineComment<'_> {
5394 fn span(&self) -> ::treesitter_types::Span {
5395 self.span
5396 }
5397}
5398#[derive(Debug, Clone, PartialEq, Eq)]
5399pub struct LoopExpression<'tree> {
5400 pub span: ::treesitter_types::Span,
5401 pub body: Block<'tree>,
5402 pub children: ::core::option::Option<Label<'tree>>,
5403}
5404impl<'tree> ::treesitter_types::FromNode<'tree> for LoopExpression<'tree> {
5405 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5406 fn from_node(
5407 node: ::treesitter_types::tree_sitter::Node<'tree>,
5408 src: &'tree [u8],
5409 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5410 debug_assert_eq!(node.kind(), "loop_expression");
5411 Ok(Self {
5412 span: ::treesitter_types::Span::from(node),
5413 body: {
5414 let child = node
5415 .child_by_field_name("body")
5416 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5417 ::treesitter_types::runtime::maybe_grow_stack(|| {
5418 <Block as ::treesitter_types::FromNode>::from_node(child, src)
5419 })?
5420 },
5421 children: {
5422 #[allow(clippy::suspicious_else_formatting)]
5423 let non_field_children = {
5424 let mut cursor = node.walk();
5425 let mut result = ::std::vec::Vec::new();
5426 if cursor.goto_first_child() {
5427 loop {
5428 if cursor.field_name().is_none()
5429 && cursor.node().is_named()
5430 && !cursor.node().is_extra()
5431 {
5432 result.push(cursor.node());
5433 }
5434 if !cursor.goto_next_sibling() {
5435 break;
5436 }
5437 }
5438 }
5439 result
5440 };
5441 match non_field_children.first() {
5442 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5443 <Label as ::treesitter_types::FromNode>::from_node(child, src)
5444 })?),
5445 None => None,
5446 }
5447 },
5448 })
5449 }
5450}
5451impl ::treesitter_types::Spanned for LoopExpression<'_> {
5452 fn span(&self) -> ::treesitter_types::Span {
5453 self.span
5454 }
5455}
5456#[derive(Debug, Clone, PartialEq, Eq)]
5457pub struct MacroDefinition<'tree> {
5458 pub span: ::treesitter_types::Span,
5459 pub name: Identifier<'tree>,
5460 pub children: ::std::vec::Vec<MacroRule<'tree>>,
5461}
5462impl<'tree> ::treesitter_types::FromNode<'tree> for MacroDefinition<'tree> {
5463 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5464 fn from_node(
5465 node: ::treesitter_types::tree_sitter::Node<'tree>,
5466 src: &'tree [u8],
5467 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5468 debug_assert_eq!(node.kind(), "macro_definition");
5469 Ok(Self {
5470 span: ::treesitter_types::Span::from(node),
5471 name: {
5472 let child = node
5473 .child_by_field_name("name")
5474 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5475 ::treesitter_types::runtime::maybe_grow_stack(|| {
5476 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5477 })?
5478 },
5479 children: {
5480 #[allow(clippy::suspicious_else_formatting)]
5481 let non_field_children = {
5482 let mut cursor = node.walk();
5483 let mut result = ::std::vec::Vec::new();
5484 if cursor.goto_first_child() {
5485 loop {
5486 if cursor.field_name().is_none()
5487 && cursor.node().is_named()
5488 && !cursor.node().is_extra()
5489 {
5490 result.push(cursor.node());
5491 }
5492 if !cursor.goto_next_sibling() {
5493 break;
5494 }
5495 }
5496 }
5497 result
5498 };
5499 let mut items = ::std::vec::Vec::new();
5500 for child in non_field_children {
5501 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5502 <MacroRule as ::treesitter_types::FromNode>::from_node(child, src)
5503 })?);
5504 }
5505 items
5506 },
5507 })
5508 }
5509}
5510impl ::treesitter_types::Spanned for MacroDefinition<'_> {
5511 fn span(&self) -> ::treesitter_types::Span {
5512 self.span
5513 }
5514}
5515#[derive(Debug, Clone, PartialEq, Eq)]
5516pub struct MacroInvocation<'tree> {
5517 pub span: ::treesitter_types::Span,
5518 pub r#macro: MacroInvocationMacro<'tree>,
5519 pub children: TokenTree<'tree>,
5520}
5521impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocation<'tree> {
5522 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5523 fn from_node(
5524 node: ::treesitter_types::tree_sitter::Node<'tree>,
5525 src: &'tree [u8],
5526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5527 debug_assert_eq!(node.kind(), "macro_invocation");
5528 Ok(Self {
5529 span: ::treesitter_types::Span::from(node),
5530 r#macro: {
5531 let child = node
5532 .child_by_field_name("macro")
5533 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("macro", node))?;
5534 ::treesitter_types::runtime::maybe_grow_stack(|| {
5535 <MacroInvocationMacro as ::treesitter_types::FromNode>::from_node(child, src)
5536 })?
5537 },
5538 children: {
5539 #[allow(clippy::suspicious_else_formatting)]
5540 let non_field_children = {
5541 let mut cursor = node.walk();
5542 let mut result = ::std::vec::Vec::new();
5543 if cursor.goto_first_child() {
5544 loop {
5545 if cursor.field_name().is_none()
5546 && cursor.node().is_named()
5547 && !cursor.node().is_extra()
5548 {
5549 result.push(cursor.node());
5550 }
5551 if !cursor.goto_next_sibling() {
5552 break;
5553 }
5554 }
5555 }
5556 result
5557 };
5558 let child = if let Some(&c) = non_field_children.first() {
5559 c
5560 } else {
5561 let mut fallback_cursor = node.walk();
5562 let mut fallback_child = None;
5563 if fallback_cursor.goto_first_child() {
5564 loop {
5565 if fallback_cursor.field_name().is_none()
5566 && !fallback_cursor.node().is_extra()
5567 {
5568 let candidate = fallback_cursor.node();
5569 #[allow(clippy::needless_question_mark)]
5570 if (|| -> ::core::result::Result<
5571 _,
5572 ::treesitter_types::ParseError,
5573 > {
5574 let child = candidate;
5575 Ok(
5576 ::treesitter_types::runtime::maybe_grow_stack(|| <TokenTree as ::treesitter_types::FromNode>::from_node(
5577 child,
5578 src,
5579 ))?,
5580 )
5581 })()
5582 .is_ok()
5583 {
5584 fallback_child = Some(candidate);
5585 break;
5586 }
5587 }
5588 if !fallback_cursor.goto_next_sibling() {
5589 break;
5590 }
5591 }
5592 }
5593 if fallback_child.is_none() {
5594 let mut cursor2 = node.walk();
5595 if cursor2.goto_first_child() {
5596 loop {
5597 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5598 let candidate = cursor2.node();
5599 #[allow(clippy::needless_question_mark)]
5600 if (|| -> ::core::result::Result<
5601 _,
5602 ::treesitter_types::ParseError,
5603 > {
5604 let child = candidate;
5605 Ok(
5606 ::treesitter_types::runtime::maybe_grow_stack(|| <TokenTree as ::treesitter_types::FromNode>::from_node(
5607 child,
5608 src,
5609 ))?,
5610 )
5611 })()
5612 .is_ok()
5613 {
5614 fallback_child = Some(candidate);
5615 break;
5616 }
5617 }
5618 if !cursor2.goto_next_sibling() {
5619 break;
5620 }
5621 }
5622 }
5623 }
5624 fallback_child.ok_or_else(|| {
5625 ::treesitter_types::ParseError::missing_field("children", node)
5626 })?
5627 };
5628 ::treesitter_types::runtime::maybe_grow_stack(|| {
5629 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)
5630 })?
5631 },
5632 })
5633 }
5634}
5635impl ::treesitter_types::Spanned for MacroInvocation<'_> {
5636 fn span(&self) -> ::treesitter_types::Span {
5637 self.span
5638 }
5639}
5640#[derive(Debug, Clone, PartialEq, Eq)]
5641pub struct MacroRule<'tree> {
5642 pub span: ::treesitter_types::Span,
5643 pub left: TokenTreePattern<'tree>,
5644 pub right: TokenTree<'tree>,
5645}
5646impl<'tree> ::treesitter_types::FromNode<'tree> for MacroRule<'tree> {
5647 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5648 fn from_node(
5649 node: ::treesitter_types::tree_sitter::Node<'tree>,
5650 src: &'tree [u8],
5651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5652 debug_assert_eq!(node.kind(), "macro_rule");
5653 Ok(Self {
5654 span: ::treesitter_types::Span::from(node),
5655 left: {
5656 let child = node
5657 .child_by_field_name("left")
5658 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5659 ::treesitter_types::runtime::maybe_grow_stack(|| {
5660 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(child, src)
5661 })?
5662 },
5663 right: {
5664 let child = node
5665 .child_by_field_name("right")
5666 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5667 ::treesitter_types::runtime::maybe_grow_stack(|| {
5668 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)
5669 })?
5670 },
5671 })
5672 }
5673}
5674impl ::treesitter_types::Spanned for MacroRule<'_> {
5675 fn span(&self) -> ::treesitter_types::Span {
5676 self.span
5677 }
5678}
5679#[derive(Debug, Clone, PartialEq, Eq)]
5680pub struct MatchArm<'tree> {
5681 pub span: ::treesitter_types::Span,
5682 pub pattern: MatchPattern<'tree>,
5683 pub value: Expression<'tree>,
5684 pub children: ::std::vec::Vec<MatchArmChildren<'tree>>,
5685}
5686impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArm<'tree> {
5687 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5688 fn from_node(
5689 node: ::treesitter_types::tree_sitter::Node<'tree>,
5690 src: &'tree [u8],
5691 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5692 debug_assert_eq!(node.kind(), "match_arm");
5693 Ok(Self {
5694 span: ::treesitter_types::Span::from(node),
5695 pattern: {
5696 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5697 ::treesitter_types::ParseError::missing_field("pattern", node)
5698 })?;
5699 ::treesitter_types::runtime::maybe_grow_stack(|| {
5700 <MatchPattern as ::treesitter_types::FromNode>::from_node(child, src)
5701 })?
5702 },
5703 value: {
5704 let child = node
5705 .child_by_field_name("value")
5706 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5707 ::treesitter_types::runtime::maybe_grow_stack(|| {
5708 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5709 })?
5710 },
5711 children: {
5712 #[allow(clippy::suspicious_else_formatting)]
5713 let non_field_children = {
5714 let mut cursor = node.walk();
5715 let mut result = ::std::vec::Vec::new();
5716 if cursor.goto_first_child() {
5717 loop {
5718 if cursor.field_name().is_none()
5719 && cursor.node().is_named()
5720 && !cursor.node().is_extra()
5721 {
5722 result.push(cursor.node());
5723 }
5724 if !cursor.goto_next_sibling() {
5725 break;
5726 }
5727 }
5728 }
5729 result
5730 };
5731 let mut items = ::std::vec::Vec::new();
5732 for child in non_field_children {
5733 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5734 <MatchArmChildren as ::treesitter_types::FromNode>::from_node(child, src)
5735 })?);
5736 }
5737 items
5738 },
5739 })
5740 }
5741}
5742impl ::treesitter_types::Spanned for MatchArm<'_> {
5743 fn span(&self) -> ::treesitter_types::Span {
5744 self.span
5745 }
5746}
5747#[derive(Debug, Clone, PartialEq, Eq)]
5748pub struct MatchBlock<'tree> {
5749 pub span: ::treesitter_types::Span,
5750 pub children: ::std::vec::Vec<MatchArm<'tree>>,
5751}
5752impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlock<'tree> {
5753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5754 fn from_node(
5755 node: ::treesitter_types::tree_sitter::Node<'tree>,
5756 src: &'tree [u8],
5757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5758 debug_assert_eq!(node.kind(), "match_block");
5759 Ok(Self {
5760 span: ::treesitter_types::Span::from(node),
5761 children: {
5762 #[allow(clippy::suspicious_else_formatting)]
5763 let non_field_children = {
5764 let mut cursor = node.walk();
5765 let mut result = ::std::vec::Vec::new();
5766 if cursor.goto_first_child() {
5767 loop {
5768 if cursor.field_name().is_none()
5769 && cursor.node().is_named()
5770 && !cursor.node().is_extra()
5771 {
5772 result.push(cursor.node());
5773 }
5774 if !cursor.goto_next_sibling() {
5775 break;
5776 }
5777 }
5778 }
5779 result
5780 };
5781 let mut items = ::std::vec::Vec::new();
5782 for child in non_field_children {
5783 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5784 <MatchArm as ::treesitter_types::FromNode>::from_node(child, src)
5785 })?);
5786 }
5787 items
5788 },
5789 })
5790 }
5791}
5792impl ::treesitter_types::Spanned for MatchBlock<'_> {
5793 fn span(&self) -> ::treesitter_types::Span {
5794 self.span
5795 }
5796}
5797#[derive(Debug, Clone, PartialEq, Eq)]
5798pub struct MatchExpression<'tree> {
5799 pub span: ::treesitter_types::Span,
5800 pub body: MatchBlock<'tree>,
5801 pub value: Expression<'tree>,
5802}
5803impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
5804 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5805 fn from_node(
5806 node: ::treesitter_types::tree_sitter::Node<'tree>,
5807 src: &'tree [u8],
5808 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5809 debug_assert_eq!(node.kind(), "match_expression");
5810 Ok(Self {
5811 span: ::treesitter_types::Span::from(node),
5812 body: {
5813 let child = node
5814 .child_by_field_name("body")
5815 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5816 ::treesitter_types::runtime::maybe_grow_stack(|| {
5817 <MatchBlock as ::treesitter_types::FromNode>::from_node(child, src)
5818 })?
5819 },
5820 value: {
5821 let child = node
5822 .child_by_field_name("value")
5823 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5824 ::treesitter_types::runtime::maybe_grow_stack(|| {
5825 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5826 })?
5827 },
5828 })
5829 }
5830}
5831impl ::treesitter_types::Spanned for MatchExpression<'_> {
5832 fn span(&self) -> ::treesitter_types::Span {
5833 self.span
5834 }
5835}
5836#[derive(Debug, Clone, PartialEq, Eq)]
5837pub struct MatchPattern<'tree> {
5838 pub span: ::treesitter_types::Span,
5839 pub condition: ::core::option::Option<MatchPatternCondition<'tree>>,
5840 pub children: Pattern<'tree>,
5841}
5842impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPattern<'tree> {
5843 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5844 fn from_node(
5845 node: ::treesitter_types::tree_sitter::Node<'tree>,
5846 src: &'tree [u8],
5847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5848 debug_assert_eq!(node.kind(), "match_pattern");
5849 Ok(Self {
5850 span: ::treesitter_types::Span::from(node),
5851 condition: match node.child_by_field_name("condition") {
5852 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5853 <MatchPatternCondition as ::treesitter_types::FromNode>::from_node(child, src)
5854 })?),
5855 None => None,
5856 },
5857 children: {
5858 #[allow(clippy::suspicious_else_formatting)]
5859 let non_field_children = {
5860 let mut cursor = node.walk();
5861 let mut result = ::std::vec::Vec::new();
5862 if cursor.goto_first_child() {
5863 loop {
5864 if cursor.field_name().is_none()
5865 && cursor.node().is_named()
5866 && !cursor.node().is_extra()
5867 {
5868 result.push(cursor.node());
5869 }
5870 if !cursor.goto_next_sibling() {
5871 break;
5872 }
5873 }
5874 }
5875 result
5876 };
5877 let child = if let Some(&c) = non_field_children.first() {
5878 c
5879 } else {
5880 let mut fallback_cursor = node.walk();
5881 let mut fallback_child = None;
5882 if fallback_cursor.goto_first_child() {
5883 loop {
5884 if fallback_cursor.field_name().is_none()
5885 && !fallback_cursor.node().is_extra()
5886 {
5887 let candidate = fallback_cursor.node();
5888 #[allow(clippy::needless_question_mark)]
5889 if (|| -> ::core::result::Result<
5890 _,
5891 ::treesitter_types::ParseError,
5892 > {
5893 let child = candidate;
5894 Ok(
5895 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
5896 child,
5897 src,
5898 ))?,
5899 )
5900 })()
5901 .is_ok()
5902 {
5903 fallback_child = Some(candidate);
5904 break;
5905 }
5906 }
5907 if !fallback_cursor.goto_next_sibling() {
5908 break;
5909 }
5910 }
5911 }
5912 if fallback_child.is_none() {
5913 let mut cursor2 = node.walk();
5914 if cursor2.goto_first_child() {
5915 loop {
5916 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5917 let candidate = cursor2.node();
5918 #[allow(clippy::needless_question_mark)]
5919 if (|| -> ::core::result::Result<
5920 _,
5921 ::treesitter_types::ParseError,
5922 > {
5923 let child = candidate;
5924 Ok(
5925 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
5926 child,
5927 src,
5928 ))?,
5929 )
5930 })()
5931 .is_ok()
5932 {
5933 fallback_child = Some(candidate);
5934 break;
5935 }
5936 }
5937 if !cursor2.goto_next_sibling() {
5938 break;
5939 }
5940 }
5941 }
5942 }
5943 fallback_child.ok_or_else(|| {
5944 ::treesitter_types::ParseError::missing_field("children", node)
5945 })?
5946 };
5947 ::treesitter_types::runtime::maybe_grow_stack(|| {
5948 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
5949 })?
5950 },
5951 })
5952 }
5953}
5954impl ::treesitter_types::Spanned for MatchPattern<'_> {
5955 fn span(&self) -> ::treesitter_types::Span {
5956 self.span
5957 }
5958}
5959#[derive(Debug, Clone, PartialEq, Eq)]
5960pub struct ModItem<'tree> {
5961 pub span: ::treesitter_types::Span,
5962 pub body: ::core::option::Option<DeclarationList<'tree>>,
5963 pub name: Identifier<'tree>,
5964 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
5965}
5966impl<'tree> ::treesitter_types::FromNode<'tree> for ModItem<'tree> {
5967 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5968 fn from_node(
5969 node: ::treesitter_types::tree_sitter::Node<'tree>,
5970 src: &'tree [u8],
5971 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5972 debug_assert_eq!(node.kind(), "mod_item");
5973 Ok(Self {
5974 span: ::treesitter_types::Span::from(node),
5975 body: match node.child_by_field_name("body") {
5976 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5977 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
5978 })?),
5979 None => None,
5980 },
5981 name: {
5982 let child = node
5983 .child_by_field_name("name")
5984 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5985 ::treesitter_types::runtime::maybe_grow_stack(|| {
5986 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5987 })?
5988 },
5989 children: {
5990 #[allow(clippy::suspicious_else_formatting)]
5991 let non_field_children = {
5992 let mut cursor = node.walk();
5993 let mut result = ::std::vec::Vec::new();
5994 if cursor.goto_first_child() {
5995 loop {
5996 if cursor.field_name().is_none()
5997 && cursor.node().is_named()
5998 && !cursor.node().is_extra()
5999 {
6000 result.push(cursor.node());
6001 }
6002 if !cursor.goto_next_sibling() {
6003 break;
6004 }
6005 }
6006 }
6007 result
6008 };
6009 match non_field_children.first() {
6010 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6011 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
6012 })?),
6013 None => None,
6014 }
6015 },
6016 })
6017 }
6018}
6019impl ::treesitter_types::Spanned for ModItem<'_> {
6020 fn span(&self) -> ::treesitter_types::Span {
6021 self.span
6022 }
6023}
6024#[derive(Debug, Clone, PartialEq, Eq)]
6025pub struct MutPattern<'tree> {
6026 pub span: ::treesitter_types::Span,
6027 pub children: ::std::vec::Vec<MutPatternChildren<'tree>>,
6028}
6029impl<'tree> ::treesitter_types::FromNode<'tree> for MutPattern<'tree> {
6030 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6031 fn from_node(
6032 node: ::treesitter_types::tree_sitter::Node<'tree>,
6033 src: &'tree [u8],
6034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6035 debug_assert_eq!(node.kind(), "mut_pattern");
6036 Ok(Self {
6037 span: ::treesitter_types::Span::from(node),
6038 children: {
6039 #[allow(clippy::suspicious_else_formatting)]
6040 let non_field_children = {
6041 let mut cursor = node.walk();
6042 let mut result = ::std::vec::Vec::new();
6043 if cursor.goto_first_child() {
6044 loop {
6045 if cursor.field_name().is_none()
6046 && cursor.node().is_named()
6047 && !cursor.node().is_extra()
6048 {
6049 result.push(cursor.node());
6050 }
6051 if !cursor.goto_next_sibling() {
6052 break;
6053 }
6054 }
6055 }
6056 result
6057 };
6058 let mut items = ::std::vec::Vec::new();
6059 for child in non_field_children {
6060 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6061 <MutPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
6062 })?);
6063 }
6064 items
6065 },
6066 })
6067 }
6068}
6069impl ::treesitter_types::Spanned for MutPattern<'_> {
6070 fn span(&self) -> ::treesitter_types::Span {
6071 self.span
6072 }
6073}
6074#[derive(Debug, Clone, PartialEq, Eq)]
6075pub struct NegativeLiteral<'tree> {
6076 pub span: ::treesitter_types::Span,
6077 pub children: NegativeLiteralChildren<'tree>,
6078}
6079impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteral<'tree> {
6080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6081 fn from_node(
6082 node: ::treesitter_types::tree_sitter::Node<'tree>,
6083 src: &'tree [u8],
6084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6085 debug_assert_eq!(node.kind(), "negative_literal");
6086 Ok(Self {
6087 span: ::treesitter_types::Span::from(node),
6088 children: {
6089 #[allow(clippy::suspicious_else_formatting)]
6090 let non_field_children = {
6091 let mut cursor = node.walk();
6092 let mut result = ::std::vec::Vec::new();
6093 if cursor.goto_first_child() {
6094 loop {
6095 if cursor.field_name().is_none()
6096 && cursor.node().is_named()
6097 && !cursor.node().is_extra()
6098 {
6099 result.push(cursor.node());
6100 }
6101 if !cursor.goto_next_sibling() {
6102 break;
6103 }
6104 }
6105 }
6106 result
6107 };
6108 let child = if let Some(&c) = non_field_children.first() {
6109 c
6110 } else {
6111 let mut fallback_cursor = node.walk();
6112 let mut fallback_child = None;
6113 if fallback_cursor.goto_first_child() {
6114 loop {
6115 if fallback_cursor.field_name().is_none()
6116 && !fallback_cursor.node().is_extra()
6117 {
6118 let candidate = fallback_cursor.node();
6119 #[allow(clippy::needless_question_mark)]
6120 if (|| -> ::core::result::Result<
6121 _,
6122 ::treesitter_types::ParseError,
6123 > {
6124 let child = candidate;
6125 Ok(
6126 ::treesitter_types::runtime::maybe_grow_stack(|| <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(
6127 child,
6128 src,
6129 ))?,
6130 )
6131 })()
6132 .is_ok()
6133 {
6134 fallback_child = Some(candidate);
6135 break;
6136 }
6137 }
6138 if !fallback_cursor.goto_next_sibling() {
6139 break;
6140 }
6141 }
6142 }
6143 if fallback_child.is_none() {
6144 let mut cursor2 = node.walk();
6145 if cursor2.goto_first_child() {
6146 loop {
6147 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6148 let candidate = cursor2.node();
6149 #[allow(clippy::needless_question_mark)]
6150 if (|| -> ::core::result::Result<
6151 _,
6152 ::treesitter_types::ParseError,
6153 > {
6154 let child = candidate;
6155 Ok(
6156 ::treesitter_types::runtime::maybe_grow_stack(|| <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(
6157 child,
6158 src,
6159 ))?,
6160 )
6161 })()
6162 .is_ok()
6163 {
6164 fallback_child = Some(candidate);
6165 break;
6166 }
6167 }
6168 if !cursor2.goto_next_sibling() {
6169 break;
6170 }
6171 }
6172 }
6173 }
6174 fallback_child.ok_or_else(|| {
6175 ::treesitter_types::ParseError::missing_field("children", node)
6176 })?
6177 };
6178 ::treesitter_types::runtime::maybe_grow_stack(|| {
6179 <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)
6180 })?
6181 },
6182 })
6183 }
6184}
6185impl ::treesitter_types::Spanned for NegativeLiteral<'_> {
6186 fn span(&self) -> ::treesitter_types::Span {
6187 self.span
6188 }
6189}
6190#[derive(Debug, Clone, PartialEq, Eq)]
6191pub struct NeverType<'tree> {
6192 pub span: ::treesitter_types::Span,
6193 text: &'tree str,
6194}
6195impl<'tree> ::treesitter_types::FromNode<'tree> for NeverType<'tree> {
6196 fn from_node(
6197 node: ::treesitter_types::tree_sitter::Node<'tree>,
6198 src: &'tree [u8],
6199 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6200 debug_assert_eq!(node.kind(), "never_type");
6201 Ok(Self {
6202 span: ::treesitter_types::Span::from(node),
6203 text: node.utf8_text(src)?,
6204 })
6205 }
6206}
6207impl<'tree> ::treesitter_types::LeafNode<'tree> for NeverType<'tree> {
6208 fn text(&self) -> &'tree str {
6209 self.text
6210 }
6211}
6212impl ::treesitter_types::Spanned for NeverType<'_> {
6213 fn span(&self) -> ::treesitter_types::Span {
6214 self.span
6215 }
6216}
6217#[derive(Debug, Clone, PartialEq, Eq)]
6218pub struct OrPattern<'tree> {
6219 pub span: ::treesitter_types::Span,
6220 pub children: ::std::vec::Vec<Pattern<'tree>>,
6221}
6222impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
6223 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6224 fn from_node(
6225 node: ::treesitter_types::tree_sitter::Node<'tree>,
6226 src: &'tree [u8],
6227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6228 debug_assert_eq!(node.kind(), "or_pattern");
6229 Ok(Self {
6230 span: ::treesitter_types::Span::from(node),
6231 children: {
6232 #[allow(clippy::suspicious_else_formatting)]
6233 let non_field_children = {
6234 let mut cursor = node.walk();
6235 let mut result = ::std::vec::Vec::new();
6236 if cursor.goto_first_child() {
6237 loop {
6238 if cursor.field_name().is_none()
6239 && cursor.node().is_named()
6240 && !cursor.node().is_extra()
6241 {
6242 result.push(cursor.node());
6243 }
6244 if !cursor.goto_next_sibling() {
6245 break;
6246 }
6247 }
6248 }
6249 result
6250 };
6251 let mut items = ::std::vec::Vec::new();
6252 for child in non_field_children {
6253 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6254 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
6255 })?);
6256 }
6257 items
6258 },
6259 })
6260 }
6261}
6262impl ::treesitter_types::Spanned for OrPattern<'_> {
6263 fn span(&self) -> ::treesitter_types::Span {
6264 self.span
6265 }
6266}
6267#[derive(Debug, Clone, PartialEq, Eq)]
6268pub struct OrderedFieldDeclarationList<'tree> {
6269 pub span: ::treesitter_types::Span,
6270 pub r#type: ::std::vec::Vec<Type<'tree>>,
6271 pub children: ::std::vec::Vec<OrderedFieldDeclarationListChildren<'tree>>,
6272}
6273impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationList<'tree> {
6274 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6275 fn from_node(
6276 node: ::treesitter_types::tree_sitter::Node<'tree>,
6277 src: &'tree [u8],
6278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6279 debug_assert_eq!(node.kind(), "ordered_field_declaration_list");
6280 Ok(Self {
6281 span: ::treesitter_types::Span::from(node),
6282 r#type: {
6283 let mut cursor = node.walk();
6284 let mut items = ::std::vec::Vec::new();
6285 for child in node.children_by_field_name("type", &mut cursor) {
6286 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6287 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6288 })?);
6289 }
6290 items
6291 },
6292 children: {
6293 #[allow(clippy::suspicious_else_formatting)]
6294 let non_field_children = {
6295 let mut cursor = node.walk();
6296 let mut result = ::std::vec::Vec::new();
6297 if cursor.goto_first_child() {
6298 loop {
6299 if cursor.field_name().is_none()
6300 && cursor.node().is_named()
6301 && !cursor.node().is_extra()
6302 {
6303 result.push(cursor.node());
6304 }
6305 if !cursor.goto_next_sibling() {
6306 break;
6307 }
6308 }
6309 }
6310 result
6311 };
6312 let mut items = ::std::vec::Vec::new();
6313 for child in non_field_children {
6314 items
6315 .push(
6316 ::treesitter_types::runtime::maybe_grow_stack(|| <OrderedFieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
6317 child,
6318 src,
6319 ))?,
6320 );
6321 }
6322 items
6323 },
6324 })
6325 }
6326}
6327impl ::treesitter_types::Spanned for OrderedFieldDeclarationList<'_> {
6328 fn span(&self) -> ::treesitter_types::Span {
6329 self.span
6330 }
6331}
6332#[derive(Debug, Clone, PartialEq, Eq)]
6333pub struct OuterDocCommentMarker<'tree> {
6334 pub span: ::treesitter_types::Span,
6335 text: &'tree str,
6336}
6337impl<'tree> ::treesitter_types::FromNode<'tree> for OuterDocCommentMarker<'tree> {
6338 fn from_node(
6339 node: ::treesitter_types::tree_sitter::Node<'tree>,
6340 src: &'tree [u8],
6341 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6342 debug_assert_eq!(node.kind(), "outer_doc_comment_marker");
6343 Ok(Self {
6344 span: ::treesitter_types::Span::from(node),
6345 text: node.utf8_text(src)?,
6346 })
6347 }
6348}
6349impl<'tree> ::treesitter_types::LeafNode<'tree> for OuterDocCommentMarker<'tree> {
6350 fn text(&self) -> &'tree str {
6351 self.text
6352 }
6353}
6354impl ::treesitter_types::Spanned for OuterDocCommentMarker<'_> {
6355 fn span(&self) -> ::treesitter_types::Span {
6356 self.span
6357 }
6358}
6359#[derive(Debug, Clone, PartialEq, Eq)]
6360pub struct Parameter<'tree> {
6361 pub span: ::treesitter_types::Span,
6362 pub pattern: ParameterPattern<'tree>,
6363 pub r#type: Type<'tree>,
6364 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
6365}
6366impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
6367 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6368 fn from_node(
6369 node: ::treesitter_types::tree_sitter::Node<'tree>,
6370 src: &'tree [u8],
6371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6372 debug_assert_eq!(node.kind(), "parameter");
6373 Ok(Self {
6374 span: ::treesitter_types::Span::from(node),
6375 pattern: {
6376 let child = node.child_by_field_name("pattern").ok_or_else(|| {
6377 ::treesitter_types::ParseError::missing_field("pattern", node)
6378 })?;
6379 ::treesitter_types::runtime::maybe_grow_stack(|| {
6380 <ParameterPattern as ::treesitter_types::FromNode>::from_node(child, src)
6381 })?
6382 },
6383 r#type: {
6384 let child = node
6385 .child_by_field_name("type")
6386 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6387 ::treesitter_types::runtime::maybe_grow_stack(|| {
6388 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6389 })?
6390 },
6391 children: {
6392 #[allow(clippy::suspicious_else_formatting)]
6393 let non_field_children = {
6394 let mut cursor = node.walk();
6395 let mut result = ::std::vec::Vec::new();
6396 if cursor.goto_first_child() {
6397 loop {
6398 if cursor.field_name().is_none()
6399 && cursor.node().is_named()
6400 && !cursor.node().is_extra()
6401 {
6402 result.push(cursor.node());
6403 }
6404 if !cursor.goto_next_sibling() {
6405 break;
6406 }
6407 }
6408 }
6409 result
6410 };
6411 match non_field_children.first() {
6412 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6413 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
6414 })?),
6415 None => None,
6416 }
6417 },
6418 })
6419 }
6420}
6421impl ::treesitter_types::Spanned for Parameter<'_> {
6422 fn span(&self) -> ::treesitter_types::Span {
6423 self.span
6424 }
6425}
6426#[derive(Debug, Clone, PartialEq, Eq)]
6427pub struct Parameters<'tree> {
6428 pub span: ::treesitter_types::Span,
6429 pub children: ::std::vec::Vec<ParametersChildren<'tree>>,
6430}
6431impl<'tree> ::treesitter_types::FromNode<'tree> for Parameters<'tree> {
6432 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6433 fn from_node(
6434 node: ::treesitter_types::tree_sitter::Node<'tree>,
6435 src: &'tree [u8],
6436 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6437 debug_assert_eq!(node.kind(), "parameters");
6438 Ok(Self {
6439 span: ::treesitter_types::Span::from(node),
6440 children: {
6441 #[allow(clippy::suspicious_else_formatting)]
6442 let non_field_children = {
6443 let mut cursor = node.walk();
6444 let mut result = ::std::vec::Vec::new();
6445 if cursor.goto_first_child() {
6446 loop {
6447 if cursor.field_name().is_none()
6448 && cursor.node().is_named()
6449 && !cursor.node().is_extra()
6450 {
6451 result.push(cursor.node());
6452 }
6453 if !cursor.goto_next_sibling() {
6454 break;
6455 }
6456 }
6457 }
6458 result
6459 };
6460 let mut items = ::std::vec::Vec::new();
6461 for child in non_field_children {
6462 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6463 <ParametersChildren as ::treesitter_types::FromNode>::from_node(child, src)
6464 })?);
6465 }
6466 items
6467 },
6468 })
6469 }
6470}
6471impl ::treesitter_types::Spanned for Parameters<'_> {
6472 fn span(&self) -> ::treesitter_types::Span {
6473 self.span
6474 }
6475}
6476#[derive(Debug, Clone, PartialEq, Eq)]
6477pub struct ParenthesizedExpression<'tree> {
6478 pub span: ::treesitter_types::Span,
6479 pub children: Expression<'tree>,
6480}
6481impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
6482 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6483 fn from_node(
6484 node: ::treesitter_types::tree_sitter::Node<'tree>,
6485 src: &'tree [u8],
6486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6487 debug_assert_eq!(node.kind(), "parenthesized_expression");
6488 Ok(Self {
6489 span: ::treesitter_types::Span::from(node),
6490 children: {
6491 #[allow(clippy::suspicious_else_formatting)]
6492 let non_field_children = {
6493 let mut cursor = node.walk();
6494 let mut result = ::std::vec::Vec::new();
6495 if cursor.goto_first_child() {
6496 loop {
6497 if cursor.field_name().is_none()
6498 && cursor.node().is_named()
6499 && !cursor.node().is_extra()
6500 {
6501 result.push(cursor.node());
6502 }
6503 if !cursor.goto_next_sibling() {
6504 break;
6505 }
6506 }
6507 }
6508 result
6509 };
6510 let child = if let Some(&c) = non_field_children.first() {
6511 c
6512 } else {
6513 let mut fallback_cursor = node.walk();
6514 let mut fallback_child = None;
6515 if fallback_cursor.goto_first_child() {
6516 loop {
6517 if fallback_cursor.field_name().is_none()
6518 && !fallback_cursor.node().is_extra()
6519 {
6520 let candidate = fallback_cursor.node();
6521 #[allow(clippy::needless_question_mark)]
6522 if (|| -> ::core::result::Result<
6523 _,
6524 ::treesitter_types::ParseError,
6525 > {
6526 let child = candidate;
6527 Ok(
6528 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6529 child,
6530 src,
6531 ))?,
6532 )
6533 })()
6534 .is_ok()
6535 {
6536 fallback_child = Some(candidate);
6537 break;
6538 }
6539 }
6540 if !fallback_cursor.goto_next_sibling() {
6541 break;
6542 }
6543 }
6544 }
6545 if fallback_child.is_none() {
6546 let mut cursor2 = node.walk();
6547 if cursor2.goto_first_child() {
6548 loop {
6549 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6550 let candidate = cursor2.node();
6551 #[allow(clippy::needless_question_mark)]
6552 if (|| -> ::core::result::Result<
6553 _,
6554 ::treesitter_types::ParseError,
6555 > {
6556 let child = candidate;
6557 Ok(
6558 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6559 child,
6560 src,
6561 ))?,
6562 )
6563 })()
6564 .is_ok()
6565 {
6566 fallback_child = Some(candidate);
6567 break;
6568 }
6569 }
6570 if !cursor2.goto_next_sibling() {
6571 break;
6572 }
6573 }
6574 }
6575 }
6576 fallback_child.ok_or_else(|| {
6577 ::treesitter_types::ParseError::missing_field("children", node)
6578 })?
6579 };
6580 ::treesitter_types::runtime::maybe_grow_stack(|| {
6581 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6582 })?
6583 },
6584 })
6585 }
6586}
6587impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
6588 fn span(&self) -> ::treesitter_types::Span {
6589 self.span
6590 }
6591}
6592#[derive(Debug, Clone, PartialEq, Eq)]
6593pub struct PointerType<'tree> {
6594 pub span: ::treesitter_types::Span,
6595 pub r#type: Type<'tree>,
6596 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
6597}
6598impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
6599 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6600 fn from_node(
6601 node: ::treesitter_types::tree_sitter::Node<'tree>,
6602 src: &'tree [u8],
6603 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6604 debug_assert_eq!(node.kind(), "pointer_type");
6605 Ok(Self {
6606 span: ::treesitter_types::Span::from(node),
6607 r#type: {
6608 let child = node
6609 .child_by_field_name("type")
6610 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6611 ::treesitter_types::runtime::maybe_grow_stack(|| {
6612 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6613 })?
6614 },
6615 children: {
6616 #[allow(clippy::suspicious_else_formatting)]
6617 let non_field_children = {
6618 let mut cursor = node.walk();
6619 let mut result = ::std::vec::Vec::new();
6620 if cursor.goto_first_child() {
6621 loop {
6622 if cursor.field_name().is_none()
6623 && cursor.node().is_named()
6624 && !cursor.node().is_extra()
6625 {
6626 result.push(cursor.node());
6627 }
6628 if !cursor.goto_next_sibling() {
6629 break;
6630 }
6631 }
6632 }
6633 result
6634 };
6635 match non_field_children.first() {
6636 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6637 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
6638 })?),
6639 None => None,
6640 }
6641 },
6642 })
6643 }
6644}
6645impl ::treesitter_types::Spanned for PointerType<'_> {
6646 fn span(&self) -> ::treesitter_types::Span {
6647 self.span
6648 }
6649}
6650#[derive(Debug, Clone, PartialEq, Eq)]
6651pub struct QualifiedType<'tree> {
6652 pub span: ::treesitter_types::Span,
6653 pub alias: Type<'tree>,
6654 pub r#type: Type<'tree>,
6655}
6656impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedType<'tree> {
6657 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6658 fn from_node(
6659 node: ::treesitter_types::tree_sitter::Node<'tree>,
6660 src: &'tree [u8],
6661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6662 debug_assert_eq!(node.kind(), "qualified_type");
6663 Ok(Self {
6664 span: ::treesitter_types::Span::from(node),
6665 alias: {
6666 let child = node
6667 .child_by_field_name("alias")
6668 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
6669 ::treesitter_types::runtime::maybe_grow_stack(|| {
6670 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6671 })?
6672 },
6673 r#type: {
6674 let child = node
6675 .child_by_field_name("type")
6676 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6677 ::treesitter_types::runtime::maybe_grow_stack(|| {
6678 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6679 })?
6680 },
6681 })
6682 }
6683}
6684impl ::treesitter_types::Spanned for QualifiedType<'_> {
6685 fn span(&self) -> ::treesitter_types::Span {
6686 self.span
6687 }
6688}
6689#[derive(Debug, Clone, PartialEq, Eq)]
6690pub struct RangeExpression<'tree> {
6691 pub span: ::treesitter_types::Span,
6692 pub children: ::std::vec::Vec<Expression<'tree>>,
6693}
6694impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
6695 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6696 fn from_node(
6697 node: ::treesitter_types::tree_sitter::Node<'tree>,
6698 src: &'tree [u8],
6699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6700 debug_assert_eq!(node.kind(), "range_expression");
6701 Ok(Self {
6702 span: ::treesitter_types::Span::from(node),
6703 children: {
6704 #[allow(clippy::suspicious_else_formatting)]
6705 let non_field_children = {
6706 let mut cursor = node.walk();
6707 let mut result = ::std::vec::Vec::new();
6708 if cursor.goto_first_child() {
6709 loop {
6710 if cursor.field_name().is_none()
6711 && cursor.node().is_named()
6712 && !cursor.node().is_extra()
6713 {
6714 result.push(cursor.node());
6715 }
6716 if !cursor.goto_next_sibling() {
6717 break;
6718 }
6719 }
6720 }
6721 result
6722 };
6723 let mut items = ::std::vec::Vec::new();
6724 for child in non_field_children {
6725 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6726 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6727 })?);
6728 }
6729 items
6730 },
6731 })
6732 }
6733}
6734impl ::treesitter_types::Spanned for RangeExpression<'_> {
6735 fn span(&self) -> ::treesitter_types::Span {
6736 self.span
6737 }
6738}
6739#[derive(Debug, Clone, PartialEq, Eq)]
6740pub struct RangePattern<'tree> {
6741 pub span: ::treesitter_types::Span,
6742 pub left: ::core::option::Option<RangePatternLeft<'tree>>,
6743 pub right: ::core::option::Option<RangePatternRight<'tree>>,
6744}
6745impl<'tree> ::treesitter_types::FromNode<'tree> for RangePattern<'tree> {
6746 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6747 fn from_node(
6748 node: ::treesitter_types::tree_sitter::Node<'tree>,
6749 src: &'tree [u8],
6750 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6751 debug_assert_eq!(node.kind(), "range_pattern");
6752 Ok(Self {
6753 span: ::treesitter_types::Span::from(node),
6754 left: match node.child_by_field_name("left") {
6755 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6756 <RangePatternLeft as ::treesitter_types::FromNode>::from_node(child, src)
6757 })?),
6758 None => None,
6759 },
6760 right: match node.child_by_field_name("right") {
6761 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6762 <RangePatternRight as ::treesitter_types::FromNode>::from_node(child, src)
6763 })?),
6764 None => None,
6765 },
6766 })
6767 }
6768}
6769impl ::treesitter_types::Spanned for RangePattern<'_> {
6770 fn span(&self) -> ::treesitter_types::Span {
6771 self.span
6772 }
6773}
6774#[derive(Debug, Clone, PartialEq, Eq)]
6775pub struct RawStringLiteral<'tree> {
6776 pub span: ::treesitter_types::Span,
6777 pub children: StringContent<'tree>,
6778}
6779impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
6780 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6781 fn from_node(
6782 node: ::treesitter_types::tree_sitter::Node<'tree>,
6783 src: &'tree [u8],
6784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6785 debug_assert_eq!(node.kind(), "raw_string_literal");
6786 Ok(Self {
6787 span: ::treesitter_types::Span::from(node),
6788 children: {
6789 #[allow(clippy::suspicious_else_formatting)]
6790 let non_field_children = {
6791 let mut cursor = node.walk();
6792 let mut result = ::std::vec::Vec::new();
6793 if cursor.goto_first_child() {
6794 loop {
6795 if cursor.field_name().is_none()
6796 && cursor.node().is_named()
6797 && !cursor.node().is_extra()
6798 {
6799 result.push(cursor.node());
6800 }
6801 if !cursor.goto_next_sibling() {
6802 break;
6803 }
6804 }
6805 }
6806 result
6807 };
6808 let child = if let Some(&c) = non_field_children.first() {
6809 c
6810 } else {
6811 let mut fallback_cursor = node.walk();
6812 let mut fallback_child = None;
6813 if fallback_cursor.goto_first_child() {
6814 loop {
6815 if fallback_cursor.field_name().is_none()
6816 && !fallback_cursor.node().is_extra()
6817 {
6818 let candidate = fallback_cursor.node();
6819 #[allow(clippy::needless_question_mark)]
6820 if (|| -> ::core::result::Result<
6821 _,
6822 ::treesitter_types::ParseError,
6823 > {
6824 let child = candidate;
6825 Ok(
6826 ::treesitter_types::runtime::maybe_grow_stack(|| <StringContent as ::treesitter_types::FromNode>::from_node(
6827 child,
6828 src,
6829 ))?,
6830 )
6831 })()
6832 .is_ok()
6833 {
6834 fallback_child = Some(candidate);
6835 break;
6836 }
6837 }
6838 if !fallback_cursor.goto_next_sibling() {
6839 break;
6840 }
6841 }
6842 }
6843 if fallback_child.is_none() {
6844 let mut cursor2 = node.walk();
6845 if cursor2.goto_first_child() {
6846 loop {
6847 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6848 let candidate = cursor2.node();
6849 #[allow(clippy::needless_question_mark)]
6850 if (|| -> ::core::result::Result<
6851 _,
6852 ::treesitter_types::ParseError,
6853 > {
6854 let child = candidate;
6855 Ok(
6856 ::treesitter_types::runtime::maybe_grow_stack(|| <StringContent as ::treesitter_types::FromNode>::from_node(
6857 child,
6858 src,
6859 ))?,
6860 )
6861 })()
6862 .is_ok()
6863 {
6864 fallback_child = Some(candidate);
6865 break;
6866 }
6867 }
6868 if !cursor2.goto_next_sibling() {
6869 break;
6870 }
6871 }
6872 }
6873 }
6874 fallback_child.ok_or_else(|| {
6875 ::treesitter_types::ParseError::missing_field("children", node)
6876 })?
6877 };
6878 ::treesitter_types::runtime::maybe_grow_stack(|| {
6879 <StringContent as ::treesitter_types::FromNode>::from_node(child, src)
6880 })?
6881 },
6882 })
6883 }
6884}
6885impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
6886 fn span(&self) -> ::treesitter_types::Span {
6887 self.span
6888 }
6889}
6890#[derive(Debug, Clone, PartialEq, Eq)]
6891pub struct RefPattern<'tree> {
6892 pub span: ::treesitter_types::Span,
6893 pub children: Pattern<'tree>,
6894}
6895impl<'tree> ::treesitter_types::FromNode<'tree> for RefPattern<'tree> {
6896 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6897 fn from_node(
6898 node: ::treesitter_types::tree_sitter::Node<'tree>,
6899 src: &'tree [u8],
6900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6901 debug_assert_eq!(node.kind(), "ref_pattern");
6902 Ok(Self {
6903 span: ::treesitter_types::Span::from(node),
6904 children: {
6905 #[allow(clippy::suspicious_else_formatting)]
6906 let non_field_children = {
6907 let mut cursor = node.walk();
6908 let mut result = ::std::vec::Vec::new();
6909 if cursor.goto_first_child() {
6910 loop {
6911 if cursor.field_name().is_none()
6912 && cursor.node().is_named()
6913 && !cursor.node().is_extra()
6914 {
6915 result.push(cursor.node());
6916 }
6917 if !cursor.goto_next_sibling() {
6918 break;
6919 }
6920 }
6921 }
6922 result
6923 };
6924 let child = if let Some(&c) = non_field_children.first() {
6925 c
6926 } else {
6927 let mut fallback_cursor = node.walk();
6928 let mut fallback_child = None;
6929 if fallback_cursor.goto_first_child() {
6930 loop {
6931 if fallback_cursor.field_name().is_none()
6932 && !fallback_cursor.node().is_extra()
6933 {
6934 let candidate = fallback_cursor.node();
6935 #[allow(clippy::needless_question_mark)]
6936 if (|| -> ::core::result::Result<
6937 _,
6938 ::treesitter_types::ParseError,
6939 > {
6940 let child = candidate;
6941 Ok(
6942 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
6943 child,
6944 src,
6945 ))?,
6946 )
6947 })()
6948 .is_ok()
6949 {
6950 fallback_child = Some(candidate);
6951 break;
6952 }
6953 }
6954 if !fallback_cursor.goto_next_sibling() {
6955 break;
6956 }
6957 }
6958 }
6959 if fallback_child.is_none() {
6960 let mut cursor2 = node.walk();
6961 if cursor2.goto_first_child() {
6962 loop {
6963 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6964 let candidate = cursor2.node();
6965 #[allow(clippy::needless_question_mark)]
6966 if (|| -> ::core::result::Result<
6967 _,
6968 ::treesitter_types::ParseError,
6969 > {
6970 let child = candidate;
6971 Ok(
6972 ::treesitter_types::runtime::maybe_grow_stack(|| <Pattern as ::treesitter_types::FromNode>::from_node(
6973 child,
6974 src,
6975 ))?,
6976 )
6977 })()
6978 .is_ok()
6979 {
6980 fallback_child = Some(candidate);
6981 break;
6982 }
6983 }
6984 if !cursor2.goto_next_sibling() {
6985 break;
6986 }
6987 }
6988 }
6989 }
6990 fallback_child.ok_or_else(|| {
6991 ::treesitter_types::ParseError::missing_field("children", node)
6992 })?
6993 };
6994 ::treesitter_types::runtime::maybe_grow_stack(|| {
6995 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
6996 })?
6997 },
6998 })
6999 }
7000}
7001impl ::treesitter_types::Spanned for RefPattern<'_> {
7002 fn span(&self) -> ::treesitter_types::Span {
7003 self.span
7004 }
7005}
7006#[derive(Debug, Clone, PartialEq, Eq)]
7007pub struct ReferenceExpression<'tree> {
7008 pub span: ::treesitter_types::Span,
7009 pub value: Expression<'tree>,
7010 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
7011}
7012impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceExpression<'tree> {
7013 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7014 fn from_node(
7015 node: ::treesitter_types::tree_sitter::Node<'tree>,
7016 src: &'tree [u8],
7017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7018 debug_assert_eq!(node.kind(), "reference_expression");
7019 Ok(Self {
7020 span: ::treesitter_types::Span::from(node),
7021 value: {
7022 let child = node
7023 .child_by_field_name("value")
7024 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
7025 ::treesitter_types::runtime::maybe_grow_stack(|| {
7026 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7027 })?
7028 },
7029 children: {
7030 #[allow(clippy::suspicious_else_formatting)]
7031 let non_field_children = {
7032 let mut cursor = node.walk();
7033 let mut result = ::std::vec::Vec::new();
7034 if cursor.goto_first_child() {
7035 loop {
7036 if cursor.field_name().is_none()
7037 && cursor.node().is_named()
7038 && !cursor.node().is_extra()
7039 {
7040 result.push(cursor.node());
7041 }
7042 if !cursor.goto_next_sibling() {
7043 break;
7044 }
7045 }
7046 }
7047 result
7048 };
7049 match non_field_children.first() {
7050 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7051 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7052 })?),
7053 None => None,
7054 }
7055 },
7056 })
7057 }
7058}
7059impl ::treesitter_types::Spanned for ReferenceExpression<'_> {
7060 fn span(&self) -> ::treesitter_types::Span {
7061 self.span
7062 }
7063}
7064#[derive(Debug, Clone, PartialEq, Eq)]
7065pub struct ReferencePattern<'tree> {
7066 pub span: ::treesitter_types::Span,
7067 pub children: ::std::vec::Vec<ReferencePatternChildren<'tree>>,
7068}
7069impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePattern<'tree> {
7070 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7071 fn from_node(
7072 node: ::treesitter_types::tree_sitter::Node<'tree>,
7073 src: &'tree [u8],
7074 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7075 debug_assert_eq!(node.kind(), "reference_pattern");
7076 Ok(Self {
7077 span: ::treesitter_types::Span::from(node),
7078 children: {
7079 #[allow(clippy::suspicious_else_formatting)]
7080 let non_field_children = {
7081 let mut cursor = node.walk();
7082 let mut result = ::std::vec::Vec::new();
7083 if cursor.goto_first_child() {
7084 loop {
7085 if cursor.field_name().is_none()
7086 && cursor.node().is_named()
7087 && !cursor.node().is_extra()
7088 {
7089 result.push(cursor.node());
7090 }
7091 if !cursor.goto_next_sibling() {
7092 break;
7093 }
7094 }
7095 }
7096 result
7097 };
7098 let mut items = ::std::vec::Vec::new();
7099 for child in non_field_children {
7100 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7101 <ReferencePatternChildren as ::treesitter_types::FromNode>::from_node(
7102 child, src,
7103 )
7104 })?);
7105 }
7106 items
7107 },
7108 })
7109 }
7110}
7111impl ::treesitter_types::Spanned for ReferencePattern<'_> {
7112 fn span(&self) -> ::treesitter_types::Span {
7113 self.span
7114 }
7115}
7116#[derive(Debug, Clone, PartialEq, Eq)]
7117pub struct ReferenceType<'tree> {
7118 pub span: ::treesitter_types::Span,
7119 pub r#type: Type<'tree>,
7120 pub children: ::std::vec::Vec<ReferenceTypeChildren<'tree>>,
7121}
7122impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceType<'tree> {
7123 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7124 fn from_node(
7125 node: ::treesitter_types::tree_sitter::Node<'tree>,
7126 src: &'tree [u8],
7127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7128 debug_assert_eq!(node.kind(), "reference_type");
7129 Ok(Self {
7130 span: ::treesitter_types::Span::from(node),
7131 r#type: {
7132 let child = node
7133 .child_by_field_name("type")
7134 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7135 ::treesitter_types::runtime::maybe_grow_stack(|| {
7136 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7137 })?
7138 },
7139 children: {
7140 #[allow(clippy::suspicious_else_formatting)]
7141 let non_field_children = {
7142 let mut cursor = node.walk();
7143 let mut result = ::std::vec::Vec::new();
7144 if cursor.goto_first_child() {
7145 loop {
7146 if cursor.field_name().is_none()
7147 && cursor.node().is_named()
7148 && !cursor.node().is_extra()
7149 {
7150 result.push(cursor.node());
7151 }
7152 if !cursor.goto_next_sibling() {
7153 break;
7154 }
7155 }
7156 }
7157 result
7158 };
7159 let mut items = ::std::vec::Vec::new();
7160 for child in non_field_children {
7161 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7162 <ReferenceTypeChildren as ::treesitter_types::FromNode>::from_node(
7163 child, src,
7164 )
7165 })?);
7166 }
7167 items
7168 },
7169 })
7170 }
7171}
7172impl ::treesitter_types::Spanned for ReferenceType<'_> {
7173 fn span(&self) -> ::treesitter_types::Span {
7174 self.span
7175 }
7176}
7177#[derive(Debug, Clone, PartialEq, Eq)]
7178pub struct RemainingFieldPattern<'tree> {
7179 pub span: ::treesitter_types::Span,
7180 text: &'tree str,
7181}
7182impl<'tree> ::treesitter_types::FromNode<'tree> for RemainingFieldPattern<'tree> {
7183 fn from_node(
7184 node: ::treesitter_types::tree_sitter::Node<'tree>,
7185 src: &'tree [u8],
7186 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7187 debug_assert_eq!(node.kind(), "remaining_field_pattern");
7188 Ok(Self {
7189 span: ::treesitter_types::Span::from(node),
7190 text: node.utf8_text(src)?,
7191 })
7192 }
7193}
7194impl<'tree> ::treesitter_types::LeafNode<'tree> for RemainingFieldPattern<'tree> {
7195 fn text(&self) -> &'tree str {
7196 self.text
7197 }
7198}
7199impl ::treesitter_types::Spanned for RemainingFieldPattern<'_> {
7200 fn span(&self) -> ::treesitter_types::Span {
7201 self.span
7202 }
7203}
7204#[derive(Debug, Clone, PartialEq, Eq)]
7205pub struct RemovedTraitBound<'tree> {
7206 pub span: ::treesitter_types::Span,
7207 pub children: Type<'tree>,
7208}
7209impl<'tree> ::treesitter_types::FromNode<'tree> for RemovedTraitBound<'tree> {
7210 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7211 fn from_node(
7212 node: ::treesitter_types::tree_sitter::Node<'tree>,
7213 src: &'tree [u8],
7214 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7215 debug_assert_eq!(node.kind(), "removed_trait_bound");
7216 Ok(Self {
7217 span: ::treesitter_types::Span::from(node),
7218 children: {
7219 #[allow(clippy::suspicious_else_formatting)]
7220 let non_field_children = {
7221 let mut cursor = node.walk();
7222 let mut result = ::std::vec::Vec::new();
7223 if cursor.goto_first_child() {
7224 loop {
7225 if cursor.field_name().is_none()
7226 && cursor.node().is_named()
7227 && !cursor.node().is_extra()
7228 {
7229 result.push(cursor.node());
7230 }
7231 if !cursor.goto_next_sibling() {
7232 break;
7233 }
7234 }
7235 }
7236 result
7237 };
7238 let child = if let Some(&c) = non_field_children.first() {
7239 c
7240 } else {
7241 let mut fallback_cursor = node.walk();
7242 let mut fallback_child = None;
7243 if fallback_cursor.goto_first_child() {
7244 loop {
7245 if fallback_cursor.field_name().is_none()
7246 && !fallback_cursor.node().is_extra()
7247 {
7248 let candidate = fallback_cursor.node();
7249 #[allow(clippy::needless_question_mark)]
7250 if (|| -> ::core::result::Result<
7251 _,
7252 ::treesitter_types::ParseError,
7253 > {
7254 let child = candidate;
7255 Ok(
7256 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
7257 child,
7258 src,
7259 ))?,
7260 )
7261 })()
7262 .is_ok()
7263 {
7264 fallback_child = Some(candidate);
7265 break;
7266 }
7267 }
7268 if !fallback_cursor.goto_next_sibling() {
7269 break;
7270 }
7271 }
7272 }
7273 if fallback_child.is_none() {
7274 let mut cursor2 = node.walk();
7275 if cursor2.goto_first_child() {
7276 loop {
7277 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7278 let candidate = cursor2.node();
7279 #[allow(clippy::needless_question_mark)]
7280 if (|| -> ::core::result::Result<
7281 _,
7282 ::treesitter_types::ParseError,
7283 > {
7284 let child = candidate;
7285 Ok(
7286 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
7287 child,
7288 src,
7289 ))?,
7290 )
7291 })()
7292 .is_ok()
7293 {
7294 fallback_child = Some(candidate);
7295 break;
7296 }
7297 }
7298 if !cursor2.goto_next_sibling() {
7299 break;
7300 }
7301 }
7302 }
7303 }
7304 fallback_child.ok_or_else(|| {
7305 ::treesitter_types::ParseError::missing_field("children", node)
7306 })?
7307 };
7308 ::treesitter_types::runtime::maybe_grow_stack(|| {
7309 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7310 })?
7311 },
7312 })
7313 }
7314}
7315impl ::treesitter_types::Spanned for RemovedTraitBound<'_> {
7316 fn span(&self) -> ::treesitter_types::Span {
7317 self.span
7318 }
7319}
7320#[derive(Debug, Clone, PartialEq, Eq)]
7321pub struct ReturnExpression<'tree> {
7322 pub span: ::treesitter_types::Span,
7323 pub children: ::core::option::Option<Expression<'tree>>,
7324}
7325impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnExpression<'tree> {
7326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7327 fn from_node(
7328 node: ::treesitter_types::tree_sitter::Node<'tree>,
7329 src: &'tree [u8],
7330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7331 debug_assert_eq!(node.kind(), "return_expression");
7332 Ok(Self {
7333 span: ::treesitter_types::Span::from(node),
7334 children: {
7335 #[allow(clippy::suspicious_else_formatting)]
7336 let non_field_children = {
7337 let mut cursor = node.walk();
7338 let mut result = ::std::vec::Vec::new();
7339 if cursor.goto_first_child() {
7340 loop {
7341 if cursor.field_name().is_none()
7342 && cursor.node().is_named()
7343 && !cursor.node().is_extra()
7344 {
7345 result.push(cursor.node());
7346 }
7347 if !cursor.goto_next_sibling() {
7348 break;
7349 }
7350 }
7351 }
7352 result
7353 };
7354 match non_field_children.first() {
7355 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7356 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7357 })?),
7358 None => None,
7359 }
7360 },
7361 })
7362 }
7363}
7364impl ::treesitter_types::Spanned for ReturnExpression<'_> {
7365 fn span(&self) -> ::treesitter_types::Span {
7366 self.span
7367 }
7368}
7369#[derive(Debug, Clone, PartialEq, Eq)]
7370pub struct ScopedIdentifier<'tree> {
7371 pub span: ::treesitter_types::Span,
7372 pub name: ScopedIdentifierName<'tree>,
7373 pub path: ::core::option::Option<ScopedIdentifierPath<'tree>>,
7374}
7375impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
7376 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7377 fn from_node(
7378 node: ::treesitter_types::tree_sitter::Node<'tree>,
7379 src: &'tree [u8],
7380 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7381 debug_assert_eq!(node.kind(), "scoped_identifier");
7382 Ok(Self {
7383 span: ::treesitter_types::Span::from(node),
7384 name: {
7385 let child = node
7386 .child_by_field_name("name")
7387 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7388 ::treesitter_types::runtime::maybe_grow_stack(|| {
7389 <ScopedIdentifierName as ::treesitter_types::FromNode>::from_node(child, src)
7390 })?
7391 },
7392 path: match node.child_by_field_name("path") {
7393 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7394 <ScopedIdentifierPath as ::treesitter_types::FromNode>::from_node(child, src)
7395 })?),
7396 None => None,
7397 },
7398 })
7399 }
7400}
7401impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
7402 fn span(&self) -> ::treesitter_types::Span {
7403 self.span
7404 }
7405}
7406#[derive(Debug, Clone, PartialEq, Eq)]
7407pub struct ScopedTypeIdentifier<'tree> {
7408 pub span: ::treesitter_types::Span,
7409 pub name: TypeIdentifier<'tree>,
7410 pub path: ::core::option::Option<ScopedTypeIdentifierPath<'tree>>,
7411}
7412impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
7413 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7414 fn from_node(
7415 node: ::treesitter_types::tree_sitter::Node<'tree>,
7416 src: &'tree [u8],
7417 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7418 debug_assert_eq!(node.kind(), "scoped_type_identifier");
7419 Ok(Self {
7420 span: ::treesitter_types::Span::from(node),
7421 name: {
7422 let child = node
7423 .child_by_field_name("name")
7424 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7425 ::treesitter_types::runtime::maybe_grow_stack(|| {
7426 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
7427 })?
7428 },
7429 path: match node.child_by_field_name("path") {
7430 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7431 <ScopedTypeIdentifierPath as ::treesitter_types::FromNode>::from_node(
7432 child, src,
7433 )
7434 })?),
7435 None => None,
7436 },
7437 })
7438 }
7439}
7440impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
7441 fn span(&self) -> ::treesitter_types::Span {
7442 self.span
7443 }
7444}
7445#[derive(Debug, Clone, PartialEq, Eq)]
7446pub struct ScopedUseList<'tree> {
7447 pub span: ::treesitter_types::Span,
7448 pub list: UseList<'tree>,
7449 pub path: ::core::option::Option<ScopedUseListPath<'tree>>,
7450}
7451impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseList<'tree> {
7452 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7453 fn from_node(
7454 node: ::treesitter_types::tree_sitter::Node<'tree>,
7455 src: &'tree [u8],
7456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7457 debug_assert_eq!(node.kind(), "scoped_use_list");
7458 Ok(Self {
7459 span: ::treesitter_types::Span::from(node),
7460 list: {
7461 let child = node
7462 .child_by_field_name("list")
7463 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("list", node))?;
7464 ::treesitter_types::runtime::maybe_grow_stack(|| {
7465 <UseList as ::treesitter_types::FromNode>::from_node(child, src)
7466 })?
7467 },
7468 path: match node.child_by_field_name("path") {
7469 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7470 <ScopedUseListPath as ::treesitter_types::FromNode>::from_node(child, src)
7471 })?),
7472 None => None,
7473 },
7474 })
7475 }
7476}
7477impl ::treesitter_types::Spanned for ScopedUseList<'_> {
7478 fn span(&self) -> ::treesitter_types::Span {
7479 self.span
7480 }
7481}
7482#[derive(Debug, Clone, PartialEq, Eq)]
7483pub struct SelfParameter<'tree> {
7484 pub span: ::treesitter_types::Span,
7485 pub children: ::std::vec::Vec<SelfParameterChildren<'tree>>,
7486}
7487impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameter<'tree> {
7488 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7489 fn from_node(
7490 node: ::treesitter_types::tree_sitter::Node<'tree>,
7491 src: &'tree [u8],
7492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7493 debug_assert_eq!(node.kind(), "self_parameter");
7494 Ok(Self {
7495 span: ::treesitter_types::Span::from(node),
7496 children: {
7497 #[allow(clippy::suspicious_else_formatting)]
7498 let non_field_children = {
7499 let mut cursor = node.walk();
7500 let mut result = ::std::vec::Vec::new();
7501 if cursor.goto_first_child() {
7502 loop {
7503 if cursor.field_name().is_none()
7504 && cursor.node().is_named()
7505 && !cursor.node().is_extra()
7506 {
7507 result.push(cursor.node());
7508 }
7509 if !cursor.goto_next_sibling() {
7510 break;
7511 }
7512 }
7513 }
7514 result
7515 };
7516 let mut items = ::std::vec::Vec::new();
7517 for child in non_field_children {
7518 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7519 <SelfParameterChildren as ::treesitter_types::FromNode>::from_node(
7520 child, src,
7521 )
7522 })?);
7523 }
7524 items
7525 },
7526 })
7527 }
7528}
7529impl ::treesitter_types::Spanned for SelfParameter<'_> {
7530 fn span(&self) -> ::treesitter_types::Span {
7531 self.span
7532 }
7533}
7534#[derive(Debug, Clone, PartialEq, Eq)]
7535pub struct ShorthandFieldInitializer<'tree> {
7536 pub span: ::treesitter_types::Span,
7537 pub children: ::std::vec::Vec<ShorthandFieldInitializerChildren<'tree>>,
7538}
7539impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializer<'tree> {
7540 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7541 fn from_node(
7542 node: ::treesitter_types::tree_sitter::Node<'tree>,
7543 src: &'tree [u8],
7544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7545 debug_assert_eq!(node.kind(), "shorthand_field_initializer");
7546 Ok(Self {
7547 span: ::treesitter_types::Span::from(node),
7548 children: {
7549 #[allow(clippy::suspicious_else_formatting)]
7550 let non_field_children = {
7551 let mut cursor = node.walk();
7552 let mut result = ::std::vec::Vec::new();
7553 if cursor.goto_first_child() {
7554 loop {
7555 if cursor.field_name().is_none()
7556 && cursor.node().is_named()
7557 && !cursor.node().is_extra()
7558 {
7559 result.push(cursor.node());
7560 }
7561 if !cursor.goto_next_sibling() {
7562 break;
7563 }
7564 }
7565 }
7566 result
7567 };
7568 let mut items = ::std::vec::Vec::new();
7569 for child in non_field_children {
7570 items
7571 .push(
7572 ::treesitter_types::runtime::maybe_grow_stack(|| <ShorthandFieldInitializerChildren as ::treesitter_types::FromNode>::from_node(
7573 child,
7574 src,
7575 ))?,
7576 );
7577 }
7578 items
7579 },
7580 })
7581 }
7582}
7583impl ::treesitter_types::Spanned for ShorthandFieldInitializer<'_> {
7584 fn span(&self) -> ::treesitter_types::Span {
7585 self.span
7586 }
7587}
7588#[derive(Debug, Clone, PartialEq, Eq)]
7589pub struct SlicePattern<'tree> {
7590 pub span: ::treesitter_types::Span,
7591 pub children: ::std::vec::Vec<Pattern<'tree>>,
7592}
7593impl<'tree> ::treesitter_types::FromNode<'tree> for SlicePattern<'tree> {
7594 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7595 fn from_node(
7596 node: ::treesitter_types::tree_sitter::Node<'tree>,
7597 src: &'tree [u8],
7598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7599 debug_assert_eq!(node.kind(), "slice_pattern");
7600 Ok(Self {
7601 span: ::treesitter_types::Span::from(node),
7602 children: {
7603 #[allow(clippy::suspicious_else_formatting)]
7604 let non_field_children = {
7605 let mut cursor = node.walk();
7606 let mut result = ::std::vec::Vec::new();
7607 if cursor.goto_first_child() {
7608 loop {
7609 if cursor.field_name().is_none()
7610 && cursor.node().is_named()
7611 && !cursor.node().is_extra()
7612 {
7613 result.push(cursor.node());
7614 }
7615 if !cursor.goto_next_sibling() {
7616 break;
7617 }
7618 }
7619 }
7620 result
7621 };
7622 let mut items = ::std::vec::Vec::new();
7623 for child in non_field_children {
7624 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7625 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
7626 })?);
7627 }
7628 items
7629 },
7630 })
7631 }
7632}
7633impl ::treesitter_types::Spanned for SlicePattern<'_> {
7634 fn span(&self) -> ::treesitter_types::Span {
7635 self.span
7636 }
7637}
7638#[derive(Debug, Clone, PartialEq, Eq)]
7639pub struct SourceFile<'tree> {
7640 pub span: ::treesitter_types::Span,
7641 pub children: ::std::vec::Vec<SourceFileChildren<'tree>>,
7642}
7643impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFile<'tree> {
7644 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7645 fn from_node(
7646 node: ::treesitter_types::tree_sitter::Node<'tree>,
7647 src: &'tree [u8],
7648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7649 debug_assert_eq!(node.kind(), "source_file");
7650 Ok(Self {
7651 span: ::treesitter_types::Span::from(node),
7652 children: {
7653 #[allow(clippy::suspicious_else_formatting)]
7654 let non_field_children = {
7655 let mut cursor = node.walk();
7656 let mut result = ::std::vec::Vec::new();
7657 if cursor.goto_first_child() {
7658 loop {
7659 if cursor.field_name().is_none()
7660 && cursor.node().is_named()
7661 && !cursor.node().is_extra()
7662 {
7663 result.push(cursor.node());
7664 }
7665 if !cursor.goto_next_sibling() {
7666 break;
7667 }
7668 }
7669 }
7670 result
7671 };
7672 let mut items = ::std::vec::Vec::new();
7673 for child in non_field_children {
7674 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7675 <SourceFileChildren as ::treesitter_types::FromNode>::from_node(child, src)
7676 })?);
7677 }
7678 items
7679 },
7680 })
7681 }
7682}
7683impl ::treesitter_types::Spanned for SourceFile<'_> {
7684 fn span(&self) -> ::treesitter_types::Span {
7685 self.span
7686 }
7687}
7688#[derive(Debug, Clone, PartialEq, Eq)]
7689pub struct StaticItem<'tree> {
7690 pub span: ::treesitter_types::Span,
7691 pub name: Identifier<'tree>,
7692 pub r#type: Type<'tree>,
7693 pub value: ::core::option::Option<Expression<'tree>>,
7694 pub children: ::std::vec::Vec<StaticItemChildren<'tree>>,
7695}
7696impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItem<'tree> {
7697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7698 fn from_node(
7699 node: ::treesitter_types::tree_sitter::Node<'tree>,
7700 src: &'tree [u8],
7701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7702 debug_assert_eq!(node.kind(), "static_item");
7703 Ok(Self {
7704 span: ::treesitter_types::Span::from(node),
7705 name: {
7706 let child = node
7707 .child_by_field_name("name")
7708 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7709 ::treesitter_types::runtime::maybe_grow_stack(|| {
7710 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7711 })?
7712 },
7713 r#type: {
7714 let child = node
7715 .child_by_field_name("type")
7716 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7717 ::treesitter_types::runtime::maybe_grow_stack(|| {
7718 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7719 })?
7720 },
7721 value: match node.child_by_field_name("value") {
7722 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7723 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7724 })?),
7725 None => None,
7726 },
7727 children: {
7728 #[allow(clippy::suspicious_else_formatting)]
7729 let non_field_children = {
7730 let mut cursor = node.walk();
7731 let mut result = ::std::vec::Vec::new();
7732 if cursor.goto_first_child() {
7733 loop {
7734 if cursor.field_name().is_none()
7735 && cursor.node().is_named()
7736 && !cursor.node().is_extra()
7737 {
7738 result.push(cursor.node());
7739 }
7740 if !cursor.goto_next_sibling() {
7741 break;
7742 }
7743 }
7744 }
7745 result
7746 };
7747 let mut items = ::std::vec::Vec::new();
7748 for child in non_field_children {
7749 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7750 <StaticItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
7751 })?);
7752 }
7753 items
7754 },
7755 })
7756 }
7757}
7758impl ::treesitter_types::Spanned for StaticItem<'_> {
7759 fn span(&self) -> ::treesitter_types::Span {
7760 self.span
7761 }
7762}
7763#[derive(Debug, Clone, PartialEq, Eq)]
7764pub struct StringLiteral<'tree> {
7765 pub span: ::treesitter_types::Span,
7766 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
7767}
7768impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
7769 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7770 fn from_node(
7771 node: ::treesitter_types::tree_sitter::Node<'tree>,
7772 src: &'tree [u8],
7773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7774 debug_assert_eq!(node.kind(), "string_literal");
7775 Ok(Self {
7776 span: ::treesitter_types::Span::from(node),
7777 children: {
7778 #[allow(clippy::suspicious_else_formatting)]
7779 let non_field_children = {
7780 let mut cursor = node.walk();
7781 let mut result = ::std::vec::Vec::new();
7782 if cursor.goto_first_child() {
7783 loop {
7784 if cursor.field_name().is_none()
7785 && cursor.node().is_named()
7786 && !cursor.node().is_extra()
7787 {
7788 result.push(cursor.node());
7789 }
7790 if !cursor.goto_next_sibling() {
7791 break;
7792 }
7793 }
7794 }
7795 result
7796 };
7797 let mut items = ::std::vec::Vec::new();
7798 for child in non_field_children {
7799 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7800 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
7801 child, src,
7802 )
7803 })?);
7804 }
7805 items
7806 },
7807 })
7808 }
7809}
7810impl ::treesitter_types::Spanned for StringLiteral<'_> {
7811 fn span(&self) -> ::treesitter_types::Span {
7812 self.span
7813 }
7814}
7815#[derive(Debug, Clone, PartialEq, Eq)]
7816pub struct StructExpression<'tree> {
7817 pub span: ::treesitter_types::Span,
7818 pub body: FieldInitializerList<'tree>,
7819 pub name: StructExpressionName<'tree>,
7820}
7821impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpression<'tree> {
7822 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7823 fn from_node(
7824 node: ::treesitter_types::tree_sitter::Node<'tree>,
7825 src: &'tree [u8],
7826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7827 debug_assert_eq!(node.kind(), "struct_expression");
7828 Ok(Self {
7829 span: ::treesitter_types::Span::from(node),
7830 body: {
7831 let child = node
7832 .child_by_field_name("body")
7833 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7834 ::treesitter_types::runtime::maybe_grow_stack(|| {
7835 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(child, src)
7836 })?
7837 },
7838 name: {
7839 let child = node
7840 .child_by_field_name("name")
7841 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7842 ::treesitter_types::runtime::maybe_grow_stack(|| {
7843 <StructExpressionName as ::treesitter_types::FromNode>::from_node(child, src)
7844 })?
7845 },
7846 })
7847 }
7848}
7849impl ::treesitter_types::Spanned for StructExpression<'_> {
7850 fn span(&self) -> ::treesitter_types::Span {
7851 self.span
7852 }
7853}
7854#[derive(Debug, Clone, PartialEq, Eq)]
7855pub struct StructItem<'tree> {
7856 pub span: ::treesitter_types::Span,
7857 pub body: ::core::option::Option<StructItemBody<'tree>>,
7858 pub name: TypeIdentifier<'tree>,
7859 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7860 pub children: ::std::vec::Vec<StructItemChildren<'tree>>,
7861}
7862impl<'tree> ::treesitter_types::FromNode<'tree> for StructItem<'tree> {
7863 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7864 fn from_node(
7865 node: ::treesitter_types::tree_sitter::Node<'tree>,
7866 src: &'tree [u8],
7867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7868 debug_assert_eq!(node.kind(), "struct_item");
7869 Ok(Self {
7870 span: ::treesitter_types::Span::from(node),
7871 body: match node.child_by_field_name("body") {
7872 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7873 <StructItemBody as ::treesitter_types::FromNode>::from_node(child, src)
7874 })?),
7875 None => None,
7876 },
7877 name: {
7878 let child = node
7879 .child_by_field_name("name")
7880 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7881 ::treesitter_types::runtime::maybe_grow_stack(|| {
7882 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
7883 })?
7884 },
7885 type_parameters: match node.child_by_field_name("type_parameters") {
7886 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7887 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
7888 })?),
7889 None => None,
7890 },
7891 children: {
7892 #[allow(clippy::suspicious_else_formatting)]
7893 let non_field_children = {
7894 let mut cursor = node.walk();
7895 let mut result = ::std::vec::Vec::new();
7896 if cursor.goto_first_child() {
7897 loop {
7898 if cursor.field_name().is_none()
7899 && cursor.node().is_named()
7900 && !cursor.node().is_extra()
7901 {
7902 result.push(cursor.node());
7903 }
7904 if !cursor.goto_next_sibling() {
7905 break;
7906 }
7907 }
7908 }
7909 result
7910 };
7911 let mut items = ::std::vec::Vec::new();
7912 for child in non_field_children {
7913 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7914 <StructItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
7915 })?);
7916 }
7917 items
7918 },
7919 })
7920 }
7921}
7922impl ::treesitter_types::Spanned for StructItem<'_> {
7923 fn span(&self) -> ::treesitter_types::Span {
7924 self.span
7925 }
7926}
7927#[derive(Debug, Clone, PartialEq, Eq)]
7928pub struct StructPattern<'tree> {
7929 pub span: ::treesitter_types::Span,
7930 pub r#type: StructPatternType<'tree>,
7931 pub children: ::std::vec::Vec<StructPatternChildren<'tree>>,
7932}
7933impl<'tree> ::treesitter_types::FromNode<'tree> for StructPattern<'tree> {
7934 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7935 fn from_node(
7936 node: ::treesitter_types::tree_sitter::Node<'tree>,
7937 src: &'tree [u8],
7938 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7939 debug_assert_eq!(node.kind(), "struct_pattern");
7940 Ok(Self {
7941 span: ::treesitter_types::Span::from(node),
7942 r#type: {
7943 let child = node
7944 .child_by_field_name("type")
7945 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7946 ::treesitter_types::runtime::maybe_grow_stack(|| {
7947 <StructPatternType as ::treesitter_types::FromNode>::from_node(child, src)
7948 })?
7949 },
7950 children: {
7951 #[allow(clippy::suspicious_else_formatting)]
7952 let non_field_children = {
7953 let mut cursor = node.walk();
7954 let mut result = ::std::vec::Vec::new();
7955 if cursor.goto_first_child() {
7956 loop {
7957 if cursor.field_name().is_none()
7958 && cursor.node().is_named()
7959 && !cursor.node().is_extra()
7960 {
7961 result.push(cursor.node());
7962 }
7963 if !cursor.goto_next_sibling() {
7964 break;
7965 }
7966 }
7967 }
7968 result
7969 };
7970 let mut items = ::std::vec::Vec::new();
7971 for child in non_field_children {
7972 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7973 <StructPatternChildren as ::treesitter_types::FromNode>::from_node(
7974 child, src,
7975 )
7976 })?);
7977 }
7978 items
7979 },
7980 })
7981 }
7982}
7983impl ::treesitter_types::Spanned for StructPattern<'_> {
7984 fn span(&self) -> ::treesitter_types::Span {
7985 self.span
7986 }
7987}
7988#[derive(Debug, Clone, PartialEq, Eq)]
7989pub struct TokenBindingPattern<'tree> {
7990 pub span: ::treesitter_types::Span,
7991 pub name: Metavariable<'tree>,
7992 pub r#type: FragmentSpecifier<'tree>,
7993}
7994impl<'tree> ::treesitter_types::FromNode<'tree> for TokenBindingPattern<'tree> {
7995 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7996 fn from_node(
7997 node: ::treesitter_types::tree_sitter::Node<'tree>,
7998 src: &'tree [u8],
7999 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8000 debug_assert_eq!(node.kind(), "token_binding_pattern");
8001 Ok(Self {
8002 span: ::treesitter_types::Span::from(node),
8003 name: {
8004 let child = node
8005 .child_by_field_name("name")
8006 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8007 ::treesitter_types::runtime::maybe_grow_stack(|| {
8008 <Metavariable as ::treesitter_types::FromNode>::from_node(child, src)
8009 })?
8010 },
8011 r#type: {
8012 let child = node
8013 .child_by_field_name("type")
8014 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8015 ::treesitter_types::runtime::maybe_grow_stack(|| {
8016 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
8017 })?
8018 },
8019 })
8020 }
8021}
8022impl ::treesitter_types::Spanned for TokenBindingPattern<'_> {
8023 fn span(&self) -> ::treesitter_types::Span {
8024 self.span
8025 }
8026}
8027#[derive(Debug, Clone, PartialEq, Eq)]
8028pub struct TokenRepetition<'tree> {
8029 pub span: ::treesitter_types::Span,
8030 pub children: ::std::vec::Vec<TokenRepetitionChildren<'tree>>,
8031}
8032impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetition<'tree> {
8033 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8034 fn from_node(
8035 node: ::treesitter_types::tree_sitter::Node<'tree>,
8036 src: &'tree [u8],
8037 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8038 debug_assert_eq!(node.kind(), "token_repetition");
8039 Ok(Self {
8040 span: ::treesitter_types::Span::from(node),
8041 children: {
8042 #[allow(clippy::suspicious_else_formatting)]
8043 let non_field_children = {
8044 let mut cursor = node.walk();
8045 let mut result = ::std::vec::Vec::new();
8046 if cursor.goto_first_child() {
8047 loop {
8048 if cursor.field_name().is_none()
8049 && cursor.node().is_named()
8050 && !cursor.node().is_extra()
8051 {
8052 result.push(cursor.node());
8053 }
8054 if !cursor.goto_next_sibling() {
8055 break;
8056 }
8057 }
8058 }
8059 result
8060 };
8061 let mut items = ::std::vec::Vec::new();
8062 for child in non_field_children {
8063 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8064 <TokenRepetitionChildren as ::treesitter_types::FromNode>::from_node(
8065 child, src,
8066 )
8067 })?);
8068 }
8069 items
8070 },
8071 })
8072 }
8073}
8074impl ::treesitter_types::Spanned for TokenRepetition<'_> {
8075 fn span(&self) -> ::treesitter_types::Span {
8076 self.span
8077 }
8078}
8079#[derive(Debug, Clone, PartialEq, Eq)]
8080pub struct TokenRepetitionPattern<'tree> {
8081 pub span: ::treesitter_types::Span,
8082 pub children: ::std::vec::Vec<TokenRepetitionPatternChildren<'tree>>,
8083}
8084impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPattern<'tree> {
8085 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8086 fn from_node(
8087 node: ::treesitter_types::tree_sitter::Node<'tree>,
8088 src: &'tree [u8],
8089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8090 debug_assert_eq!(node.kind(), "token_repetition_pattern");
8091 Ok(Self {
8092 span: ::treesitter_types::Span::from(node),
8093 children: {
8094 #[allow(clippy::suspicious_else_formatting)]
8095 let non_field_children = {
8096 let mut cursor = node.walk();
8097 let mut result = ::std::vec::Vec::new();
8098 if cursor.goto_first_child() {
8099 loop {
8100 if cursor.field_name().is_none()
8101 && cursor.node().is_named()
8102 && !cursor.node().is_extra()
8103 {
8104 result.push(cursor.node());
8105 }
8106 if !cursor.goto_next_sibling() {
8107 break;
8108 }
8109 }
8110 }
8111 result
8112 };
8113 let mut items = ::std::vec::Vec::new();
8114 for child in non_field_children {
8115 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8116 <TokenRepetitionPatternChildren as ::treesitter_types::FromNode>::from_node(
8117 child, src,
8118 )
8119 })?);
8120 }
8121 items
8122 },
8123 })
8124 }
8125}
8126impl ::treesitter_types::Spanned for TokenRepetitionPattern<'_> {
8127 fn span(&self) -> ::treesitter_types::Span {
8128 self.span
8129 }
8130}
8131#[derive(Debug, Clone, PartialEq, Eq)]
8132pub struct TokenTree<'tree> {
8133 pub span: ::treesitter_types::Span,
8134 pub children: ::std::vec::Vec<TokenTreeChildren<'tree>>,
8135}
8136impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTree<'tree> {
8137 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8138 fn from_node(
8139 node: ::treesitter_types::tree_sitter::Node<'tree>,
8140 src: &'tree [u8],
8141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8142 debug_assert_eq!(node.kind(), "token_tree");
8143 Ok(Self {
8144 span: ::treesitter_types::Span::from(node),
8145 children: {
8146 #[allow(clippy::suspicious_else_formatting)]
8147 let non_field_children = {
8148 let mut cursor = node.walk();
8149 let mut result = ::std::vec::Vec::new();
8150 if cursor.goto_first_child() {
8151 loop {
8152 if cursor.field_name().is_none()
8153 && cursor.node().is_named()
8154 && !cursor.node().is_extra()
8155 {
8156 result.push(cursor.node());
8157 }
8158 if !cursor.goto_next_sibling() {
8159 break;
8160 }
8161 }
8162 }
8163 result
8164 };
8165 let mut items = ::std::vec::Vec::new();
8166 for child in non_field_children {
8167 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8168 <TokenTreeChildren as ::treesitter_types::FromNode>::from_node(child, src)
8169 })?);
8170 }
8171 items
8172 },
8173 })
8174 }
8175}
8176impl ::treesitter_types::Spanned for TokenTree<'_> {
8177 fn span(&self) -> ::treesitter_types::Span {
8178 self.span
8179 }
8180}
8181#[derive(Debug, Clone, PartialEq, Eq)]
8182pub struct TokenTreePattern<'tree> {
8183 pub span: ::treesitter_types::Span,
8184 pub children: ::std::vec::Vec<TokenTreePatternChildren<'tree>>,
8185}
8186impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePattern<'tree> {
8187 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8188 fn from_node(
8189 node: ::treesitter_types::tree_sitter::Node<'tree>,
8190 src: &'tree [u8],
8191 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8192 debug_assert_eq!(node.kind(), "token_tree_pattern");
8193 Ok(Self {
8194 span: ::treesitter_types::Span::from(node),
8195 children: {
8196 #[allow(clippy::suspicious_else_formatting)]
8197 let non_field_children = {
8198 let mut cursor = node.walk();
8199 let mut result = ::std::vec::Vec::new();
8200 if cursor.goto_first_child() {
8201 loop {
8202 if cursor.field_name().is_none()
8203 && cursor.node().is_named()
8204 && !cursor.node().is_extra()
8205 {
8206 result.push(cursor.node());
8207 }
8208 if !cursor.goto_next_sibling() {
8209 break;
8210 }
8211 }
8212 }
8213 result
8214 };
8215 let mut items = ::std::vec::Vec::new();
8216 for child in non_field_children {
8217 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8218 <TokenTreePatternChildren as ::treesitter_types::FromNode>::from_node(
8219 child, src,
8220 )
8221 })?);
8222 }
8223 items
8224 },
8225 })
8226 }
8227}
8228impl ::treesitter_types::Spanned for TokenTreePattern<'_> {
8229 fn span(&self) -> ::treesitter_types::Span {
8230 self.span
8231 }
8232}
8233#[derive(Debug, Clone, PartialEq, Eq)]
8234pub struct TraitBounds<'tree> {
8235 pub span: ::treesitter_types::Span,
8236 pub children: ::std::vec::Vec<TraitBoundsChildren<'tree>>,
8237}
8238impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBounds<'tree> {
8239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8240 fn from_node(
8241 node: ::treesitter_types::tree_sitter::Node<'tree>,
8242 src: &'tree [u8],
8243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8244 debug_assert_eq!(node.kind(), "trait_bounds");
8245 Ok(Self {
8246 span: ::treesitter_types::Span::from(node),
8247 children: {
8248 #[allow(clippy::suspicious_else_formatting)]
8249 let non_field_children = {
8250 let mut cursor = node.walk();
8251 let mut result = ::std::vec::Vec::new();
8252 if cursor.goto_first_child() {
8253 loop {
8254 if cursor.field_name().is_none()
8255 && cursor.node().is_named()
8256 && !cursor.node().is_extra()
8257 {
8258 result.push(cursor.node());
8259 }
8260 if !cursor.goto_next_sibling() {
8261 break;
8262 }
8263 }
8264 }
8265 result
8266 };
8267 let mut items = ::std::vec::Vec::new();
8268 for child in non_field_children {
8269 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8270 <TraitBoundsChildren as ::treesitter_types::FromNode>::from_node(child, src)
8271 })?);
8272 }
8273 items
8274 },
8275 })
8276 }
8277}
8278impl ::treesitter_types::Spanned for TraitBounds<'_> {
8279 fn span(&self) -> ::treesitter_types::Span {
8280 self.span
8281 }
8282}
8283#[derive(Debug, Clone, PartialEq, Eq)]
8284pub struct TraitItem<'tree> {
8285 pub span: ::treesitter_types::Span,
8286 pub body: DeclarationList<'tree>,
8287 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
8288 pub name: TypeIdentifier<'tree>,
8289 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
8290 pub children: ::std::vec::Vec<TraitItemChildren<'tree>>,
8291}
8292impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItem<'tree> {
8293 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8294 fn from_node(
8295 node: ::treesitter_types::tree_sitter::Node<'tree>,
8296 src: &'tree [u8],
8297 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8298 debug_assert_eq!(node.kind(), "trait_item");
8299 Ok(Self {
8300 span: ::treesitter_types::Span::from(node),
8301 body: {
8302 let child = node
8303 .child_by_field_name("body")
8304 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8305 ::treesitter_types::runtime::maybe_grow_stack(|| {
8306 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
8307 })?
8308 },
8309 bounds: match node.child_by_field_name("bounds") {
8310 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8311 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)
8312 })?),
8313 None => None,
8314 },
8315 name: {
8316 let child = node
8317 .child_by_field_name("name")
8318 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8319 ::treesitter_types::runtime::maybe_grow_stack(|| {
8320 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
8321 })?
8322 },
8323 type_parameters: match node.child_by_field_name("type_parameters") {
8324 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8325 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
8326 })?),
8327 None => None,
8328 },
8329 children: {
8330 #[allow(clippy::suspicious_else_formatting)]
8331 let non_field_children = {
8332 let mut cursor = node.walk();
8333 let mut result = ::std::vec::Vec::new();
8334 if cursor.goto_first_child() {
8335 loop {
8336 if cursor.field_name().is_none()
8337 && cursor.node().is_named()
8338 && !cursor.node().is_extra()
8339 {
8340 result.push(cursor.node());
8341 }
8342 if !cursor.goto_next_sibling() {
8343 break;
8344 }
8345 }
8346 }
8347 result
8348 };
8349 let mut items = ::std::vec::Vec::new();
8350 for child in non_field_children {
8351 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8352 <TraitItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
8353 })?);
8354 }
8355 items
8356 },
8357 })
8358 }
8359}
8360impl ::treesitter_types::Spanned for TraitItem<'_> {
8361 fn span(&self) -> ::treesitter_types::Span {
8362 self.span
8363 }
8364}
8365#[derive(Debug, Clone, PartialEq, Eq)]
8366pub struct TryBlock<'tree> {
8367 pub span: ::treesitter_types::Span,
8368 pub children: Block<'tree>,
8369}
8370impl<'tree> ::treesitter_types::FromNode<'tree> for TryBlock<'tree> {
8371 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8372 fn from_node(
8373 node: ::treesitter_types::tree_sitter::Node<'tree>,
8374 src: &'tree [u8],
8375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8376 debug_assert_eq!(node.kind(), "try_block");
8377 Ok(Self {
8378 span: ::treesitter_types::Span::from(node),
8379 children: {
8380 #[allow(clippy::suspicious_else_formatting)]
8381 let non_field_children = {
8382 let mut cursor = node.walk();
8383 let mut result = ::std::vec::Vec::new();
8384 if cursor.goto_first_child() {
8385 loop {
8386 if cursor.field_name().is_none()
8387 && cursor.node().is_named()
8388 && !cursor.node().is_extra()
8389 {
8390 result.push(cursor.node());
8391 }
8392 if !cursor.goto_next_sibling() {
8393 break;
8394 }
8395 }
8396 }
8397 result
8398 };
8399 let child = if let Some(&c) = non_field_children.first() {
8400 c
8401 } else {
8402 let mut fallback_cursor = node.walk();
8403 let mut fallback_child = None;
8404 if fallback_cursor.goto_first_child() {
8405 loop {
8406 if fallback_cursor.field_name().is_none()
8407 && !fallback_cursor.node().is_extra()
8408 {
8409 let candidate = fallback_cursor.node();
8410 #[allow(clippy::needless_question_mark)]
8411 if (|| -> ::core::result::Result<
8412 _,
8413 ::treesitter_types::ParseError,
8414 > {
8415 let child = candidate;
8416 Ok(
8417 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
8418 child,
8419 src,
8420 ))?,
8421 )
8422 })()
8423 .is_ok()
8424 {
8425 fallback_child = Some(candidate);
8426 break;
8427 }
8428 }
8429 if !fallback_cursor.goto_next_sibling() {
8430 break;
8431 }
8432 }
8433 }
8434 if fallback_child.is_none() {
8435 let mut cursor2 = node.walk();
8436 if cursor2.goto_first_child() {
8437 loop {
8438 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8439 let candidate = cursor2.node();
8440 #[allow(clippy::needless_question_mark)]
8441 if (|| -> ::core::result::Result<
8442 _,
8443 ::treesitter_types::ParseError,
8444 > {
8445 let child = candidate;
8446 Ok(
8447 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
8448 child,
8449 src,
8450 ))?,
8451 )
8452 })()
8453 .is_ok()
8454 {
8455 fallback_child = Some(candidate);
8456 break;
8457 }
8458 }
8459 if !cursor2.goto_next_sibling() {
8460 break;
8461 }
8462 }
8463 }
8464 }
8465 fallback_child.ok_or_else(|| {
8466 ::treesitter_types::ParseError::missing_field("children", node)
8467 })?
8468 };
8469 ::treesitter_types::runtime::maybe_grow_stack(|| {
8470 <Block as ::treesitter_types::FromNode>::from_node(child, src)
8471 })?
8472 },
8473 })
8474 }
8475}
8476impl ::treesitter_types::Spanned for TryBlock<'_> {
8477 fn span(&self) -> ::treesitter_types::Span {
8478 self.span
8479 }
8480}
8481#[derive(Debug, Clone, PartialEq, Eq)]
8482pub struct TryExpression<'tree> {
8483 pub span: ::treesitter_types::Span,
8484 pub children: Expression<'tree>,
8485}
8486impl<'tree> ::treesitter_types::FromNode<'tree> for TryExpression<'tree> {
8487 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8488 fn from_node(
8489 node: ::treesitter_types::tree_sitter::Node<'tree>,
8490 src: &'tree [u8],
8491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8492 debug_assert_eq!(node.kind(), "try_expression");
8493 Ok(Self {
8494 span: ::treesitter_types::Span::from(node),
8495 children: {
8496 #[allow(clippy::suspicious_else_formatting)]
8497 let non_field_children = {
8498 let mut cursor = node.walk();
8499 let mut result = ::std::vec::Vec::new();
8500 if cursor.goto_first_child() {
8501 loop {
8502 if cursor.field_name().is_none()
8503 && cursor.node().is_named()
8504 && !cursor.node().is_extra()
8505 {
8506 result.push(cursor.node());
8507 }
8508 if !cursor.goto_next_sibling() {
8509 break;
8510 }
8511 }
8512 }
8513 result
8514 };
8515 let child = if let Some(&c) = non_field_children.first() {
8516 c
8517 } else {
8518 let mut fallback_cursor = node.walk();
8519 let mut fallback_child = None;
8520 if fallback_cursor.goto_first_child() {
8521 loop {
8522 if fallback_cursor.field_name().is_none()
8523 && !fallback_cursor.node().is_extra()
8524 {
8525 let candidate = fallback_cursor.node();
8526 #[allow(clippy::needless_question_mark)]
8527 if (|| -> ::core::result::Result<
8528 _,
8529 ::treesitter_types::ParseError,
8530 > {
8531 let child = candidate;
8532 Ok(
8533 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8534 child,
8535 src,
8536 ))?,
8537 )
8538 })()
8539 .is_ok()
8540 {
8541 fallback_child = Some(candidate);
8542 break;
8543 }
8544 }
8545 if !fallback_cursor.goto_next_sibling() {
8546 break;
8547 }
8548 }
8549 }
8550 if fallback_child.is_none() {
8551 let mut cursor2 = node.walk();
8552 if cursor2.goto_first_child() {
8553 loop {
8554 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8555 let candidate = cursor2.node();
8556 #[allow(clippy::needless_question_mark)]
8557 if (|| -> ::core::result::Result<
8558 _,
8559 ::treesitter_types::ParseError,
8560 > {
8561 let child = candidate;
8562 Ok(
8563 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8564 child,
8565 src,
8566 ))?,
8567 )
8568 })()
8569 .is_ok()
8570 {
8571 fallback_child = Some(candidate);
8572 break;
8573 }
8574 }
8575 if !cursor2.goto_next_sibling() {
8576 break;
8577 }
8578 }
8579 }
8580 }
8581 fallback_child.ok_or_else(|| {
8582 ::treesitter_types::ParseError::missing_field("children", node)
8583 })?
8584 };
8585 ::treesitter_types::runtime::maybe_grow_stack(|| {
8586 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8587 })?
8588 },
8589 })
8590 }
8591}
8592impl ::treesitter_types::Spanned for TryExpression<'_> {
8593 fn span(&self) -> ::treesitter_types::Span {
8594 self.span
8595 }
8596}
8597#[derive(Debug, Clone, PartialEq, Eq)]
8598pub struct TupleExpression<'tree> {
8599 pub span: ::treesitter_types::Span,
8600 pub children: ::std::vec::Vec<TupleExpressionChildren<'tree>>,
8601}
8602impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
8603 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8604 fn from_node(
8605 node: ::treesitter_types::tree_sitter::Node<'tree>,
8606 src: &'tree [u8],
8607 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8608 debug_assert_eq!(node.kind(), "tuple_expression");
8609 Ok(Self {
8610 span: ::treesitter_types::Span::from(node),
8611 children: {
8612 #[allow(clippy::suspicious_else_formatting)]
8613 let non_field_children = {
8614 let mut cursor = node.walk();
8615 let mut result = ::std::vec::Vec::new();
8616 if cursor.goto_first_child() {
8617 loop {
8618 if cursor.field_name().is_none()
8619 && cursor.node().is_named()
8620 && !cursor.node().is_extra()
8621 {
8622 result.push(cursor.node());
8623 }
8624 if !cursor.goto_next_sibling() {
8625 break;
8626 }
8627 }
8628 }
8629 result
8630 };
8631 let mut items = ::std::vec::Vec::new();
8632 for child in non_field_children {
8633 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8634 <TupleExpressionChildren as ::treesitter_types::FromNode>::from_node(
8635 child, src,
8636 )
8637 })?);
8638 }
8639 items
8640 },
8641 })
8642 }
8643}
8644impl ::treesitter_types::Spanned for TupleExpression<'_> {
8645 fn span(&self) -> ::treesitter_types::Span {
8646 self.span
8647 }
8648}
8649#[derive(Debug, Clone, PartialEq, Eq)]
8650pub struct TuplePattern<'tree> {
8651 pub span: ::treesitter_types::Span,
8652 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
8653}
8654impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
8655 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8656 fn from_node(
8657 node: ::treesitter_types::tree_sitter::Node<'tree>,
8658 src: &'tree [u8],
8659 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8660 debug_assert_eq!(node.kind(), "tuple_pattern");
8661 Ok(Self {
8662 span: ::treesitter_types::Span::from(node),
8663 children: {
8664 #[allow(clippy::suspicious_else_formatting)]
8665 let non_field_children = {
8666 let mut cursor = node.walk();
8667 let mut result = ::std::vec::Vec::new();
8668 if cursor.goto_first_child() {
8669 loop {
8670 if cursor.field_name().is_none()
8671 && cursor.node().is_named()
8672 && !cursor.node().is_extra()
8673 {
8674 result.push(cursor.node());
8675 }
8676 if !cursor.goto_next_sibling() {
8677 break;
8678 }
8679 }
8680 }
8681 result
8682 };
8683 let mut items = ::std::vec::Vec::new();
8684 for child in non_field_children {
8685 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8686 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
8687 child, src,
8688 )
8689 })?);
8690 }
8691 items
8692 },
8693 })
8694 }
8695}
8696impl ::treesitter_types::Spanned for TuplePattern<'_> {
8697 fn span(&self) -> ::treesitter_types::Span {
8698 self.span
8699 }
8700}
8701#[derive(Debug, Clone, PartialEq, Eq)]
8702pub struct TupleStructPattern<'tree> {
8703 pub span: ::treesitter_types::Span,
8704 pub r#type: TupleStructPatternType<'tree>,
8705 pub children: ::std::vec::Vec<Pattern<'tree>>,
8706}
8707impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPattern<'tree> {
8708 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8709 fn from_node(
8710 node: ::treesitter_types::tree_sitter::Node<'tree>,
8711 src: &'tree [u8],
8712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8713 debug_assert_eq!(node.kind(), "tuple_struct_pattern");
8714 Ok(Self {
8715 span: ::treesitter_types::Span::from(node),
8716 r#type: {
8717 let child = node
8718 .child_by_field_name("type")
8719 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8720 ::treesitter_types::runtime::maybe_grow_stack(|| {
8721 <TupleStructPatternType as ::treesitter_types::FromNode>::from_node(child, src)
8722 })?
8723 },
8724 children: {
8725 #[allow(clippy::suspicious_else_formatting)]
8726 let non_field_children = {
8727 let mut cursor = node.walk();
8728 let mut result = ::std::vec::Vec::new();
8729 if cursor.goto_first_child() {
8730 loop {
8731 if cursor.field_name().is_none()
8732 && cursor.node().is_named()
8733 && !cursor.node().is_extra()
8734 {
8735 result.push(cursor.node());
8736 }
8737 if !cursor.goto_next_sibling() {
8738 break;
8739 }
8740 }
8741 }
8742 result
8743 };
8744 let mut items = ::std::vec::Vec::new();
8745 for child in non_field_children {
8746 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8747 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8748 })?);
8749 }
8750 items
8751 },
8752 })
8753 }
8754}
8755impl ::treesitter_types::Spanned for TupleStructPattern<'_> {
8756 fn span(&self) -> ::treesitter_types::Span {
8757 self.span
8758 }
8759}
8760#[derive(Debug, Clone, PartialEq, Eq)]
8761pub struct TupleType<'tree> {
8762 pub span: ::treesitter_types::Span,
8763 pub children: ::std::vec::Vec<Type<'tree>>,
8764}
8765impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
8766 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8767 fn from_node(
8768 node: ::treesitter_types::tree_sitter::Node<'tree>,
8769 src: &'tree [u8],
8770 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8771 debug_assert_eq!(node.kind(), "tuple_type");
8772 Ok(Self {
8773 span: ::treesitter_types::Span::from(node),
8774 children: {
8775 #[allow(clippy::suspicious_else_formatting)]
8776 let non_field_children = {
8777 let mut cursor = node.walk();
8778 let mut result = ::std::vec::Vec::new();
8779 if cursor.goto_first_child() {
8780 loop {
8781 if cursor.field_name().is_none()
8782 && cursor.node().is_named()
8783 && !cursor.node().is_extra()
8784 {
8785 result.push(cursor.node());
8786 }
8787 if !cursor.goto_next_sibling() {
8788 break;
8789 }
8790 }
8791 }
8792 result
8793 };
8794 let mut items = ::std::vec::Vec::new();
8795 for child in non_field_children {
8796 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8797 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8798 })?);
8799 }
8800 items
8801 },
8802 })
8803 }
8804}
8805impl ::treesitter_types::Spanned for TupleType<'_> {
8806 fn span(&self) -> ::treesitter_types::Span {
8807 self.span
8808 }
8809}
8810#[derive(Debug, Clone, PartialEq, Eq)]
8811pub struct TypeArguments<'tree> {
8812 pub span: ::treesitter_types::Span,
8813 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
8814}
8815impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
8816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8817 fn from_node(
8818 node: ::treesitter_types::tree_sitter::Node<'tree>,
8819 src: &'tree [u8],
8820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8821 debug_assert_eq!(node.kind(), "type_arguments");
8822 Ok(Self {
8823 span: ::treesitter_types::Span::from(node),
8824 children: {
8825 #[allow(clippy::suspicious_else_formatting)]
8826 let non_field_children = {
8827 let mut cursor = node.walk();
8828 let mut result = ::std::vec::Vec::new();
8829 if cursor.goto_first_child() {
8830 loop {
8831 if cursor.field_name().is_none()
8832 && cursor.node().is_named()
8833 && !cursor.node().is_extra()
8834 {
8835 result.push(cursor.node());
8836 }
8837 if !cursor.goto_next_sibling() {
8838 break;
8839 }
8840 }
8841 }
8842 result
8843 };
8844 let mut items = ::std::vec::Vec::new();
8845 for child in non_field_children {
8846 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8847 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
8848 child, src,
8849 )
8850 })?);
8851 }
8852 items
8853 },
8854 })
8855 }
8856}
8857impl ::treesitter_types::Spanned for TypeArguments<'_> {
8858 fn span(&self) -> ::treesitter_types::Span {
8859 self.span
8860 }
8861}
8862#[derive(Debug, Clone, PartialEq, Eq)]
8863pub struct TypeBinding<'tree> {
8864 pub span: ::treesitter_types::Span,
8865 pub name: TypeIdentifier<'tree>,
8866 pub r#type: Type<'tree>,
8867 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
8868}
8869impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBinding<'tree> {
8870 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8871 fn from_node(
8872 node: ::treesitter_types::tree_sitter::Node<'tree>,
8873 src: &'tree [u8],
8874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8875 debug_assert_eq!(node.kind(), "type_binding");
8876 Ok(Self {
8877 span: ::treesitter_types::Span::from(node),
8878 name: {
8879 let child = node
8880 .child_by_field_name("name")
8881 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8882 ::treesitter_types::runtime::maybe_grow_stack(|| {
8883 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
8884 })?
8885 },
8886 r#type: {
8887 let child = node
8888 .child_by_field_name("type")
8889 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8890 ::treesitter_types::runtime::maybe_grow_stack(|| {
8891 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8892 })?
8893 },
8894 type_arguments: match node.child_by_field_name("type_arguments") {
8895 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8896 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
8897 })?),
8898 None => None,
8899 },
8900 })
8901 }
8902}
8903impl ::treesitter_types::Spanned for TypeBinding<'_> {
8904 fn span(&self) -> ::treesitter_types::Span {
8905 self.span
8906 }
8907}
8908#[derive(Debug, Clone, PartialEq, Eq)]
8909pub struct TypeCastExpression<'tree> {
8910 pub span: ::treesitter_types::Span,
8911 pub r#type: Type<'tree>,
8912 pub value: Expression<'tree>,
8913}
8914impl<'tree> ::treesitter_types::FromNode<'tree> for TypeCastExpression<'tree> {
8915 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8916 fn from_node(
8917 node: ::treesitter_types::tree_sitter::Node<'tree>,
8918 src: &'tree [u8],
8919 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8920 debug_assert_eq!(node.kind(), "type_cast_expression");
8921 Ok(Self {
8922 span: ::treesitter_types::Span::from(node),
8923 r#type: {
8924 let child = node
8925 .child_by_field_name("type")
8926 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8927 ::treesitter_types::runtime::maybe_grow_stack(|| {
8928 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8929 })?
8930 },
8931 value: {
8932 let child = node
8933 .child_by_field_name("value")
8934 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
8935 ::treesitter_types::runtime::maybe_grow_stack(|| {
8936 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8937 })?
8938 },
8939 })
8940 }
8941}
8942impl ::treesitter_types::Spanned for TypeCastExpression<'_> {
8943 fn span(&self) -> ::treesitter_types::Span {
8944 self.span
8945 }
8946}
8947#[derive(Debug, Clone, PartialEq, Eq)]
8948pub struct TypeItem<'tree> {
8949 pub span: ::treesitter_types::Span,
8950 pub name: TypeIdentifier<'tree>,
8951 pub r#type: Type<'tree>,
8952 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
8953 pub children: ::std::vec::Vec<TypeItemChildren<'tree>>,
8954}
8955impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItem<'tree> {
8956 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8957 fn from_node(
8958 node: ::treesitter_types::tree_sitter::Node<'tree>,
8959 src: &'tree [u8],
8960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8961 debug_assert_eq!(node.kind(), "type_item");
8962 Ok(Self {
8963 span: ::treesitter_types::Span::from(node),
8964 name: {
8965 let child = node
8966 .child_by_field_name("name")
8967 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8968 ::treesitter_types::runtime::maybe_grow_stack(|| {
8969 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
8970 })?
8971 },
8972 r#type: {
8973 let child = node
8974 .child_by_field_name("type")
8975 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8976 ::treesitter_types::runtime::maybe_grow_stack(|| {
8977 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8978 })?
8979 },
8980 type_parameters: match node.child_by_field_name("type_parameters") {
8981 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8982 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
8983 })?),
8984 None => None,
8985 },
8986 children: {
8987 #[allow(clippy::suspicious_else_formatting)]
8988 let non_field_children = {
8989 let mut cursor = node.walk();
8990 let mut result = ::std::vec::Vec::new();
8991 if cursor.goto_first_child() {
8992 loop {
8993 if cursor.field_name().is_none()
8994 && cursor.node().is_named()
8995 && !cursor.node().is_extra()
8996 {
8997 result.push(cursor.node());
8998 }
8999 if !cursor.goto_next_sibling() {
9000 break;
9001 }
9002 }
9003 }
9004 result
9005 };
9006 let mut items = ::std::vec::Vec::new();
9007 for child in non_field_children {
9008 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9009 <TypeItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
9010 })?);
9011 }
9012 items
9013 },
9014 })
9015 }
9016}
9017impl ::treesitter_types::Spanned for TypeItem<'_> {
9018 fn span(&self) -> ::treesitter_types::Span {
9019 self.span
9020 }
9021}
9022#[derive(Debug, Clone, PartialEq, Eq)]
9023pub struct TypeParameter<'tree> {
9024 pub span: ::treesitter_types::Span,
9025 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
9026 pub default_type: ::core::option::Option<Type<'tree>>,
9027 pub name: TypeIdentifier<'tree>,
9028}
9029impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
9030 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9031 fn from_node(
9032 node: ::treesitter_types::tree_sitter::Node<'tree>,
9033 src: &'tree [u8],
9034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9035 debug_assert_eq!(node.kind(), "type_parameter");
9036 Ok(Self {
9037 span: ::treesitter_types::Span::from(node),
9038 bounds: match node.child_by_field_name("bounds") {
9039 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9040 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)
9041 })?),
9042 None => None,
9043 },
9044 default_type: match node.child_by_field_name("default_type") {
9045 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9046 <Type as ::treesitter_types::FromNode>::from_node(child, src)
9047 })?),
9048 None => None,
9049 },
9050 name: {
9051 let child = node
9052 .child_by_field_name("name")
9053 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9054 ::treesitter_types::runtime::maybe_grow_stack(|| {
9055 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
9056 })?
9057 },
9058 })
9059 }
9060}
9061impl ::treesitter_types::Spanned for TypeParameter<'_> {
9062 fn span(&self) -> ::treesitter_types::Span {
9063 self.span
9064 }
9065}
9066#[derive(Debug, Clone, PartialEq, Eq)]
9067pub struct TypeParameters<'tree> {
9068 pub span: ::treesitter_types::Span,
9069 pub children: ::std::vec::Vec<TypeParametersChildren<'tree>>,
9070}
9071impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
9072 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9073 fn from_node(
9074 node: ::treesitter_types::tree_sitter::Node<'tree>,
9075 src: &'tree [u8],
9076 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9077 debug_assert_eq!(node.kind(), "type_parameters");
9078 Ok(Self {
9079 span: ::treesitter_types::Span::from(node),
9080 children: {
9081 #[allow(clippy::suspicious_else_formatting)]
9082 let non_field_children = {
9083 let mut cursor = node.walk();
9084 let mut result = ::std::vec::Vec::new();
9085 if cursor.goto_first_child() {
9086 loop {
9087 if cursor.field_name().is_none()
9088 && cursor.node().is_named()
9089 && !cursor.node().is_extra()
9090 {
9091 result.push(cursor.node());
9092 }
9093 if !cursor.goto_next_sibling() {
9094 break;
9095 }
9096 }
9097 }
9098 result
9099 };
9100 let mut items = ::std::vec::Vec::new();
9101 for child in non_field_children {
9102 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9103 <TypeParametersChildren as ::treesitter_types::FromNode>::from_node(
9104 child, src,
9105 )
9106 })?);
9107 }
9108 items
9109 },
9110 })
9111 }
9112}
9113impl ::treesitter_types::Spanned for TypeParameters<'_> {
9114 fn span(&self) -> ::treesitter_types::Span {
9115 self.span
9116 }
9117}
9118#[derive(Debug, Clone, PartialEq, Eq)]
9119pub struct UnaryExpression<'tree> {
9120 pub span: ::treesitter_types::Span,
9121 pub children: Expression<'tree>,
9122}
9123impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
9124 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9125 fn from_node(
9126 node: ::treesitter_types::tree_sitter::Node<'tree>,
9127 src: &'tree [u8],
9128 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9129 debug_assert_eq!(node.kind(), "unary_expression");
9130 Ok(Self {
9131 span: ::treesitter_types::Span::from(node),
9132 children: {
9133 #[allow(clippy::suspicious_else_formatting)]
9134 let non_field_children = {
9135 let mut cursor = node.walk();
9136 let mut result = ::std::vec::Vec::new();
9137 if cursor.goto_first_child() {
9138 loop {
9139 if cursor.field_name().is_none()
9140 && cursor.node().is_named()
9141 && !cursor.node().is_extra()
9142 {
9143 result.push(cursor.node());
9144 }
9145 if !cursor.goto_next_sibling() {
9146 break;
9147 }
9148 }
9149 }
9150 result
9151 };
9152 let child = if let Some(&c) = non_field_children.first() {
9153 c
9154 } else {
9155 let mut fallback_cursor = node.walk();
9156 let mut fallback_child = None;
9157 if fallback_cursor.goto_first_child() {
9158 loop {
9159 if fallback_cursor.field_name().is_none()
9160 && !fallback_cursor.node().is_extra()
9161 {
9162 let candidate = fallback_cursor.node();
9163 #[allow(clippy::needless_question_mark)]
9164 if (|| -> ::core::result::Result<
9165 _,
9166 ::treesitter_types::ParseError,
9167 > {
9168 let child = candidate;
9169 Ok(
9170 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9171 child,
9172 src,
9173 ))?,
9174 )
9175 })()
9176 .is_ok()
9177 {
9178 fallback_child = Some(candidate);
9179 break;
9180 }
9181 }
9182 if !fallback_cursor.goto_next_sibling() {
9183 break;
9184 }
9185 }
9186 }
9187 if fallback_child.is_none() {
9188 let mut cursor2 = node.walk();
9189 if cursor2.goto_first_child() {
9190 loop {
9191 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9192 let candidate = cursor2.node();
9193 #[allow(clippy::needless_question_mark)]
9194 if (|| -> ::core::result::Result<
9195 _,
9196 ::treesitter_types::ParseError,
9197 > {
9198 let child = candidate;
9199 Ok(
9200 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9201 child,
9202 src,
9203 ))?,
9204 )
9205 })()
9206 .is_ok()
9207 {
9208 fallback_child = Some(candidate);
9209 break;
9210 }
9211 }
9212 if !cursor2.goto_next_sibling() {
9213 break;
9214 }
9215 }
9216 }
9217 }
9218 fallback_child.ok_or_else(|| {
9219 ::treesitter_types::ParseError::missing_field("children", node)
9220 })?
9221 };
9222 ::treesitter_types::runtime::maybe_grow_stack(|| {
9223 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9224 })?
9225 },
9226 })
9227 }
9228}
9229impl ::treesitter_types::Spanned for UnaryExpression<'_> {
9230 fn span(&self) -> ::treesitter_types::Span {
9231 self.span
9232 }
9233}
9234#[derive(Debug, Clone, PartialEq, Eq)]
9235pub struct UnionItem<'tree> {
9236 pub span: ::treesitter_types::Span,
9237 pub body: FieldDeclarationList<'tree>,
9238 pub name: TypeIdentifier<'tree>,
9239 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
9240 pub children: ::std::vec::Vec<UnionItemChildren<'tree>>,
9241}
9242impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItem<'tree> {
9243 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9244 fn from_node(
9245 node: ::treesitter_types::tree_sitter::Node<'tree>,
9246 src: &'tree [u8],
9247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9248 debug_assert_eq!(node.kind(), "union_item");
9249 Ok(Self {
9250 span: ::treesitter_types::Span::from(node),
9251 body: {
9252 let child = node
9253 .child_by_field_name("body")
9254 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9255 ::treesitter_types::runtime::maybe_grow_stack(|| {
9256 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
9257 })?
9258 },
9259 name: {
9260 let child = node
9261 .child_by_field_name("name")
9262 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9263 ::treesitter_types::runtime::maybe_grow_stack(|| {
9264 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
9265 })?
9266 },
9267 type_parameters: match node.child_by_field_name("type_parameters") {
9268 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9269 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)
9270 })?),
9271 None => None,
9272 },
9273 children: {
9274 #[allow(clippy::suspicious_else_formatting)]
9275 let non_field_children = {
9276 let mut cursor = node.walk();
9277 let mut result = ::std::vec::Vec::new();
9278 if cursor.goto_first_child() {
9279 loop {
9280 if cursor.field_name().is_none()
9281 && cursor.node().is_named()
9282 && !cursor.node().is_extra()
9283 {
9284 result.push(cursor.node());
9285 }
9286 if !cursor.goto_next_sibling() {
9287 break;
9288 }
9289 }
9290 }
9291 result
9292 };
9293 let mut items = ::std::vec::Vec::new();
9294 for child in non_field_children {
9295 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9296 <UnionItemChildren as ::treesitter_types::FromNode>::from_node(child, src)
9297 })?);
9298 }
9299 items
9300 },
9301 })
9302 }
9303}
9304impl ::treesitter_types::Spanned for UnionItem<'_> {
9305 fn span(&self) -> ::treesitter_types::Span {
9306 self.span
9307 }
9308}
9309#[derive(Debug, Clone, PartialEq, Eq)]
9310pub struct UnitExpression<'tree> {
9311 pub span: ::treesitter_types::Span,
9312 text: &'tree str,
9313}
9314impl<'tree> ::treesitter_types::FromNode<'tree> for UnitExpression<'tree> {
9315 fn from_node(
9316 node: ::treesitter_types::tree_sitter::Node<'tree>,
9317 src: &'tree [u8],
9318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9319 debug_assert_eq!(node.kind(), "unit_expression");
9320 Ok(Self {
9321 span: ::treesitter_types::Span::from(node),
9322 text: node.utf8_text(src)?,
9323 })
9324 }
9325}
9326impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitExpression<'tree> {
9327 fn text(&self) -> &'tree str {
9328 self.text
9329 }
9330}
9331impl ::treesitter_types::Spanned for UnitExpression<'_> {
9332 fn span(&self) -> ::treesitter_types::Span {
9333 self.span
9334 }
9335}
9336#[derive(Debug, Clone, PartialEq, Eq)]
9337pub struct UnitType<'tree> {
9338 pub span: ::treesitter_types::Span,
9339 text: &'tree str,
9340}
9341impl<'tree> ::treesitter_types::FromNode<'tree> for UnitType<'tree> {
9342 fn from_node(
9343 node: ::treesitter_types::tree_sitter::Node<'tree>,
9344 src: &'tree [u8],
9345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9346 debug_assert_eq!(node.kind(), "unit_type");
9347 Ok(Self {
9348 span: ::treesitter_types::Span::from(node),
9349 text: node.utf8_text(src)?,
9350 })
9351 }
9352}
9353impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitType<'tree> {
9354 fn text(&self) -> &'tree str {
9355 self.text
9356 }
9357}
9358impl ::treesitter_types::Spanned for UnitType<'_> {
9359 fn span(&self) -> ::treesitter_types::Span {
9360 self.span
9361 }
9362}
9363#[derive(Debug, Clone, PartialEq, Eq)]
9364pub struct UnsafeBlock<'tree> {
9365 pub span: ::treesitter_types::Span,
9366 pub children: Block<'tree>,
9367}
9368impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeBlock<'tree> {
9369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9370 fn from_node(
9371 node: ::treesitter_types::tree_sitter::Node<'tree>,
9372 src: &'tree [u8],
9373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9374 debug_assert_eq!(node.kind(), "unsafe_block");
9375 Ok(Self {
9376 span: ::treesitter_types::Span::from(node),
9377 children: {
9378 #[allow(clippy::suspicious_else_formatting)]
9379 let non_field_children = {
9380 let mut cursor = node.walk();
9381 let mut result = ::std::vec::Vec::new();
9382 if cursor.goto_first_child() {
9383 loop {
9384 if cursor.field_name().is_none()
9385 && cursor.node().is_named()
9386 && !cursor.node().is_extra()
9387 {
9388 result.push(cursor.node());
9389 }
9390 if !cursor.goto_next_sibling() {
9391 break;
9392 }
9393 }
9394 }
9395 result
9396 };
9397 let child = if let Some(&c) = non_field_children.first() {
9398 c
9399 } else {
9400 let mut fallback_cursor = node.walk();
9401 let mut fallback_child = None;
9402 if fallback_cursor.goto_first_child() {
9403 loop {
9404 if fallback_cursor.field_name().is_none()
9405 && !fallback_cursor.node().is_extra()
9406 {
9407 let candidate = fallback_cursor.node();
9408 #[allow(clippy::needless_question_mark)]
9409 if (|| -> ::core::result::Result<
9410 _,
9411 ::treesitter_types::ParseError,
9412 > {
9413 let child = candidate;
9414 Ok(
9415 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
9416 child,
9417 src,
9418 ))?,
9419 )
9420 })()
9421 .is_ok()
9422 {
9423 fallback_child = Some(candidate);
9424 break;
9425 }
9426 }
9427 if !fallback_cursor.goto_next_sibling() {
9428 break;
9429 }
9430 }
9431 }
9432 if fallback_child.is_none() {
9433 let mut cursor2 = node.walk();
9434 if cursor2.goto_first_child() {
9435 loop {
9436 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9437 let candidate = cursor2.node();
9438 #[allow(clippy::needless_question_mark)]
9439 if (|| -> ::core::result::Result<
9440 _,
9441 ::treesitter_types::ParseError,
9442 > {
9443 let child = candidate;
9444 Ok(
9445 ::treesitter_types::runtime::maybe_grow_stack(|| <Block as ::treesitter_types::FromNode>::from_node(
9446 child,
9447 src,
9448 ))?,
9449 )
9450 })()
9451 .is_ok()
9452 {
9453 fallback_child = Some(candidate);
9454 break;
9455 }
9456 }
9457 if !cursor2.goto_next_sibling() {
9458 break;
9459 }
9460 }
9461 }
9462 }
9463 fallback_child.ok_or_else(|| {
9464 ::treesitter_types::ParseError::missing_field("children", node)
9465 })?
9466 };
9467 ::treesitter_types::runtime::maybe_grow_stack(|| {
9468 <Block as ::treesitter_types::FromNode>::from_node(child, src)
9469 })?
9470 },
9471 })
9472 }
9473}
9474impl ::treesitter_types::Spanned for UnsafeBlock<'_> {
9475 fn span(&self) -> ::treesitter_types::Span {
9476 self.span
9477 }
9478}
9479#[derive(Debug, Clone, PartialEq, Eq)]
9480pub struct UseAsClause<'tree> {
9481 pub span: ::treesitter_types::Span,
9482 pub alias: Identifier<'tree>,
9483 pub path: UseAsClausePath<'tree>,
9484}
9485impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClause<'tree> {
9486 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9487 fn from_node(
9488 node: ::treesitter_types::tree_sitter::Node<'tree>,
9489 src: &'tree [u8],
9490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9491 debug_assert_eq!(node.kind(), "use_as_clause");
9492 Ok(Self {
9493 span: ::treesitter_types::Span::from(node),
9494 alias: {
9495 let child = node
9496 .child_by_field_name("alias")
9497 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
9498 ::treesitter_types::runtime::maybe_grow_stack(|| {
9499 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
9500 })?
9501 },
9502 path: {
9503 let child = node
9504 .child_by_field_name("path")
9505 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
9506 ::treesitter_types::runtime::maybe_grow_stack(|| {
9507 <UseAsClausePath as ::treesitter_types::FromNode>::from_node(child, src)
9508 })?
9509 },
9510 })
9511 }
9512}
9513impl ::treesitter_types::Spanned for UseAsClause<'_> {
9514 fn span(&self) -> ::treesitter_types::Span {
9515 self.span
9516 }
9517}
9518#[derive(Debug, Clone, PartialEq, Eq)]
9519pub struct UseBounds<'tree> {
9520 pub span: ::treesitter_types::Span,
9521 pub children: ::std::vec::Vec<UseBoundsChildren<'tree>>,
9522}
9523impl<'tree> ::treesitter_types::FromNode<'tree> for UseBounds<'tree> {
9524 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9525 fn from_node(
9526 node: ::treesitter_types::tree_sitter::Node<'tree>,
9527 src: &'tree [u8],
9528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9529 debug_assert_eq!(node.kind(), "use_bounds");
9530 Ok(Self {
9531 span: ::treesitter_types::Span::from(node),
9532 children: {
9533 #[allow(clippy::suspicious_else_formatting)]
9534 let non_field_children = {
9535 let mut cursor = node.walk();
9536 let mut result = ::std::vec::Vec::new();
9537 if cursor.goto_first_child() {
9538 loop {
9539 if cursor.field_name().is_none()
9540 && cursor.node().is_named()
9541 && !cursor.node().is_extra()
9542 {
9543 result.push(cursor.node());
9544 }
9545 if !cursor.goto_next_sibling() {
9546 break;
9547 }
9548 }
9549 }
9550 result
9551 };
9552 let mut items = ::std::vec::Vec::new();
9553 for child in non_field_children {
9554 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9555 <UseBoundsChildren as ::treesitter_types::FromNode>::from_node(child, src)
9556 })?);
9557 }
9558 items
9559 },
9560 })
9561 }
9562}
9563impl ::treesitter_types::Spanned for UseBounds<'_> {
9564 fn span(&self) -> ::treesitter_types::Span {
9565 self.span
9566 }
9567}
9568#[derive(Debug, Clone, PartialEq, Eq)]
9569pub struct UseDeclaration<'tree> {
9570 pub span: ::treesitter_types::Span,
9571 pub argument: UseDeclarationArgument<'tree>,
9572 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
9573}
9574impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclaration<'tree> {
9575 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9576 fn from_node(
9577 node: ::treesitter_types::tree_sitter::Node<'tree>,
9578 src: &'tree [u8],
9579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9580 debug_assert_eq!(node.kind(), "use_declaration");
9581 Ok(Self {
9582 span: ::treesitter_types::Span::from(node),
9583 argument: {
9584 let child = node.child_by_field_name("argument").ok_or_else(|| {
9585 ::treesitter_types::ParseError::missing_field("argument", node)
9586 })?;
9587 ::treesitter_types::runtime::maybe_grow_stack(|| {
9588 <UseDeclarationArgument as ::treesitter_types::FromNode>::from_node(child, src)
9589 })?
9590 },
9591 children: {
9592 #[allow(clippy::suspicious_else_formatting)]
9593 let non_field_children = {
9594 let mut cursor = node.walk();
9595 let mut result = ::std::vec::Vec::new();
9596 if cursor.goto_first_child() {
9597 loop {
9598 if cursor.field_name().is_none()
9599 && cursor.node().is_named()
9600 && !cursor.node().is_extra()
9601 {
9602 result.push(cursor.node());
9603 }
9604 if !cursor.goto_next_sibling() {
9605 break;
9606 }
9607 }
9608 }
9609 result
9610 };
9611 match non_field_children.first() {
9612 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9613 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
9614 })?),
9615 None => None,
9616 }
9617 },
9618 })
9619 }
9620}
9621impl ::treesitter_types::Spanned for UseDeclaration<'_> {
9622 fn span(&self) -> ::treesitter_types::Span {
9623 self.span
9624 }
9625}
9626#[derive(Debug, Clone, PartialEq, Eq)]
9627pub struct UseList<'tree> {
9628 pub span: ::treesitter_types::Span,
9629 pub children: ::std::vec::Vec<UseListChildren<'tree>>,
9630}
9631impl<'tree> ::treesitter_types::FromNode<'tree> for UseList<'tree> {
9632 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9633 fn from_node(
9634 node: ::treesitter_types::tree_sitter::Node<'tree>,
9635 src: &'tree [u8],
9636 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9637 debug_assert_eq!(node.kind(), "use_list");
9638 Ok(Self {
9639 span: ::treesitter_types::Span::from(node),
9640 children: {
9641 #[allow(clippy::suspicious_else_formatting)]
9642 let non_field_children = {
9643 let mut cursor = node.walk();
9644 let mut result = ::std::vec::Vec::new();
9645 if cursor.goto_first_child() {
9646 loop {
9647 if cursor.field_name().is_none()
9648 && cursor.node().is_named()
9649 && !cursor.node().is_extra()
9650 {
9651 result.push(cursor.node());
9652 }
9653 if !cursor.goto_next_sibling() {
9654 break;
9655 }
9656 }
9657 }
9658 result
9659 };
9660 let mut items = ::std::vec::Vec::new();
9661 for child in non_field_children {
9662 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9663 <UseListChildren as ::treesitter_types::FromNode>::from_node(child, src)
9664 })?);
9665 }
9666 items
9667 },
9668 })
9669 }
9670}
9671impl ::treesitter_types::Spanned for UseList<'_> {
9672 fn span(&self) -> ::treesitter_types::Span {
9673 self.span
9674 }
9675}
9676#[derive(Debug, Clone, PartialEq, Eq)]
9677pub struct UseWildcard<'tree> {
9678 pub span: ::treesitter_types::Span,
9679 pub children: ::core::option::Option<UseWildcardChildren<'tree>>,
9680}
9681impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcard<'tree> {
9682 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9683 fn from_node(
9684 node: ::treesitter_types::tree_sitter::Node<'tree>,
9685 src: &'tree [u8],
9686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9687 debug_assert_eq!(node.kind(), "use_wildcard");
9688 Ok(Self {
9689 span: ::treesitter_types::Span::from(node),
9690 children: {
9691 #[allow(clippy::suspicious_else_formatting)]
9692 let non_field_children = {
9693 let mut cursor = node.walk();
9694 let mut result = ::std::vec::Vec::new();
9695 if cursor.goto_first_child() {
9696 loop {
9697 if cursor.field_name().is_none()
9698 && cursor.node().is_named()
9699 && !cursor.node().is_extra()
9700 {
9701 result.push(cursor.node());
9702 }
9703 if !cursor.goto_next_sibling() {
9704 break;
9705 }
9706 }
9707 }
9708 result
9709 };
9710 match non_field_children.first() {
9711 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9712 <UseWildcardChildren as ::treesitter_types::FromNode>::from_node(child, src)
9713 })?),
9714 None => None,
9715 }
9716 },
9717 })
9718 }
9719}
9720impl ::treesitter_types::Spanned for UseWildcard<'_> {
9721 fn span(&self) -> ::treesitter_types::Span {
9722 self.span
9723 }
9724}
9725#[derive(Debug, Clone, PartialEq, Eq)]
9726pub struct VariadicParameter<'tree> {
9727 pub span: ::treesitter_types::Span,
9728 pub pattern: ::core::option::Option<Pattern<'tree>>,
9729 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
9730}
9731impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
9732 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9733 fn from_node(
9734 node: ::treesitter_types::tree_sitter::Node<'tree>,
9735 src: &'tree [u8],
9736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9737 debug_assert_eq!(node.kind(), "variadic_parameter");
9738 Ok(Self {
9739 span: ::treesitter_types::Span::from(node),
9740 pattern: match node.child_by_field_name("pattern") {
9741 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9742 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
9743 })?),
9744 None => None,
9745 },
9746 children: {
9747 #[allow(clippy::suspicious_else_formatting)]
9748 let non_field_children = {
9749 let mut cursor = node.walk();
9750 let mut result = ::std::vec::Vec::new();
9751 if cursor.goto_first_child() {
9752 loop {
9753 if cursor.field_name().is_none()
9754 && cursor.node().is_named()
9755 && !cursor.node().is_extra()
9756 {
9757 result.push(cursor.node());
9758 }
9759 if !cursor.goto_next_sibling() {
9760 break;
9761 }
9762 }
9763 }
9764 result
9765 };
9766 match non_field_children.first() {
9767 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9768 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
9769 })?),
9770 None => None,
9771 }
9772 },
9773 })
9774 }
9775}
9776impl ::treesitter_types::Spanned for VariadicParameter<'_> {
9777 fn span(&self) -> ::treesitter_types::Span {
9778 self.span
9779 }
9780}
9781#[derive(Debug, Clone, PartialEq, Eq)]
9782pub struct VisibilityModifier<'tree> {
9783 pub span: ::treesitter_types::Span,
9784 pub children: ::core::option::Option<VisibilityModifierChildren<'tree>>,
9785}
9786impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifier<'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(), "visibility_modifier");
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 match non_field_children.first() {
9816 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9817 <VisibilityModifierChildren as ::treesitter_types::FromNode>::from_node(
9818 child, src,
9819 )
9820 })?),
9821 None => None,
9822 }
9823 },
9824 })
9825 }
9826}
9827impl ::treesitter_types::Spanned for VisibilityModifier<'_> {
9828 fn span(&self) -> ::treesitter_types::Span {
9829 self.span
9830 }
9831}
9832#[derive(Debug, Clone, PartialEq, Eq)]
9833pub struct WhereClause<'tree> {
9834 pub span: ::treesitter_types::Span,
9835 pub children: ::std::vec::Vec<WherePredicate<'tree>>,
9836}
9837impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
9838 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9839 fn from_node(
9840 node: ::treesitter_types::tree_sitter::Node<'tree>,
9841 src: &'tree [u8],
9842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9843 debug_assert_eq!(node.kind(), "where_clause");
9844 Ok(Self {
9845 span: ::treesitter_types::Span::from(node),
9846 children: {
9847 #[allow(clippy::suspicious_else_formatting)]
9848 let non_field_children = {
9849 let mut cursor = node.walk();
9850 let mut result = ::std::vec::Vec::new();
9851 if cursor.goto_first_child() {
9852 loop {
9853 if cursor.field_name().is_none()
9854 && cursor.node().is_named()
9855 && !cursor.node().is_extra()
9856 {
9857 result.push(cursor.node());
9858 }
9859 if !cursor.goto_next_sibling() {
9860 break;
9861 }
9862 }
9863 }
9864 result
9865 };
9866 let mut items = ::std::vec::Vec::new();
9867 for child in non_field_children {
9868 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9869 <WherePredicate as ::treesitter_types::FromNode>::from_node(child, src)
9870 })?);
9871 }
9872 items
9873 },
9874 })
9875 }
9876}
9877impl ::treesitter_types::Spanned for WhereClause<'_> {
9878 fn span(&self) -> ::treesitter_types::Span {
9879 self.span
9880 }
9881}
9882#[derive(Debug, Clone, PartialEq, Eq)]
9883pub struct WherePredicate<'tree> {
9884 pub span: ::treesitter_types::Span,
9885 pub bounds: TraitBounds<'tree>,
9886 pub left: WherePredicateLeft<'tree>,
9887}
9888impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicate<'tree> {
9889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9890 fn from_node(
9891 node: ::treesitter_types::tree_sitter::Node<'tree>,
9892 src: &'tree [u8],
9893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9894 debug_assert_eq!(node.kind(), "where_predicate");
9895 Ok(Self {
9896 span: ::treesitter_types::Span::from(node),
9897 bounds: {
9898 let child = node
9899 .child_by_field_name("bounds")
9900 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bounds", node))?;
9901 ::treesitter_types::runtime::maybe_grow_stack(|| {
9902 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)
9903 })?
9904 },
9905 left: {
9906 let child = node
9907 .child_by_field_name("left")
9908 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
9909 ::treesitter_types::runtime::maybe_grow_stack(|| {
9910 <WherePredicateLeft as ::treesitter_types::FromNode>::from_node(child, src)
9911 })?
9912 },
9913 })
9914 }
9915}
9916impl ::treesitter_types::Spanned for WherePredicate<'_> {
9917 fn span(&self) -> ::treesitter_types::Span {
9918 self.span
9919 }
9920}
9921#[derive(Debug, Clone, PartialEq, Eq)]
9922pub struct WhileExpression<'tree> {
9923 pub span: ::treesitter_types::Span,
9924 pub body: Block<'tree>,
9925 pub condition: WhileExpressionCondition<'tree>,
9926 pub children: ::core::option::Option<Label<'tree>>,
9927}
9928impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpression<'tree> {
9929 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9930 fn from_node(
9931 node: ::treesitter_types::tree_sitter::Node<'tree>,
9932 src: &'tree [u8],
9933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9934 debug_assert_eq!(node.kind(), "while_expression");
9935 Ok(Self {
9936 span: ::treesitter_types::Span::from(node),
9937 body: {
9938 let child = node
9939 .child_by_field_name("body")
9940 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9941 ::treesitter_types::runtime::maybe_grow_stack(|| {
9942 <Block as ::treesitter_types::FromNode>::from_node(child, src)
9943 })?
9944 },
9945 condition: {
9946 let child = node.child_by_field_name("condition").ok_or_else(|| {
9947 ::treesitter_types::ParseError::missing_field("condition", node)
9948 })?;
9949 ::treesitter_types::runtime::maybe_grow_stack(|| {
9950 <WhileExpressionCondition as ::treesitter_types::FromNode>::from_node(
9951 child, src,
9952 )
9953 })?
9954 },
9955 children: {
9956 #[allow(clippy::suspicious_else_formatting)]
9957 let non_field_children = {
9958 let mut cursor = node.walk();
9959 let mut result = ::std::vec::Vec::new();
9960 if cursor.goto_first_child() {
9961 loop {
9962 if cursor.field_name().is_none()
9963 && cursor.node().is_named()
9964 && !cursor.node().is_extra()
9965 {
9966 result.push(cursor.node());
9967 }
9968 if !cursor.goto_next_sibling() {
9969 break;
9970 }
9971 }
9972 }
9973 result
9974 };
9975 match non_field_children.first() {
9976 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9977 <Label as ::treesitter_types::FromNode>::from_node(child, src)
9978 })?),
9979 None => None,
9980 }
9981 },
9982 })
9983 }
9984}
9985impl ::treesitter_types::Spanned for WhileExpression<'_> {
9986 fn span(&self) -> ::treesitter_types::Span {
9987 self.span
9988 }
9989}
9990#[derive(Debug, Clone, PartialEq, Eq)]
9991pub struct YieldExpression<'tree> {
9992 pub span: ::treesitter_types::Span,
9993 pub children: ::core::option::Option<Expression<'tree>>,
9994}
9995impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
9996 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9997 fn from_node(
9998 node: ::treesitter_types::tree_sitter::Node<'tree>,
9999 src: &'tree [u8],
10000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10001 debug_assert_eq!(node.kind(), "yield_expression");
10002 Ok(Self {
10003 span: ::treesitter_types::Span::from(node),
10004 children: {
10005 #[allow(clippy::suspicious_else_formatting)]
10006 let non_field_children = {
10007 let mut cursor = node.walk();
10008 let mut result = ::std::vec::Vec::new();
10009 if cursor.goto_first_child() {
10010 loop {
10011 if cursor.field_name().is_none()
10012 && cursor.node().is_named()
10013 && !cursor.node().is_extra()
10014 {
10015 result.push(cursor.node());
10016 }
10017 if !cursor.goto_next_sibling() {
10018 break;
10019 }
10020 }
10021 }
10022 result
10023 };
10024 match non_field_children.first() {
10025 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10026 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10027 })?),
10028 None => None,
10029 }
10030 },
10031 })
10032 }
10033}
10034impl ::treesitter_types::Spanned for YieldExpression<'_> {
10035 fn span(&self) -> ::treesitter_types::Span {
10036 self.span
10037 }
10038}
10039#[derive(Debug, Clone, PartialEq, Eq)]
10040pub struct CharLiteral<'tree> {
10041 pub span: ::treesitter_types::Span,
10042 text: &'tree str,
10043}
10044impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
10045 fn from_node(
10046 node: ::treesitter_types::tree_sitter::Node<'tree>,
10047 src: &'tree [u8],
10048 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10049 debug_assert_eq!(node.kind(), "char_literal");
10050 Ok(Self {
10051 span: ::treesitter_types::Span::from(node),
10052 text: node.utf8_text(src)?,
10053 })
10054 }
10055}
10056impl<'tree> ::treesitter_types::LeafNode<'tree> for CharLiteral<'tree> {
10057 fn text(&self) -> &'tree str {
10058 self.text
10059 }
10060}
10061impl ::treesitter_types::Spanned for CharLiteral<'_> {
10062 fn span(&self) -> ::treesitter_types::Span {
10063 self.span
10064 }
10065}
10066#[derive(Debug, Clone, PartialEq, Eq)]
10067pub struct Crate<'tree> {
10068 pub span: ::treesitter_types::Span,
10069 text: &'tree str,
10070}
10071impl<'tree> ::treesitter_types::FromNode<'tree> for Crate<'tree> {
10072 fn from_node(
10073 node: ::treesitter_types::tree_sitter::Node<'tree>,
10074 src: &'tree [u8],
10075 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10076 debug_assert_eq!(node.kind(), "crate");
10077 Ok(Self {
10078 span: ::treesitter_types::Span::from(node),
10079 text: node.utf8_text(src)?,
10080 })
10081 }
10082}
10083impl<'tree> ::treesitter_types::LeafNode<'tree> for Crate<'tree> {
10084 fn text(&self) -> &'tree str {
10085 self.text
10086 }
10087}
10088impl ::treesitter_types::Spanned for Crate<'_> {
10089 fn span(&self) -> ::treesitter_types::Span {
10090 self.span
10091 }
10092}
10093#[derive(Debug, Clone, PartialEq, Eq)]
10094pub struct DocComment<'tree> {
10095 pub span: ::treesitter_types::Span,
10096 text: &'tree str,
10097}
10098impl<'tree> ::treesitter_types::FromNode<'tree> for DocComment<'tree> {
10099 fn from_node(
10100 node: ::treesitter_types::tree_sitter::Node<'tree>,
10101 src: &'tree [u8],
10102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10103 debug_assert_eq!(node.kind(), "doc_comment");
10104 Ok(Self {
10105 span: ::treesitter_types::Span::from(node),
10106 text: node.utf8_text(src)?,
10107 })
10108 }
10109}
10110impl<'tree> ::treesitter_types::LeafNode<'tree> for DocComment<'tree> {
10111 fn text(&self) -> &'tree str {
10112 self.text
10113 }
10114}
10115impl ::treesitter_types::Spanned for DocComment<'_> {
10116 fn span(&self) -> ::treesitter_types::Span {
10117 self.span
10118 }
10119}
10120#[derive(Debug, Clone, PartialEq, Eq)]
10121pub struct EscapeSequence<'tree> {
10122 pub span: ::treesitter_types::Span,
10123 text: &'tree str,
10124}
10125impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
10126 fn from_node(
10127 node: ::treesitter_types::tree_sitter::Node<'tree>,
10128 src: &'tree [u8],
10129 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10130 debug_assert_eq!(node.kind(), "escape_sequence");
10131 Ok(Self {
10132 span: ::treesitter_types::Span::from(node),
10133 text: node.utf8_text(src)?,
10134 })
10135 }
10136}
10137impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
10138 fn text(&self) -> &'tree str {
10139 self.text
10140 }
10141}
10142impl ::treesitter_types::Spanned for EscapeSequence<'_> {
10143 fn span(&self) -> ::treesitter_types::Span {
10144 self.span
10145 }
10146}
10147#[derive(Debug, Clone, PartialEq, Eq)]
10148pub struct FieldIdentifier<'tree> {
10149 pub span: ::treesitter_types::Span,
10150 text: &'tree str,
10151}
10152impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
10153 fn from_node(
10154 node: ::treesitter_types::tree_sitter::Node<'tree>,
10155 src: &'tree [u8],
10156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10157 debug_assert_eq!(node.kind(), "field_identifier");
10158 Ok(Self {
10159 span: ::treesitter_types::Span::from(node),
10160 text: node.utf8_text(src)?,
10161 })
10162 }
10163}
10164impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
10165 fn text(&self) -> &'tree str {
10166 self.text
10167 }
10168}
10169impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
10170 fn span(&self) -> ::treesitter_types::Span {
10171 self.span
10172 }
10173}
10174#[derive(Debug, Clone, PartialEq, Eq)]
10175pub struct FloatLiteral<'tree> {
10176 pub span: ::treesitter_types::Span,
10177 text: &'tree str,
10178}
10179impl<'tree> ::treesitter_types::FromNode<'tree> for FloatLiteral<'tree> {
10180 fn from_node(
10181 node: ::treesitter_types::tree_sitter::Node<'tree>,
10182 src: &'tree [u8],
10183 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10184 debug_assert_eq!(node.kind(), "float_literal");
10185 Ok(Self {
10186 span: ::treesitter_types::Span::from(node),
10187 text: node.utf8_text(src)?,
10188 })
10189 }
10190}
10191impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatLiteral<'tree> {
10192 fn text(&self) -> &'tree str {
10193 self.text
10194 }
10195}
10196impl ::treesitter_types::Spanned for FloatLiteral<'_> {
10197 fn span(&self) -> ::treesitter_types::Span {
10198 self.span
10199 }
10200}
10201#[derive(Debug, Clone, PartialEq, Eq)]
10202pub struct Identifier<'tree> {
10203 pub span: ::treesitter_types::Span,
10204 text: &'tree str,
10205}
10206impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
10207 fn from_node(
10208 node: ::treesitter_types::tree_sitter::Node<'tree>,
10209 src: &'tree [u8],
10210 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10211 debug_assert_eq!(node.kind(), "identifier");
10212 Ok(Self {
10213 span: ::treesitter_types::Span::from(node),
10214 text: node.utf8_text(src)?,
10215 })
10216 }
10217}
10218impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
10219 fn text(&self) -> &'tree str {
10220 self.text
10221 }
10222}
10223impl ::treesitter_types::Spanned for Identifier<'_> {
10224 fn span(&self) -> ::treesitter_types::Span {
10225 self.span
10226 }
10227}
10228#[derive(Debug, Clone, PartialEq, Eq)]
10229pub struct IntegerLiteral<'tree> {
10230 pub span: ::treesitter_types::Span,
10231 text: &'tree str,
10232}
10233impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
10234 fn from_node(
10235 node: ::treesitter_types::tree_sitter::Node<'tree>,
10236 src: &'tree [u8],
10237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10238 debug_assert_eq!(node.kind(), "integer_literal");
10239 Ok(Self {
10240 span: ::treesitter_types::Span::from(node),
10241 text: node.utf8_text(src)?,
10242 })
10243 }
10244}
10245impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
10246 fn text(&self) -> &'tree str {
10247 self.text
10248 }
10249}
10250impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
10251 fn span(&self) -> ::treesitter_types::Span {
10252 self.span
10253 }
10254}
10255#[derive(Debug, Clone, PartialEq, Eq)]
10256pub struct Metavariable<'tree> {
10257 pub span: ::treesitter_types::Span,
10258 text: &'tree str,
10259}
10260impl<'tree> ::treesitter_types::FromNode<'tree> for Metavariable<'tree> {
10261 fn from_node(
10262 node: ::treesitter_types::tree_sitter::Node<'tree>,
10263 src: &'tree [u8],
10264 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10265 debug_assert_eq!(node.kind(), "metavariable");
10266 Ok(Self {
10267 span: ::treesitter_types::Span::from(node),
10268 text: node.utf8_text(src)?,
10269 })
10270 }
10271}
10272impl<'tree> ::treesitter_types::LeafNode<'tree> for Metavariable<'tree> {
10273 fn text(&self) -> &'tree str {
10274 self.text
10275 }
10276}
10277impl ::treesitter_types::Spanned for Metavariable<'_> {
10278 fn span(&self) -> ::treesitter_types::Span {
10279 self.span
10280 }
10281}
10282#[derive(Debug, Clone, PartialEq, Eq)]
10283pub struct MutableSpecifier<'tree> {
10284 pub span: ::treesitter_types::Span,
10285 text: &'tree str,
10286}
10287impl<'tree> ::treesitter_types::FromNode<'tree> for MutableSpecifier<'tree> {
10288 fn from_node(
10289 node: ::treesitter_types::tree_sitter::Node<'tree>,
10290 src: &'tree [u8],
10291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10292 debug_assert_eq!(node.kind(), "mutable_specifier");
10293 Ok(Self {
10294 span: ::treesitter_types::Span::from(node),
10295 text: node.utf8_text(src)?,
10296 })
10297 }
10298}
10299impl<'tree> ::treesitter_types::LeafNode<'tree> for MutableSpecifier<'tree> {
10300 fn text(&self) -> &'tree str {
10301 self.text
10302 }
10303}
10304impl ::treesitter_types::Spanned for MutableSpecifier<'_> {
10305 fn span(&self) -> ::treesitter_types::Span {
10306 self.span
10307 }
10308}
10309#[derive(Debug, Clone, PartialEq, Eq)]
10310pub struct PrimitiveType<'tree> {
10311 pub span: ::treesitter_types::Span,
10312 text: &'tree str,
10313}
10314impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
10315 fn from_node(
10316 node: ::treesitter_types::tree_sitter::Node<'tree>,
10317 src: &'tree [u8],
10318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10319 debug_assert_eq!(node.kind(), "primitive_type");
10320 Ok(Self {
10321 span: ::treesitter_types::Span::from(node),
10322 text: node.utf8_text(src)?,
10323 })
10324 }
10325}
10326impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
10327 fn text(&self) -> &'tree str {
10328 self.text
10329 }
10330}
10331impl ::treesitter_types::Spanned for PrimitiveType<'_> {
10332 fn span(&self) -> ::treesitter_types::Span {
10333 self.span
10334 }
10335}
10336#[derive(Debug, Clone, PartialEq, Eq)]
10337pub struct SelfType<'tree> {
10338 pub span: ::treesitter_types::Span,
10339 text: &'tree str,
10340}
10341impl<'tree> ::treesitter_types::FromNode<'tree> for SelfType<'tree> {
10342 fn from_node(
10343 node: ::treesitter_types::tree_sitter::Node<'tree>,
10344 src: &'tree [u8],
10345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10346 debug_assert_eq!(node.kind(), "self");
10347 Ok(Self {
10348 span: ::treesitter_types::Span::from(node),
10349 text: node.utf8_text(src)?,
10350 })
10351 }
10352}
10353impl<'tree> ::treesitter_types::LeafNode<'tree> for SelfType<'tree> {
10354 fn text(&self) -> &'tree str {
10355 self.text
10356 }
10357}
10358impl ::treesitter_types::Spanned for SelfType<'_> {
10359 fn span(&self) -> ::treesitter_types::Span {
10360 self.span
10361 }
10362}
10363#[derive(Debug, Clone, PartialEq, Eq)]
10364pub struct Shebang<'tree> {
10365 pub span: ::treesitter_types::Span,
10366 text: &'tree str,
10367}
10368impl<'tree> ::treesitter_types::FromNode<'tree> for Shebang<'tree> {
10369 fn from_node(
10370 node: ::treesitter_types::tree_sitter::Node<'tree>,
10371 src: &'tree [u8],
10372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10373 debug_assert_eq!(node.kind(), "shebang");
10374 Ok(Self {
10375 span: ::treesitter_types::Span::from(node),
10376 text: node.utf8_text(src)?,
10377 })
10378 }
10379}
10380impl<'tree> ::treesitter_types::LeafNode<'tree> for Shebang<'tree> {
10381 fn text(&self) -> &'tree str {
10382 self.text
10383 }
10384}
10385impl ::treesitter_types::Spanned for Shebang<'_> {
10386 fn span(&self) -> ::treesitter_types::Span {
10387 self.span
10388 }
10389}
10390#[derive(Debug, Clone, PartialEq, Eq)]
10391pub struct ShorthandFieldIdentifier<'tree> {
10392 pub span: ::treesitter_types::Span,
10393 text: &'tree str,
10394}
10395impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldIdentifier<'tree> {
10396 fn from_node(
10397 node: ::treesitter_types::tree_sitter::Node<'tree>,
10398 src: &'tree [u8],
10399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10400 debug_assert_eq!(node.kind(), "shorthand_field_identifier");
10401 Ok(Self {
10402 span: ::treesitter_types::Span::from(node),
10403 text: node.utf8_text(src)?,
10404 })
10405 }
10406}
10407impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandFieldIdentifier<'tree> {
10408 fn text(&self) -> &'tree str {
10409 self.text
10410 }
10411}
10412impl ::treesitter_types::Spanned for ShorthandFieldIdentifier<'_> {
10413 fn span(&self) -> ::treesitter_types::Span {
10414 self.span
10415 }
10416}
10417#[derive(Debug, Clone, PartialEq, Eq)]
10418pub struct StringContent<'tree> {
10419 pub span: ::treesitter_types::Span,
10420 text: &'tree str,
10421}
10422impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
10423 fn from_node(
10424 node: ::treesitter_types::tree_sitter::Node<'tree>,
10425 src: &'tree [u8],
10426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10427 debug_assert_eq!(node.kind(), "string_content");
10428 Ok(Self {
10429 span: ::treesitter_types::Span::from(node),
10430 text: node.utf8_text(src)?,
10431 })
10432 }
10433}
10434impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
10435 fn text(&self) -> &'tree str {
10436 self.text
10437 }
10438}
10439impl ::treesitter_types::Spanned for StringContent<'_> {
10440 fn span(&self) -> ::treesitter_types::Span {
10441 self.span
10442 }
10443}
10444#[derive(Debug, Clone, PartialEq, Eq)]
10445pub struct Super<'tree> {
10446 pub span: ::treesitter_types::Span,
10447 text: &'tree str,
10448}
10449impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
10450 fn from_node(
10451 node: ::treesitter_types::tree_sitter::Node<'tree>,
10452 src: &'tree [u8],
10453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10454 debug_assert_eq!(node.kind(), "super");
10455 Ok(Self {
10456 span: ::treesitter_types::Span::from(node),
10457 text: node.utf8_text(src)?,
10458 })
10459 }
10460}
10461impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
10462 fn text(&self) -> &'tree str {
10463 self.text
10464 }
10465}
10466impl ::treesitter_types::Spanned for Super<'_> {
10467 fn span(&self) -> ::treesitter_types::Span {
10468 self.span
10469 }
10470}
10471#[derive(Debug, Clone, PartialEq, Eq)]
10472pub struct TypeIdentifier<'tree> {
10473 pub span: ::treesitter_types::Span,
10474 text: &'tree str,
10475}
10476impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
10477 fn from_node(
10478 node: ::treesitter_types::tree_sitter::Node<'tree>,
10479 src: &'tree [u8],
10480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10481 debug_assert_eq!(node.kind(), "type_identifier");
10482 Ok(Self {
10483 span: ::treesitter_types::Span::from(node),
10484 text: node.utf8_text(src)?,
10485 })
10486 }
10487}
10488impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
10489 fn text(&self) -> &'tree str {
10490 self.text
10491 }
10492}
10493impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
10494 fn span(&self) -> ::treesitter_types::Span {
10495 self.span
10496 }
10497}
10498#[derive(Debug, Clone, PartialEq, Eq)]
10499pub enum AbstractTypeTrait<'tree> {
10500 BoundedType(::std::boxed::Box<BoundedType<'tree>>),
10501 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
10502 GenericType(::std::boxed::Box<GenericType<'tree>>),
10503 RemovedTraitBound(::std::boxed::Box<RemovedTraitBound<'tree>>),
10504 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10505 TupleType(::std::boxed::Box<TupleType<'tree>>),
10506 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10507}
10508impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractTypeTrait<'tree> {
10509 #[allow(clippy::collapsible_else_if)]
10510 fn from_node(
10511 node: ::treesitter_types::tree_sitter::Node<'tree>,
10512 src: &'tree [u8],
10513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10514 match node.kind() {
10515 "bounded_type" => Ok(Self::BoundedType(::std::boxed::Box::new(
10516 ::treesitter_types::runtime::maybe_grow_stack(|| {
10517 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)
10518 })?,
10519 ))),
10520 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
10521 ::treesitter_types::runtime::maybe_grow_stack(|| {
10522 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
10523 })?,
10524 ))),
10525 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10526 ::treesitter_types::runtime::maybe_grow_stack(|| {
10527 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
10528 })?,
10529 ))),
10530 "removed_trait_bound" => Ok(Self::RemovedTraitBound(::std::boxed::Box::new(
10531 ::treesitter_types::runtime::maybe_grow_stack(|| {
10532 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
10533 })?,
10534 ))),
10535 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10536 ::treesitter_types::runtime::maybe_grow_stack(|| {
10537 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10538 })?,
10539 ))),
10540 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
10541 ::treesitter_types::runtime::maybe_grow_stack(|| {
10542 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
10543 })?,
10544 ))),
10545 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10546 ::treesitter_types::runtime::maybe_grow_stack(|| {
10547 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10548 })?,
10549 ))),
10550 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10551 }
10552 }
10553}
10554impl ::treesitter_types::Spanned for AbstractTypeTrait<'_> {
10555 fn span(&self) -> ::treesitter_types::Span {
10556 match self {
10557 Self::BoundedType(inner) => inner.span(),
10558 Self::FunctionType(inner) => inner.span(),
10559 Self::GenericType(inner) => inner.span(),
10560 Self::RemovedTraitBound(inner) => inner.span(),
10561 Self::ScopedTypeIdentifier(inner) => inner.span(),
10562 Self::TupleType(inner) => inner.span(),
10563 Self::TypeIdentifier(inner) => inner.span(),
10564 }
10565 }
10566}
10567#[derive(Debug, Clone, PartialEq, Eq)]
10568pub enum ArgumentsChildren<'tree> {
10569 Expression(::std::boxed::Box<Expression<'tree>>),
10570 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10571}
10572impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
10573 #[allow(clippy::collapsible_else_if)]
10574 fn from_node(
10575 node: ::treesitter_types::tree_sitter::Node<'tree>,
10576 src: &'tree [u8],
10577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10578 match node.kind() {
10579 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10580 ::treesitter_types::runtime::maybe_grow_stack(|| {
10581 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
10582 })?,
10583 ))),
10584 _other => {
10585 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10586 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10587 }) {
10588 Ok(Self::Expression(::std::boxed::Box::new(v)))
10589 } else {
10590 Err(::treesitter_types::ParseError::unexpected_kind(
10591 _other, node,
10592 ))
10593 }
10594 }
10595 }
10596 }
10597}
10598impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
10599 fn span(&self) -> ::treesitter_types::Span {
10600 match self {
10601 Self::Expression(inner) => inner.span(),
10602 Self::AttributeItem(inner) => inner.span(),
10603 }
10604 }
10605}
10606#[derive(Debug, Clone, PartialEq, Eq)]
10607pub enum ArrayExpressionChildren<'tree> {
10608 Expression(::std::boxed::Box<Expression<'tree>>),
10609 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10610}
10611impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayExpressionChildren<'tree> {
10612 #[allow(clippy::collapsible_else_if)]
10613 fn from_node(
10614 node: ::treesitter_types::tree_sitter::Node<'tree>,
10615 src: &'tree [u8],
10616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10617 match node.kind() {
10618 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10619 ::treesitter_types::runtime::maybe_grow_stack(|| {
10620 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
10621 })?,
10622 ))),
10623 _other => {
10624 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10625 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10626 }) {
10627 Ok(Self::Expression(::std::boxed::Box::new(v)))
10628 } else {
10629 Err(::treesitter_types::ParseError::unexpected_kind(
10630 _other, node,
10631 ))
10632 }
10633 }
10634 }
10635 }
10636}
10637impl ::treesitter_types::Spanned for ArrayExpressionChildren<'_> {
10638 fn span(&self) -> ::treesitter_types::Span {
10639 match self {
10640 Self::Expression(inner) => inner.span(),
10641 Self::AttributeItem(inner) => inner.span(),
10642 }
10643 }
10644}
10645#[derive(Debug, Clone, PartialEq, Eq)]
10646pub enum AttributeChildren<'tree> {
10647 Crate(::std::boxed::Box<Crate<'tree>>),
10648 Identifier(::std::boxed::Box<Identifier<'tree>>),
10649 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10650 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10651 SelfType(::std::boxed::Box<SelfType<'tree>>),
10652 Super(::std::boxed::Box<Super<'tree>>),
10653}
10654impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeChildren<'tree> {
10655 #[allow(clippy::collapsible_else_if)]
10656 fn from_node(
10657 node: ::treesitter_types::tree_sitter::Node<'tree>,
10658 src: &'tree [u8],
10659 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10660 match node.kind() {
10661 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
10662 ::treesitter_types::runtime::maybe_grow_stack(|| {
10663 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
10664 })?,
10665 ))),
10666 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10667 ::treesitter_types::runtime::maybe_grow_stack(|| {
10668 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10669 })?,
10670 ))),
10671 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10672 ::treesitter_types::runtime::maybe_grow_stack(|| {
10673 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
10674 })?,
10675 ))),
10676 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10677 ::treesitter_types::runtime::maybe_grow_stack(|| {
10678 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10679 })?,
10680 ))),
10681 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10682 ::treesitter_types::runtime::maybe_grow_stack(|| {
10683 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
10684 })?,
10685 ))),
10686 "super" => Ok(Self::Super(::std::boxed::Box::new(
10687 ::treesitter_types::runtime::maybe_grow_stack(|| {
10688 <Super as ::treesitter_types::FromNode>::from_node(node, src)
10689 })?,
10690 ))),
10691 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10692 }
10693 }
10694}
10695impl ::treesitter_types::Spanned for AttributeChildren<'_> {
10696 fn span(&self) -> ::treesitter_types::Span {
10697 match self {
10698 Self::Crate(inner) => inner.span(),
10699 Self::Identifier(inner) => inner.span(),
10700 Self::Metavariable(inner) => inner.span(),
10701 Self::ScopedIdentifier(inner) => inner.span(),
10702 Self::SelfType(inner) => inner.span(),
10703 Self::Super(inner) => inner.span(),
10704 }
10705 }
10706}
10707#[derive(Debug, Clone, PartialEq, Eq)]
10708pub enum BinaryExpressionOperator {
10709 NotEq(::treesitter_types::Span),
10710 Percent(::treesitter_types::Span),
10711 Amp(::treesitter_types::Span),
10712 AmpAmp(::treesitter_types::Span),
10713 Star(::treesitter_types::Span),
10714 Plus(::treesitter_types::Span),
10715 Minus(::treesitter_types::Span),
10716 Slash(::treesitter_types::Span),
10717 Lt(::treesitter_types::Span),
10718 Shl(::treesitter_types::Span),
10719 LtEq(::treesitter_types::Span),
10720 EqEq(::treesitter_types::Span),
10721 Gt(::treesitter_types::Span),
10722 GtEq(::treesitter_types::Span),
10723 Shr(::treesitter_types::Span),
10724 Caret(::treesitter_types::Span),
10725 Pipe(::treesitter_types::Span),
10726 PipePipe(::treesitter_types::Span),
10727}
10728impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
10729 #[allow(clippy::collapsible_else_if)]
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 match node.kind() {
10735 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
10736 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
10737 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
10738 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
10739 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
10740 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10741 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10742 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
10743 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
10744 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
10745 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
10746 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
10747 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
10748 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
10749 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
10750 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
10751 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
10752 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
10753 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10754 }
10755 }
10756}
10757impl ::treesitter_types::Spanned for BinaryExpressionOperator {
10758 fn span(&self) -> ::treesitter_types::Span {
10759 match self {
10760 Self::NotEq(span) => *span,
10761 Self::Percent(span) => *span,
10762 Self::Amp(span) => *span,
10763 Self::AmpAmp(span) => *span,
10764 Self::Star(span) => *span,
10765 Self::Plus(span) => *span,
10766 Self::Minus(span) => *span,
10767 Self::Slash(span) => *span,
10768 Self::Lt(span) => *span,
10769 Self::Shl(span) => *span,
10770 Self::LtEq(span) => *span,
10771 Self::EqEq(span) => *span,
10772 Self::Gt(span) => *span,
10773 Self::GtEq(span) => *span,
10774 Self::Shr(span) => *span,
10775 Self::Caret(span) => *span,
10776 Self::Pipe(span) => *span,
10777 Self::PipePipe(span) => *span,
10778 }
10779 }
10780}
10781#[derive(Debug, Clone, PartialEq, Eq)]
10782pub enum BlockChildren<'tree> {
10783 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
10784 Expression(::std::boxed::Box<Expression<'tree>>),
10785 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
10786 Label(::std::boxed::Box<Label<'tree>>),
10787}
10788impl<'tree> ::treesitter_types::FromNode<'tree> for BlockChildren<'tree> {
10789 #[allow(clippy::collapsible_else_if)]
10790 fn from_node(
10791 node: ::treesitter_types::tree_sitter::Node<'tree>,
10792 src: &'tree [u8],
10793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10794 match node.kind() {
10795 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
10796 ::treesitter_types::runtime::maybe_grow_stack(|| {
10797 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
10798 })?,
10799 ))),
10800 "label" => Ok(Self::Label(::std::boxed::Box::new(
10801 ::treesitter_types::runtime::maybe_grow_stack(|| {
10802 <Label as ::treesitter_types::FromNode>::from_node(node, src)
10803 })?,
10804 ))),
10805 _other => {
10806 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10807 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
10808 }) {
10809 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
10810 } else {
10811 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10812 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10813 }) {
10814 Ok(Self::Expression(::std::boxed::Box::new(v)))
10815 } else {
10816 Err(::treesitter_types::ParseError::unexpected_kind(
10817 _other, node,
10818 ))
10819 }
10820 }
10821 }
10822 }
10823 }
10824}
10825impl ::treesitter_types::Spanned for BlockChildren<'_> {
10826 fn span(&self) -> ::treesitter_types::Span {
10827 match self {
10828 Self::DeclarationStatement(inner) => inner.span(),
10829 Self::Expression(inner) => inner.span(),
10830 Self::ExpressionStatement(inner) => inner.span(),
10831 Self::Label(inner) => inner.span(),
10832 }
10833 }
10834}
10835#[derive(Debug, Clone, PartialEq, Eq)]
10836pub enum BoundedTypeChildren<'tree> {
10837 Type(::std::boxed::Box<Type<'tree>>),
10838 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
10839 UseBounds(::std::boxed::Box<UseBounds<'tree>>),
10840}
10841impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedTypeChildren<'tree> {
10842 #[allow(clippy::collapsible_else_if)]
10843 fn from_node(
10844 node: ::treesitter_types::tree_sitter::Node<'tree>,
10845 src: &'tree [u8],
10846 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10847 match node.kind() {
10848 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
10849 ::treesitter_types::runtime::maybe_grow_stack(|| {
10850 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
10851 })?,
10852 ))),
10853 "use_bounds" => Ok(Self::UseBounds(::std::boxed::Box::new(
10854 ::treesitter_types::runtime::maybe_grow_stack(|| {
10855 <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)
10856 })?,
10857 ))),
10858 _other => {
10859 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10860 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10861 }) {
10862 Ok(Self::Type(::std::boxed::Box::new(v)))
10863 } else {
10864 Err(::treesitter_types::ParseError::unexpected_kind(
10865 _other, node,
10866 ))
10867 }
10868 }
10869 }
10870 }
10871}
10872impl ::treesitter_types::Spanned for BoundedTypeChildren<'_> {
10873 fn span(&self) -> ::treesitter_types::Span {
10874 match self {
10875 Self::Type(inner) => inner.span(),
10876 Self::Lifetime(inner) => inner.span(),
10877 Self::UseBounds(inner) => inner.span(),
10878 }
10879 }
10880}
10881#[derive(Debug, Clone, PartialEq, Eq)]
10882pub enum BracketedTypeChildren<'tree> {
10883 Type(::std::boxed::Box<Type<'tree>>),
10884 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
10885}
10886impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedTypeChildren<'tree> {
10887 #[allow(clippy::collapsible_else_if)]
10888 fn from_node(
10889 node: ::treesitter_types::tree_sitter::Node<'tree>,
10890 src: &'tree [u8],
10891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10892 match node.kind() {
10893 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
10894 ::treesitter_types::runtime::maybe_grow_stack(|| {
10895 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
10896 })?,
10897 ))),
10898 _other => {
10899 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10900 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10901 }) {
10902 Ok(Self::Type(::std::boxed::Box::new(v)))
10903 } else {
10904 Err(::treesitter_types::ParseError::unexpected_kind(
10905 _other, node,
10906 ))
10907 }
10908 }
10909 }
10910 }
10911}
10912impl ::treesitter_types::Spanned for BracketedTypeChildren<'_> {
10913 fn span(&self) -> ::treesitter_types::Span {
10914 match self {
10915 Self::Type(inner) => inner.span(),
10916 Self::QualifiedType(inner) => inner.span(),
10917 }
10918 }
10919}
10920#[derive(Debug, Clone, PartialEq, Eq)]
10921pub enum BreakExpressionChildren<'tree> {
10922 Expression(::std::boxed::Box<Expression<'tree>>),
10923 Label(::std::boxed::Box<Label<'tree>>),
10924}
10925impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpressionChildren<'tree> {
10926 #[allow(clippy::collapsible_else_if)]
10927 fn from_node(
10928 node: ::treesitter_types::tree_sitter::Node<'tree>,
10929 src: &'tree [u8],
10930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10931 match node.kind() {
10932 "label" => Ok(Self::Label(::std::boxed::Box::new(
10933 ::treesitter_types::runtime::maybe_grow_stack(|| {
10934 <Label as ::treesitter_types::FromNode>::from_node(node, src)
10935 })?,
10936 ))),
10937 _other => {
10938 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10939 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10940 }) {
10941 Ok(Self::Expression(::std::boxed::Box::new(v)))
10942 } else {
10943 Err(::treesitter_types::ParseError::unexpected_kind(
10944 _other, node,
10945 ))
10946 }
10947 }
10948 }
10949 }
10950}
10951impl ::treesitter_types::Spanned for BreakExpressionChildren<'_> {
10952 fn span(&self) -> ::treesitter_types::Span {
10953 match self {
10954 Self::Expression(inner) => inner.span(),
10955 Self::Label(inner) => inner.span(),
10956 }
10957 }
10958}
10959#[derive(Debug, Clone, PartialEq, Eq)]
10960pub enum CallExpressionFunction<'tree> {
10961 Literal(::std::boxed::Box<Literal<'tree>>),
10962 ArrayExpression(::std::boxed::Box<ArrayExpression<'tree>>),
10963 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
10964 AsyncBlock(::std::boxed::Box<AsyncBlock<'tree>>),
10965 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
10966 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
10967 Block(::std::boxed::Box<Block<'tree>>),
10968 BreakExpression(::std::boxed::Box<BreakExpression<'tree>>),
10969 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
10970 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
10971 CompoundAssignmentExpr(::std::boxed::Box<CompoundAssignmentExpr<'tree>>),
10972 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
10973 ContinueExpression(::std::boxed::Box<ContinueExpression<'tree>>),
10974 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
10975 ForExpression(::std::boxed::Box<ForExpression<'tree>>),
10976 GenBlock(::std::boxed::Box<GenBlock<'tree>>),
10977 GenericFunction(::std::boxed::Box<GenericFunction<'tree>>),
10978 Identifier(::std::boxed::Box<Identifier<'tree>>),
10979 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
10980 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
10981 LoopExpression(::std::boxed::Box<LoopExpression<'tree>>),
10982 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
10983 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
10984 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10985 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10986 ReferenceExpression(::std::boxed::Box<ReferenceExpression<'tree>>),
10987 ReturnExpression(::std::boxed::Box<ReturnExpression<'tree>>),
10988 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10989 SelfType(::std::boxed::Box<SelfType<'tree>>),
10990 StructExpression(::std::boxed::Box<StructExpression<'tree>>),
10991 TryBlock(::std::boxed::Box<TryBlock<'tree>>),
10992 TryExpression(::std::boxed::Box<TryExpression<'tree>>),
10993 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
10994 TypeCastExpression(::std::boxed::Box<TypeCastExpression<'tree>>),
10995 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
10996 UnitExpression(::std::boxed::Box<UnitExpression<'tree>>),
10997 UnsafeBlock(::std::boxed::Box<UnsafeBlock<'tree>>),
10998 WhileExpression(::std::boxed::Box<WhileExpression<'tree>>),
10999 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
11000}
11001impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
11002 #[allow(clippy::collapsible_else_if)]
11003 fn from_node(
11004 node: ::treesitter_types::tree_sitter::Node<'tree>,
11005 src: &'tree [u8],
11006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11007 match node.kind() {
11008 "array_expression" => Ok(Self::ArrayExpression(::std::boxed::Box::new(
11009 ::treesitter_types::runtime::maybe_grow_stack(|| {
11010 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)
11011 })?,
11012 ))),
11013 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
11014 ::treesitter_types::runtime::maybe_grow_stack(|| {
11015 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
11016 })?,
11017 ))),
11018 "async_block" => Ok(Self::AsyncBlock(::std::boxed::Box::new(
11019 ::treesitter_types::runtime::maybe_grow_stack(|| {
11020 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)
11021 })?,
11022 ))),
11023 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
11024 ::treesitter_types::runtime::maybe_grow_stack(|| {
11025 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
11026 })?,
11027 ))),
11028 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
11029 ::treesitter_types::runtime::maybe_grow_stack(|| {
11030 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11031 })?,
11032 ))),
11033 "block" => Ok(Self::Block(::std::boxed::Box::new(
11034 ::treesitter_types::runtime::maybe_grow_stack(|| {
11035 <Block as ::treesitter_types::FromNode>::from_node(node, src)
11036 })?,
11037 ))),
11038 "break_expression" => Ok(Self::BreakExpression(::std::boxed::Box::new(
11039 ::treesitter_types::runtime::maybe_grow_stack(|| {
11040 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)
11041 })?,
11042 ))),
11043 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
11044 ::treesitter_types::runtime::maybe_grow_stack(|| {
11045 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
11046 })?,
11047 ))),
11048 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
11049 ::treesitter_types::runtime::maybe_grow_stack(|| {
11050 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
11051 })?,
11052 ))),
11053 "compound_assignment_expr" => Ok(Self::CompoundAssignmentExpr(::std::boxed::Box::new(
11054 ::treesitter_types::runtime::maybe_grow_stack(|| {
11055 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)
11056 })?,
11057 ))),
11058 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
11059 ::treesitter_types::runtime::maybe_grow_stack(|| {
11060 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
11061 })?,
11062 ))),
11063 "continue_expression" => Ok(Self::ContinueExpression(::std::boxed::Box::new(
11064 ::treesitter_types::runtime::maybe_grow_stack(|| {
11065 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)
11066 })?,
11067 ))),
11068 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
11069 ::treesitter_types::runtime::maybe_grow_stack(|| {
11070 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
11071 })?,
11072 ))),
11073 "for_expression" => Ok(Self::ForExpression(::std::boxed::Box::new(
11074 ::treesitter_types::runtime::maybe_grow_stack(|| {
11075 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)
11076 })?,
11077 ))),
11078 "gen_block" => Ok(Self::GenBlock(::std::boxed::Box::new(
11079 ::treesitter_types::runtime::maybe_grow_stack(|| {
11080 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)
11081 })?,
11082 ))),
11083 "generic_function" => Ok(Self::GenericFunction(::std::boxed::Box::new(
11084 ::treesitter_types::runtime::maybe_grow_stack(|| {
11085 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)
11086 })?,
11087 ))),
11088 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11089 ::treesitter_types::runtime::maybe_grow_stack(|| {
11090 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11091 })?,
11092 ))),
11093 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
11094 ::treesitter_types::runtime::maybe_grow_stack(|| {
11095 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
11096 })?,
11097 ))),
11098 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
11099 ::treesitter_types::runtime::maybe_grow_stack(|| {
11100 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
11101 })?,
11102 ))),
11103 "loop_expression" => Ok(Self::LoopExpression(::std::boxed::Box::new(
11104 ::treesitter_types::runtime::maybe_grow_stack(|| {
11105 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)
11106 })?,
11107 ))),
11108 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
11109 ::treesitter_types::runtime::maybe_grow_stack(|| {
11110 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
11111 })?,
11112 ))),
11113 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
11114 ::treesitter_types::runtime::maybe_grow_stack(|| {
11115 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
11116 })?,
11117 ))),
11118 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11119 ::treesitter_types::runtime::maybe_grow_stack(|| {
11120 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
11121 })?,
11122 ))),
11123 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
11124 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11125 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
11126 })?),
11127 )),
11128 "reference_expression" => Ok(Self::ReferenceExpression(::std::boxed::Box::new(
11129 ::treesitter_types::runtime::maybe_grow_stack(|| {
11130 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
11131 })?,
11132 ))),
11133 "return_expression" => Ok(Self::ReturnExpression(::std::boxed::Box::new(
11134 ::treesitter_types::runtime::maybe_grow_stack(|| {
11135 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)
11136 })?,
11137 ))),
11138 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11139 ::treesitter_types::runtime::maybe_grow_stack(|| {
11140 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11141 })?,
11142 ))),
11143 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11144 ::treesitter_types::runtime::maybe_grow_stack(|| {
11145 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
11146 })?,
11147 ))),
11148 "struct_expression" => Ok(Self::StructExpression(::std::boxed::Box::new(
11149 ::treesitter_types::runtime::maybe_grow_stack(|| {
11150 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)
11151 })?,
11152 ))),
11153 "try_block" => Ok(Self::TryBlock(::std::boxed::Box::new(
11154 ::treesitter_types::runtime::maybe_grow_stack(|| {
11155 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)
11156 })?,
11157 ))),
11158 "try_expression" => Ok(Self::TryExpression(::std::boxed::Box::new(
11159 ::treesitter_types::runtime::maybe_grow_stack(|| {
11160 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11161 })?,
11162 ))),
11163 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
11164 ::treesitter_types::runtime::maybe_grow_stack(|| {
11165 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
11166 })?,
11167 ))),
11168 "type_cast_expression" => Ok(Self::TypeCastExpression(::std::boxed::Box::new(
11169 ::treesitter_types::runtime::maybe_grow_stack(|| {
11170 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)
11171 })?,
11172 ))),
11173 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
11174 ::treesitter_types::runtime::maybe_grow_stack(|| {
11175 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11176 })?,
11177 ))),
11178 "unit_expression" => Ok(Self::UnitExpression(::std::boxed::Box::new(
11179 ::treesitter_types::runtime::maybe_grow_stack(|| {
11180 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)
11181 })?,
11182 ))),
11183 "unsafe_block" => Ok(Self::UnsafeBlock(::std::boxed::Box::new(
11184 ::treesitter_types::runtime::maybe_grow_stack(|| {
11185 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)
11186 })?,
11187 ))),
11188 "while_expression" => Ok(Self::WhileExpression(::std::boxed::Box::new(
11189 ::treesitter_types::runtime::maybe_grow_stack(|| {
11190 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)
11191 })?,
11192 ))),
11193 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
11194 ::treesitter_types::runtime::maybe_grow_stack(|| {
11195 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
11196 })?,
11197 ))),
11198 _other => {
11199 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11200 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
11201 }) {
11202 Ok(Self::Literal(::std::boxed::Box::new(v)))
11203 } else {
11204 Err(::treesitter_types::ParseError::unexpected_kind(
11205 _other, node,
11206 ))
11207 }
11208 }
11209 }
11210 }
11211}
11212impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
11213 fn span(&self) -> ::treesitter_types::Span {
11214 match self {
11215 Self::Literal(inner) => inner.span(),
11216 Self::ArrayExpression(inner) => inner.span(),
11217 Self::AssignmentExpression(inner) => inner.span(),
11218 Self::AsyncBlock(inner) => inner.span(),
11219 Self::AwaitExpression(inner) => inner.span(),
11220 Self::BinaryExpression(inner) => inner.span(),
11221 Self::Block(inner) => inner.span(),
11222 Self::BreakExpression(inner) => inner.span(),
11223 Self::CallExpression(inner) => inner.span(),
11224 Self::ClosureExpression(inner) => inner.span(),
11225 Self::CompoundAssignmentExpr(inner) => inner.span(),
11226 Self::ConstBlock(inner) => inner.span(),
11227 Self::ContinueExpression(inner) => inner.span(),
11228 Self::FieldExpression(inner) => inner.span(),
11229 Self::ForExpression(inner) => inner.span(),
11230 Self::GenBlock(inner) => inner.span(),
11231 Self::GenericFunction(inner) => inner.span(),
11232 Self::Identifier(inner) => inner.span(),
11233 Self::IfExpression(inner) => inner.span(),
11234 Self::IndexExpression(inner) => inner.span(),
11235 Self::LoopExpression(inner) => inner.span(),
11236 Self::MacroInvocation(inner) => inner.span(),
11237 Self::MatchExpression(inner) => inner.span(),
11238 Self::Metavariable(inner) => inner.span(),
11239 Self::ParenthesizedExpression(inner) => inner.span(),
11240 Self::ReferenceExpression(inner) => inner.span(),
11241 Self::ReturnExpression(inner) => inner.span(),
11242 Self::ScopedIdentifier(inner) => inner.span(),
11243 Self::SelfType(inner) => inner.span(),
11244 Self::StructExpression(inner) => inner.span(),
11245 Self::TryBlock(inner) => inner.span(),
11246 Self::TryExpression(inner) => inner.span(),
11247 Self::TupleExpression(inner) => inner.span(),
11248 Self::TypeCastExpression(inner) => inner.span(),
11249 Self::UnaryExpression(inner) => inner.span(),
11250 Self::UnitExpression(inner) => inner.span(),
11251 Self::UnsafeBlock(inner) => inner.span(),
11252 Self::WhileExpression(inner) => inner.span(),
11253 Self::YieldExpression(inner) => inner.span(),
11254 }
11255 }
11256}
11257#[derive(Debug, Clone, PartialEq, Eq)]
11258pub enum ClosureExpressionBody<'tree> {
11259 Blank(::treesitter_types::Span),
11260 Expression(::std::boxed::Box<Expression<'tree>>),
11261}
11262impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpressionBody<'tree> {
11263 #[allow(clippy::collapsible_else_if)]
11264 fn from_node(
11265 node: ::treesitter_types::tree_sitter::Node<'tree>,
11266 src: &'tree [u8],
11267 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11268 match node.kind() {
11269 "_" => Ok(Self::Blank(::treesitter_types::Span::from(node))),
11270 _other => {
11271 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11272 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11273 }) {
11274 Ok(Self::Expression(::std::boxed::Box::new(v)))
11275 } else {
11276 Err(::treesitter_types::ParseError::unexpected_kind(
11277 _other, node,
11278 ))
11279 }
11280 }
11281 }
11282 }
11283}
11284impl ::treesitter_types::Spanned for ClosureExpressionBody<'_> {
11285 fn span(&self) -> ::treesitter_types::Span {
11286 match self {
11287 Self::Blank(span) => *span,
11288 Self::Expression(inner) => inner.span(),
11289 }
11290 }
11291}
11292#[derive(Debug, Clone, PartialEq, Eq)]
11293pub enum ClosureParametersChildren<'tree> {
11294 Pattern(::std::boxed::Box<Pattern<'tree>>),
11295 Parameter(::std::boxed::Box<Parameter<'tree>>),
11296}
11297impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParametersChildren<'tree> {
11298 #[allow(clippy::collapsible_else_if)]
11299 fn from_node(
11300 node: ::treesitter_types::tree_sitter::Node<'tree>,
11301 src: &'tree [u8],
11302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11303 match node.kind() {
11304 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
11305 ::treesitter_types::runtime::maybe_grow_stack(|| {
11306 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
11307 })?,
11308 ))),
11309 _other => {
11310 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11311 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
11312 }) {
11313 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11314 } else {
11315 Err(::treesitter_types::ParseError::unexpected_kind(
11316 _other, node,
11317 ))
11318 }
11319 }
11320 }
11321 }
11322}
11323impl ::treesitter_types::Spanned for ClosureParametersChildren<'_> {
11324 fn span(&self) -> ::treesitter_types::Span {
11325 match self {
11326 Self::Pattern(inner) => inner.span(),
11327 Self::Parameter(inner) => inner.span(),
11328 }
11329 }
11330}
11331#[derive(Debug, Clone, PartialEq, Eq)]
11332pub enum CompoundAssignmentExprOperator {
11333 PercentEq(::treesitter_types::Span),
11334 AmpEq(::treesitter_types::Span),
11335 StarEq(::treesitter_types::Span),
11336 PlusEq(::treesitter_types::Span),
11337 MinusEq(::treesitter_types::Span),
11338 SlashEq(::treesitter_types::Span),
11339 ShlEq(::treesitter_types::Span),
11340 ShrEq(::treesitter_types::Span),
11341 CaretEq(::treesitter_types::Span),
11342 PipeEq(::treesitter_types::Span),
11343}
11344impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExprOperator {
11345 #[allow(clippy::collapsible_else_if)]
11346 fn from_node(
11347 node: ::treesitter_types::tree_sitter::Node<'tree>,
11348 _src: &'tree [u8],
11349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11350 match node.kind() {
11351 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
11352 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
11353 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
11354 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
11355 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
11356 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
11357 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
11358 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
11359 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
11360 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
11361 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11362 }
11363 }
11364}
11365impl ::treesitter_types::Spanned for CompoundAssignmentExprOperator {
11366 fn span(&self) -> ::treesitter_types::Span {
11367 match self {
11368 Self::PercentEq(span) => *span,
11369 Self::AmpEq(span) => *span,
11370 Self::StarEq(span) => *span,
11371 Self::PlusEq(span) => *span,
11372 Self::MinusEq(span) => *span,
11373 Self::SlashEq(span) => *span,
11374 Self::ShlEq(span) => *span,
11375 Self::ShrEq(span) => *span,
11376 Self::CaretEq(span) => *span,
11377 Self::PipeEq(span) => *span,
11378 }
11379 }
11380}
11381#[derive(Debug, Clone, PartialEq, Eq)]
11382pub enum ConstParameterValue<'tree> {
11383 Literal(::std::boxed::Box<Literal<'tree>>),
11384 Block(::std::boxed::Box<Block<'tree>>),
11385 Identifier(::std::boxed::Box<Identifier<'tree>>),
11386 NegativeLiteral(::std::boxed::Box<NegativeLiteral<'tree>>),
11387}
11388impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameterValue<'tree> {
11389 #[allow(clippy::collapsible_else_if)]
11390 fn from_node(
11391 node: ::treesitter_types::tree_sitter::Node<'tree>,
11392 src: &'tree [u8],
11393 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11394 match node.kind() {
11395 "block" => Ok(Self::Block(::std::boxed::Box::new(
11396 ::treesitter_types::runtime::maybe_grow_stack(|| {
11397 <Block as ::treesitter_types::FromNode>::from_node(node, src)
11398 })?,
11399 ))),
11400 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11401 ::treesitter_types::runtime::maybe_grow_stack(|| {
11402 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11403 })?,
11404 ))),
11405 "negative_literal" => Ok(Self::NegativeLiteral(::std::boxed::Box::new(
11406 ::treesitter_types::runtime::maybe_grow_stack(|| {
11407 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11408 })?,
11409 ))),
11410 _other => {
11411 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11412 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
11413 }) {
11414 Ok(Self::Literal(::std::boxed::Box::new(v)))
11415 } else {
11416 Err(::treesitter_types::ParseError::unexpected_kind(
11417 _other, node,
11418 ))
11419 }
11420 }
11421 }
11422 }
11423}
11424impl ::treesitter_types::Spanned for ConstParameterValue<'_> {
11425 fn span(&self) -> ::treesitter_types::Span {
11426 match self {
11427 Self::Literal(inner) => inner.span(),
11428 Self::Block(inner) => inner.span(),
11429 Self::Identifier(inner) => inner.span(),
11430 Self::NegativeLiteral(inner) => inner.span(),
11431 }
11432 }
11433}
11434#[derive(Debug, Clone, PartialEq, Eq)]
11435pub enum DynamicTypeTrait<'tree> {
11436 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
11437 GenericType(::std::boxed::Box<GenericType<'tree>>),
11438 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
11439 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11440 TupleType(::std::boxed::Box<TupleType<'tree>>),
11441 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11442}
11443impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicTypeTrait<'tree> {
11444 #[allow(clippy::collapsible_else_if)]
11445 fn from_node(
11446 node: ::treesitter_types::tree_sitter::Node<'tree>,
11447 src: &'tree [u8],
11448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11449 match node.kind() {
11450 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
11451 ::treesitter_types::runtime::maybe_grow_stack(|| {
11452 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
11453 })?,
11454 ))),
11455 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11456 ::treesitter_types::runtime::maybe_grow_stack(|| {
11457 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
11458 })?,
11459 ))),
11460 "higher_ranked_trait_bound" => Ok(Self::HigherRankedTraitBound(
11461 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11462 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
11463 })?),
11464 )),
11465 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11466 ::treesitter_types::runtime::maybe_grow_stack(|| {
11467 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11468 })?,
11469 ))),
11470 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
11471 ::treesitter_types::runtime::maybe_grow_stack(|| {
11472 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
11473 })?,
11474 ))),
11475 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11476 ::treesitter_types::runtime::maybe_grow_stack(|| {
11477 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11478 })?,
11479 ))),
11480 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11481 }
11482 }
11483}
11484impl ::treesitter_types::Spanned for DynamicTypeTrait<'_> {
11485 fn span(&self) -> ::treesitter_types::Span {
11486 match self {
11487 Self::FunctionType(inner) => inner.span(),
11488 Self::GenericType(inner) => inner.span(),
11489 Self::HigherRankedTraitBound(inner) => inner.span(),
11490 Self::ScopedTypeIdentifier(inner) => inner.span(),
11491 Self::TupleType(inner) => inner.span(),
11492 Self::TypeIdentifier(inner) => inner.span(),
11493 }
11494 }
11495}
11496#[derive(Debug, Clone, PartialEq, Eq)]
11497pub enum ElseClauseChildren<'tree> {
11498 Block(::std::boxed::Box<Block<'tree>>),
11499 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
11500}
11501impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClauseChildren<'tree> {
11502 #[allow(clippy::collapsible_else_if)]
11503 fn from_node(
11504 node: ::treesitter_types::tree_sitter::Node<'tree>,
11505 src: &'tree [u8],
11506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11507 match node.kind() {
11508 "block" => Ok(Self::Block(::std::boxed::Box::new(
11509 ::treesitter_types::runtime::maybe_grow_stack(|| {
11510 <Block as ::treesitter_types::FromNode>::from_node(node, src)
11511 })?,
11512 ))),
11513 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
11514 ::treesitter_types::runtime::maybe_grow_stack(|| {
11515 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
11516 })?,
11517 ))),
11518 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11519 }
11520 }
11521}
11522impl ::treesitter_types::Spanned for ElseClauseChildren<'_> {
11523 fn span(&self) -> ::treesitter_types::Span {
11524 match self {
11525 Self::Block(inner) => inner.span(),
11526 Self::IfExpression(inner) => inner.span(),
11527 }
11528 }
11529}
11530#[derive(Debug, Clone, PartialEq, Eq)]
11531pub enum EnumItemChildren<'tree> {
11532 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11533 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11534}
11535impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItemChildren<'tree> {
11536 #[allow(clippy::collapsible_else_if)]
11537 fn from_node(
11538 node: ::treesitter_types::tree_sitter::Node<'tree>,
11539 src: &'tree [u8],
11540 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11541 match node.kind() {
11542 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11543 ::treesitter_types::runtime::maybe_grow_stack(|| {
11544 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11545 })?,
11546 ))),
11547 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11548 ::treesitter_types::runtime::maybe_grow_stack(|| {
11549 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
11550 })?,
11551 ))),
11552 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11553 }
11554 }
11555}
11556impl ::treesitter_types::Spanned for EnumItemChildren<'_> {
11557 fn span(&self) -> ::treesitter_types::Span {
11558 match self {
11559 Self::VisibilityModifier(inner) => inner.span(),
11560 Self::WhereClause(inner) => inner.span(),
11561 }
11562 }
11563}
11564#[derive(Debug, Clone, PartialEq, Eq)]
11565pub enum EnumVariantBody<'tree> {
11566 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
11567 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
11568}
11569impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantBody<'tree> {
11570 #[allow(clippy::collapsible_else_if)]
11571 fn from_node(
11572 node: ::treesitter_types::tree_sitter::Node<'tree>,
11573 src: &'tree [u8],
11574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11575 match node.kind() {
11576 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
11577 ::treesitter_types::runtime::maybe_grow_stack(|| {
11578 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
11579 })?,
11580 ))),
11581 "ordered_field_declaration_list" => Ok(Self::OrderedFieldDeclarationList(
11582 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11583 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
11584 node, src,
11585 )
11586 })?),
11587 )),
11588 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11589 }
11590 }
11591}
11592impl ::treesitter_types::Spanned for EnumVariantBody<'_> {
11593 fn span(&self) -> ::treesitter_types::Span {
11594 match self {
11595 Self::FieldDeclarationList(inner) => inner.span(),
11596 Self::OrderedFieldDeclarationList(inner) => inner.span(),
11597 }
11598 }
11599}
11600#[derive(Debug, Clone, PartialEq, Eq)]
11601pub enum EnumVariantListChildren<'tree> {
11602 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11603 EnumVariant(::std::boxed::Box<EnumVariant<'tree>>),
11604}
11605impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantListChildren<'tree> {
11606 #[allow(clippy::collapsible_else_if)]
11607 fn from_node(
11608 node: ::treesitter_types::tree_sitter::Node<'tree>,
11609 src: &'tree [u8],
11610 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11611 match node.kind() {
11612 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11613 ::treesitter_types::runtime::maybe_grow_stack(|| {
11614 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
11615 })?,
11616 ))),
11617 "enum_variant" => Ok(Self::EnumVariant(::std::boxed::Box::new(
11618 ::treesitter_types::runtime::maybe_grow_stack(|| {
11619 <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)
11620 })?,
11621 ))),
11622 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11623 }
11624 }
11625}
11626impl ::treesitter_types::Spanned for EnumVariantListChildren<'_> {
11627 fn span(&self) -> ::treesitter_types::Span {
11628 match self {
11629 Self::AttributeItem(inner) => inner.span(),
11630 Self::EnumVariant(inner) => inner.span(),
11631 }
11632 }
11633}
11634#[derive(Debug, Clone, PartialEq, Eq)]
11635pub enum ExternCrateDeclarationChildren<'tree> {
11636 Crate(::std::boxed::Box<Crate<'tree>>),
11637 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11638}
11639impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclarationChildren<'tree> {
11640 #[allow(clippy::collapsible_else_if)]
11641 fn from_node(
11642 node: ::treesitter_types::tree_sitter::Node<'tree>,
11643 src: &'tree [u8],
11644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11645 match node.kind() {
11646 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11647 ::treesitter_types::runtime::maybe_grow_stack(|| {
11648 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
11649 })?,
11650 ))),
11651 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11652 ::treesitter_types::runtime::maybe_grow_stack(|| {
11653 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11654 })?,
11655 ))),
11656 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11657 }
11658 }
11659}
11660impl ::treesitter_types::Spanned for ExternCrateDeclarationChildren<'_> {
11661 fn span(&self) -> ::treesitter_types::Span {
11662 match self {
11663 Self::Crate(inner) => inner.span(),
11664 Self::VisibilityModifier(inner) => inner.span(),
11665 }
11666 }
11667}
11668#[derive(Debug, Clone, PartialEq, Eq)]
11669pub enum FieldDeclarationListChildren<'tree> {
11670 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11671 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
11672}
11673impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
11674 #[allow(clippy::collapsible_else_if)]
11675 fn from_node(
11676 node: ::treesitter_types::tree_sitter::Node<'tree>,
11677 src: &'tree [u8],
11678 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11679 match node.kind() {
11680 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11681 ::treesitter_types::runtime::maybe_grow_stack(|| {
11682 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
11683 })?,
11684 ))),
11685 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
11686 ::treesitter_types::runtime::maybe_grow_stack(|| {
11687 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11688 })?,
11689 ))),
11690 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11691 }
11692 }
11693}
11694impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
11695 fn span(&self) -> ::treesitter_types::Span {
11696 match self {
11697 Self::AttributeItem(inner) => inner.span(),
11698 Self::FieldDeclaration(inner) => inner.span(),
11699 }
11700 }
11701}
11702#[derive(Debug, Clone, PartialEq, Eq)]
11703pub enum FieldExpressionField<'tree> {
11704 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11705 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
11706}
11707impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionField<'tree> {
11708 #[allow(clippy::collapsible_else_if)]
11709 fn from_node(
11710 node: ::treesitter_types::tree_sitter::Node<'tree>,
11711 src: &'tree [u8],
11712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11713 match node.kind() {
11714 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11715 ::treesitter_types::runtime::maybe_grow_stack(|| {
11716 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11717 })?,
11718 ))),
11719 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
11720 ::treesitter_types::runtime::maybe_grow_stack(|| {
11721 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11722 })?,
11723 ))),
11724 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11725 }
11726 }
11727}
11728impl ::treesitter_types::Spanned for FieldExpressionField<'_> {
11729 fn span(&self) -> ::treesitter_types::Span {
11730 match self {
11731 Self::FieldIdentifier(inner) => inner.span(),
11732 Self::IntegerLiteral(inner) => inner.span(),
11733 }
11734 }
11735}
11736#[derive(Debug, Clone, PartialEq, Eq)]
11737pub enum FieldInitializerField<'tree> {
11738 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11739 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
11740}
11741impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerField<'tree> {
11742 #[allow(clippy::collapsible_else_if)]
11743 fn from_node(
11744 node: ::treesitter_types::tree_sitter::Node<'tree>,
11745 src: &'tree [u8],
11746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11747 match node.kind() {
11748 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11749 ::treesitter_types::runtime::maybe_grow_stack(|| {
11750 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11751 })?,
11752 ))),
11753 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
11754 ::treesitter_types::runtime::maybe_grow_stack(|| {
11755 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11756 })?,
11757 ))),
11758 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11759 }
11760 }
11761}
11762impl ::treesitter_types::Spanned for FieldInitializerField<'_> {
11763 fn span(&self) -> ::treesitter_types::Span {
11764 match self {
11765 Self::FieldIdentifier(inner) => inner.span(),
11766 Self::IntegerLiteral(inner) => inner.span(),
11767 }
11768 }
11769}
11770#[derive(Debug, Clone, PartialEq, Eq)]
11771pub enum FieldInitializerListChildren<'tree> {
11772 BaseFieldInitializer(::std::boxed::Box<BaseFieldInitializer<'tree>>),
11773 FieldInitializer(::std::boxed::Box<FieldInitializer<'tree>>),
11774 ShorthandFieldInitializer(::std::boxed::Box<ShorthandFieldInitializer<'tree>>),
11775}
11776impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerListChildren<'tree> {
11777 #[allow(clippy::collapsible_else_if)]
11778 fn from_node(
11779 node: ::treesitter_types::tree_sitter::Node<'tree>,
11780 src: &'tree [u8],
11781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11782 match node.kind() {
11783 "base_field_initializer" => Ok(Self::BaseFieldInitializer(::std::boxed::Box::new(
11784 ::treesitter_types::runtime::maybe_grow_stack(|| {
11785 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11786 })?,
11787 ))),
11788 "field_initializer" => Ok(Self::FieldInitializer(::std::boxed::Box::new(
11789 ::treesitter_types::runtime::maybe_grow_stack(|| {
11790 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
11791 })?,
11792 ))),
11793 "shorthand_field_initializer" => Ok(Self::ShorthandFieldInitializer(
11794 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11795 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(
11796 node, src,
11797 )
11798 })?),
11799 )),
11800 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11801 }
11802 }
11803}
11804impl ::treesitter_types::Spanned for FieldInitializerListChildren<'_> {
11805 fn span(&self) -> ::treesitter_types::Span {
11806 match self {
11807 Self::BaseFieldInitializer(inner) => inner.span(),
11808 Self::FieldInitializer(inner) => inner.span(),
11809 Self::ShorthandFieldInitializer(inner) => inner.span(),
11810 }
11811 }
11812}
11813#[derive(Debug, Clone, PartialEq, Eq)]
11814pub enum FieldPatternName<'tree> {
11815 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11816 ShorthandFieldIdentifier(::std::boxed::Box<ShorthandFieldIdentifier<'tree>>),
11817}
11818impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternName<'tree> {
11819 #[allow(clippy::collapsible_else_if)]
11820 fn from_node(
11821 node: ::treesitter_types::tree_sitter::Node<'tree>,
11822 src: &'tree [u8],
11823 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11824 match node.kind() {
11825 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11826 ::treesitter_types::runtime::maybe_grow_stack(|| {
11827 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11828 })?,
11829 ))),
11830 "shorthand_field_identifier" => Ok(Self::ShorthandFieldIdentifier(
11831 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11832 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
11833 })?),
11834 )),
11835 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11836 }
11837 }
11838}
11839impl ::treesitter_types::Spanned for FieldPatternName<'_> {
11840 fn span(&self) -> ::treesitter_types::Span {
11841 match self {
11842 Self::FieldIdentifier(inner) => inner.span(),
11843 Self::ShorthandFieldIdentifier(inner) => inner.span(),
11844 }
11845 }
11846}
11847#[derive(Debug, Clone, PartialEq, Eq)]
11848pub enum FunctionItemName<'tree> {
11849 Identifier(::std::boxed::Box<Identifier<'tree>>),
11850 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11851}
11852impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemName<'tree> {
11853 #[allow(clippy::collapsible_else_if)]
11854 fn from_node(
11855 node: ::treesitter_types::tree_sitter::Node<'tree>,
11856 src: &'tree [u8],
11857 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11858 match node.kind() {
11859 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11860 ::treesitter_types::runtime::maybe_grow_stack(|| {
11861 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11862 })?,
11863 ))),
11864 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11865 ::treesitter_types::runtime::maybe_grow_stack(|| {
11866 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
11867 })?,
11868 ))),
11869 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11870 }
11871 }
11872}
11873impl ::treesitter_types::Spanned for FunctionItemName<'_> {
11874 fn span(&self) -> ::treesitter_types::Span {
11875 match self {
11876 Self::Identifier(inner) => inner.span(),
11877 Self::Metavariable(inner) => inner.span(),
11878 }
11879 }
11880}
11881#[derive(Debug, Clone, PartialEq, Eq)]
11882pub enum FunctionItemChildren<'tree> {
11883 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
11884 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11885 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11886}
11887impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemChildren<'tree> {
11888 #[allow(clippy::collapsible_else_if)]
11889 fn from_node(
11890 node: ::treesitter_types::tree_sitter::Node<'tree>,
11891 src: &'tree [u8],
11892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11893 match node.kind() {
11894 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
11895 ::treesitter_types::runtime::maybe_grow_stack(|| {
11896 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
11897 })?,
11898 ))),
11899 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11900 ::treesitter_types::runtime::maybe_grow_stack(|| {
11901 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11902 })?,
11903 ))),
11904 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11905 ::treesitter_types::runtime::maybe_grow_stack(|| {
11906 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
11907 })?,
11908 ))),
11909 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11910 }
11911 }
11912}
11913impl ::treesitter_types::Spanned for FunctionItemChildren<'_> {
11914 fn span(&self) -> ::treesitter_types::Span {
11915 match self {
11916 Self::FunctionModifiers(inner) => inner.span(),
11917 Self::VisibilityModifier(inner) => inner.span(),
11918 Self::WhereClause(inner) => inner.span(),
11919 }
11920 }
11921}
11922#[derive(Debug, Clone, PartialEq, Eq)]
11923pub enum FunctionSignatureItemName<'tree> {
11924 Identifier(::std::boxed::Box<Identifier<'tree>>),
11925 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11926}
11927impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemName<'tree> {
11928 #[allow(clippy::collapsible_else_if)]
11929 fn from_node(
11930 node: ::treesitter_types::tree_sitter::Node<'tree>,
11931 src: &'tree [u8],
11932 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11933 match node.kind() {
11934 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11935 ::treesitter_types::runtime::maybe_grow_stack(|| {
11936 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
11937 })?,
11938 ))),
11939 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11940 ::treesitter_types::runtime::maybe_grow_stack(|| {
11941 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
11942 })?,
11943 ))),
11944 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11945 }
11946 }
11947}
11948impl ::treesitter_types::Spanned for FunctionSignatureItemName<'_> {
11949 fn span(&self) -> ::treesitter_types::Span {
11950 match self {
11951 Self::Identifier(inner) => inner.span(),
11952 Self::Metavariable(inner) => inner.span(),
11953 }
11954 }
11955}
11956#[derive(Debug, Clone, PartialEq, Eq)]
11957pub enum FunctionSignatureItemChildren<'tree> {
11958 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
11959 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11960 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11961}
11962impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemChildren<'tree> {
11963 #[allow(clippy::collapsible_else_if)]
11964 fn from_node(
11965 node: ::treesitter_types::tree_sitter::Node<'tree>,
11966 src: &'tree [u8],
11967 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11968 match node.kind() {
11969 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
11970 ::treesitter_types::runtime::maybe_grow_stack(|| {
11971 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
11972 })?,
11973 ))),
11974 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11975 ::treesitter_types::runtime::maybe_grow_stack(|| {
11976 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11977 })?,
11978 ))),
11979 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11980 ::treesitter_types::runtime::maybe_grow_stack(|| {
11981 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
11982 })?,
11983 ))),
11984 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11985 }
11986 }
11987}
11988impl ::treesitter_types::Spanned for FunctionSignatureItemChildren<'_> {
11989 fn span(&self) -> ::treesitter_types::Span {
11990 match self {
11991 Self::FunctionModifiers(inner) => inner.span(),
11992 Self::VisibilityModifier(inner) => inner.span(),
11993 Self::WhereClause(inner) => inner.span(),
11994 }
11995 }
11996}
11997#[derive(Debug, Clone, PartialEq, Eq)]
11998pub enum FunctionTypeTrait<'tree> {
11999 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12000 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12001}
12002impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeTrait<'tree> {
12003 #[allow(clippy::collapsible_else_if)]
12004 fn from_node(
12005 node: ::treesitter_types::tree_sitter::Node<'tree>,
12006 src: &'tree [u8],
12007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12008 match node.kind() {
12009 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12010 ::treesitter_types::runtime::maybe_grow_stack(|| {
12011 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12012 })?,
12013 ))),
12014 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12015 ::treesitter_types::runtime::maybe_grow_stack(|| {
12016 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12017 })?,
12018 ))),
12019 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12020 }
12021 }
12022}
12023impl ::treesitter_types::Spanned for FunctionTypeTrait<'_> {
12024 fn span(&self) -> ::treesitter_types::Span {
12025 match self {
12026 Self::ScopedTypeIdentifier(inner) => inner.span(),
12027 Self::TypeIdentifier(inner) => inner.span(),
12028 }
12029 }
12030}
12031#[derive(Debug, Clone, PartialEq, Eq)]
12032pub enum FunctionTypeChildren<'tree> {
12033 ForLifetimes(::std::boxed::Box<ForLifetimes<'tree>>),
12034 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
12035}
12036impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeChildren<'tree> {
12037 #[allow(clippy::collapsible_else_if)]
12038 fn from_node(
12039 node: ::treesitter_types::tree_sitter::Node<'tree>,
12040 src: &'tree [u8],
12041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12042 match node.kind() {
12043 "for_lifetimes" => Ok(Self::ForLifetimes(::std::boxed::Box::new(
12044 ::treesitter_types::runtime::maybe_grow_stack(|| {
12045 <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)
12046 })?,
12047 ))),
12048 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
12049 ::treesitter_types::runtime::maybe_grow_stack(|| {
12050 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
12051 })?,
12052 ))),
12053 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12054 }
12055 }
12056}
12057impl ::treesitter_types::Spanned for FunctionTypeChildren<'_> {
12058 fn span(&self) -> ::treesitter_types::Span {
12059 match self {
12060 Self::ForLifetimes(inner) => inner.span(),
12061 Self::FunctionModifiers(inner) => inner.span(),
12062 }
12063 }
12064}
12065#[derive(Debug, Clone, PartialEq, Eq)]
12066pub enum GenericFunctionFunction<'tree> {
12067 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
12068 Identifier(::std::boxed::Box<Identifier<'tree>>),
12069 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12070}
12071impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunctionFunction<'tree> {
12072 #[allow(clippy::collapsible_else_if)]
12073 fn from_node(
12074 node: ::treesitter_types::tree_sitter::Node<'tree>,
12075 src: &'tree [u8],
12076 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12077 match node.kind() {
12078 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
12079 ::treesitter_types::runtime::maybe_grow_stack(|| {
12080 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
12081 })?,
12082 ))),
12083 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12084 ::treesitter_types::runtime::maybe_grow_stack(|| {
12085 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12086 })?,
12087 ))),
12088 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12089 ::treesitter_types::runtime::maybe_grow_stack(|| {
12090 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12091 })?,
12092 ))),
12093 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12094 }
12095 }
12096}
12097impl ::treesitter_types::Spanned for GenericFunctionFunction<'_> {
12098 fn span(&self) -> ::treesitter_types::Span {
12099 match self {
12100 Self::FieldExpression(inner) => inner.span(),
12101 Self::Identifier(inner) => inner.span(),
12102 Self::ScopedIdentifier(inner) => inner.span(),
12103 }
12104 }
12105}
12106#[derive(Debug, Clone, PartialEq, Eq)]
12107pub enum GenericPatternChildren<'tree> {
12108 Identifier(::std::boxed::Box<Identifier<'tree>>),
12109 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12110}
12111impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPatternChildren<'tree> {
12112 #[allow(clippy::collapsible_else_if)]
12113 fn from_node(
12114 node: ::treesitter_types::tree_sitter::Node<'tree>,
12115 src: &'tree [u8],
12116 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12117 match node.kind() {
12118 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12119 ::treesitter_types::runtime::maybe_grow_stack(|| {
12120 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12121 })?,
12122 ))),
12123 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12124 ::treesitter_types::runtime::maybe_grow_stack(|| {
12125 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12126 })?,
12127 ))),
12128 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12129 }
12130 }
12131}
12132impl ::treesitter_types::Spanned for GenericPatternChildren<'_> {
12133 fn span(&self) -> ::treesitter_types::Span {
12134 match self {
12135 Self::Identifier(inner) => inner.span(),
12136 Self::ScopedIdentifier(inner) => inner.span(),
12137 }
12138 }
12139}
12140#[derive(Debug, Clone, PartialEq, Eq)]
12141pub enum GenericTypeType<'tree> {
12142 Identifier(::std::boxed::Box<Identifier<'tree>>),
12143 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12144 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12145 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12146}
12147impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeType<'tree> {
12148 #[allow(clippy::collapsible_else_if)]
12149 fn from_node(
12150 node: ::treesitter_types::tree_sitter::Node<'tree>,
12151 src: &'tree [u8],
12152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12153 match node.kind() {
12154 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12155 ::treesitter_types::runtime::maybe_grow_stack(|| {
12156 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12157 })?,
12158 ))),
12159 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12160 ::treesitter_types::runtime::maybe_grow_stack(|| {
12161 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12162 })?,
12163 ))),
12164 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12165 ::treesitter_types::runtime::maybe_grow_stack(|| {
12166 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12167 })?,
12168 ))),
12169 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12170 ::treesitter_types::runtime::maybe_grow_stack(|| {
12171 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12172 })?,
12173 ))),
12174 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12175 }
12176 }
12177}
12178impl ::treesitter_types::Spanned for GenericTypeType<'_> {
12179 fn span(&self) -> ::treesitter_types::Span {
12180 match self {
12181 Self::Identifier(inner) => inner.span(),
12182 Self::ScopedIdentifier(inner) => inner.span(),
12183 Self::ScopedTypeIdentifier(inner) => inner.span(),
12184 Self::TypeIdentifier(inner) => inner.span(),
12185 }
12186 }
12187}
12188#[derive(Debug, Clone, PartialEq, Eq)]
12189pub enum GenericTypeWithTurbofishType<'tree> {
12190 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12191 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12192}
12193impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofishType<'tree> {
12194 #[allow(clippy::collapsible_else_if)]
12195 fn from_node(
12196 node: ::treesitter_types::tree_sitter::Node<'tree>,
12197 src: &'tree [u8],
12198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12199 match node.kind() {
12200 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12201 ::treesitter_types::runtime::maybe_grow_stack(|| {
12202 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12203 })?,
12204 ))),
12205 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12206 ::treesitter_types::runtime::maybe_grow_stack(|| {
12207 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12208 })?,
12209 ))),
12210 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12211 }
12212 }
12213}
12214impl ::treesitter_types::Spanned for GenericTypeWithTurbofishType<'_> {
12215 fn span(&self) -> ::treesitter_types::Span {
12216 match self {
12217 Self::ScopedIdentifier(inner) => inner.span(),
12218 Self::TypeIdentifier(inner) => inner.span(),
12219 }
12220 }
12221}
12222#[derive(Debug, Clone, PartialEq, Eq)]
12223pub enum IfExpressionCondition<'tree> {
12224 Expression(::std::boxed::Box<Expression<'tree>>),
12225 LetChain(::std::boxed::Box<LetChain<'tree>>),
12226 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
12227}
12228impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpressionCondition<'tree> {
12229 #[allow(clippy::collapsible_else_if)]
12230 fn from_node(
12231 node: ::treesitter_types::tree_sitter::Node<'tree>,
12232 src: &'tree [u8],
12233 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12234 match node.kind() {
12235 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
12236 ::treesitter_types::runtime::maybe_grow_stack(|| {
12237 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
12238 })?,
12239 ))),
12240 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
12241 ::treesitter_types::runtime::maybe_grow_stack(|| {
12242 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
12243 })?,
12244 ))),
12245 _other => {
12246 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12247 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12248 }) {
12249 Ok(Self::Expression(::std::boxed::Box::new(v)))
12250 } else {
12251 Err(::treesitter_types::ParseError::unexpected_kind(
12252 _other, node,
12253 ))
12254 }
12255 }
12256 }
12257 }
12258}
12259impl ::treesitter_types::Spanned for IfExpressionCondition<'_> {
12260 fn span(&self) -> ::treesitter_types::Span {
12261 match self {
12262 Self::Expression(inner) => inner.span(),
12263 Self::LetChain(inner) => inner.span(),
12264 Self::LetCondition(inner) => inner.span(),
12265 }
12266 }
12267}
12268#[derive(Debug, Clone, PartialEq, Eq)]
12269pub enum ImplItemTrait<'tree> {
12270 GenericType(::std::boxed::Box<GenericType<'tree>>),
12271 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12272 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12273}
12274impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItemTrait<'tree> {
12275 #[allow(clippy::collapsible_else_if)]
12276 fn from_node(
12277 node: ::treesitter_types::tree_sitter::Node<'tree>,
12278 src: &'tree [u8],
12279 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12280 match node.kind() {
12281 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
12282 ::treesitter_types::runtime::maybe_grow_stack(|| {
12283 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
12284 })?,
12285 ))),
12286 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12287 ::treesitter_types::runtime::maybe_grow_stack(|| {
12288 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12289 })?,
12290 ))),
12291 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12292 ::treesitter_types::runtime::maybe_grow_stack(|| {
12293 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12294 })?,
12295 ))),
12296 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12297 }
12298 }
12299}
12300impl ::treesitter_types::Spanned for ImplItemTrait<'_> {
12301 fn span(&self) -> ::treesitter_types::Span {
12302 match self {
12303 Self::GenericType(inner) => inner.span(),
12304 Self::ScopedTypeIdentifier(inner) => inner.span(),
12305 Self::TypeIdentifier(inner) => inner.span(),
12306 }
12307 }
12308}
12309#[derive(Debug, Clone, PartialEq, Eq)]
12310pub enum LetChainChildren<'tree> {
12311 Expression(::std::boxed::Box<Expression<'tree>>),
12312 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
12313}
12314impl<'tree> ::treesitter_types::FromNode<'tree> for LetChainChildren<'tree> {
12315 #[allow(clippy::collapsible_else_if)]
12316 fn from_node(
12317 node: ::treesitter_types::tree_sitter::Node<'tree>,
12318 src: &'tree [u8],
12319 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12320 match node.kind() {
12321 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
12322 ::treesitter_types::runtime::maybe_grow_stack(|| {
12323 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
12324 })?,
12325 ))),
12326 _other => {
12327 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12328 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12329 }) {
12330 Ok(Self::Expression(::std::boxed::Box::new(v)))
12331 } else {
12332 Err(::treesitter_types::ParseError::unexpected_kind(
12333 _other, node,
12334 ))
12335 }
12336 }
12337 }
12338 }
12339}
12340impl ::treesitter_types::Spanned for LetChainChildren<'_> {
12341 fn span(&self) -> ::treesitter_types::Span {
12342 match self {
12343 Self::Expression(inner) => inner.span(),
12344 Self::LetCondition(inner) => inner.span(),
12345 }
12346 }
12347}
12348#[derive(Debug, Clone, PartialEq, Eq)]
12349pub enum MacroInvocationMacro<'tree> {
12350 Identifier(::std::boxed::Box<Identifier<'tree>>),
12351 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12352}
12353impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocationMacro<'tree> {
12354 #[allow(clippy::collapsible_else_if)]
12355 fn from_node(
12356 node: ::treesitter_types::tree_sitter::Node<'tree>,
12357 src: &'tree [u8],
12358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12359 match node.kind() {
12360 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12361 ::treesitter_types::runtime::maybe_grow_stack(|| {
12362 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12363 })?,
12364 ))),
12365 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12366 ::treesitter_types::runtime::maybe_grow_stack(|| {
12367 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12368 })?,
12369 ))),
12370 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12371 }
12372 }
12373}
12374impl ::treesitter_types::Spanned for MacroInvocationMacro<'_> {
12375 fn span(&self) -> ::treesitter_types::Span {
12376 match self {
12377 Self::Identifier(inner) => inner.span(),
12378 Self::ScopedIdentifier(inner) => inner.span(),
12379 }
12380 }
12381}
12382#[derive(Debug, Clone, PartialEq, Eq)]
12383pub enum MatchArmChildren<'tree> {
12384 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
12385 InnerAttributeItem(::std::boxed::Box<InnerAttributeItem<'tree>>),
12386}
12387impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArmChildren<'tree> {
12388 #[allow(clippy::collapsible_else_if)]
12389 fn from_node(
12390 node: ::treesitter_types::tree_sitter::Node<'tree>,
12391 src: &'tree [u8],
12392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12393 match node.kind() {
12394 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
12395 ::treesitter_types::runtime::maybe_grow_stack(|| {
12396 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12397 })?,
12398 ))),
12399 "inner_attribute_item" => Ok(Self::InnerAttributeItem(::std::boxed::Box::new(
12400 ::treesitter_types::runtime::maybe_grow_stack(|| {
12401 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12402 })?,
12403 ))),
12404 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12405 }
12406 }
12407}
12408impl ::treesitter_types::Spanned for MatchArmChildren<'_> {
12409 fn span(&self) -> ::treesitter_types::Span {
12410 match self {
12411 Self::AttributeItem(inner) => inner.span(),
12412 Self::InnerAttributeItem(inner) => inner.span(),
12413 }
12414 }
12415}
12416#[derive(Debug, Clone, PartialEq, Eq)]
12417pub enum MatchPatternCondition<'tree> {
12418 Expression(::std::boxed::Box<Expression<'tree>>),
12419 LetChain(::std::boxed::Box<LetChain<'tree>>),
12420 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
12421}
12422impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPatternCondition<'tree> {
12423 #[allow(clippy::collapsible_else_if)]
12424 fn from_node(
12425 node: ::treesitter_types::tree_sitter::Node<'tree>,
12426 src: &'tree [u8],
12427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12428 match node.kind() {
12429 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
12430 ::treesitter_types::runtime::maybe_grow_stack(|| {
12431 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
12432 })?,
12433 ))),
12434 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
12435 ::treesitter_types::runtime::maybe_grow_stack(|| {
12436 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
12437 })?,
12438 ))),
12439 _other => {
12440 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12441 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12442 }) {
12443 Ok(Self::Expression(::std::boxed::Box::new(v)))
12444 } else {
12445 Err(::treesitter_types::ParseError::unexpected_kind(
12446 _other, node,
12447 ))
12448 }
12449 }
12450 }
12451 }
12452}
12453impl ::treesitter_types::Spanned for MatchPatternCondition<'_> {
12454 fn span(&self) -> ::treesitter_types::Span {
12455 match self {
12456 Self::Expression(inner) => inner.span(),
12457 Self::LetChain(inner) => inner.span(),
12458 Self::LetCondition(inner) => inner.span(),
12459 }
12460 }
12461}
12462#[derive(Debug, Clone, PartialEq, Eq)]
12463pub enum MutPatternChildren<'tree> {
12464 Pattern(::std::boxed::Box<Pattern<'tree>>),
12465 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12466}
12467impl<'tree> ::treesitter_types::FromNode<'tree> for MutPatternChildren<'tree> {
12468 #[allow(clippy::collapsible_else_if)]
12469 fn from_node(
12470 node: ::treesitter_types::tree_sitter::Node<'tree>,
12471 src: &'tree [u8],
12472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12473 match node.kind() {
12474 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12475 ::treesitter_types::runtime::maybe_grow_stack(|| {
12476 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12477 })?,
12478 ))),
12479 _other => {
12480 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12481 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12482 }) {
12483 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12484 } else {
12485 Err(::treesitter_types::ParseError::unexpected_kind(
12486 _other, node,
12487 ))
12488 }
12489 }
12490 }
12491 }
12492}
12493impl ::treesitter_types::Spanned for MutPatternChildren<'_> {
12494 fn span(&self) -> ::treesitter_types::Span {
12495 match self {
12496 Self::Pattern(inner) => inner.span(),
12497 Self::MutableSpecifier(inner) => inner.span(),
12498 }
12499 }
12500}
12501#[derive(Debug, Clone, PartialEq, Eq)]
12502pub enum NegativeLiteralChildren<'tree> {
12503 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
12504 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
12505}
12506impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteralChildren<'tree> {
12507 #[allow(clippy::collapsible_else_if)]
12508 fn from_node(
12509 node: ::treesitter_types::tree_sitter::Node<'tree>,
12510 src: &'tree [u8],
12511 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12512 match node.kind() {
12513 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
12514 ::treesitter_types::runtime::maybe_grow_stack(|| {
12515 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12516 })?,
12517 ))),
12518 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
12519 ::treesitter_types::runtime::maybe_grow_stack(|| {
12520 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12521 })?,
12522 ))),
12523 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12524 }
12525 }
12526}
12527impl ::treesitter_types::Spanned for NegativeLiteralChildren<'_> {
12528 fn span(&self) -> ::treesitter_types::Span {
12529 match self {
12530 Self::FloatLiteral(inner) => inner.span(),
12531 Self::IntegerLiteral(inner) => inner.span(),
12532 }
12533 }
12534}
12535#[derive(Debug, Clone, PartialEq, Eq)]
12536pub enum OrderedFieldDeclarationListChildren<'tree> {
12537 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
12538 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
12539}
12540impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationListChildren<'tree> {
12541 #[allow(clippy::collapsible_else_if)]
12542 fn from_node(
12543 node: ::treesitter_types::tree_sitter::Node<'tree>,
12544 src: &'tree [u8],
12545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12546 match node.kind() {
12547 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
12548 ::treesitter_types::runtime::maybe_grow_stack(|| {
12549 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12550 })?,
12551 ))),
12552 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12553 ::treesitter_types::runtime::maybe_grow_stack(|| {
12554 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
12555 })?,
12556 ))),
12557 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12558 }
12559 }
12560}
12561impl ::treesitter_types::Spanned for OrderedFieldDeclarationListChildren<'_> {
12562 fn span(&self) -> ::treesitter_types::Span {
12563 match self {
12564 Self::AttributeItem(inner) => inner.span(),
12565 Self::VisibilityModifier(inner) => inner.span(),
12566 }
12567 }
12568}
12569#[derive(Debug, Clone, PartialEq, Eq)]
12570pub enum ParameterPattern<'tree> {
12571 Pattern(::std::boxed::Box<Pattern<'tree>>),
12572 SelfType(::std::boxed::Box<SelfType<'tree>>),
12573}
12574impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPattern<'tree> {
12575 #[allow(clippy::collapsible_else_if)]
12576 fn from_node(
12577 node: ::treesitter_types::tree_sitter::Node<'tree>,
12578 src: &'tree [u8],
12579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12580 match node.kind() {
12581 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12582 ::treesitter_types::runtime::maybe_grow_stack(|| {
12583 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
12584 })?,
12585 ))),
12586 _other => {
12587 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12588 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12589 }) {
12590 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12591 } else {
12592 Err(::treesitter_types::ParseError::unexpected_kind(
12593 _other, node,
12594 ))
12595 }
12596 }
12597 }
12598 }
12599}
12600impl ::treesitter_types::Spanned for ParameterPattern<'_> {
12601 fn span(&self) -> ::treesitter_types::Span {
12602 match self {
12603 Self::Pattern(inner) => inner.span(),
12604 Self::SelfType(inner) => inner.span(),
12605 }
12606 }
12607}
12608#[derive(Debug, Clone, PartialEq, Eq)]
12609pub enum ParametersChildren<'tree> {
12610 Type(::std::boxed::Box<Type<'tree>>),
12611 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
12612 Parameter(::std::boxed::Box<Parameter<'tree>>),
12613 SelfParameter(::std::boxed::Box<SelfParameter<'tree>>),
12614 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
12615}
12616impl<'tree> ::treesitter_types::FromNode<'tree> for ParametersChildren<'tree> {
12617 #[allow(clippy::collapsible_else_if)]
12618 fn from_node(
12619 node: ::treesitter_types::tree_sitter::Node<'tree>,
12620 src: &'tree [u8],
12621 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12622 match node.kind() {
12623 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
12624 ::treesitter_types::runtime::maybe_grow_stack(|| {
12625 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12626 })?,
12627 ))),
12628 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
12629 ::treesitter_types::runtime::maybe_grow_stack(|| {
12630 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
12631 })?,
12632 ))),
12633 "self_parameter" => Ok(Self::SelfParameter(::std::boxed::Box::new(
12634 ::treesitter_types::runtime::maybe_grow_stack(|| {
12635 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)
12636 })?,
12637 ))),
12638 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
12639 ::treesitter_types::runtime::maybe_grow_stack(|| {
12640 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
12641 })?,
12642 ))),
12643 _other => {
12644 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12645 <Type as ::treesitter_types::FromNode>::from_node(node, src)
12646 }) {
12647 Ok(Self::Type(::std::boxed::Box::new(v)))
12648 } else {
12649 Err(::treesitter_types::ParseError::unexpected_kind(
12650 _other, node,
12651 ))
12652 }
12653 }
12654 }
12655 }
12656}
12657impl ::treesitter_types::Spanned for ParametersChildren<'_> {
12658 fn span(&self) -> ::treesitter_types::Span {
12659 match self {
12660 Self::Type(inner) => inner.span(),
12661 Self::AttributeItem(inner) => inner.span(),
12662 Self::Parameter(inner) => inner.span(),
12663 Self::SelfParameter(inner) => inner.span(),
12664 Self::VariadicParameter(inner) => inner.span(),
12665 }
12666 }
12667}
12668#[derive(Debug, Clone, PartialEq, Eq)]
12669pub enum RangePatternLeft<'tree> {
12670 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
12671 Crate(::std::boxed::Box<Crate<'tree>>),
12672 Identifier(::std::boxed::Box<Identifier<'tree>>),
12673 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12674 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12675 SelfType(::std::boxed::Box<SelfType<'tree>>),
12676 Super(::std::boxed::Box<Super<'tree>>),
12677}
12678impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternLeft<'tree> {
12679 #[allow(clippy::collapsible_else_if)]
12680 fn from_node(
12681 node: ::treesitter_types::tree_sitter::Node<'tree>,
12682 src: &'tree [u8],
12683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12684 match node.kind() {
12685 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12686 ::treesitter_types::runtime::maybe_grow_stack(|| {
12687 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
12688 })?,
12689 ))),
12690 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12691 ::treesitter_types::runtime::maybe_grow_stack(|| {
12692 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12693 })?,
12694 ))),
12695 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12696 ::treesitter_types::runtime::maybe_grow_stack(|| {
12697 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
12698 })?,
12699 ))),
12700 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12701 ::treesitter_types::runtime::maybe_grow_stack(|| {
12702 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12703 })?,
12704 ))),
12705 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12706 ::treesitter_types::runtime::maybe_grow_stack(|| {
12707 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
12708 })?,
12709 ))),
12710 "super" => Ok(Self::Super(::std::boxed::Box::new(
12711 ::treesitter_types::runtime::maybe_grow_stack(|| {
12712 <Super as ::treesitter_types::FromNode>::from_node(node, src)
12713 })?,
12714 ))),
12715 _other => {
12716 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12717 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
12718 }) {
12719 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
12720 } else {
12721 Err(::treesitter_types::ParseError::unexpected_kind(
12722 _other, node,
12723 ))
12724 }
12725 }
12726 }
12727 }
12728}
12729impl ::treesitter_types::Spanned for RangePatternLeft<'_> {
12730 fn span(&self) -> ::treesitter_types::Span {
12731 match self {
12732 Self::LiteralPattern(inner) => inner.span(),
12733 Self::Crate(inner) => inner.span(),
12734 Self::Identifier(inner) => inner.span(),
12735 Self::Metavariable(inner) => inner.span(),
12736 Self::ScopedIdentifier(inner) => inner.span(),
12737 Self::SelfType(inner) => inner.span(),
12738 Self::Super(inner) => inner.span(),
12739 }
12740 }
12741}
12742#[derive(Debug, Clone, PartialEq, Eq)]
12743pub enum RangePatternRight<'tree> {
12744 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
12745 Crate(::std::boxed::Box<Crate<'tree>>),
12746 Identifier(::std::boxed::Box<Identifier<'tree>>),
12747 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12748 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12749 SelfType(::std::boxed::Box<SelfType<'tree>>),
12750 Super(::std::boxed::Box<Super<'tree>>),
12751}
12752impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternRight<'tree> {
12753 #[allow(clippy::collapsible_else_if)]
12754 fn from_node(
12755 node: ::treesitter_types::tree_sitter::Node<'tree>,
12756 src: &'tree [u8],
12757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12758 match node.kind() {
12759 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12760 ::treesitter_types::runtime::maybe_grow_stack(|| {
12761 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
12762 })?,
12763 ))),
12764 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12765 ::treesitter_types::runtime::maybe_grow_stack(|| {
12766 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12767 })?,
12768 ))),
12769 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12770 ::treesitter_types::runtime::maybe_grow_stack(|| {
12771 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
12772 })?,
12773 ))),
12774 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12775 ::treesitter_types::runtime::maybe_grow_stack(|| {
12776 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12777 })?,
12778 ))),
12779 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12780 ::treesitter_types::runtime::maybe_grow_stack(|| {
12781 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
12782 })?,
12783 ))),
12784 "super" => Ok(Self::Super(::std::boxed::Box::new(
12785 ::treesitter_types::runtime::maybe_grow_stack(|| {
12786 <Super as ::treesitter_types::FromNode>::from_node(node, src)
12787 })?,
12788 ))),
12789 _other => {
12790 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12791 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
12792 }) {
12793 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
12794 } else {
12795 Err(::treesitter_types::ParseError::unexpected_kind(
12796 _other, node,
12797 ))
12798 }
12799 }
12800 }
12801 }
12802}
12803impl ::treesitter_types::Spanned for RangePatternRight<'_> {
12804 fn span(&self) -> ::treesitter_types::Span {
12805 match self {
12806 Self::LiteralPattern(inner) => inner.span(),
12807 Self::Crate(inner) => inner.span(),
12808 Self::Identifier(inner) => inner.span(),
12809 Self::Metavariable(inner) => inner.span(),
12810 Self::ScopedIdentifier(inner) => inner.span(),
12811 Self::SelfType(inner) => inner.span(),
12812 Self::Super(inner) => inner.span(),
12813 }
12814 }
12815}
12816#[derive(Debug, Clone, PartialEq, Eq)]
12817pub enum ReferencePatternChildren<'tree> {
12818 Pattern(::std::boxed::Box<Pattern<'tree>>),
12819 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12820}
12821impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePatternChildren<'tree> {
12822 #[allow(clippy::collapsible_else_if)]
12823 fn from_node(
12824 node: ::treesitter_types::tree_sitter::Node<'tree>,
12825 src: &'tree [u8],
12826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12827 match node.kind() {
12828 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12829 ::treesitter_types::runtime::maybe_grow_stack(|| {
12830 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12831 })?,
12832 ))),
12833 _other => {
12834 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12835 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12836 }) {
12837 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12838 } else {
12839 Err(::treesitter_types::ParseError::unexpected_kind(
12840 _other, node,
12841 ))
12842 }
12843 }
12844 }
12845 }
12846}
12847impl ::treesitter_types::Spanned for ReferencePatternChildren<'_> {
12848 fn span(&self) -> ::treesitter_types::Span {
12849 match self {
12850 Self::Pattern(inner) => inner.span(),
12851 Self::MutableSpecifier(inner) => inner.span(),
12852 }
12853 }
12854}
12855#[derive(Debug, Clone, PartialEq, Eq)]
12856pub enum ReferenceTypeChildren<'tree> {
12857 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12858 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12859}
12860impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceTypeChildren<'tree> {
12861 #[allow(clippy::collapsible_else_if)]
12862 fn from_node(
12863 node: ::treesitter_types::tree_sitter::Node<'tree>,
12864 src: &'tree [u8],
12865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12866 match node.kind() {
12867 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12868 ::treesitter_types::runtime::maybe_grow_stack(|| {
12869 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
12870 })?,
12871 ))),
12872 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12873 ::treesitter_types::runtime::maybe_grow_stack(|| {
12874 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12875 })?,
12876 ))),
12877 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12878 }
12879 }
12880}
12881impl ::treesitter_types::Spanned for ReferenceTypeChildren<'_> {
12882 fn span(&self) -> ::treesitter_types::Span {
12883 match self {
12884 Self::Lifetime(inner) => inner.span(),
12885 Self::MutableSpecifier(inner) => inner.span(),
12886 }
12887 }
12888}
12889#[derive(Debug, Clone, PartialEq, Eq)]
12890pub enum ScopedIdentifierName<'tree> {
12891 Identifier(::std::boxed::Box<Identifier<'tree>>),
12892 Super(::std::boxed::Box<Super<'tree>>),
12893}
12894impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierName<'tree> {
12895 #[allow(clippy::collapsible_else_if)]
12896 fn from_node(
12897 node: ::treesitter_types::tree_sitter::Node<'tree>,
12898 src: &'tree [u8],
12899 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12900 match node.kind() {
12901 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12902 ::treesitter_types::runtime::maybe_grow_stack(|| {
12903 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12904 })?,
12905 ))),
12906 "super" => Ok(Self::Super(::std::boxed::Box::new(
12907 ::treesitter_types::runtime::maybe_grow_stack(|| {
12908 <Super as ::treesitter_types::FromNode>::from_node(node, src)
12909 })?,
12910 ))),
12911 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12912 }
12913 }
12914}
12915impl ::treesitter_types::Spanned for ScopedIdentifierName<'_> {
12916 fn span(&self) -> ::treesitter_types::Span {
12917 match self {
12918 Self::Identifier(inner) => inner.span(),
12919 Self::Super(inner) => inner.span(),
12920 }
12921 }
12922}
12923#[derive(Debug, Clone, PartialEq, Eq)]
12924pub enum ScopedIdentifierPath<'tree> {
12925 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
12926 Crate(::std::boxed::Box<Crate<'tree>>),
12927 GenericType(::std::boxed::Box<GenericType<'tree>>),
12928 Identifier(::std::boxed::Box<Identifier<'tree>>),
12929 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12930 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12931 SelfType(::std::boxed::Box<SelfType<'tree>>),
12932 Super(::std::boxed::Box<Super<'tree>>),
12933}
12934impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierPath<'tree> {
12935 #[allow(clippy::collapsible_else_if)]
12936 fn from_node(
12937 node: ::treesitter_types::tree_sitter::Node<'tree>,
12938 src: &'tree [u8],
12939 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12940 match node.kind() {
12941 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
12942 ::treesitter_types::runtime::maybe_grow_stack(|| {
12943 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)
12944 })?,
12945 ))),
12946 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12947 ::treesitter_types::runtime::maybe_grow_stack(|| {
12948 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
12949 })?,
12950 ))),
12951 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
12952 ::treesitter_types::runtime::maybe_grow_stack(|| {
12953 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
12954 })?,
12955 ))),
12956 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12957 ::treesitter_types::runtime::maybe_grow_stack(|| {
12958 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12959 })?,
12960 ))),
12961 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12962 ::treesitter_types::runtime::maybe_grow_stack(|| {
12963 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
12964 })?,
12965 ))),
12966 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12967 ::treesitter_types::runtime::maybe_grow_stack(|| {
12968 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12969 })?,
12970 ))),
12971 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12972 ::treesitter_types::runtime::maybe_grow_stack(|| {
12973 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
12974 })?,
12975 ))),
12976 "super" => Ok(Self::Super(::std::boxed::Box::new(
12977 ::treesitter_types::runtime::maybe_grow_stack(|| {
12978 <Super as ::treesitter_types::FromNode>::from_node(node, src)
12979 })?,
12980 ))),
12981 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12982 }
12983 }
12984}
12985impl ::treesitter_types::Spanned for ScopedIdentifierPath<'_> {
12986 fn span(&self) -> ::treesitter_types::Span {
12987 match self {
12988 Self::BracketedType(inner) => inner.span(),
12989 Self::Crate(inner) => inner.span(),
12990 Self::GenericType(inner) => inner.span(),
12991 Self::Identifier(inner) => inner.span(),
12992 Self::Metavariable(inner) => inner.span(),
12993 Self::ScopedIdentifier(inner) => inner.span(),
12994 Self::SelfType(inner) => inner.span(),
12995 Self::Super(inner) => inner.span(),
12996 }
12997 }
12998}
12999#[derive(Debug, Clone, PartialEq, Eq)]
13000pub enum ScopedTypeIdentifierPath<'tree> {
13001 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
13002 Crate(::std::boxed::Box<Crate<'tree>>),
13003 GenericType(::std::boxed::Box<GenericType<'tree>>),
13004 Identifier(::std::boxed::Box<Identifier<'tree>>),
13005 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13006 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13007 SelfType(::std::boxed::Box<SelfType<'tree>>),
13008 Super(::std::boxed::Box<Super<'tree>>),
13009}
13010impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierPath<'tree> {
13011 #[allow(clippy::collapsible_else_if)]
13012 fn from_node(
13013 node: ::treesitter_types::tree_sitter::Node<'tree>,
13014 src: &'tree [u8],
13015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13016 match node.kind() {
13017 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
13018 ::treesitter_types::runtime::maybe_grow_stack(|| {
13019 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)
13020 })?,
13021 ))),
13022 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13023 ::treesitter_types::runtime::maybe_grow_stack(|| {
13024 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13025 })?,
13026 ))),
13027 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
13028 ::treesitter_types::runtime::maybe_grow_stack(|| {
13029 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
13030 })?,
13031 ))),
13032 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13033 ::treesitter_types::runtime::maybe_grow_stack(|| {
13034 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13035 })?,
13036 ))),
13037 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13038 ::treesitter_types::runtime::maybe_grow_stack(|| {
13039 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13040 })?,
13041 ))),
13042 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13043 ::treesitter_types::runtime::maybe_grow_stack(|| {
13044 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13045 })?,
13046 ))),
13047 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13048 ::treesitter_types::runtime::maybe_grow_stack(|| {
13049 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13050 })?,
13051 ))),
13052 "super" => Ok(Self::Super(::std::boxed::Box::new(
13053 ::treesitter_types::runtime::maybe_grow_stack(|| {
13054 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13055 })?,
13056 ))),
13057 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13058 }
13059 }
13060}
13061impl ::treesitter_types::Spanned for ScopedTypeIdentifierPath<'_> {
13062 fn span(&self) -> ::treesitter_types::Span {
13063 match self {
13064 Self::BracketedType(inner) => inner.span(),
13065 Self::Crate(inner) => inner.span(),
13066 Self::GenericType(inner) => inner.span(),
13067 Self::Identifier(inner) => inner.span(),
13068 Self::Metavariable(inner) => inner.span(),
13069 Self::ScopedIdentifier(inner) => inner.span(),
13070 Self::SelfType(inner) => inner.span(),
13071 Self::Super(inner) => inner.span(),
13072 }
13073 }
13074}
13075#[derive(Debug, Clone, PartialEq, Eq)]
13076pub enum ScopedUseListPath<'tree> {
13077 Crate(::std::boxed::Box<Crate<'tree>>),
13078 Identifier(::std::boxed::Box<Identifier<'tree>>),
13079 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13080 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13081 SelfType(::std::boxed::Box<SelfType<'tree>>),
13082 Super(::std::boxed::Box<Super<'tree>>),
13083}
13084impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseListPath<'tree> {
13085 #[allow(clippy::collapsible_else_if)]
13086 fn from_node(
13087 node: ::treesitter_types::tree_sitter::Node<'tree>,
13088 src: &'tree [u8],
13089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13090 match node.kind() {
13091 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13092 ::treesitter_types::runtime::maybe_grow_stack(|| {
13093 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13094 })?,
13095 ))),
13096 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13097 ::treesitter_types::runtime::maybe_grow_stack(|| {
13098 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13099 })?,
13100 ))),
13101 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13102 ::treesitter_types::runtime::maybe_grow_stack(|| {
13103 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13104 })?,
13105 ))),
13106 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13107 ::treesitter_types::runtime::maybe_grow_stack(|| {
13108 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13109 })?,
13110 ))),
13111 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13112 ::treesitter_types::runtime::maybe_grow_stack(|| {
13113 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13114 })?,
13115 ))),
13116 "super" => Ok(Self::Super(::std::boxed::Box::new(
13117 ::treesitter_types::runtime::maybe_grow_stack(|| {
13118 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13119 })?,
13120 ))),
13121 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13122 }
13123 }
13124}
13125impl ::treesitter_types::Spanned for ScopedUseListPath<'_> {
13126 fn span(&self) -> ::treesitter_types::Span {
13127 match self {
13128 Self::Crate(inner) => inner.span(),
13129 Self::Identifier(inner) => inner.span(),
13130 Self::Metavariable(inner) => inner.span(),
13131 Self::ScopedIdentifier(inner) => inner.span(),
13132 Self::SelfType(inner) => inner.span(),
13133 Self::Super(inner) => inner.span(),
13134 }
13135 }
13136}
13137#[derive(Debug, Clone, PartialEq, Eq)]
13138pub enum SelfParameterChildren<'tree> {
13139 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
13140 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13141 SelfType(::std::boxed::Box<SelfType<'tree>>),
13142}
13143impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameterChildren<'tree> {
13144 #[allow(clippy::collapsible_else_if)]
13145 fn from_node(
13146 node: ::treesitter_types::tree_sitter::Node<'tree>,
13147 src: &'tree [u8],
13148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13149 match node.kind() {
13150 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
13151 ::treesitter_types::runtime::maybe_grow_stack(|| {
13152 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
13153 })?,
13154 ))),
13155 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13156 ::treesitter_types::runtime::maybe_grow_stack(|| {
13157 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13158 })?,
13159 ))),
13160 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13161 ::treesitter_types::runtime::maybe_grow_stack(|| {
13162 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13163 })?,
13164 ))),
13165 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13166 }
13167 }
13168}
13169impl ::treesitter_types::Spanned for SelfParameterChildren<'_> {
13170 fn span(&self) -> ::treesitter_types::Span {
13171 match self {
13172 Self::Lifetime(inner) => inner.span(),
13173 Self::MutableSpecifier(inner) => inner.span(),
13174 Self::SelfType(inner) => inner.span(),
13175 }
13176 }
13177}
13178#[derive(Debug, Clone, PartialEq, Eq)]
13179pub enum ShorthandFieldInitializerChildren<'tree> {
13180 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
13181 Identifier(::std::boxed::Box<Identifier<'tree>>),
13182}
13183impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializerChildren<'tree> {
13184 #[allow(clippy::collapsible_else_if)]
13185 fn from_node(
13186 node: ::treesitter_types::tree_sitter::Node<'tree>,
13187 src: &'tree [u8],
13188 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13189 match node.kind() {
13190 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
13191 ::treesitter_types::runtime::maybe_grow_stack(|| {
13192 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
13193 })?,
13194 ))),
13195 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13196 ::treesitter_types::runtime::maybe_grow_stack(|| {
13197 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13198 })?,
13199 ))),
13200 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13201 }
13202 }
13203}
13204impl ::treesitter_types::Spanned for ShorthandFieldInitializerChildren<'_> {
13205 fn span(&self) -> ::treesitter_types::Span {
13206 match self {
13207 Self::AttributeItem(inner) => inner.span(),
13208 Self::Identifier(inner) => inner.span(),
13209 }
13210 }
13211}
13212#[derive(Debug, Clone, PartialEq, Eq)]
13213pub enum SourceFileChildren<'tree> {
13214 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
13215 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
13216 Shebang(::std::boxed::Box<Shebang<'tree>>),
13217}
13218impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFileChildren<'tree> {
13219 #[allow(clippy::collapsible_else_if)]
13220 fn from_node(
13221 node: ::treesitter_types::tree_sitter::Node<'tree>,
13222 src: &'tree [u8],
13223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13224 match node.kind() {
13225 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
13226 ::treesitter_types::runtime::maybe_grow_stack(|| {
13227 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
13228 })?,
13229 ))),
13230 "shebang" => Ok(Self::Shebang(::std::boxed::Box::new(
13231 ::treesitter_types::runtime::maybe_grow_stack(|| {
13232 <Shebang as ::treesitter_types::FromNode>::from_node(node, src)
13233 })?,
13234 ))),
13235 _other => {
13236 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13237 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
13238 }) {
13239 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
13240 } else {
13241 Err(::treesitter_types::ParseError::unexpected_kind(
13242 _other, node,
13243 ))
13244 }
13245 }
13246 }
13247 }
13248}
13249impl ::treesitter_types::Spanned for SourceFileChildren<'_> {
13250 fn span(&self) -> ::treesitter_types::Span {
13251 match self {
13252 Self::DeclarationStatement(inner) => inner.span(),
13253 Self::ExpressionStatement(inner) => inner.span(),
13254 Self::Shebang(inner) => inner.span(),
13255 }
13256 }
13257}
13258#[derive(Debug, Clone, PartialEq, Eq)]
13259pub enum StaticItemChildren<'tree> {
13260 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13261 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13262}
13263impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItemChildren<'tree> {
13264 #[allow(clippy::collapsible_else_if)]
13265 fn from_node(
13266 node: ::treesitter_types::tree_sitter::Node<'tree>,
13267 src: &'tree [u8],
13268 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13269 match node.kind() {
13270 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13271 ::treesitter_types::runtime::maybe_grow_stack(|| {
13272 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13273 })?,
13274 ))),
13275 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13276 ::treesitter_types::runtime::maybe_grow_stack(|| {
13277 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13278 })?,
13279 ))),
13280 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13281 }
13282 }
13283}
13284impl ::treesitter_types::Spanned for StaticItemChildren<'_> {
13285 fn span(&self) -> ::treesitter_types::Span {
13286 match self {
13287 Self::MutableSpecifier(inner) => inner.span(),
13288 Self::VisibilityModifier(inner) => inner.span(),
13289 }
13290 }
13291}
13292#[derive(Debug, Clone, PartialEq, Eq)]
13293pub enum StringLiteralChildren<'tree> {
13294 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
13295 StringContent(::std::boxed::Box<StringContent<'tree>>),
13296}
13297impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
13298 #[allow(clippy::collapsible_else_if)]
13299 fn from_node(
13300 node: ::treesitter_types::tree_sitter::Node<'tree>,
13301 src: &'tree [u8],
13302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13303 match node.kind() {
13304 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
13305 ::treesitter_types::runtime::maybe_grow_stack(|| {
13306 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
13307 })?,
13308 ))),
13309 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
13310 ::treesitter_types::runtime::maybe_grow_stack(|| {
13311 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
13312 })?,
13313 ))),
13314 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13315 }
13316 }
13317}
13318impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
13319 fn span(&self) -> ::treesitter_types::Span {
13320 match self {
13321 Self::EscapeSequence(inner) => inner.span(),
13322 Self::StringContent(inner) => inner.span(),
13323 }
13324 }
13325}
13326#[derive(Debug, Clone, PartialEq, Eq)]
13327pub enum StructExpressionName<'tree> {
13328 GenericTypeWithTurbofish(::std::boxed::Box<GenericTypeWithTurbofish<'tree>>),
13329 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
13330 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13331}
13332impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpressionName<'tree> {
13333 #[allow(clippy::collapsible_else_if)]
13334 fn from_node(
13335 node: ::treesitter_types::tree_sitter::Node<'tree>,
13336 src: &'tree [u8],
13337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13338 match node.kind() {
13339 "generic_type_with_turbofish" => Ok(Self::GenericTypeWithTurbofish(
13340 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13341 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(node, src)
13342 })?),
13343 )),
13344 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
13345 ::treesitter_types::runtime::maybe_grow_stack(|| {
13346 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13347 })?,
13348 ))),
13349 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13350 ::treesitter_types::runtime::maybe_grow_stack(|| {
13351 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13352 })?,
13353 ))),
13354 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13355 }
13356 }
13357}
13358impl ::treesitter_types::Spanned for StructExpressionName<'_> {
13359 fn span(&self) -> ::treesitter_types::Span {
13360 match self {
13361 Self::GenericTypeWithTurbofish(inner) => inner.span(),
13362 Self::ScopedTypeIdentifier(inner) => inner.span(),
13363 Self::TypeIdentifier(inner) => inner.span(),
13364 }
13365 }
13366}
13367#[derive(Debug, Clone, PartialEq, Eq)]
13368pub enum StructItemBody<'tree> {
13369 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
13370 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
13371}
13372impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemBody<'tree> {
13373 #[allow(clippy::collapsible_else_if)]
13374 fn from_node(
13375 node: ::treesitter_types::tree_sitter::Node<'tree>,
13376 src: &'tree [u8],
13377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13378 match node.kind() {
13379 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
13380 ::treesitter_types::runtime::maybe_grow_stack(|| {
13381 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
13382 })?,
13383 ))),
13384 "ordered_field_declaration_list" => Ok(Self::OrderedFieldDeclarationList(
13385 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13386 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
13387 node, src,
13388 )
13389 })?),
13390 )),
13391 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13392 }
13393 }
13394}
13395impl ::treesitter_types::Spanned for StructItemBody<'_> {
13396 fn span(&self) -> ::treesitter_types::Span {
13397 match self {
13398 Self::FieldDeclarationList(inner) => inner.span(),
13399 Self::OrderedFieldDeclarationList(inner) => inner.span(),
13400 }
13401 }
13402}
13403#[derive(Debug, Clone, PartialEq, Eq)]
13404pub enum StructItemChildren<'tree> {
13405 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13406 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
13407}
13408impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemChildren<'tree> {
13409 #[allow(clippy::collapsible_else_if)]
13410 fn from_node(
13411 node: ::treesitter_types::tree_sitter::Node<'tree>,
13412 src: &'tree [u8],
13413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13414 match node.kind() {
13415 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13416 ::treesitter_types::runtime::maybe_grow_stack(|| {
13417 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13418 })?,
13419 ))),
13420 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
13421 ::treesitter_types::runtime::maybe_grow_stack(|| {
13422 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
13423 })?,
13424 ))),
13425 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13426 }
13427 }
13428}
13429impl ::treesitter_types::Spanned for StructItemChildren<'_> {
13430 fn span(&self) -> ::treesitter_types::Span {
13431 match self {
13432 Self::VisibilityModifier(inner) => inner.span(),
13433 Self::WhereClause(inner) => inner.span(),
13434 }
13435 }
13436}
13437#[derive(Debug, Clone, PartialEq, Eq)]
13438pub enum StructPatternType<'tree> {
13439 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
13440 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13441}
13442impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternType<'tree> {
13443 #[allow(clippy::collapsible_else_if)]
13444 fn from_node(
13445 node: ::treesitter_types::tree_sitter::Node<'tree>,
13446 src: &'tree [u8],
13447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13448 match node.kind() {
13449 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
13450 ::treesitter_types::runtime::maybe_grow_stack(|| {
13451 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13452 })?,
13453 ))),
13454 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13455 ::treesitter_types::runtime::maybe_grow_stack(|| {
13456 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13457 })?,
13458 ))),
13459 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13460 }
13461 }
13462}
13463impl ::treesitter_types::Spanned for StructPatternType<'_> {
13464 fn span(&self) -> ::treesitter_types::Span {
13465 match self {
13466 Self::ScopedTypeIdentifier(inner) => inner.span(),
13467 Self::TypeIdentifier(inner) => inner.span(),
13468 }
13469 }
13470}
13471#[derive(Debug, Clone, PartialEq, Eq)]
13472pub enum StructPatternChildren<'tree> {
13473 FieldPattern(::std::boxed::Box<FieldPattern<'tree>>),
13474 RemainingFieldPattern(::std::boxed::Box<RemainingFieldPattern<'tree>>),
13475}
13476impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternChildren<'tree> {
13477 #[allow(clippy::collapsible_else_if)]
13478 fn from_node(
13479 node: ::treesitter_types::tree_sitter::Node<'tree>,
13480 src: &'tree [u8],
13481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13482 match node.kind() {
13483 "field_pattern" => Ok(Self::FieldPattern(::std::boxed::Box::new(
13484 ::treesitter_types::runtime::maybe_grow_stack(|| {
13485 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
13486 })?,
13487 ))),
13488 "remaining_field_pattern" => Ok(Self::RemainingFieldPattern(::std::boxed::Box::new(
13489 ::treesitter_types::runtime::maybe_grow_stack(|| {
13490 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
13491 })?,
13492 ))),
13493 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13494 }
13495 }
13496}
13497impl ::treesitter_types::Spanned for StructPatternChildren<'_> {
13498 fn span(&self) -> ::treesitter_types::Span {
13499 match self {
13500 Self::FieldPattern(inner) => inner.span(),
13501 Self::RemainingFieldPattern(inner) => inner.span(),
13502 }
13503 }
13504}
13505#[derive(Debug, Clone, PartialEq, Eq)]
13506pub enum TokenRepetitionChildren<'tree> {
13507 Literal(::std::boxed::Box<Literal<'tree>>),
13508 Crate(::std::boxed::Box<Crate<'tree>>),
13509 Identifier(::std::boxed::Box<Identifier<'tree>>),
13510 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13511 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13512 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13513 SelfType(::std::boxed::Box<SelfType<'tree>>),
13514 Super(::std::boxed::Box<Super<'tree>>),
13515 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
13516 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
13517}
13518impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionChildren<'tree> {
13519 #[allow(clippy::collapsible_else_if)]
13520 fn from_node(
13521 node: ::treesitter_types::tree_sitter::Node<'tree>,
13522 src: &'tree [u8],
13523 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13524 match node.kind() {
13525 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13526 ::treesitter_types::runtime::maybe_grow_stack(|| {
13527 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13528 })?,
13529 ))),
13530 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13531 ::treesitter_types::runtime::maybe_grow_stack(|| {
13532 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13533 })?,
13534 ))),
13535 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13536 ::treesitter_types::runtime::maybe_grow_stack(|| {
13537 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13538 })?,
13539 ))),
13540 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13541 ::treesitter_types::runtime::maybe_grow_stack(|| {
13542 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13543 })?,
13544 ))),
13545 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13546 ::treesitter_types::runtime::maybe_grow_stack(|| {
13547 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13548 })?,
13549 ))),
13550 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13551 ::treesitter_types::runtime::maybe_grow_stack(|| {
13552 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13553 })?,
13554 ))),
13555 "super" => Ok(Self::Super(::std::boxed::Box::new(
13556 ::treesitter_types::runtime::maybe_grow_stack(|| {
13557 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13558 })?,
13559 ))),
13560 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
13561 ::treesitter_types::runtime::maybe_grow_stack(|| {
13562 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)
13563 })?,
13564 ))),
13565 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
13566 ::treesitter_types::runtime::maybe_grow_stack(|| {
13567 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)
13568 })?,
13569 ))),
13570 _other => {
13571 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13572 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
13573 }) {
13574 Ok(Self::Literal(::std::boxed::Box::new(v)))
13575 } else {
13576 Err(::treesitter_types::ParseError::unexpected_kind(
13577 _other, node,
13578 ))
13579 }
13580 }
13581 }
13582 }
13583}
13584impl ::treesitter_types::Spanned for TokenRepetitionChildren<'_> {
13585 fn span(&self) -> ::treesitter_types::Span {
13586 match self {
13587 Self::Literal(inner) => inner.span(),
13588 Self::Crate(inner) => inner.span(),
13589 Self::Identifier(inner) => inner.span(),
13590 Self::Metavariable(inner) => inner.span(),
13591 Self::MutableSpecifier(inner) => inner.span(),
13592 Self::PrimitiveType(inner) => inner.span(),
13593 Self::SelfType(inner) => inner.span(),
13594 Self::Super(inner) => inner.span(),
13595 Self::TokenRepetition(inner) => inner.span(),
13596 Self::TokenTree(inner) => inner.span(),
13597 }
13598 }
13599}
13600#[derive(Debug, Clone, PartialEq, Eq)]
13601pub enum TokenRepetitionPatternChildren<'tree> {
13602 Literal(::std::boxed::Box<Literal<'tree>>),
13603 Crate(::std::boxed::Box<Crate<'tree>>),
13604 Identifier(::std::boxed::Box<Identifier<'tree>>),
13605 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13606 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13607 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13608 SelfType(::std::boxed::Box<SelfType<'tree>>),
13609 Super(::std::boxed::Box<Super<'tree>>),
13610 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
13611 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
13612 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
13613}
13614impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPatternChildren<'tree> {
13615 #[allow(clippy::collapsible_else_if)]
13616 fn from_node(
13617 node: ::treesitter_types::tree_sitter::Node<'tree>,
13618 src: &'tree [u8],
13619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13620 match node.kind() {
13621 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13622 ::treesitter_types::runtime::maybe_grow_stack(|| {
13623 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13624 })?,
13625 ))),
13626 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13627 ::treesitter_types::runtime::maybe_grow_stack(|| {
13628 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13629 })?,
13630 ))),
13631 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13632 ::treesitter_types::runtime::maybe_grow_stack(|| {
13633 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13634 })?,
13635 ))),
13636 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13637 ::treesitter_types::runtime::maybe_grow_stack(|| {
13638 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13639 })?,
13640 ))),
13641 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13642 ::treesitter_types::runtime::maybe_grow_stack(|| {
13643 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13644 })?,
13645 ))),
13646 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13647 ::treesitter_types::runtime::maybe_grow_stack(|| {
13648 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13649 })?,
13650 ))),
13651 "super" => Ok(Self::Super(::std::boxed::Box::new(
13652 ::treesitter_types::runtime::maybe_grow_stack(|| {
13653 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13654 })?,
13655 ))),
13656 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
13657 ::treesitter_types::runtime::maybe_grow_stack(|| {
13658 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)
13659 })?,
13660 ))),
13661 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
13662 ::treesitter_types::runtime::maybe_grow_stack(|| {
13663 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)
13664 })?,
13665 ))),
13666 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
13667 ::treesitter_types::runtime::maybe_grow_stack(|| {
13668 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)
13669 })?,
13670 ))),
13671 _other => {
13672 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13673 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
13674 }) {
13675 Ok(Self::Literal(::std::boxed::Box::new(v)))
13676 } else {
13677 Err(::treesitter_types::ParseError::unexpected_kind(
13678 _other, node,
13679 ))
13680 }
13681 }
13682 }
13683 }
13684}
13685impl ::treesitter_types::Spanned for TokenRepetitionPatternChildren<'_> {
13686 fn span(&self) -> ::treesitter_types::Span {
13687 match self {
13688 Self::Literal(inner) => inner.span(),
13689 Self::Crate(inner) => inner.span(),
13690 Self::Identifier(inner) => inner.span(),
13691 Self::Metavariable(inner) => inner.span(),
13692 Self::MutableSpecifier(inner) => inner.span(),
13693 Self::PrimitiveType(inner) => inner.span(),
13694 Self::SelfType(inner) => inner.span(),
13695 Self::Super(inner) => inner.span(),
13696 Self::TokenBindingPattern(inner) => inner.span(),
13697 Self::TokenRepetitionPattern(inner) => inner.span(),
13698 Self::TokenTreePattern(inner) => inner.span(),
13699 }
13700 }
13701}
13702#[derive(Debug, Clone, PartialEq, Eq)]
13703pub enum TokenTreeChildren<'tree> {
13704 Literal(::std::boxed::Box<Literal<'tree>>),
13705 Crate(::std::boxed::Box<Crate<'tree>>),
13706 Identifier(::std::boxed::Box<Identifier<'tree>>),
13707 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13708 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13709 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13710 SelfType(::std::boxed::Box<SelfType<'tree>>),
13711 Super(::std::boxed::Box<Super<'tree>>),
13712 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
13713 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
13714}
13715impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreeChildren<'tree> {
13716 #[allow(clippy::collapsible_else_if)]
13717 fn from_node(
13718 node: ::treesitter_types::tree_sitter::Node<'tree>,
13719 src: &'tree [u8],
13720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13721 match node.kind() {
13722 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13723 ::treesitter_types::runtime::maybe_grow_stack(|| {
13724 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13725 })?,
13726 ))),
13727 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13728 ::treesitter_types::runtime::maybe_grow_stack(|| {
13729 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13730 })?,
13731 ))),
13732 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13733 ::treesitter_types::runtime::maybe_grow_stack(|| {
13734 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13735 })?,
13736 ))),
13737 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13738 ::treesitter_types::runtime::maybe_grow_stack(|| {
13739 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13740 })?,
13741 ))),
13742 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13743 ::treesitter_types::runtime::maybe_grow_stack(|| {
13744 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13745 })?,
13746 ))),
13747 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13748 ::treesitter_types::runtime::maybe_grow_stack(|| {
13749 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13750 })?,
13751 ))),
13752 "super" => Ok(Self::Super(::std::boxed::Box::new(
13753 ::treesitter_types::runtime::maybe_grow_stack(|| {
13754 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13755 })?,
13756 ))),
13757 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
13758 ::treesitter_types::runtime::maybe_grow_stack(|| {
13759 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)
13760 })?,
13761 ))),
13762 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
13763 ::treesitter_types::runtime::maybe_grow_stack(|| {
13764 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)
13765 })?,
13766 ))),
13767 _other => {
13768 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13769 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
13770 }) {
13771 Ok(Self::Literal(::std::boxed::Box::new(v)))
13772 } else {
13773 Err(::treesitter_types::ParseError::unexpected_kind(
13774 _other, node,
13775 ))
13776 }
13777 }
13778 }
13779 }
13780}
13781impl ::treesitter_types::Spanned for TokenTreeChildren<'_> {
13782 fn span(&self) -> ::treesitter_types::Span {
13783 match self {
13784 Self::Literal(inner) => inner.span(),
13785 Self::Crate(inner) => inner.span(),
13786 Self::Identifier(inner) => inner.span(),
13787 Self::Metavariable(inner) => inner.span(),
13788 Self::MutableSpecifier(inner) => inner.span(),
13789 Self::PrimitiveType(inner) => inner.span(),
13790 Self::SelfType(inner) => inner.span(),
13791 Self::Super(inner) => inner.span(),
13792 Self::TokenRepetition(inner) => inner.span(),
13793 Self::TokenTree(inner) => inner.span(),
13794 }
13795 }
13796}
13797#[derive(Debug, Clone, PartialEq, Eq)]
13798pub enum TokenTreePatternChildren<'tree> {
13799 Literal(::std::boxed::Box<Literal<'tree>>),
13800 Crate(::std::boxed::Box<Crate<'tree>>),
13801 Identifier(::std::boxed::Box<Identifier<'tree>>),
13802 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13803 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
13804 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13805 SelfType(::std::boxed::Box<SelfType<'tree>>),
13806 Super(::std::boxed::Box<Super<'tree>>),
13807 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
13808 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
13809 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
13810}
13811impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePatternChildren<'tree> {
13812 #[allow(clippy::collapsible_else_if)]
13813 fn from_node(
13814 node: ::treesitter_types::tree_sitter::Node<'tree>,
13815 src: &'tree [u8],
13816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13817 match node.kind() {
13818 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13819 ::treesitter_types::runtime::maybe_grow_stack(|| {
13820 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13821 })?,
13822 ))),
13823 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13824 ::treesitter_types::runtime::maybe_grow_stack(|| {
13825 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13826 })?,
13827 ))),
13828 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13829 ::treesitter_types::runtime::maybe_grow_stack(|| {
13830 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13831 })?,
13832 ))),
13833 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
13834 ::treesitter_types::runtime::maybe_grow_stack(|| {
13835 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13836 })?,
13837 ))),
13838 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13839 ::treesitter_types::runtime::maybe_grow_stack(|| {
13840 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13841 })?,
13842 ))),
13843 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13844 ::treesitter_types::runtime::maybe_grow_stack(|| {
13845 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13846 })?,
13847 ))),
13848 "super" => Ok(Self::Super(::std::boxed::Box::new(
13849 ::treesitter_types::runtime::maybe_grow_stack(|| {
13850 <Super as ::treesitter_types::FromNode>::from_node(node, src)
13851 })?,
13852 ))),
13853 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
13854 ::treesitter_types::runtime::maybe_grow_stack(|| {
13855 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)
13856 })?,
13857 ))),
13858 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
13859 ::treesitter_types::runtime::maybe_grow_stack(|| {
13860 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)
13861 })?,
13862 ))),
13863 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
13864 ::treesitter_types::runtime::maybe_grow_stack(|| {
13865 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)
13866 })?,
13867 ))),
13868 _other => {
13869 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13870 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
13871 }) {
13872 Ok(Self::Literal(::std::boxed::Box::new(v)))
13873 } else {
13874 Err(::treesitter_types::ParseError::unexpected_kind(
13875 _other, node,
13876 ))
13877 }
13878 }
13879 }
13880 }
13881}
13882impl ::treesitter_types::Spanned for TokenTreePatternChildren<'_> {
13883 fn span(&self) -> ::treesitter_types::Span {
13884 match self {
13885 Self::Literal(inner) => inner.span(),
13886 Self::Crate(inner) => inner.span(),
13887 Self::Identifier(inner) => inner.span(),
13888 Self::Metavariable(inner) => inner.span(),
13889 Self::MutableSpecifier(inner) => inner.span(),
13890 Self::PrimitiveType(inner) => inner.span(),
13891 Self::SelfType(inner) => inner.span(),
13892 Self::Super(inner) => inner.span(),
13893 Self::TokenBindingPattern(inner) => inner.span(),
13894 Self::TokenRepetitionPattern(inner) => inner.span(),
13895 Self::TokenTreePattern(inner) => inner.span(),
13896 }
13897 }
13898}
13899#[derive(Debug, Clone, PartialEq, Eq)]
13900pub enum TraitBoundsChildren<'tree> {
13901 Type(::std::boxed::Box<Type<'tree>>),
13902 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
13903 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
13904}
13905impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBoundsChildren<'tree> {
13906 #[allow(clippy::collapsible_else_if)]
13907 fn from_node(
13908 node: ::treesitter_types::tree_sitter::Node<'tree>,
13909 src: &'tree [u8],
13910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13911 match node.kind() {
13912 "higher_ranked_trait_bound" => Ok(Self::HigherRankedTraitBound(
13913 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13914 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
13915 })?),
13916 )),
13917 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
13918 ::treesitter_types::runtime::maybe_grow_stack(|| {
13919 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
13920 })?,
13921 ))),
13922 _other => {
13923 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13924 <Type as ::treesitter_types::FromNode>::from_node(node, src)
13925 }) {
13926 Ok(Self::Type(::std::boxed::Box::new(v)))
13927 } else {
13928 Err(::treesitter_types::ParseError::unexpected_kind(
13929 _other, node,
13930 ))
13931 }
13932 }
13933 }
13934 }
13935}
13936impl ::treesitter_types::Spanned for TraitBoundsChildren<'_> {
13937 fn span(&self) -> ::treesitter_types::Span {
13938 match self {
13939 Self::Type(inner) => inner.span(),
13940 Self::HigherRankedTraitBound(inner) => inner.span(),
13941 Self::Lifetime(inner) => inner.span(),
13942 }
13943 }
13944}
13945#[derive(Debug, Clone, PartialEq, Eq)]
13946pub enum TraitItemChildren<'tree> {
13947 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13948 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
13949}
13950impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItemChildren<'tree> {
13951 #[allow(clippy::collapsible_else_if)]
13952 fn from_node(
13953 node: ::treesitter_types::tree_sitter::Node<'tree>,
13954 src: &'tree [u8],
13955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13956 match node.kind() {
13957 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13958 ::treesitter_types::runtime::maybe_grow_stack(|| {
13959 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13960 })?,
13961 ))),
13962 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
13963 ::treesitter_types::runtime::maybe_grow_stack(|| {
13964 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
13965 })?,
13966 ))),
13967 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13968 }
13969 }
13970}
13971impl ::treesitter_types::Spanned for TraitItemChildren<'_> {
13972 fn span(&self) -> ::treesitter_types::Span {
13973 match self {
13974 Self::VisibilityModifier(inner) => inner.span(),
13975 Self::WhereClause(inner) => inner.span(),
13976 }
13977 }
13978}
13979#[derive(Debug, Clone, PartialEq, Eq)]
13980pub enum TupleExpressionChildren<'tree> {
13981 Expression(::std::boxed::Box<Expression<'tree>>),
13982 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
13983}
13984impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpressionChildren<'tree> {
13985 #[allow(clippy::collapsible_else_if)]
13986 fn from_node(
13987 node: ::treesitter_types::tree_sitter::Node<'tree>,
13988 src: &'tree [u8],
13989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13990 match node.kind() {
13991 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
13992 ::treesitter_types::runtime::maybe_grow_stack(|| {
13993 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
13994 })?,
13995 ))),
13996 _other => {
13997 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13998 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13999 }) {
14000 Ok(Self::Expression(::std::boxed::Box::new(v)))
14001 } else {
14002 Err(::treesitter_types::ParseError::unexpected_kind(
14003 _other, node,
14004 ))
14005 }
14006 }
14007 }
14008 }
14009}
14010impl ::treesitter_types::Spanned for TupleExpressionChildren<'_> {
14011 fn span(&self) -> ::treesitter_types::Span {
14012 match self {
14013 Self::Expression(inner) => inner.span(),
14014 Self::AttributeItem(inner) => inner.span(),
14015 }
14016 }
14017}
14018#[derive(Debug, Clone, PartialEq, Eq)]
14019pub enum TuplePatternChildren<'tree> {
14020 Pattern(::std::boxed::Box<Pattern<'tree>>),
14021 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
14022}
14023impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
14024 #[allow(clippy::collapsible_else_if)]
14025 fn from_node(
14026 node: ::treesitter_types::tree_sitter::Node<'tree>,
14027 src: &'tree [u8],
14028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14029 match node.kind() {
14030 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
14031 ::treesitter_types::runtime::maybe_grow_stack(|| {
14032 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
14033 })?,
14034 ))),
14035 _other => {
14036 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14037 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
14038 }) {
14039 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14040 } else {
14041 Err(::treesitter_types::ParseError::unexpected_kind(
14042 _other, node,
14043 ))
14044 }
14045 }
14046 }
14047 }
14048}
14049impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
14050 fn span(&self) -> ::treesitter_types::Span {
14051 match self {
14052 Self::Pattern(inner) => inner.span(),
14053 Self::ClosureExpression(inner) => inner.span(),
14054 }
14055 }
14056}
14057#[derive(Debug, Clone, PartialEq, Eq)]
14058pub enum TupleStructPatternType<'tree> {
14059 GenericType(::std::boxed::Box<GenericType<'tree>>),
14060 Identifier(::std::boxed::Box<Identifier<'tree>>),
14061 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14062}
14063impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPatternType<'tree> {
14064 #[allow(clippy::collapsible_else_if)]
14065 fn from_node(
14066 node: ::treesitter_types::tree_sitter::Node<'tree>,
14067 src: &'tree [u8],
14068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14069 match node.kind() {
14070 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
14071 ::treesitter_types::runtime::maybe_grow_stack(|| {
14072 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
14073 })?,
14074 ))),
14075 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14076 ::treesitter_types::runtime::maybe_grow_stack(|| {
14077 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14078 })?,
14079 ))),
14080 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14081 ::treesitter_types::runtime::maybe_grow_stack(|| {
14082 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14083 })?,
14084 ))),
14085 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14086 }
14087 }
14088}
14089impl ::treesitter_types::Spanned for TupleStructPatternType<'_> {
14090 fn span(&self) -> ::treesitter_types::Span {
14091 match self {
14092 Self::GenericType(inner) => inner.span(),
14093 Self::Identifier(inner) => inner.span(),
14094 Self::ScopedIdentifier(inner) => inner.span(),
14095 }
14096 }
14097}
14098#[derive(Debug, Clone, PartialEq, Eq)]
14099pub enum TypeArgumentsChildren<'tree> {
14100 Literal(::std::boxed::Box<Literal<'tree>>),
14101 Type(::std::boxed::Box<Type<'tree>>),
14102 Block(::std::boxed::Box<Block<'tree>>),
14103 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
14104 TraitBounds(::std::boxed::Box<TraitBounds<'tree>>),
14105 TypeBinding(::std::boxed::Box<TypeBinding<'tree>>),
14106}
14107impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
14108 #[allow(clippy::collapsible_else_if)]
14109 fn from_node(
14110 node: ::treesitter_types::tree_sitter::Node<'tree>,
14111 src: &'tree [u8],
14112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14113 match node.kind() {
14114 "block" => Ok(Self::Block(::std::boxed::Box::new(
14115 ::treesitter_types::runtime::maybe_grow_stack(|| {
14116 <Block as ::treesitter_types::FromNode>::from_node(node, src)
14117 })?,
14118 ))),
14119 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
14120 ::treesitter_types::runtime::maybe_grow_stack(|| {
14121 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
14122 })?,
14123 ))),
14124 "trait_bounds" => Ok(Self::TraitBounds(::std::boxed::Box::new(
14125 ::treesitter_types::runtime::maybe_grow_stack(|| {
14126 <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)
14127 })?,
14128 ))),
14129 "type_binding" => Ok(Self::TypeBinding(::std::boxed::Box::new(
14130 ::treesitter_types::runtime::maybe_grow_stack(|| {
14131 <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)
14132 })?,
14133 ))),
14134 _other => {
14135 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14136 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
14137 }) {
14138 Ok(Self::Literal(::std::boxed::Box::new(v)))
14139 } else {
14140 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14141 <Type as ::treesitter_types::FromNode>::from_node(node, src)
14142 }) {
14143 Ok(Self::Type(::std::boxed::Box::new(v)))
14144 } else {
14145 Err(::treesitter_types::ParseError::unexpected_kind(
14146 _other, node,
14147 ))
14148 }
14149 }
14150 }
14151 }
14152 }
14153}
14154impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
14155 fn span(&self) -> ::treesitter_types::Span {
14156 match self {
14157 Self::Literal(inner) => inner.span(),
14158 Self::Type(inner) => inner.span(),
14159 Self::Block(inner) => inner.span(),
14160 Self::Lifetime(inner) => inner.span(),
14161 Self::TraitBounds(inner) => inner.span(),
14162 Self::TypeBinding(inner) => inner.span(),
14163 }
14164 }
14165}
14166#[derive(Debug, Clone, PartialEq, Eq)]
14167pub enum TypeItemChildren<'tree> {
14168 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
14169 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
14170}
14171impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItemChildren<'tree> {
14172 #[allow(clippy::collapsible_else_if)]
14173 fn from_node(
14174 node: ::treesitter_types::tree_sitter::Node<'tree>,
14175 src: &'tree [u8],
14176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14177 match node.kind() {
14178 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
14179 ::treesitter_types::runtime::maybe_grow_stack(|| {
14180 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
14181 })?,
14182 ))),
14183 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
14184 ::treesitter_types::runtime::maybe_grow_stack(|| {
14185 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
14186 })?,
14187 ))),
14188 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14189 }
14190 }
14191}
14192impl ::treesitter_types::Spanned for TypeItemChildren<'_> {
14193 fn span(&self) -> ::treesitter_types::Span {
14194 match self {
14195 Self::VisibilityModifier(inner) => inner.span(),
14196 Self::WhereClause(inner) => inner.span(),
14197 }
14198 }
14199}
14200#[derive(Debug, Clone, PartialEq, Eq)]
14201pub enum TypeParametersChildren<'tree> {
14202 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
14203 ConstParameter(::std::boxed::Box<ConstParameter<'tree>>),
14204 LifetimeParameter(::std::boxed::Box<LifetimeParameter<'tree>>),
14205 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14206 TypeParameter(::std::boxed::Box<TypeParameter<'tree>>),
14207}
14208impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParametersChildren<'tree> {
14209 #[allow(clippy::collapsible_else_if)]
14210 fn from_node(
14211 node: ::treesitter_types::tree_sitter::Node<'tree>,
14212 src: &'tree [u8],
14213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14214 match node.kind() {
14215 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
14216 ::treesitter_types::runtime::maybe_grow_stack(|| {
14217 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
14218 })?,
14219 ))),
14220 "const_parameter" => Ok(Self::ConstParameter(::std::boxed::Box::new(
14221 ::treesitter_types::runtime::maybe_grow_stack(|| {
14222 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)
14223 })?,
14224 ))),
14225 "lifetime_parameter" => Ok(Self::LifetimeParameter(::std::boxed::Box::new(
14226 ::treesitter_types::runtime::maybe_grow_stack(|| {
14227 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)
14228 })?,
14229 ))),
14230 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14231 ::treesitter_types::runtime::maybe_grow_stack(|| {
14232 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14233 })?,
14234 ))),
14235 "type_parameter" => Ok(Self::TypeParameter(::std::boxed::Box::new(
14236 ::treesitter_types::runtime::maybe_grow_stack(|| {
14237 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
14238 })?,
14239 ))),
14240 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14241 }
14242 }
14243}
14244impl ::treesitter_types::Spanned for TypeParametersChildren<'_> {
14245 fn span(&self) -> ::treesitter_types::Span {
14246 match self {
14247 Self::AttributeItem(inner) => inner.span(),
14248 Self::ConstParameter(inner) => inner.span(),
14249 Self::LifetimeParameter(inner) => inner.span(),
14250 Self::Metavariable(inner) => inner.span(),
14251 Self::TypeParameter(inner) => inner.span(),
14252 }
14253 }
14254}
14255#[derive(Debug, Clone, PartialEq, Eq)]
14256pub enum UnionItemChildren<'tree> {
14257 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
14258 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
14259}
14260impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItemChildren<'tree> {
14261 #[allow(clippy::collapsible_else_if)]
14262 fn from_node(
14263 node: ::treesitter_types::tree_sitter::Node<'tree>,
14264 src: &'tree [u8],
14265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14266 match node.kind() {
14267 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
14268 ::treesitter_types::runtime::maybe_grow_stack(|| {
14269 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
14270 })?,
14271 ))),
14272 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
14273 ::treesitter_types::runtime::maybe_grow_stack(|| {
14274 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
14275 })?,
14276 ))),
14277 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14278 }
14279 }
14280}
14281impl ::treesitter_types::Spanned for UnionItemChildren<'_> {
14282 fn span(&self) -> ::treesitter_types::Span {
14283 match self {
14284 Self::VisibilityModifier(inner) => inner.span(),
14285 Self::WhereClause(inner) => inner.span(),
14286 }
14287 }
14288}
14289#[derive(Debug, Clone, PartialEq, Eq)]
14290pub enum UseAsClausePath<'tree> {
14291 Crate(::std::boxed::Box<Crate<'tree>>),
14292 Identifier(::std::boxed::Box<Identifier<'tree>>),
14293 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14294 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14295 SelfType(::std::boxed::Box<SelfType<'tree>>),
14296 Super(::std::boxed::Box<Super<'tree>>),
14297}
14298impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClausePath<'tree> {
14299 #[allow(clippy::collapsible_else_if)]
14300 fn from_node(
14301 node: ::treesitter_types::tree_sitter::Node<'tree>,
14302 src: &'tree [u8],
14303 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14304 match node.kind() {
14305 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
14306 ::treesitter_types::runtime::maybe_grow_stack(|| {
14307 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14308 })?,
14309 ))),
14310 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14311 ::treesitter_types::runtime::maybe_grow_stack(|| {
14312 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14313 })?,
14314 ))),
14315 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14316 ::treesitter_types::runtime::maybe_grow_stack(|| {
14317 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14318 })?,
14319 ))),
14320 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14321 ::treesitter_types::runtime::maybe_grow_stack(|| {
14322 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14323 })?,
14324 ))),
14325 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
14326 ::treesitter_types::runtime::maybe_grow_stack(|| {
14327 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14328 })?,
14329 ))),
14330 "super" => Ok(Self::Super(::std::boxed::Box::new(
14331 ::treesitter_types::runtime::maybe_grow_stack(|| {
14332 <Super as ::treesitter_types::FromNode>::from_node(node, src)
14333 })?,
14334 ))),
14335 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14336 }
14337 }
14338}
14339impl ::treesitter_types::Spanned for UseAsClausePath<'_> {
14340 fn span(&self) -> ::treesitter_types::Span {
14341 match self {
14342 Self::Crate(inner) => inner.span(),
14343 Self::Identifier(inner) => inner.span(),
14344 Self::Metavariable(inner) => inner.span(),
14345 Self::ScopedIdentifier(inner) => inner.span(),
14346 Self::SelfType(inner) => inner.span(),
14347 Self::Super(inner) => inner.span(),
14348 }
14349 }
14350}
14351#[derive(Debug, Clone, PartialEq, Eq)]
14352pub enum UseBoundsChildren<'tree> {
14353 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
14354 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14355}
14356impl<'tree> ::treesitter_types::FromNode<'tree> for UseBoundsChildren<'tree> {
14357 #[allow(clippy::collapsible_else_if)]
14358 fn from_node(
14359 node: ::treesitter_types::tree_sitter::Node<'tree>,
14360 src: &'tree [u8],
14361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14362 match node.kind() {
14363 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
14364 ::treesitter_types::runtime::maybe_grow_stack(|| {
14365 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
14366 })?,
14367 ))),
14368 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14369 ::treesitter_types::runtime::maybe_grow_stack(|| {
14370 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14371 })?,
14372 ))),
14373 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14374 }
14375 }
14376}
14377impl ::treesitter_types::Spanned for UseBoundsChildren<'_> {
14378 fn span(&self) -> ::treesitter_types::Span {
14379 match self {
14380 Self::Lifetime(inner) => inner.span(),
14381 Self::TypeIdentifier(inner) => inner.span(),
14382 }
14383 }
14384}
14385#[derive(Debug, Clone, PartialEq, Eq)]
14386pub enum UseDeclarationArgument<'tree> {
14387 Crate(::std::boxed::Box<Crate<'tree>>),
14388 Identifier(::std::boxed::Box<Identifier<'tree>>),
14389 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14390 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14391 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
14392 SelfType(::std::boxed::Box<SelfType<'tree>>),
14393 Super(::std::boxed::Box<Super<'tree>>),
14394 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
14395 UseList(::std::boxed::Box<UseList<'tree>>),
14396 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
14397}
14398impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclarationArgument<'tree> {
14399 #[allow(clippy::collapsible_else_if)]
14400 fn from_node(
14401 node: ::treesitter_types::tree_sitter::Node<'tree>,
14402 src: &'tree [u8],
14403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14404 match node.kind() {
14405 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
14406 ::treesitter_types::runtime::maybe_grow_stack(|| {
14407 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14408 })?,
14409 ))),
14410 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14411 ::treesitter_types::runtime::maybe_grow_stack(|| {
14412 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14413 })?,
14414 ))),
14415 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14416 ::treesitter_types::runtime::maybe_grow_stack(|| {
14417 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14418 })?,
14419 ))),
14420 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14421 ::treesitter_types::runtime::maybe_grow_stack(|| {
14422 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14423 })?,
14424 ))),
14425 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
14426 ::treesitter_types::runtime::maybe_grow_stack(|| {
14427 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)
14428 })?,
14429 ))),
14430 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
14431 ::treesitter_types::runtime::maybe_grow_stack(|| {
14432 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14433 })?,
14434 ))),
14435 "super" => Ok(Self::Super(::std::boxed::Box::new(
14436 ::treesitter_types::runtime::maybe_grow_stack(|| {
14437 <Super as ::treesitter_types::FromNode>::from_node(node, src)
14438 })?,
14439 ))),
14440 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
14441 ::treesitter_types::runtime::maybe_grow_stack(|| {
14442 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
14443 })?,
14444 ))),
14445 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
14446 ::treesitter_types::runtime::maybe_grow_stack(|| {
14447 <UseList as ::treesitter_types::FromNode>::from_node(node, src)
14448 })?,
14449 ))),
14450 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
14451 ::treesitter_types::runtime::maybe_grow_stack(|| {
14452 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)
14453 })?,
14454 ))),
14455 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14456 }
14457 }
14458}
14459impl ::treesitter_types::Spanned for UseDeclarationArgument<'_> {
14460 fn span(&self) -> ::treesitter_types::Span {
14461 match self {
14462 Self::Crate(inner) => inner.span(),
14463 Self::Identifier(inner) => inner.span(),
14464 Self::Metavariable(inner) => inner.span(),
14465 Self::ScopedIdentifier(inner) => inner.span(),
14466 Self::ScopedUseList(inner) => inner.span(),
14467 Self::SelfType(inner) => inner.span(),
14468 Self::Super(inner) => inner.span(),
14469 Self::UseAsClause(inner) => inner.span(),
14470 Self::UseList(inner) => inner.span(),
14471 Self::UseWildcard(inner) => inner.span(),
14472 }
14473 }
14474}
14475#[derive(Debug, Clone, PartialEq, Eq)]
14476pub enum UseListChildren<'tree> {
14477 Crate(::std::boxed::Box<Crate<'tree>>),
14478 Identifier(::std::boxed::Box<Identifier<'tree>>),
14479 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14480 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14481 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
14482 SelfType(::std::boxed::Box<SelfType<'tree>>),
14483 Super(::std::boxed::Box<Super<'tree>>),
14484 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
14485 UseList(::std::boxed::Box<UseList<'tree>>),
14486 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
14487}
14488impl<'tree> ::treesitter_types::FromNode<'tree> for UseListChildren<'tree> {
14489 #[allow(clippy::collapsible_else_if)]
14490 fn from_node(
14491 node: ::treesitter_types::tree_sitter::Node<'tree>,
14492 src: &'tree [u8],
14493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14494 match node.kind() {
14495 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
14496 ::treesitter_types::runtime::maybe_grow_stack(|| {
14497 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14498 })?,
14499 ))),
14500 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14501 ::treesitter_types::runtime::maybe_grow_stack(|| {
14502 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14503 })?,
14504 ))),
14505 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14506 ::treesitter_types::runtime::maybe_grow_stack(|| {
14507 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14508 })?,
14509 ))),
14510 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14511 ::treesitter_types::runtime::maybe_grow_stack(|| {
14512 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14513 })?,
14514 ))),
14515 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
14516 ::treesitter_types::runtime::maybe_grow_stack(|| {
14517 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)
14518 })?,
14519 ))),
14520 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
14521 ::treesitter_types::runtime::maybe_grow_stack(|| {
14522 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14523 })?,
14524 ))),
14525 "super" => Ok(Self::Super(::std::boxed::Box::new(
14526 ::treesitter_types::runtime::maybe_grow_stack(|| {
14527 <Super as ::treesitter_types::FromNode>::from_node(node, src)
14528 })?,
14529 ))),
14530 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
14531 ::treesitter_types::runtime::maybe_grow_stack(|| {
14532 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
14533 })?,
14534 ))),
14535 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
14536 ::treesitter_types::runtime::maybe_grow_stack(|| {
14537 <UseList as ::treesitter_types::FromNode>::from_node(node, src)
14538 })?,
14539 ))),
14540 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
14541 ::treesitter_types::runtime::maybe_grow_stack(|| {
14542 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)
14543 })?,
14544 ))),
14545 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14546 }
14547 }
14548}
14549impl ::treesitter_types::Spanned for UseListChildren<'_> {
14550 fn span(&self) -> ::treesitter_types::Span {
14551 match self {
14552 Self::Crate(inner) => inner.span(),
14553 Self::Identifier(inner) => inner.span(),
14554 Self::Metavariable(inner) => inner.span(),
14555 Self::ScopedIdentifier(inner) => inner.span(),
14556 Self::ScopedUseList(inner) => inner.span(),
14557 Self::SelfType(inner) => inner.span(),
14558 Self::Super(inner) => inner.span(),
14559 Self::UseAsClause(inner) => inner.span(),
14560 Self::UseList(inner) => inner.span(),
14561 Self::UseWildcard(inner) => inner.span(),
14562 }
14563 }
14564}
14565#[derive(Debug, Clone, PartialEq, Eq)]
14566pub enum UseWildcardChildren<'tree> {
14567 Crate(::std::boxed::Box<Crate<'tree>>),
14568 Identifier(::std::boxed::Box<Identifier<'tree>>),
14569 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14570 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14571 SelfType(::std::boxed::Box<SelfType<'tree>>),
14572 Super(::std::boxed::Box<Super<'tree>>),
14573}
14574impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcardChildren<'tree> {
14575 #[allow(clippy::collapsible_else_if)]
14576 fn from_node(
14577 node: ::treesitter_types::tree_sitter::Node<'tree>,
14578 src: &'tree [u8],
14579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14580 match node.kind() {
14581 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
14582 ::treesitter_types::runtime::maybe_grow_stack(|| {
14583 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14584 })?,
14585 ))),
14586 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14587 ::treesitter_types::runtime::maybe_grow_stack(|| {
14588 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14589 })?,
14590 ))),
14591 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14592 ::treesitter_types::runtime::maybe_grow_stack(|| {
14593 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14594 })?,
14595 ))),
14596 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14597 ::treesitter_types::runtime::maybe_grow_stack(|| {
14598 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14599 })?,
14600 ))),
14601 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
14602 ::treesitter_types::runtime::maybe_grow_stack(|| {
14603 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14604 })?,
14605 ))),
14606 "super" => Ok(Self::Super(::std::boxed::Box::new(
14607 ::treesitter_types::runtime::maybe_grow_stack(|| {
14608 <Super as ::treesitter_types::FromNode>::from_node(node, src)
14609 })?,
14610 ))),
14611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14612 }
14613 }
14614}
14615impl ::treesitter_types::Spanned for UseWildcardChildren<'_> {
14616 fn span(&self) -> ::treesitter_types::Span {
14617 match self {
14618 Self::Crate(inner) => inner.span(),
14619 Self::Identifier(inner) => inner.span(),
14620 Self::Metavariable(inner) => inner.span(),
14621 Self::ScopedIdentifier(inner) => inner.span(),
14622 Self::SelfType(inner) => inner.span(),
14623 Self::Super(inner) => inner.span(),
14624 }
14625 }
14626}
14627#[derive(Debug, Clone, PartialEq, Eq)]
14628pub enum VisibilityModifierChildren<'tree> {
14629 Crate(::std::boxed::Box<Crate<'tree>>),
14630 Identifier(::std::boxed::Box<Identifier<'tree>>),
14631 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
14632 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
14633 SelfType(::std::boxed::Box<SelfType<'tree>>),
14634 Super(::std::boxed::Box<Super<'tree>>),
14635}
14636impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifierChildren<'tree> {
14637 #[allow(clippy::collapsible_else_if)]
14638 fn from_node(
14639 node: ::treesitter_types::tree_sitter::Node<'tree>,
14640 src: &'tree [u8],
14641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14642 match node.kind() {
14643 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
14644 ::treesitter_types::runtime::maybe_grow_stack(|| {
14645 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14646 })?,
14647 ))),
14648 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14649 ::treesitter_types::runtime::maybe_grow_stack(|| {
14650 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14651 })?,
14652 ))),
14653 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
14654 ::treesitter_types::runtime::maybe_grow_stack(|| {
14655 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14656 })?,
14657 ))),
14658 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
14659 ::treesitter_types::runtime::maybe_grow_stack(|| {
14660 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14661 })?,
14662 ))),
14663 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
14664 ::treesitter_types::runtime::maybe_grow_stack(|| {
14665 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14666 })?,
14667 ))),
14668 "super" => Ok(Self::Super(::std::boxed::Box::new(
14669 ::treesitter_types::runtime::maybe_grow_stack(|| {
14670 <Super as ::treesitter_types::FromNode>::from_node(node, src)
14671 })?,
14672 ))),
14673 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14674 }
14675 }
14676}
14677impl ::treesitter_types::Spanned for VisibilityModifierChildren<'_> {
14678 fn span(&self) -> ::treesitter_types::Span {
14679 match self {
14680 Self::Crate(inner) => inner.span(),
14681 Self::Identifier(inner) => inner.span(),
14682 Self::Metavariable(inner) => inner.span(),
14683 Self::ScopedIdentifier(inner) => inner.span(),
14684 Self::SelfType(inner) => inner.span(),
14685 Self::Super(inner) => inner.span(),
14686 }
14687 }
14688}
14689#[derive(Debug, Clone, PartialEq, Eq)]
14690pub enum WherePredicateLeft<'tree> {
14691 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
14692 GenericType(::std::boxed::Box<GenericType<'tree>>),
14693 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
14694 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
14695 PointerType(::std::boxed::Box<PointerType<'tree>>),
14696 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
14697 ReferenceType(::std::boxed::Box<ReferenceType<'tree>>),
14698 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
14699 TupleType(::std::boxed::Box<TupleType<'tree>>),
14700 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14701}
14702impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicateLeft<'tree> {
14703 #[allow(clippy::collapsible_else_if)]
14704 fn from_node(
14705 node: ::treesitter_types::tree_sitter::Node<'tree>,
14706 src: &'tree [u8],
14707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14708 match node.kind() {
14709 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
14710 ::treesitter_types::runtime::maybe_grow_stack(|| {
14711 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
14712 })?,
14713 ))),
14714 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
14715 ::treesitter_types::runtime::maybe_grow_stack(|| {
14716 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
14717 })?,
14718 ))),
14719 "higher_ranked_trait_bound" => Ok(Self::HigherRankedTraitBound(
14720 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14721 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
14722 })?),
14723 )),
14724 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
14725 ::treesitter_types::runtime::maybe_grow_stack(|| {
14726 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
14727 })?,
14728 ))),
14729 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
14730 ::treesitter_types::runtime::maybe_grow_stack(|| {
14731 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
14732 })?,
14733 ))),
14734 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
14735 ::treesitter_types::runtime::maybe_grow_stack(|| {
14736 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
14737 })?,
14738 ))),
14739 "reference_type" => Ok(Self::ReferenceType(::std::boxed::Box::new(
14740 ::treesitter_types::runtime::maybe_grow_stack(|| {
14741 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)
14742 })?,
14743 ))),
14744 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
14745 ::treesitter_types::runtime::maybe_grow_stack(|| {
14746 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14747 })?,
14748 ))),
14749 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
14750 ::treesitter_types::runtime::maybe_grow_stack(|| {
14751 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
14752 })?,
14753 ))),
14754 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14755 ::treesitter_types::runtime::maybe_grow_stack(|| {
14756 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14757 })?,
14758 ))),
14759 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14760 }
14761 }
14762}
14763impl ::treesitter_types::Spanned for WherePredicateLeft<'_> {
14764 fn span(&self) -> ::treesitter_types::Span {
14765 match self {
14766 Self::ArrayType(inner) => inner.span(),
14767 Self::GenericType(inner) => inner.span(),
14768 Self::HigherRankedTraitBound(inner) => inner.span(),
14769 Self::Lifetime(inner) => inner.span(),
14770 Self::PointerType(inner) => inner.span(),
14771 Self::PrimitiveType(inner) => inner.span(),
14772 Self::ReferenceType(inner) => inner.span(),
14773 Self::ScopedTypeIdentifier(inner) => inner.span(),
14774 Self::TupleType(inner) => inner.span(),
14775 Self::TypeIdentifier(inner) => inner.span(),
14776 }
14777 }
14778}
14779#[derive(Debug, Clone, PartialEq, Eq)]
14780pub enum WhileExpressionCondition<'tree> {
14781 Expression(::std::boxed::Box<Expression<'tree>>),
14782 LetChain(::std::boxed::Box<LetChain<'tree>>),
14783 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
14784}
14785impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpressionCondition<'tree> {
14786 #[allow(clippy::collapsible_else_if)]
14787 fn from_node(
14788 node: ::treesitter_types::tree_sitter::Node<'tree>,
14789 src: &'tree [u8],
14790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14791 match node.kind() {
14792 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
14793 ::treesitter_types::runtime::maybe_grow_stack(|| {
14794 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
14795 })?,
14796 ))),
14797 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
14798 ::treesitter_types::runtime::maybe_grow_stack(|| {
14799 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
14800 })?,
14801 ))),
14802 _other => {
14803 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14804 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14805 }) {
14806 Ok(Self::Expression(::std::boxed::Box::new(v)))
14807 } else {
14808 Err(::treesitter_types::ParseError::unexpected_kind(
14809 _other, node,
14810 ))
14811 }
14812 }
14813 }
14814 }
14815}
14816impl ::treesitter_types::Spanned for WhileExpressionCondition<'_> {
14817 fn span(&self) -> ::treesitter_types::Span {
14818 match self {
14819 Self::Expression(inner) => inner.span(),
14820 Self::LetChain(inner) => inner.span(),
14821 Self::LetCondition(inner) => inner.span(),
14822 }
14823 }
14824}
14825#[derive(Debug, Clone, PartialEq, Eq)]
14826pub enum AnyNode<'tree> {
14827 DeclarationStatement(DeclarationStatement<'tree>),
14828 Expression(Expression<'tree>),
14829 Literal(Literal<'tree>),
14830 LiteralPattern(LiteralPattern<'tree>),
14831 Pattern(Pattern<'tree>),
14832 Type(Type<'tree>),
14833 AbstractType(AbstractType<'tree>),
14834 Arguments(Arguments<'tree>),
14835 ArrayExpression(ArrayExpression<'tree>),
14836 ArrayType(ArrayType<'tree>),
14837 AssignmentExpression(AssignmentExpression<'tree>),
14838 AssociatedType(AssociatedType<'tree>),
14839 AsyncBlock(AsyncBlock<'tree>),
14840 Attribute(Attribute<'tree>),
14841 AttributeItem(AttributeItem<'tree>),
14842 AwaitExpression(AwaitExpression<'tree>),
14843 BaseFieldInitializer(BaseFieldInitializer<'tree>),
14844 BinaryExpression(BinaryExpression<'tree>),
14845 Block(Block<'tree>),
14846 BlockComment(BlockComment<'tree>),
14847 BooleanLiteral(BooleanLiteral<'tree>),
14848 BoundedType(BoundedType<'tree>),
14849 BracketedType(BracketedType<'tree>),
14850 BreakExpression(BreakExpression<'tree>),
14851 CallExpression(CallExpression<'tree>),
14852 CapturedPattern(CapturedPattern<'tree>),
14853 ClosureExpression(ClosureExpression<'tree>),
14854 ClosureParameters(ClosureParameters<'tree>),
14855 CompoundAssignmentExpr(CompoundAssignmentExpr<'tree>),
14856 ConstBlock(ConstBlock<'tree>),
14857 ConstItem(ConstItem<'tree>),
14858 ConstParameter(ConstParameter<'tree>),
14859 ContinueExpression(ContinueExpression<'tree>),
14860 DeclarationList(DeclarationList<'tree>),
14861 DynamicType(DynamicType<'tree>),
14862 ElseClause(ElseClause<'tree>),
14863 EmptyStatement(EmptyStatement<'tree>),
14864 EnumItem(EnumItem<'tree>),
14865 EnumVariant(EnumVariant<'tree>),
14866 EnumVariantList(EnumVariantList<'tree>),
14867 ExpressionStatement(ExpressionStatement<'tree>),
14868 ExternCrateDeclaration(ExternCrateDeclaration<'tree>),
14869 ExternModifier(ExternModifier<'tree>),
14870 FieldDeclaration(FieldDeclaration<'tree>),
14871 FieldDeclarationList(FieldDeclarationList<'tree>),
14872 FieldExpression(FieldExpression<'tree>),
14873 FieldInitializer(FieldInitializer<'tree>),
14874 FieldInitializerList(FieldInitializerList<'tree>),
14875 FieldPattern(FieldPattern<'tree>),
14876 ForExpression(ForExpression<'tree>),
14877 ForLifetimes(ForLifetimes<'tree>),
14878 ForeignModItem(ForeignModItem<'tree>),
14879 FragmentSpecifier(FragmentSpecifier<'tree>),
14880 FunctionItem(FunctionItem<'tree>),
14881 FunctionModifiers(FunctionModifiers<'tree>),
14882 FunctionSignatureItem(FunctionSignatureItem<'tree>),
14883 FunctionType(FunctionType<'tree>),
14884 GenBlock(GenBlock<'tree>),
14885 GenericFunction(GenericFunction<'tree>),
14886 GenericPattern(GenericPattern<'tree>),
14887 GenericType(GenericType<'tree>),
14888 GenericTypeWithTurbofish(GenericTypeWithTurbofish<'tree>),
14889 HigherRankedTraitBound(HigherRankedTraitBound<'tree>),
14890 IfExpression(IfExpression<'tree>),
14891 ImplItem(ImplItem<'tree>),
14892 IndexExpression(IndexExpression<'tree>),
14893 InnerAttributeItem(InnerAttributeItem<'tree>),
14894 InnerDocCommentMarker(InnerDocCommentMarker<'tree>),
14895 Label(Label<'tree>),
14896 LetChain(LetChain<'tree>),
14897 LetCondition(LetCondition<'tree>),
14898 LetDeclaration(LetDeclaration<'tree>),
14899 Lifetime(Lifetime<'tree>),
14900 LifetimeParameter(LifetimeParameter<'tree>),
14901 LineComment(LineComment<'tree>),
14902 LoopExpression(LoopExpression<'tree>),
14903 MacroDefinition(MacroDefinition<'tree>),
14904 MacroInvocation(MacroInvocation<'tree>),
14905 MacroRule(MacroRule<'tree>),
14906 MatchArm(MatchArm<'tree>),
14907 MatchBlock(MatchBlock<'tree>),
14908 MatchExpression(MatchExpression<'tree>),
14909 MatchPattern(MatchPattern<'tree>),
14910 ModItem(ModItem<'tree>),
14911 MutPattern(MutPattern<'tree>),
14912 NegativeLiteral(NegativeLiteral<'tree>),
14913 NeverType(NeverType<'tree>),
14914 OrPattern(OrPattern<'tree>),
14915 OrderedFieldDeclarationList(OrderedFieldDeclarationList<'tree>),
14916 OuterDocCommentMarker(OuterDocCommentMarker<'tree>),
14917 Parameter(Parameter<'tree>),
14918 Parameters(Parameters<'tree>),
14919 ParenthesizedExpression(ParenthesizedExpression<'tree>),
14920 PointerType(PointerType<'tree>),
14921 QualifiedType(QualifiedType<'tree>),
14922 RangeExpression(RangeExpression<'tree>),
14923 RangePattern(RangePattern<'tree>),
14924 RawStringLiteral(RawStringLiteral<'tree>),
14925 RefPattern(RefPattern<'tree>),
14926 ReferenceExpression(ReferenceExpression<'tree>),
14927 ReferencePattern(ReferencePattern<'tree>),
14928 ReferenceType(ReferenceType<'tree>),
14929 RemainingFieldPattern(RemainingFieldPattern<'tree>),
14930 RemovedTraitBound(RemovedTraitBound<'tree>),
14931 ReturnExpression(ReturnExpression<'tree>),
14932 ScopedIdentifier(ScopedIdentifier<'tree>),
14933 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
14934 ScopedUseList(ScopedUseList<'tree>),
14935 SelfParameter(SelfParameter<'tree>),
14936 ShorthandFieldInitializer(ShorthandFieldInitializer<'tree>),
14937 SlicePattern(SlicePattern<'tree>),
14938 SourceFile(SourceFile<'tree>),
14939 StaticItem(StaticItem<'tree>),
14940 StringLiteral(StringLiteral<'tree>),
14941 StructExpression(StructExpression<'tree>),
14942 StructItem(StructItem<'tree>),
14943 StructPattern(StructPattern<'tree>),
14944 TokenBindingPattern(TokenBindingPattern<'tree>),
14945 TokenRepetition(TokenRepetition<'tree>),
14946 TokenRepetitionPattern(TokenRepetitionPattern<'tree>),
14947 TokenTree(TokenTree<'tree>),
14948 TokenTreePattern(TokenTreePattern<'tree>),
14949 TraitBounds(TraitBounds<'tree>),
14950 TraitItem(TraitItem<'tree>),
14951 TryBlock(TryBlock<'tree>),
14952 TryExpression(TryExpression<'tree>),
14953 TupleExpression(TupleExpression<'tree>),
14954 TuplePattern(TuplePattern<'tree>),
14955 TupleStructPattern(TupleStructPattern<'tree>),
14956 TupleType(TupleType<'tree>),
14957 TypeArguments(TypeArguments<'tree>),
14958 TypeBinding(TypeBinding<'tree>),
14959 TypeCastExpression(TypeCastExpression<'tree>),
14960 TypeItem(TypeItem<'tree>),
14961 TypeParameter(TypeParameter<'tree>),
14962 TypeParameters(TypeParameters<'tree>),
14963 UnaryExpression(UnaryExpression<'tree>),
14964 UnionItem(UnionItem<'tree>),
14965 UnitExpression(UnitExpression<'tree>),
14966 UnitType(UnitType<'tree>),
14967 UnsafeBlock(UnsafeBlock<'tree>),
14968 UseAsClause(UseAsClause<'tree>),
14969 UseBounds(UseBounds<'tree>),
14970 UseDeclaration(UseDeclaration<'tree>),
14971 UseList(UseList<'tree>),
14972 UseWildcard(UseWildcard<'tree>),
14973 VariadicParameter(VariadicParameter<'tree>),
14974 VisibilityModifier(VisibilityModifier<'tree>),
14975 WhereClause(WhereClause<'tree>),
14976 WherePredicate(WherePredicate<'tree>),
14977 WhileExpression(WhileExpression<'tree>),
14978 YieldExpression(YieldExpression<'tree>),
14979 CharLiteral(CharLiteral<'tree>),
14980 Crate(Crate<'tree>),
14981 DocComment(DocComment<'tree>),
14982 EscapeSequence(EscapeSequence<'tree>),
14983 FieldIdentifier(FieldIdentifier<'tree>),
14984 FloatLiteral(FloatLiteral<'tree>),
14985 Identifier(Identifier<'tree>),
14986 IntegerLiteral(IntegerLiteral<'tree>),
14987 Metavariable(Metavariable<'tree>),
14988 MutableSpecifier(MutableSpecifier<'tree>),
14989 PrimitiveType(PrimitiveType<'tree>),
14990 SelfType(SelfType<'tree>),
14991 Shebang(Shebang<'tree>),
14992 ShorthandFieldIdentifier(ShorthandFieldIdentifier<'tree>),
14993 StringContent(StringContent<'tree>),
14994 Super(Super<'tree>),
14995 TypeIdentifier(TypeIdentifier<'tree>),
14996 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
14997}
14998impl<'tree> AnyNode<'tree> {
14999 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
15000 match node.kind() {
15001 "_declaration_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15002 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
15003 })
15004 .map(Self::DeclarationStatement)
15005 .unwrap_or(Self::Unknown(node)),
15006 "_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15007 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15008 })
15009 .map(Self::Expression)
15010 .unwrap_or(Self::Unknown(node)),
15011 "_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15012 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
15013 })
15014 .map(Self::Literal)
15015 .unwrap_or(Self::Unknown(node)),
15016 "_literal_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15017 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
15018 })
15019 .map(Self::LiteralPattern)
15020 .unwrap_or(Self::Unknown(node)),
15021 "_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15022 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
15023 })
15024 .map(Self::Pattern)
15025 .unwrap_or(Self::Unknown(node)),
15026 "_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15027 <Type as ::treesitter_types::FromNode>::from_node(node, src)
15028 })
15029 .map(Self::Type)
15030 .unwrap_or(Self::Unknown(node)),
15031 "abstract_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15032 <AbstractType as ::treesitter_types::FromNode>::from_node(node, src)
15033 })
15034 .map(Self::AbstractType)
15035 .unwrap_or(Self::Unknown(node)),
15036 "arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15037 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
15038 })
15039 .map(Self::Arguments)
15040 .unwrap_or(Self::Unknown(node)),
15041 "array_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15042 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)
15043 })
15044 .map(Self::ArrayExpression)
15045 .unwrap_or(Self::Unknown(node)),
15046 "array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15047 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
15048 })
15049 .map(Self::ArrayType)
15050 .unwrap_or(Self::Unknown(node)),
15051 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15052 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
15053 })
15054 .map(Self::AssignmentExpression)
15055 .unwrap_or(Self::Unknown(node)),
15056 "associated_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15057 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
15058 })
15059 .map(Self::AssociatedType)
15060 .unwrap_or(Self::Unknown(node)),
15061 "async_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15062 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)
15063 })
15064 .map(Self::AsyncBlock)
15065 .unwrap_or(Self::Unknown(node)),
15066 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15067 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
15068 })
15069 .map(Self::Attribute)
15070 .unwrap_or(Self::Unknown(node)),
15071 "attribute_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15072 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
15073 })
15074 .map(Self::AttributeItem)
15075 .unwrap_or(Self::Unknown(node)),
15076 "await_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15077 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
15078 })
15079 .map(Self::AwaitExpression)
15080 .unwrap_or(Self::Unknown(node)),
15081 "base_field_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15082 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15083 })
15084 .map(Self::BaseFieldInitializer)
15085 .unwrap_or(Self::Unknown(node)),
15086 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15087 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15088 })
15089 .map(Self::BinaryExpression)
15090 .unwrap_or(Self::Unknown(node)),
15091 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15092 <Block as ::treesitter_types::FromNode>::from_node(node, src)
15093 })
15094 .map(Self::Block)
15095 .unwrap_or(Self::Unknown(node)),
15096 "block_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15097 <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
15098 })
15099 .map(Self::BlockComment)
15100 .unwrap_or(Self::Unknown(node)),
15101 "boolean_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15102 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15103 })
15104 .map(Self::BooleanLiteral)
15105 .unwrap_or(Self::Unknown(node)),
15106 "bounded_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15107 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)
15108 })
15109 .map(Self::BoundedType)
15110 .unwrap_or(Self::Unknown(node)),
15111 "bracketed_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15112 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)
15113 })
15114 .map(Self::BracketedType)
15115 .unwrap_or(Self::Unknown(node)),
15116 "break_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15117 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)
15118 })
15119 .map(Self::BreakExpression)
15120 .unwrap_or(Self::Unknown(node)),
15121 "call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15122 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15123 })
15124 .map(Self::CallExpression)
15125 .unwrap_or(Self::Unknown(node)),
15126 "captured_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15127 <CapturedPattern as ::treesitter_types::FromNode>::from_node(node, src)
15128 })
15129 .map(Self::CapturedPattern)
15130 .unwrap_or(Self::Unknown(node)),
15131 "closure_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15132 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
15133 })
15134 .map(Self::ClosureExpression)
15135 .unwrap_or(Self::Unknown(node)),
15136 "closure_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15137 <ClosureParameters as ::treesitter_types::FromNode>::from_node(node, src)
15138 })
15139 .map(Self::ClosureParameters)
15140 .unwrap_or(Self::Unknown(node)),
15141 "compound_assignment_expr" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15142 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)
15143 })
15144 .map(Self::CompoundAssignmentExpr)
15145 .unwrap_or(Self::Unknown(node)),
15146 "const_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15147 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
15148 })
15149 .map(Self::ConstBlock)
15150 .unwrap_or(Self::Unknown(node)),
15151 "const_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15152 <ConstItem as ::treesitter_types::FromNode>::from_node(node, src)
15153 })
15154 .map(Self::ConstItem)
15155 .unwrap_or(Self::Unknown(node)),
15156 "const_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15157 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)
15158 })
15159 .map(Self::ConstParameter)
15160 .unwrap_or(Self::Unknown(node)),
15161 "continue_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15162 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)
15163 })
15164 .map(Self::ContinueExpression)
15165 .unwrap_or(Self::Unknown(node)),
15166 "declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15167 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
15168 })
15169 .map(Self::DeclarationList)
15170 .unwrap_or(Self::Unknown(node)),
15171 "dynamic_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15172 <DynamicType as ::treesitter_types::FromNode>::from_node(node, src)
15173 })
15174 .map(Self::DynamicType)
15175 .unwrap_or(Self::Unknown(node)),
15176 "else_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15177 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
15178 })
15179 .map(Self::ElseClause)
15180 .unwrap_or(Self::Unknown(node)),
15181 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15182 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
15183 })
15184 .map(Self::EmptyStatement)
15185 .unwrap_or(Self::Unknown(node)),
15186 "enum_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15187 <EnumItem as ::treesitter_types::FromNode>::from_node(node, src)
15188 })
15189 .map(Self::EnumItem)
15190 .unwrap_or(Self::Unknown(node)),
15191 "enum_variant" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15192 <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)
15193 })
15194 .map(Self::EnumVariant)
15195 .unwrap_or(Self::Unknown(node)),
15196 "enum_variant_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15197 <EnumVariantList as ::treesitter_types::FromNode>::from_node(node, src)
15198 })
15199 .map(Self::EnumVariantList)
15200 .unwrap_or(Self::Unknown(node)),
15201 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15202 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
15203 })
15204 .map(Self::ExpressionStatement)
15205 .unwrap_or(Self::Unknown(node)),
15206 "extern_crate_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15207 <ExternCrateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15208 })
15209 .map(Self::ExternCrateDeclaration)
15210 .unwrap_or(Self::Unknown(node)),
15211 "extern_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15212 <ExternModifier as ::treesitter_types::FromNode>::from_node(node, src)
15213 })
15214 .map(Self::ExternModifier)
15215 .unwrap_or(Self::Unknown(node)),
15216 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15217 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15218 })
15219 .map(Self::FieldDeclaration)
15220 .unwrap_or(Self::Unknown(node)),
15221 "field_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15222 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
15223 })
15224 .map(Self::FieldDeclarationList)
15225 .unwrap_or(Self::Unknown(node)),
15226 "field_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15227 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
15228 })
15229 .map(Self::FieldExpression)
15230 .unwrap_or(Self::Unknown(node)),
15231 "field_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15232 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15233 })
15234 .map(Self::FieldInitializer)
15235 .unwrap_or(Self::Unknown(node)),
15236 "field_initializer_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15237 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
15238 })
15239 .map(Self::FieldInitializerList)
15240 .unwrap_or(Self::Unknown(node)),
15241 "field_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15242 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
15243 })
15244 .map(Self::FieldPattern)
15245 .unwrap_or(Self::Unknown(node)),
15246 "for_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15247 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)
15248 })
15249 .map(Self::ForExpression)
15250 .unwrap_or(Self::Unknown(node)),
15251 "for_lifetimes" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15252 <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)
15253 })
15254 .map(Self::ForLifetimes)
15255 .unwrap_or(Self::Unknown(node)),
15256 "foreign_mod_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15257 <ForeignModItem as ::treesitter_types::FromNode>::from_node(node, src)
15258 })
15259 .map(Self::ForeignModItem)
15260 .unwrap_or(Self::Unknown(node)),
15261 "fragment_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15262 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15263 })
15264 .map(Self::FragmentSpecifier)
15265 .unwrap_or(Self::Unknown(node)),
15266 "function_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15267 <FunctionItem as ::treesitter_types::FromNode>::from_node(node, src)
15268 })
15269 .map(Self::FunctionItem)
15270 .unwrap_or(Self::Unknown(node)),
15271 "function_modifiers" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15272 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
15273 })
15274 .map(Self::FunctionModifiers)
15275 .unwrap_or(Self::Unknown(node)),
15276 "function_signature_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15277 <FunctionSignatureItem as ::treesitter_types::FromNode>::from_node(node, src)
15278 })
15279 .map(Self::FunctionSignatureItem)
15280 .unwrap_or(Self::Unknown(node)),
15281 "function_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15282 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
15283 })
15284 .map(Self::FunctionType)
15285 .unwrap_or(Self::Unknown(node)),
15286 "gen_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15287 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)
15288 })
15289 .map(Self::GenBlock)
15290 .unwrap_or(Self::Unknown(node)),
15291 "generic_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15292 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)
15293 })
15294 .map(Self::GenericFunction)
15295 .unwrap_or(Self::Unknown(node)),
15296 "generic_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15297 <GenericPattern as ::treesitter_types::FromNode>::from_node(node, src)
15298 })
15299 .map(Self::GenericPattern)
15300 .unwrap_or(Self::Unknown(node)),
15301 "generic_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15302 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
15303 })
15304 .map(Self::GenericType)
15305 .unwrap_or(Self::Unknown(node)),
15306 "generic_type_with_turbofish" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15307 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(node, src)
15308 })
15309 .map(Self::GenericTypeWithTurbofish)
15310 .unwrap_or(Self::Unknown(node)),
15311 "higher_ranked_trait_bound" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15312 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
15313 })
15314 .map(Self::HigherRankedTraitBound)
15315 .unwrap_or(Self::Unknown(node)),
15316 "if_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15317 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
15318 })
15319 .map(Self::IfExpression)
15320 .unwrap_or(Self::Unknown(node)),
15321 "impl_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15322 <ImplItem as ::treesitter_types::FromNode>::from_node(node, src)
15323 })
15324 .map(Self::ImplItem)
15325 .unwrap_or(Self::Unknown(node)),
15326 "index_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15327 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
15328 })
15329 .map(Self::IndexExpression)
15330 .unwrap_or(Self::Unknown(node)),
15331 "inner_attribute_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15332 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
15333 })
15334 .map(Self::InnerAttributeItem)
15335 .unwrap_or(Self::Unknown(node)),
15336 "inner_doc_comment_marker" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15337 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
15338 })
15339 .map(Self::InnerDocCommentMarker)
15340 .unwrap_or(Self::Unknown(node)),
15341 "label" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15342 <Label as ::treesitter_types::FromNode>::from_node(node, src)
15343 })
15344 .map(Self::Label)
15345 .unwrap_or(Self::Unknown(node)),
15346 "let_chain" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15347 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
15348 })
15349 .map(Self::LetChain)
15350 .unwrap_or(Self::Unknown(node)),
15351 "let_condition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15352 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
15353 })
15354 .map(Self::LetCondition)
15355 .unwrap_or(Self::Unknown(node)),
15356 "let_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15357 <LetDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15358 })
15359 .map(Self::LetDeclaration)
15360 .unwrap_or(Self::Unknown(node)),
15361 "lifetime" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15362 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
15363 })
15364 .map(Self::Lifetime)
15365 .unwrap_or(Self::Unknown(node)),
15366 "lifetime_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15367 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)
15368 })
15369 .map(Self::LifetimeParameter)
15370 .unwrap_or(Self::Unknown(node)),
15371 "line_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15372 <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
15373 })
15374 .map(Self::LineComment)
15375 .unwrap_or(Self::Unknown(node)),
15376 "loop_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15377 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)
15378 })
15379 .map(Self::LoopExpression)
15380 .unwrap_or(Self::Unknown(node)),
15381 "macro_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15382 <MacroDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15383 })
15384 .map(Self::MacroDefinition)
15385 .unwrap_or(Self::Unknown(node)),
15386 "macro_invocation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15387 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
15388 })
15389 .map(Self::MacroInvocation)
15390 .unwrap_or(Self::Unknown(node)),
15391 "macro_rule" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15392 <MacroRule as ::treesitter_types::FromNode>::from_node(node, src)
15393 })
15394 .map(Self::MacroRule)
15395 .unwrap_or(Self::Unknown(node)),
15396 "match_arm" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15397 <MatchArm as ::treesitter_types::FromNode>::from_node(node, src)
15398 })
15399 .map(Self::MatchArm)
15400 .unwrap_or(Self::Unknown(node)),
15401 "match_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15402 <MatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
15403 })
15404 .map(Self::MatchBlock)
15405 .unwrap_or(Self::Unknown(node)),
15406 "match_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15407 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
15408 })
15409 .map(Self::MatchExpression)
15410 .unwrap_or(Self::Unknown(node)),
15411 "match_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15412 <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
15413 })
15414 .map(Self::MatchPattern)
15415 .unwrap_or(Self::Unknown(node)),
15416 "mod_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15417 <ModItem as ::treesitter_types::FromNode>::from_node(node, src)
15418 })
15419 .map(Self::ModItem)
15420 .unwrap_or(Self::Unknown(node)),
15421 "mut_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15422 <MutPattern as ::treesitter_types::FromNode>::from_node(node, src)
15423 })
15424 .map(Self::MutPattern)
15425 .unwrap_or(Self::Unknown(node)),
15426 "negative_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15427 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15428 })
15429 .map(Self::NegativeLiteral)
15430 .unwrap_or(Self::Unknown(node)),
15431 "never_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15432 <NeverType as ::treesitter_types::FromNode>::from_node(node, src)
15433 })
15434 .map(Self::NeverType)
15435 .unwrap_or(Self::Unknown(node)),
15436 "or_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15437 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
15438 })
15439 .map(Self::OrPattern)
15440 .unwrap_or(Self::Unknown(node)),
15441 "ordered_field_declaration_list" => {
15442 ::treesitter_types::runtime::maybe_grow_stack(|| {
15443 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
15444 node, src,
15445 )
15446 })
15447 .map(Self::OrderedFieldDeclarationList)
15448 .unwrap_or(Self::Unknown(node))
15449 }
15450 "outer_doc_comment_marker" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15451 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
15452 })
15453 .map(Self::OuterDocCommentMarker)
15454 .unwrap_or(Self::Unknown(node)),
15455 "parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15456 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
15457 })
15458 .map(Self::Parameter)
15459 .unwrap_or(Self::Unknown(node)),
15460 "parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15461 <Parameters as ::treesitter_types::FromNode>::from_node(node, src)
15462 })
15463 .map(Self::Parameters)
15464 .unwrap_or(Self::Unknown(node)),
15465 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15466 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15467 })
15468 .map(Self::ParenthesizedExpression)
15469 .unwrap_or(Self::Unknown(node)),
15470 "pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15471 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
15472 })
15473 .map(Self::PointerType)
15474 .unwrap_or(Self::Unknown(node)),
15475 "qualified_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15476 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15477 })
15478 .map(Self::QualifiedType)
15479 .unwrap_or(Self::Unknown(node)),
15480 "range_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15481 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
15482 })
15483 .map(Self::RangeExpression)
15484 .unwrap_or(Self::Unknown(node)),
15485 "range_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15486 <RangePattern as ::treesitter_types::FromNode>::from_node(node, src)
15487 })
15488 .map(Self::RangePattern)
15489 .unwrap_or(Self::Unknown(node)),
15490 "raw_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15491 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15492 })
15493 .map(Self::RawStringLiteral)
15494 .unwrap_or(Self::Unknown(node)),
15495 "ref_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15496 <RefPattern as ::treesitter_types::FromNode>::from_node(node, src)
15497 })
15498 .map(Self::RefPattern)
15499 .unwrap_or(Self::Unknown(node)),
15500 "reference_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15501 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
15502 })
15503 .map(Self::ReferenceExpression)
15504 .unwrap_or(Self::Unknown(node)),
15505 "reference_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15506 <ReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
15507 })
15508 .map(Self::ReferencePattern)
15509 .unwrap_or(Self::Unknown(node)),
15510 "reference_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15511 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)
15512 })
15513 .map(Self::ReferenceType)
15514 .unwrap_or(Self::Unknown(node)),
15515 "remaining_field_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15516 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
15517 })
15518 .map(Self::RemainingFieldPattern)
15519 .unwrap_or(Self::Unknown(node)),
15520 "removed_trait_bound" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15521 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
15522 })
15523 .map(Self::RemovedTraitBound)
15524 .unwrap_or(Self::Unknown(node)),
15525 "return_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15526 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)
15527 })
15528 .map(Self::ReturnExpression)
15529 .unwrap_or(Self::Unknown(node)),
15530 "scoped_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15531 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15532 })
15533 .map(Self::ScopedIdentifier)
15534 .unwrap_or(Self::Unknown(node)),
15535 "scoped_type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15536 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15537 })
15538 .map(Self::ScopedTypeIdentifier)
15539 .unwrap_or(Self::Unknown(node)),
15540 "scoped_use_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15541 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)
15542 })
15543 .map(Self::ScopedUseList)
15544 .unwrap_or(Self::Unknown(node)),
15545 "self_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15546 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)
15547 })
15548 .map(Self::SelfParameter)
15549 .unwrap_or(Self::Unknown(node)),
15550 "shorthand_field_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15551 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15552 })
15553 .map(Self::ShorthandFieldInitializer)
15554 .unwrap_or(Self::Unknown(node)),
15555 "slice_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15556 <SlicePattern as ::treesitter_types::FromNode>::from_node(node, src)
15557 })
15558 .map(Self::SlicePattern)
15559 .unwrap_or(Self::Unknown(node)),
15560 "source_file" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15561 <SourceFile as ::treesitter_types::FromNode>::from_node(node, src)
15562 })
15563 .map(Self::SourceFile)
15564 .unwrap_or(Self::Unknown(node)),
15565 "static_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15566 <StaticItem as ::treesitter_types::FromNode>::from_node(node, src)
15567 })
15568 .map(Self::StaticItem)
15569 .unwrap_or(Self::Unknown(node)),
15570 "string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15571 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15572 })
15573 .map(Self::StringLiteral)
15574 .unwrap_or(Self::Unknown(node)),
15575 "struct_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15576 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)
15577 })
15578 .map(Self::StructExpression)
15579 .unwrap_or(Self::Unknown(node)),
15580 "struct_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15581 <StructItem as ::treesitter_types::FromNode>::from_node(node, src)
15582 })
15583 .map(Self::StructItem)
15584 .unwrap_or(Self::Unknown(node)),
15585 "struct_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15586 <StructPattern as ::treesitter_types::FromNode>::from_node(node, src)
15587 })
15588 .map(Self::StructPattern)
15589 .unwrap_or(Self::Unknown(node)),
15590 "token_binding_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15591 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)
15592 })
15593 .map(Self::TokenBindingPattern)
15594 .unwrap_or(Self::Unknown(node)),
15595 "token_repetition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15596 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)
15597 })
15598 .map(Self::TokenRepetition)
15599 .unwrap_or(Self::Unknown(node)),
15600 "token_repetition_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15601 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)
15602 })
15603 .map(Self::TokenRepetitionPattern)
15604 .unwrap_or(Self::Unknown(node)),
15605 "token_tree" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15606 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)
15607 })
15608 .map(Self::TokenTree)
15609 .unwrap_or(Self::Unknown(node)),
15610 "token_tree_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15611 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)
15612 })
15613 .map(Self::TokenTreePattern)
15614 .unwrap_or(Self::Unknown(node)),
15615 "trait_bounds" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15616 <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)
15617 })
15618 .map(Self::TraitBounds)
15619 .unwrap_or(Self::Unknown(node)),
15620 "trait_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15621 <TraitItem as ::treesitter_types::FromNode>::from_node(node, src)
15622 })
15623 .map(Self::TraitItem)
15624 .unwrap_or(Self::Unknown(node)),
15625 "try_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15626 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)
15627 })
15628 .map(Self::TryBlock)
15629 .unwrap_or(Self::Unknown(node)),
15630 "try_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15631 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15632 })
15633 .map(Self::TryExpression)
15634 .unwrap_or(Self::Unknown(node)),
15635 "tuple_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15636 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
15637 })
15638 .map(Self::TupleExpression)
15639 .unwrap_or(Self::Unknown(node)),
15640 "tuple_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15641 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
15642 })
15643 .map(Self::TuplePattern)
15644 .unwrap_or(Self::Unknown(node)),
15645 "tuple_struct_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15646 <TupleStructPattern as ::treesitter_types::FromNode>::from_node(node, src)
15647 })
15648 .map(Self::TupleStructPattern)
15649 .unwrap_or(Self::Unknown(node)),
15650 "tuple_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15651 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
15652 })
15653 .map(Self::TupleType)
15654 .unwrap_or(Self::Unknown(node)),
15655 "type_arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15656 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
15657 })
15658 .map(Self::TypeArguments)
15659 .unwrap_or(Self::Unknown(node)),
15660 "type_binding" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15661 <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)
15662 })
15663 .map(Self::TypeBinding)
15664 .unwrap_or(Self::Unknown(node)),
15665 "type_cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15666 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15667 })
15668 .map(Self::TypeCastExpression)
15669 .unwrap_or(Self::Unknown(node)),
15670 "type_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15671 <TypeItem as ::treesitter_types::FromNode>::from_node(node, src)
15672 })
15673 .map(Self::TypeItem)
15674 .unwrap_or(Self::Unknown(node)),
15675 "type_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15676 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
15677 })
15678 .map(Self::TypeParameter)
15679 .unwrap_or(Self::Unknown(node)),
15680 "type_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15681 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
15682 })
15683 .map(Self::TypeParameters)
15684 .unwrap_or(Self::Unknown(node)),
15685 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15686 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15687 })
15688 .map(Self::UnaryExpression)
15689 .unwrap_or(Self::Unknown(node)),
15690 "union_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15691 <UnionItem as ::treesitter_types::FromNode>::from_node(node, src)
15692 })
15693 .map(Self::UnionItem)
15694 .unwrap_or(Self::Unknown(node)),
15695 "unit_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15696 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)
15697 })
15698 .map(Self::UnitExpression)
15699 .unwrap_or(Self::Unknown(node)),
15700 "unit_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15701 <UnitType as ::treesitter_types::FromNode>::from_node(node, src)
15702 })
15703 .map(Self::UnitType)
15704 .unwrap_or(Self::Unknown(node)),
15705 "unsafe_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15706 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)
15707 })
15708 .map(Self::UnsafeBlock)
15709 .unwrap_or(Self::Unknown(node)),
15710 "use_as_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15711 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
15712 })
15713 .map(Self::UseAsClause)
15714 .unwrap_or(Self::Unknown(node)),
15715 "use_bounds" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15716 <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)
15717 })
15718 .map(Self::UseBounds)
15719 .unwrap_or(Self::Unknown(node)),
15720 "use_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15721 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15722 })
15723 .map(Self::UseDeclaration)
15724 .unwrap_or(Self::Unknown(node)),
15725 "use_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15726 <UseList as ::treesitter_types::FromNode>::from_node(node, src)
15727 })
15728 .map(Self::UseList)
15729 .unwrap_or(Self::Unknown(node)),
15730 "use_wildcard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15731 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)
15732 })
15733 .map(Self::UseWildcard)
15734 .unwrap_or(Self::Unknown(node)),
15735 "variadic_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15736 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
15737 })
15738 .map(Self::VariadicParameter)
15739 .unwrap_or(Self::Unknown(node)),
15740 "visibility_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15741 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
15742 })
15743 .map(Self::VisibilityModifier)
15744 .unwrap_or(Self::Unknown(node)),
15745 "where_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15746 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
15747 })
15748 .map(Self::WhereClause)
15749 .unwrap_or(Self::Unknown(node)),
15750 "where_predicate" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15751 <WherePredicate as ::treesitter_types::FromNode>::from_node(node, src)
15752 })
15753 .map(Self::WherePredicate)
15754 .unwrap_or(Self::Unknown(node)),
15755 "while_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15756 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)
15757 })
15758 .map(Self::WhileExpression)
15759 .unwrap_or(Self::Unknown(node)),
15760 "yield_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15761 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
15762 })
15763 .map(Self::YieldExpression)
15764 .unwrap_or(Self::Unknown(node)),
15765 "char_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15766 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15767 })
15768 .map(Self::CharLiteral)
15769 .unwrap_or(Self::Unknown(node)),
15770 "crate" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15771 <Crate as ::treesitter_types::FromNode>::from_node(node, src)
15772 })
15773 .map(Self::Crate)
15774 .unwrap_or(Self::Unknown(node)),
15775 "doc_comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15776 <DocComment as ::treesitter_types::FromNode>::from_node(node, src)
15777 })
15778 .map(Self::DocComment)
15779 .unwrap_or(Self::Unknown(node)),
15780 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15781 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
15782 })
15783 .map(Self::EscapeSequence)
15784 .unwrap_or(Self::Unknown(node)),
15785 "field_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15786 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15787 })
15788 .map(Self::FieldIdentifier)
15789 .unwrap_or(Self::Unknown(node)),
15790 "float_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15791 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15792 })
15793 .map(Self::FloatLiteral)
15794 .unwrap_or(Self::Unknown(node)),
15795 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15796 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
15797 })
15798 .map(Self::Identifier)
15799 .unwrap_or(Self::Unknown(node)),
15800 "integer_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15801 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15802 })
15803 .map(Self::IntegerLiteral)
15804 .unwrap_or(Self::Unknown(node)),
15805 "metavariable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15806 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
15807 })
15808 .map(Self::Metavariable)
15809 .unwrap_or(Self::Unknown(node)),
15810 "mutable_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15811 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15812 })
15813 .map(Self::MutableSpecifier)
15814 .unwrap_or(Self::Unknown(node)),
15815 "primitive_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15816 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
15817 })
15818 .map(Self::PrimitiveType)
15819 .unwrap_or(Self::Unknown(node)),
15820 "self" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15821 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
15822 })
15823 .map(Self::SelfType)
15824 .unwrap_or(Self::Unknown(node)),
15825 "shebang" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15826 <Shebang as ::treesitter_types::FromNode>::from_node(node, src)
15827 })
15828 .map(Self::Shebang)
15829 .unwrap_or(Self::Unknown(node)),
15830 "shorthand_field_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15831 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15832 })
15833 .map(Self::ShorthandFieldIdentifier)
15834 .unwrap_or(Self::Unknown(node)),
15835 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15836 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
15837 })
15838 .map(Self::StringContent)
15839 .unwrap_or(Self::Unknown(node)),
15840 "super" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15841 <Super as ::treesitter_types::FromNode>::from_node(node, src)
15842 })
15843 .map(Self::Super)
15844 .unwrap_or(Self::Unknown(node)),
15845 "type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
15846 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15847 })
15848 .map(Self::TypeIdentifier)
15849 .unwrap_or(Self::Unknown(node)),
15850 _ => Self::Unknown(node),
15851 }
15852 }
15853}
15854impl ::treesitter_types::Spanned for AnyNode<'_> {
15855 fn span(&self) -> ::treesitter_types::Span {
15856 match self {
15857 Self::DeclarationStatement(inner) => inner.span(),
15858 Self::Expression(inner) => inner.span(),
15859 Self::Literal(inner) => inner.span(),
15860 Self::LiteralPattern(inner) => inner.span(),
15861 Self::Pattern(inner) => inner.span(),
15862 Self::Type(inner) => inner.span(),
15863 Self::AbstractType(inner) => inner.span(),
15864 Self::Arguments(inner) => inner.span(),
15865 Self::ArrayExpression(inner) => inner.span(),
15866 Self::ArrayType(inner) => inner.span(),
15867 Self::AssignmentExpression(inner) => inner.span(),
15868 Self::AssociatedType(inner) => inner.span(),
15869 Self::AsyncBlock(inner) => inner.span(),
15870 Self::Attribute(inner) => inner.span(),
15871 Self::AttributeItem(inner) => inner.span(),
15872 Self::AwaitExpression(inner) => inner.span(),
15873 Self::BaseFieldInitializer(inner) => inner.span(),
15874 Self::BinaryExpression(inner) => inner.span(),
15875 Self::Block(inner) => inner.span(),
15876 Self::BlockComment(inner) => inner.span(),
15877 Self::BooleanLiteral(inner) => inner.span(),
15878 Self::BoundedType(inner) => inner.span(),
15879 Self::BracketedType(inner) => inner.span(),
15880 Self::BreakExpression(inner) => inner.span(),
15881 Self::CallExpression(inner) => inner.span(),
15882 Self::CapturedPattern(inner) => inner.span(),
15883 Self::ClosureExpression(inner) => inner.span(),
15884 Self::ClosureParameters(inner) => inner.span(),
15885 Self::CompoundAssignmentExpr(inner) => inner.span(),
15886 Self::ConstBlock(inner) => inner.span(),
15887 Self::ConstItem(inner) => inner.span(),
15888 Self::ConstParameter(inner) => inner.span(),
15889 Self::ContinueExpression(inner) => inner.span(),
15890 Self::DeclarationList(inner) => inner.span(),
15891 Self::DynamicType(inner) => inner.span(),
15892 Self::ElseClause(inner) => inner.span(),
15893 Self::EmptyStatement(inner) => inner.span(),
15894 Self::EnumItem(inner) => inner.span(),
15895 Self::EnumVariant(inner) => inner.span(),
15896 Self::EnumVariantList(inner) => inner.span(),
15897 Self::ExpressionStatement(inner) => inner.span(),
15898 Self::ExternCrateDeclaration(inner) => inner.span(),
15899 Self::ExternModifier(inner) => inner.span(),
15900 Self::FieldDeclaration(inner) => inner.span(),
15901 Self::FieldDeclarationList(inner) => inner.span(),
15902 Self::FieldExpression(inner) => inner.span(),
15903 Self::FieldInitializer(inner) => inner.span(),
15904 Self::FieldInitializerList(inner) => inner.span(),
15905 Self::FieldPattern(inner) => inner.span(),
15906 Self::ForExpression(inner) => inner.span(),
15907 Self::ForLifetimes(inner) => inner.span(),
15908 Self::ForeignModItem(inner) => inner.span(),
15909 Self::FragmentSpecifier(inner) => inner.span(),
15910 Self::FunctionItem(inner) => inner.span(),
15911 Self::FunctionModifiers(inner) => inner.span(),
15912 Self::FunctionSignatureItem(inner) => inner.span(),
15913 Self::FunctionType(inner) => inner.span(),
15914 Self::GenBlock(inner) => inner.span(),
15915 Self::GenericFunction(inner) => inner.span(),
15916 Self::GenericPattern(inner) => inner.span(),
15917 Self::GenericType(inner) => inner.span(),
15918 Self::GenericTypeWithTurbofish(inner) => inner.span(),
15919 Self::HigherRankedTraitBound(inner) => inner.span(),
15920 Self::IfExpression(inner) => inner.span(),
15921 Self::ImplItem(inner) => inner.span(),
15922 Self::IndexExpression(inner) => inner.span(),
15923 Self::InnerAttributeItem(inner) => inner.span(),
15924 Self::InnerDocCommentMarker(inner) => inner.span(),
15925 Self::Label(inner) => inner.span(),
15926 Self::LetChain(inner) => inner.span(),
15927 Self::LetCondition(inner) => inner.span(),
15928 Self::LetDeclaration(inner) => inner.span(),
15929 Self::Lifetime(inner) => inner.span(),
15930 Self::LifetimeParameter(inner) => inner.span(),
15931 Self::LineComment(inner) => inner.span(),
15932 Self::LoopExpression(inner) => inner.span(),
15933 Self::MacroDefinition(inner) => inner.span(),
15934 Self::MacroInvocation(inner) => inner.span(),
15935 Self::MacroRule(inner) => inner.span(),
15936 Self::MatchArm(inner) => inner.span(),
15937 Self::MatchBlock(inner) => inner.span(),
15938 Self::MatchExpression(inner) => inner.span(),
15939 Self::MatchPattern(inner) => inner.span(),
15940 Self::ModItem(inner) => inner.span(),
15941 Self::MutPattern(inner) => inner.span(),
15942 Self::NegativeLiteral(inner) => inner.span(),
15943 Self::NeverType(inner) => inner.span(),
15944 Self::OrPattern(inner) => inner.span(),
15945 Self::OrderedFieldDeclarationList(inner) => inner.span(),
15946 Self::OuterDocCommentMarker(inner) => inner.span(),
15947 Self::Parameter(inner) => inner.span(),
15948 Self::Parameters(inner) => inner.span(),
15949 Self::ParenthesizedExpression(inner) => inner.span(),
15950 Self::PointerType(inner) => inner.span(),
15951 Self::QualifiedType(inner) => inner.span(),
15952 Self::RangeExpression(inner) => inner.span(),
15953 Self::RangePattern(inner) => inner.span(),
15954 Self::RawStringLiteral(inner) => inner.span(),
15955 Self::RefPattern(inner) => inner.span(),
15956 Self::ReferenceExpression(inner) => inner.span(),
15957 Self::ReferencePattern(inner) => inner.span(),
15958 Self::ReferenceType(inner) => inner.span(),
15959 Self::RemainingFieldPattern(inner) => inner.span(),
15960 Self::RemovedTraitBound(inner) => inner.span(),
15961 Self::ReturnExpression(inner) => inner.span(),
15962 Self::ScopedIdentifier(inner) => inner.span(),
15963 Self::ScopedTypeIdentifier(inner) => inner.span(),
15964 Self::ScopedUseList(inner) => inner.span(),
15965 Self::SelfParameter(inner) => inner.span(),
15966 Self::ShorthandFieldInitializer(inner) => inner.span(),
15967 Self::SlicePattern(inner) => inner.span(),
15968 Self::SourceFile(inner) => inner.span(),
15969 Self::StaticItem(inner) => inner.span(),
15970 Self::StringLiteral(inner) => inner.span(),
15971 Self::StructExpression(inner) => inner.span(),
15972 Self::StructItem(inner) => inner.span(),
15973 Self::StructPattern(inner) => inner.span(),
15974 Self::TokenBindingPattern(inner) => inner.span(),
15975 Self::TokenRepetition(inner) => inner.span(),
15976 Self::TokenRepetitionPattern(inner) => inner.span(),
15977 Self::TokenTree(inner) => inner.span(),
15978 Self::TokenTreePattern(inner) => inner.span(),
15979 Self::TraitBounds(inner) => inner.span(),
15980 Self::TraitItem(inner) => inner.span(),
15981 Self::TryBlock(inner) => inner.span(),
15982 Self::TryExpression(inner) => inner.span(),
15983 Self::TupleExpression(inner) => inner.span(),
15984 Self::TuplePattern(inner) => inner.span(),
15985 Self::TupleStructPattern(inner) => inner.span(),
15986 Self::TupleType(inner) => inner.span(),
15987 Self::TypeArguments(inner) => inner.span(),
15988 Self::TypeBinding(inner) => inner.span(),
15989 Self::TypeCastExpression(inner) => inner.span(),
15990 Self::TypeItem(inner) => inner.span(),
15991 Self::TypeParameter(inner) => inner.span(),
15992 Self::TypeParameters(inner) => inner.span(),
15993 Self::UnaryExpression(inner) => inner.span(),
15994 Self::UnionItem(inner) => inner.span(),
15995 Self::UnitExpression(inner) => inner.span(),
15996 Self::UnitType(inner) => inner.span(),
15997 Self::UnsafeBlock(inner) => inner.span(),
15998 Self::UseAsClause(inner) => inner.span(),
15999 Self::UseBounds(inner) => inner.span(),
16000 Self::UseDeclaration(inner) => inner.span(),
16001 Self::UseList(inner) => inner.span(),
16002 Self::UseWildcard(inner) => inner.span(),
16003 Self::VariadicParameter(inner) => inner.span(),
16004 Self::VisibilityModifier(inner) => inner.span(),
16005 Self::WhereClause(inner) => inner.span(),
16006 Self::WherePredicate(inner) => inner.span(),
16007 Self::WhileExpression(inner) => inner.span(),
16008 Self::YieldExpression(inner) => inner.span(),
16009 Self::CharLiteral(inner) => inner.span(),
16010 Self::Crate(inner) => inner.span(),
16011 Self::DocComment(inner) => inner.span(),
16012 Self::EscapeSequence(inner) => inner.span(),
16013 Self::FieldIdentifier(inner) => inner.span(),
16014 Self::FloatLiteral(inner) => inner.span(),
16015 Self::Identifier(inner) => inner.span(),
16016 Self::IntegerLiteral(inner) => inner.span(),
16017 Self::Metavariable(inner) => inner.span(),
16018 Self::MutableSpecifier(inner) => inner.span(),
16019 Self::PrimitiveType(inner) => inner.span(),
16020 Self::SelfType(inner) => inner.span(),
16021 Self::Shebang(inner) => inner.span(),
16022 Self::ShorthandFieldIdentifier(inner) => inner.span(),
16023 Self::StringContent(inner) => inner.span(),
16024 Self::Super(inner) => inner.span(),
16025 Self::TypeIdentifier(inner) => inner.span(),
16026 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
16027 }
16028 }
16029}