1#[derive(Debug, Clone)]
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: ::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 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)?,
34 ))),
35 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
36 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
37 ))),
38 "const_item" => Ok(Self::ConstItem(::std::boxed::Box::new(
39 <ConstItem as ::treesitter_types::FromNode>::from_node(node, src)?,
40 ))),
41 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
42 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
43 ))),
44 "enum_item" => Ok(Self::EnumItem(::std::boxed::Box::new(
45 <EnumItem as ::treesitter_types::FromNode>::from_node(node, src)?,
46 ))),
47 "extern_crate_declaration" => Ok(Self::ExternCrateDeclaration(::std::boxed::Box::new(
48 <ExternCrateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
49 ))),
50 "foreign_mod_item" => Ok(Self::ForeignModItem(::std::boxed::Box::new(
51 <ForeignModItem as ::treesitter_types::FromNode>::from_node(node, src)?,
52 ))),
53 "function_item" => Ok(Self::FunctionItem(::std::boxed::Box::new(
54 <FunctionItem as ::treesitter_types::FromNode>::from_node(node, src)?,
55 ))),
56 "function_signature_item" => Ok(Self::FunctionSignatureItem(::std::boxed::Box::new(
57 <FunctionSignatureItem as ::treesitter_types::FromNode>::from_node(node, src)?,
58 ))),
59 "impl_item" => Ok(Self::ImplItem(::std::boxed::Box::new(
60 <ImplItem as ::treesitter_types::FromNode>::from_node(node, src)?,
61 ))),
62 "inner_attribute_item" => Ok(Self::InnerAttributeItem(::std::boxed::Box::new(
63 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
64 ))),
65 "let_declaration" => Ok(Self::LetDeclaration(::std::boxed::Box::new(
66 <LetDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
67 ))),
68 "macro_definition" => Ok(Self::MacroDefinition(::std::boxed::Box::new(
69 <MacroDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
70 ))),
71 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
72 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
73 ))),
74 "mod_item" => Ok(Self::ModItem(::std::boxed::Box::new(
75 <ModItem as ::treesitter_types::FromNode>::from_node(node, src)?,
76 ))),
77 "static_item" => Ok(Self::StaticItem(::std::boxed::Box::new(
78 <StaticItem as ::treesitter_types::FromNode>::from_node(node, src)?,
79 ))),
80 "struct_item" => Ok(Self::StructItem(::std::boxed::Box::new(
81 <StructItem as ::treesitter_types::FromNode>::from_node(node, src)?,
82 ))),
83 "trait_item" => Ok(Self::TraitItem(::std::boxed::Box::new(
84 <TraitItem as ::treesitter_types::FromNode>::from_node(node, src)?,
85 ))),
86 "type_item" => Ok(Self::TypeItem(::std::boxed::Box::new(
87 <TypeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
88 ))),
89 "union_item" => Ok(Self::UnionItem(::std::boxed::Box::new(
90 <UnionItem as ::treesitter_types::FromNode>::from_node(node, src)?,
91 ))),
92 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
93 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
94 ))),
95 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
96 }
97 }
98}
99impl ::treesitter_types::Spanned for DeclarationStatement<'_> {
100 fn span(&self) -> ::treesitter_types::Span {
101 match self {
102 Self::AssociatedType(inner) => inner.span(),
103 Self::AttributeItem(inner) => inner.span(),
104 Self::ConstItem(inner) => inner.span(),
105 Self::EmptyStatement(inner) => inner.span(),
106 Self::EnumItem(inner) => inner.span(),
107 Self::ExternCrateDeclaration(inner) => inner.span(),
108 Self::ForeignModItem(inner) => inner.span(),
109 Self::FunctionItem(inner) => inner.span(),
110 Self::FunctionSignatureItem(inner) => inner.span(),
111 Self::ImplItem(inner) => inner.span(),
112 Self::InnerAttributeItem(inner) => inner.span(),
113 Self::LetDeclaration(inner) => inner.span(),
114 Self::MacroDefinition(inner) => inner.span(),
115 Self::MacroInvocation(inner) => inner.span(),
116 Self::ModItem(inner) => inner.span(),
117 Self::StaticItem(inner) => inner.span(),
118 Self::StructItem(inner) => inner.span(),
119 Self::TraitItem(inner) => inner.span(),
120 Self::TypeItem(inner) => inner.span(),
121 Self::UnionItem(inner) => inner.span(),
122 Self::UseDeclaration(inner) => inner.span(),
123 }
124 }
125}
126#[derive(Debug, Clone)]
127pub enum Expression<'tree> {
128 Literal(::std::boxed::Box<Literal<'tree>>),
129 ArrayExpression(::std::boxed::Box<ArrayExpression<'tree>>),
130 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
131 AsyncBlock(::std::boxed::Box<AsyncBlock<'tree>>),
132 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
133 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
134 Block(::std::boxed::Box<Block<'tree>>),
135 BreakExpression(::std::boxed::Box<BreakExpression<'tree>>),
136 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
137 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
138 CompoundAssignmentExpr(::std::boxed::Box<CompoundAssignmentExpr<'tree>>),
139 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
140 ContinueExpression(::std::boxed::Box<ContinueExpression<'tree>>),
141 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
142 ForExpression(::std::boxed::Box<ForExpression<'tree>>),
143 GenBlock(::std::boxed::Box<GenBlock<'tree>>),
144 GenericFunction(::std::boxed::Box<GenericFunction<'tree>>),
145 Identifier(::std::boxed::Box<Identifier<'tree>>),
146 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
147 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
148 LoopExpression(::std::boxed::Box<LoopExpression<'tree>>),
149 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
150 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
151 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
152 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
153 RangeExpression(::std::boxed::Box<RangeExpression<'tree>>),
154 ReferenceExpression(::std::boxed::Box<ReferenceExpression<'tree>>),
155 ReturnExpression(::std::boxed::Box<ReturnExpression<'tree>>),
156 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
157 SelfType(::std::boxed::Box<SelfType<'tree>>),
158 StructExpression(::std::boxed::Box<StructExpression<'tree>>),
159 TryBlock(::std::boxed::Box<TryBlock<'tree>>),
160 TryExpression(::std::boxed::Box<TryExpression<'tree>>),
161 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
162 TypeCastExpression(::std::boxed::Box<TypeCastExpression<'tree>>),
163 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
164 UnitExpression(::std::boxed::Box<UnitExpression<'tree>>),
165 UnsafeBlock(::std::boxed::Box<UnsafeBlock<'tree>>),
166 WhileExpression(::std::boxed::Box<WhileExpression<'tree>>),
167 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
168}
169impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
170 #[allow(clippy::collapsible_else_if)]
171 fn from_node(
172 node: ::tree_sitter::Node<'tree>,
173 src: &'tree [u8],
174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
175 match node.kind() {
176 "array_expression" => Ok(Self::ArrayExpression(::std::boxed::Box::new(
177 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
178 ))),
179 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
180 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
181 ))),
182 "async_block" => Ok(Self::AsyncBlock(::std::boxed::Box::new(
183 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
184 ))),
185 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
186 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
187 ))),
188 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
189 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
190 ))),
191 "block" => Ok(Self::Block(::std::boxed::Box::new(
192 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
193 ))),
194 "break_expression" => Ok(Self::BreakExpression(::std::boxed::Box::new(
195 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
196 ))),
197 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
198 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
199 ))),
200 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
201 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
202 ))),
203 "compound_assignment_expr" => Ok(Self::CompoundAssignmentExpr(::std::boxed::Box::new(
204 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)?,
205 ))),
206 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
207 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
208 ))),
209 "continue_expression" => Ok(Self::ContinueExpression(::std::boxed::Box::new(
210 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
211 ))),
212 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
213 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
214 ))),
215 "for_expression" => Ok(Self::ForExpression(::std::boxed::Box::new(
216 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
217 ))),
218 "gen_block" => Ok(Self::GenBlock(::std::boxed::Box::new(
219 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
220 ))),
221 "generic_function" => Ok(Self::GenericFunction(::std::boxed::Box::new(
222 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
223 ))),
224 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
225 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
226 ))),
227 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
228 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
229 ))),
230 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
231 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
232 ))),
233 "loop_expression" => Ok(Self::LoopExpression(::std::boxed::Box::new(
234 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
235 ))),
236 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
237 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
238 ))),
239 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
240 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
241 ))),
242 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
243 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
244 ))),
245 "parenthesized_expression" => {
246 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
247 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
248 node, src,
249 )?,
250 )))
251 }
252 "range_expression" => Ok(Self::RangeExpression(::std::boxed::Box::new(
253 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
254 ))),
255 "reference_expression" => Ok(Self::ReferenceExpression(::std::boxed::Box::new(
256 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
257 ))),
258 "return_expression" => Ok(Self::ReturnExpression(::std::boxed::Box::new(
259 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
260 ))),
261 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
262 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
263 ))),
264 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
265 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
266 ))),
267 "struct_expression" => Ok(Self::StructExpression(::std::boxed::Box::new(
268 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
269 ))),
270 "try_block" => Ok(Self::TryBlock(::std::boxed::Box::new(
271 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
272 ))),
273 "try_expression" => Ok(Self::TryExpression(::std::boxed::Box::new(
274 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
275 ))),
276 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
277 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
278 ))),
279 "type_cast_expression" => Ok(Self::TypeCastExpression(::std::boxed::Box::new(
280 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
281 ))),
282 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
283 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
284 ))),
285 "unit_expression" => Ok(Self::UnitExpression(::std::boxed::Box::new(
286 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
287 ))),
288 "unsafe_block" => Ok(Self::UnsafeBlock(::std::boxed::Box::new(
289 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
290 ))),
291 "while_expression" => Ok(Self::WhileExpression(::std::boxed::Box::new(
292 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
293 ))),
294 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
295 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
296 ))),
297 _other => {
298 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
299 Ok(Self::Literal(::std::boxed::Box::new(v)))
300 } else {
301 Err(::treesitter_types::ParseError::unexpected_kind(
302 _other, node,
303 ))
304 }
305 }
306 }
307 }
308}
309impl ::treesitter_types::Spanned for Expression<'_> {
310 fn span(&self) -> ::treesitter_types::Span {
311 match self {
312 Self::Literal(inner) => inner.span(),
313 Self::ArrayExpression(inner) => inner.span(),
314 Self::AssignmentExpression(inner) => inner.span(),
315 Self::AsyncBlock(inner) => inner.span(),
316 Self::AwaitExpression(inner) => inner.span(),
317 Self::BinaryExpression(inner) => inner.span(),
318 Self::Block(inner) => inner.span(),
319 Self::BreakExpression(inner) => inner.span(),
320 Self::CallExpression(inner) => inner.span(),
321 Self::ClosureExpression(inner) => inner.span(),
322 Self::CompoundAssignmentExpr(inner) => inner.span(),
323 Self::ConstBlock(inner) => inner.span(),
324 Self::ContinueExpression(inner) => inner.span(),
325 Self::FieldExpression(inner) => inner.span(),
326 Self::ForExpression(inner) => inner.span(),
327 Self::GenBlock(inner) => inner.span(),
328 Self::GenericFunction(inner) => inner.span(),
329 Self::Identifier(inner) => inner.span(),
330 Self::IfExpression(inner) => inner.span(),
331 Self::IndexExpression(inner) => inner.span(),
332 Self::LoopExpression(inner) => inner.span(),
333 Self::MacroInvocation(inner) => inner.span(),
334 Self::MatchExpression(inner) => inner.span(),
335 Self::Metavariable(inner) => inner.span(),
336 Self::ParenthesizedExpression(inner) => inner.span(),
337 Self::RangeExpression(inner) => inner.span(),
338 Self::ReferenceExpression(inner) => inner.span(),
339 Self::ReturnExpression(inner) => inner.span(),
340 Self::ScopedIdentifier(inner) => inner.span(),
341 Self::SelfType(inner) => inner.span(),
342 Self::StructExpression(inner) => inner.span(),
343 Self::TryBlock(inner) => inner.span(),
344 Self::TryExpression(inner) => inner.span(),
345 Self::TupleExpression(inner) => inner.span(),
346 Self::TypeCastExpression(inner) => inner.span(),
347 Self::UnaryExpression(inner) => inner.span(),
348 Self::UnitExpression(inner) => inner.span(),
349 Self::UnsafeBlock(inner) => inner.span(),
350 Self::WhileExpression(inner) => inner.span(),
351 Self::YieldExpression(inner) => inner.span(),
352 }
353 }
354}
355#[derive(Debug, Clone)]
356pub enum Literal<'tree> {
357 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
358 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
359 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
360 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
361 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
362 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
363}
364impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
365 #[allow(clippy::collapsible_else_if)]
366 fn from_node(
367 node: ::tree_sitter::Node<'tree>,
368 src: &'tree [u8],
369 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
370 match node.kind() {
371 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
372 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
373 ))),
374 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
375 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
376 ))),
377 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
378 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
379 ))),
380 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
381 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
382 ))),
383 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
384 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
385 ))),
386 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
387 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
388 ))),
389 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
390 }
391 }
392}
393impl ::treesitter_types::Spanned for Literal<'_> {
394 fn span(&self) -> ::treesitter_types::Span {
395 match self {
396 Self::BooleanLiteral(inner) => inner.span(),
397 Self::CharLiteral(inner) => inner.span(),
398 Self::FloatLiteral(inner) => inner.span(),
399 Self::IntegerLiteral(inner) => inner.span(),
400 Self::RawStringLiteral(inner) => inner.span(),
401 Self::StringLiteral(inner) => inner.span(),
402 }
403 }
404}
405#[derive(Debug, Clone)]
406pub enum LiteralPattern<'tree> {
407 BooleanLiteral(::std::boxed::Box<BooleanLiteral<'tree>>),
408 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
409 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
410 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
411 NegativeLiteral(::std::boxed::Box<NegativeLiteral<'tree>>),
412 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
413 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
414}
415impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralPattern<'tree> {
416 #[allow(clippy::collapsible_else_if)]
417 fn from_node(
418 node: ::tree_sitter::Node<'tree>,
419 src: &'tree [u8],
420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
421 match node.kind() {
422 "boolean_literal" => Ok(Self::BooleanLiteral(::std::boxed::Box::new(
423 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
424 ))),
425 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
426 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
427 ))),
428 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
429 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
430 ))),
431 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
432 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
433 ))),
434 "negative_literal" => Ok(Self::NegativeLiteral(::std::boxed::Box::new(
435 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
436 ))),
437 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
438 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
439 ))),
440 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
441 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
442 ))),
443 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
444 }
445 }
446}
447impl ::treesitter_types::Spanned for LiteralPattern<'_> {
448 fn span(&self) -> ::treesitter_types::Span {
449 match self {
450 Self::BooleanLiteral(inner) => inner.span(),
451 Self::CharLiteral(inner) => inner.span(),
452 Self::FloatLiteral(inner) => inner.span(),
453 Self::IntegerLiteral(inner) => inner.span(),
454 Self::NegativeLiteral(inner) => inner.span(),
455 Self::RawStringLiteral(inner) => inner.span(),
456 Self::StringLiteral(inner) => inner.span(),
457 }
458 }
459}
460#[derive(Debug, Clone)]
461pub enum Pattern<'tree> {
462 Blank(::treesitter_types::Span),
463 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
464 CapturedPattern(::std::boxed::Box<CapturedPattern<'tree>>),
465 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
466 GenericPattern(::std::boxed::Box<GenericPattern<'tree>>),
467 Identifier(::std::boxed::Box<Identifier<'tree>>),
468 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
469 MutPattern(::std::boxed::Box<MutPattern<'tree>>),
470 OrPattern(::std::boxed::Box<OrPattern<'tree>>),
471 RangePattern(::std::boxed::Box<RangePattern<'tree>>),
472 RefPattern(::std::boxed::Box<RefPattern<'tree>>),
473 ReferencePattern(::std::boxed::Box<ReferencePattern<'tree>>),
474 RemainingFieldPattern(::std::boxed::Box<RemainingFieldPattern<'tree>>),
475 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
476 SlicePattern(::std::boxed::Box<SlicePattern<'tree>>),
477 StructPattern(::std::boxed::Box<StructPattern<'tree>>),
478 TuplePattern(::std::boxed::Box<TuplePattern<'tree>>),
479 TupleStructPattern(::std::boxed::Box<TupleStructPattern<'tree>>),
480}
481impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
482 #[allow(clippy::collapsible_else_if)]
483 fn from_node(
484 node: ::tree_sitter::Node<'tree>,
485 src: &'tree [u8],
486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
487 match node.kind() {
488 "_" => Ok(Self::Blank(::treesitter_types::Span::from(node))),
489 "captured_pattern" => Ok(Self::CapturedPattern(::std::boxed::Box::new(
490 <CapturedPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
491 ))),
492 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
493 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
494 ))),
495 "generic_pattern" => Ok(Self::GenericPattern(::std::boxed::Box::new(
496 <GenericPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
497 ))),
498 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
499 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
500 ))),
501 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
502 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
503 ))),
504 "mut_pattern" => Ok(Self::MutPattern(::std::boxed::Box::new(
505 <MutPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
506 ))),
507 "or_pattern" => Ok(Self::OrPattern(::std::boxed::Box::new(
508 <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
509 ))),
510 "range_pattern" => Ok(Self::RangePattern(::std::boxed::Box::new(
511 <RangePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
512 ))),
513 "ref_pattern" => Ok(Self::RefPattern(::std::boxed::Box::new(
514 <RefPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
515 ))),
516 "reference_pattern" => Ok(Self::ReferencePattern(::std::boxed::Box::new(
517 <ReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
518 ))),
519 "remaining_field_pattern" => Ok(Self::RemainingFieldPattern(::std::boxed::Box::new(
520 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
521 ))),
522 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
523 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
524 ))),
525 "slice_pattern" => Ok(Self::SlicePattern(::std::boxed::Box::new(
526 <SlicePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
527 ))),
528 "struct_pattern" => Ok(Self::StructPattern(::std::boxed::Box::new(
529 <StructPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
530 ))),
531 "tuple_pattern" => Ok(Self::TuplePattern(::std::boxed::Box::new(
532 <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
533 ))),
534 "tuple_struct_pattern" => Ok(Self::TupleStructPattern(::std::boxed::Box::new(
535 <TupleStructPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
536 ))),
537 _other => {
538 if let Ok(v) =
539 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
540 {
541 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
542 } else {
543 Err(::treesitter_types::ParseError::unexpected_kind(
544 _other, node,
545 ))
546 }
547 }
548 }
549 }
550}
551impl ::treesitter_types::Spanned for Pattern<'_> {
552 fn span(&self) -> ::treesitter_types::Span {
553 match self {
554 Self::Blank(span) => *span,
555 Self::LiteralPattern(inner) => inner.span(),
556 Self::CapturedPattern(inner) => inner.span(),
557 Self::ConstBlock(inner) => inner.span(),
558 Self::GenericPattern(inner) => inner.span(),
559 Self::Identifier(inner) => inner.span(),
560 Self::MacroInvocation(inner) => inner.span(),
561 Self::MutPattern(inner) => inner.span(),
562 Self::OrPattern(inner) => inner.span(),
563 Self::RangePattern(inner) => inner.span(),
564 Self::RefPattern(inner) => inner.span(),
565 Self::ReferencePattern(inner) => inner.span(),
566 Self::RemainingFieldPattern(inner) => inner.span(),
567 Self::ScopedIdentifier(inner) => inner.span(),
568 Self::SlicePattern(inner) => inner.span(),
569 Self::StructPattern(inner) => inner.span(),
570 Self::TuplePattern(inner) => inner.span(),
571 Self::TupleStructPattern(inner) => inner.span(),
572 }
573 }
574}
575#[derive(Debug, Clone)]
576pub enum Type<'tree> {
577 AbstractType(::std::boxed::Box<AbstractType<'tree>>),
578 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
579 BoundedType(::std::boxed::Box<BoundedType<'tree>>),
580 DynamicType(::std::boxed::Box<DynamicType<'tree>>),
581 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
582 GenericType(::std::boxed::Box<GenericType<'tree>>),
583 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
584 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
585 NeverType(::std::boxed::Box<NeverType<'tree>>),
586 PointerType(::std::boxed::Box<PointerType<'tree>>),
587 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
588 ReferenceType(::std::boxed::Box<ReferenceType<'tree>>),
589 RemovedTraitBound(::std::boxed::Box<RemovedTraitBound<'tree>>),
590 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
591 TupleType(::std::boxed::Box<TupleType<'tree>>),
592 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
593 UnitType(::std::boxed::Box<UnitType<'tree>>),
594}
595impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
596 #[allow(clippy::collapsible_else_if)]
597 fn from_node(
598 node: ::tree_sitter::Node<'tree>,
599 src: &'tree [u8],
600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
601 match node.kind() {
602 "abstract_type" => Ok(Self::AbstractType(::std::boxed::Box::new(
603 <AbstractType as ::treesitter_types::FromNode>::from_node(node, src)?,
604 ))),
605 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
606 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
607 ))),
608 "bounded_type" => Ok(Self::BoundedType(::std::boxed::Box::new(
609 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)?,
610 ))),
611 "dynamic_type" => Ok(Self::DynamicType(::std::boxed::Box::new(
612 <DynamicType as ::treesitter_types::FromNode>::from_node(node, src)?,
613 ))),
614 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
615 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
616 ))),
617 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
618 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
619 ))),
620 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
621 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
622 ))),
623 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
624 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
625 ))),
626 "never_type" => Ok(Self::NeverType(::std::boxed::Box::new(
627 <NeverType as ::treesitter_types::FromNode>::from_node(node, src)?,
628 ))),
629 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
630 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
631 ))),
632 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
633 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
634 ))),
635 "reference_type" => Ok(Self::ReferenceType(::std::boxed::Box::new(
636 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)?,
637 ))),
638 "removed_trait_bound" => Ok(Self::RemovedTraitBound(::std::boxed::Box::new(
639 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
640 ))),
641 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
642 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
643 ))),
644 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
645 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
646 ))),
647 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
648 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
649 ))),
650 "unit_type" => Ok(Self::UnitType(::std::boxed::Box::new(
651 <UnitType as ::treesitter_types::FromNode>::from_node(node, src)?,
652 ))),
653 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
654 }
655 }
656}
657impl ::treesitter_types::Spanned for Type<'_> {
658 fn span(&self) -> ::treesitter_types::Span {
659 match self {
660 Self::AbstractType(inner) => inner.span(),
661 Self::ArrayType(inner) => inner.span(),
662 Self::BoundedType(inner) => inner.span(),
663 Self::DynamicType(inner) => inner.span(),
664 Self::FunctionType(inner) => inner.span(),
665 Self::GenericType(inner) => inner.span(),
666 Self::MacroInvocation(inner) => inner.span(),
667 Self::Metavariable(inner) => inner.span(),
668 Self::NeverType(inner) => inner.span(),
669 Self::PointerType(inner) => inner.span(),
670 Self::PrimitiveType(inner) => inner.span(),
671 Self::ReferenceType(inner) => inner.span(),
672 Self::RemovedTraitBound(inner) => inner.span(),
673 Self::ScopedTypeIdentifier(inner) => inner.span(),
674 Self::TupleType(inner) => inner.span(),
675 Self::TypeIdentifier(inner) => inner.span(),
676 Self::UnitType(inner) => inner.span(),
677 }
678 }
679}
680#[derive(Debug, Clone)]
681pub struct AbstractType<'tree> {
682 pub span: ::treesitter_types::Span,
683 pub r#trait: AbstractTypeTrait<'tree>,
684 pub children: ::core::option::Option<TypeParameters<'tree>>,
685}
686impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractType<'tree> {
687 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
688 fn from_node(
689 node: ::tree_sitter::Node<'tree>,
690 src: &'tree [u8],
691 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
692 debug_assert_eq!(node.kind(), "abstract_type");
693 Ok(Self {
694 span: ::treesitter_types::Span::from(node),
695 r#trait: {
696 let child = node
697 .child_by_field_name("trait")
698 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("trait", node))?;
699 <AbstractTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)?
700 },
701 children: {
702 #[allow(clippy::suspicious_else_formatting)]
703 let non_field_children = {
704 let mut cursor = node.walk();
705 let mut result = ::std::vec::Vec::new();
706 if cursor.goto_first_child() {
707 loop {
708 if cursor.field_name().is_none()
709 && cursor.node().is_named()
710 && !cursor.node().is_extra()
711 {
712 result.push(cursor.node());
713 }
714 if !cursor.goto_next_sibling() {
715 break;
716 }
717 }
718 }
719 result
720 };
721 match non_field_children.first() {
722 Some(&child) => Some(
723 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)?,
724 ),
725 None => None,
726 }
727 },
728 })
729 }
730}
731impl ::treesitter_types::Spanned for AbstractType<'_> {
732 fn span(&self) -> ::treesitter_types::Span {
733 self.span
734 }
735}
736#[derive(Debug, Clone)]
737pub struct Arguments<'tree> {
738 pub span: ::treesitter_types::Span,
739 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
740}
741impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
742 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
743 fn from_node(
744 node: ::tree_sitter::Node<'tree>,
745 src: &'tree [u8],
746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
747 debug_assert_eq!(node.kind(), "arguments");
748 Ok(Self {
749 span: ::treesitter_types::Span::from(node),
750 children: {
751 #[allow(clippy::suspicious_else_formatting)]
752 let non_field_children = {
753 let mut cursor = node.walk();
754 let mut result = ::std::vec::Vec::new();
755 if cursor.goto_first_child() {
756 loop {
757 if cursor.field_name().is_none()
758 && cursor.node().is_named()
759 && !cursor.node().is_extra()
760 {
761 result.push(cursor.node());
762 }
763 if !cursor.goto_next_sibling() {
764 break;
765 }
766 }
767 }
768 result
769 };
770 let mut items = ::std::vec::Vec::new();
771 for child in non_field_children {
772 items.push(
773 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
774 );
775 }
776 items
777 },
778 })
779 }
780}
781impl ::treesitter_types::Spanned for Arguments<'_> {
782 fn span(&self) -> ::treesitter_types::Span {
783 self.span
784 }
785}
786#[derive(Debug, Clone)]
787pub struct ArrayExpression<'tree> {
788 pub span: ::treesitter_types::Span,
789 pub length: ::core::option::Option<Expression<'tree>>,
790 pub children: ::std::vec::Vec<ArrayExpressionChildren<'tree>>,
791}
792impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayExpression<'tree> {
793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
794 fn from_node(
795 node: ::tree_sitter::Node<'tree>,
796 src: &'tree [u8],
797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
798 debug_assert_eq!(node.kind(), "array_expression");
799 Ok(Self {
800 span: ::treesitter_types::Span::from(node),
801 length: match node.child_by_field_name("length") {
802 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
803 child, src,
804 )?),
805 None => None,
806 },
807 children: {
808 #[allow(clippy::suspicious_else_formatting)]
809 let non_field_children = {
810 let mut cursor = node.walk();
811 let mut result = ::std::vec::Vec::new();
812 if cursor.goto_first_child() {
813 loop {
814 if cursor.field_name().is_none()
815 && cursor.node().is_named()
816 && !cursor.node().is_extra()
817 {
818 result.push(cursor.node());
819 }
820 if !cursor.goto_next_sibling() {
821 break;
822 }
823 }
824 }
825 result
826 };
827 let mut items = ::std::vec::Vec::new();
828 for child in non_field_children {
829 items.push(
830 <ArrayExpressionChildren as ::treesitter_types::FromNode>::from_node(
831 child, src,
832 )?,
833 );
834 }
835 items
836 },
837 })
838 }
839}
840impl ::treesitter_types::Spanned for ArrayExpression<'_> {
841 fn span(&self) -> ::treesitter_types::Span {
842 self.span
843 }
844}
845#[derive(Debug, Clone)]
846pub struct ArrayType<'tree> {
847 pub span: ::treesitter_types::Span,
848 pub element: Type<'tree>,
849 pub length: ::core::option::Option<Expression<'tree>>,
850}
851impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
852 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
853 fn from_node(
854 node: ::tree_sitter::Node<'tree>,
855 src: &'tree [u8],
856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
857 debug_assert_eq!(node.kind(), "array_type");
858 Ok(Self {
859 span: ::treesitter_types::Span::from(node),
860 element: {
861 let child = node.child_by_field_name("element").ok_or_else(|| {
862 ::treesitter_types::ParseError::missing_field("element", node)
863 })?;
864 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
865 },
866 length: match node.child_by_field_name("length") {
867 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
868 child, src,
869 )?),
870 None => None,
871 },
872 })
873 }
874}
875impl ::treesitter_types::Spanned for ArrayType<'_> {
876 fn span(&self) -> ::treesitter_types::Span {
877 self.span
878 }
879}
880#[derive(Debug, Clone)]
881pub struct AssignmentExpression<'tree> {
882 pub span: ::treesitter_types::Span,
883 pub left: Expression<'tree>,
884 pub right: Expression<'tree>,
885}
886impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
887 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
888 fn from_node(
889 node: ::tree_sitter::Node<'tree>,
890 src: &'tree [u8],
891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
892 debug_assert_eq!(node.kind(), "assignment_expression");
893 Ok(Self {
894 span: ::treesitter_types::Span::from(node),
895 left: {
896 let child = node
897 .child_by_field_name("left")
898 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
899 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
900 },
901 right: {
902 let child = node
903 .child_by_field_name("right")
904 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
905 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
906 },
907 })
908 }
909}
910impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
911 fn span(&self) -> ::treesitter_types::Span {
912 self.span
913 }
914}
915#[derive(Debug, Clone)]
916pub struct AssociatedType<'tree> {
917 pub span: ::treesitter_types::Span,
918 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
919 pub name: TypeIdentifier<'tree>,
920 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
921 pub children: ::core::option::Option<WhereClause<'tree>>,
922}
923impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedType<'tree> {
924 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
925 fn from_node(
926 node: ::tree_sitter::Node<'tree>,
927 src: &'tree [u8],
928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
929 debug_assert_eq!(node.kind(), "associated_type");
930 Ok(Self {
931 span: ::treesitter_types::Span::from(node),
932 bounds: match node.child_by_field_name("bounds") {
933 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
934 child, src,
935 )?),
936 None => None,
937 },
938 name: {
939 let child = node
940 .child_by_field_name("name")
941 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
942 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
943 },
944 type_parameters: match node.child_by_field_name("type_parameters") {
945 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
946 child, src,
947 )?),
948 None => None,
949 },
950 children: {
951 #[allow(clippy::suspicious_else_formatting)]
952 let non_field_children = {
953 let mut cursor = node.walk();
954 let mut result = ::std::vec::Vec::new();
955 if cursor.goto_first_child() {
956 loop {
957 if cursor.field_name().is_none()
958 && cursor.node().is_named()
959 && !cursor.node().is_extra()
960 {
961 result.push(cursor.node());
962 }
963 if !cursor.goto_next_sibling() {
964 break;
965 }
966 }
967 }
968 result
969 };
970 match non_field_children.first() {
971 Some(&child) => Some(<WhereClause as ::treesitter_types::FromNode>::from_node(
972 child, src,
973 )?),
974 None => None,
975 }
976 },
977 })
978 }
979}
980impl ::treesitter_types::Spanned for AssociatedType<'_> {
981 fn span(&self) -> ::treesitter_types::Span {
982 self.span
983 }
984}
985#[derive(Debug, Clone)]
986pub struct AsyncBlock<'tree> {
987 pub span: ::treesitter_types::Span,
988 pub children: Block<'tree>,
989}
990impl<'tree> ::treesitter_types::FromNode<'tree> for AsyncBlock<'tree> {
991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
992 fn from_node(
993 node: ::tree_sitter::Node<'tree>,
994 src: &'tree [u8],
995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
996 debug_assert_eq!(node.kind(), "async_block");
997 Ok(Self {
998 span: ::treesitter_types::Span::from(node),
999 children: {
1000 #[allow(clippy::suspicious_else_formatting)]
1001 let non_field_children = {
1002 let mut cursor = node.walk();
1003 let mut result = ::std::vec::Vec::new();
1004 if cursor.goto_first_child() {
1005 loop {
1006 if cursor.field_name().is_none()
1007 && cursor.node().is_named()
1008 && !cursor.node().is_extra()
1009 {
1010 result.push(cursor.node());
1011 }
1012 if !cursor.goto_next_sibling() {
1013 break;
1014 }
1015 }
1016 }
1017 result
1018 };
1019 let child = if let Some(&c) = non_field_children.first() {
1020 c
1021 } else {
1022 let mut fallback_cursor = node.walk();
1023 let mut fallback_child = None;
1024 if fallback_cursor.goto_first_child() {
1025 loop {
1026 if fallback_cursor.field_name().is_none()
1027 && !fallback_cursor.node().is_extra()
1028 {
1029 fallback_child = Some(fallback_cursor.node());
1030 break;
1031 }
1032 if !fallback_cursor.goto_next_sibling() {
1033 break;
1034 }
1035 }
1036 }
1037 fallback_child.ok_or_else(|| {
1038 ::treesitter_types::ParseError::missing_field("children", node)
1039 })?
1040 };
1041 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
1042 },
1043 })
1044 }
1045}
1046impl ::treesitter_types::Spanned for AsyncBlock<'_> {
1047 fn span(&self) -> ::treesitter_types::Span {
1048 self.span
1049 }
1050}
1051#[derive(Debug, Clone)]
1052pub struct Attribute<'tree> {
1053 pub span: ::treesitter_types::Span,
1054 pub arguments: ::core::option::Option<TokenTree<'tree>>,
1055 pub value: ::core::option::Option<Expression<'tree>>,
1056 pub children: AttributeChildren<'tree>,
1057}
1058impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1059 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1060 fn from_node(
1061 node: ::tree_sitter::Node<'tree>,
1062 src: &'tree [u8],
1063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1064 debug_assert_eq!(node.kind(), "attribute");
1065 Ok(Self {
1066 span: ::treesitter_types::Span::from(node),
1067 arguments: match node.child_by_field_name("arguments") {
1068 Some(child) => Some(<TokenTree as ::treesitter_types::FromNode>::from_node(
1069 child, src,
1070 )?),
1071 None => None,
1072 },
1073 value: match node.child_by_field_name("value") {
1074 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
1075 child, src,
1076 )?),
1077 None => None,
1078 },
1079 children: {
1080 #[allow(clippy::suspicious_else_formatting)]
1081 let non_field_children = {
1082 let mut cursor = node.walk();
1083 let mut result = ::std::vec::Vec::new();
1084 if cursor.goto_first_child() {
1085 loop {
1086 if cursor.field_name().is_none()
1087 && cursor.node().is_named()
1088 && !cursor.node().is_extra()
1089 {
1090 result.push(cursor.node());
1091 }
1092 if !cursor.goto_next_sibling() {
1093 break;
1094 }
1095 }
1096 }
1097 result
1098 };
1099 let child = if let Some(&c) = non_field_children.first() {
1100 c
1101 } else {
1102 let mut fallback_cursor = node.walk();
1103 let mut fallback_child = None;
1104 if fallback_cursor.goto_first_child() {
1105 loop {
1106 if fallback_cursor.field_name().is_none()
1107 && !fallback_cursor.node().is_extra()
1108 {
1109 fallback_child = Some(fallback_cursor.node());
1110 break;
1111 }
1112 if !fallback_cursor.goto_next_sibling() {
1113 break;
1114 }
1115 }
1116 }
1117 fallback_child.ok_or_else(|| {
1118 ::treesitter_types::ParseError::missing_field("children", node)
1119 })?
1120 };
1121 <AttributeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1122 },
1123 })
1124 }
1125}
1126impl ::treesitter_types::Spanned for Attribute<'_> {
1127 fn span(&self) -> ::treesitter_types::Span {
1128 self.span
1129 }
1130}
1131#[derive(Debug, Clone)]
1132pub struct AttributeItem<'tree> {
1133 pub span: ::treesitter_types::Span,
1134 pub children: Attribute<'tree>,
1135}
1136impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeItem<'tree> {
1137 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1138 fn from_node(
1139 node: ::tree_sitter::Node<'tree>,
1140 src: &'tree [u8],
1141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1142 debug_assert_eq!(node.kind(), "attribute_item");
1143 Ok(Self {
1144 span: ::treesitter_types::Span::from(node),
1145 children: {
1146 #[allow(clippy::suspicious_else_formatting)]
1147 let non_field_children = {
1148 let mut cursor = node.walk();
1149 let mut result = ::std::vec::Vec::new();
1150 if cursor.goto_first_child() {
1151 loop {
1152 if cursor.field_name().is_none()
1153 && cursor.node().is_named()
1154 && !cursor.node().is_extra()
1155 {
1156 result.push(cursor.node());
1157 }
1158 if !cursor.goto_next_sibling() {
1159 break;
1160 }
1161 }
1162 }
1163 result
1164 };
1165 let child = if let Some(&c) = non_field_children.first() {
1166 c
1167 } else {
1168 let mut fallback_cursor = node.walk();
1169 let mut fallback_child = None;
1170 if fallback_cursor.goto_first_child() {
1171 loop {
1172 if fallback_cursor.field_name().is_none()
1173 && !fallback_cursor.node().is_extra()
1174 {
1175 fallback_child = Some(fallback_cursor.node());
1176 break;
1177 }
1178 if !fallback_cursor.goto_next_sibling() {
1179 break;
1180 }
1181 }
1182 }
1183 fallback_child.ok_or_else(|| {
1184 ::treesitter_types::ParseError::missing_field("children", node)
1185 })?
1186 };
1187 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)?
1188 },
1189 })
1190 }
1191}
1192impl ::treesitter_types::Spanned for AttributeItem<'_> {
1193 fn span(&self) -> ::treesitter_types::Span {
1194 self.span
1195 }
1196}
1197#[derive(Debug, Clone)]
1198pub struct AwaitExpression<'tree> {
1199 pub span: ::treesitter_types::Span,
1200 pub children: Expression<'tree>,
1201}
1202impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
1203 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1204 fn from_node(
1205 node: ::tree_sitter::Node<'tree>,
1206 src: &'tree [u8],
1207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1208 debug_assert_eq!(node.kind(), "await_expression");
1209 Ok(Self {
1210 span: ::treesitter_types::Span::from(node),
1211 children: {
1212 #[allow(clippy::suspicious_else_formatting)]
1213 let non_field_children = {
1214 let mut cursor = node.walk();
1215 let mut result = ::std::vec::Vec::new();
1216 if cursor.goto_first_child() {
1217 loop {
1218 if cursor.field_name().is_none()
1219 && cursor.node().is_named()
1220 && !cursor.node().is_extra()
1221 {
1222 result.push(cursor.node());
1223 }
1224 if !cursor.goto_next_sibling() {
1225 break;
1226 }
1227 }
1228 }
1229 result
1230 };
1231 let child = if let Some(&c) = non_field_children.first() {
1232 c
1233 } else {
1234 let mut fallback_cursor = node.walk();
1235 let mut fallback_child = None;
1236 if fallback_cursor.goto_first_child() {
1237 loop {
1238 if fallback_cursor.field_name().is_none()
1239 && !fallback_cursor.node().is_extra()
1240 {
1241 fallback_child = Some(fallback_cursor.node());
1242 break;
1243 }
1244 if !fallback_cursor.goto_next_sibling() {
1245 break;
1246 }
1247 }
1248 }
1249 fallback_child.ok_or_else(|| {
1250 ::treesitter_types::ParseError::missing_field("children", node)
1251 })?
1252 };
1253 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1254 },
1255 })
1256 }
1257}
1258impl ::treesitter_types::Spanned for AwaitExpression<'_> {
1259 fn span(&self) -> ::treesitter_types::Span {
1260 self.span
1261 }
1262}
1263#[derive(Debug, Clone)]
1264pub struct BaseFieldInitializer<'tree> {
1265 pub span: ::treesitter_types::Span,
1266 pub children: Expression<'tree>,
1267}
1268impl<'tree> ::treesitter_types::FromNode<'tree> for BaseFieldInitializer<'tree> {
1269 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1270 fn from_node(
1271 node: ::tree_sitter::Node<'tree>,
1272 src: &'tree [u8],
1273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1274 debug_assert_eq!(node.kind(), "base_field_initializer");
1275 Ok(Self {
1276 span: ::treesitter_types::Span::from(node),
1277 children: {
1278 #[allow(clippy::suspicious_else_formatting)]
1279 let non_field_children = {
1280 let mut cursor = node.walk();
1281 let mut result = ::std::vec::Vec::new();
1282 if cursor.goto_first_child() {
1283 loop {
1284 if cursor.field_name().is_none()
1285 && cursor.node().is_named()
1286 && !cursor.node().is_extra()
1287 {
1288 result.push(cursor.node());
1289 }
1290 if !cursor.goto_next_sibling() {
1291 break;
1292 }
1293 }
1294 }
1295 result
1296 };
1297 let child = if let Some(&c) = non_field_children.first() {
1298 c
1299 } else {
1300 let mut fallback_cursor = node.walk();
1301 let mut fallback_child = None;
1302 if fallback_cursor.goto_first_child() {
1303 loop {
1304 if fallback_cursor.field_name().is_none()
1305 && !fallback_cursor.node().is_extra()
1306 {
1307 fallback_child = Some(fallback_cursor.node());
1308 break;
1309 }
1310 if !fallback_cursor.goto_next_sibling() {
1311 break;
1312 }
1313 }
1314 }
1315 fallback_child.ok_or_else(|| {
1316 ::treesitter_types::ParseError::missing_field("children", node)
1317 })?
1318 };
1319 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1320 },
1321 })
1322 }
1323}
1324impl ::treesitter_types::Spanned for BaseFieldInitializer<'_> {
1325 fn span(&self) -> ::treesitter_types::Span {
1326 self.span
1327 }
1328}
1329#[derive(Debug, Clone)]
1330pub struct BinaryExpression<'tree> {
1331 pub span: ::treesitter_types::Span,
1332 pub left: Expression<'tree>,
1333 pub operator: BinaryExpressionOperator,
1334 pub right: Expression<'tree>,
1335}
1336impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1337 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1338 fn from_node(
1339 node: ::tree_sitter::Node<'tree>,
1340 src: &'tree [u8],
1341 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1342 debug_assert_eq!(node.kind(), "binary_expression");
1343 Ok(Self {
1344 span: ::treesitter_types::Span::from(node),
1345 left: {
1346 let child = node
1347 .child_by_field_name("left")
1348 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1349 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1350 },
1351 operator: {
1352 let child = node.child_by_field_name("operator").ok_or_else(|| {
1353 ::treesitter_types::ParseError::missing_field("operator", node)
1354 })?;
1355 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1356 },
1357 right: {
1358 let child = node
1359 .child_by_field_name("right")
1360 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1361 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1362 },
1363 })
1364 }
1365}
1366impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1367 fn span(&self) -> ::treesitter_types::Span {
1368 self.span
1369 }
1370}
1371#[derive(Debug, Clone)]
1372pub struct Block<'tree> {
1373 pub span: ::treesitter_types::Span,
1374 pub children: ::std::vec::Vec<BlockChildren<'tree>>,
1375}
1376impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1377 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1378 fn from_node(
1379 node: ::tree_sitter::Node<'tree>,
1380 src: &'tree [u8],
1381 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1382 debug_assert_eq!(node.kind(), "block");
1383 Ok(Self {
1384 span: ::treesitter_types::Span::from(node),
1385 children: {
1386 #[allow(clippy::suspicious_else_formatting)]
1387 let non_field_children = {
1388 let mut cursor = node.walk();
1389 let mut result = ::std::vec::Vec::new();
1390 if cursor.goto_first_child() {
1391 loop {
1392 if cursor.field_name().is_none()
1393 && cursor.node().is_named()
1394 && !cursor.node().is_extra()
1395 {
1396 result.push(cursor.node());
1397 }
1398 if !cursor.goto_next_sibling() {
1399 break;
1400 }
1401 }
1402 }
1403 result
1404 };
1405 let mut items = ::std::vec::Vec::new();
1406 for child in non_field_children {
1407 items.push(<BlockChildren as ::treesitter_types::FromNode>::from_node(
1408 child, src,
1409 )?);
1410 }
1411 items
1412 },
1413 })
1414 }
1415}
1416impl ::treesitter_types::Spanned for Block<'_> {
1417 fn span(&self) -> ::treesitter_types::Span {
1418 self.span
1419 }
1420}
1421#[derive(Debug, Clone)]
1422pub struct BlockComment<'tree> {
1423 pub span: ::treesitter_types::Span,
1424 pub doc: ::core::option::Option<DocComment<'tree>>,
1425 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
1426 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
1427}
1428impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
1429 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1430 fn from_node(
1431 node: ::tree_sitter::Node<'tree>,
1432 src: &'tree [u8],
1433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1434 debug_assert_eq!(node.kind(), "block_comment");
1435 Ok(Self {
1436 span: ::treesitter_types::Span::from(node),
1437 doc: match node.child_by_field_name("doc") {
1438 Some(child) => Some(<DocComment as ::treesitter_types::FromNode>::from_node(
1439 child, src,
1440 )?),
1441 None => None,
1442 },
1443 inner: match node.child_by_field_name("inner") {
1444 Some(child) => Some(
1445 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
1446 ),
1447 None => None,
1448 },
1449 outer: match node.child_by_field_name("outer") {
1450 Some(child) => Some(
1451 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
1452 ),
1453 None => None,
1454 },
1455 })
1456 }
1457}
1458impl ::treesitter_types::Spanned for BlockComment<'_> {
1459 fn span(&self) -> ::treesitter_types::Span {
1460 self.span
1461 }
1462}
1463#[derive(Debug, Clone)]
1464pub struct BooleanLiteral<'tree> {
1465 pub span: ::treesitter_types::Span,
1466 text: &'tree str,
1467}
1468impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
1469 fn from_node(
1470 node: ::tree_sitter::Node<'tree>,
1471 src: &'tree [u8],
1472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1473 debug_assert_eq!(node.kind(), "boolean_literal");
1474 Ok(Self {
1475 span: ::treesitter_types::Span::from(node),
1476 text: node.utf8_text(src)?,
1477 })
1478 }
1479}
1480impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
1481 fn text(&self) -> &'tree str {
1482 self.text
1483 }
1484}
1485impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
1486 fn span(&self) -> ::treesitter_types::Span {
1487 self.span
1488 }
1489}
1490#[derive(Debug, Clone)]
1491pub struct BoundedType<'tree> {
1492 pub span: ::treesitter_types::Span,
1493 pub children: ::std::vec::Vec<BoundedTypeChildren<'tree>>,
1494}
1495impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedType<'tree> {
1496 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1497 fn from_node(
1498 node: ::tree_sitter::Node<'tree>,
1499 src: &'tree [u8],
1500 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1501 debug_assert_eq!(node.kind(), "bounded_type");
1502 Ok(Self {
1503 span: ::treesitter_types::Span::from(node),
1504 children: {
1505 #[allow(clippy::suspicious_else_formatting)]
1506 let non_field_children = {
1507 let mut cursor = node.walk();
1508 let mut result = ::std::vec::Vec::new();
1509 if cursor.goto_first_child() {
1510 loop {
1511 if cursor.field_name().is_none()
1512 && cursor.node().is_named()
1513 && !cursor.node().is_extra()
1514 {
1515 result.push(cursor.node());
1516 }
1517 if !cursor.goto_next_sibling() {
1518 break;
1519 }
1520 }
1521 }
1522 result
1523 };
1524 let mut items = ::std::vec::Vec::new();
1525 for child in non_field_children {
1526 items.push(
1527 <BoundedTypeChildren as ::treesitter_types::FromNode>::from_node(
1528 child, src,
1529 )?,
1530 );
1531 }
1532 items
1533 },
1534 })
1535 }
1536}
1537impl ::treesitter_types::Spanned for BoundedType<'_> {
1538 fn span(&self) -> ::treesitter_types::Span {
1539 self.span
1540 }
1541}
1542#[derive(Debug, Clone)]
1543pub struct BracketedType<'tree> {
1544 pub span: ::treesitter_types::Span,
1545 pub children: BracketedTypeChildren<'tree>,
1546}
1547impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedType<'tree> {
1548 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1549 fn from_node(
1550 node: ::tree_sitter::Node<'tree>,
1551 src: &'tree [u8],
1552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1553 debug_assert_eq!(node.kind(), "bracketed_type");
1554 Ok(Self {
1555 span: ::treesitter_types::Span::from(node),
1556 children: {
1557 #[allow(clippy::suspicious_else_formatting)]
1558 let non_field_children = {
1559 let mut cursor = node.walk();
1560 let mut result = ::std::vec::Vec::new();
1561 if cursor.goto_first_child() {
1562 loop {
1563 if cursor.field_name().is_none()
1564 && cursor.node().is_named()
1565 && !cursor.node().is_extra()
1566 {
1567 result.push(cursor.node());
1568 }
1569 if !cursor.goto_next_sibling() {
1570 break;
1571 }
1572 }
1573 }
1574 result
1575 };
1576 let child = if let Some(&c) = non_field_children.first() {
1577 c
1578 } else {
1579 let mut fallback_cursor = node.walk();
1580 let mut fallback_child = None;
1581 if fallback_cursor.goto_first_child() {
1582 loop {
1583 if fallback_cursor.field_name().is_none()
1584 && !fallback_cursor.node().is_extra()
1585 {
1586 fallback_child = Some(fallback_cursor.node());
1587 break;
1588 }
1589 if !fallback_cursor.goto_next_sibling() {
1590 break;
1591 }
1592 }
1593 }
1594 fallback_child.ok_or_else(|| {
1595 ::treesitter_types::ParseError::missing_field("children", node)
1596 })?
1597 };
1598 <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1599 },
1600 })
1601 }
1602}
1603impl ::treesitter_types::Spanned for BracketedType<'_> {
1604 fn span(&self) -> ::treesitter_types::Span {
1605 self.span
1606 }
1607}
1608#[derive(Debug, Clone)]
1609pub struct BreakExpression<'tree> {
1610 pub span: ::treesitter_types::Span,
1611 pub children: ::std::vec::Vec<BreakExpressionChildren<'tree>>,
1612}
1613impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpression<'tree> {
1614 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1615 fn from_node(
1616 node: ::tree_sitter::Node<'tree>,
1617 src: &'tree [u8],
1618 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1619 debug_assert_eq!(node.kind(), "break_expression");
1620 Ok(Self {
1621 span: ::treesitter_types::Span::from(node),
1622 children: {
1623 #[allow(clippy::suspicious_else_formatting)]
1624 let non_field_children = {
1625 let mut cursor = node.walk();
1626 let mut result = ::std::vec::Vec::new();
1627 if cursor.goto_first_child() {
1628 loop {
1629 if cursor.field_name().is_none()
1630 && cursor.node().is_named()
1631 && !cursor.node().is_extra()
1632 {
1633 result.push(cursor.node());
1634 }
1635 if !cursor.goto_next_sibling() {
1636 break;
1637 }
1638 }
1639 }
1640 result
1641 };
1642 let mut items = ::std::vec::Vec::new();
1643 for child in non_field_children {
1644 items.push(
1645 <BreakExpressionChildren as ::treesitter_types::FromNode>::from_node(
1646 child, src,
1647 )?,
1648 );
1649 }
1650 items
1651 },
1652 })
1653 }
1654}
1655impl ::treesitter_types::Spanned for BreakExpression<'_> {
1656 fn span(&self) -> ::treesitter_types::Span {
1657 self.span
1658 }
1659}
1660#[derive(Debug, Clone)]
1661pub struct CallExpression<'tree> {
1662 pub span: ::treesitter_types::Span,
1663 pub arguments: Arguments<'tree>,
1664 pub function: CallExpressionFunction<'tree>,
1665}
1666impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1667 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1668 fn from_node(
1669 node: ::tree_sitter::Node<'tree>,
1670 src: &'tree [u8],
1671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1672 debug_assert_eq!(node.kind(), "call_expression");
1673 Ok(Self {
1674 span: ::treesitter_types::Span::from(node),
1675 arguments: {
1676 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1677 ::treesitter_types::ParseError::missing_field("arguments", node)
1678 })?;
1679 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
1680 },
1681 function: {
1682 let child = node.child_by_field_name("function").ok_or_else(|| {
1683 ::treesitter_types::ParseError::missing_field("function", node)
1684 })?;
1685 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
1686 },
1687 })
1688 }
1689}
1690impl ::treesitter_types::Spanned for CallExpression<'_> {
1691 fn span(&self) -> ::treesitter_types::Span {
1692 self.span
1693 }
1694}
1695#[derive(Debug, Clone)]
1696pub struct CapturedPattern<'tree> {
1697 pub span: ::treesitter_types::Span,
1698 pub children: ::std::vec::Vec<Pattern<'tree>>,
1699}
1700impl<'tree> ::treesitter_types::FromNode<'tree> for CapturedPattern<'tree> {
1701 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1702 fn from_node(
1703 node: ::tree_sitter::Node<'tree>,
1704 src: &'tree [u8],
1705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1706 debug_assert_eq!(node.kind(), "captured_pattern");
1707 Ok(Self {
1708 span: ::treesitter_types::Span::from(node),
1709 children: {
1710 #[allow(clippy::suspicious_else_formatting)]
1711 let non_field_children = {
1712 let mut cursor = node.walk();
1713 let mut result = ::std::vec::Vec::new();
1714 if cursor.goto_first_child() {
1715 loop {
1716 if cursor.field_name().is_none()
1717 && cursor.node().is_named()
1718 && !cursor.node().is_extra()
1719 {
1720 result.push(cursor.node());
1721 }
1722 if !cursor.goto_next_sibling() {
1723 break;
1724 }
1725 }
1726 }
1727 result
1728 };
1729 let mut items = ::std::vec::Vec::new();
1730 for child in non_field_children {
1731 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
1732 child, src,
1733 )?);
1734 }
1735 items
1736 },
1737 })
1738 }
1739}
1740impl ::treesitter_types::Spanned for CapturedPattern<'_> {
1741 fn span(&self) -> ::treesitter_types::Span {
1742 self.span
1743 }
1744}
1745#[derive(Debug, Clone)]
1746pub struct ClosureExpression<'tree> {
1747 pub span: ::treesitter_types::Span,
1748 pub body: ClosureExpressionBody<'tree>,
1749 pub parameters: ClosureParameters<'tree>,
1750 pub return_type: ::core::option::Option<Type<'tree>>,
1751}
1752impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpression<'tree> {
1753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1754 fn from_node(
1755 node: ::tree_sitter::Node<'tree>,
1756 src: &'tree [u8],
1757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1758 debug_assert_eq!(node.kind(), "closure_expression");
1759 Ok(Self {
1760 span: ::treesitter_types::Span::from(node),
1761 body: {
1762 let child = node
1763 .child_by_field_name("body")
1764 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1765 <ClosureExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)?
1766 },
1767 parameters: {
1768 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1769 ::treesitter_types::ParseError::missing_field("parameters", node)
1770 })?;
1771 <ClosureParameters as ::treesitter_types::FromNode>::from_node(child, src)?
1772 },
1773 return_type: match node.child_by_field_name("return_type") {
1774 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
1775 child, src,
1776 )?),
1777 None => None,
1778 },
1779 })
1780 }
1781}
1782impl ::treesitter_types::Spanned for ClosureExpression<'_> {
1783 fn span(&self) -> ::treesitter_types::Span {
1784 self.span
1785 }
1786}
1787#[derive(Debug, Clone)]
1788pub struct ClosureParameters<'tree> {
1789 pub span: ::treesitter_types::Span,
1790 pub children: ::std::vec::Vec<ClosureParametersChildren<'tree>>,
1791}
1792impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParameters<'tree> {
1793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1794 fn from_node(
1795 node: ::tree_sitter::Node<'tree>,
1796 src: &'tree [u8],
1797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1798 debug_assert_eq!(node.kind(), "closure_parameters");
1799 Ok(Self {
1800 span: ::treesitter_types::Span::from(node),
1801 children: {
1802 #[allow(clippy::suspicious_else_formatting)]
1803 let non_field_children = {
1804 let mut cursor = node.walk();
1805 let mut result = ::std::vec::Vec::new();
1806 if cursor.goto_first_child() {
1807 loop {
1808 if cursor.field_name().is_none()
1809 && cursor.node().is_named()
1810 && !cursor.node().is_extra()
1811 {
1812 result.push(cursor.node());
1813 }
1814 if !cursor.goto_next_sibling() {
1815 break;
1816 }
1817 }
1818 }
1819 result
1820 };
1821 let mut items = ::std::vec::Vec::new();
1822 for child in non_field_children {
1823 items.push(
1824 <ClosureParametersChildren as ::treesitter_types::FromNode>::from_node(
1825 child, src,
1826 )?,
1827 );
1828 }
1829 items
1830 },
1831 })
1832 }
1833}
1834impl ::treesitter_types::Spanned for ClosureParameters<'_> {
1835 fn span(&self) -> ::treesitter_types::Span {
1836 self.span
1837 }
1838}
1839#[derive(Debug, Clone)]
1840pub struct CompoundAssignmentExpr<'tree> {
1841 pub span: ::treesitter_types::Span,
1842 pub left: Expression<'tree>,
1843 pub operator: CompoundAssignmentExprOperator,
1844 pub right: Expression<'tree>,
1845}
1846impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExpr<'tree> {
1847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1848 fn from_node(
1849 node: ::tree_sitter::Node<'tree>,
1850 src: &'tree [u8],
1851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1852 debug_assert_eq!(node.kind(), "compound_assignment_expr");
1853 Ok(Self {
1854 span: ::treesitter_types::Span::from(node),
1855 left: {
1856 let child = node
1857 .child_by_field_name("left")
1858 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1859 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1860 },
1861 operator: {
1862 let child = node.child_by_field_name("operator").ok_or_else(|| {
1863 ::treesitter_types::ParseError::missing_field("operator", node)
1864 })?;
1865 <CompoundAssignmentExprOperator as ::treesitter_types::FromNode>::from_node(
1866 child, src,
1867 )?
1868 },
1869 right: {
1870 let child = node
1871 .child_by_field_name("right")
1872 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1873 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1874 },
1875 })
1876 }
1877}
1878impl ::treesitter_types::Spanned for CompoundAssignmentExpr<'_> {
1879 fn span(&self) -> ::treesitter_types::Span {
1880 self.span
1881 }
1882}
1883#[derive(Debug, Clone)]
1884pub struct ConstBlock<'tree> {
1885 pub span: ::treesitter_types::Span,
1886 pub body: Block<'tree>,
1887}
1888impl<'tree> ::treesitter_types::FromNode<'tree> for ConstBlock<'tree> {
1889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1890 fn from_node(
1891 node: ::tree_sitter::Node<'tree>,
1892 src: &'tree [u8],
1893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1894 debug_assert_eq!(node.kind(), "const_block");
1895 Ok(Self {
1896 span: ::treesitter_types::Span::from(node),
1897 body: {
1898 let child = node
1899 .child_by_field_name("body")
1900 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1901 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
1902 },
1903 })
1904 }
1905}
1906impl ::treesitter_types::Spanned for ConstBlock<'_> {
1907 fn span(&self) -> ::treesitter_types::Span {
1908 self.span
1909 }
1910}
1911#[derive(Debug, Clone)]
1912pub struct ConstItem<'tree> {
1913 pub span: ::treesitter_types::Span,
1914 pub name: Identifier<'tree>,
1915 pub r#type: Type<'tree>,
1916 pub value: ::core::option::Option<Expression<'tree>>,
1917 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
1918}
1919impl<'tree> ::treesitter_types::FromNode<'tree> for ConstItem<'tree> {
1920 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1921 fn from_node(
1922 node: ::tree_sitter::Node<'tree>,
1923 src: &'tree [u8],
1924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1925 debug_assert_eq!(node.kind(), "const_item");
1926 Ok(Self {
1927 span: ::treesitter_types::Span::from(node),
1928 name: {
1929 let child = node
1930 .child_by_field_name("name")
1931 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1932 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1933 },
1934 r#type: {
1935 let child = node
1936 .child_by_field_name("type")
1937 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1938 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
1939 },
1940 value: match node.child_by_field_name("value") {
1941 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
1942 child, src,
1943 )?),
1944 None => None,
1945 },
1946 children: {
1947 #[allow(clippy::suspicious_else_formatting)]
1948 let non_field_children = {
1949 let mut cursor = node.walk();
1950 let mut result = ::std::vec::Vec::new();
1951 if cursor.goto_first_child() {
1952 loop {
1953 if cursor.field_name().is_none()
1954 && cursor.node().is_named()
1955 && !cursor.node().is_extra()
1956 {
1957 result.push(cursor.node());
1958 }
1959 if !cursor.goto_next_sibling() {
1960 break;
1961 }
1962 }
1963 }
1964 result
1965 };
1966 match non_field_children.first() {
1967 Some(&child) => Some(
1968 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
1969 child, src,
1970 )?,
1971 ),
1972 None => None,
1973 }
1974 },
1975 })
1976 }
1977}
1978impl ::treesitter_types::Spanned for ConstItem<'_> {
1979 fn span(&self) -> ::treesitter_types::Span {
1980 self.span
1981 }
1982}
1983#[derive(Debug, Clone)]
1984pub struct ConstParameter<'tree> {
1985 pub span: ::treesitter_types::Span,
1986 pub name: Identifier<'tree>,
1987 pub r#type: Type<'tree>,
1988 pub value: ::core::option::Option<ConstParameterValue<'tree>>,
1989}
1990impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameter<'tree> {
1991 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1992 fn from_node(
1993 node: ::tree_sitter::Node<'tree>,
1994 src: &'tree [u8],
1995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1996 debug_assert_eq!(node.kind(), "const_parameter");
1997 Ok(Self {
1998 span: ::treesitter_types::Span::from(node),
1999 name: {
2000 let child = node
2001 .child_by_field_name("name")
2002 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2003 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2004 },
2005 r#type: {
2006 let child = node
2007 .child_by_field_name("type")
2008 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2009 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2010 },
2011 value: match node.child_by_field_name("value") {
2012 Some(child) => Some(
2013 <ConstParameterValue as ::treesitter_types::FromNode>::from_node(child, src)?,
2014 ),
2015 None => None,
2016 },
2017 })
2018 }
2019}
2020impl ::treesitter_types::Spanned for ConstParameter<'_> {
2021 fn span(&self) -> ::treesitter_types::Span {
2022 self.span
2023 }
2024}
2025#[derive(Debug, Clone)]
2026pub struct ContinueExpression<'tree> {
2027 pub span: ::treesitter_types::Span,
2028 pub children: ::core::option::Option<Label<'tree>>,
2029}
2030impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueExpression<'tree> {
2031 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2032 fn from_node(
2033 node: ::tree_sitter::Node<'tree>,
2034 src: &'tree [u8],
2035 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2036 debug_assert_eq!(node.kind(), "continue_expression");
2037 Ok(Self {
2038 span: ::treesitter_types::Span::from(node),
2039 children: {
2040 #[allow(clippy::suspicious_else_formatting)]
2041 let non_field_children = {
2042 let mut cursor = node.walk();
2043 let mut result = ::std::vec::Vec::new();
2044 if cursor.goto_first_child() {
2045 loop {
2046 if cursor.field_name().is_none()
2047 && cursor.node().is_named()
2048 && !cursor.node().is_extra()
2049 {
2050 result.push(cursor.node());
2051 }
2052 if !cursor.goto_next_sibling() {
2053 break;
2054 }
2055 }
2056 }
2057 result
2058 };
2059 match non_field_children.first() {
2060 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
2061 child, src,
2062 )?),
2063 None => None,
2064 }
2065 },
2066 })
2067 }
2068}
2069impl ::treesitter_types::Spanned for ContinueExpression<'_> {
2070 fn span(&self) -> ::treesitter_types::Span {
2071 self.span
2072 }
2073}
2074#[derive(Debug, Clone)]
2075pub struct DeclarationList<'tree> {
2076 pub span: ::treesitter_types::Span,
2077 pub children: ::std::vec::Vec<DeclarationStatement<'tree>>,
2078}
2079impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2081 fn from_node(
2082 node: ::tree_sitter::Node<'tree>,
2083 src: &'tree [u8],
2084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2085 debug_assert_eq!(node.kind(), "declaration_list");
2086 Ok(Self {
2087 span: ::treesitter_types::Span::from(node),
2088 children: {
2089 #[allow(clippy::suspicious_else_formatting)]
2090 let non_field_children = {
2091 let mut cursor = node.walk();
2092 let mut result = ::std::vec::Vec::new();
2093 if cursor.goto_first_child() {
2094 loop {
2095 if cursor.field_name().is_none()
2096 && cursor.node().is_named()
2097 && !cursor.node().is_extra()
2098 {
2099 result.push(cursor.node());
2100 }
2101 if !cursor.goto_next_sibling() {
2102 break;
2103 }
2104 }
2105 }
2106 result
2107 };
2108 let mut items = ::std::vec::Vec::new();
2109 for child in non_field_children {
2110 items.push(
2111 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(
2112 child, src,
2113 )?,
2114 );
2115 }
2116 items
2117 },
2118 })
2119 }
2120}
2121impl ::treesitter_types::Spanned for DeclarationList<'_> {
2122 fn span(&self) -> ::treesitter_types::Span {
2123 self.span
2124 }
2125}
2126#[derive(Debug, Clone)]
2127pub struct DynamicType<'tree> {
2128 pub span: ::treesitter_types::Span,
2129 pub r#trait: DynamicTypeTrait<'tree>,
2130}
2131impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicType<'tree> {
2132 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2133 fn from_node(
2134 node: ::tree_sitter::Node<'tree>,
2135 src: &'tree [u8],
2136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2137 debug_assert_eq!(node.kind(), "dynamic_type");
2138 Ok(Self {
2139 span: ::treesitter_types::Span::from(node),
2140 r#trait: {
2141 let child = node
2142 .child_by_field_name("trait")
2143 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("trait", node))?;
2144 <DynamicTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)?
2145 },
2146 })
2147 }
2148}
2149impl ::treesitter_types::Spanned for DynamicType<'_> {
2150 fn span(&self) -> ::treesitter_types::Span {
2151 self.span
2152 }
2153}
2154#[derive(Debug, Clone)]
2155pub struct ElseClause<'tree> {
2156 pub span: ::treesitter_types::Span,
2157 pub children: ElseClauseChildren<'tree>,
2158}
2159impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
2160 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2161 fn from_node(
2162 node: ::tree_sitter::Node<'tree>,
2163 src: &'tree [u8],
2164 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2165 debug_assert_eq!(node.kind(), "else_clause");
2166 Ok(Self {
2167 span: ::treesitter_types::Span::from(node),
2168 children: {
2169 #[allow(clippy::suspicious_else_formatting)]
2170 let non_field_children = {
2171 let mut cursor = node.walk();
2172 let mut result = ::std::vec::Vec::new();
2173 if cursor.goto_first_child() {
2174 loop {
2175 if cursor.field_name().is_none()
2176 && cursor.node().is_named()
2177 && !cursor.node().is_extra()
2178 {
2179 result.push(cursor.node());
2180 }
2181 if !cursor.goto_next_sibling() {
2182 break;
2183 }
2184 }
2185 }
2186 result
2187 };
2188 let child = if let Some(&c) = non_field_children.first() {
2189 c
2190 } else {
2191 let mut fallback_cursor = node.walk();
2192 let mut fallback_child = None;
2193 if fallback_cursor.goto_first_child() {
2194 loop {
2195 if fallback_cursor.field_name().is_none()
2196 && !fallback_cursor.node().is_extra()
2197 {
2198 fallback_child = Some(fallback_cursor.node());
2199 break;
2200 }
2201 if !fallback_cursor.goto_next_sibling() {
2202 break;
2203 }
2204 }
2205 }
2206 fallback_child.ok_or_else(|| {
2207 ::treesitter_types::ParseError::missing_field("children", node)
2208 })?
2209 };
2210 <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2211 },
2212 })
2213 }
2214}
2215impl ::treesitter_types::Spanned for ElseClause<'_> {
2216 fn span(&self) -> ::treesitter_types::Span {
2217 self.span
2218 }
2219}
2220#[derive(Debug, Clone)]
2221pub struct EmptyStatement<'tree> {
2222 pub span: ::treesitter_types::Span,
2223 text: &'tree str,
2224}
2225impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
2226 fn from_node(
2227 node: ::tree_sitter::Node<'tree>,
2228 src: &'tree [u8],
2229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2230 debug_assert_eq!(node.kind(), "empty_statement");
2231 Ok(Self {
2232 span: ::treesitter_types::Span::from(node),
2233 text: node.utf8_text(src)?,
2234 })
2235 }
2236}
2237impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
2238 fn text(&self) -> &'tree str {
2239 self.text
2240 }
2241}
2242impl ::treesitter_types::Spanned for EmptyStatement<'_> {
2243 fn span(&self) -> ::treesitter_types::Span {
2244 self.span
2245 }
2246}
2247#[derive(Debug, Clone)]
2248pub struct EnumItem<'tree> {
2249 pub span: ::treesitter_types::Span,
2250 pub body: EnumVariantList<'tree>,
2251 pub name: TypeIdentifier<'tree>,
2252 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2253 pub children: ::std::vec::Vec<EnumItemChildren<'tree>>,
2254}
2255impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItem<'tree> {
2256 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2257 fn from_node(
2258 node: ::tree_sitter::Node<'tree>,
2259 src: &'tree [u8],
2260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2261 debug_assert_eq!(node.kind(), "enum_item");
2262 Ok(Self {
2263 span: ::treesitter_types::Span::from(node),
2264 body: {
2265 let child = node
2266 .child_by_field_name("body")
2267 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2268 <EnumVariantList as ::treesitter_types::FromNode>::from_node(child, src)?
2269 },
2270 name: {
2271 let child = node
2272 .child_by_field_name("name")
2273 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2274 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
2275 },
2276 type_parameters: match node.child_by_field_name("type_parameters") {
2277 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2278 child, src,
2279 )?),
2280 None => None,
2281 },
2282 children: {
2283 #[allow(clippy::suspicious_else_formatting)]
2284 let non_field_children = {
2285 let mut cursor = node.walk();
2286 let mut result = ::std::vec::Vec::new();
2287 if cursor.goto_first_child() {
2288 loop {
2289 if cursor.field_name().is_none()
2290 && cursor.node().is_named()
2291 && !cursor.node().is_extra()
2292 {
2293 result.push(cursor.node());
2294 }
2295 if !cursor.goto_next_sibling() {
2296 break;
2297 }
2298 }
2299 }
2300 result
2301 };
2302 let mut items = ::std::vec::Vec::new();
2303 for child in non_field_children {
2304 items.push(
2305 <EnumItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2306 );
2307 }
2308 items
2309 },
2310 })
2311 }
2312}
2313impl ::treesitter_types::Spanned for EnumItem<'_> {
2314 fn span(&self) -> ::treesitter_types::Span {
2315 self.span
2316 }
2317}
2318#[derive(Debug, Clone)]
2319pub struct EnumVariant<'tree> {
2320 pub span: ::treesitter_types::Span,
2321 pub body: ::core::option::Option<EnumVariantBody<'tree>>,
2322 pub name: Identifier<'tree>,
2323 pub value: ::core::option::Option<Expression<'tree>>,
2324 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2325}
2326impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariant<'tree> {
2327 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2328 fn from_node(
2329 node: ::tree_sitter::Node<'tree>,
2330 src: &'tree [u8],
2331 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2332 debug_assert_eq!(node.kind(), "enum_variant");
2333 Ok(Self {
2334 span: ::treesitter_types::Span::from(node),
2335 body: match node.child_by_field_name("body") {
2336 Some(child) => {
2337 Some(<EnumVariantBody as ::treesitter_types::FromNode>::from_node(child, src)?)
2338 }
2339 None => None,
2340 },
2341 name: {
2342 let child = node
2343 .child_by_field_name("name")
2344 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2345 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2346 },
2347 value: match node.child_by_field_name("value") {
2348 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2349 child, src,
2350 )?),
2351 None => None,
2352 },
2353 children: {
2354 #[allow(clippy::suspicious_else_formatting)]
2355 let non_field_children = {
2356 let mut cursor = node.walk();
2357 let mut result = ::std::vec::Vec::new();
2358 if cursor.goto_first_child() {
2359 loop {
2360 if cursor.field_name().is_none()
2361 && cursor.node().is_named()
2362 && !cursor.node().is_extra()
2363 {
2364 result.push(cursor.node());
2365 }
2366 if !cursor.goto_next_sibling() {
2367 break;
2368 }
2369 }
2370 }
2371 result
2372 };
2373 match non_field_children.first() {
2374 Some(&child) => Some(
2375 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
2376 child, src,
2377 )?,
2378 ),
2379 None => None,
2380 }
2381 },
2382 })
2383 }
2384}
2385impl ::treesitter_types::Spanned for EnumVariant<'_> {
2386 fn span(&self) -> ::treesitter_types::Span {
2387 self.span
2388 }
2389}
2390#[derive(Debug, Clone)]
2391pub struct EnumVariantList<'tree> {
2392 pub span: ::treesitter_types::Span,
2393 pub children: ::std::vec::Vec<EnumVariantListChildren<'tree>>,
2394}
2395impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantList<'tree> {
2396 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2397 fn from_node(
2398 node: ::tree_sitter::Node<'tree>,
2399 src: &'tree [u8],
2400 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2401 debug_assert_eq!(node.kind(), "enum_variant_list");
2402 Ok(Self {
2403 span: ::treesitter_types::Span::from(node),
2404 children: {
2405 #[allow(clippy::suspicious_else_formatting)]
2406 let non_field_children = {
2407 let mut cursor = node.walk();
2408 let mut result = ::std::vec::Vec::new();
2409 if cursor.goto_first_child() {
2410 loop {
2411 if cursor.field_name().is_none()
2412 && cursor.node().is_named()
2413 && !cursor.node().is_extra()
2414 {
2415 result.push(cursor.node());
2416 }
2417 if !cursor.goto_next_sibling() {
2418 break;
2419 }
2420 }
2421 }
2422 result
2423 };
2424 let mut items = ::std::vec::Vec::new();
2425 for child in non_field_children {
2426 items.push(
2427 <EnumVariantListChildren as ::treesitter_types::FromNode>::from_node(
2428 child, src,
2429 )?,
2430 );
2431 }
2432 items
2433 },
2434 })
2435 }
2436}
2437impl ::treesitter_types::Spanned for EnumVariantList<'_> {
2438 fn span(&self) -> ::treesitter_types::Span {
2439 self.span
2440 }
2441}
2442#[derive(Debug, Clone)]
2443pub struct ExpressionStatement<'tree> {
2444 pub span: ::treesitter_types::Span,
2445 pub children: Expression<'tree>,
2446}
2447impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
2448 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2449 fn from_node(
2450 node: ::tree_sitter::Node<'tree>,
2451 src: &'tree [u8],
2452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2453 debug_assert_eq!(node.kind(), "expression_statement");
2454 Ok(Self {
2455 span: ::treesitter_types::Span::from(node),
2456 children: {
2457 #[allow(clippy::suspicious_else_formatting)]
2458 let non_field_children = {
2459 let mut cursor = node.walk();
2460 let mut result = ::std::vec::Vec::new();
2461 if cursor.goto_first_child() {
2462 loop {
2463 if cursor.field_name().is_none()
2464 && cursor.node().is_named()
2465 && !cursor.node().is_extra()
2466 {
2467 result.push(cursor.node());
2468 }
2469 if !cursor.goto_next_sibling() {
2470 break;
2471 }
2472 }
2473 }
2474 result
2475 };
2476 let child = if let Some(&c) = non_field_children.first() {
2477 c
2478 } else {
2479 let mut fallback_cursor = node.walk();
2480 let mut fallback_child = None;
2481 if fallback_cursor.goto_first_child() {
2482 loop {
2483 if fallback_cursor.field_name().is_none()
2484 && !fallback_cursor.node().is_extra()
2485 {
2486 fallback_child = Some(fallback_cursor.node());
2487 break;
2488 }
2489 if !fallback_cursor.goto_next_sibling() {
2490 break;
2491 }
2492 }
2493 }
2494 fallback_child.ok_or_else(|| {
2495 ::treesitter_types::ParseError::missing_field("children", node)
2496 })?
2497 };
2498 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2499 },
2500 })
2501 }
2502}
2503impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2504 fn span(&self) -> ::treesitter_types::Span {
2505 self.span
2506 }
2507}
2508#[derive(Debug, Clone)]
2509pub struct ExternCrateDeclaration<'tree> {
2510 pub span: ::treesitter_types::Span,
2511 pub alias: ::core::option::Option<Identifier<'tree>>,
2512 pub name: Identifier<'tree>,
2513 pub children: ::std::vec::Vec<ExternCrateDeclarationChildren<'tree>>,
2514}
2515impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclaration<'tree> {
2516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2517 fn from_node(
2518 node: ::tree_sitter::Node<'tree>,
2519 src: &'tree [u8],
2520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2521 debug_assert_eq!(node.kind(), "extern_crate_declaration");
2522 Ok(Self {
2523 span: ::treesitter_types::Span::from(node),
2524 alias: match node.child_by_field_name("alias") {
2525 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2526 child, src,
2527 )?),
2528 None => None,
2529 },
2530 name: {
2531 let child = node
2532 .child_by_field_name("name")
2533 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2534 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2535 },
2536 children: {
2537 #[allow(clippy::suspicious_else_formatting)]
2538 let non_field_children = {
2539 let mut cursor = node.walk();
2540 let mut result = ::std::vec::Vec::new();
2541 if cursor.goto_first_child() {
2542 loop {
2543 if cursor.field_name().is_none()
2544 && cursor.node().is_named()
2545 && !cursor.node().is_extra()
2546 {
2547 result.push(cursor.node());
2548 }
2549 if !cursor.goto_next_sibling() {
2550 break;
2551 }
2552 }
2553 }
2554 result
2555 };
2556 let mut items = ::std::vec::Vec::new();
2557 for child in non_field_children {
2558 items
2559 .push(
2560 <ExternCrateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2561 child,
2562 src,
2563 )?,
2564 );
2565 }
2566 items
2567 },
2568 })
2569 }
2570}
2571impl ::treesitter_types::Spanned for ExternCrateDeclaration<'_> {
2572 fn span(&self) -> ::treesitter_types::Span {
2573 self.span
2574 }
2575}
2576#[derive(Debug, Clone)]
2577pub struct ExternModifier<'tree> {
2578 pub span: ::treesitter_types::Span,
2579 pub children: ::core::option::Option<StringLiteral<'tree>>,
2580}
2581impl<'tree> ::treesitter_types::FromNode<'tree> for ExternModifier<'tree> {
2582 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2583 fn from_node(
2584 node: ::tree_sitter::Node<'tree>,
2585 src: &'tree [u8],
2586 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2587 debug_assert_eq!(node.kind(), "extern_modifier");
2588 Ok(Self {
2589 span: ::treesitter_types::Span::from(node),
2590 children: {
2591 #[allow(clippy::suspicious_else_formatting)]
2592 let non_field_children = {
2593 let mut cursor = node.walk();
2594 let mut result = ::std::vec::Vec::new();
2595 if cursor.goto_first_child() {
2596 loop {
2597 if cursor.field_name().is_none()
2598 && cursor.node().is_named()
2599 && !cursor.node().is_extra()
2600 {
2601 result.push(cursor.node());
2602 }
2603 if !cursor.goto_next_sibling() {
2604 break;
2605 }
2606 }
2607 }
2608 result
2609 };
2610 match non_field_children.first() {
2611 Some(&child) => Some(
2612 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?,
2613 ),
2614 None => None,
2615 }
2616 },
2617 })
2618 }
2619}
2620impl ::treesitter_types::Spanned for ExternModifier<'_> {
2621 fn span(&self) -> ::treesitter_types::Span {
2622 self.span
2623 }
2624}
2625#[derive(Debug, Clone)]
2626pub struct FieldDeclaration<'tree> {
2627 pub span: ::treesitter_types::Span,
2628 pub name: FieldIdentifier<'tree>,
2629 pub r#type: Type<'tree>,
2630 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2631}
2632impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
2633 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2634 fn from_node(
2635 node: ::tree_sitter::Node<'tree>,
2636 src: &'tree [u8],
2637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2638 debug_assert_eq!(node.kind(), "field_declaration");
2639 Ok(Self {
2640 span: ::treesitter_types::Span::from(node),
2641 name: {
2642 let child = node
2643 .child_by_field_name("name")
2644 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2645 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
2646 },
2647 r#type: {
2648 let child = node
2649 .child_by_field_name("type")
2650 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2651 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2652 },
2653 children: {
2654 #[allow(clippy::suspicious_else_formatting)]
2655 let non_field_children = {
2656 let mut cursor = node.walk();
2657 let mut result = ::std::vec::Vec::new();
2658 if cursor.goto_first_child() {
2659 loop {
2660 if cursor.field_name().is_none()
2661 && cursor.node().is_named()
2662 && !cursor.node().is_extra()
2663 {
2664 result.push(cursor.node());
2665 }
2666 if !cursor.goto_next_sibling() {
2667 break;
2668 }
2669 }
2670 }
2671 result
2672 };
2673 match non_field_children.first() {
2674 Some(&child) => Some(
2675 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
2676 child, src,
2677 )?,
2678 ),
2679 None => None,
2680 }
2681 },
2682 })
2683 }
2684}
2685impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
2686 fn span(&self) -> ::treesitter_types::Span {
2687 self.span
2688 }
2689}
2690#[derive(Debug, Clone)]
2691pub struct FieldDeclarationList<'tree> {
2692 pub span: ::treesitter_types::Span,
2693 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
2694}
2695impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
2696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2697 fn from_node(
2698 node: ::tree_sitter::Node<'tree>,
2699 src: &'tree [u8],
2700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2701 debug_assert_eq!(node.kind(), "field_declaration_list");
2702 Ok(Self {
2703 span: ::treesitter_types::Span::from(node),
2704 children: {
2705 #[allow(clippy::suspicious_else_formatting)]
2706 let non_field_children = {
2707 let mut cursor = node.walk();
2708 let mut result = ::std::vec::Vec::new();
2709 if cursor.goto_first_child() {
2710 loop {
2711 if cursor.field_name().is_none()
2712 && cursor.node().is_named()
2713 && !cursor.node().is_extra()
2714 {
2715 result.push(cursor.node());
2716 }
2717 if !cursor.goto_next_sibling() {
2718 break;
2719 }
2720 }
2721 }
2722 result
2723 };
2724 let mut items = ::std::vec::Vec::new();
2725 for child in non_field_children {
2726 items.push(
2727 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
2728 child, src,
2729 )?,
2730 );
2731 }
2732 items
2733 },
2734 })
2735 }
2736}
2737impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
2738 fn span(&self) -> ::treesitter_types::Span {
2739 self.span
2740 }
2741}
2742#[derive(Debug, Clone)]
2743pub struct FieldExpression<'tree> {
2744 pub span: ::treesitter_types::Span,
2745 pub field: FieldExpressionField<'tree>,
2746 pub value: Expression<'tree>,
2747}
2748impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
2749 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2750 fn from_node(
2751 node: ::tree_sitter::Node<'tree>,
2752 src: &'tree [u8],
2753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2754 debug_assert_eq!(node.kind(), "field_expression");
2755 Ok(Self {
2756 span: ::treesitter_types::Span::from(node),
2757 field: {
2758 let child = node
2759 .child_by_field_name("field")
2760 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
2761 <FieldExpressionField as ::treesitter_types::FromNode>::from_node(child, src)?
2762 },
2763 value: {
2764 let child = node
2765 .child_by_field_name("value")
2766 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2767 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2768 },
2769 })
2770 }
2771}
2772impl ::treesitter_types::Spanned for FieldExpression<'_> {
2773 fn span(&self) -> ::treesitter_types::Span {
2774 self.span
2775 }
2776}
2777#[derive(Debug, Clone)]
2778pub struct FieldInitializer<'tree> {
2779 pub span: ::treesitter_types::Span,
2780 pub field: FieldInitializerField<'tree>,
2781 pub value: Expression<'tree>,
2782 pub children: ::std::vec::Vec<AttributeItem<'tree>>,
2783}
2784impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializer<'tree> {
2785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2786 fn from_node(
2787 node: ::tree_sitter::Node<'tree>,
2788 src: &'tree [u8],
2789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2790 debug_assert_eq!(node.kind(), "field_initializer");
2791 Ok(Self {
2792 span: ::treesitter_types::Span::from(node),
2793 field: {
2794 let child = node
2795 .child_by_field_name("field")
2796 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
2797 <FieldInitializerField as ::treesitter_types::FromNode>::from_node(child, src)?
2798 },
2799 value: {
2800 let child = node
2801 .child_by_field_name("value")
2802 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2803 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2804 },
2805 children: {
2806 #[allow(clippy::suspicious_else_formatting)]
2807 let non_field_children = {
2808 let mut cursor = node.walk();
2809 let mut result = ::std::vec::Vec::new();
2810 if cursor.goto_first_child() {
2811 loop {
2812 if cursor.field_name().is_none()
2813 && cursor.node().is_named()
2814 && !cursor.node().is_extra()
2815 {
2816 result.push(cursor.node());
2817 }
2818 if !cursor.goto_next_sibling() {
2819 break;
2820 }
2821 }
2822 }
2823 result
2824 };
2825 let mut items = ::std::vec::Vec::new();
2826 for child in non_field_children {
2827 items.push(<AttributeItem as ::treesitter_types::FromNode>::from_node(
2828 child, src,
2829 )?);
2830 }
2831 items
2832 },
2833 })
2834 }
2835}
2836impl ::treesitter_types::Spanned for FieldInitializer<'_> {
2837 fn span(&self) -> ::treesitter_types::Span {
2838 self.span
2839 }
2840}
2841#[derive(Debug, Clone)]
2842pub struct FieldInitializerList<'tree> {
2843 pub span: ::treesitter_types::Span,
2844 pub children: ::std::vec::Vec<FieldInitializerListChildren<'tree>>,
2845}
2846impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerList<'tree> {
2847 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2848 fn from_node(
2849 node: ::tree_sitter::Node<'tree>,
2850 src: &'tree [u8],
2851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2852 debug_assert_eq!(node.kind(), "field_initializer_list");
2853 Ok(Self {
2854 span: ::treesitter_types::Span::from(node),
2855 children: {
2856 #[allow(clippy::suspicious_else_formatting)]
2857 let non_field_children = {
2858 let mut cursor = node.walk();
2859 let mut result = ::std::vec::Vec::new();
2860 if cursor.goto_first_child() {
2861 loop {
2862 if cursor.field_name().is_none()
2863 && cursor.node().is_named()
2864 && !cursor.node().is_extra()
2865 {
2866 result.push(cursor.node());
2867 }
2868 if !cursor.goto_next_sibling() {
2869 break;
2870 }
2871 }
2872 }
2873 result
2874 };
2875 let mut items = ::std::vec::Vec::new();
2876 for child in non_field_children {
2877 items.push(
2878 <FieldInitializerListChildren as ::treesitter_types::FromNode>::from_node(
2879 child, src,
2880 )?,
2881 );
2882 }
2883 items
2884 },
2885 })
2886 }
2887}
2888impl ::treesitter_types::Spanned for FieldInitializerList<'_> {
2889 fn span(&self) -> ::treesitter_types::Span {
2890 self.span
2891 }
2892}
2893#[derive(Debug, Clone)]
2894pub struct FieldPattern<'tree> {
2895 pub span: ::treesitter_types::Span,
2896 pub name: FieldPatternName<'tree>,
2897 pub pattern: ::core::option::Option<Pattern<'tree>>,
2898 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
2899}
2900impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPattern<'tree> {
2901 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2902 fn from_node(
2903 node: ::tree_sitter::Node<'tree>,
2904 src: &'tree [u8],
2905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2906 debug_assert_eq!(node.kind(), "field_pattern");
2907 Ok(Self {
2908 span: ::treesitter_types::Span::from(node),
2909 name: {
2910 let child = node
2911 .child_by_field_name("name")
2912 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2913 <FieldPatternName as ::treesitter_types::FromNode>::from_node(child, src)?
2914 },
2915 pattern: match node.child_by_field_name("pattern") {
2916 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
2917 child, src,
2918 )?),
2919 None => None,
2920 },
2921 children: {
2922 #[allow(clippy::suspicious_else_formatting)]
2923 let non_field_children = {
2924 let mut cursor = node.walk();
2925 let mut result = ::std::vec::Vec::new();
2926 if cursor.goto_first_child() {
2927 loop {
2928 if cursor.field_name().is_none()
2929 && cursor.node().is_named()
2930 && !cursor.node().is_extra()
2931 {
2932 result.push(cursor.node());
2933 }
2934 if !cursor.goto_next_sibling() {
2935 break;
2936 }
2937 }
2938 }
2939 result
2940 };
2941 match non_field_children.first() {
2942 Some(&child) => Some(
2943 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
2944 ),
2945 None => None,
2946 }
2947 },
2948 })
2949 }
2950}
2951impl ::treesitter_types::Spanned for FieldPattern<'_> {
2952 fn span(&self) -> ::treesitter_types::Span {
2953 self.span
2954 }
2955}
2956#[derive(Debug, Clone)]
2957pub struct ForExpression<'tree> {
2958 pub span: ::treesitter_types::Span,
2959 pub body: Block<'tree>,
2960 pub pattern: Pattern<'tree>,
2961 pub value: Expression<'tree>,
2962 pub children: ::core::option::Option<Label<'tree>>,
2963}
2964impl<'tree> ::treesitter_types::FromNode<'tree> for ForExpression<'tree> {
2965 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2966 fn from_node(
2967 node: ::tree_sitter::Node<'tree>,
2968 src: &'tree [u8],
2969 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2970 debug_assert_eq!(node.kind(), "for_expression");
2971 Ok(Self {
2972 span: ::treesitter_types::Span::from(node),
2973 body: {
2974 let child = node
2975 .child_by_field_name("body")
2976 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2977 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
2978 },
2979 pattern: {
2980 let child = node.child_by_field_name("pattern").ok_or_else(|| {
2981 ::treesitter_types::ParseError::missing_field("pattern", node)
2982 })?;
2983 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
2984 },
2985 value: {
2986 let child = node
2987 .child_by_field_name("value")
2988 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2989 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2990 },
2991 children: {
2992 #[allow(clippy::suspicious_else_formatting)]
2993 let non_field_children = {
2994 let mut cursor = node.walk();
2995 let mut result = ::std::vec::Vec::new();
2996 if cursor.goto_first_child() {
2997 loop {
2998 if cursor.field_name().is_none()
2999 && cursor.node().is_named()
3000 && !cursor.node().is_extra()
3001 {
3002 result.push(cursor.node());
3003 }
3004 if !cursor.goto_next_sibling() {
3005 break;
3006 }
3007 }
3008 }
3009 result
3010 };
3011 match non_field_children.first() {
3012 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
3013 child, src,
3014 )?),
3015 None => None,
3016 }
3017 },
3018 })
3019 }
3020}
3021impl ::treesitter_types::Spanned for ForExpression<'_> {
3022 fn span(&self) -> ::treesitter_types::Span {
3023 self.span
3024 }
3025}
3026#[derive(Debug, Clone)]
3027pub struct ForLifetimes<'tree> {
3028 pub span: ::treesitter_types::Span,
3029 pub children: ::std::vec::Vec<Lifetime<'tree>>,
3030}
3031impl<'tree> ::treesitter_types::FromNode<'tree> for ForLifetimes<'tree> {
3032 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3033 fn from_node(
3034 node: ::tree_sitter::Node<'tree>,
3035 src: &'tree [u8],
3036 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3037 debug_assert_eq!(node.kind(), "for_lifetimes");
3038 Ok(Self {
3039 span: ::treesitter_types::Span::from(node),
3040 children: {
3041 #[allow(clippy::suspicious_else_formatting)]
3042 let non_field_children = {
3043 let mut cursor = node.walk();
3044 let mut result = ::std::vec::Vec::new();
3045 if cursor.goto_first_child() {
3046 loop {
3047 if cursor.field_name().is_none()
3048 && cursor.node().is_named()
3049 && !cursor.node().is_extra()
3050 {
3051 result.push(cursor.node());
3052 }
3053 if !cursor.goto_next_sibling() {
3054 break;
3055 }
3056 }
3057 }
3058 result
3059 };
3060 let mut items = ::std::vec::Vec::new();
3061 for child in non_field_children {
3062 items.push(<Lifetime as ::treesitter_types::FromNode>::from_node(
3063 child, src,
3064 )?);
3065 }
3066 items
3067 },
3068 })
3069 }
3070}
3071impl ::treesitter_types::Spanned for ForLifetimes<'_> {
3072 fn span(&self) -> ::treesitter_types::Span {
3073 self.span
3074 }
3075}
3076#[derive(Debug, Clone)]
3077pub struct ForeignModItem<'tree> {
3078 pub span: ::treesitter_types::Span,
3079 pub body: ::core::option::Option<DeclarationList<'tree>>,
3080 pub children: ExternModifier<'tree>,
3081}
3082impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignModItem<'tree> {
3083 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3084 fn from_node(
3085 node: ::tree_sitter::Node<'tree>,
3086 src: &'tree [u8],
3087 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3088 debug_assert_eq!(node.kind(), "foreign_mod_item");
3089 Ok(Self {
3090 span: ::treesitter_types::Span::from(node),
3091 body: match node.child_by_field_name("body") {
3092 Some(child) => {
3093 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
3094 }
3095 None => None,
3096 },
3097 children: {
3098 #[allow(clippy::suspicious_else_formatting)]
3099 let non_field_children = {
3100 let mut cursor = node.walk();
3101 let mut result = ::std::vec::Vec::new();
3102 if cursor.goto_first_child() {
3103 loop {
3104 if cursor.field_name().is_none()
3105 && cursor.node().is_named()
3106 && !cursor.node().is_extra()
3107 {
3108 result.push(cursor.node());
3109 }
3110 if !cursor.goto_next_sibling() {
3111 break;
3112 }
3113 }
3114 }
3115 result
3116 };
3117 let child = if let Some(&c) = non_field_children.first() {
3118 c
3119 } else {
3120 let mut fallback_cursor = node.walk();
3121 let mut fallback_child = None;
3122 if fallback_cursor.goto_first_child() {
3123 loop {
3124 if fallback_cursor.field_name().is_none()
3125 && !fallback_cursor.node().is_extra()
3126 {
3127 fallback_child = Some(fallback_cursor.node());
3128 break;
3129 }
3130 if !fallback_cursor.goto_next_sibling() {
3131 break;
3132 }
3133 }
3134 }
3135 fallback_child.ok_or_else(|| {
3136 ::treesitter_types::ParseError::missing_field("children", node)
3137 })?
3138 };
3139 <ExternModifier as ::treesitter_types::FromNode>::from_node(child, src)?
3140 },
3141 })
3142 }
3143}
3144impl ::treesitter_types::Spanned for ForeignModItem<'_> {
3145 fn span(&self) -> ::treesitter_types::Span {
3146 self.span
3147 }
3148}
3149#[derive(Debug, Clone)]
3150pub struct FragmentSpecifier<'tree> {
3151 pub span: ::treesitter_types::Span,
3152 text: &'tree str,
3153}
3154impl<'tree> ::treesitter_types::FromNode<'tree> for FragmentSpecifier<'tree> {
3155 fn from_node(
3156 node: ::tree_sitter::Node<'tree>,
3157 src: &'tree [u8],
3158 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3159 debug_assert_eq!(node.kind(), "fragment_specifier");
3160 Ok(Self {
3161 span: ::treesitter_types::Span::from(node),
3162 text: node.utf8_text(src)?,
3163 })
3164 }
3165}
3166impl<'tree> ::treesitter_types::LeafNode<'tree> for FragmentSpecifier<'tree> {
3167 fn text(&self) -> &'tree str {
3168 self.text
3169 }
3170}
3171impl ::treesitter_types::Spanned for FragmentSpecifier<'_> {
3172 fn span(&self) -> ::treesitter_types::Span {
3173 self.span
3174 }
3175}
3176#[derive(Debug, Clone)]
3177pub struct FunctionItem<'tree> {
3178 pub span: ::treesitter_types::Span,
3179 pub body: Block<'tree>,
3180 pub name: FunctionItemName<'tree>,
3181 pub parameters: Parameters<'tree>,
3182 pub return_type: ::core::option::Option<Type<'tree>>,
3183 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3184 pub children: ::std::vec::Vec<FunctionItemChildren<'tree>>,
3185}
3186impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItem<'tree> {
3187 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3188 fn from_node(
3189 node: ::tree_sitter::Node<'tree>,
3190 src: &'tree [u8],
3191 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3192 debug_assert_eq!(node.kind(), "function_item");
3193 Ok(Self {
3194 span: ::treesitter_types::Span::from(node),
3195 body: {
3196 let child = node
3197 .child_by_field_name("body")
3198 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3199 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3200 },
3201 name: {
3202 let child = node
3203 .child_by_field_name("name")
3204 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3205 <FunctionItemName as ::treesitter_types::FromNode>::from_node(child, src)?
3206 },
3207 parameters: {
3208 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3209 ::treesitter_types::ParseError::missing_field("parameters", node)
3210 })?;
3211 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3212 },
3213 return_type: match node.child_by_field_name("return_type") {
3214 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3215 child, src,
3216 )?),
3217 None => None,
3218 },
3219 type_parameters: match node.child_by_field_name("type_parameters") {
3220 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3221 child, src,
3222 )?),
3223 None => None,
3224 },
3225 children: {
3226 #[allow(clippy::suspicious_else_formatting)]
3227 let non_field_children = {
3228 let mut cursor = node.walk();
3229 let mut result = ::std::vec::Vec::new();
3230 if cursor.goto_first_child() {
3231 loop {
3232 if cursor.field_name().is_none()
3233 && cursor.node().is_named()
3234 && !cursor.node().is_extra()
3235 {
3236 result.push(cursor.node());
3237 }
3238 if !cursor.goto_next_sibling() {
3239 break;
3240 }
3241 }
3242 }
3243 result
3244 };
3245 let mut items = ::std::vec::Vec::new();
3246 for child in non_field_children {
3247 items.push(
3248 <FunctionItemChildren as ::treesitter_types::FromNode>::from_node(
3249 child, src,
3250 )?,
3251 );
3252 }
3253 items
3254 },
3255 })
3256 }
3257}
3258impl ::treesitter_types::Spanned for FunctionItem<'_> {
3259 fn span(&self) -> ::treesitter_types::Span {
3260 self.span
3261 }
3262}
3263#[derive(Debug, Clone)]
3264pub struct FunctionModifiers<'tree> {
3265 pub span: ::treesitter_types::Span,
3266 pub children: ::std::vec::Vec<ExternModifier<'tree>>,
3267}
3268impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionModifiers<'tree> {
3269 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3270 fn from_node(
3271 node: ::tree_sitter::Node<'tree>,
3272 src: &'tree [u8],
3273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3274 debug_assert_eq!(node.kind(), "function_modifiers");
3275 Ok(Self {
3276 span: ::treesitter_types::Span::from(node),
3277 children: {
3278 #[allow(clippy::suspicious_else_formatting)]
3279 let non_field_children = {
3280 let mut cursor = node.walk();
3281 let mut result = ::std::vec::Vec::new();
3282 if cursor.goto_first_child() {
3283 loop {
3284 if cursor.field_name().is_none()
3285 && cursor.node().is_named()
3286 && !cursor.node().is_extra()
3287 {
3288 result.push(cursor.node());
3289 }
3290 if !cursor.goto_next_sibling() {
3291 break;
3292 }
3293 }
3294 }
3295 result
3296 };
3297 let mut items = ::std::vec::Vec::new();
3298 for child in non_field_children {
3299 items.push(<ExternModifier as ::treesitter_types::FromNode>::from_node(
3300 child, src,
3301 )?);
3302 }
3303 items
3304 },
3305 })
3306 }
3307}
3308impl ::treesitter_types::Spanned for FunctionModifiers<'_> {
3309 fn span(&self) -> ::treesitter_types::Span {
3310 self.span
3311 }
3312}
3313#[derive(Debug, Clone)]
3314pub struct FunctionSignatureItem<'tree> {
3315 pub span: ::treesitter_types::Span,
3316 pub name: FunctionSignatureItemName<'tree>,
3317 pub parameters: Parameters<'tree>,
3318 pub return_type: ::core::option::Option<Type<'tree>>,
3319 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3320 pub children: ::std::vec::Vec<FunctionSignatureItemChildren<'tree>>,
3321}
3322impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItem<'tree> {
3323 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3324 fn from_node(
3325 node: ::tree_sitter::Node<'tree>,
3326 src: &'tree [u8],
3327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3328 debug_assert_eq!(node.kind(), "function_signature_item");
3329 Ok(Self {
3330 span: ::treesitter_types::Span::from(node),
3331 name: {
3332 let child = node
3333 .child_by_field_name("name")
3334 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3335 <FunctionSignatureItemName as ::treesitter_types::FromNode>::from_node(child, src)?
3336 },
3337 parameters: {
3338 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3339 ::treesitter_types::ParseError::missing_field("parameters", node)
3340 })?;
3341 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3342 },
3343 return_type: match node.child_by_field_name("return_type") {
3344 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3345 child, src,
3346 )?),
3347 None => None,
3348 },
3349 type_parameters: match node.child_by_field_name("type_parameters") {
3350 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3351 child, src,
3352 )?),
3353 None => None,
3354 },
3355 children: {
3356 #[allow(clippy::suspicious_else_formatting)]
3357 let non_field_children = {
3358 let mut cursor = node.walk();
3359 let mut result = ::std::vec::Vec::new();
3360 if cursor.goto_first_child() {
3361 loop {
3362 if cursor.field_name().is_none()
3363 && cursor.node().is_named()
3364 && !cursor.node().is_extra()
3365 {
3366 result.push(cursor.node());
3367 }
3368 if !cursor.goto_next_sibling() {
3369 break;
3370 }
3371 }
3372 }
3373 result
3374 };
3375 let mut items = ::std::vec::Vec::new();
3376 for child in non_field_children {
3377 items.push(
3378 <FunctionSignatureItemChildren as ::treesitter_types::FromNode>::from_node(
3379 child, src,
3380 )?,
3381 );
3382 }
3383 items
3384 },
3385 })
3386 }
3387}
3388impl ::treesitter_types::Spanned for FunctionSignatureItem<'_> {
3389 fn span(&self) -> ::treesitter_types::Span {
3390 self.span
3391 }
3392}
3393#[derive(Debug, Clone)]
3394pub struct FunctionType<'tree> {
3395 pub span: ::treesitter_types::Span,
3396 pub parameters: Parameters<'tree>,
3397 pub return_type: ::core::option::Option<Type<'tree>>,
3398 pub r#trait: ::core::option::Option<FunctionTypeTrait<'tree>>,
3399 pub children: ::std::vec::Vec<FunctionTypeChildren<'tree>>,
3400}
3401impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
3402 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3403 fn from_node(
3404 node: ::tree_sitter::Node<'tree>,
3405 src: &'tree [u8],
3406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3407 debug_assert_eq!(node.kind(), "function_type");
3408 Ok(Self {
3409 span: ::treesitter_types::Span::from(node),
3410 parameters: {
3411 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3412 ::treesitter_types::ParseError::missing_field("parameters", node)
3413 })?;
3414 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3415 },
3416 return_type: match node.child_by_field_name("return_type") {
3417 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3418 child, src,
3419 )?),
3420 None => None,
3421 },
3422 r#trait: match node.child_by_field_name("trait") {
3423 Some(child) => Some(
3424 <FunctionTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)?,
3425 ),
3426 None => None,
3427 },
3428 children: {
3429 #[allow(clippy::suspicious_else_formatting)]
3430 let non_field_children = {
3431 let mut cursor = node.walk();
3432 let mut result = ::std::vec::Vec::new();
3433 if cursor.goto_first_child() {
3434 loop {
3435 if cursor.field_name().is_none()
3436 && cursor.node().is_named()
3437 && !cursor.node().is_extra()
3438 {
3439 result.push(cursor.node());
3440 }
3441 if !cursor.goto_next_sibling() {
3442 break;
3443 }
3444 }
3445 }
3446 result
3447 };
3448 let mut items = ::std::vec::Vec::new();
3449 for child in non_field_children {
3450 items.push(
3451 <FunctionTypeChildren as ::treesitter_types::FromNode>::from_node(
3452 child, src,
3453 )?,
3454 );
3455 }
3456 items
3457 },
3458 })
3459 }
3460}
3461impl ::treesitter_types::Spanned for FunctionType<'_> {
3462 fn span(&self) -> ::treesitter_types::Span {
3463 self.span
3464 }
3465}
3466#[derive(Debug, Clone)]
3467pub struct GenBlock<'tree> {
3468 pub span: ::treesitter_types::Span,
3469 pub children: Block<'tree>,
3470}
3471impl<'tree> ::treesitter_types::FromNode<'tree> for GenBlock<'tree> {
3472 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3473 fn from_node(
3474 node: ::tree_sitter::Node<'tree>,
3475 src: &'tree [u8],
3476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3477 debug_assert_eq!(node.kind(), "gen_block");
3478 Ok(Self {
3479 span: ::treesitter_types::Span::from(node),
3480 children: {
3481 #[allow(clippy::suspicious_else_formatting)]
3482 let non_field_children = {
3483 let mut cursor = node.walk();
3484 let mut result = ::std::vec::Vec::new();
3485 if cursor.goto_first_child() {
3486 loop {
3487 if cursor.field_name().is_none()
3488 && cursor.node().is_named()
3489 && !cursor.node().is_extra()
3490 {
3491 result.push(cursor.node());
3492 }
3493 if !cursor.goto_next_sibling() {
3494 break;
3495 }
3496 }
3497 }
3498 result
3499 };
3500 let child = if let Some(&c) = non_field_children.first() {
3501 c
3502 } else {
3503 let mut fallback_cursor = node.walk();
3504 let mut fallback_child = None;
3505 if fallback_cursor.goto_first_child() {
3506 loop {
3507 if fallback_cursor.field_name().is_none()
3508 && !fallback_cursor.node().is_extra()
3509 {
3510 fallback_child = Some(fallback_cursor.node());
3511 break;
3512 }
3513 if !fallback_cursor.goto_next_sibling() {
3514 break;
3515 }
3516 }
3517 }
3518 fallback_child.ok_or_else(|| {
3519 ::treesitter_types::ParseError::missing_field("children", node)
3520 })?
3521 };
3522 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3523 },
3524 })
3525 }
3526}
3527impl ::treesitter_types::Spanned for GenBlock<'_> {
3528 fn span(&self) -> ::treesitter_types::Span {
3529 self.span
3530 }
3531}
3532#[derive(Debug, Clone)]
3533pub struct GenericFunction<'tree> {
3534 pub span: ::treesitter_types::Span,
3535 pub function: GenericFunctionFunction<'tree>,
3536 pub type_arguments: TypeArguments<'tree>,
3537}
3538impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunction<'tree> {
3539 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3540 fn from_node(
3541 node: ::tree_sitter::Node<'tree>,
3542 src: &'tree [u8],
3543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3544 debug_assert_eq!(node.kind(), "generic_function");
3545 Ok(Self {
3546 span: ::treesitter_types::Span::from(node),
3547 function: {
3548 let child = node.child_by_field_name("function").ok_or_else(|| {
3549 ::treesitter_types::ParseError::missing_field("function", node)
3550 })?;
3551 <GenericFunctionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
3552 },
3553 type_arguments: {
3554 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
3555 ::treesitter_types::ParseError::missing_field("type_arguments", node)
3556 })?;
3557 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
3558 },
3559 })
3560 }
3561}
3562impl ::treesitter_types::Spanned for GenericFunction<'_> {
3563 fn span(&self) -> ::treesitter_types::Span {
3564 self.span
3565 }
3566}
3567#[derive(Debug, Clone)]
3568pub struct GenericPattern<'tree> {
3569 pub span: ::treesitter_types::Span,
3570 pub type_arguments: TypeArguments<'tree>,
3571 pub children: GenericPatternChildren<'tree>,
3572}
3573impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPattern<'tree> {
3574 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3575 fn from_node(
3576 node: ::tree_sitter::Node<'tree>,
3577 src: &'tree [u8],
3578 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3579 debug_assert_eq!(node.kind(), "generic_pattern");
3580 Ok(Self {
3581 span: ::treesitter_types::Span::from(node),
3582 type_arguments: {
3583 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
3584 ::treesitter_types::ParseError::missing_field("type_arguments", node)
3585 })?;
3586 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
3587 },
3588 children: {
3589 #[allow(clippy::suspicious_else_formatting)]
3590 let non_field_children = {
3591 let mut cursor = node.walk();
3592 let mut result = ::std::vec::Vec::new();
3593 if cursor.goto_first_child() {
3594 loop {
3595 if cursor.field_name().is_none()
3596 && cursor.node().is_named()
3597 && !cursor.node().is_extra()
3598 {
3599 result.push(cursor.node());
3600 }
3601 if !cursor.goto_next_sibling() {
3602 break;
3603 }
3604 }
3605 }
3606 result
3607 };
3608 let child = if let Some(&c) = non_field_children.first() {
3609 c
3610 } else {
3611 let mut fallback_cursor = node.walk();
3612 let mut fallback_child = None;
3613 if fallback_cursor.goto_first_child() {
3614 loop {
3615 if fallback_cursor.field_name().is_none()
3616 && !fallback_cursor.node().is_extra()
3617 {
3618 fallback_child = Some(fallback_cursor.node());
3619 break;
3620 }
3621 if !fallback_cursor.goto_next_sibling() {
3622 break;
3623 }
3624 }
3625 }
3626 fallback_child.ok_or_else(|| {
3627 ::treesitter_types::ParseError::missing_field("children", node)
3628 })?
3629 };
3630 <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3631 },
3632 })
3633 }
3634}
3635impl ::treesitter_types::Spanned for GenericPattern<'_> {
3636 fn span(&self) -> ::treesitter_types::Span {
3637 self.span
3638 }
3639}
3640#[derive(Debug, Clone)]
3641pub struct GenericType<'tree> {
3642 pub span: ::treesitter_types::Span,
3643 pub r#type: GenericTypeType<'tree>,
3644 pub type_arguments: TypeArguments<'tree>,
3645}
3646impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
3647 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3648 fn from_node(
3649 node: ::tree_sitter::Node<'tree>,
3650 src: &'tree [u8],
3651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3652 debug_assert_eq!(node.kind(), "generic_type");
3653 Ok(Self {
3654 span: ::treesitter_types::Span::from(node),
3655 r#type: {
3656 let child = node
3657 .child_by_field_name("type")
3658 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3659 <GenericTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
3660 },
3661 type_arguments: {
3662 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
3663 ::treesitter_types::ParseError::missing_field("type_arguments", node)
3664 })?;
3665 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
3666 },
3667 })
3668 }
3669}
3670impl ::treesitter_types::Spanned for GenericType<'_> {
3671 fn span(&self) -> ::treesitter_types::Span {
3672 self.span
3673 }
3674}
3675#[derive(Debug, Clone)]
3676pub struct GenericTypeWithTurbofish<'tree> {
3677 pub span: ::treesitter_types::Span,
3678 pub r#type: GenericTypeWithTurbofishType<'tree>,
3679 pub type_arguments: TypeArguments<'tree>,
3680}
3681impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofish<'tree> {
3682 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3683 fn from_node(
3684 node: ::tree_sitter::Node<'tree>,
3685 src: &'tree [u8],
3686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3687 debug_assert_eq!(node.kind(), "generic_type_with_turbofish");
3688 Ok(Self {
3689 span: ::treesitter_types::Span::from(node),
3690 r#type: {
3691 let child = node
3692 .child_by_field_name("type")
3693 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3694 <GenericTypeWithTurbofishType as ::treesitter_types::FromNode>::from_node(
3695 child, src,
3696 )?
3697 },
3698 type_arguments: {
3699 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
3700 ::treesitter_types::ParseError::missing_field("type_arguments", node)
3701 })?;
3702 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
3703 },
3704 })
3705 }
3706}
3707impl ::treesitter_types::Spanned for GenericTypeWithTurbofish<'_> {
3708 fn span(&self) -> ::treesitter_types::Span {
3709 self.span
3710 }
3711}
3712#[derive(Debug, Clone)]
3713pub struct HigherRankedTraitBound<'tree> {
3714 pub span: ::treesitter_types::Span,
3715 pub r#type: Type<'tree>,
3716 pub type_parameters: TypeParameters<'tree>,
3717}
3718impl<'tree> ::treesitter_types::FromNode<'tree> for HigherRankedTraitBound<'tree> {
3719 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3720 fn from_node(
3721 node: ::tree_sitter::Node<'tree>,
3722 src: &'tree [u8],
3723 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3724 debug_assert_eq!(node.kind(), "higher_ranked_trait_bound");
3725 Ok(Self {
3726 span: ::treesitter_types::Span::from(node),
3727 r#type: {
3728 let child = node
3729 .child_by_field_name("type")
3730 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3731 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3732 },
3733 type_parameters: {
3734 let child = node.child_by_field_name("type_parameters").ok_or_else(|| {
3735 ::treesitter_types::ParseError::missing_field("type_parameters", node)
3736 })?;
3737 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3738 },
3739 })
3740 }
3741}
3742impl ::treesitter_types::Spanned for HigherRankedTraitBound<'_> {
3743 fn span(&self) -> ::treesitter_types::Span {
3744 self.span
3745 }
3746}
3747#[derive(Debug, Clone)]
3748pub struct IfExpression<'tree> {
3749 pub span: ::treesitter_types::Span,
3750 pub alternative: ::core::option::Option<ElseClause<'tree>>,
3751 pub condition: IfExpressionCondition<'tree>,
3752 pub consequence: Block<'tree>,
3753}
3754impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpression<'tree> {
3755 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3756 fn from_node(
3757 node: ::tree_sitter::Node<'tree>,
3758 src: &'tree [u8],
3759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3760 debug_assert_eq!(node.kind(), "if_expression");
3761 Ok(Self {
3762 span: ::treesitter_types::Span::from(node),
3763 alternative: match node.child_by_field_name("alternative") {
3764 Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
3765 child, src,
3766 )?),
3767 None => None,
3768 },
3769 condition: {
3770 let child = node.child_by_field_name("condition").ok_or_else(|| {
3771 ::treesitter_types::ParseError::missing_field("condition", node)
3772 })?;
3773 <IfExpressionCondition as ::treesitter_types::FromNode>::from_node(child, src)?
3774 },
3775 consequence: {
3776 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3777 ::treesitter_types::ParseError::missing_field("consequence", node)
3778 })?;
3779 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3780 },
3781 })
3782 }
3783}
3784impl ::treesitter_types::Spanned for IfExpression<'_> {
3785 fn span(&self) -> ::treesitter_types::Span {
3786 self.span
3787 }
3788}
3789#[derive(Debug, Clone)]
3790pub struct ImplItem<'tree> {
3791 pub span: ::treesitter_types::Span,
3792 pub body: ::core::option::Option<DeclarationList<'tree>>,
3793 pub r#trait: ::core::option::Option<ImplItemTrait<'tree>>,
3794 pub r#type: Type<'tree>,
3795 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3796 pub children: ::core::option::Option<WhereClause<'tree>>,
3797}
3798impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItem<'tree> {
3799 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3800 fn from_node(
3801 node: ::tree_sitter::Node<'tree>,
3802 src: &'tree [u8],
3803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3804 debug_assert_eq!(node.kind(), "impl_item");
3805 Ok(Self {
3806 span: ::treesitter_types::Span::from(node),
3807 body: match node.child_by_field_name("body") {
3808 Some(child) => {
3809 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
3810 }
3811 None => None,
3812 },
3813 r#trait: match node.child_by_field_name("trait") {
3814 Some(child) => Some(<ImplItemTrait as ::treesitter_types::FromNode>::from_node(
3815 child, src,
3816 )?),
3817 None => None,
3818 },
3819 r#type: {
3820 let child = node
3821 .child_by_field_name("type")
3822 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3823 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3824 },
3825 type_parameters: match node.child_by_field_name("type_parameters") {
3826 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3827 child, src,
3828 )?),
3829 None => None,
3830 },
3831 children: {
3832 #[allow(clippy::suspicious_else_formatting)]
3833 let non_field_children = {
3834 let mut cursor = node.walk();
3835 let mut result = ::std::vec::Vec::new();
3836 if cursor.goto_first_child() {
3837 loop {
3838 if cursor.field_name().is_none()
3839 && cursor.node().is_named()
3840 && !cursor.node().is_extra()
3841 {
3842 result.push(cursor.node());
3843 }
3844 if !cursor.goto_next_sibling() {
3845 break;
3846 }
3847 }
3848 }
3849 result
3850 };
3851 match non_field_children.first() {
3852 Some(&child) => Some(<WhereClause as ::treesitter_types::FromNode>::from_node(
3853 child, src,
3854 )?),
3855 None => None,
3856 }
3857 },
3858 })
3859 }
3860}
3861impl ::treesitter_types::Spanned for ImplItem<'_> {
3862 fn span(&self) -> ::treesitter_types::Span {
3863 self.span
3864 }
3865}
3866#[derive(Debug, Clone)]
3867pub struct IndexExpression<'tree> {
3868 pub span: ::treesitter_types::Span,
3869 pub children: ::std::vec::Vec<Expression<'tree>>,
3870}
3871impl<'tree> ::treesitter_types::FromNode<'tree> for IndexExpression<'tree> {
3872 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3873 fn from_node(
3874 node: ::tree_sitter::Node<'tree>,
3875 src: &'tree [u8],
3876 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3877 debug_assert_eq!(node.kind(), "index_expression");
3878 Ok(Self {
3879 span: ::treesitter_types::Span::from(node),
3880 children: {
3881 #[allow(clippy::suspicious_else_formatting)]
3882 let non_field_children = {
3883 let mut cursor = node.walk();
3884 let mut result = ::std::vec::Vec::new();
3885 if cursor.goto_first_child() {
3886 loop {
3887 if cursor.field_name().is_none()
3888 && cursor.node().is_named()
3889 && !cursor.node().is_extra()
3890 {
3891 result.push(cursor.node());
3892 }
3893 if !cursor.goto_next_sibling() {
3894 break;
3895 }
3896 }
3897 }
3898 result
3899 };
3900 let mut items = ::std::vec::Vec::new();
3901 for child in non_field_children {
3902 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
3903 child, src,
3904 )?);
3905 }
3906 items
3907 },
3908 })
3909 }
3910}
3911impl ::treesitter_types::Spanned for IndexExpression<'_> {
3912 fn span(&self) -> ::treesitter_types::Span {
3913 self.span
3914 }
3915}
3916#[derive(Debug, Clone)]
3917pub struct InnerAttributeItem<'tree> {
3918 pub span: ::treesitter_types::Span,
3919 pub children: Attribute<'tree>,
3920}
3921impl<'tree> ::treesitter_types::FromNode<'tree> for InnerAttributeItem<'tree> {
3922 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3923 fn from_node(
3924 node: ::tree_sitter::Node<'tree>,
3925 src: &'tree [u8],
3926 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3927 debug_assert_eq!(node.kind(), "inner_attribute_item");
3928 Ok(Self {
3929 span: ::treesitter_types::Span::from(node),
3930 children: {
3931 #[allow(clippy::suspicious_else_formatting)]
3932 let non_field_children = {
3933 let mut cursor = node.walk();
3934 let mut result = ::std::vec::Vec::new();
3935 if cursor.goto_first_child() {
3936 loop {
3937 if cursor.field_name().is_none()
3938 && cursor.node().is_named()
3939 && !cursor.node().is_extra()
3940 {
3941 result.push(cursor.node());
3942 }
3943 if !cursor.goto_next_sibling() {
3944 break;
3945 }
3946 }
3947 }
3948 result
3949 };
3950 let child = if let Some(&c) = non_field_children.first() {
3951 c
3952 } else {
3953 let mut fallback_cursor = node.walk();
3954 let mut fallback_child = None;
3955 if fallback_cursor.goto_first_child() {
3956 loop {
3957 if fallback_cursor.field_name().is_none()
3958 && !fallback_cursor.node().is_extra()
3959 {
3960 fallback_child = Some(fallback_cursor.node());
3961 break;
3962 }
3963 if !fallback_cursor.goto_next_sibling() {
3964 break;
3965 }
3966 }
3967 }
3968 fallback_child.ok_or_else(|| {
3969 ::treesitter_types::ParseError::missing_field("children", node)
3970 })?
3971 };
3972 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)?
3973 },
3974 })
3975 }
3976}
3977impl ::treesitter_types::Spanned for InnerAttributeItem<'_> {
3978 fn span(&self) -> ::treesitter_types::Span {
3979 self.span
3980 }
3981}
3982#[derive(Debug, Clone)]
3983pub struct InnerDocCommentMarker<'tree> {
3984 pub span: ::treesitter_types::Span,
3985 text: &'tree str,
3986}
3987impl<'tree> ::treesitter_types::FromNode<'tree> for InnerDocCommentMarker<'tree> {
3988 fn from_node(
3989 node: ::tree_sitter::Node<'tree>,
3990 src: &'tree [u8],
3991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3992 debug_assert_eq!(node.kind(), "inner_doc_comment_marker");
3993 Ok(Self {
3994 span: ::treesitter_types::Span::from(node),
3995 text: node.utf8_text(src)?,
3996 })
3997 }
3998}
3999impl<'tree> ::treesitter_types::LeafNode<'tree> for InnerDocCommentMarker<'tree> {
4000 fn text(&self) -> &'tree str {
4001 self.text
4002 }
4003}
4004impl ::treesitter_types::Spanned for InnerDocCommentMarker<'_> {
4005 fn span(&self) -> ::treesitter_types::Span {
4006 self.span
4007 }
4008}
4009#[derive(Debug, Clone)]
4010pub struct Label<'tree> {
4011 pub span: ::treesitter_types::Span,
4012 pub children: Identifier<'tree>,
4013}
4014impl<'tree> ::treesitter_types::FromNode<'tree> for Label<'tree> {
4015 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4016 fn from_node(
4017 node: ::tree_sitter::Node<'tree>,
4018 src: &'tree [u8],
4019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4020 debug_assert_eq!(node.kind(), "label");
4021 Ok(Self {
4022 span: ::treesitter_types::Span::from(node),
4023 children: {
4024 #[allow(clippy::suspicious_else_formatting)]
4025 let non_field_children = {
4026 let mut cursor = node.walk();
4027 let mut result = ::std::vec::Vec::new();
4028 if cursor.goto_first_child() {
4029 loop {
4030 if cursor.field_name().is_none()
4031 && cursor.node().is_named()
4032 && !cursor.node().is_extra()
4033 {
4034 result.push(cursor.node());
4035 }
4036 if !cursor.goto_next_sibling() {
4037 break;
4038 }
4039 }
4040 }
4041 result
4042 };
4043 let child = if let Some(&c) = non_field_children.first() {
4044 c
4045 } else {
4046 let mut fallback_cursor = node.walk();
4047 let mut fallback_child = None;
4048 if fallback_cursor.goto_first_child() {
4049 loop {
4050 if fallback_cursor.field_name().is_none()
4051 && !fallback_cursor.node().is_extra()
4052 {
4053 fallback_child = Some(fallback_cursor.node());
4054 break;
4055 }
4056 if !fallback_cursor.goto_next_sibling() {
4057 break;
4058 }
4059 }
4060 }
4061 fallback_child.ok_or_else(|| {
4062 ::treesitter_types::ParseError::missing_field("children", node)
4063 })?
4064 };
4065 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4066 },
4067 })
4068 }
4069}
4070impl ::treesitter_types::Spanned for Label<'_> {
4071 fn span(&self) -> ::treesitter_types::Span {
4072 self.span
4073 }
4074}
4075#[derive(Debug, Clone)]
4076pub struct LetChain<'tree> {
4077 pub span: ::treesitter_types::Span,
4078 pub children: ::std::vec::Vec<LetChainChildren<'tree>>,
4079}
4080impl<'tree> ::treesitter_types::FromNode<'tree> for LetChain<'tree> {
4081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4082 fn from_node(
4083 node: ::tree_sitter::Node<'tree>,
4084 src: &'tree [u8],
4085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4086 debug_assert_eq!(node.kind(), "let_chain");
4087 Ok(Self {
4088 span: ::treesitter_types::Span::from(node),
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(
4112 <LetChainChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4113 );
4114 }
4115 items
4116 },
4117 })
4118 }
4119}
4120impl ::treesitter_types::Spanned for LetChain<'_> {
4121 fn span(&self) -> ::treesitter_types::Span {
4122 self.span
4123 }
4124}
4125#[derive(Debug, Clone)]
4126pub struct LetCondition<'tree> {
4127 pub span: ::treesitter_types::Span,
4128 pub pattern: Pattern<'tree>,
4129 pub value: Expression<'tree>,
4130}
4131impl<'tree> ::treesitter_types::FromNode<'tree> for LetCondition<'tree> {
4132 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4133 fn from_node(
4134 node: ::tree_sitter::Node<'tree>,
4135 src: &'tree [u8],
4136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4137 debug_assert_eq!(node.kind(), "let_condition");
4138 Ok(Self {
4139 span: ::treesitter_types::Span::from(node),
4140 pattern: {
4141 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4142 ::treesitter_types::ParseError::missing_field("pattern", node)
4143 })?;
4144 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
4145 },
4146 value: {
4147 let child = node
4148 .child_by_field_name("value")
4149 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4150 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4151 },
4152 })
4153 }
4154}
4155impl ::treesitter_types::Spanned for LetCondition<'_> {
4156 fn span(&self) -> ::treesitter_types::Span {
4157 self.span
4158 }
4159}
4160#[derive(Debug, Clone)]
4161pub struct LetDeclaration<'tree> {
4162 pub span: ::treesitter_types::Span,
4163 pub alternative: ::core::option::Option<Block<'tree>>,
4164 pub pattern: Pattern<'tree>,
4165 pub r#type: ::core::option::Option<Type<'tree>>,
4166 pub value: ::core::option::Option<Expression<'tree>>,
4167 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
4168}
4169impl<'tree> ::treesitter_types::FromNode<'tree> for LetDeclaration<'tree> {
4170 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4171 fn from_node(
4172 node: ::tree_sitter::Node<'tree>,
4173 src: &'tree [u8],
4174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4175 debug_assert_eq!(node.kind(), "let_declaration");
4176 Ok(Self {
4177 span: ::treesitter_types::Span::from(node),
4178 alternative: match node.child_by_field_name("alternative") {
4179 Some(child) => Some(<Block as ::treesitter_types::FromNode>::from_node(
4180 child, src,
4181 )?),
4182 None => None,
4183 },
4184 pattern: {
4185 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4186 ::treesitter_types::ParseError::missing_field("pattern", node)
4187 })?;
4188 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
4189 },
4190 r#type: match node.child_by_field_name("type") {
4191 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
4192 child, src,
4193 )?),
4194 None => None,
4195 },
4196 value: match node.child_by_field_name("value") {
4197 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4198 child, src,
4199 )?),
4200 None => None,
4201 },
4202 children: {
4203 #[allow(clippy::suspicious_else_formatting)]
4204 let non_field_children = {
4205 let mut cursor = node.walk();
4206 let mut result = ::std::vec::Vec::new();
4207 if cursor.goto_first_child() {
4208 loop {
4209 if cursor.field_name().is_none()
4210 && cursor.node().is_named()
4211 && !cursor.node().is_extra()
4212 {
4213 result.push(cursor.node());
4214 }
4215 if !cursor.goto_next_sibling() {
4216 break;
4217 }
4218 }
4219 }
4220 result
4221 };
4222 match non_field_children.first() {
4223 Some(&child) => Some(
4224 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
4225 ),
4226 None => None,
4227 }
4228 },
4229 })
4230 }
4231}
4232impl ::treesitter_types::Spanned for LetDeclaration<'_> {
4233 fn span(&self) -> ::treesitter_types::Span {
4234 self.span
4235 }
4236}
4237#[derive(Debug, Clone)]
4238pub struct Lifetime<'tree> {
4239 pub span: ::treesitter_types::Span,
4240 pub children: Identifier<'tree>,
4241}
4242impl<'tree> ::treesitter_types::FromNode<'tree> for Lifetime<'tree> {
4243 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4244 fn from_node(
4245 node: ::tree_sitter::Node<'tree>,
4246 src: &'tree [u8],
4247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4248 debug_assert_eq!(node.kind(), "lifetime");
4249 Ok(Self {
4250 span: ::treesitter_types::Span::from(node),
4251 children: {
4252 #[allow(clippy::suspicious_else_formatting)]
4253 let non_field_children = {
4254 let mut cursor = node.walk();
4255 let mut result = ::std::vec::Vec::new();
4256 if cursor.goto_first_child() {
4257 loop {
4258 if cursor.field_name().is_none()
4259 && cursor.node().is_named()
4260 && !cursor.node().is_extra()
4261 {
4262 result.push(cursor.node());
4263 }
4264 if !cursor.goto_next_sibling() {
4265 break;
4266 }
4267 }
4268 }
4269 result
4270 };
4271 let child = if let Some(&c) = non_field_children.first() {
4272 c
4273 } else {
4274 let mut fallback_cursor = node.walk();
4275 let mut fallback_child = None;
4276 if fallback_cursor.goto_first_child() {
4277 loop {
4278 if fallback_cursor.field_name().is_none()
4279 && !fallback_cursor.node().is_extra()
4280 {
4281 fallback_child = Some(fallback_cursor.node());
4282 break;
4283 }
4284 if !fallback_cursor.goto_next_sibling() {
4285 break;
4286 }
4287 }
4288 }
4289 fallback_child.ok_or_else(|| {
4290 ::treesitter_types::ParseError::missing_field("children", node)
4291 })?
4292 };
4293 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4294 },
4295 })
4296 }
4297}
4298impl ::treesitter_types::Spanned for Lifetime<'_> {
4299 fn span(&self) -> ::treesitter_types::Span {
4300 self.span
4301 }
4302}
4303#[derive(Debug, Clone)]
4304pub struct LifetimeParameter<'tree> {
4305 pub span: ::treesitter_types::Span,
4306 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
4307 pub name: Lifetime<'tree>,
4308}
4309impl<'tree> ::treesitter_types::FromNode<'tree> for LifetimeParameter<'tree> {
4310 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4311 fn from_node(
4312 node: ::tree_sitter::Node<'tree>,
4313 src: &'tree [u8],
4314 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4315 debug_assert_eq!(node.kind(), "lifetime_parameter");
4316 Ok(Self {
4317 span: ::treesitter_types::Span::from(node),
4318 bounds: match node.child_by_field_name("bounds") {
4319 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
4320 child, src,
4321 )?),
4322 None => None,
4323 },
4324 name: {
4325 let child = node
4326 .child_by_field_name("name")
4327 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4328 <Lifetime as ::treesitter_types::FromNode>::from_node(child, src)?
4329 },
4330 })
4331 }
4332}
4333impl ::treesitter_types::Spanned for LifetimeParameter<'_> {
4334 fn span(&self) -> ::treesitter_types::Span {
4335 self.span
4336 }
4337}
4338#[derive(Debug, Clone)]
4339pub struct LineComment<'tree> {
4340 pub span: ::treesitter_types::Span,
4341 pub doc: ::core::option::Option<DocComment<'tree>>,
4342 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
4343 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
4344}
4345impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
4346 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4347 fn from_node(
4348 node: ::tree_sitter::Node<'tree>,
4349 src: &'tree [u8],
4350 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4351 debug_assert_eq!(node.kind(), "line_comment");
4352 Ok(Self {
4353 span: ::treesitter_types::Span::from(node),
4354 doc: match node.child_by_field_name("doc") {
4355 Some(child) => Some(<DocComment as ::treesitter_types::FromNode>::from_node(
4356 child, src,
4357 )?),
4358 None => None,
4359 },
4360 inner: match node.child_by_field_name("inner") {
4361 Some(child) => Some(
4362 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
4363 ),
4364 None => None,
4365 },
4366 outer: match node.child_by_field_name("outer") {
4367 Some(child) => Some(
4368 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
4369 ),
4370 None => None,
4371 },
4372 })
4373 }
4374}
4375impl ::treesitter_types::Spanned for LineComment<'_> {
4376 fn span(&self) -> ::treesitter_types::Span {
4377 self.span
4378 }
4379}
4380#[derive(Debug, Clone)]
4381pub struct LoopExpression<'tree> {
4382 pub span: ::treesitter_types::Span,
4383 pub body: Block<'tree>,
4384 pub children: ::core::option::Option<Label<'tree>>,
4385}
4386impl<'tree> ::treesitter_types::FromNode<'tree> for LoopExpression<'tree> {
4387 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4388 fn from_node(
4389 node: ::tree_sitter::Node<'tree>,
4390 src: &'tree [u8],
4391 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4392 debug_assert_eq!(node.kind(), "loop_expression");
4393 Ok(Self {
4394 span: ::treesitter_types::Span::from(node),
4395 body: {
4396 let child = node
4397 .child_by_field_name("body")
4398 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4399 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
4400 },
4401 children: {
4402 #[allow(clippy::suspicious_else_formatting)]
4403 let non_field_children = {
4404 let mut cursor = node.walk();
4405 let mut result = ::std::vec::Vec::new();
4406 if cursor.goto_first_child() {
4407 loop {
4408 if cursor.field_name().is_none()
4409 && cursor.node().is_named()
4410 && !cursor.node().is_extra()
4411 {
4412 result.push(cursor.node());
4413 }
4414 if !cursor.goto_next_sibling() {
4415 break;
4416 }
4417 }
4418 }
4419 result
4420 };
4421 match non_field_children.first() {
4422 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
4423 child, src,
4424 )?),
4425 None => None,
4426 }
4427 },
4428 })
4429 }
4430}
4431impl ::treesitter_types::Spanned for LoopExpression<'_> {
4432 fn span(&self) -> ::treesitter_types::Span {
4433 self.span
4434 }
4435}
4436#[derive(Debug, Clone)]
4437pub struct MacroDefinition<'tree> {
4438 pub span: ::treesitter_types::Span,
4439 pub name: Identifier<'tree>,
4440 pub children: ::std::vec::Vec<MacroRule<'tree>>,
4441}
4442impl<'tree> ::treesitter_types::FromNode<'tree> for MacroDefinition<'tree> {
4443 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4444 fn from_node(
4445 node: ::tree_sitter::Node<'tree>,
4446 src: &'tree [u8],
4447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4448 debug_assert_eq!(node.kind(), "macro_definition");
4449 Ok(Self {
4450 span: ::treesitter_types::Span::from(node),
4451 name: {
4452 let child = node
4453 .child_by_field_name("name")
4454 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4455 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4456 },
4457 children: {
4458 #[allow(clippy::suspicious_else_formatting)]
4459 let non_field_children = {
4460 let mut cursor = node.walk();
4461 let mut result = ::std::vec::Vec::new();
4462 if cursor.goto_first_child() {
4463 loop {
4464 if cursor.field_name().is_none()
4465 && cursor.node().is_named()
4466 && !cursor.node().is_extra()
4467 {
4468 result.push(cursor.node());
4469 }
4470 if !cursor.goto_next_sibling() {
4471 break;
4472 }
4473 }
4474 }
4475 result
4476 };
4477 let mut items = ::std::vec::Vec::new();
4478 for child in non_field_children {
4479 items.push(<MacroRule as ::treesitter_types::FromNode>::from_node(
4480 child, src,
4481 )?);
4482 }
4483 items
4484 },
4485 })
4486 }
4487}
4488impl ::treesitter_types::Spanned for MacroDefinition<'_> {
4489 fn span(&self) -> ::treesitter_types::Span {
4490 self.span
4491 }
4492}
4493#[derive(Debug, Clone)]
4494pub struct MacroInvocation<'tree> {
4495 pub span: ::treesitter_types::Span,
4496 pub r#macro: MacroInvocationMacro<'tree>,
4497 pub children: TokenTree<'tree>,
4498}
4499impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocation<'tree> {
4500 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4501 fn from_node(
4502 node: ::tree_sitter::Node<'tree>,
4503 src: &'tree [u8],
4504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4505 debug_assert_eq!(node.kind(), "macro_invocation");
4506 Ok(Self {
4507 span: ::treesitter_types::Span::from(node),
4508 r#macro: {
4509 let child = node
4510 .child_by_field_name("macro")
4511 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("macro", node))?;
4512 <MacroInvocationMacro as ::treesitter_types::FromNode>::from_node(child, src)?
4513 },
4514 children: {
4515 #[allow(clippy::suspicious_else_formatting)]
4516 let non_field_children = {
4517 let mut cursor = node.walk();
4518 let mut result = ::std::vec::Vec::new();
4519 if cursor.goto_first_child() {
4520 loop {
4521 if cursor.field_name().is_none()
4522 && cursor.node().is_named()
4523 && !cursor.node().is_extra()
4524 {
4525 result.push(cursor.node());
4526 }
4527 if !cursor.goto_next_sibling() {
4528 break;
4529 }
4530 }
4531 }
4532 result
4533 };
4534 let child = if let Some(&c) = non_field_children.first() {
4535 c
4536 } else {
4537 let mut fallback_cursor = node.walk();
4538 let mut fallback_child = None;
4539 if fallback_cursor.goto_first_child() {
4540 loop {
4541 if fallback_cursor.field_name().is_none()
4542 && !fallback_cursor.node().is_extra()
4543 {
4544 fallback_child = Some(fallback_cursor.node());
4545 break;
4546 }
4547 if !fallback_cursor.goto_next_sibling() {
4548 break;
4549 }
4550 }
4551 }
4552 fallback_child.ok_or_else(|| {
4553 ::treesitter_types::ParseError::missing_field("children", node)
4554 })?
4555 };
4556 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)?
4557 },
4558 })
4559 }
4560}
4561impl ::treesitter_types::Spanned for MacroInvocation<'_> {
4562 fn span(&self) -> ::treesitter_types::Span {
4563 self.span
4564 }
4565}
4566#[derive(Debug, Clone)]
4567pub struct MacroRule<'tree> {
4568 pub span: ::treesitter_types::Span,
4569 pub left: TokenTreePattern<'tree>,
4570 pub right: TokenTree<'tree>,
4571}
4572impl<'tree> ::treesitter_types::FromNode<'tree> for MacroRule<'tree> {
4573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4574 fn from_node(
4575 node: ::tree_sitter::Node<'tree>,
4576 src: &'tree [u8],
4577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4578 debug_assert_eq!(node.kind(), "macro_rule");
4579 Ok(Self {
4580 span: ::treesitter_types::Span::from(node),
4581 left: {
4582 let child = node
4583 .child_by_field_name("left")
4584 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4585 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(child, src)?
4586 },
4587 right: {
4588 let child = node
4589 .child_by_field_name("right")
4590 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4591 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)?
4592 },
4593 })
4594 }
4595}
4596impl ::treesitter_types::Spanned for MacroRule<'_> {
4597 fn span(&self) -> ::treesitter_types::Span {
4598 self.span
4599 }
4600}
4601#[derive(Debug, Clone)]
4602pub struct MatchArm<'tree> {
4603 pub span: ::treesitter_types::Span,
4604 pub pattern: MatchPattern<'tree>,
4605 pub value: Expression<'tree>,
4606 pub children: ::std::vec::Vec<MatchArmChildren<'tree>>,
4607}
4608impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArm<'tree> {
4609 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4610 fn from_node(
4611 node: ::tree_sitter::Node<'tree>,
4612 src: &'tree [u8],
4613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4614 debug_assert_eq!(node.kind(), "match_arm");
4615 Ok(Self {
4616 span: ::treesitter_types::Span::from(node),
4617 pattern: {
4618 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4619 ::treesitter_types::ParseError::missing_field("pattern", node)
4620 })?;
4621 <MatchPattern as ::treesitter_types::FromNode>::from_node(child, src)?
4622 },
4623 value: {
4624 let child = node
4625 .child_by_field_name("value")
4626 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4627 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4628 },
4629 children: {
4630 #[allow(clippy::suspicious_else_formatting)]
4631 let non_field_children = {
4632 let mut cursor = node.walk();
4633 let mut result = ::std::vec::Vec::new();
4634 if cursor.goto_first_child() {
4635 loop {
4636 if cursor.field_name().is_none()
4637 && cursor.node().is_named()
4638 && !cursor.node().is_extra()
4639 {
4640 result.push(cursor.node());
4641 }
4642 if !cursor.goto_next_sibling() {
4643 break;
4644 }
4645 }
4646 }
4647 result
4648 };
4649 let mut items = ::std::vec::Vec::new();
4650 for child in non_field_children {
4651 items.push(
4652 <MatchArmChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4653 );
4654 }
4655 items
4656 },
4657 })
4658 }
4659}
4660impl ::treesitter_types::Spanned for MatchArm<'_> {
4661 fn span(&self) -> ::treesitter_types::Span {
4662 self.span
4663 }
4664}
4665#[derive(Debug, Clone)]
4666pub struct MatchBlock<'tree> {
4667 pub span: ::treesitter_types::Span,
4668 pub children: ::std::vec::Vec<MatchArm<'tree>>,
4669}
4670impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlock<'tree> {
4671 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4672 fn from_node(
4673 node: ::tree_sitter::Node<'tree>,
4674 src: &'tree [u8],
4675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4676 debug_assert_eq!(node.kind(), "match_block");
4677 Ok(Self {
4678 span: ::treesitter_types::Span::from(node),
4679 children: {
4680 #[allow(clippy::suspicious_else_formatting)]
4681 let non_field_children = {
4682 let mut cursor = node.walk();
4683 let mut result = ::std::vec::Vec::new();
4684 if cursor.goto_first_child() {
4685 loop {
4686 if cursor.field_name().is_none()
4687 && cursor.node().is_named()
4688 && !cursor.node().is_extra()
4689 {
4690 result.push(cursor.node());
4691 }
4692 if !cursor.goto_next_sibling() {
4693 break;
4694 }
4695 }
4696 }
4697 result
4698 };
4699 let mut items = ::std::vec::Vec::new();
4700 for child in non_field_children {
4701 items.push(<MatchArm as ::treesitter_types::FromNode>::from_node(
4702 child, src,
4703 )?);
4704 }
4705 items
4706 },
4707 })
4708 }
4709}
4710impl ::treesitter_types::Spanned for MatchBlock<'_> {
4711 fn span(&self) -> ::treesitter_types::Span {
4712 self.span
4713 }
4714}
4715#[derive(Debug, Clone)]
4716pub struct MatchExpression<'tree> {
4717 pub span: ::treesitter_types::Span,
4718 pub body: MatchBlock<'tree>,
4719 pub value: Expression<'tree>,
4720}
4721impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
4722 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4723 fn from_node(
4724 node: ::tree_sitter::Node<'tree>,
4725 src: &'tree [u8],
4726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4727 debug_assert_eq!(node.kind(), "match_expression");
4728 Ok(Self {
4729 span: ::treesitter_types::Span::from(node),
4730 body: {
4731 let child = node
4732 .child_by_field_name("body")
4733 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4734 <MatchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
4735 },
4736 value: {
4737 let child = node
4738 .child_by_field_name("value")
4739 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4740 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4741 },
4742 })
4743 }
4744}
4745impl ::treesitter_types::Spanned for MatchExpression<'_> {
4746 fn span(&self) -> ::treesitter_types::Span {
4747 self.span
4748 }
4749}
4750#[derive(Debug, Clone)]
4751pub struct MatchPattern<'tree> {
4752 pub span: ::treesitter_types::Span,
4753 pub condition: ::core::option::Option<MatchPatternCondition<'tree>>,
4754 pub children: Pattern<'tree>,
4755}
4756impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPattern<'tree> {
4757 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4758 fn from_node(
4759 node: ::tree_sitter::Node<'tree>,
4760 src: &'tree [u8],
4761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4762 debug_assert_eq!(node.kind(), "match_pattern");
4763 Ok(Self {
4764 span: ::treesitter_types::Span::from(node),
4765 condition: match node.child_by_field_name("condition") {
4766 Some(child) => Some(
4767 <MatchPatternCondition as ::treesitter_types::FromNode>::from_node(child, src)?,
4768 ),
4769 None => None,
4770 },
4771 children: {
4772 #[allow(clippy::suspicious_else_formatting)]
4773 let non_field_children = {
4774 let mut cursor = node.walk();
4775 let mut result = ::std::vec::Vec::new();
4776 if cursor.goto_first_child() {
4777 loop {
4778 if cursor.field_name().is_none()
4779 && cursor.node().is_named()
4780 && !cursor.node().is_extra()
4781 {
4782 result.push(cursor.node());
4783 }
4784 if !cursor.goto_next_sibling() {
4785 break;
4786 }
4787 }
4788 }
4789 result
4790 };
4791 let child = if let Some(&c) = non_field_children.first() {
4792 c
4793 } else {
4794 let mut fallback_cursor = node.walk();
4795 let mut fallback_child = None;
4796 if fallback_cursor.goto_first_child() {
4797 loop {
4798 if fallback_cursor.field_name().is_none()
4799 && !fallback_cursor.node().is_extra()
4800 {
4801 fallback_child = Some(fallback_cursor.node());
4802 break;
4803 }
4804 if !fallback_cursor.goto_next_sibling() {
4805 break;
4806 }
4807 }
4808 }
4809 fallback_child.ok_or_else(|| {
4810 ::treesitter_types::ParseError::missing_field("children", node)
4811 })?
4812 };
4813 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
4814 },
4815 })
4816 }
4817}
4818impl ::treesitter_types::Spanned for MatchPattern<'_> {
4819 fn span(&self) -> ::treesitter_types::Span {
4820 self.span
4821 }
4822}
4823#[derive(Debug, Clone)]
4824pub struct ModItem<'tree> {
4825 pub span: ::treesitter_types::Span,
4826 pub body: ::core::option::Option<DeclarationList<'tree>>,
4827 pub name: Identifier<'tree>,
4828 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
4829}
4830impl<'tree> ::treesitter_types::FromNode<'tree> for ModItem<'tree> {
4831 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4832 fn from_node(
4833 node: ::tree_sitter::Node<'tree>,
4834 src: &'tree [u8],
4835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4836 debug_assert_eq!(node.kind(), "mod_item");
4837 Ok(Self {
4838 span: ::treesitter_types::Span::from(node),
4839 body: match node.child_by_field_name("body") {
4840 Some(child) => {
4841 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
4842 }
4843 None => None,
4844 },
4845 name: {
4846 let child = node
4847 .child_by_field_name("name")
4848 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4849 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4850 },
4851 children: {
4852 #[allow(clippy::suspicious_else_formatting)]
4853 let non_field_children = {
4854 let mut cursor = node.walk();
4855 let mut result = ::std::vec::Vec::new();
4856 if cursor.goto_first_child() {
4857 loop {
4858 if cursor.field_name().is_none()
4859 && cursor.node().is_named()
4860 && !cursor.node().is_extra()
4861 {
4862 result.push(cursor.node());
4863 }
4864 if !cursor.goto_next_sibling() {
4865 break;
4866 }
4867 }
4868 }
4869 result
4870 };
4871 match non_field_children.first() {
4872 Some(&child) => Some(
4873 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
4874 child, src,
4875 )?,
4876 ),
4877 None => None,
4878 }
4879 },
4880 })
4881 }
4882}
4883impl ::treesitter_types::Spanned for ModItem<'_> {
4884 fn span(&self) -> ::treesitter_types::Span {
4885 self.span
4886 }
4887}
4888#[derive(Debug, Clone)]
4889pub struct MutPattern<'tree> {
4890 pub span: ::treesitter_types::Span,
4891 pub children: ::std::vec::Vec<MutPatternChildren<'tree>>,
4892}
4893impl<'tree> ::treesitter_types::FromNode<'tree> for MutPattern<'tree> {
4894 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4895 fn from_node(
4896 node: ::tree_sitter::Node<'tree>,
4897 src: &'tree [u8],
4898 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4899 debug_assert_eq!(node.kind(), "mut_pattern");
4900 Ok(Self {
4901 span: ::treesitter_types::Span::from(node),
4902 children: {
4903 #[allow(clippy::suspicious_else_formatting)]
4904 let non_field_children = {
4905 let mut cursor = node.walk();
4906 let mut result = ::std::vec::Vec::new();
4907 if cursor.goto_first_child() {
4908 loop {
4909 if cursor.field_name().is_none()
4910 && cursor.node().is_named()
4911 && !cursor.node().is_extra()
4912 {
4913 result.push(cursor.node());
4914 }
4915 if !cursor.goto_next_sibling() {
4916 break;
4917 }
4918 }
4919 }
4920 result
4921 };
4922 let mut items = ::std::vec::Vec::new();
4923 for child in non_field_children {
4924 items.push(
4925 <MutPatternChildren as ::treesitter_types::FromNode>::from_node(
4926 child, src,
4927 )?,
4928 );
4929 }
4930 items
4931 },
4932 })
4933 }
4934}
4935impl ::treesitter_types::Spanned for MutPattern<'_> {
4936 fn span(&self) -> ::treesitter_types::Span {
4937 self.span
4938 }
4939}
4940#[derive(Debug, Clone)]
4941pub struct NegativeLiteral<'tree> {
4942 pub span: ::treesitter_types::Span,
4943 pub children: NegativeLiteralChildren<'tree>,
4944}
4945impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteral<'tree> {
4946 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4947 fn from_node(
4948 node: ::tree_sitter::Node<'tree>,
4949 src: &'tree [u8],
4950 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4951 debug_assert_eq!(node.kind(), "negative_literal");
4952 Ok(Self {
4953 span: ::treesitter_types::Span::from(node),
4954 children: {
4955 #[allow(clippy::suspicious_else_formatting)]
4956 let non_field_children = {
4957 let mut cursor = node.walk();
4958 let mut result = ::std::vec::Vec::new();
4959 if cursor.goto_first_child() {
4960 loop {
4961 if cursor.field_name().is_none()
4962 && cursor.node().is_named()
4963 && !cursor.node().is_extra()
4964 {
4965 result.push(cursor.node());
4966 }
4967 if !cursor.goto_next_sibling() {
4968 break;
4969 }
4970 }
4971 }
4972 result
4973 };
4974 let child = if let Some(&c) = non_field_children.first() {
4975 c
4976 } else {
4977 let mut fallback_cursor = node.walk();
4978 let mut fallback_child = None;
4979 if fallback_cursor.goto_first_child() {
4980 loop {
4981 if fallback_cursor.field_name().is_none()
4982 && !fallback_cursor.node().is_extra()
4983 {
4984 fallback_child = Some(fallback_cursor.node());
4985 break;
4986 }
4987 if !fallback_cursor.goto_next_sibling() {
4988 break;
4989 }
4990 }
4991 }
4992 fallback_child.ok_or_else(|| {
4993 ::treesitter_types::ParseError::missing_field("children", node)
4994 })?
4995 };
4996 <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4997 },
4998 })
4999 }
5000}
5001impl ::treesitter_types::Spanned for NegativeLiteral<'_> {
5002 fn span(&self) -> ::treesitter_types::Span {
5003 self.span
5004 }
5005}
5006#[derive(Debug, Clone)]
5007pub struct NeverType<'tree> {
5008 pub span: ::treesitter_types::Span,
5009 text: &'tree str,
5010}
5011impl<'tree> ::treesitter_types::FromNode<'tree> for NeverType<'tree> {
5012 fn from_node(
5013 node: ::tree_sitter::Node<'tree>,
5014 src: &'tree [u8],
5015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5016 debug_assert_eq!(node.kind(), "never_type");
5017 Ok(Self {
5018 span: ::treesitter_types::Span::from(node),
5019 text: node.utf8_text(src)?,
5020 })
5021 }
5022}
5023impl<'tree> ::treesitter_types::LeafNode<'tree> for NeverType<'tree> {
5024 fn text(&self) -> &'tree str {
5025 self.text
5026 }
5027}
5028impl ::treesitter_types::Spanned for NeverType<'_> {
5029 fn span(&self) -> ::treesitter_types::Span {
5030 self.span
5031 }
5032}
5033#[derive(Debug, Clone)]
5034pub struct OrPattern<'tree> {
5035 pub span: ::treesitter_types::Span,
5036 pub children: ::std::vec::Vec<Pattern<'tree>>,
5037}
5038impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
5039 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5040 fn from_node(
5041 node: ::tree_sitter::Node<'tree>,
5042 src: &'tree [u8],
5043 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5044 debug_assert_eq!(node.kind(), "or_pattern");
5045 Ok(Self {
5046 span: ::treesitter_types::Span::from(node),
5047 children: {
5048 #[allow(clippy::suspicious_else_formatting)]
5049 let non_field_children = {
5050 let mut cursor = node.walk();
5051 let mut result = ::std::vec::Vec::new();
5052 if cursor.goto_first_child() {
5053 loop {
5054 if cursor.field_name().is_none()
5055 && cursor.node().is_named()
5056 && !cursor.node().is_extra()
5057 {
5058 result.push(cursor.node());
5059 }
5060 if !cursor.goto_next_sibling() {
5061 break;
5062 }
5063 }
5064 }
5065 result
5066 };
5067 let mut items = ::std::vec::Vec::new();
5068 for child in non_field_children {
5069 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
5070 child, src,
5071 )?);
5072 }
5073 items
5074 },
5075 })
5076 }
5077}
5078impl ::treesitter_types::Spanned for OrPattern<'_> {
5079 fn span(&self) -> ::treesitter_types::Span {
5080 self.span
5081 }
5082}
5083#[derive(Debug, Clone)]
5084pub struct OrderedFieldDeclarationList<'tree> {
5085 pub span: ::treesitter_types::Span,
5086 pub r#type: ::std::vec::Vec<Type<'tree>>,
5087 pub children: ::std::vec::Vec<OrderedFieldDeclarationListChildren<'tree>>,
5088}
5089impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationList<'tree> {
5090 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5091 fn from_node(
5092 node: ::tree_sitter::Node<'tree>,
5093 src: &'tree [u8],
5094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5095 debug_assert_eq!(node.kind(), "ordered_field_declaration_list");
5096 Ok(Self {
5097 span: ::treesitter_types::Span::from(node),
5098 r#type: {
5099 let mut cursor = node.walk();
5100 let mut items = ::std::vec::Vec::new();
5101 for child in node.children_by_field_name("type", &mut cursor) {
5102 items.push(<Type as ::treesitter_types::FromNode>::from_node(
5103 child, src,
5104 )?);
5105 }
5106 items
5107 },
5108 children: {
5109 #[allow(clippy::suspicious_else_formatting)]
5110 let non_field_children = {
5111 let mut cursor = node.walk();
5112 let mut result = ::std::vec::Vec::new();
5113 if cursor.goto_first_child() {
5114 loop {
5115 if cursor.field_name().is_none()
5116 && cursor.node().is_named()
5117 && !cursor.node().is_extra()
5118 {
5119 result.push(cursor.node());
5120 }
5121 if !cursor.goto_next_sibling() {
5122 break;
5123 }
5124 }
5125 }
5126 result
5127 };
5128 let mut items = ::std::vec::Vec::new();
5129 for child in non_field_children {
5130 items
5131 .push(
5132 <OrderedFieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
5133 child,
5134 src,
5135 )?,
5136 );
5137 }
5138 items
5139 },
5140 })
5141 }
5142}
5143impl ::treesitter_types::Spanned for OrderedFieldDeclarationList<'_> {
5144 fn span(&self) -> ::treesitter_types::Span {
5145 self.span
5146 }
5147}
5148#[derive(Debug, Clone)]
5149pub struct OuterDocCommentMarker<'tree> {
5150 pub span: ::treesitter_types::Span,
5151 text: &'tree str,
5152}
5153impl<'tree> ::treesitter_types::FromNode<'tree> for OuterDocCommentMarker<'tree> {
5154 fn from_node(
5155 node: ::tree_sitter::Node<'tree>,
5156 src: &'tree [u8],
5157 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5158 debug_assert_eq!(node.kind(), "outer_doc_comment_marker");
5159 Ok(Self {
5160 span: ::treesitter_types::Span::from(node),
5161 text: node.utf8_text(src)?,
5162 })
5163 }
5164}
5165impl<'tree> ::treesitter_types::LeafNode<'tree> for OuterDocCommentMarker<'tree> {
5166 fn text(&self) -> &'tree str {
5167 self.text
5168 }
5169}
5170impl ::treesitter_types::Spanned for OuterDocCommentMarker<'_> {
5171 fn span(&self) -> ::treesitter_types::Span {
5172 self.span
5173 }
5174}
5175#[derive(Debug, Clone)]
5176pub struct Parameter<'tree> {
5177 pub span: ::treesitter_types::Span,
5178 pub pattern: ParameterPattern<'tree>,
5179 pub r#type: Type<'tree>,
5180 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
5181}
5182impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
5183 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5184 fn from_node(
5185 node: ::tree_sitter::Node<'tree>,
5186 src: &'tree [u8],
5187 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5188 debug_assert_eq!(node.kind(), "parameter");
5189 Ok(Self {
5190 span: ::treesitter_types::Span::from(node),
5191 pattern: {
5192 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5193 ::treesitter_types::ParseError::missing_field("pattern", node)
5194 })?;
5195 <ParameterPattern as ::treesitter_types::FromNode>::from_node(child, src)?
5196 },
5197 r#type: {
5198 let child = node
5199 .child_by_field_name("type")
5200 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5201 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5202 },
5203 children: {
5204 #[allow(clippy::suspicious_else_formatting)]
5205 let non_field_children = {
5206 let mut cursor = node.walk();
5207 let mut result = ::std::vec::Vec::new();
5208 if cursor.goto_first_child() {
5209 loop {
5210 if cursor.field_name().is_none()
5211 && cursor.node().is_named()
5212 && !cursor.node().is_extra()
5213 {
5214 result.push(cursor.node());
5215 }
5216 if !cursor.goto_next_sibling() {
5217 break;
5218 }
5219 }
5220 }
5221 result
5222 };
5223 match non_field_children.first() {
5224 Some(&child) => Some(
5225 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5226 ),
5227 None => None,
5228 }
5229 },
5230 })
5231 }
5232}
5233impl ::treesitter_types::Spanned for Parameter<'_> {
5234 fn span(&self) -> ::treesitter_types::Span {
5235 self.span
5236 }
5237}
5238#[derive(Debug, Clone)]
5239pub struct Parameters<'tree> {
5240 pub span: ::treesitter_types::Span,
5241 pub children: ::std::vec::Vec<ParametersChildren<'tree>>,
5242}
5243impl<'tree> ::treesitter_types::FromNode<'tree> for Parameters<'tree> {
5244 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5245 fn from_node(
5246 node: ::tree_sitter::Node<'tree>,
5247 src: &'tree [u8],
5248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5249 debug_assert_eq!(node.kind(), "parameters");
5250 Ok(Self {
5251 span: ::treesitter_types::Span::from(node),
5252 children: {
5253 #[allow(clippy::suspicious_else_formatting)]
5254 let non_field_children = {
5255 let mut cursor = node.walk();
5256 let mut result = ::std::vec::Vec::new();
5257 if cursor.goto_first_child() {
5258 loop {
5259 if cursor.field_name().is_none()
5260 && cursor.node().is_named()
5261 && !cursor.node().is_extra()
5262 {
5263 result.push(cursor.node());
5264 }
5265 if !cursor.goto_next_sibling() {
5266 break;
5267 }
5268 }
5269 }
5270 result
5271 };
5272 let mut items = ::std::vec::Vec::new();
5273 for child in non_field_children {
5274 items.push(
5275 <ParametersChildren as ::treesitter_types::FromNode>::from_node(
5276 child, src,
5277 )?,
5278 );
5279 }
5280 items
5281 },
5282 })
5283 }
5284}
5285impl ::treesitter_types::Spanned for Parameters<'_> {
5286 fn span(&self) -> ::treesitter_types::Span {
5287 self.span
5288 }
5289}
5290#[derive(Debug, Clone)]
5291pub struct ParenthesizedExpression<'tree> {
5292 pub span: ::treesitter_types::Span,
5293 pub children: Expression<'tree>,
5294}
5295impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
5296 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5297 fn from_node(
5298 node: ::tree_sitter::Node<'tree>,
5299 src: &'tree [u8],
5300 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5301 debug_assert_eq!(node.kind(), "parenthesized_expression");
5302 Ok(Self {
5303 span: ::treesitter_types::Span::from(node),
5304 children: {
5305 #[allow(clippy::suspicious_else_formatting)]
5306 let non_field_children = {
5307 let mut cursor = node.walk();
5308 let mut result = ::std::vec::Vec::new();
5309 if cursor.goto_first_child() {
5310 loop {
5311 if cursor.field_name().is_none()
5312 && cursor.node().is_named()
5313 && !cursor.node().is_extra()
5314 {
5315 result.push(cursor.node());
5316 }
5317 if !cursor.goto_next_sibling() {
5318 break;
5319 }
5320 }
5321 }
5322 result
5323 };
5324 let child = if let Some(&c) = non_field_children.first() {
5325 c
5326 } else {
5327 let mut fallback_cursor = node.walk();
5328 let mut fallback_child = None;
5329 if fallback_cursor.goto_first_child() {
5330 loop {
5331 if fallback_cursor.field_name().is_none()
5332 && !fallback_cursor.node().is_extra()
5333 {
5334 fallback_child = Some(fallback_cursor.node());
5335 break;
5336 }
5337 if !fallback_cursor.goto_next_sibling() {
5338 break;
5339 }
5340 }
5341 }
5342 fallback_child.ok_or_else(|| {
5343 ::treesitter_types::ParseError::missing_field("children", node)
5344 })?
5345 };
5346 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5347 },
5348 })
5349 }
5350}
5351impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
5352 fn span(&self) -> ::treesitter_types::Span {
5353 self.span
5354 }
5355}
5356#[derive(Debug, Clone)]
5357pub struct PointerType<'tree> {
5358 pub span: ::treesitter_types::Span,
5359 pub r#type: Type<'tree>,
5360 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
5361}
5362impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
5363 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5364 fn from_node(
5365 node: ::tree_sitter::Node<'tree>,
5366 src: &'tree [u8],
5367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5368 debug_assert_eq!(node.kind(), "pointer_type");
5369 Ok(Self {
5370 span: ::treesitter_types::Span::from(node),
5371 r#type: {
5372 let child = node
5373 .child_by_field_name("type")
5374 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5375 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5376 },
5377 children: {
5378 #[allow(clippy::suspicious_else_formatting)]
5379 let non_field_children = {
5380 let mut cursor = node.walk();
5381 let mut result = ::std::vec::Vec::new();
5382 if cursor.goto_first_child() {
5383 loop {
5384 if cursor.field_name().is_none()
5385 && cursor.node().is_named()
5386 && !cursor.node().is_extra()
5387 {
5388 result.push(cursor.node());
5389 }
5390 if !cursor.goto_next_sibling() {
5391 break;
5392 }
5393 }
5394 }
5395 result
5396 };
5397 match non_field_children.first() {
5398 Some(&child) => Some(
5399 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5400 ),
5401 None => None,
5402 }
5403 },
5404 })
5405 }
5406}
5407impl ::treesitter_types::Spanned for PointerType<'_> {
5408 fn span(&self) -> ::treesitter_types::Span {
5409 self.span
5410 }
5411}
5412#[derive(Debug, Clone)]
5413pub struct QualifiedType<'tree> {
5414 pub span: ::treesitter_types::Span,
5415 pub alias: Type<'tree>,
5416 pub r#type: Type<'tree>,
5417}
5418impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedType<'tree> {
5419 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5420 fn from_node(
5421 node: ::tree_sitter::Node<'tree>,
5422 src: &'tree [u8],
5423 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5424 debug_assert_eq!(node.kind(), "qualified_type");
5425 Ok(Self {
5426 span: ::treesitter_types::Span::from(node),
5427 alias: {
5428 let child = node
5429 .child_by_field_name("alias")
5430 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
5431 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5432 },
5433 r#type: {
5434 let child = node
5435 .child_by_field_name("type")
5436 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5437 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5438 },
5439 })
5440 }
5441}
5442impl ::treesitter_types::Spanned for QualifiedType<'_> {
5443 fn span(&self) -> ::treesitter_types::Span {
5444 self.span
5445 }
5446}
5447#[derive(Debug, Clone)]
5448pub struct RangeExpression<'tree> {
5449 pub span: ::treesitter_types::Span,
5450 pub children: ::std::vec::Vec<Expression<'tree>>,
5451}
5452impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
5453 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5454 fn from_node(
5455 node: ::tree_sitter::Node<'tree>,
5456 src: &'tree [u8],
5457 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5458 debug_assert_eq!(node.kind(), "range_expression");
5459 Ok(Self {
5460 span: ::treesitter_types::Span::from(node),
5461 children: {
5462 #[allow(clippy::suspicious_else_formatting)]
5463 let non_field_children = {
5464 let mut cursor = node.walk();
5465 let mut result = ::std::vec::Vec::new();
5466 if cursor.goto_first_child() {
5467 loop {
5468 if cursor.field_name().is_none()
5469 && cursor.node().is_named()
5470 && !cursor.node().is_extra()
5471 {
5472 result.push(cursor.node());
5473 }
5474 if !cursor.goto_next_sibling() {
5475 break;
5476 }
5477 }
5478 }
5479 result
5480 };
5481 let mut items = ::std::vec::Vec::new();
5482 for child in non_field_children {
5483 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
5484 child, src,
5485 )?);
5486 }
5487 items
5488 },
5489 })
5490 }
5491}
5492impl ::treesitter_types::Spanned for RangeExpression<'_> {
5493 fn span(&self) -> ::treesitter_types::Span {
5494 self.span
5495 }
5496}
5497#[derive(Debug, Clone)]
5498pub struct RangePattern<'tree> {
5499 pub span: ::treesitter_types::Span,
5500 pub left: ::core::option::Option<RangePatternLeft<'tree>>,
5501 pub right: ::core::option::Option<RangePatternRight<'tree>>,
5502}
5503impl<'tree> ::treesitter_types::FromNode<'tree> for RangePattern<'tree> {
5504 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5505 fn from_node(
5506 node: ::tree_sitter::Node<'tree>,
5507 src: &'tree [u8],
5508 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5509 debug_assert_eq!(node.kind(), "range_pattern");
5510 Ok(Self {
5511 span: ::treesitter_types::Span::from(node),
5512 left: match node.child_by_field_name("left") {
5513 Some(child) => {
5514 Some(<RangePatternLeft as ::treesitter_types::FromNode>::from_node(child, src)?)
5515 }
5516 None => None,
5517 },
5518 right: match node.child_by_field_name("right") {
5519 Some(child) => Some(
5520 <RangePatternRight as ::treesitter_types::FromNode>::from_node(child, src)?,
5521 ),
5522 None => None,
5523 },
5524 })
5525 }
5526}
5527impl ::treesitter_types::Spanned for RangePattern<'_> {
5528 fn span(&self) -> ::treesitter_types::Span {
5529 self.span
5530 }
5531}
5532#[derive(Debug, Clone)]
5533pub struct RawStringLiteral<'tree> {
5534 pub span: ::treesitter_types::Span,
5535 pub children: StringContent<'tree>,
5536}
5537impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
5538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5539 fn from_node(
5540 node: ::tree_sitter::Node<'tree>,
5541 src: &'tree [u8],
5542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5543 debug_assert_eq!(node.kind(), "raw_string_literal");
5544 Ok(Self {
5545 span: ::treesitter_types::Span::from(node),
5546 children: {
5547 #[allow(clippy::suspicious_else_formatting)]
5548 let non_field_children = {
5549 let mut cursor = node.walk();
5550 let mut result = ::std::vec::Vec::new();
5551 if cursor.goto_first_child() {
5552 loop {
5553 if cursor.field_name().is_none()
5554 && cursor.node().is_named()
5555 && !cursor.node().is_extra()
5556 {
5557 result.push(cursor.node());
5558 }
5559 if !cursor.goto_next_sibling() {
5560 break;
5561 }
5562 }
5563 }
5564 result
5565 };
5566 let child = if let Some(&c) = non_field_children.first() {
5567 c
5568 } else {
5569 let mut fallback_cursor = node.walk();
5570 let mut fallback_child = None;
5571 if fallback_cursor.goto_first_child() {
5572 loop {
5573 if fallback_cursor.field_name().is_none()
5574 && !fallback_cursor.node().is_extra()
5575 {
5576 fallback_child = Some(fallback_cursor.node());
5577 break;
5578 }
5579 if !fallback_cursor.goto_next_sibling() {
5580 break;
5581 }
5582 }
5583 }
5584 fallback_child.ok_or_else(|| {
5585 ::treesitter_types::ParseError::missing_field("children", node)
5586 })?
5587 };
5588 <StringContent as ::treesitter_types::FromNode>::from_node(child, src)?
5589 },
5590 })
5591 }
5592}
5593impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
5594 fn span(&self) -> ::treesitter_types::Span {
5595 self.span
5596 }
5597}
5598#[derive(Debug, Clone)]
5599pub struct RefPattern<'tree> {
5600 pub span: ::treesitter_types::Span,
5601 pub children: Pattern<'tree>,
5602}
5603impl<'tree> ::treesitter_types::FromNode<'tree> for RefPattern<'tree> {
5604 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5605 fn from_node(
5606 node: ::tree_sitter::Node<'tree>,
5607 src: &'tree [u8],
5608 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5609 debug_assert_eq!(node.kind(), "ref_pattern");
5610 Ok(Self {
5611 span: ::treesitter_types::Span::from(node),
5612 children: {
5613 #[allow(clippy::suspicious_else_formatting)]
5614 let non_field_children = {
5615 let mut cursor = node.walk();
5616 let mut result = ::std::vec::Vec::new();
5617 if cursor.goto_first_child() {
5618 loop {
5619 if cursor.field_name().is_none()
5620 && cursor.node().is_named()
5621 && !cursor.node().is_extra()
5622 {
5623 result.push(cursor.node());
5624 }
5625 if !cursor.goto_next_sibling() {
5626 break;
5627 }
5628 }
5629 }
5630 result
5631 };
5632 let child = if let Some(&c) = non_field_children.first() {
5633 c
5634 } else {
5635 let mut fallback_cursor = node.walk();
5636 let mut fallback_child = None;
5637 if fallback_cursor.goto_first_child() {
5638 loop {
5639 if fallback_cursor.field_name().is_none()
5640 && !fallback_cursor.node().is_extra()
5641 {
5642 fallback_child = Some(fallback_cursor.node());
5643 break;
5644 }
5645 if !fallback_cursor.goto_next_sibling() {
5646 break;
5647 }
5648 }
5649 }
5650 fallback_child.ok_or_else(|| {
5651 ::treesitter_types::ParseError::missing_field("children", node)
5652 })?
5653 };
5654 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
5655 },
5656 })
5657 }
5658}
5659impl ::treesitter_types::Spanned for RefPattern<'_> {
5660 fn span(&self) -> ::treesitter_types::Span {
5661 self.span
5662 }
5663}
5664#[derive(Debug, Clone)]
5665pub struct ReferenceExpression<'tree> {
5666 pub span: ::treesitter_types::Span,
5667 pub value: Expression<'tree>,
5668 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
5669}
5670impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceExpression<'tree> {
5671 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5672 fn from_node(
5673 node: ::tree_sitter::Node<'tree>,
5674 src: &'tree [u8],
5675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5676 debug_assert_eq!(node.kind(), "reference_expression");
5677 Ok(Self {
5678 span: ::treesitter_types::Span::from(node),
5679 value: {
5680 let child = node
5681 .child_by_field_name("value")
5682 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5683 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5684 },
5685 children: {
5686 #[allow(clippy::suspicious_else_formatting)]
5687 let non_field_children = {
5688 let mut cursor = node.walk();
5689 let mut result = ::std::vec::Vec::new();
5690 if cursor.goto_first_child() {
5691 loop {
5692 if cursor.field_name().is_none()
5693 && cursor.node().is_named()
5694 && !cursor.node().is_extra()
5695 {
5696 result.push(cursor.node());
5697 }
5698 if !cursor.goto_next_sibling() {
5699 break;
5700 }
5701 }
5702 }
5703 result
5704 };
5705 match non_field_children.first() {
5706 Some(&child) => Some(
5707 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5708 ),
5709 None => None,
5710 }
5711 },
5712 })
5713 }
5714}
5715impl ::treesitter_types::Spanned for ReferenceExpression<'_> {
5716 fn span(&self) -> ::treesitter_types::Span {
5717 self.span
5718 }
5719}
5720#[derive(Debug, Clone)]
5721pub struct ReferencePattern<'tree> {
5722 pub span: ::treesitter_types::Span,
5723 pub children: ::std::vec::Vec<ReferencePatternChildren<'tree>>,
5724}
5725impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePattern<'tree> {
5726 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5727 fn from_node(
5728 node: ::tree_sitter::Node<'tree>,
5729 src: &'tree [u8],
5730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5731 debug_assert_eq!(node.kind(), "reference_pattern");
5732 Ok(Self {
5733 span: ::treesitter_types::Span::from(node),
5734 children: {
5735 #[allow(clippy::suspicious_else_formatting)]
5736 let non_field_children = {
5737 let mut cursor = node.walk();
5738 let mut result = ::std::vec::Vec::new();
5739 if cursor.goto_first_child() {
5740 loop {
5741 if cursor.field_name().is_none()
5742 && cursor.node().is_named()
5743 && !cursor.node().is_extra()
5744 {
5745 result.push(cursor.node());
5746 }
5747 if !cursor.goto_next_sibling() {
5748 break;
5749 }
5750 }
5751 }
5752 result
5753 };
5754 let mut items = ::std::vec::Vec::new();
5755 for child in non_field_children {
5756 items.push(
5757 <ReferencePatternChildren as ::treesitter_types::FromNode>::from_node(
5758 child, src,
5759 )?,
5760 );
5761 }
5762 items
5763 },
5764 })
5765 }
5766}
5767impl ::treesitter_types::Spanned for ReferencePattern<'_> {
5768 fn span(&self) -> ::treesitter_types::Span {
5769 self.span
5770 }
5771}
5772#[derive(Debug, Clone)]
5773pub struct ReferenceType<'tree> {
5774 pub span: ::treesitter_types::Span,
5775 pub r#type: Type<'tree>,
5776 pub children: ::std::vec::Vec<ReferenceTypeChildren<'tree>>,
5777}
5778impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceType<'tree> {
5779 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5780 fn from_node(
5781 node: ::tree_sitter::Node<'tree>,
5782 src: &'tree [u8],
5783 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5784 debug_assert_eq!(node.kind(), "reference_type");
5785 Ok(Self {
5786 span: ::treesitter_types::Span::from(node),
5787 r#type: {
5788 let child = node
5789 .child_by_field_name("type")
5790 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5791 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5792 },
5793 children: {
5794 #[allow(clippy::suspicious_else_formatting)]
5795 let non_field_children = {
5796 let mut cursor = node.walk();
5797 let mut result = ::std::vec::Vec::new();
5798 if cursor.goto_first_child() {
5799 loop {
5800 if cursor.field_name().is_none()
5801 && cursor.node().is_named()
5802 && !cursor.node().is_extra()
5803 {
5804 result.push(cursor.node());
5805 }
5806 if !cursor.goto_next_sibling() {
5807 break;
5808 }
5809 }
5810 }
5811 result
5812 };
5813 let mut items = ::std::vec::Vec::new();
5814 for child in non_field_children {
5815 items.push(
5816 <ReferenceTypeChildren as ::treesitter_types::FromNode>::from_node(
5817 child, src,
5818 )?,
5819 );
5820 }
5821 items
5822 },
5823 })
5824 }
5825}
5826impl ::treesitter_types::Spanned for ReferenceType<'_> {
5827 fn span(&self) -> ::treesitter_types::Span {
5828 self.span
5829 }
5830}
5831#[derive(Debug, Clone)]
5832pub struct RemainingFieldPattern<'tree> {
5833 pub span: ::treesitter_types::Span,
5834 text: &'tree str,
5835}
5836impl<'tree> ::treesitter_types::FromNode<'tree> for RemainingFieldPattern<'tree> {
5837 fn from_node(
5838 node: ::tree_sitter::Node<'tree>,
5839 src: &'tree [u8],
5840 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5841 debug_assert_eq!(node.kind(), "remaining_field_pattern");
5842 Ok(Self {
5843 span: ::treesitter_types::Span::from(node),
5844 text: node.utf8_text(src)?,
5845 })
5846 }
5847}
5848impl<'tree> ::treesitter_types::LeafNode<'tree> for RemainingFieldPattern<'tree> {
5849 fn text(&self) -> &'tree str {
5850 self.text
5851 }
5852}
5853impl ::treesitter_types::Spanned for RemainingFieldPattern<'_> {
5854 fn span(&self) -> ::treesitter_types::Span {
5855 self.span
5856 }
5857}
5858#[derive(Debug, Clone)]
5859pub struct RemovedTraitBound<'tree> {
5860 pub span: ::treesitter_types::Span,
5861 pub children: Type<'tree>,
5862}
5863impl<'tree> ::treesitter_types::FromNode<'tree> for RemovedTraitBound<'tree> {
5864 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5865 fn from_node(
5866 node: ::tree_sitter::Node<'tree>,
5867 src: &'tree [u8],
5868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5869 debug_assert_eq!(node.kind(), "removed_trait_bound");
5870 Ok(Self {
5871 span: ::treesitter_types::Span::from(node),
5872 children: {
5873 #[allow(clippy::suspicious_else_formatting)]
5874 let non_field_children = {
5875 let mut cursor = node.walk();
5876 let mut result = ::std::vec::Vec::new();
5877 if cursor.goto_first_child() {
5878 loop {
5879 if cursor.field_name().is_none()
5880 && cursor.node().is_named()
5881 && !cursor.node().is_extra()
5882 {
5883 result.push(cursor.node());
5884 }
5885 if !cursor.goto_next_sibling() {
5886 break;
5887 }
5888 }
5889 }
5890 result
5891 };
5892 let child = if let Some(&c) = non_field_children.first() {
5893 c
5894 } else {
5895 let mut fallback_cursor = node.walk();
5896 let mut fallback_child = None;
5897 if fallback_cursor.goto_first_child() {
5898 loop {
5899 if fallback_cursor.field_name().is_none()
5900 && !fallback_cursor.node().is_extra()
5901 {
5902 fallback_child = Some(fallback_cursor.node());
5903 break;
5904 }
5905 if !fallback_cursor.goto_next_sibling() {
5906 break;
5907 }
5908 }
5909 }
5910 fallback_child.ok_or_else(|| {
5911 ::treesitter_types::ParseError::missing_field("children", node)
5912 })?
5913 };
5914 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5915 },
5916 })
5917 }
5918}
5919impl ::treesitter_types::Spanned for RemovedTraitBound<'_> {
5920 fn span(&self) -> ::treesitter_types::Span {
5921 self.span
5922 }
5923}
5924#[derive(Debug, Clone)]
5925pub struct ReturnExpression<'tree> {
5926 pub span: ::treesitter_types::Span,
5927 pub children: ::core::option::Option<Expression<'tree>>,
5928}
5929impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnExpression<'tree> {
5930 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5931 fn from_node(
5932 node: ::tree_sitter::Node<'tree>,
5933 src: &'tree [u8],
5934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5935 debug_assert_eq!(node.kind(), "return_expression");
5936 Ok(Self {
5937 span: ::treesitter_types::Span::from(node),
5938 children: {
5939 #[allow(clippy::suspicious_else_formatting)]
5940 let non_field_children = {
5941 let mut cursor = node.walk();
5942 let mut result = ::std::vec::Vec::new();
5943 if cursor.goto_first_child() {
5944 loop {
5945 if cursor.field_name().is_none()
5946 && cursor.node().is_named()
5947 && !cursor.node().is_extra()
5948 {
5949 result.push(cursor.node());
5950 }
5951 if !cursor.goto_next_sibling() {
5952 break;
5953 }
5954 }
5955 }
5956 result
5957 };
5958 match non_field_children.first() {
5959 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5960 child, src,
5961 )?),
5962 None => None,
5963 }
5964 },
5965 })
5966 }
5967}
5968impl ::treesitter_types::Spanned for ReturnExpression<'_> {
5969 fn span(&self) -> ::treesitter_types::Span {
5970 self.span
5971 }
5972}
5973#[derive(Debug, Clone)]
5974pub struct ScopedIdentifier<'tree> {
5975 pub span: ::treesitter_types::Span,
5976 pub name: ScopedIdentifierName<'tree>,
5977 pub path: ::core::option::Option<ScopedIdentifierPath<'tree>>,
5978}
5979impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
5980 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5981 fn from_node(
5982 node: ::tree_sitter::Node<'tree>,
5983 src: &'tree [u8],
5984 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5985 debug_assert_eq!(node.kind(), "scoped_identifier");
5986 Ok(Self {
5987 span: ::treesitter_types::Span::from(node),
5988 name: {
5989 let child = node
5990 .child_by_field_name("name")
5991 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5992 <ScopedIdentifierName as ::treesitter_types::FromNode>::from_node(child, src)?
5993 },
5994 path: match node.child_by_field_name("path") {
5995 Some(child) => Some(
5996 <ScopedIdentifierPath as ::treesitter_types::FromNode>::from_node(child, src)?,
5997 ),
5998 None => None,
5999 },
6000 })
6001 }
6002}
6003impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
6004 fn span(&self) -> ::treesitter_types::Span {
6005 self.span
6006 }
6007}
6008#[derive(Debug, Clone)]
6009pub struct ScopedTypeIdentifier<'tree> {
6010 pub span: ::treesitter_types::Span,
6011 pub name: TypeIdentifier<'tree>,
6012 pub path: ::core::option::Option<ScopedTypeIdentifierPath<'tree>>,
6013}
6014impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
6015 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6016 fn from_node(
6017 node: ::tree_sitter::Node<'tree>,
6018 src: &'tree [u8],
6019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6020 debug_assert_eq!(node.kind(), "scoped_type_identifier");
6021 Ok(Self {
6022 span: ::treesitter_types::Span::from(node),
6023 name: {
6024 let child = node
6025 .child_by_field_name("name")
6026 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6027 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
6028 },
6029 path: match node.child_by_field_name("path") {
6030 Some(child) => Some(
6031 <ScopedTypeIdentifierPath as ::treesitter_types::FromNode>::from_node(
6032 child, src,
6033 )?,
6034 ),
6035 None => None,
6036 },
6037 })
6038 }
6039}
6040impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
6041 fn span(&self) -> ::treesitter_types::Span {
6042 self.span
6043 }
6044}
6045#[derive(Debug, Clone)]
6046pub struct ScopedUseList<'tree> {
6047 pub span: ::treesitter_types::Span,
6048 pub list: UseList<'tree>,
6049 pub path: ::core::option::Option<ScopedUseListPath<'tree>>,
6050}
6051impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseList<'tree> {
6052 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6053 fn from_node(
6054 node: ::tree_sitter::Node<'tree>,
6055 src: &'tree [u8],
6056 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6057 debug_assert_eq!(node.kind(), "scoped_use_list");
6058 Ok(Self {
6059 span: ::treesitter_types::Span::from(node),
6060 list: {
6061 let child = node
6062 .child_by_field_name("list")
6063 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("list", node))?;
6064 <UseList as ::treesitter_types::FromNode>::from_node(child, src)?
6065 },
6066 path: match node.child_by_field_name("path") {
6067 Some(child) => Some(
6068 <ScopedUseListPath as ::treesitter_types::FromNode>::from_node(child, src)?,
6069 ),
6070 None => None,
6071 },
6072 })
6073 }
6074}
6075impl ::treesitter_types::Spanned for ScopedUseList<'_> {
6076 fn span(&self) -> ::treesitter_types::Span {
6077 self.span
6078 }
6079}
6080#[derive(Debug, Clone)]
6081pub struct SelfParameter<'tree> {
6082 pub span: ::treesitter_types::Span,
6083 pub children: ::std::vec::Vec<SelfParameterChildren<'tree>>,
6084}
6085impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameter<'tree> {
6086 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6087 fn from_node(
6088 node: ::tree_sitter::Node<'tree>,
6089 src: &'tree [u8],
6090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6091 debug_assert_eq!(node.kind(), "self_parameter");
6092 Ok(Self {
6093 span: ::treesitter_types::Span::from(node),
6094 children: {
6095 #[allow(clippy::suspicious_else_formatting)]
6096 let non_field_children = {
6097 let mut cursor = node.walk();
6098 let mut result = ::std::vec::Vec::new();
6099 if cursor.goto_first_child() {
6100 loop {
6101 if cursor.field_name().is_none()
6102 && cursor.node().is_named()
6103 && !cursor.node().is_extra()
6104 {
6105 result.push(cursor.node());
6106 }
6107 if !cursor.goto_next_sibling() {
6108 break;
6109 }
6110 }
6111 }
6112 result
6113 };
6114 let mut items = ::std::vec::Vec::new();
6115 for child in non_field_children {
6116 items.push(
6117 <SelfParameterChildren as ::treesitter_types::FromNode>::from_node(
6118 child, src,
6119 )?,
6120 );
6121 }
6122 items
6123 },
6124 })
6125 }
6126}
6127impl ::treesitter_types::Spanned for SelfParameter<'_> {
6128 fn span(&self) -> ::treesitter_types::Span {
6129 self.span
6130 }
6131}
6132#[derive(Debug, Clone)]
6133pub struct ShorthandFieldInitializer<'tree> {
6134 pub span: ::treesitter_types::Span,
6135 pub children: ::std::vec::Vec<ShorthandFieldInitializerChildren<'tree>>,
6136}
6137impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializer<'tree> {
6138 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6139 fn from_node(
6140 node: ::tree_sitter::Node<'tree>,
6141 src: &'tree [u8],
6142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6143 debug_assert_eq!(node.kind(), "shorthand_field_initializer");
6144 Ok(Self {
6145 span: ::treesitter_types::Span::from(node),
6146 children: {
6147 #[allow(clippy::suspicious_else_formatting)]
6148 let non_field_children = {
6149 let mut cursor = node.walk();
6150 let mut result = ::std::vec::Vec::new();
6151 if cursor.goto_first_child() {
6152 loop {
6153 if cursor.field_name().is_none()
6154 && cursor.node().is_named()
6155 && !cursor.node().is_extra()
6156 {
6157 result.push(cursor.node());
6158 }
6159 if !cursor.goto_next_sibling() {
6160 break;
6161 }
6162 }
6163 }
6164 result
6165 };
6166 let mut items = ::std::vec::Vec::new();
6167 for child in non_field_children {
6168 items
6169 .push(
6170 <ShorthandFieldInitializerChildren as ::treesitter_types::FromNode>::from_node(
6171 child,
6172 src,
6173 )?,
6174 );
6175 }
6176 items
6177 },
6178 })
6179 }
6180}
6181impl ::treesitter_types::Spanned for ShorthandFieldInitializer<'_> {
6182 fn span(&self) -> ::treesitter_types::Span {
6183 self.span
6184 }
6185}
6186#[derive(Debug, Clone)]
6187pub struct SlicePattern<'tree> {
6188 pub span: ::treesitter_types::Span,
6189 pub children: ::std::vec::Vec<Pattern<'tree>>,
6190}
6191impl<'tree> ::treesitter_types::FromNode<'tree> for SlicePattern<'tree> {
6192 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6193 fn from_node(
6194 node: ::tree_sitter::Node<'tree>,
6195 src: &'tree [u8],
6196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6197 debug_assert_eq!(node.kind(), "slice_pattern");
6198 Ok(Self {
6199 span: ::treesitter_types::Span::from(node),
6200 children: {
6201 #[allow(clippy::suspicious_else_formatting)]
6202 let non_field_children = {
6203 let mut cursor = node.walk();
6204 let mut result = ::std::vec::Vec::new();
6205 if cursor.goto_first_child() {
6206 loop {
6207 if cursor.field_name().is_none()
6208 && cursor.node().is_named()
6209 && !cursor.node().is_extra()
6210 {
6211 result.push(cursor.node());
6212 }
6213 if !cursor.goto_next_sibling() {
6214 break;
6215 }
6216 }
6217 }
6218 result
6219 };
6220 let mut items = ::std::vec::Vec::new();
6221 for child in non_field_children {
6222 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
6223 child, src,
6224 )?);
6225 }
6226 items
6227 },
6228 })
6229 }
6230}
6231impl ::treesitter_types::Spanned for SlicePattern<'_> {
6232 fn span(&self) -> ::treesitter_types::Span {
6233 self.span
6234 }
6235}
6236#[derive(Debug, Clone)]
6237pub struct SourceFile<'tree> {
6238 pub span: ::treesitter_types::Span,
6239 pub children: ::std::vec::Vec<SourceFileChildren<'tree>>,
6240}
6241impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFile<'tree> {
6242 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6243 fn from_node(
6244 node: ::tree_sitter::Node<'tree>,
6245 src: &'tree [u8],
6246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6247 debug_assert_eq!(node.kind(), "source_file");
6248 Ok(Self {
6249 span: ::treesitter_types::Span::from(node),
6250 children: {
6251 #[allow(clippy::suspicious_else_formatting)]
6252 let non_field_children = {
6253 let mut cursor = node.walk();
6254 let mut result = ::std::vec::Vec::new();
6255 if cursor.goto_first_child() {
6256 loop {
6257 if cursor.field_name().is_none()
6258 && cursor.node().is_named()
6259 && !cursor.node().is_extra()
6260 {
6261 result.push(cursor.node());
6262 }
6263 if !cursor.goto_next_sibling() {
6264 break;
6265 }
6266 }
6267 }
6268 result
6269 };
6270 let mut items = ::std::vec::Vec::new();
6271 for child in non_field_children {
6272 items.push(
6273 <SourceFileChildren as ::treesitter_types::FromNode>::from_node(
6274 child, src,
6275 )?,
6276 );
6277 }
6278 items
6279 },
6280 })
6281 }
6282}
6283impl ::treesitter_types::Spanned for SourceFile<'_> {
6284 fn span(&self) -> ::treesitter_types::Span {
6285 self.span
6286 }
6287}
6288#[derive(Debug, Clone)]
6289pub struct StaticItem<'tree> {
6290 pub span: ::treesitter_types::Span,
6291 pub name: Identifier<'tree>,
6292 pub r#type: Type<'tree>,
6293 pub value: ::core::option::Option<Expression<'tree>>,
6294 pub children: ::std::vec::Vec<StaticItemChildren<'tree>>,
6295}
6296impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItem<'tree> {
6297 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6298 fn from_node(
6299 node: ::tree_sitter::Node<'tree>,
6300 src: &'tree [u8],
6301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6302 debug_assert_eq!(node.kind(), "static_item");
6303 Ok(Self {
6304 span: ::treesitter_types::Span::from(node),
6305 name: {
6306 let child = node
6307 .child_by_field_name("name")
6308 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6309 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
6310 },
6311 r#type: {
6312 let child = node
6313 .child_by_field_name("type")
6314 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6315 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6316 },
6317 value: match node.child_by_field_name("value") {
6318 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6319 child, src,
6320 )?),
6321 None => None,
6322 },
6323 children: {
6324 #[allow(clippy::suspicious_else_formatting)]
6325 let non_field_children = {
6326 let mut cursor = node.walk();
6327 let mut result = ::std::vec::Vec::new();
6328 if cursor.goto_first_child() {
6329 loop {
6330 if cursor.field_name().is_none()
6331 && cursor.node().is_named()
6332 && !cursor.node().is_extra()
6333 {
6334 result.push(cursor.node());
6335 }
6336 if !cursor.goto_next_sibling() {
6337 break;
6338 }
6339 }
6340 }
6341 result
6342 };
6343 let mut items = ::std::vec::Vec::new();
6344 for child in non_field_children {
6345 items.push(
6346 <StaticItemChildren as ::treesitter_types::FromNode>::from_node(
6347 child, src,
6348 )?,
6349 );
6350 }
6351 items
6352 },
6353 })
6354 }
6355}
6356impl ::treesitter_types::Spanned for StaticItem<'_> {
6357 fn span(&self) -> ::treesitter_types::Span {
6358 self.span
6359 }
6360}
6361#[derive(Debug, Clone)]
6362pub struct StringLiteral<'tree> {
6363 pub span: ::treesitter_types::Span,
6364 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
6365}
6366impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
6367 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6368 fn from_node(
6369 node: ::tree_sitter::Node<'tree>,
6370 src: &'tree [u8],
6371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6372 debug_assert_eq!(node.kind(), "string_literal");
6373 Ok(Self {
6374 span: ::treesitter_types::Span::from(node),
6375 children: {
6376 #[allow(clippy::suspicious_else_formatting)]
6377 let non_field_children = {
6378 let mut cursor = node.walk();
6379 let mut result = ::std::vec::Vec::new();
6380 if cursor.goto_first_child() {
6381 loop {
6382 if cursor.field_name().is_none()
6383 && cursor.node().is_named()
6384 && !cursor.node().is_extra()
6385 {
6386 result.push(cursor.node());
6387 }
6388 if !cursor.goto_next_sibling() {
6389 break;
6390 }
6391 }
6392 }
6393 result
6394 };
6395 let mut items = ::std::vec::Vec::new();
6396 for child in non_field_children {
6397 items.push(
6398 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
6399 child, src,
6400 )?,
6401 );
6402 }
6403 items
6404 },
6405 })
6406 }
6407}
6408impl ::treesitter_types::Spanned for StringLiteral<'_> {
6409 fn span(&self) -> ::treesitter_types::Span {
6410 self.span
6411 }
6412}
6413#[derive(Debug, Clone)]
6414pub struct StructExpression<'tree> {
6415 pub span: ::treesitter_types::Span,
6416 pub body: FieldInitializerList<'tree>,
6417 pub name: StructExpressionName<'tree>,
6418}
6419impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpression<'tree> {
6420 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6421 fn from_node(
6422 node: ::tree_sitter::Node<'tree>,
6423 src: &'tree [u8],
6424 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6425 debug_assert_eq!(node.kind(), "struct_expression");
6426 Ok(Self {
6427 span: ::treesitter_types::Span::from(node),
6428 body: {
6429 let child = node
6430 .child_by_field_name("body")
6431 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6432 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(child, src)?
6433 },
6434 name: {
6435 let child = node
6436 .child_by_field_name("name")
6437 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6438 <StructExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
6439 },
6440 })
6441 }
6442}
6443impl ::treesitter_types::Spanned for StructExpression<'_> {
6444 fn span(&self) -> ::treesitter_types::Span {
6445 self.span
6446 }
6447}
6448#[derive(Debug, Clone)]
6449pub struct StructItem<'tree> {
6450 pub span: ::treesitter_types::Span,
6451 pub body: ::core::option::Option<StructItemBody<'tree>>,
6452 pub name: TypeIdentifier<'tree>,
6453 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
6454 pub children: ::std::vec::Vec<StructItemChildren<'tree>>,
6455}
6456impl<'tree> ::treesitter_types::FromNode<'tree> for StructItem<'tree> {
6457 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6458 fn from_node(
6459 node: ::tree_sitter::Node<'tree>,
6460 src: &'tree [u8],
6461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6462 debug_assert_eq!(node.kind(), "struct_item");
6463 Ok(Self {
6464 span: ::treesitter_types::Span::from(node),
6465 body: match node.child_by_field_name("body") {
6466 Some(child) => Some(<StructItemBody as ::treesitter_types::FromNode>::from_node(
6467 child, src,
6468 )?),
6469 None => None,
6470 },
6471 name: {
6472 let child = node
6473 .child_by_field_name("name")
6474 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6475 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
6476 },
6477 type_parameters: match node.child_by_field_name("type_parameters") {
6478 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
6479 child, src,
6480 )?),
6481 None => None,
6482 },
6483 children: {
6484 #[allow(clippy::suspicious_else_formatting)]
6485 let non_field_children = {
6486 let mut cursor = node.walk();
6487 let mut result = ::std::vec::Vec::new();
6488 if cursor.goto_first_child() {
6489 loop {
6490 if cursor.field_name().is_none()
6491 && cursor.node().is_named()
6492 && !cursor.node().is_extra()
6493 {
6494 result.push(cursor.node());
6495 }
6496 if !cursor.goto_next_sibling() {
6497 break;
6498 }
6499 }
6500 }
6501 result
6502 };
6503 let mut items = ::std::vec::Vec::new();
6504 for child in non_field_children {
6505 items.push(
6506 <StructItemChildren as ::treesitter_types::FromNode>::from_node(
6507 child, src,
6508 )?,
6509 );
6510 }
6511 items
6512 },
6513 })
6514 }
6515}
6516impl ::treesitter_types::Spanned for StructItem<'_> {
6517 fn span(&self) -> ::treesitter_types::Span {
6518 self.span
6519 }
6520}
6521#[derive(Debug, Clone)]
6522pub struct StructPattern<'tree> {
6523 pub span: ::treesitter_types::Span,
6524 pub r#type: StructPatternType<'tree>,
6525 pub children: ::std::vec::Vec<StructPatternChildren<'tree>>,
6526}
6527impl<'tree> ::treesitter_types::FromNode<'tree> for StructPattern<'tree> {
6528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6529 fn from_node(
6530 node: ::tree_sitter::Node<'tree>,
6531 src: &'tree [u8],
6532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6533 debug_assert_eq!(node.kind(), "struct_pattern");
6534 Ok(Self {
6535 span: ::treesitter_types::Span::from(node),
6536 r#type: {
6537 let child = node
6538 .child_by_field_name("type")
6539 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6540 <StructPatternType as ::treesitter_types::FromNode>::from_node(child, src)?
6541 },
6542 children: {
6543 #[allow(clippy::suspicious_else_formatting)]
6544 let non_field_children = {
6545 let mut cursor = node.walk();
6546 let mut result = ::std::vec::Vec::new();
6547 if cursor.goto_first_child() {
6548 loop {
6549 if cursor.field_name().is_none()
6550 && cursor.node().is_named()
6551 && !cursor.node().is_extra()
6552 {
6553 result.push(cursor.node());
6554 }
6555 if !cursor.goto_next_sibling() {
6556 break;
6557 }
6558 }
6559 }
6560 result
6561 };
6562 let mut items = ::std::vec::Vec::new();
6563 for child in non_field_children {
6564 items.push(
6565 <StructPatternChildren as ::treesitter_types::FromNode>::from_node(
6566 child, src,
6567 )?,
6568 );
6569 }
6570 items
6571 },
6572 })
6573 }
6574}
6575impl ::treesitter_types::Spanned for StructPattern<'_> {
6576 fn span(&self) -> ::treesitter_types::Span {
6577 self.span
6578 }
6579}
6580#[derive(Debug, Clone)]
6581pub struct TokenBindingPattern<'tree> {
6582 pub span: ::treesitter_types::Span,
6583 pub name: Metavariable<'tree>,
6584 pub r#type: FragmentSpecifier<'tree>,
6585}
6586impl<'tree> ::treesitter_types::FromNode<'tree> for TokenBindingPattern<'tree> {
6587 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6588 fn from_node(
6589 node: ::tree_sitter::Node<'tree>,
6590 src: &'tree [u8],
6591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6592 debug_assert_eq!(node.kind(), "token_binding_pattern");
6593 Ok(Self {
6594 span: ::treesitter_types::Span::from(node),
6595 name: {
6596 let child = node
6597 .child_by_field_name("name")
6598 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6599 <Metavariable as ::treesitter_types::FromNode>::from_node(child, src)?
6600 },
6601 r#type: {
6602 let child = node
6603 .child_by_field_name("type")
6604 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6605 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
6606 },
6607 })
6608 }
6609}
6610impl ::treesitter_types::Spanned for TokenBindingPattern<'_> {
6611 fn span(&self) -> ::treesitter_types::Span {
6612 self.span
6613 }
6614}
6615#[derive(Debug, Clone)]
6616pub struct TokenRepetition<'tree> {
6617 pub span: ::treesitter_types::Span,
6618 pub children: ::std::vec::Vec<TokenRepetitionChildren<'tree>>,
6619}
6620impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetition<'tree> {
6621 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6622 fn from_node(
6623 node: ::tree_sitter::Node<'tree>,
6624 src: &'tree [u8],
6625 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6626 debug_assert_eq!(node.kind(), "token_repetition");
6627 Ok(Self {
6628 span: ::treesitter_types::Span::from(node),
6629 children: {
6630 #[allow(clippy::suspicious_else_formatting)]
6631 let non_field_children = {
6632 let mut cursor = node.walk();
6633 let mut result = ::std::vec::Vec::new();
6634 if cursor.goto_first_child() {
6635 loop {
6636 if cursor.field_name().is_none()
6637 && cursor.node().is_named()
6638 && !cursor.node().is_extra()
6639 {
6640 result.push(cursor.node());
6641 }
6642 if !cursor.goto_next_sibling() {
6643 break;
6644 }
6645 }
6646 }
6647 result
6648 };
6649 let mut items = ::std::vec::Vec::new();
6650 for child in non_field_children {
6651 items.push(
6652 <TokenRepetitionChildren as ::treesitter_types::FromNode>::from_node(
6653 child, src,
6654 )?,
6655 );
6656 }
6657 items
6658 },
6659 })
6660 }
6661}
6662impl ::treesitter_types::Spanned for TokenRepetition<'_> {
6663 fn span(&self) -> ::treesitter_types::Span {
6664 self.span
6665 }
6666}
6667#[derive(Debug, Clone)]
6668pub struct TokenRepetitionPattern<'tree> {
6669 pub span: ::treesitter_types::Span,
6670 pub children: ::std::vec::Vec<TokenRepetitionPatternChildren<'tree>>,
6671}
6672impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPattern<'tree> {
6673 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6674 fn from_node(
6675 node: ::tree_sitter::Node<'tree>,
6676 src: &'tree [u8],
6677 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6678 debug_assert_eq!(node.kind(), "token_repetition_pattern");
6679 Ok(Self {
6680 span: ::treesitter_types::Span::from(node),
6681 children: {
6682 #[allow(clippy::suspicious_else_formatting)]
6683 let non_field_children = {
6684 let mut cursor = node.walk();
6685 let mut result = ::std::vec::Vec::new();
6686 if cursor.goto_first_child() {
6687 loop {
6688 if cursor.field_name().is_none()
6689 && cursor.node().is_named()
6690 && !cursor.node().is_extra()
6691 {
6692 result.push(cursor.node());
6693 }
6694 if !cursor.goto_next_sibling() {
6695 break;
6696 }
6697 }
6698 }
6699 result
6700 };
6701 let mut items = ::std::vec::Vec::new();
6702 for child in non_field_children {
6703 items
6704 .push(
6705 <TokenRepetitionPatternChildren as ::treesitter_types::FromNode>::from_node(
6706 child,
6707 src,
6708 )?,
6709 );
6710 }
6711 items
6712 },
6713 })
6714 }
6715}
6716impl ::treesitter_types::Spanned for TokenRepetitionPattern<'_> {
6717 fn span(&self) -> ::treesitter_types::Span {
6718 self.span
6719 }
6720}
6721#[derive(Debug, Clone)]
6722pub struct TokenTree<'tree> {
6723 pub span: ::treesitter_types::Span,
6724 pub children: ::std::vec::Vec<TokenTreeChildren<'tree>>,
6725}
6726impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTree<'tree> {
6727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6728 fn from_node(
6729 node: ::tree_sitter::Node<'tree>,
6730 src: &'tree [u8],
6731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6732 debug_assert_eq!(node.kind(), "token_tree");
6733 Ok(Self {
6734 span: ::treesitter_types::Span::from(node),
6735 children: {
6736 #[allow(clippy::suspicious_else_formatting)]
6737 let non_field_children = {
6738 let mut cursor = node.walk();
6739 let mut result = ::std::vec::Vec::new();
6740 if cursor.goto_first_child() {
6741 loop {
6742 if cursor.field_name().is_none()
6743 && cursor.node().is_named()
6744 && !cursor.node().is_extra()
6745 {
6746 result.push(cursor.node());
6747 }
6748 if !cursor.goto_next_sibling() {
6749 break;
6750 }
6751 }
6752 }
6753 result
6754 };
6755 let mut items = ::std::vec::Vec::new();
6756 for child in non_field_children {
6757 items.push(
6758 <TokenTreeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6759 );
6760 }
6761 items
6762 },
6763 })
6764 }
6765}
6766impl ::treesitter_types::Spanned for TokenTree<'_> {
6767 fn span(&self) -> ::treesitter_types::Span {
6768 self.span
6769 }
6770}
6771#[derive(Debug, Clone)]
6772pub struct TokenTreePattern<'tree> {
6773 pub span: ::treesitter_types::Span,
6774 pub children: ::std::vec::Vec<TokenTreePatternChildren<'tree>>,
6775}
6776impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePattern<'tree> {
6777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6778 fn from_node(
6779 node: ::tree_sitter::Node<'tree>,
6780 src: &'tree [u8],
6781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6782 debug_assert_eq!(node.kind(), "token_tree_pattern");
6783 Ok(Self {
6784 span: ::treesitter_types::Span::from(node),
6785 children: {
6786 #[allow(clippy::suspicious_else_formatting)]
6787 let non_field_children = {
6788 let mut cursor = node.walk();
6789 let mut result = ::std::vec::Vec::new();
6790 if cursor.goto_first_child() {
6791 loop {
6792 if cursor.field_name().is_none()
6793 && cursor.node().is_named()
6794 && !cursor.node().is_extra()
6795 {
6796 result.push(cursor.node());
6797 }
6798 if !cursor.goto_next_sibling() {
6799 break;
6800 }
6801 }
6802 }
6803 result
6804 };
6805 let mut items = ::std::vec::Vec::new();
6806 for child in non_field_children {
6807 items.push(
6808 <TokenTreePatternChildren as ::treesitter_types::FromNode>::from_node(
6809 child, src,
6810 )?,
6811 );
6812 }
6813 items
6814 },
6815 })
6816 }
6817}
6818impl ::treesitter_types::Spanned for TokenTreePattern<'_> {
6819 fn span(&self) -> ::treesitter_types::Span {
6820 self.span
6821 }
6822}
6823#[derive(Debug, Clone)]
6824pub struct TraitBounds<'tree> {
6825 pub span: ::treesitter_types::Span,
6826 pub children: ::std::vec::Vec<TraitBoundsChildren<'tree>>,
6827}
6828impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBounds<'tree> {
6829 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6830 fn from_node(
6831 node: ::tree_sitter::Node<'tree>,
6832 src: &'tree [u8],
6833 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6834 debug_assert_eq!(node.kind(), "trait_bounds");
6835 Ok(Self {
6836 span: ::treesitter_types::Span::from(node),
6837 children: {
6838 #[allow(clippy::suspicious_else_formatting)]
6839 let non_field_children = {
6840 let mut cursor = node.walk();
6841 let mut result = ::std::vec::Vec::new();
6842 if cursor.goto_first_child() {
6843 loop {
6844 if cursor.field_name().is_none()
6845 && cursor.node().is_named()
6846 && !cursor.node().is_extra()
6847 {
6848 result.push(cursor.node());
6849 }
6850 if !cursor.goto_next_sibling() {
6851 break;
6852 }
6853 }
6854 }
6855 result
6856 };
6857 let mut items = ::std::vec::Vec::new();
6858 for child in non_field_children {
6859 items.push(
6860 <TraitBoundsChildren as ::treesitter_types::FromNode>::from_node(
6861 child, src,
6862 )?,
6863 );
6864 }
6865 items
6866 },
6867 })
6868 }
6869}
6870impl ::treesitter_types::Spanned for TraitBounds<'_> {
6871 fn span(&self) -> ::treesitter_types::Span {
6872 self.span
6873 }
6874}
6875#[derive(Debug, Clone)]
6876pub struct TraitItem<'tree> {
6877 pub span: ::treesitter_types::Span,
6878 pub body: DeclarationList<'tree>,
6879 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
6880 pub name: TypeIdentifier<'tree>,
6881 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
6882 pub children: ::std::vec::Vec<TraitItemChildren<'tree>>,
6883}
6884impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItem<'tree> {
6885 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6886 fn from_node(
6887 node: ::tree_sitter::Node<'tree>,
6888 src: &'tree [u8],
6889 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6890 debug_assert_eq!(node.kind(), "trait_item");
6891 Ok(Self {
6892 span: ::treesitter_types::Span::from(node),
6893 body: {
6894 let child = node
6895 .child_by_field_name("body")
6896 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6897 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
6898 },
6899 bounds: match node.child_by_field_name("bounds") {
6900 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
6901 child, src,
6902 )?),
6903 None => None,
6904 },
6905 name: {
6906 let child = node
6907 .child_by_field_name("name")
6908 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6909 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
6910 },
6911 type_parameters: match node.child_by_field_name("type_parameters") {
6912 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
6913 child, src,
6914 )?),
6915 None => None,
6916 },
6917 children: {
6918 #[allow(clippy::suspicious_else_formatting)]
6919 let non_field_children = {
6920 let mut cursor = node.walk();
6921 let mut result = ::std::vec::Vec::new();
6922 if cursor.goto_first_child() {
6923 loop {
6924 if cursor.field_name().is_none()
6925 && cursor.node().is_named()
6926 && !cursor.node().is_extra()
6927 {
6928 result.push(cursor.node());
6929 }
6930 if !cursor.goto_next_sibling() {
6931 break;
6932 }
6933 }
6934 }
6935 result
6936 };
6937 let mut items = ::std::vec::Vec::new();
6938 for child in non_field_children {
6939 items.push(
6940 <TraitItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6941 );
6942 }
6943 items
6944 },
6945 })
6946 }
6947}
6948impl ::treesitter_types::Spanned for TraitItem<'_> {
6949 fn span(&self) -> ::treesitter_types::Span {
6950 self.span
6951 }
6952}
6953#[derive(Debug, Clone)]
6954pub struct TryBlock<'tree> {
6955 pub span: ::treesitter_types::Span,
6956 pub children: Block<'tree>,
6957}
6958impl<'tree> ::treesitter_types::FromNode<'tree> for TryBlock<'tree> {
6959 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6960 fn from_node(
6961 node: ::tree_sitter::Node<'tree>,
6962 src: &'tree [u8],
6963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6964 debug_assert_eq!(node.kind(), "try_block");
6965 Ok(Self {
6966 span: ::treesitter_types::Span::from(node),
6967 children: {
6968 #[allow(clippy::suspicious_else_formatting)]
6969 let non_field_children = {
6970 let mut cursor = node.walk();
6971 let mut result = ::std::vec::Vec::new();
6972 if cursor.goto_first_child() {
6973 loop {
6974 if cursor.field_name().is_none()
6975 && cursor.node().is_named()
6976 && !cursor.node().is_extra()
6977 {
6978 result.push(cursor.node());
6979 }
6980 if !cursor.goto_next_sibling() {
6981 break;
6982 }
6983 }
6984 }
6985 result
6986 };
6987 let child = if let Some(&c) = non_field_children.first() {
6988 c
6989 } else {
6990 let mut fallback_cursor = node.walk();
6991 let mut fallback_child = None;
6992 if fallback_cursor.goto_first_child() {
6993 loop {
6994 if fallback_cursor.field_name().is_none()
6995 && !fallback_cursor.node().is_extra()
6996 {
6997 fallback_child = Some(fallback_cursor.node());
6998 break;
6999 }
7000 if !fallback_cursor.goto_next_sibling() {
7001 break;
7002 }
7003 }
7004 }
7005 fallback_child.ok_or_else(|| {
7006 ::treesitter_types::ParseError::missing_field("children", node)
7007 })?
7008 };
7009 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
7010 },
7011 })
7012 }
7013}
7014impl ::treesitter_types::Spanned for TryBlock<'_> {
7015 fn span(&self) -> ::treesitter_types::Span {
7016 self.span
7017 }
7018}
7019#[derive(Debug, Clone)]
7020pub struct TryExpression<'tree> {
7021 pub span: ::treesitter_types::Span,
7022 pub children: Expression<'tree>,
7023}
7024impl<'tree> ::treesitter_types::FromNode<'tree> for TryExpression<'tree> {
7025 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7026 fn from_node(
7027 node: ::tree_sitter::Node<'tree>,
7028 src: &'tree [u8],
7029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7030 debug_assert_eq!(node.kind(), "try_expression");
7031 Ok(Self {
7032 span: ::treesitter_types::Span::from(node),
7033 children: {
7034 #[allow(clippy::suspicious_else_formatting)]
7035 let non_field_children = {
7036 let mut cursor = node.walk();
7037 let mut result = ::std::vec::Vec::new();
7038 if cursor.goto_first_child() {
7039 loop {
7040 if cursor.field_name().is_none()
7041 && cursor.node().is_named()
7042 && !cursor.node().is_extra()
7043 {
7044 result.push(cursor.node());
7045 }
7046 if !cursor.goto_next_sibling() {
7047 break;
7048 }
7049 }
7050 }
7051 result
7052 };
7053 let child = if let Some(&c) = non_field_children.first() {
7054 c
7055 } else {
7056 let mut fallback_cursor = node.walk();
7057 let mut fallback_child = None;
7058 if fallback_cursor.goto_first_child() {
7059 loop {
7060 if fallback_cursor.field_name().is_none()
7061 && !fallback_cursor.node().is_extra()
7062 {
7063 fallback_child = Some(fallback_cursor.node());
7064 break;
7065 }
7066 if !fallback_cursor.goto_next_sibling() {
7067 break;
7068 }
7069 }
7070 }
7071 fallback_child.ok_or_else(|| {
7072 ::treesitter_types::ParseError::missing_field("children", node)
7073 })?
7074 };
7075 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7076 },
7077 })
7078 }
7079}
7080impl ::treesitter_types::Spanned for TryExpression<'_> {
7081 fn span(&self) -> ::treesitter_types::Span {
7082 self.span
7083 }
7084}
7085#[derive(Debug, Clone)]
7086pub struct TupleExpression<'tree> {
7087 pub span: ::treesitter_types::Span,
7088 pub children: ::std::vec::Vec<TupleExpressionChildren<'tree>>,
7089}
7090impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
7091 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7092 fn from_node(
7093 node: ::tree_sitter::Node<'tree>,
7094 src: &'tree [u8],
7095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7096 debug_assert_eq!(node.kind(), "tuple_expression");
7097 Ok(Self {
7098 span: ::treesitter_types::Span::from(node),
7099 children: {
7100 #[allow(clippy::suspicious_else_formatting)]
7101 let non_field_children = {
7102 let mut cursor = node.walk();
7103 let mut result = ::std::vec::Vec::new();
7104 if cursor.goto_first_child() {
7105 loop {
7106 if cursor.field_name().is_none()
7107 && cursor.node().is_named()
7108 && !cursor.node().is_extra()
7109 {
7110 result.push(cursor.node());
7111 }
7112 if !cursor.goto_next_sibling() {
7113 break;
7114 }
7115 }
7116 }
7117 result
7118 };
7119 let mut items = ::std::vec::Vec::new();
7120 for child in non_field_children {
7121 items.push(
7122 <TupleExpressionChildren as ::treesitter_types::FromNode>::from_node(
7123 child, src,
7124 )?,
7125 );
7126 }
7127 items
7128 },
7129 })
7130 }
7131}
7132impl ::treesitter_types::Spanned for TupleExpression<'_> {
7133 fn span(&self) -> ::treesitter_types::Span {
7134 self.span
7135 }
7136}
7137#[derive(Debug, Clone)]
7138pub struct TuplePattern<'tree> {
7139 pub span: ::treesitter_types::Span,
7140 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
7141}
7142impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
7143 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7144 fn from_node(
7145 node: ::tree_sitter::Node<'tree>,
7146 src: &'tree [u8],
7147 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7148 debug_assert_eq!(node.kind(), "tuple_pattern");
7149 Ok(Self {
7150 span: ::treesitter_types::Span::from(node),
7151 children: {
7152 #[allow(clippy::suspicious_else_formatting)]
7153 let non_field_children = {
7154 let mut cursor = node.walk();
7155 let mut result = ::std::vec::Vec::new();
7156 if cursor.goto_first_child() {
7157 loop {
7158 if cursor.field_name().is_none()
7159 && cursor.node().is_named()
7160 && !cursor.node().is_extra()
7161 {
7162 result.push(cursor.node());
7163 }
7164 if !cursor.goto_next_sibling() {
7165 break;
7166 }
7167 }
7168 }
7169 result
7170 };
7171 let mut items = ::std::vec::Vec::new();
7172 for child in non_field_children {
7173 items.push(
7174 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
7175 child, src,
7176 )?,
7177 );
7178 }
7179 items
7180 },
7181 })
7182 }
7183}
7184impl ::treesitter_types::Spanned for TuplePattern<'_> {
7185 fn span(&self) -> ::treesitter_types::Span {
7186 self.span
7187 }
7188}
7189#[derive(Debug, Clone)]
7190pub struct TupleStructPattern<'tree> {
7191 pub span: ::treesitter_types::Span,
7192 pub r#type: TupleStructPatternType<'tree>,
7193 pub children: ::std::vec::Vec<Pattern<'tree>>,
7194}
7195impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPattern<'tree> {
7196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7197 fn from_node(
7198 node: ::tree_sitter::Node<'tree>,
7199 src: &'tree [u8],
7200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7201 debug_assert_eq!(node.kind(), "tuple_struct_pattern");
7202 Ok(Self {
7203 span: ::treesitter_types::Span::from(node),
7204 r#type: {
7205 let child = node
7206 .child_by_field_name("type")
7207 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7208 <TupleStructPatternType as ::treesitter_types::FromNode>::from_node(child, src)?
7209 },
7210 children: {
7211 #[allow(clippy::suspicious_else_formatting)]
7212 let non_field_children = {
7213 let mut cursor = node.walk();
7214 let mut result = ::std::vec::Vec::new();
7215 if cursor.goto_first_child() {
7216 loop {
7217 if cursor.field_name().is_none()
7218 && cursor.node().is_named()
7219 && !cursor.node().is_extra()
7220 {
7221 result.push(cursor.node());
7222 }
7223 if !cursor.goto_next_sibling() {
7224 break;
7225 }
7226 }
7227 }
7228 result
7229 };
7230 let mut items = ::std::vec::Vec::new();
7231 for child in non_field_children {
7232 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
7233 child, src,
7234 )?);
7235 }
7236 items
7237 },
7238 })
7239 }
7240}
7241impl ::treesitter_types::Spanned for TupleStructPattern<'_> {
7242 fn span(&self) -> ::treesitter_types::Span {
7243 self.span
7244 }
7245}
7246#[derive(Debug, Clone)]
7247pub struct TupleType<'tree> {
7248 pub span: ::treesitter_types::Span,
7249 pub children: ::std::vec::Vec<Type<'tree>>,
7250}
7251impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
7252 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7253 fn from_node(
7254 node: ::tree_sitter::Node<'tree>,
7255 src: &'tree [u8],
7256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7257 debug_assert_eq!(node.kind(), "tuple_type");
7258 Ok(Self {
7259 span: ::treesitter_types::Span::from(node),
7260 children: {
7261 #[allow(clippy::suspicious_else_formatting)]
7262 let non_field_children = {
7263 let mut cursor = node.walk();
7264 let mut result = ::std::vec::Vec::new();
7265 if cursor.goto_first_child() {
7266 loop {
7267 if cursor.field_name().is_none()
7268 && cursor.node().is_named()
7269 && !cursor.node().is_extra()
7270 {
7271 result.push(cursor.node());
7272 }
7273 if !cursor.goto_next_sibling() {
7274 break;
7275 }
7276 }
7277 }
7278 result
7279 };
7280 let mut items = ::std::vec::Vec::new();
7281 for child in non_field_children {
7282 items.push(<Type as ::treesitter_types::FromNode>::from_node(
7283 child, src,
7284 )?);
7285 }
7286 items
7287 },
7288 })
7289 }
7290}
7291impl ::treesitter_types::Spanned for TupleType<'_> {
7292 fn span(&self) -> ::treesitter_types::Span {
7293 self.span
7294 }
7295}
7296#[derive(Debug, Clone)]
7297pub struct TypeArguments<'tree> {
7298 pub span: ::treesitter_types::Span,
7299 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
7300}
7301impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
7302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7303 fn from_node(
7304 node: ::tree_sitter::Node<'tree>,
7305 src: &'tree [u8],
7306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7307 debug_assert_eq!(node.kind(), "type_arguments");
7308 Ok(Self {
7309 span: ::treesitter_types::Span::from(node),
7310 children: {
7311 #[allow(clippy::suspicious_else_formatting)]
7312 let non_field_children = {
7313 let mut cursor = node.walk();
7314 let mut result = ::std::vec::Vec::new();
7315 if cursor.goto_first_child() {
7316 loop {
7317 if cursor.field_name().is_none()
7318 && cursor.node().is_named()
7319 && !cursor.node().is_extra()
7320 {
7321 result.push(cursor.node());
7322 }
7323 if !cursor.goto_next_sibling() {
7324 break;
7325 }
7326 }
7327 }
7328 result
7329 };
7330 let mut items = ::std::vec::Vec::new();
7331 for child in non_field_children {
7332 items.push(
7333 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
7334 child, src,
7335 )?,
7336 );
7337 }
7338 items
7339 },
7340 })
7341 }
7342}
7343impl ::treesitter_types::Spanned for TypeArguments<'_> {
7344 fn span(&self) -> ::treesitter_types::Span {
7345 self.span
7346 }
7347}
7348#[derive(Debug, Clone)]
7349pub struct TypeBinding<'tree> {
7350 pub span: ::treesitter_types::Span,
7351 pub name: TypeIdentifier<'tree>,
7352 pub r#type: Type<'tree>,
7353 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
7354}
7355impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBinding<'tree> {
7356 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7357 fn from_node(
7358 node: ::tree_sitter::Node<'tree>,
7359 src: &'tree [u8],
7360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7361 debug_assert_eq!(node.kind(), "type_binding");
7362 Ok(Self {
7363 span: ::treesitter_types::Span::from(node),
7364 name: {
7365 let child = node
7366 .child_by_field_name("name")
7367 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7368 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7369 },
7370 r#type: {
7371 let child = node
7372 .child_by_field_name("type")
7373 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7374 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7375 },
7376 type_arguments: match node.child_by_field_name("type_arguments") {
7377 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
7378 child, src,
7379 )?),
7380 None => None,
7381 },
7382 })
7383 }
7384}
7385impl ::treesitter_types::Spanned for TypeBinding<'_> {
7386 fn span(&self) -> ::treesitter_types::Span {
7387 self.span
7388 }
7389}
7390#[derive(Debug, Clone)]
7391pub struct TypeCastExpression<'tree> {
7392 pub span: ::treesitter_types::Span,
7393 pub r#type: Type<'tree>,
7394 pub value: Expression<'tree>,
7395}
7396impl<'tree> ::treesitter_types::FromNode<'tree> for TypeCastExpression<'tree> {
7397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7398 fn from_node(
7399 node: ::tree_sitter::Node<'tree>,
7400 src: &'tree [u8],
7401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7402 debug_assert_eq!(node.kind(), "type_cast_expression");
7403 Ok(Self {
7404 span: ::treesitter_types::Span::from(node),
7405 r#type: {
7406 let child = node
7407 .child_by_field_name("type")
7408 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7409 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7410 },
7411 value: {
7412 let child = node
7413 .child_by_field_name("value")
7414 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
7415 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7416 },
7417 })
7418 }
7419}
7420impl ::treesitter_types::Spanned for TypeCastExpression<'_> {
7421 fn span(&self) -> ::treesitter_types::Span {
7422 self.span
7423 }
7424}
7425#[derive(Debug, Clone)]
7426pub struct TypeItem<'tree> {
7427 pub span: ::treesitter_types::Span,
7428 pub name: TypeIdentifier<'tree>,
7429 pub r#type: Type<'tree>,
7430 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7431 pub children: ::std::vec::Vec<TypeItemChildren<'tree>>,
7432}
7433impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItem<'tree> {
7434 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7435 fn from_node(
7436 node: ::tree_sitter::Node<'tree>,
7437 src: &'tree [u8],
7438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7439 debug_assert_eq!(node.kind(), "type_item");
7440 Ok(Self {
7441 span: ::treesitter_types::Span::from(node),
7442 name: {
7443 let child = node
7444 .child_by_field_name("name")
7445 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7446 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7447 },
7448 r#type: {
7449 let child = node
7450 .child_by_field_name("type")
7451 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7452 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7453 },
7454 type_parameters: match node.child_by_field_name("type_parameters") {
7455 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
7456 child, src,
7457 )?),
7458 None => None,
7459 },
7460 children: {
7461 #[allow(clippy::suspicious_else_formatting)]
7462 let non_field_children = {
7463 let mut cursor = node.walk();
7464 let mut result = ::std::vec::Vec::new();
7465 if cursor.goto_first_child() {
7466 loop {
7467 if cursor.field_name().is_none()
7468 && cursor.node().is_named()
7469 && !cursor.node().is_extra()
7470 {
7471 result.push(cursor.node());
7472 }
7473 if !cursor.goto_next_sibling() {
7474 break;
7475 }
7476 }
7477 }
7478 result
7479 };
7480 let mut items = ::std::vec::Vec::new();
7481 for child in non_field_children {
7482 items.push(
7483 <TypeItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7484 );
7485 }
7486 items
7487 },
7488 })
7489 }
7490}
7491impl ::treesitter_types::Spanned for TypeItem<'_> {
7492 fn span(&self) -> ::treesitter_types::Span {
7493 self.span
7494 }
7495}
7496#[derive(Debug, Clone)]
7497pub struct TypeParameter<'tree> {
7498 pub span: ::treesitter_types::Span,
7499 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
7500 pub default_type: ::core::option::Option<Type<'tree>>,
7501 pub name: TypeIdentifier<'tree>,
7502}
7503impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
7504 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7505 fn from_node(
7506 node: ::tree_sitter::Node<'tree>,
7507 src: &'tree [u8],
7508 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7509 debug_assert_eq!(node.kind(), "type_parameter");
7510 Ok(Self {
7511 span: ::treesitter_types::Span::from(node),
7512 bounds: match node.child_by_field_name("bounds") {
7513 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
7514 child, src,
7515 )?),
7516 None => None,
7517 },
7518 default_type: match node.child_by_field_name("default_type") {
7519 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
7520 child, src,
7521 )?),
7522 None => None,
7523 },
7524 name: {
7525 let child = node
7526 .child_by_field_name("name")
7527 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7528 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7529 },
7530 })
7531 }
7532}
7533impl ::treesitter_types::Spanned for TypeParameter<'_> {
7534 fn span(&self) -> ::treesitter_types::Span {
7535 self.span
7536 }
7537}
7538#[derive(Debug, Clone)]
7539pub struct TypeParameters<'tree> {
7540 pub span: ::treesitter_types::Span,
7541 pub children: ::std::vec::Vec<TypeParametersChildren<'tree>>,
7542}
7543impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
7544 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7545 fn from_node(
7546 node: ::tree_sitter::Node<'tree>,
7547 src: &'tree [u8],
7548 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7549 debug_assert_eq!(node.kind(), "type_parameters");
7550 Ok(Self {
7551 span: ::treesitter_types::Span::from(node),
7552 children: {
7553 #[allow(clippy::suspicious_else_formatting)]
7554 let non_field_children = {
7555 let mut cursor = node.walk();
7556 let mut result = ::std::vec::Vec::new();
7557 if cursor.goto_first_child() {
7558 loop {
7559 if cursor.field_name().is_none()
7560 && cursor.node().is_named()
7561 && !cursor.node().is_extra()
7562 {
7563 result.push(cursor.node());
7564 }
7565 if !cursor.goto_next_sibling() {
7566 break;
7567 }
7568 }
7569 }
7570 result
7571 };
7572 let mut items = ::std::vec::Vec::new();
7573 for child in non_field_children {
7574 items.push(
7575 <TypeParametersChildren as ::treesitter_types::FromNode>::from_node(
7576 child, src,
7577 )?,
7578 );
7579 }
7580 items
7581 },
7582 })
7583 }
7584}
7585impl ::treesitter_types::Spanned for TypeParameters<'_> {
7586 fn span(&self) -> ::treesitter_types::Span {
7587 self.span
7588 }
7589}
7590#[derive(Debug, Clone)]
7591pub struct UnaryExpression<'tree> {
7592 pub span: ::treesitter_types::Span,
7593 pub children: Expression<'tree>,
7594}
7595impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
7596 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7597 fn from_node(
7598 node: ::tree_sitter::Node<'tree>,
7599 src: &'tree [u8],
7600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7601 debug_assert_eq!(node.kind(), "unary_expression");
7602 Ok(Self {
7603 span: ::treesitter_types::Span::from(node),
7604 children: {
7605 #[allow(clippy::suspicious_else_formatting)]
7606 let non_field_children = {
7607 let mut cursor = node.walk();
7608 let mut result = ::std::vec::Vec::new();
7609 if cursor.goto_first_child() {
7610 loop {
7611 if cursor.field_name().is_none()
7612 && cursor.node().is_named()
7613 && !cursor.node().is_extra()
7614 {
7615 result.push(cursor.node());
7616 }
7617 if !cursor.goto_next_sibling() {
7618 break;
7619 }
7620 }
7621 }
7622 result
7623 };
7624 let child = if let Some(&c) = non_field_children.first() {
7625 c
7626 } else {
7627 let mut fallback_cursor = node.walk();
7628 let mut fallback_child = None;
7629 if fallback_cursor.goto_first_child() {
7630 loop {
7631 if fallback_cursor.field_name().is_none()
7632 && !fallback_cursor.node().is_extra()
7633 {
7634 fallback_child = Some(fallback_cursor.node());
7635 break;
7636 }
7637 if !fallback_cursor.goto_next_sibling() {
7638 break;
7639 }
7640 }
7641 }
7642 fallback_child.ok_or_else(|| {
7643 ::treesitter_types::ParseError::missing_field("children", node)
7644 })?
7645 };
7646 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7647 },
7648 })
7649 }
7650}
7651impl ::treesitter_types::Spanned for UnaryExpression<'_> {
7652 fn span(&self) -> ::treesitter_types::Span {
7653 self.span
7654 }
7655}
7656#[derive(Debug, Clone)]
7657pub struct UnionItem<'tree> {
7658 pub span: ::treesitter_types::Span,
7659 pub body: FieldDeclarationList<'tree>,
7660 pub name: TypeIdentifier<'tree>,
7661 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7662 pub children: ::std::vec::Vec<UnionItemChildren<'tree>>,
7663}
7664impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItem<'tree> {
7665 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7666 fn from_node(
7667 node: ::tree_sitter::Node<'tree>,
7668 src: &'tree [u8],
7669 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7670 debug_assert_eq!(node.kind(), "union_item");
7671 Ok(Self {
7672 span: ::treesitter_types::Span::from(node),
7673 body: {
7674 let child = node
7675 .child_by_field_name("body")
7676 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7677 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
7678 },
7679 name: {
7680 let child = node
7681 .child_by_field_name("name")
7682 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7683 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7684 },
7685 type_parameters: match node.child_by_field_name("type_parameters") {
7686 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
7687 child, src,
7688 )?),
7689 None => None,
7690 },
7691 children: {
7692 #[allow(clippy::suspicious_else_formatting)]
7693 let non_field_children = {
7694 let mut cursor = node.walk();
7695 let mut result = ::std::vec::Vec::new();
7696 if cursor.goto_first_child() {
7697 loop {
7698 if cursor.field_name().is_none()
7699 && cursor.node().is_named()
7700 && !cursor.node().is_extra()
7701 {
7702 result.push(cursor.node());
7703 }
7704 if !cursor.goto_next_sibling() {
7705 break;
7706 }
7707 }
7708 }
7709 result
7710 };
7711 let mut items = ::std::vec::Vec::new();
7712 for child in non_field_children {
7713 items.push(
7714 <UnionItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7715 );
7716 }
7717 items
7718 },
7719 })
7720 }
7721}
7722impl ::treesitter_types::Spanned for UnionItem<'_> {
7723 fn span(&self) -> ::treesitter_types::Span {
7724 self.span
7725 }
7726}
7727#[derive(Debug, Clone)]
7728pub struct UnitExpression<'tree> {
7729 pub span: ::treesitter_types::Span,
7730 text: &'tree str,
7731}
7732impl<'tree> ::treesitter_types::FromNode<'tree> for UnitExpression<'tree> {
7733 fn from_node(
7734 node: ::tree_sitter::Node<'tree>,
7735 src: &'tree [u8],
7736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7737 debug_assert_eq!(node.kind(), "unit_expression");
7738 Ok(Self {
7739 span: ::treesitter_types::Span::from(node),
7740 text: node.utf8_text(src)?,
7741 })
7742 }
7743}
7744impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitExpression<'tree> {
7745 fn text(&self) -> &'tree str {
7746 self.text
7747 }
7748}
7749impl ::treesitter_types::Spanned for UnitExpression<'_> {
7750 fn span(&self) -> ::treesitter_types::Span {
7751 self.span
7752 }
7753}
7754#[derive(Debug, Clone)]
7755pub struct UnitType<'tree> {
7756 pub span: ::treesitter_types::Span,
7757 text: &'tree str,
7758}
7759impl<'tree> ::treesitter_types::FromNode<'tree> for UnitType<'tree> {
7760 fn from_node(
7761 node: ::tree_sitter::Node<'tree>,
7762 src: &'tree [u8],
7763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7764 debug_assert_eq!(node.kind(), "unit_type");
7765 Ok(Self {
7766 span: ::treesitter_types::Span::from(node),
7767 text: node.utf8_text(src)?,
7768 })
7769 }
7770}
7771impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitType<'tree> {
7772 fn text(&self) -> &'tree str {
7773 self.text
7774 }
7775}
7776impl ::treesitter_types::Spanned for UnitType<'_> {
7777 fn span(&self) -> ::treesitter_types::Span {
7778 self.span
7779 }
7780}
7781#[derive(Debug, Clone)]
7782pub struct UnsafeBlock<'tree> {
7783 pub span: ::treesitter_types::Span,
7784 pub children: Block<'tree>,
7785}
7786impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeBlock<'tree> {
7787 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7788 fn from_node(
7789 node: ::tree_sitter::Node<'tree>,
7790 src: &'tree [u8],
7791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7792 debug_assert_eq!(node.kind(), "unsafe_block");
7793 Ok(Self {
7794 span: ::treesitter_types::Span::from(node),
7795 children: {
7796 #[allow(clippy::suspicious_else_formatting)]
7797 let non_field_children = {
7798 let mut cursor = node.walk();
7799 let mut result = ::std::vec::Vec::new();
7800 if cursor.goto_first_child() {
7801 loop {
7802 if cursor.field_name().is_none()
7803 && cursor.node().is_named()
7804 && !cursor.node().is_extra()
7805 {
7806 result.push(cursor.node());
7807 }
7808 if !cursor.goto_next_sibling() {
7809 break;
7810 }
7811 }
7812 }
7813 result
7814 };
7815 let child = if let Some(&c) = non_field_children.first() {
7816 c
7817 } else {
7818 let mut fallback_cursor = node.walk();
7819 let mut fallback_child = None;
7820 if fallback_cursor.goto_first_child() {
7821 loop {
7822 if fallback_cursor.field_name().is_none()
7823 && !fallback_cursor.node().is_extra()
7824 {
7825 fallback_child = Some(fallback_cursor.node());
7826 break;
7827 }
7828 if !fallback_cursor.goto_next_sibling() {
7829 break;
7830 }
7831 }
7832 }
7833 fallback_child.ok_or_else(|| {
7834 ::treesitter_types::ParseError::missing_field("children", node)
7835 })?
7836 };
7837 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
7838 },
7839 })
7840 }
7841}
7842impl ::treesitter_types::Spanned for UnsafeBlock<'_> {
7843 fn span(&self) -> ::treesitter_types::Span {
7844 self.span
7845 }
7846}
7847#[derive(Debug, Clone)]
7848pub struct UseAsClause<'tree> {
7849 pub span: ::treesitter_types::Span,
7850 pub alias: Identifier<'tree>,
7851 pub path: UseAsClausePath<'tree>,
7852}
7853impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClause<'tree> {
7854 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7855 fn from_node(
7856 node: ::tree_sitter::Node<'tree>,
7857 src: &'tree [u8],
7858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7859 debug_assert_eq!(node.kind(), "use_as_clause");
7860 Ok(Self {
7861 span: ::treesitter_types::Span::from(node),
7862 alias: {
7863 let child = node
7864 .child_by_field_name("alias")
7865 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
7866 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7867 },
7868 path: {
7869 let child = node
7870 .child_by_field_name("path")
7871 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
7872 <UseAsClausePath as ::treesitter_types::FromNode>::from_node(child, src)?
7873 },
7874 })
7875 }
7876}
7877impl ::treesitter_types::Spanned for UseAsClause<'_> {
7878 fn span(&self) -> ::treesitter_types::Span {
7879 self.span
7880 }
7881}
7882#[derive(Debug, Clone)]
7883pub struct UseBounds<'tree> {
7884 pub span: ::treesitter_types::Span,
7885 pub children: ::std::vec::Vec<UseBoundsChildren<'tree>>,
7886}
7887impl<'tree> ::treesitter_types::FromNode<'tree> for UseBounds<'tree> {
7888 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7889 fn from_node(
7890 node: ::tree_sitter::Node<'tree>,
7891 src: &'tree [u8],
7892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7893 debug_assert_eq!(node.kind(), "use_bounds");
7894 Ok(Self {
7895 span: ::treesitter_types::Span::from(node),
7896 children: {
7897 #[allow(clippy::suspicious_else_formatting)]
7898 let non_field_children = {
7899 let mut cursor = node.walk();
7900 let mut result = ::std::vec::Vec::new();
7901 if cursor.goto_first_child() {
7902 loop {
7903 if cursor.field_name().is_none()
7904 && cursor.node().is_named()
7905 && !cursor.node().is_extra()
7906 {
7907 result.push(cursor.node());
7908 }
7909 if !cursor.goto_next_sibling() {
7910 break;
7911 }
7912 }
7913 }
7914 result
7915 };
7916 let mut items = ::std::vec::Vec::new();
7917 for child in non_field_children {
7918 items.push(
7919 <UseBoundsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7920 );
7921 }
7922 items
7923 },
7924 })
7925 }
7926}
7927impl ::treesitter_types::Spanned for UseBounds<'_> {
7928 fn span(&self) -> ::treesitter_types::Span {
7929 self.span
7930 }
7931}
7932#[derive(Debug, Clone)]
7933pub struct UseDeclaration<'tree> {
7934 pub span: ::treesitter_types::Span,
7935 pub argument: UseDeclarationArgument<'tree>,
7936 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
7937}
7938impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclaration<'tree> {
7939 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7940 fn from_node(
7941 node: ::tree_sitter::Node<'tree>,
7942 src: &'tree [u8],
7943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7944 debug_assert_eq!(node.kind(), "use_declaration");
7945 Ok(Self {
7946 span: ::treesitter_types::Span::from(node),
7947 argument: {
7948 let child = node.child_by_field_name("argument").ok_or_else(|| {
7949 ::treesitter_types::ParseError::missing_field("argument", node)
7950 })?;
7951 <UseDeclarationArgument as ::treesitter_types::FromNode>::from_node(child, src)?
7952 },
7953 children: {
7954 #[allow(clippy::suspicious_else_formatting)]
7955 let non_field_children = {
7956 let mut cursor = node.walk();
7957 let mut result = ::std::vec::Vec::new();
7958 if cursor.goto_first_child() {
7959 loop {
7960 if cursor.field_name().is_none()
7961 && cursor.node().is_named()
7962 && !cursor.node().is_extra()
7963 {
7964 result.push(cursor.node());
7965 }
7966 if !cursor.goto_next_sibling() {
7967 break;
7968 }
7969 }
7970 }
7971 result
7972 };
7973 match non_field_children.first() {
7974 Some(&child) => Some(
7975 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
7976 child, src,
7977 )?,
7978 ),
7979 None => None,
7980 }
7981 },
7982 })
7983 }
7984}
7985impl ::treesitter_types::Spanned for UseDeclaration<'_> {
7986 fn span(&self) -> ::treesitter_types::Span {
7987 self.span
7988 }
7989}
7990#[derive(Debug, Clone)]
7991pub struct UseList<'tree> {
7992 pub span: ::treesitter_types::Span,
7993 pub children: ::std::vec::Vec<UseListChildren<'tree>>,
7994}
7995impl<'tree> ::treesitter_types::FromNode<'tree> for UseList<'tree> {
7996 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7997 fn from_node(
7998 node: ::tree_sitter::Node<'tree>,
7999 src: &'tree [u8],
8000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8001 debug_assert_eq!(node.kind(), "use_list");
8002 Ok(Self {
8003 span: ::treesitter_types::Span::from(node),
8004 children: {
8005 #[allow(clippy::suspicious_else_formatting)]
8006 let non_field_children = {
8007 let mut cursor = node.walk();
8008 let mut result = ::std::vec::Vec::new();
8009 if cursor.goto_first_child() {
8010 loop {
8011 if cursor.field_name().is_none()
8012 && cursor.node().is_named()
8013 && !cursor.node().is_extra()
8014 {
8015 result.push(cursor.node());
8016 }
8017 if !cursor.goto_next_sibling() {
8018 break;
8019 }
8020 }
8021 }
8022 result
8023 };
8024 let mut items = ::std::vec::Vec::new();
8025 for child in non_field_children {
8026 items.push(
8027 <UseListChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8028 );
8029 }
8030 items
8031 },
8032 })
8033 }
8034}
8035impl ::treesitter_types::Spanned for UseList<'_> {
8036 fn span(&self) -> ::treesitter_types::Span {
8037 self.span
8038 }
8039}
8040#[derive(Debug, Clone)]
8041pub struct UseWildcard<'tree> {
8042 pub span: ::treesitter_types::Span,
8043 pub children: ::core::option::Option<UseWildcardChildren<'tree>>,
8044}
8045impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcard<'tree> {
8046 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8047 fn from_node(
8048 node: ::tree_sitter::Node<'tree>,
8049 src: &'tree [u8],
8050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8051 debug_assert_eq!(node.kind(), "use_wildcard");
8052 Ok(Self {
8053 span: ::treesitter_types::Span::from(node),
8054 children: {
8055 #[allow(clippy::suspicious_else_formatting)]
8056 let non_field_children = {
8057 let mut cursor = node.walk();
8058 let mut result = ::std::vec::Vec::new();
8059 if cursor.goto_first_child() {
8060 loop {
8061 if cursor.field_name().is_none()
8062 && cursor.node().is_named()
8063 && !cursor.node().is_extra()
8064 {
8065 result.push(cursor.node());
8066 }
8067 if !cursor.goto_next_sibling() {
8068 break;
8069 }
8070 }
8071 }
8072 result
8073 };
8074 match non_field_children.first() {
8075 Some(&child) => Some(
8076 <UseWildcardChildren as ::treesitter_types::FromNode>::from_node(
8077 child, src,
8078 )?,
8079 ),
8080 None => None,
8081 }
8082 },
8083 })
8084 }
8085}
8086impl ::treesitter_types::Spanned for UseWildcard<'_> {
8087 fn span(&self) -> ::treesitter_types::Span {
8088 self.span
8089 }
8090}
8091#[derive(Debug, Clone)]
8092pub struct VariadicParameter<'tree> {
8093 pub span: ::treesitter_types::Span,
8094 pub pattern: ::core::option::Option<Pattern<'tree>>,
8095 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
8096}
8097impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
8098 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8099 fn from_node(
8100 node: ::tree_sitter::Node<'tree>,
8101 src: &'tree [u8],
8102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8103 debug_assert_eq!(node.kind(), "variadic_parameter");
8104 Ok(Self {
8105 span: ::treesitter_types::Span::from(node),
8106 pattern: match node.child_by_field_name("pattern") {
8107 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
8108 child, src,
8109 )?),
8110 None => None,
8111 },
8112 children: {
8113 #[allow(clippy::suspicious_else_formatting)]
8114 let non_field_children = {
8115 let mut cursor = node.walk();
8116 let mut result = ::std::vec::Vec::new();
8117 if cursor.goto_first_child() {
8118 loop {
8119 if cursor.field_name().is_none()
8120 && cursor.node().is_named()
8121 && !cursor.node().is_extra()
8122 {
8123 result.push(cursor.node());
8124 }
8125 if !cursor.goto_next_sibling() {
8126 break;
8127 }
8128 }
8129 }
8130 result
8131 };
8132 match non_field_children.first() {
8133 Some(&child) => Some(
8134 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
8135 ),
8136 None => None,
8137 }
8138 },
8139 })
8140 }
8141}
8142impl ::treesitter_types::Spanned for VariadicParameter<'_> {
8143 fn span(&self) -> ::treesitter_types::Span {
8144 self.span
8145 }
8146}
8147#[derive(Debug, Clone)]
8148pub struct VisibilityModifier<'tree> {
8149 pub span: ::treesitter_types::Span,
8150 pub children: ::core::option::Option<VisibilityModifierChildren<'tree>>,
8151}
8152impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifier<'tree> {
8153 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8154 fn from_node(
8155 node: ::tree_sitter::Node<'tree>,
8156 src: &'tree [u8],
8157 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8158 debug_assert_eq!(node.kind(), "visibility_modifier");
8159 Ok(Self {
8160 span: ::treesitter_types::Span::from(node),
8161 children: {
8162 #[allow(clippy::suspicious_else_formatting)]
8163 let non_field_children = {
8164 let mut cursor = node.walk();
8165 let mut result = ::std::vec::Vec::new();
8166 if cursor.goto_first_child() {
8167 loop {
8168 if cursor.field_name().is_none()
8169 && cursor.node().is_named()
8170 && !cursor.node().is_extra()
8171 {
8172 result.push(cursor.node());
8173 }
8174 if !cursor.goto_next_sibling() {
8175 break;
8176 }
8177 }
8178 }
8179 result
8180 };
8181 match non_field_children.first() {
8182 Some(&child) => Some(
8183 <VisibilityModifierChildren as ::treesitter_types::FromNode>::from_node(
8184 child, src,
8185 )?,
8186 ),
8187 None => None,
8188 }
8189 },
8190 })
8191 }
8192}
8193impl ::treesitter_types::Spanned for VisibilityModifier<'_> {
8194 fn span(&self) -> ::treesitter_types::Span {
8195 self.span
8196 }
8197}
8198#[derive(Debug, Clone)]
8199pub struct WhereClause<'tree> {
8200 pub span: ::treesitter_types::Span,
8201 pub children: ::std::vec::Vec<WherePredicate<'tree>>,
8202}
8203impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
8204 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8205 fn from_node(
8206 node: ::tree_sitter::Node<'tree>,
8207 src: &'tree [u8],
8208 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8209 debug_assert_eq!(node.kind(), "where_clause");
8210 Ok(Self {
8211 span: ::treesitter_types::Span::from(node),
8212 children: {
8213 #[allow(clippy::suspicious_else_formatting)]
8214 let non_field_children = {
8215 let mut cursor = node.walk();
8216 let mut result = ::std::vec::Vec::new();
8217 if cursor.goto_first_child() {
8218 loop {
8219 if cursor.field_name().is_none()
8220 && cursor.node().is_named()
8221 && !cursor.node().is_extra()
8222 {
8223 result.push(cursor.node());
8224 }
8225 if !cursor.goto_next_sibling() {
8226 break;
8227 }
8228 }
8229 }
8230 result
8231 };
8232 let mut items = ::std::vec::Vec::new();
8233 for child in non_field_children {
8234 items.push(<WherePredicate as ::treesitter_types::FromNode>::from_node(
8235 child, src,
8236 )?);
8237 }
8238 items
8239 },
8240 })
8241 }
8242}
8243impl ::treesitter_types::Spanned for WhereClause<'_> {
8244 fn span(&self) -> ::treesitter_types::Span {
8245 self.span
8246 }
8247}
8248#[derive(Debug, Clone)]
8249pub struct WherePredicate<'tree> {
8250 pub span: ::treesitter_types::Span,
8251 pub bounds: TraitBounds<'tree>,
8252 pub left: WherePredicateLeft<'tree>,
8253}
8254impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicate<'tree> {
8255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8256 fn from_node(
8257 node: ::tree_sitter::Node<'tree>,
8258 src: &'tree [u8],
8259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8260 debug_assert_eq!(node.kind(), "where_predicate");
8261 Ok(Self {
8262 span: ::treesitter_types::Span::from(node),
8263 bounds: {
8264 let child = node
8265 .child_by_field_name("bounds")
8266 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bounds", node))?;
8267 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)?
8268 },
8269 left: {
8270 let child = node
8271 .child_by_field_name("left")
8272 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
8273 <WherePredicateLeft as ::treesitter_types::FromNode>::from_node(child, src)?
8274 },
8275 })
8276 }
8277}
8278impl ::treesitter_types::Spanned for WherePredicate<'_> {
8279 fn span(&self) -> ::treesitter_types::Span {
8280 self.span
8281 }
8282}
8283#[derive(Debug, Clone)]
8284pub struct WhileExpression<'tree> {
8285 pub span: ::treesitter_types::Span,
8286 pub body: Block<'tree>,
8287 pub condition: WhileExpressionCondition<'tree>,
8288 pub children: ::core::option::Option<Label<'tree>>,
8289}
8290impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpression<'tree> {
8291 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8292 fn from_node(
8293 node: ::tree_sitter::Node<'tree>,
8294 src: &'tree [u8],
8295 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8296 debug_assert_eq!(node.kind(), "while_expression");
8297 Ok(Self {
8298 span: ::treesitter_types::Span::from(node),
8299 body: {
8300 let child = node
8301 .child_by_field_name("body")
8302 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8303 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
8304 },
8305 condition: {
8306 let child = node.child_by_field_name("condition").ok_or_else(|| {
8307 ::treesitter_types::ParseError::missing_field("condition", node)
8308 })?;
8309 <WhileExpressionCondition as ::treesitter_types::FromNode>::from_node(child, src)?
8310 },
8311 children: {
8312 #[allow(clippy::suspicious_else_formatting)]
8313 let non_field_children = {
8314 let mut cursor = node.walk();
8315 let mut result = ::std::vec::Vec::new();
8316 if cursor.goto_first_child() {
8317 loop {
8318 if cursor.field_name().is_none()
8319 && cursor.node().is_named()
8320 && !cursor.node().is_extra()
8321 {
8322 result.push(cursor.node());
8323 }
8324 if !cursor.goto_next_sibling() {
8325 break;
8326 }
8327 }
8328 }
8329 result
8330 };
8331 match non_field_children.first() {
8332 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
8333 child, src,
8334 )?),
8335 None => None,
8336 }
8337 },
8338 })
8339 }
8340}
8341impl ::treesitter_types::Spanned for WhileExpression<'_> {
8342 fn span(&self) -> ::treesitter_types::Span {
8343 self.span
8344 }
8345}
8346#[derive(Debug, Clone)]
8347pub struct YieldExpression<'tree> {
8348 pub span: ::treesitter_types::Span,
8349 pub children: ::core::option::Option<Expression<'tree>>,
8350}
8351impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
8352 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8353 fn from_node(
8354 node: ::tree_sitter::Node<'tree>,
8355 src: &'tree [u8],
8356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8357 debug_assert_eq!(node.kind(), "yield_expression");
8358 Ok(Self {
8359 span: ::treesitter_types::Span::from(node),
8360 children: {
8361 #[allow(clippy::suspicious_else_formatting)]
8362 let non_field_children = {
8363 let mut cursor = node.walk();
8364 let mut result = ::std::vec::Vec::new();
8365 if cursor.goto_first_child() {
8366 loop {
8367 if cursor.field_name().is_none()
8368 && cursor.node().is_named()
8369 && !cursor.node().is_extra()
8370 {
8371 result.push(cursor.node());
8372 }
8373 if !cursor.goto_next_sibling() {
8374 break;
8375 }
8376 }
8377 }
8378 result
8379 };
8380 match non_field_children.first() {
8381 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
8382 child, src,
8383 )?),
8384 None => None,
8385 }
8386 },
8387 })
8388 }
8389}
8390impl ::treesitter_types::Spanned for YieldExpression<'_> {
8391 fn span(&self) -> ::treesitter_types::Span {
8392 self.span
8393 }
8394}
8395#[derive(Debug, Clone)]
8396pub struct CharLiteral<'tree> {
8397 pub span: ::treesitter_types::Span,
8398 text: &'tree str,
8399}
8400impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
8401 fn from_node(
8402 node: ::tree_sitter::Node<'tree>,
8403 src: &'tree [u8],
8404 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8405 debug_assert_eq!(node.kind(), "char_literal");
8406 Ok(Self {
8407 span: ::treesitter_types::Span::from(node),
8408 text: node.utf8_text(src)?,
8409 })
8410 }
8411}
8412impl<'tree> ::treesitter_types::LeafNode<'tree> for CharLiteral<'tree> {
8413 fn text(&self) -> &'tree str {
8414 self.text
8415 }
8416}
8417impl ::treesitter_types::Spanned for CharLiteral<'_> {
8418 fn span(&self) -> ::treesitter_types::Span {
8419 self.span
8420 }
8421}
8422#[derive(Debug, Clone)]
8423pub struct Crate<'tree> {
8424 pub span: ::treesitter_types::Span,
8425 text: &'tree str,
8426}
8427impl<'tree> ::treesitter_types::FromNode<'tree> for Crate<'tree> {
8428 fn from_node(
8429 node: ::tree_sitter::Node<'tree>,
8430 src: &'tree [u8],
8431 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8432 debug_assert_eq!(node.kind(), "crate");
8433 Ok(Self {
8434 span: ::treesitter_types::Span::from(node),
8435 text: node.utf8_text(src)?,
8436 })
8437 }
8438}
8439impl<'tree> ::treesitter_types::LeafNode<'tree> for Crate<'tree> {
8440 fn text(&self) -> &'tree str {
8441 self.text
8442 }
8443}
8444impl ::treesitter_types::Spanned for Crate<'_> {
8445 fn span(&self) -> ::treesitter_types::Span {
8446 self.span
8447 }
8448}
8449#[derive(Debug, Clone)]
8450pub struct DocComment<'tree> {
8451 pub span: ::treesitter_types::Span,
8452 text: &'tree str,
8453}
8454impl<'tree> ::treesitter_types::FromNode<'tree> for DocComment<'tree> {
8455 fn from_node(
8456 node: ::tree_sitter::Node<'tree>,
8457 src: &'tree [u8],
8458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8459 debug_assert_eq!(node.kind(), "doc_comment");
8460 Ok(Self {
8461 span: ::treesitter_types::Span::from(node),
8462 text: node.utf8_text(src)?,
8463 })
8464 }
8465}
8466impl<'tree> ::treesitter_types::LeafNode<'tree> for DocComment<'tree> {
8467 fn text(&self) -> &'tree str {
8468 self.text
8469 }
8470}
8471impl ::treesitter_types::Spanned for DocComment<'_> {
8472 fn span(&self) -> ::treesitter_types::Span {
8473 self.span
8474 }
8475}
8476#[derive(Debug, Clone)]
8477pub struct EscapeSequence<'tree> {
8478 pub span: ::treesitter_types::Span,
8479 text: &'tree str,
8480}
8481impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
8482 fn from_node(
8483 node: ::tree_sitter::Node<'tree>,
8484 src: &'tree [u8],
8485 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8486 debug_assert_eq!(node.kind(), "escape_sequence");
8487 Ok(Self {
8488 span: ::treesitter_types::Span::from(node),
8489 text: node.utf8_text(src)?,
8490 })
8491 }
8492}
8493impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
8494 fn text(&self) -> &'tree str {
8495 self.text
8496 }
8497}
8498impl ::treesitter_types::Spanned for EscapeSequence<'_> {
8499 fn span(&self) -> ::treesitter_types::Span {
8500 self.span
8501 }
8502}
8503#[derive(Debug, Clone)]
8504pub struct FieldIdentifier<'tree> {
8505 pub span: ::treesitter_types::Span,
8506 text: &'tree str,
8507}
8508impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
8509 fn from_node(
8510 node: ::tree_sitter::Node<'tree>,
8511 src: &'tree [u8],
8512 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8513 debug_assert_eq!(node.kind(), "field_identifier");
8514 Ok(Self {
8515 span: ::treesitter_types::Span::from(node),
8516 text: node.utf8_text(src)?,
8517 })
8518 }
8519}
8520impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
8521 fn text(&self) -> &'tree str {
8522 self.text
8523 }
8524}
8525impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
8526 fn span(&self) -> ::treesitter_types::Span {
8527 self.span
8528 }
8529}
8530#[derive(Debug, Clone)]
8531pub struct FloatLiteral<'tree> {
8532 pub span: ::treesitter_types::Span,
8533 text: &'tree str,
8534}
8535impl<'tree> ::treesitter_types::FromNode<'tree> for FloatLiteral<'tree> {
8536 fn from_node(
8537 node: ::tree_sitter::Node<'tree>,
8538 src: &'tree [u8],
8539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8540 debug_assert_eq!(node.kind(), "float_literal");
8541 Ok(Self {
8542 span: ::treesitter_types::Span::from(node),
8543 text: node.utf8_text(src)?,
8544 })
8545 }
8546}
8547impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatLiteral<'tree> {
8548 fn text(&self) -> &'tree str {
8549 self.text
8550 }
8551}
8552impl ::treesitter_types::Spanned for FloatLiteral<'_> {
8553 fn span(&self) -> ::treesitter_types::Span {
8554 self.span
8555 }
8556}
8557#[derive(Debug, Clone)]
8558pub struct Identifier<'tree> {
8559 pub span: ::treesitter_types::Span,
8560 text: &'tree str,
8561}
8562impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
8563 fn from_node(
8564 node: ::tree_sitter::Node<'tree>,
8565 src: &'tree [u8],
8566 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8567 debug_assert_eq!(node.kind(), "identifier");
8568 Ok(Self {
8569 span: ::treesitter_types::Span::from(node),
8570 text: node.utf8_text(src)?,
8571 })
8572 }
8573}
8574impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
8575 fn text(&self) -> &'tree str {
8576 self.text
8577 }
8578}
8579impl ::treesitter_types::Spanned for Identifier<'_> {
8580 fn span(&self) -> ::treesitter_types::Span {
8581 self.span
8582 }
8583}
8584#[derive(Debug, Clone)]
8585pub struct IntegerLiteral<'tree> {
8586 pub span: ::treesitter_types::Span,
8587 text: &'tree str,
8588}
8589impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
8590 fn from_node(
8591 node: ::tree_sitter::Node<'tree>,
8592 src: &'tree [u8],
8593 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8594 debug_assert_eq!(node.kind(), "integer_literal");
8595 Ok(Self {
8596 span: ::treesitter_types::Span::from(node),
8597 text: node.utf8_text(src)?,
8598 })
8599 }
8600}
8601impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
8602 fn text(&self) -> &'tree str {
8603 self.text
8604 }
8605}
8606impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
8607 fn span(&self) -> ::treesitter_types::Span {
8608 self.span
8609 }
8610}
8611#[derive(Debug, Clone)]
8612pub struct Metavariable<'tree> {
8613 pub span: ::treesitter_types::Span,
8614 text: &'tree str,
8615}
8616impl<'tree> ::treesitter_types::FromNode<'tree> for Metavariable<'tree> {
8617 fn from_node(
8618 node: ::tree_sitter::Node<'tree>,
8619 src: &'tree [u8],
8620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8621 debug_assert_eq!(node.kind(), "metavariable");
8622 Ok(Self {
8623 span: ::treesitter_types::Span::from(node),
8624 text: node.utf8_text(src)?,
8625 })
8626 }
8627}
8628impl<'tree> ::treesitter_types::LeafNode<'tree> for Metavariable<'tree> {
8629 fn text(&self) -> &'tree str {
8630 self.text
8631 }
8632}
8633impl ::treesitter_types::Spanned for Metavariable<'_> {
8634 fn span(&self) -> ::treesitter_types::Span {
8635 self.span
8636 }
8637}
8638#[derive(Debug, Clone)]
8639pub struct MutableSpecifier<'tree> {
8640 pub span: ::treesitter_types::Span,
8641 text: &'tree str,
8642}
8643impl<'tree> ::treesitter_types::FromNode<'tree> for MutableSpecifier<'tree> {
8644 fn from_node(
8645 node: ::tree_sitter::Node<'tree>,
8646 src: &'tree [u8],
8647 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8648 debug_assert_eq!(node.kind(), "mutable_specifier");
8649 Ok(Self {
8650 span: ::treesitter_types::Span::from(node),
8651 text: node.utf8_text(src)?,
8652 })
8653 }
8654}
8655impl<'tree> ::treesitter_types::LeafNode<'tree> for MutableSpecifier<'tree> {
8656 fn text(&self) -> &'tree str {
8657 self.text
8658 }
8659}
8660impl ::treesitter_types::Spanned for MutableSpecifier<'_> {
8661 fn span(&self) -> ::treesitter_types::Span {
8662 self.span
8663 }
8664}
8665#[derive(Debug, Clone)]
8666pub struct PrimitiveType<'tree> {
8667 pub span: ::treesitter_types::Span,
8668 text: &'tree str,
8669}
8670impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
8671 fn from_node(
8672 node: ::tree_sitter::Node<'tree>,
8673 src: &'tree [u8],
8674 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8675 debug_assert_eq!(node.kind(), "primitive_type");
8676 Ok(Self {
8677 span: ::treesitter_types::Span::from(node),
8678 text: node.utf8_text(src)?,
8679 })
8680 }
8681}
8682impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
8683 fn text(&self) -> &'tree str {
8684 self.text
8685 }
8686}
8687impl ::treesitter_types::Spanned for PrimitiveType<'_> {
8688 fn span(&self) -> ::treesitter_types::Span {
8689 self.span
8690 }
8691}
8692#[derive(Debug, Clone)]
8693pub struct SelfType<'tree> {
8694 pub span: ::treesitter_types::Span,
8695 text: &'tree str,
8696}
8697impl<'tree> ::treesitter_types::FromNode<'tree> for SelfType<'tree> {
8698 fn from_node(
8699 node: ::tree_sitter::Node<'tree>,
8700 src: &'tree [u8],
8701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8702 debug_assert_eq!(node.kind(), "self");
8703 Ok(Self {
8704 span: ::treesitter_types::Span::from(node),
8705 text: node.utf8_text(src)?,
8706 })
8707 }
8708}
8709impl<'tree> ::treesitter_types::LeafNode<'tree> for SelfType<'tree> {
8710 fn text(&self) -> &'tree str {
8711 self.text
8712 }
8713}
8714impl ::treesitter_types::Spanned for SelfType<'_> {
8715 fn span(&self) -> ::treesitter_types::Span {
8716 self.span
8717 }
8718}
8719#[derive(Debug, Clone)]
8720pub struct Shebang<'tree> {
8721 pub span: ::treesitter_types::Span,
8722 text: &'tree str,
8723}
8724impl<'tree> ::treesitter_types::FromNode<'tree> for Shebang<'tree> {
8725 fn from_node(
8726 node: ::tree_sitter::Node<'tree>,
8727 src: &'tree [u8],
8728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8729 debug_assert_eq!(node.kind(), "shebang");
8730 Ok(Self {
8731 span: ::treesitter_types::Span::from(node),
8732 text: node.utf8_text(src)?,
8733 })
8734 }
8735}
8736impl<'tree> ::treesitter_types::LeafNode<'tree> for Shebang<'tree> {
8737 fn text(&self) -> &'tree str {
8738 self.text
8739 }
8740}
8741impl ::treesitter_types::Spanned for Shebang<'_> {
8742 fn span(&self) -> ::treesitter_types::Span {
8743 self.span
8744 }
8745}
8746#[derive(Debug, Clone)]
8747pub struct ShorthandFieldIdentifier<'tree> {
8748 pub span: ::treesitter_types::Span,
8749 text: &'tree str,
8750}
8751impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldIdentifier<'tree> {
8752 fn from_node(
8753 node: ::tree_sitter::Node<'tree>,
8754 src: &'tree [u8],
8755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8756 debug_assert_eq!(node.kind(), "shorthand_field_identifier");
8757 Ok(Self {
8758 span: ::treesitter_types::Span::from(node),
8759 text: node.utf8_text(src)?,
8760 })
8761 }
8762}
8763impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandFieldIdentifier<'tree> {
8764 fn text(&self) -> &'tree str {
8765 self.text
8766 }
8767}
8768impl ::treesitter_types::Spanned for ShorthandFieldIdentifier<'_> {
8769 fn span(&self) -> ::treesitter_types::Span {
8770 self.span
8771 }
8772}
8773#[derive(Debug, Clone)]
8774pub struct StringContent<'tree> {
8775 pub span: ::treesitter_types::Span,
8776 text: &'tree str,
8777}
8778impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
8779 fn from_node(
8780 node: ::tree_sitter::Node<'tree>,
8781 src: &'tree [u8],
8782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8783 debug_assert_eq!(node.kind(), "string_content");
8784 Ok(Self {
8785 span: ::treesitter_types::Span::from(node),
8786 text: node.utf8_text(src)?,
8787 })
8788 }
8789}
8790impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
8791 fn text(&self) -> &'tree str {
8792 self.text
8793 }
8794}
8795impl ::treesitter_types::Spanned for StringContent<'_> {
8796 fn span(&self) -> ::treesitter_types::Span {
8797 self.span
8798 }
8799}
8800#[derive(Debug, Clone)]
8801pub struct Super<'tree> {
8802 pub span: ::treesitter_types::Span,
8803 text: &'tree str,
8804}
8805impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
8806 fn from_node(
8807 node: ::tree_sitter::Node<'tree>,
8808 src: &'tree [u8],
8809 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8810 debug_assert_eq!(node.kind(), "super");
8811 Ok(Self {
8812 span: ::treesitter_types::Span::from(node),
8813 text: node.utf8_text(src)?,
8814 })
8815 }
8816}
8817impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
8818 fn text(&self) -> &'tree str {
8819 self.text
8820 }
8821}
8822impl ::treesitter_types::Spanned for Super<'_> {
8823 fn span(&self) -> ::treesitter_types::Span {
8824 self.span
8825 }
8826}
8827#[derive(Debug, Clone)]
8828pub struct TypeIdentifier<'tree> {
8829 pub span: ::treesitter_types::Span,
8830 text: &'tree str,
8831}
8832impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
8833 fn from_node(
8834 node: ::tree_sitter::Node<'tree>,
8835 src: &'tree [u8],
8836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8837 debug_assert_eq!(node.kind(), "type_identifier");
8838 Ok(Self {
8839 span: ::treesitter_types::Span::from(node),
8840 text: node.utf8_text(src)?,
8841 })
8842 }
8843}
8844impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
8845 fn text(&self) -> &'tree str {
8846 self.text
8847 }
8848}
8849impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
8850 fn span(&self) -> ::treesitter_types::Span {
8851 self.span
8852 }
8853}
8854#[derive(Debug, Clone)]
8855pub enum AbstractTypeTrait<'tree> {
8856 BoundedType(::std::boxed::Box<BoundedType<'tree>>),
8857 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
8858 GenericType(::std::boxed::Box<GenericType<'tree>>),
8859 RemovedTraitBound(::std::boxed::Box<RemovedTraitBound<'tree>>),
8860 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
8861 TupleType(::std::boxed::Box<TupleType<'tree>>),
8862 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
8863}
8864impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractTypeTrait<'tree> {
8865 #[allow(clippy::collapsible_else_if)]
8866 fn from_node(
8867 node: ::tree_sitter::Node<'tree>,
8868 src: &'tree [u8],
8869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8870 match node.kind() {
8871 "bounded_type" => Ok(Self::BoundedType(::std::boxed::Box::new(
8872 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)?,
8873 ))),
8874 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
8875 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
8876 ))),
8877 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
8878 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
8879 ))),
8880 "removed_trait_bound" => Ok(Self::RemovedTraitBound(::std::boxed::Box::new(
8881 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
8882 ))),
8883 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
8884 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8885 ))),
8886 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
8887 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
8888 ))),
8889 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
8890 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8891 ))),
8892 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8893 }
8894 }
8895}
8896impl ::treesitter_types::Spanned for AbstractTypeTrait<'_> {
8897 fn span(&self) -> ::treesitter_types::Span {
8898 match self {
8899 Self::BoundedType(inner) => inner.span(),
8900 Self::FunctionType(inner) => inner.span(),
8901 Self::GenericType(inner) => inner.span(),
8902 Self::RemovedTraitBound(inner) => inner.span(),
8903 Self::ScopedTypeIdentifier(inner) => inner.span(),
8904 Self::TupleType(inner) => inner.span(),
8905 Self::TypeIdentifier(inner) => inner.span(),
8906 }
8907 }
8908}
8909#[derive(Debug, Clone)]
8910pub enum ArgumentsChildren<'tree> {
8911 Expression(::std::boxed::Box<Expression<'tree>>),
8912 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
8913}
8914impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
8915 #[allow(clippy::collapsible_else_if)]
8916 fn from_node(
8917 node: ::tree_sitter::Node<'tree>,
8918 src: &'tree [u8],
8919 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8920 match node.kind() {
8921 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
8922 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
8923 ))),
8924 _other => {
8925 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8926 Ok(Self::Expression(::std::boxed::Box::new(v)))
8927 } else {
8928 Err(::treesitter_types::ParseError::unexpected_kind(
8929 _other, node,
8930 ))
8931 }
8932 }
8933 }
8934 }
8935}
8936impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
8937 fn span(&self) -> ::treesitter_types::Span {
8938 match self {
8939 Self::Expression(inner) => inner.span(),
8940 Self::AttributeItem(inner) => inner.span(),
8941 }
8942 }
8943}
8944#[derive(Debug, Clone)]
8945pub enum ArrayExpressionChildren<'tree> {
8946 Expression(::std::boxed::Box<Expression<'tree>>),
8947 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
8948}
8949impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayExpressionChildren<'tree> {
8950 #[allow(clippy::collapsible_else_if)]
8951 fn from_node(
8952 node: ::tree_sitter::Node<'tree>,
8953 src: &'tree [u8],
8954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8955 match node.kind() {
8956 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
8957 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
8958 ))),
8959 _other => {
8960 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8961 Ok(Self::Expression(::std::boxed::Box::new(v)))
8962 } else {
8963 Err(::treesitter_types::ParseError::unexpected_kind(
8964 _other, node,
8965 ))
8966 }
8967 }
8968 }
8969 }
8970}
8971impl ::treesitter_types::Spanned for ArrayExpressionChildren<'_> {
8972 fn span(&self) -> ::treesitter_types::Span {
8973 match self {
8974 Self::Expression(inner) => inner.span(),
8975 Self::AttributeItem(inner) => inner.span(),
8976 }
8977 }
8978}
8979#[derive(Debug, Clone)]
8980pub enum AttributeChildren<'tree> {
8981 Crate(::std::boxed::Box<Crate<'tree>>),
8982 Identifier(::std::boxed::Box<Identifier<'tree>>),
8983 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
8984 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
8985 SelfType(::std::boxed::Box<SelfType<'tree>>),
8986 Super(::std::boxed::Box<Super<'tree>>),
8987}
8988impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeChildren<'tree> {
8989 #[allow(clippy::collapsible_else_if)]
8990 fn from_node(
8991 node: ::tree_sitter::Node<'tree>,
8992 src: &'tree [u8],
8993 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8994 match node.kind() {
8995 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
8996 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
8997 ))),
8998 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8999 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9000 ))),
9001 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
9002 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
9003 ))),
9004 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9005 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9006 ))),
9007 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
9008 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
9009 ))),
9010 "super" => Ok(Self::Super(::std::boxed::Box::new(
9011 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
9012 ))),
9013 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9014 }
9015 }
9016}
9017impl ::treesitter_types::Spanned for AttributeChildren<'_> {
9018 fn span(&self) -> ::treesitter_types::Span {
9019 match self {
9020 Self::Crate(inner) => inner.span(),
9021 Self::Identifier(inner) => inner.span(),
9022 Self::Metavariable(inner) => inner.span(),
9023 Self::ScopedIdentifier(inner) => inner.span(),
9024 Self::SelfType(inner) => inner.span(),
9025 Self::Super(inner) => inner.span(),
9026 }
9027 }
9028}
9029#[derive(Debug, Clone)]
9030pub enum BinaryExpressionOperator {
9031 NotEq(::treesitter_types::Span),
9032 Percent(::treesitter_types::Span),
9033 Amp(::treesitter_types::Span),
9034 AmpAmp(::treesitter_types::Span),
9035 Star(::treesitter_types::Span),
9036 Plus(::treesitter_types::Span),
9037 Minus(::treesitter_types::Span),
9038 Slash(::treesitter_types::Span),
9039 Lt(::treesitter_types::Span),
9040 Shl(::treesitter_types::Span),
9041 LtEq(::treesitter_types::Span),
9042 EqEq(::treesitter_types::Span),
9043 Gt(::treesitter_types::Span),
9044 GtEq(::treesitter_types::Span),
9045 Shr(::treesitter_types::Span),
9046 Caret(::treesitter_types::Span),
9047 Pipe(::treesitter_types::Span),
9048 PipePipe(::treesitter_types::Span),
9049}
9050impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
9051 #[allow(clippy::collapsible_else_if)]
9052 fn from_node(
9053 node: ::tree_sitter::Node<'tree>,
9054 _src: &'tree [u8],
9055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9056 match node.kind() {
9057 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
9058 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
9059 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
9060 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
9061 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
9062 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9063 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9064 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
9065 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
9066 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
9067 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
9068 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
9069 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
9070 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
9071 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
9072 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
9073 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
9074 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
9075 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9076 }
9077 }
9078}
9079impl ::treesitter_types::Spanned for BinaryExpressionOperator {
9080 fn span(&self) -> ::treesitter_types::Span {
9081 match self {
9082 Self::NotEq(span) => *span,
9083 Self::Percent(span) => *span,
9084 Self::Amp(span) => *span,
9085 Self::AmpAmp(span) => *span,
9086 Self::Star(span) => *span,
9087 Self::Plus(span) => *span,
9088 Self::Minus(span) => *span,
9089 Self::Slash(span) => *span,
9090 Self::Lt(span) => *span,
9091 Self::Shl(span) => *span,
9092 Self::LtEq(span) => *span,
9093 Self::EqEq(span) => *span,
9094 Self::Gt(span) => *span,
9095 Self::GtEq(span) => *span,
9096 Self::Shr(span) => *span,
9097 Self::Caret(span) => *span,
9098 Self::Pipe(span) => *span,
9099 Self::PipePipe(span) => *span,
9100 }
9101 }
9102}
9103#[derive(Debug, Clone)]
9104pub enum BlockChildren<'tree> {
9105 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
9106 Expression(::std::boxed::Box<Expression<'tree>>),
9107 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
9108 Label(::std::boxed::Box<Label<'tree>>),
9109}
9110impl<'tree> ::treesitter_types::FromNode<'tree> for BlockChildren<'tree> {
9111 #[allow(clippy::collapsible_else_if)]
9112 fn from_node(
9113 node: ::tree_sitter::Node<'tree>,
9114 src: &'tree [u8],
9115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9116 match node.kind() {
9117 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
9118 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
9119 ))),
9120 "label" => Ok(Self::Label(::std::boxed::Box::new(
9121 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
9122 ))),
9123 _other => {
9124 if let Ok(v) =
9125 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
9126 {
9127 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
9128 } else {
9129 if let Ok(v) =
9130 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9131 {
9132 Ok(Self::Expression(::std::boxed::Box::new(v)))
9133 } else {
9134 Err(::treesitter_types::ParseError::unexpected_kind(
9135 _other, node,
9136 ))
9137 }
9138 }
9139 }
9140 }
9141 }
9142}
9143impl ::treesitter_types::Spanned for BlockChildren<'_> {
9144 fn span(&self) -> ::treesitter_types::Span {
9145 match self {
9146 Self::DeclarationStatement(inner) => inner.span(),
9147 Self::Expression(inner) => inner.span(),
9148 Self::ExpressionStatement(inner) => inner.span(),
9149 Self::Label(inner) => inner.span(),
9150 }
9151 }
9152}
9153#[derive(Debug, Clone)]
9154pub enum BoundedTypeChildren<'tree> {
9155 Type(::std::boxed::Box<Type<'tree>>),
9156 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
9157 UseBounds(::std::boxed::Box<UseBounds<'tree>>),
9158}
9159impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedTypeChildren<'tree> {
9160 #[allow(clippy::collapsible_else_if)]
9161 fn from_node(
9162 node: ::tree_sitter::Node<'tree>,
9163 src: &'tree [u8],
9164 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9165 match node.kind() {
9166 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
9167 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
9168 ))),
9169 "use_bounds" => Ok(Self::UseBounds(::std::boxed::Box::new(
9170 <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)?,
9171 ))),
9172 _other => {
9173 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9174 Ok(Self::Type(::std::boxed::Box::new(v)))
9175 } else {
9176 Err(::treesitter_types::ParseError::unexpected_kind(
9177 _other, node,
9178 ))
9179 }
9180 }
9181 }
9182 }
9183}
9184impl ::treesitter_types::Spanned for BoundedTypeChildren<'_> {
9185 fn span(&self) -> ::treesitter_types::Span {
9186 match self {
9187 Self::Type(inner) => inner.span(),
9188 Self::Lifetime(inner) => inner.span(),
9189 Self::UseBounds(inner) => inner.span(),
9190 }
9191 }
9192}
9193#[derive(Debug, Clone)]
9194pub enum BracketedTypeChildren<'tree> {
9195 Type(::std::boxed::Box<Type<'tree>>),
9196 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
9197}
9198impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedTypeChildren<'tree> {
9199 #[allow(clippy::collapsible_else_if)]
9200 fn from_node(
9201 node: ::tree_sitter::Node<'tree>,
9202 src: &'tree [u8],
9203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9204 match node.kind() {
9205 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
9206 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)?,
9207 ))),
9208 _other => {
9209 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9210 Ok(Self::Type(::std::boxed::Box::new(v)))
9211 } else {
9212 Err(::treesitter_types::ParseError::unexpected_kind(
9213 _other, node,
9214 ))
9215 }
9216 }
9217 }
9218 }
9219}
9220impl ::treesitter_types::Spanned for BracketedTypeChildren<'_> {
9221 fn span(&self) -> ::treesitter_types::Span {
9222 match self {
9223 Self::Type(inner) => inner.span(),
9224 Self::QualifiedType(inner) => inner.span(),
9225 }
9226 }
9227}
9228#[derive(Debug, Clone)]
9229pub enum BreakExpressionChildren<'tree> {
9230 Expression(::std::boxed::Box<Expression<'tree>>),
9231 Label(::std::boxed::Box<Label<'tree>>),
9232}
9233impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpressionChildren<'tree> {
9234 #[allow(clippy::collapsible_else_if)]
9235 fn from_node(
9236 node: ::tree_sitter::Node<'tree>,
9237 src: &'tree [u8],
9238 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9239 match node.kind() {
9240 "label" => Ok(Self::Label(::std::boxed::Box::new(
9241 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
9242 ))),
9243 _other => {
9244 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9245 Ok(Self::Expression(::std::boxed::Box::new(v)))
9246 } else {
9247 Err(::treesitter_types::ParseError::unexpected_kind(
9248 _other, node,
9249 ))
9250 }
9251 }
9252 }
9253 }
9254}
9255impl ::treesitter_types::Spanned for BreakExpressionChildren<'_> {
9256 fn span(&self) -> ::treesitter_types::Span {
9257 match self {
9258 Self::Expression(inner) => inner.span(),
9259 Self::Label(inner) => inner.span(),
9260 }
9261 }
9262}
9263#[derive(Debug, Clone)]
9264pub enum CallExpressionFunction<'tree> {
9265 Literal(::std::boxed::Box<Literal<'tree>>),
9266 ArrayExpression(::std::boxed::Box<ArrayExpression<'tree>>),
9267 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
9268 AsyncBlock(::std::boxed::Box<AsyncBlock<'tree>>),
9269 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
9270 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
9271 Block(::std::boxed::Box<Block<'tree>>),
9272 BreakExpression(::std::boxed::Box<BreakExpression<'tree>>),
9273 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
9274 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
9275 CompoundAssignmentExpr(::std::boxed::Box<CompoundAssignmentExpr<'tree>>),
9276 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
9277 ContinueExpression(::std::boxed::Box<ContinueExpression<'tree>>),
9278 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
9279 ForExpression(::std::boxed::Box<ForExpression<'tree>>),
9280 GenBlock(::std::boxed::Box<GenBlock<'tree>>),
9281 GenericFunction(::std::boxed::Box<GenericFunction<'tree>>),
9282 Identifier(::std::boxed::Box<Identifier<'tree>>),
9283 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
9284 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
9285 LoopExpression(::std::boxed::Box<LoopExpression<'tree>>),
9286 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
9287 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
9288 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
9289 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
9290 ReferenceExpression(::std::boxed::Box<ReferenceExpression<'tree>>),
9291 ReturnExpression(::std::boxed::Box<ReturnExpression<'tree>>),
9292 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
9293 SelfType(::std::boxed::Box<SelfType<'tree>>),
9294 StructExpression(::std::boxed::Box<StructExpression<'tree>>),
9295 TryBlock(::std::boxed::Box<TryBlock<'tree>>),
9296 TryExpression(::std::boxed::Box<TryExpression<'tree>>),
9297 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
9298 TypeCastExpression(::std::boxed::Box<TypeCastExpression<'tree>>),
9299 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
9300 UnitExpression(::std::boxed::Box<UnitExpression<'tree>>),
9301 UnsafeBlock(::std::boxed::Box<UnsafeBlock<'tree>>),
9302 WhileExpression(::std::boxed::Box<WhileExpression<'tree>>),
9303 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
9304}
9305impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
9306 #[allow(clippy::collapsible_else_if)]
9307 fn from_node(
9308 node: ::tree_sitter::Node<'tree>,
9309 src: &'tree [u8],
9310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9311 match node.kind() {
9312 "array_expression" => Ok(Self::ArrayExpression(::std::boxed::Box::new(
9313 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9314 ))),
9315 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
9316 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9317 ))),
9318 "async_block" => Ok(Self::AsyncBlock(::std::boxed::Box::new(
9319 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9320 ))),
9321 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
9322 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9323 ))),
9324 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
9325 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9326 ))),
9327 "block" => Ok(Self::Block(::std::boxed::Box::new(
9328 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9329 ))),
9330 "break_expression" => Ok(Self::BreakExpression(::std::boxed::Box::new(
9331 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9332 ))),
9333 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
9334 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9335 ))),
9336 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
9337 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9338 ))),
9339 "compound_assignment_expr" => Ok(Self::CompoundAssignmentExpr(::std::boxed::Box::new(
9340 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)?,
9341 ))),
9342 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
9343 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9344 ))),
9345 "continue_expression" => Ok(Self::ContinueExpression(::std::boxed::Box::new(
9346 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9347 ))),
9348 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
9349 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9350 ))),
9351 "for_expression" => Ok(Self::ForExpression(::std::boxed::Box::new(
9352 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9353 ))),
9354 "gen_block" => Ok(Self::GenBlock(::std::boxed::Box::new(
9355 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9356 ))),
9357 "generic_function" => Ok(Self::GenericFunction(::std::boxed::Box::new(
9358 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
9359 ))),
9360 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9361 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9362 ))),
9363 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
9364 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9365 ))),
9366 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
9367 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9368 ))),
9369 "loop_expression" => Ok(Self::LoopExpression(::std::boxed::Box::new(
9370 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9371 ))),
9372 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
9373 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
9374 ))),
9375 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
9376 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9377 ))),
9378 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
9379 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
9380 ))),
9381 "parenthesized_expression" => {
9382 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
9383 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
9384 node, src,
9385 )?,
9386 )))
9387 }
9388 "reference_expression" => Ok(Self::ReferenceExpression(::std::boxed::Box::new(
9389 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9390 ))),
9391 "return_expression" => Ok(Self::ReturnExpression(::std::boxed::Box::new(
9392 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9393 ))),
9394 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
9395 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9396 ))),
9397 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
9398 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
9399 ))),
9400 "struct_expression" => Ok(Self::StructExpression(::std::boxed::Box::new(
9401 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9402 ))),
9403 "try_block" => Ok(Self::TryBlock(::std::boxed::Box::new(
9404 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9405 ))),
9406 "try_expression" => Ok(Self::TryExpression(::std::boxed::Box::new(
9407 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9408 ))),
9409 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
9410 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9411 ))),
9412 "type_cast_expression" => Ok(Self::TypeCastExpression(::std::boxed::Box::new(
9413 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9414 ))),
9415 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
9416 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9417 ))),
9418 "unit_expression" => Ok(Self::UnitExpression(::std::boxed::Box::new(
9419 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9420 ))),
9421 "unsafe_block" => Ok(Self::UnsafeBlock(::std::boxed::Box::new(
9422 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9423 ))),
9424 "while_expression" => Ok(Self::WhileExpression(::std::boxed::Box::new(
9425 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9426 ))),
9427 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
9428 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9429 ))),
9430 _other => {
9431 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
9432 Ok(Self::Literal(::std::boxed::Box::new(v)))
9433 } else {
9434 Err(::treesitter_types::ParseError::unexpected_kind(
9435 _other, node,
9436 ))
9437 }
9438 }
9439 }
9440 }
9441}
9442impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
9443 fn span(&self) -> ::treesitter_types::Span {
9444 match self {
9445 Self::Literal(inner) => inner.span(),
9446 Self::ArrayExpression(inner) => inner.span(),
9447 Self::AssignmentExpression(inner) => inner.span(),
9448 Self::AsyncBlock(inner) => inner.span(),
9449 Self::AwaitExpression(inner) => inner.span(),
9450 Self::BinaryExpression(inner) => inner.span(),
9451 Self::Block(inner) => inner.span(),
9452 Self::BreakExpression(inner) => inner.span(),
9453 Self::CallExpression(inner) => inner.span(),
9454 Self::ClosureExpression(inner) => inner.span(),
9455 Self::CompoundAssignmentExpr(inner) => inner.span(),
9456 Self::ConstBlock(inner) => inner.span(),
9457 Self::ContinueExpression(inner) => inner.span(),
9458 Self::FieldExpression(inner) => inner.span(),
9459 Self::ForExpression(inner) => inner.span(),
9460 Self::GenBlock(inner) => inner.span(),
9461 Self::GenericFunction(inner) => inner.span(),
9462 Self::Identifier(inner) => inner.span(),
9463 Self::IfExpression(inner) => inner.span(),
9464 Self::IndexExpression(inner) => inner.span(),
9465 Self::LoopExpression(inner) => inner.span(),
9466 Self::MacroInvocation(inner) => inner.span(),
9467 Self::MatchExpression(inner) => inner.span(),
9468 Self::Metavariable(inner) => inner.span(),
9469 Self::ParenthesizedExpression(inner) => inner.span(),
9470 Self::ReferenceExpression(inner) => inner.span(),
9471 Self::ReturnExpression(inner) => inner.span(),
9472 Self::ScopedIdentifier(inner) => inner.span(),
9473 Self::SelfType(inner) => inner.span(),
9474 Self::StructExpression(inner) => inner.span(),
9475 Self::TryBlock(inner) => inner.span(),
9476 Self::TryExpression(inner) => inner.span(),
9477 Self::TupleExpression(inner) => inner.span(),
9478 Self::TypeCastExpression(inner) => inner.span(),
9479 Self::UnaryExpression(inner) => inner.span(),
9480 Self::UnitExpression(inner) => inner.span(),
9481 Self::UnsafeBlock(inner) => inner.span(),
9482 Self::WhileExpression(inner) => inner.span(),
9483 Self::YieldExpression(inner) => inner.span(),
9484 }
9485 }
9486}
9487#[derive(Debug, Clone)]
9488pub enum ClosureExpressionBody<'tree> {
9489 Blank(::treesitter_types::Span),
9490 Expression(::std::boxed::Box<Expression<'tree>>),
9491}
9492impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpressionBody<'tree> {
9493 #[allow(clippy::collapsible_else_if)]
9494 fn from_node(
9495 node: ::tree_sitter::Node<'tree>,
9496 src: &'tree [u8],
9497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9498 match node.kind() {
9499 "_" => Ok(Self::Blank(::treesitter_types::Span::from(node))),
9500 _other => {
9501 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9502 Ok(Self::Expression(::std::boxed::Box::new(v)))
9503 } else {
9504 Err(::treesitter_types::ParseError::unexpected_kind(
9505 _other, node,
9506 ))
9507 }
9508 }
9509 }
9510 }
9511}
9512impl ::treesitter_types::Spanned for ClosureExpressionBody<'_> {
9513 fn span(&self) -> ::treesitter_types::Span {
9514 match self {
9515 Self::Blank(span) => *span,
9516 Self::Expression(inner) => inner.span(),
9517 }
9518 }
9519}
9520#[derive(Debug, Clone)]
9521pub enum ClosureParametersChildren<'tree> {
9522 Pattern(::std::boxed::Box<Pattern<'tree>>),
9523 Parameter(::std::boxed::Box<Parameter<'tree>>),
9524}
9525impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParametersChildren<'tree> {
9526 #[allow(clippy::collapsible_else_if)]
9527 fn from_node(
9528 node: ::tree_sitter::Node<'tree>,
9529 src: &'tree [u8],
9530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9531 match node.kind() {
9532 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
9533 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
9534 ))),
9535 _other => {
9536 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
9537 Ok(Self::Pattern(::std::boxed::Box::new(v)))
9538 } else {
9539 Err(::treesitter_types::ParseError::unexpected_kind(
9540 _other, node,
9541 ))
9542 }
9543 }
9544 }
9545 }
9546}
9547impl ::treesitter_types::Spanned for ClosureParametersChildren<'_> {
9548 fn span(&self) -> ::treesitter_types::Span {
9549 match self {
9550 Self::Pattern(inner) => inner.span(),
9551 Self::Parameter(inner) => inner.span(),
9552 }
9553 }
9554}
9555#[derive(Debug, Clone)]
9556pub enum CompoundAssignmentExprOperator {
9557 PercentEq(::treesitter_types::Span),
9558 AmpEq(::treesitter_types::Span),
9559 StarEq(::treesitter_types::Span),
9560 PlusEq(::treesitter_types::Span),
9561 MinusEq(::treesitter_types::Span),
9562 SlashEq(::treesitter_types::Span),
9563 ShlEq(::treesitter_types::Span),
9564 ShrEq(::treesitter_types::Span),
9565 CaretEq(::treesitter_types::Span),
9566 PipeEq(::treesitter_types::Span),
9567}
9568impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExprOperator {
9569 #[allow(clippy::collapsible_else_if)]
9570 fn from_node(
9571 node: ::tree_sitter::Node<'tree>,
9572 _src: &'tree [u8],
9573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9574 match node.kind() {
9575 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
9576 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
9577 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
9578 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
9579 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
9580 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
9581 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
9582 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
9583 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
9584 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
9585 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9586 }
9587 }
9588}
9589impl ::treesitter_types::Spanned for CompoundAssignmentExprOperator {
9590 fn span(&self) -> ::treesitter_types::Span {
9591 match self {
9592 Self::PercentEq(span) => *span,
9593 Self::AmpEq(span) => *span,
9594 Self::StarEq(span) => *span,
9595 Self::PlusEq(span) => *span,
9596 Self::MinusEq(span) => *span,
9597 Self::SlashEq(span) => *span,
9598 Self::ShlEq(span) => *span,
9599 Self::ShrEq(span) => *span,
9600 Self::CaretEq(span) => *span,
9601 Self::PipeEq(span) => *span,
9602 }
9603 }
9604}
9605#[derive(Debug, Clone)]
9606pub enum ConstParameterValue<'tree> {
9607 Literal(::std::boxed::Box<Literal<'tree>>),
9608 Block(::std::boxed::Box<Block<'tree>>),
9609 Identifier(::std::boxed::Box<Identifier<'tree>>),
9610 NegativeLiteral(::std::boxed::Box<NegativeLiteral<'tree>>),
9611}
9612impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameterValue<'tree> {
9613 #[allow(clippy::collapsible_else_if)]
9614 fn from_node(
9615 node: ::tree_sitter::Node<'tree>,
9616 src: &'tree [u8],
9617 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9618 match node.kind() {
9619 "block" => Ok(Self::Block(::std::boxed::Box::new(
9620 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9621 ))),
9622 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9623 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9624 ))),
9625 "negative_literal" => Ok(Self::NegativeLiteral(::std::boxed::Box::new(
9626 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
9627 ))),
9628 _other => {
9629 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
9630 Ok(Self::Literal(::std::boxed::Box::new(v)))
9631 } else {
9632 Err(::treesitter_types::ParseError::unexpected_kind(
9633 _other, node,
9634 ))
9635 }
9636 }
9637 }
9638 }
9639}
9640impl ::treesitter_types::Spanned for ConstParameterValue<'_> {
9641 fn span(&self) -> ::treesitter_types::Span {
9642 match self {
9643 Self::Literal(inner) => inner.span(),
9644 Self::Block(inner) => inner.span(),
9645 Self::Identifier(inner) => inner.span(),
9646 Self::NegativeLiteral(inner) => inner.span(),
9647 }
9648 }
9649}
9650#[derive(Debug, Clone)]
9651pub enum DynamicTypeTrait<'tree> {
9652 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
9653 GenericType(::std::boxed::Box<GenericType<'tree>>),
9654 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
9655 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
9656 TupleType(::std::boxed::Box<TupleType<'tree>>),
9657 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
9658}
9659impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicTypeTrait<'tree> {
9660 #[allow(clippy::collapsible_else_if)]
9661 fn from_node(
9662 node: ::tree_sitter::Node<'tree>,
9663 src: &'tree [u8],
9664 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9665 match node.kind() {
9666 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
9667 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
9668 ))),
9669 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
9670 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
9671 ))),
9672 "higher_ranked_trait_bound" => {
9673 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
9674 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
9675 )))
9676 }
9677 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
9678 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9679 ))),
9680 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
9681 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
9682 ))),
9683 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
9684 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9685 ))),
9686 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9687 }
9688 }
9689}
9690impl ::treesitter_types::Spanned for DynamicTypeTrait<'_> {
9691 fn span(&self) -> ::treesitter_types::Span {
9692 match self {
9693 Self::FunctionType(inner) => inner.span(),
9694 Self::GenericType(inner) => inner.span(),
9695 Self::HigherRankedTraitBound(inner) => inner.span(),
9696 Self::ScopedTypeIdentifier(inner) => inner.span(),
9697 Self::TupleType(inner) => inner.span(),
9698 Self::TypeIdentifier(inner) => inner.span(),
9699 }
9700 }
9701}
9702#[derive(Debug, Clone)]
9703pub enum ElseClauseChildren<'tree> {
9704 Block(::std::boxed::Box<Block<'tree>>),
9705 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
9706}
9707impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClauseChildren<'tree> {
9708 #[allow(clippy::collapsible_else_if)]
9709 fn from_node(
9710 node: ::tree_sitter::Node<'tree>,
9711 src: &'tree [u8],
9712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9713 match node.kind() {
9714 "block" => Ok(Self::Block(::std::boxed::Box::new(
9715 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
9716 ))),
9717 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
9718 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9719 ))),
9720 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9721 }
9722 }
9723}
9724impl ::treesitter_types::Spanned for ElseClauseChildren<'_> {
9725 fn span(&self) -> ::treesitter_types::Span {
9726 match self {
9727 Self::Block(inner) => inner.span(),
9728 Self::IfExpression(inner) => inner.span(),
9729 }
9730 }
9731}
9732#[derive(Debug, Clone)]
9733pub enum EnumItemChildren<'tree> {
9734 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
9735 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
9736}
9737impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItemChildren<'tree> {
9738 #[allow(clippy::collapsible_else_if)]
9739 fn from_node(
9740 node: ::tree_sitter::Node<'tree>,
9741 src: &'tree [u8],
9742 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9743 match node.kind() {
9744 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
9745 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9746 ))),
9747 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
9748 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
9749 ))),
9750 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9751 }
9752 }
9753}
9754impl ::treesitter_types::Spanned for EnumItemChildren<'_> {
9755 fn span(&self) -> ::treesitter_types::Span {
9756 match self {
9757 Self::VisibilityModifier(inner) => inner.span(),
9758 Self::WhereClause(inner) => inner.span(),
9759 }
9760 }
9761}
9762#[derive(Debug, Clone)]
9763pub enum EnumVariantBody<'tree> {
9764 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
9765 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
9766}
9767impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantBody<'tree> {
9768 #[allow(clippy::collapsible_else_if)]
9769 fn from_node(
9770 node: ::tree_sitter::Node<'tree>,
9771 src: &'tree [u8],
9772 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9773 match node.kind() {
9774 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
9775 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)?,
9776 ))),
9777 "ordered_field_declaration_list" => {
9778 Ok(Self::OrderedFieldDeclarationList(::std::boxed::Box::new(
9779 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
9780 node, src,
9781 )?,
9782 )))
9783 }
9784 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9785 }
9786 }
9787}
9788impl ::treesitter_types::Spanned for EnumVariantBody<'_> {
9789 fn span(&self) -> ::treesitter_types::Span {
9790 match self {
9791 Self::FieldDeclarationList(inner) => inner.span(),
9792 Self::OrderedFieldDeclarationList(inner) => inner.span(),
9793 }
9794 }
9795}
9796#[derive(Debug, Clone)]
9797pub enum EnumVariantListChildren<'tree> {
9798 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
9799 EnumVariant(::std::boxed::Box<EnumVariant<'tree>>),
9800}
9801impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantListChildren<'tree> {
9802 #[allow(clippy::collapsible_else_if)]
9803 fn from_node(
9804 node: ::tree_sitter::Node<'tree>,
9805 src: &'tree [u8],
9806 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9807 match node.kind() {
9808 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
9809 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
9810 ))),
9811 "enum_variant" => Ok(Self::EnumVariant(::std::boxed::Box::new(
9812 <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)?,
9813 ))),
9814 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9815 }
9816 }
9817}
9818impl ::treesitter_types::Spanned for EnumVariantListChildren<'_> {
9819 fn span(&self) -> ::treesitter_types::Span {
9820 match self {
9821 Self::AttributeItem(inner) => inner.span(),
9822 Self::EnumVariant(inner) => inner.span(),
9823 }
9824 }
9825}
9826#[derive(Debug, Clone)]
9827pub enum ExternCrateDeclarationChildren<'tree> {
9828 Crate(::std::boxed::Box<Crate<'tree>>),
9829 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
9830}
9831impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclarationChildren<'tree> {
9832 #[allow(clippy::collapsible_else_if)]
9833 fn from_node(
9834 node: ::tree_sitter::Node<'tree>,
9835 src: &'tree [u8],
9836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9837 match node.kind() {
9838 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
9839 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
9840 ))),
9841 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
9842 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9843 ))),
9844 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9845 }
9846 }
9847}
9848impl ::treesitter_types::Spanned for ExternCrateDeclarationChildren<'_> {
9849 fn span(&self) -> ::treesitter_types::Span {
9850 match self {
9851 Self::Crate(inner) => inner.span(),
9852 Self::VisibilityModifier(inner) => inner.span(),
9853 }
9854 }
9855}
9856#[derive(Debug, Clone)]
9857pub enum FieldDeclarationListChildren<'tree> {
9858 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
9859 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
9860}
9861impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
9862 #[allow(clippy::collapsible_else_if)]
9863 fn from_node(
9864 node: ::tree_sitter::Node<'tree>,
9865 src: &'tree [u8],
9866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9867 match node.kind() {
9868 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
9869 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
9870 ))),
9871 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
9872 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
9873 ))),
9874 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9875 }
9876 }
9877}
9878impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
9879 fn span(&self) -> ::treesitter_types::Span {
9880 match self {
9881 Self::AttributeItem(inner) => inner.span(),
9882 Self::FieldDeclaration(inner) => inner.span(),
9883 }
9884 }
9885}
9886#[derive(Debug, Clone)]
9887pub enum FieldExpressionField<'tree> {
9888 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
9889 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
9890}
9891impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionField<'tree> {
9892 #[allow(clippy::collapsible_else_if)]
9893 fn from_node(
9894 node: ::tree_sitter::Node<'tree>,
9895 src: &'tree [u8],
9896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9897 match node.kind() {
9898 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
9899 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9900 ))),
9901 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
9902 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
9903 ))),
9904 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9905 }
9906 }
9907}
9908impl ::treesitter_types::Spanned for FieldExpressionField<'_> {
9909 fn span(&self) -> ::treesitter_types::Span {
9910 match self {
9911 Self::FieldIdentifier(inner) => inner.span(),
9912 Self::IntegerLiteral(inner) => inner.span(),
9913 }
9914 }
9915}
9916#[derive(Debug, Clone)]
9917pub enum FieldInitializerField<'tree> {
9918 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
9919 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
9920}
9921impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerField<'tree> {
9922 #[allow(clippy::collapsible_else_if)]
9923 fn from_node(
9924 node: ::tree_sitter::Node<'tree>,
9925 src: &'tree [u8],
9926 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9927 match node.kind() {
9928 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
9929 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9930 ))),
9931 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
9932 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
9933 ))),
9934 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9935 }
9936 }
9937}
9938impl ::treesitter_types::Spanned for FieldInitializerField<'_> {
9939 fn span(&self) -> ::treesitter_types::Span {
9940 match self {
9941 Self::FieldIdentifier(inner) => inner.span(),
9942 Self::IntegerLiteral(inner) => inner.span(),
9943 }
9944 }
9945}
9946#[derive(Debug, Clone)]
9947pub enum FieldInitializerListChildren<'tree> {
9948 BaseFieldInitializer(::std::boxed::Box<BaseFieldInitializer<'tree>>),
9949 FieldInitializer(::std::boxed::Box<FieldInitializer<'tree>>),
9950 ShorthandFieldInitializer(::std::boxed::Box<ShorthandFieldInitializer<'tree>>),
9951}
9952impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerListChildren<'tree> {
9953 #[allow(clippy::collapsible_else_if)]
9954 fn from_node(
9955 node: ::tree_sitter::Node<'tree>,
9956 src: &'tree [u8],
9957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9958 match node.kind() {
9959 "base_field_initializer" => Ok(Self::BaseFieldInitializer(::std::boxed::Box::new(
9960 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
9961 ))),
9962 "field_initializer" => Ok(Self::FieldInitializer(::std::boxed::Box::new(
9963 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
9964 ))),
9965 "shorthand_field_initializer" => {
9966 Ok(Self::ShorthandFieldInitializer(::std::boxed::Box::new(
9967 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(
9968 node, src,
9969 )?,
9970 )))
9971 }
9972 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9973 }
9974 }
9975}
9976impl ::treesitter_types::Spanned for FieldInitializerListChildren<'_> {
9977 fn span(&self) -> ::treesitter_types::Span {
9978 match self {
9979 Self::BaseFieldInitializer(inner) => inner.span(),
9980 Self::FieldInitializer(inner) => inner.span(),
9981 Self::ShorthandFieldInitializer(inner) => inner.span(),
9982 }
9983 }
9984}
9985#[derive(Debug, Clone)]
9986pub enum FieldPatternName<'tree> {
9987 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
9988 ShorthandFieldIdentifier(::std::boxed::Box<ShorthandFieldIdentifier<'tree>>),
9989}
9990impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternName<'tree> {
9991 #[allow(clippy::collapsible_else_if)]
9992 fn from_node(
9993 node: ::tree_sitter::Node<'tree>,
9994 src: &'tree [u8],
9995 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9996 match node.kind() {
9997 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
9998 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9999 ))),
10000 "shorthand_field_identifier" => {
10001 Ok(Self::ShorthandFieldIdentifier(::std::boxed::Box::new(
10002 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(
10003 node, src,
10004 )?,
10005 )))
10006 }
10007 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10008 }
10009 }
10010}
10011impl ::treesitter_types::Spanned for FieldPatternName<'_> {
10012 fn span(&self) -> ::treesitter_types::Span {
10013 match self {
10014 Self::FieldIdentifier(inner) => inner.span(),
10015 Self::ShorthandFieldIdentifier(inner) => inner.span(),
10016 }
10017 }
10018}
10019#[derive(Debug, Clone)]
10020pub enum FunctionItemName<'tree> {
10021 Identifier(::std::boxed::Box<Identifier<'tree>>),
10022 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10023}
10024impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemName<'tree> {
10025 #[allow(clippy::collapsible_else_if)]
10026 fn from_node(
10027 node: ::tree_sitter::Node<'tree>,
10028 src: &'tree [u8],
10029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10030 match node.kind() {
10031 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10032 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10033 ))),
10034 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10035 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10036 ))),
10037 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10038 }
10039 }
10040}
10041impl ::treesitter_types::Spanned for FunctionItemName<'_> {
10042 fn span(&self) -> ::treesitter_types::Span {
10043 match self {
10044 Self::Identifier(inner) => inner.span(),
10045 Self::Metavariable(inner) => inner.span(),
10046 }
10047 }
10048}
10049#[derive(Debug, Clone)]
10050pub enum FunctionItemChildren<'tree> {
10051 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
10052 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10053 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
10054}
10055impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemChildren<'tree> {
10056 #[allow(clippy::collapsible_else_if)]
10057 fn from_node(
10058 node: ::tree_sitter::Node<'tree>,
10059 src: &'tree [u8],
10060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10061 match node.kind() {
10062 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
10063 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10064 ))),
10065 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10066 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10067 ))),
10068 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
10069 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10070 ))),
10071 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10072 }
10073 }
10074}
10075impl ::treesitter_types::Spanned for FunctionItemChildren<'_> {
10076 fn span(&self) -> ::treesitter_types::Span {
10077 match self {
10078 Self::FunctionModifiers(inner) => inner.span(),
10079 Self::VisibilityModifier(inner) => inner.span(),
10080 Self::WhereClause(inner) => inner.span(),
10081 }
10082 }
10083}
10084#[derive(Debug, Clone)]
10085pub enum FunctionSignatureItemName<'tree> {
10086 Identifier(::std::boxed::Box<Identifier<'tree>>),
10087 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10088}
10089impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemName<'tree> {
10090 #[allow(clippy::collapsible_else_if)]
10091 fn from_node(
10092 node: ::tree_sitter::Node<'tree>,
10093 src: &'tree [u8],
10094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10095 match node.kind() {
10096 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10097 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10098 ))),
10099 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10100 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10101 ))),
10102 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10103 }
10104 }
10105}
10106impl ::treesitter_types::Spanned for FunctionSignatureItemName<'_> {
10107 fn span(&self) -> ::treesitter_types::Span {
10108 match self {
10109 Self::Identifier(inner) => inner.span(),
10110 Self::Metavariable(inner) => inner.span(),
10111 }
10112 }
10113}
10114#[derive(Debug, Clone)]
10115pub enum FunctionSignatureItemChildren<'tree> {
10116 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
10117 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10118 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
10119}
10120impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemChildren<'tree> {
10121 #[allow(clippy::collapsible_else_if)]
10122 fn from_node(
10123 node: ::tree_sitter::Node<'tree>,
10124 src: &'tree [u8],
10125 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10126 match node.kind() {
10127 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
10128 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10129 ))),
10130 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10131 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10132 ))),
10133 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
10134 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10135 ))),
10136 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10137 }
10138 }
10139}
10140impl ::treesitter_types::Spanned for FunctionSignatureItemChildren<'_> {
10141 fn span(&self) -> ::treesitter_types::Span {
10142 match self {
10143 Self::FunctionModifiers(inner) => inner.span(),
10144 Self::VisibilityModifier(inner) => inner.span(),
10145 Self::WhereClause(inner) => inner.span(),
10146 }
10147 }
10148}
10149#[derive(Debug, Clone)]
10150pub enum FunctionTypeTrait<'tree> {
10151 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10152 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10153}
10154impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeTrait<'tree> {
10155 #[allow(clippy::collapsible_else_if)]
10156 fn from_node(
10157 node: ::tree_sitter::Node<'tree>,
10158 src: &'tree [u8],
10159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10160 match node.kind() {
10161 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10162 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10163 ))),
10164 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10165 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10166 ))),
10167 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10168 }
10169 }
10170}
10171impl ::treesitter_types::Spanned for FunctionTypeTrait<'_> {
10172 fn span(&self) -> ::treesitter_types::Span {
10173 match self {
10174 Self::ScopedTypeIdentifier(inner) => inner.span(),
10175 Self::TypeIdentifier(inner) => inner.span(),
10176 }
10177 }
10178}
10179#[derive(Debug, Clone)]
10180pub enum FunctionTypeChildren<'tree> {
10181 ForLifetimes(::std::boxed::Box<ForLifetimes<'tree>>),
10182 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
10183}
10184impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeChildren<'tree> {
10185 #[allow(clippy::collapsible_else_if)]
10186 fn from_node(
10187 node: ::tree_sitter::Node<'tree>,
10188 src: &'tree [u8],
10189 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10190 match node.kind() {
10191 "for_lifetimes" => Ok(Self::ForLifetimes(::std::boxed::Box::new(
10192 <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)?,
10193 ))),
10194 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
10195 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
10196 ))),
10197 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10198 }
10199 }
10200}
10201impl ::treesitter_types::Spanned for FunctionTypeChildren<'_> {
10202 fn span(&self) -> ::treesitter_types::Span {
10203 match self {
10204 Self::ForLifetimes(inner) => inner.span(),
10205 Self::FunctionModifiers(inner) => inner.span(),
10206 }
10207 }
10208}
10209#[derive(Debug, Clone)]
10210pub enum GenericFunctionFunction<'tree> {
10211 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
10212 Identifier(::std::boxed::Box<Identifier<'tree>>),
10213 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10214}
10215impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunctionFunction<'tree> {
10216 #[allow(clippy::collapsible_else_if)]
10217 fn from_node(
10218 node: ::tree_sitter::Node<'tree>,
10219 src: &'tree [u8],
10220 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10221 match node.kind() {
10222 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
10223 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10224 ))),
10225 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10226 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10227 ))),
10228 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10229 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10230 ))),
10231 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10232 }
10233 }
10234}
10235impl ::treesitter_types::Spanned for GenericFunctionFunction<'_> {
10236 fn span(&self) -> ::treesitter_types::Span {
10237 match self {
10238 Self::FieldExpression(inner) => inner.span(),
10239 Self::Identifier(inner) => inner.span(),
10240 Self::ScopedIdentifier(inner) => inner.span(),
10241 }
10242 }
10243}
10244#[derive(Debug, Clone)]
10245pub enum GenericPatternChildren<'tree> {
10246 Identifier(::std::boxed::Box<Identifier<'tree>>),
10247 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10248}
10249impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPatternChildren<'tree> {
10250 #[allow(clippy::collapsible_else_if)]
10251 fn from_node(
10252 node: ::tree_sitter::Node<'tree>,
10253 src: &'tree [u8],
10254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10255 match node.kind() {
10256 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10257 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10258 ))),
10259 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10260 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10261 ))),
10262 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10263 }
10264 }
10265}
10266impl ::treesitter_types::Spanned for GenericPatternChildren<'_> {
10267 fn span(&self) -> ::treesitter_types::Span {
10268 match self {
10269 Self::Identifier(inner) => inner.span(),
10270 Self::ScopedIdentifier(inner) => inner.span(),
10271 }
10272 }
10273}
10274#[derive(Debug, Clone)]
10275pub enum GenericTypeType<'tree> {
10276 Identifier(::std::boxed::Box<Identifier<'tree>>),
10277 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10278 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10279 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10280}
10281impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeType<'tree> {
10282 #[allow(clippy::collapsible_else_if)]
10283 fn from_node(
10284 node: ::tree_sitter::Node<'tree>,
10285 src: &'tree [u8],
10286 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10287 match node.kind() {
10288 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10289 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10290 ))),
10291 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10292 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10293 ))),
10294 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10295 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10296 ))),
10297 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10298 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10299 ))),
10300 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10301 }
10302 }
10303}
10304impl ::treesitter_types::Spanned for GenericTypeType<'_> {
10305 fn span(&self) -> ::treesitter_types::Span {
10306 match self {
10307 Self::Identifier(inner) => inner.span(),
10308 Self::ScopedIdentifier(inner) => inner.span(),
10309 Self::ScopedTypeIdentifier(inner) => inner.span(),
10310 Self::TypeIdentifier(inner) => inner.span(),
10311 }
10312 }
10313}
10314#[derive(Debug, Clone)]
10315pub enum GenericTypeWithTurbofishType<'tree> {
10316 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10317 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10318}
10319impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofishType<'tree> {
10320 #[allow(clippy::collapsible_else_if)]
10321 fn from_node(
10322 node: ::tree_sitter::Node<'tree>,
10323 src: &'tree [u8],
10324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10325 match node.kind() {
10326 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10327 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10328 ))),
10329 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10330 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10331 ))),
10332 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10333 }
10334 }
10335}
10336impl ::treesitter_types::Spanned for GenericTypeWithTurbofishType<'_> {
10337 fn span(&self) -> ::treesitter_types::Span {
10338 match self {
10339 Self::ScopedIdentifier(inner) => inner.span(),
10340 Self::TypeIdentifier(inner) => inner.span(),
10341 }
10342 }
10343}
10344#[derive(Debug, Clone)]
10345pub enum IfExpressionCondition<'tree> {
10346 Expression(::std::boxed::Box<Expression<'tree>>),
10347 LetChain(::std::boxed::Box<LetChain<'tree>>),
10348 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
10349}
10350impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpressionCondition<'tree> {
10351 #[allow(clippy::collapsible_else_if)]
10352 fn from_node(
10353 node: ::tree_sitter::Node<'tree>,
10354 src: &'tree [u8],
10355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10356 match node.kind() {
10357 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
10358 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
10359 ))),
10360 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
10361 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
10362 ))),
10363 _other => {
10364 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10365 Ok(Self::Expression(::std::boxed::Box::new(v)))
10366 } else {
10367 Err(::treesitter_types::ParseError::unexpected_kind(
10368 _other, node,
10369 ))
10370 }
10371 }
10372 }
10373 }
10374}
10375impl ::treesitter_types::Spanned for IfExpressionCondition<'_> {
10376 fn span(&self) -> ::treesitter_types::Span {
10377 match self {
10378 Self::Expression(inner) => inner.span(),
10379 Self::LetChain(inner) => inner.span(),
10380 Self::LetCondition(inner) => inner.span(),
10381 }
10382 }
10383}
10384#[derive(Debug, Clone)]
10385pub enum ImplItemTrait<'tree> {
10386 GenericType(::std::boxed::Box<GenericType<'tree>>),
10387 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10388 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10389}
10390impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItemTrait<'tree> {
10391 #[allow(clippy::collapsible_else_if)]
10392 fn from_node(
10393 node: ::tree_sitter::Node<'tree>,
10394 src: &'tree [u8],
10395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10396 match node.kind() {
10397 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10398 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10399 ))),
10400 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10401 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10402 ))),
10403 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10404 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10405 ))),
10406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10407 }
10408 }
10409}
10410impl ::treesitter_types::Spanned for ImplItemTrait<'_> {
10411 fn span(&self) -> ::treesitter_types::Span {
10412 match self {
10413 Self::GenericType(inner) => inner.span(),
10414 Self::ScopedTypeIdentifier(inner) => inner.span(),
10415 Self::TypeIdentifier(inner) => inner.span(),
10416 }
10417 }
10418}
10419#[derive(Debug, Clone)]
10420pub enum LetChainChildren<'tree> {
10421 Expression(::std::boxed::Box<Expression<'tree>>),
10422 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
10423}
10424impl<'tree> ::treesitter_types::FromNode<'tree> for LetChainChildren<'tree> {
10425 #[allow(clippy::collapsible_else_if)]
10426 fn from_node(
10427 node: ::tree_sitter::Node<'tree>,
10428 src: &'tree [u8],
10429 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10430 match node.kind() {
10431 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
10432 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
10433 ))),
10434 _other => {
10435 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10436 Ok(Self::Expression(::std::boxed::Box::new(v)))
10437 } else {
10438 Err(::treesitter_types::ParseError::unexpected_kind(
10439 _other, node,
10440 ))
10441 }
10442 }
10443 }
10444 }
10445}
10446impl ::treesitter_types::Spanned for LetChainChildren<'_> {
10447 fn span(&self) -> ::treesitter_types::Span {
10448 match self {
10449 Self::Expression(inner) => inner.span(),
10450 Self::LetCondition(inner) => inner.span(),
10451 }
10452 }
10453}
10454#[derive(Debug, Clone)]
10455pub enum MacroInvocationMacro<'tree> {
10456 Identifier(::std::boxed::Box<Identifier<'tree>>),
10457 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10458}
10459impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocationMacro<'tree> {
10460 #[allow(clippy::collapsible_else_if)]
10461 fn from_node(
10462 node: ::tree_sitter::Node<'tree>,
10463 src: &'tree [u8],
10464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10465 match node.kind() {
10466 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10467 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10468 ))),
10469 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10470 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10471 ))),
10472 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10473 }
10474 }
10475}
10476impl ::treesitter_types::Spanned for MacroInvocationMacro<'_> {
10477 fn span(&self) -> ::treesitter_types::Span {
10478 match self {
10479 Self::Identifier(inner) => inner.span(),
10480 Self::ScopedIdentifier(inner) => inner.span(),
10481 }
10482 }
10483}
10484#[derive(Debug, Clone)]
10485pub enum MatchArmChildren<'tree> {
10486 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10487 InnerAttributeItem(::std::boxed::Box<InnerAttributeItem<'tree>>),
10488}
10489impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArmChildren<'tree> {
10490 #[allow(clippy::collapsible_else_if)]
10491 fn from_node(
10492 node: ::tree_sitter::Node<'tree>,
10493 src: &'tree [u8],
10494 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10495 match node.kind() {
10496 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10497 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10498 ))),
10499 "inner_attribute_item" => Ok(Self::InnerAttributeItem(::std::boxed::Box::new(
10500 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10501 ))),
10502 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10503 }
10504 }
10505}
10506impl ::treesitter_types::Spanned for MatchArmChildren<'_> {
10507 fn span(&self) -> ::treesitter_types::Span {
10508 match self {
10509 Self::AttributeItem(inner) => inner.span(),
10510 Self::InnerAttributeItem(inner) => inner.span(),
10511 }
10512 }
10513}
10514#[derive(Debug, Clone)]
10515pub enum MatchPatternCondition<'tree> {
10516 Expression(::std::boxed::Box<Expression<'tree>>),
10517 LetChain(::std::boxed::Box<LetChain<'tree>>),
10518 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
10519}
10520impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPatternCondition<'tree> {
10521 #[allow(clippy::collapsible_else_if)]
10522 fn from_node(
10523 node: ::tree_sitter::Node<'tree>,
10524 src: &'tree [u8],
10525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10526 match node.kind() {
10527 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
10528 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
10529 ))),
10530 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
10531 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
10532 ))),
10533 _other => {
10534 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10535 Ok(Self::Expression(::std::boxed::Box::new(v)))
10536 } else {
10537 Err(::treesitter_types::ParseError::unexpected_kind(
10538 _other, node,
10539 ))
10540 }
10541 }
10542 }
10543 }
10544}
10545impl ::treesitter_types::Spanned for MatchPatternCondition<'_> {
10546 fn span(&self) -> ::treesitter_types::Span {
10547 match self {
10548 Self::Expression(inner) => inner.span(),
10549 Self::LetChain(inner) => inner.span(),
10550 Self::LetCondition(inner) => inner.span(),
10551 }
10552 }
10553}
10554#[derive(Debug, Clone)]
10555pub enum MutPatternChildren<'tree> {
10556 Pattern(::std::boxed::Box<Pattern<'tree>>),
10557 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
10558}
10559impl<'tree> ::treesitter_types::FromNode<'tree> for MutPatternChildren<'tree> {
10560 #[allow(clippy::collapsible_else_if)]
10561 fn from_node(
10562 node: ::tree_sitter::Node<'tree>,
10563 src: &'tree [u8],
10564 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10565 match node.kind() {
10566 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
10567 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10568 ))),
10569 _other => {
10570 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10571 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10572 } else {
10573 Err(::treesitter_types::ParseError::unexpected_kind(
10574 _other, node,
10575 ))
10576 }
10577 }
10578 }
10579 }
10580}
10581impl ::treesitter_types::Spanned for MutPatternChildren<'_> {
10582 fn span(&self) -> ::treesitter_types::Span {
10583 match self {
10584 Self::Pattern(inner) => inner.span(),
10585 Self::MutableSpecifier(inner) => inner.span(),
10586 }
10587 }
10588}
10589#[derive(Debug, Clone)]
10590pub enum NegativeLiteralChildren<'tree> {
10591 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
10592 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
10593}
10594impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteralChildren<'tree> {
10595 #[allow(clippy::collapsible_else_if)]
10596 fn from_node(
10597 node: ::tree_sitter::Node<'tree>,
10598 src: &'tree [u8],
10599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10600 match node.kind() {
10601 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
10602 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
10603 ))),
10604 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
10605 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
10606 ))),
10607 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10608 }
10609 }
10610}
10611impl ::treesitter_types::Spanned for NegativeLiteralChildren<'_> {
10612 fn span(&self) -> ::treesitter_types::Span {
10613 match self {
10614 Self::FloatLiteral(inner) => inner.span(),
10615 Self::IntegerLiteral(inner) => inner.span(),
10616 }
10617 }
10618}
10619#[derive(Debug, Clone)]
10620pub enum OrderedFieldDeclarationListChildren<'tree> {
10621 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10622 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10623}
10624impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationListChildren<'tree> {
10625 #[allow(clippy::collapsible_else_if)]
10626 fn from_node(
10627 node: ::tree_sitter::Node<'tree>,
10628 src: &'tree [u8],
10629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10630 match node.kind() {
10631 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10632 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10633 ))),
10634 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10635 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10636 ))),
10637 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10638 }
10639 }
10640}
10641impl ::treesitter_types::Spanned for OrderedFieldDeclarationListChildren<'_> {
10642 fn span(&self) -> ::treesitter_types::Span {
10643 match self {
10644 Self::AttributeItem(inner) => inner.span(),
10645 Self::VisibilityModifier(inner) => inner.span(),
10646 }
10647 }
10648}
10649#[derive(Debug, Clone)]
10650pub enum ParameterPattern<'tree> {
10651 Pattern(::std::boxed::Box<Pattern<'tree>>),
10652 SelfType(::std::boxed::Box<SelfType<'tree>>),
10653}
10654impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPattern<'tree> {
10655 #[allow(clippy::collapsible_else_if)]
10656 fn from_node(
10657 node: ::tree_sitter::Node<'tree>,
10658 src: &'tree [u8],
10659 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10660 match node.kind() {
10661 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10662 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10663 ))),
10664 _other => {
10665 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10666 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10667 } else {
10668 Err(::treesitter_types::ParseError::unexpected_kind(
10669 _other, node,
10670 ))
10671 }
10672 }
10673 }
10674 }
10675}
10676impl ::treesitter_types::Spanned for ParameterPattern<'_> {
10677 fn span(&self) -> ::treesitter_types::Span {
10678 match self {
10679 Self::Pattern(inner) => inner.span(),
10680 Self::SelfType(inner) => inner.span(),
10681 }
10682 }
10683}
10684#[derive(Debug, Clone)]
10685pub enum ParametersChildren<'tree> {
10686 Type(::std::boxed::Box<Type<'tree>>),
10687 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10688 Parameter(::std::boxed::Box<Parameter<'tree>>),
10689 SelfParameter(::std::boxed::Box<SelfParameter<'tree>>),
10690 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
10691}
10692impl<'tree> ::treesitter_types::FromNode<'tree> for ParametersChildren<'tree> {
10693 #[allow(clippy::collapsible_else_if)]
10694 fn from_node(
10695 node: ::tree_sitter::Node<'tree>,
10696 src: &'tree [u8],
10697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10698 match node.kind() {
10699 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10700 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10701 ))),
10702 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
10703 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10704 ))),
10705 "self_parameter" => Ok(Self::SelfParameter(::std::boxed::Box::new(
10706 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10707 ))),
10708 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
10709 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10710 ))),
10711 _other => {
10712 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10713 Ok(Self::Type(::std::boxed::Box::new(v)))
10714 } else {
10715 Err(::treesitter_types::ParseError::unexpected_kind(
10716 _other, node,
10717 ))
10718 }
10719 }
10720 }
10721 }
10722}
10723impl ::treesitter_types::Spanned for ParametersChildren<'_> {
10724 fn span(&self) -> ::treesitter_types::Span {
10725 match self {
10726 Self::Type(inner) => inner.span(),
10727 Self::AttributeItem(inner) => inner.span(),
10728 Self::Parameter(inner) => inner.span(),
10729 Self::SelfParameter(inner) => inner.span(),
10730 Self::VariadicParameter(inner) => inner.span(),
10731 }
10732 }
10733}
10734#[derive(Debug, Clone)]
10735pub enum RangePatternLeft<'tree> {
10736 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
10737 Crate(::std::boxed::Box<Crate<'tree>>),
10738 Identifier(::std::boxed::Box<Identifier<'tree>>),
10739 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10740 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10741 SelfType(::std::boxed::Box<SelfType<'tree>>),
10742 Super(::std::boxed::Box<Super<'tree>>),
10743}
10744impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternLeft<'tree> {
10745 #[allow(clippy::collapsible_else_if)]
10746 fn from_node(
10747 node: ::tree_sitter::Node<'tree>,
10748 src: &'tree [u8],
10749 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10750 match node.kind() {
10751 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
10752 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
10753 ))),
10754 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10755 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10756 ))),
10757 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10758 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10759 ))),
10760 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10761 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10762 ))),
10763 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10764 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10765 ))),
10766 "super" => Ok(Self::Super(::std::boxed::Box::new(
10767 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10768 ))),
10769 _other => {
10770 if let Ok(v) =
10771 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
10772 {
10773 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
10774 } else {
10775 Err(::treesitter_types::ParseError::unexpected_kind(
10776 _other, node,
10777 ))
10778 }
10779 }
10780 }
10781 }
10782}
10783impl ::treesitter_types::Spanned for RangePatternLeft<'_> {
10784 fn span(&self) -> ::treesitter_types::Span {
10785 match self {
10786 Self::LiteralPattern(inner) => inner.span(),
10787 Self::Crate(inner) => inner.span(),
10788 Self::Identifier(inner) => inner.span(),
10789 Self::Metavariable(inner) => inner.span(),
10790 Self::ScopedIdentifier(inner) => inner.span(),
10791 Self::SelfType(inner) => inner.span(),
10792 Self::Super(inner) => inner.span(),
10793 }
10794 }
10795}
10796#[derive(Debug, Clone)]
10797pub enum RangePatternRight<'tree> {
10798 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
10799 Crate(::std::boxed::Box<Crate<'tree>>),
10800 Identifier(::std::boxed::Box<Identifier<'tree>>),
10801 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10802 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10803 SelfType(::std::boxed::Box<SelfType<'tree>>),
10804 Super(::std::boxed::Box<Super<'tree>>),
10805}
10806impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternRight<'tree> {
10807 #[allow(clippy::collapsible_else_if)]
10808 fn from_node(
10809 node: ::tree_sitter::Node<'tree>,
10810 src: &'tree [u8],
10811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10812 match node.kind() {
10813 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
10814 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
10815 ))),
10816 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10817 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10818 ))),
10819 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10820 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10821 ))),
10822 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10823 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10824 ))),
10825 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10826 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10827 ))),
10828 "super" => Ok(Self::Super(::std::boxed::Box::new(
10829 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10830 ))),
10831 _other => {
10832 if let Ok(v) =
10833 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
10834 {
10835 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
10836 } else {
10837 Err(::treesitter_types::ParseError::unexpected_kind(
10838 _other, node,
10839 ))
10840 }
10841 }
10842 }
10843 }
10844}
10845impl ::treesitter_types::Spanned for RangePatternRight<'_> {
10846 fn span(&self) -> ::treesitter_types::Span {
10847 match self {
10848 Self::LiteralPattern(inner) => inner.span(),
10849 Self::Crate(inner) => inner.span(),
10850 Self::Identifier(inner) => inner.span(),
10851 Self::Metavariable(inner) => inner.span(),
10852 Self::ScopedIdentifier(inner) => inner.span(),
10853 Self::SelfType(inner) => inner.span(),
10854 Self::Super(inner) => inner.span(),
10855 }
10856 }
10857}
10858#[derive(Debug, Clone)]
10859pub enum ReferencePatternChildren<'tree> {
10860 Pattern(::std::boxed::Box<Pattern<'tree>>),
10861 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
10862}
10863impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePatternChildren<'tree> {
10864 #[allow(clippy::collapsible_else_if)]
10865 fn from_node(
10866 node: ::tree_sitter::Node<'tree>,
10867 src: &'tree [u8],
10868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10869 match node.kind() {
10870 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
10871 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10872 ))),
10873 _other => {
10874 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10875 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10876 } else {
10877 Err(::treesitter_types::ParseError::unexpected_kind(
10878 _other, node,
10879 ))
10880 }
10881 }
10882 }
10883 }
10884}
10885impl ::treesitter_types::Spanned for ReferencePatternChildren<'_> {
10886 fn span(&self) -> ::treesitter_types::Span {
10887 match self {
10888 Self::Pattern(inner) => inner.span(),
10889 Self::MutableSpecifier(inner) => inner.span(),
10890 }
10891 }
10892}
10893#[derive(Debug, Clone)]
10894pub enum ReferenceTypeChildren<'tree> {
10895 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
10896 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
10897}
10898impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceTypeChildren<'tree> {
10899 #[allow(clippy::collapsible_else_if)]
10900 fn from_node(
10901 node: ::tree_sitter::Node<'tree>,
10902 src: &'tree [u8],
10903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10904 match node.kind() {
10905 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
10906 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
10907 ))),
10908 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
10909 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10910 ))),
10911 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10912 }
10913 }
10914}
10915impl ::treesitter_types::Spanned for ReferenceTypeChildren<'_> {
10916 fn span(&self) -> ::treesitter_types::Span {
10917 match self {
10918 Self::Lifetime(inner) => inner.span(),
10919 Self::MutableSpecifier(inner) => inner.span(),
10920 }
10921 }
10922}
10923#[derive(Debug, Clone)]
10924pub enum ScopedIdentifierName<'tree> {
10925 Identifier(::std::boxed::Box<Identifier<'tree>>),
10926 Super(::std::boxed::Box<Super<'tree>>),
10927}
10928impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierName<'tree> {
10929 #[allow(clippy::collapsible_else_if)]
10930 fn from_node(
10931 node: ::tree_sitter::Node<'tree>,
10932 src: &'tree [u8],
10933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10934 match node.kind() {
10935 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10936 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10937 ))),
10938 "super" => Ok(Self::Super(::std::boxed::Box::new(
10939 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10940 ))),
10941 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10942 }
10943 }
10944}
10945impl ::treesitter_types::Spanned for ScopedIdentifierName<'_> {
10946 fn span(&self) -> ::treesitter_types::Span {
10947 match self {
10948 Self::Identifier(inner) => inner.span(),
10949 Self::Super(inner) => inner.span(),
10950 }
10951 }
10952}
10953#[derive(Debug, Clone)]
10954pub enum ScopedIdentifierPath<'tree> {
10955 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
10956 Crate(::std::boxed::Box<Crate<'tree>>),
10957 GenericType(::std::boxed::Box<GenericType<'tree>>),
10958 Identifier(::std::boxed::Box<Identifier<'tree>>),
10959 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10960 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10961 SelfType(::std::boxed::Box<SelfType<'tree>>),
10962 Super(::std::boxed::Box<Super<'tree>>),
10963}
10964impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierPath<'tree> {
10965 #[allow(clippy::collapsible_else_if)]
10966 fn from_node(
10967 node: ::tree_sitter::Node<'tree>,
10968 src: &'tree [u8],
10969 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10970 match node.kind() {
10971 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
10972 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)?,
10973 ))),
10974 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
10975 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
10976 ))),
10977 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10978 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10979 ))),
10980 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10981 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10982 ))),
10983 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10984 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10985 ))),
10986 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10987 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10988 ))),
10989 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10990 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10991 ))),
10992 "super" => Ok(Self::Super(::std::boxed::Box::new(
10993 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10994 ))),
10995 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10996 }
10997 }
10998}
10999impl ::treesitter_types::Spanned for ScopedIdentifierPath<'_> {
11000 fn span(&self) -> ::treesitter_types::Span {
11001 match self {
11002 Self::BracketedType(inner) => inner.span(),
11003 Self::Crate(inner) => inner.span(),
11004 Self::GenericType(inner) => inner.span(),
11005 Self::Identifier(inner) => inner.span(),
11006 Self::Metavariable(inner) => inner.span(),
11007 Self::ScopedIdentifier(inner) => inner.span(),
11008 Self::SelfType(inner) => inner.span(),
11009 Self::Super(inner) => inner.span(),
11010 }
11011 }
11012}
11013#[derive(Debug, Clone)]
11014pub enum ScopedTypeIdentifierPath<'tree> {
11015 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
11016 Crate(::std::boxed::Box<Crate<'tree>>),
11017 GenericType(::std::boxed::Box<GenericType<'tree>>),
11018 Identifier(::std::boxed::Box<Identifier<'tree>>),
11019 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11020 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11021 SelfType(::std::boxed::Box<SelfType<'tree>>),
11022 Super(::std::boxed::Box<Super<'tree>>),
11023}
11024impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierPath<'tree> {
11025 #[allow(clippy::collapsible_else_if)]
11026 fn from_node(
11027 node: ::tree_sitter::Node<'tree>,
11028 src: &'tree [u8],
11029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11030 match node.kind() {
11031 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
11032 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)?,
11033 ))),
11034 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11035 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11036 ))),
11037 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11038 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
11039 ))),
11040 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11041 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11042 ))),
11043 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11044 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11045 ))),
11046 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11047 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11048 ))),
11049 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11050 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11051 ))),
11052 "super" => Ok(Self::Super(::std::boxed::Box::new(
11053 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11054 ))),
11055 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11056 }
11057 }
11058}
11059impl ::treesitter_types::Spanned for ScopedTypeIdentifierPath<'_> {
11060 fn span(&self) -> ::treesitter_types::Span {
11061 match self {
11062 Self::BracketedType(inner) => inner.span(),
11063 Self::Crate(inner) => inner.span(),
11064 Self::GenericType(inner) => inner.span(),
11065 Self::Identifier(inner) => inner.span(),
11066 Self::Metavariable(inner) => inner.span(),
11067 Self::ScopedIdentifier(inner) => inner.span(),
11068 Self::SelfType(inner) => inner.span(),
11069 Self::Super(inner) => inner.span(),
11070 }
11071 }
11072}
11073#[derive(Debug, Clone)]
11074pub enum ScopedUseListPath<'tree> {
11075 Crate(::std::boxed::Box<Crate<'tree>>),
11076 Identifier(::std::boxed::Box<Identifier<'tree>>),
11077 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11078 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11079 SelfType(::std::boxed::Box<SelfType<'tree>>),
11080 Super(::std::boxed::Box<Super<'tree>>),
11081}
11082impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseListPath<'tree> {
11083 #[allow(clippy::collapsible_else_if)]
11084 fn from_node(
11085 node: ::tree_sitter::Node<'tree>,
11086 src: &'tree [u8],
11087 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11088 match node.kind() {
11089 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11090 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11091 ))),
11092 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11093 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11094 ))),
11095 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11096 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11097 ))),
11098 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11099 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11100 ))),
11101 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11102 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11103 ))),
11104 "super" => Ok(Self::Super(::std::boxed::Box::new(
11105 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11106 ))),
11107 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11108 }
11109 }
11110}
11111impl ::treesitter_types::Spanned for ScopedUseListPath<'_> {
11112 fn span(&self) -> ::treesitter_types::Span {
11113 match self {
11114 Self::Crate(inner) => inner.span(),
11115 Self::Identifier(inner) => inner.span(),
11116 Self::Metavariable(inner) => inner.span(),
11117 Self::ScopedIdentifier(inner) => inner.span(),
11118 Self::SelfType(inner) => inner.span(),
11119 Self::Super(inner) => inner.span(),
11120 }
11121 }
11122}
11123#[derive(Debug, Clone)]
11124pub enum SelfParameterChildren<'tree> {
11125 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
11126 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11127 SelfType(::std::boxed::Box<SelfType<'tree>>),
11128}
11129impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameterChildren<'tree> {
11130 #[allow(clippy::collapsible_else_if)]
11131 fn from_node(
11132 node: ::tree_sitter::Node<'tree>,
11133 src: &'tree [u8],
11134 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11135 match node.kind() {
11136 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
11137 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
11138 ))),
11139 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11140 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11141 ))),
11142 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11143 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11144 ))),
11145 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11146 }
11147 }
11148}
11149impl ::treesitter_types::Spanned for SelfParameterChildren<'_> {
11150 fn span(&self) -> ::treesitter_types::Span {
11151 match self {
11152 Self::Lifetime(inner) => inner.span(),
11153 Self::MutableSpecifier(inner) => inner.span(),
11154 Self::SelfType(inner) => inner.span(),
11155 }
11156 }
11157}
11158#[derive(Debug, Clone)]
11159pub enum ShorthandFieldInitializerChildren<'tree> {
11160 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11161 Identifier(::std::boxed::Box<Identifier<'tree>>),
11162}
11163impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializerChildren<'tree> {
11164 #[allow(clippy::collapsible_else_if)]
11165 fn from_node(
11166 node: ::tree_sitter::Node<'tree>,
11167 src: &'tree [u8],
11168 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11169 match node.kind() {
11170 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11171 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11172 ))),
11173 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11174 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11175 ))),
11176 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11177 }
11178 }
11179}
11180impl ::treesitter_types::Spanned for ShorthandFieldInitializerChildren<'_> {
11181 fn span(&self) -> ::treesitter_types::Span {
11182 match self {
11183 Self::AttributeItem(inner) => inner.span(),
11184 Self::Identifier(inner) => inner.span(),
11185 }
11186 }
11187}
11188#[derive(Debug, Clone)]
11189pub enum SourceFileChildren<'tree> {
11190 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
11191 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
11192 Shebang(::std::boxed::Box<Shebang<'tree>>),
11193}
11194impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFileChildren<'tree> {
11195 #[allow(clippy::collapsible_else_if)]
11196 fn from_node(
11197 node: ::tree_sitter::Node<'tree>,
11198 src: &'tree [u8],
11199 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11200 match node.kind() {
11201 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
11202 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
11203 ))),
11204 "shebang" => Ok(Self::Shebang(::std::boxed::Box::new(
11205 <Shebang as ::treesitter_types::FromNode>::from_node(node, src)?,
11206 ))),
11207 _other => {
11208 if let Ok(v) =
11209 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
11210 {
11211 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
11212 } else {
11213 Err(::treesitter_types::ParseError::unexpected_kind(
11214 _other, node,
11215 ))
11216 }
11217 }
11218 }
11219 }
11220}
11221impl ::treesitter_types::Spanned for SourceFileChildren<'_> {
11222 fn span(&self) -> ::treesitter_types::Span {
11223 match self {
11224 Self::DeclarationStatement(inner) => inner.span(),
11225 Self::ExpressionStatement(inner) => inner.span(),
11226 Self::Shebang(inner) => inner.span(),
11227 }
11228 }
11229}
11230#[derive(Debug, Clone)]
11231pub enum StaticItemChildren<'tree> {
11232 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11233 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11234}
11235impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItemChildren<'tree> {
11236 #[allow(clippy::collapsible_else_if)]
11237 fn from_node(
11238 node: ::tree_sitter::Node<'tree>,
11239 src: &'tree [u8],
11240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11241 match node.kind() {
11242 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11243 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11244 ))),
11245 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11246 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11247 ))),
11248 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11249 }
11250 }
11251}
11252impl ::treesitter_types::Spanned for StaticItemChildren<'_> {
11253 fn span(&self) -> ::treesitter_types::Span {
11254 match self {
11255 Self::MutableSpecifier(inner) => inner.span(),
11256 Self::VisibilityModifier(inner) => inner.span(),
11257 }
11258 }
11259}
11260#[derive(Debug, Clone)]
11261pub enum StringLiteralChildren<'tree> {
11262 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11263 StringContent(::std::boxed::Box<StringContent<'tree>>),
11264}
11265impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
11266 #[allow(clippy::collapsible_else_if)]
11267 fn from_node(
11268 node: ::tree_sitter::Node<'tree>,
11269 src: &'tree [u8],
11270 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11271 match node.kind() {
11272 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11273 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
11274 ))),
11275 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
11276 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
11277 ))),
11278 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11279 }
11280 }
11281}
11282impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
11283 fn span(&self) -> ::treesitter_types::Span {
11284 match self {
11285 Self::EscapeSequence(inner) => inner.span(),
11286 Self::StringContent(inner) => inner.span(),
11287 }
11288 }
11289}
11290#[derive(Debug, Clone)]
11291pub enum StructExpressionName<'tree> {
11292 GenericTypeWithTurbofish(::std::boxed::Box<GenericTypeWithTurbofish<'tree>>),
11293 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11294 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11295}
11296impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpressionName<'tree> {
11297 #[allow(clippy::collapsible_else_if)]
11298 fn from_node(
11299 node: ::tree_sitter::Node<'tree>,
11300 src: &'tree [u8],
11301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11302 match node.kind() {
11303 "generic_type_with_turbofish" => {
11304 Ok(Self::GenericTypeWithTurbofish(::std::boxed::Box::new(
11305 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(
11306 node, src,
11307 )?,
11308 )))
11309 }
11310 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11311 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11312 ))),
11313 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11314 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11315 ))),
11316 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11317 }
11318 }
11319}
11320impl ::treesitter_types::Spanned for StructExpressionName<'_> {
11321 fn span(&self) -> ::treesitter_types::Span {
11322 match self {
11323 Self::GenericTypeWithTurbofish(inner) => inner.span(),
11324 Self::ScopedTypeIdentifier(inner) => inner.span(),
11325 Self::TypeIdentifier(inner) => inner.span(),
11326 }
11327 }
11328}
11329#[derive(Debug, Clone)]
11330pub enum StructItemBody<'tree> {
11331 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
11332 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
11333}
11334impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemBody<'tree> {
11335 #[allow(clippy::collapsible_else_if)]
11336 fn from_node(
11337 node: ::tree_sitter::Node<'tree>,
11338 src: &'tree [u8],
11339 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11340 match node.kind() {
11341 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
11342 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)?,
11343 ))),
11344 "ordered_field_declaration_list" => {
11345 Ok(Self::OrderedFieldDeclarationList(::std::boxed::Box::new(
11346 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
11347 node, src,
11348 )?,
11349 )))
11350 }
11351 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11352 }
11353 }
11354}
11355impl ::treesitter_types::Spanned for StructItemBody<'_> {
11356 fn span(&self) -> ::treesitter_types::Span {
11357 match self {
11358 Self::FieldDeclarationList(inner) => inner.span(),
11359 Self::OrderedFieldDeclarationList(inner) => inner.span(),
11360 }
11361 }
11362}
11363#[derive(Debug, Clone)]
11364pub enum StructItemChildren<'tree> {
11365 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11366 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11367}
11368impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemChildren<'tree> {
11369 #[allow(clippy::collapsible_else_if)]
11370 fn from_node(
11371 node: ::tree_sitter::Node<'tree>,
11372 src: &'tree [u8],
11373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11374 match node.kind() {
11375 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11376 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11377 ))),
11378 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11379 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11380 ))),
11381 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11382 }
11383 }
11384}
11385impl ::treesitter_types::Spanned for StructItemChildren<'_> {
11386 fn span(&self) -> ::treesitter_types::Span {
11387 match self {
11388 Self::VisibilityModifier(inner) => inner.span(),
11389 Self::WhereClause(inner) => inner.span(),
11390 }
11391 }
11392}
11393#[derive(Debug, Clone)]
11394pub enum StructPatternType<'tree> {
11395 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11396 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11397}
11398impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternType<'tree> {
11399 #[allow(clippy::collapsible_else_if)]
11400 fn from_node(
11401 node: ::tree_sitter::Node<'tree>,
11402 src: &'tree [u8],
11403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11404 match node.kind() {
11405 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11406 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11407 ))),
11408 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11409 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11410 ))),
11411 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11412 }
11413 }
11414}
11415impl ::treesitter_types::Spanned for StructPatternType<'_> {
11416 fn span(&self) -> ::treesitter_types::Span {
11417 match self {
11418 Self::ScopedTypeIdentifier(inner) => inner.span(),
11419 Self::TypeIdentifier(inner) => inner.span(),
11420 }
11421 }
11422}
11423#[derive(Debug, Clone)]
11424pub enum StructPatternChildren<'tree> {
11425 FieldPattern(::std::boxed::Box<FieldPattern<'tree>>),
11426 RemainingFieldPattern(::std::boxed::Box<RemainingFieldPattern<'tree>>),
11427}
11428impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternChildren<'tree> {
11429 #[allow(clippy::collapsible_else_if)]
11430 fn from_node(
11431 node: ::tree_sitter::Node<'tree>,
11432 src: &'tree [u8],
11433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11434 match node.kind() {
11435 "field_pattern" => Ok(Self::FieldPattern(::std::boxed::Box::new(
11436 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11437 ))),
11438 "remaining_field_pattern" => Ok(Self::RemainingFieldPattern(::std::boxed::Box::new(
11439 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11440 ))),
11441 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11442 }
11443 }
11444}
11445impl ::treesitter_types::Spanned for StructPatternChildren<'_> {
11446 fn span(&self) -> ::treesitter_types::Span {
11447 match self {
11448 Self::FieldPattern(inner) => inner.span(),
11449 Self::RemainingFieldPattern(inner) => inner.span(),
11450 }
11451 }
11452}
11453#[derive(Debug, Clone)]
11454pub enum TokenRepetitionChildren<'tree> {
11455 Literal(::std::boxed::Box<Literal<'tree>>),
11456 Crate(::std::boxed::Box<Crate<'tree>>),
11457 Identifier(::std::boxed::Box<Identifier<'tree>>),
11458 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11459 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11460 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11461 SelfType(::std::boxed::Box<SelfType<'tree>>),
11462 Super(::std::boxed::Box<Super<'tree>>),
11463 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
11464 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
11465}
11466impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionChildren<'tree> {
11467 #[allow(clippy::collapsible_else_if)]
11468 fn from_node(
11469 node: ::tree_sitter::Node<'tree>,
11470 src: &'tree [u8],
11471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11472 match node.kind() {
11473 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11474 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11475 ))),
11476 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11477 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11478 ))),
11479 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11480 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11481 ))),
11482 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11483 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11484 ))),
11485 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11486 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11487 ))),
11488 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11489 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11490 ))),
11491 "super" => Ok(Self::Super(::std::boxed::Box::new(
11492 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11493 ))),
11494 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
11495 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)?,
11496 ))),
11497 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
11498 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)?,
11499 ))),
11500 _other => {
11501 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
11502 Ok(Self::Literal(::std::boxed::Box::new(v)))
11503 } else {
11504 Err(::treesitter_types::ParseError::unexpected_kind(
11505 _other, node,
11506 ))
11507 }
11508 }
11509 }
11510 }
11511}
11512impl ::treesitter_types::Spanned for TokenRepetitionChildren<'_> {
11513 fn span(&self) -> ::treesitter_types::Span {
11514 match self {
11515 Self::Literal(inner) => inner.span(),
11516 Self::Crate(inner) => inner.span(),
11517 Self::Identifier(inner) => inner.span(),
11518 Self::Metavariable(inner) => inner.span(),
11519 Self::MutableSpecifier(inner) => inner.span(),
11520 Self::PrimitiveType(inner) => inner.span(),
11521 Self::SelfType(inner) => inner.span(),
11522 Self::Super(inner) => inner.span(),
11523 Self::TokenRepetition(inner) => inner.span(),
11524 Self::TokenTree(inner) => inner.span(),
11525 }
11526 }
11527}
11528#[derive(Debug, Clone)]
11529pub enum TokenRepetitionPatternChildren<'tree> {
11530 Literal(::std::boxed::Box<Literal<'tree>>),
11531 Crate(::std::boxed::Box<Crate<'tree>>),
11532 Identifier(::std::boxed::Box<Identifier<'tree>>),
11533 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11534 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11535 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11536 SelfType(::std::boxed::Box<SelfType<'tree>>),
11537 Super(::std::boxed::Box<Super<'tree>>),
11538 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
11539 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
11540 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
11541}
11542impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPatternChildren<'tree> {
11543 #[allow(clippy::collapsible_else_if)]
11544 fn from_node(
11545 node: ::tree_sitter::Node<'tree>,
11546 src: &'tree [u8],
11547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11548 match node.kind() {
11549 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11550 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11551 ))),
11552 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11553 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11554 ))),
11555 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11556 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11557 ))),
11558 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11559 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11560 ))),
11561 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11562 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11563 ))),
11564 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11565 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11566 ))),
11567 "super" => Ok(Self::Super(::std::boxed::Box::new(
11568 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11569 ))),
11570 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
11571 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11572 ))),
11573 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
11574 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11575 ))),
11576 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
11577 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11578 ))),
11579 _other => {
11580 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
11581 Ok(Self::Literal(::std::boxed::Box::new(v)))
11582 } else {
11583 Err(::treesitter_types::ParseError::unexpected_kind(
11584 _other, node,
11585 ))
11586 }
11587 }
11588 }
11589 }
11590}
11591impl ::treesitter_types::Spanned for TokenRepetitionPatternChildren<'_> {
11592 fn span(&self) -> ::treesitter_types::Span {
11593 match self {
11594 Self::Literal(inner) => inner.span(),
11595 Self::Crate(inner) => inner.span(),
11596 Self::Identifier(inner) => inner.span(),
11597 Self::Metavariable(inner) => inner.span(),
11598 Self::MutableSpecifier(inner) => inner.span(),
11599 Self::PrimitiveType(inner) => inner.span(),
11600 Self::SelfType(inner) => inner.span(),
11601 Self::Super(inner) => inner.span(),
11602 Self::TokenBindingPattern(inner) => inner.span(),
11603 Self::TokenRepetitionPattern(inner) => inner.span(),
11604 Self::TokenTreePattern(inner) => inner.span(),
11605 }
11606 }
11607}
11608#[derive(Debug, Clone)]
11609pub enum TokenTreeChildren<'tree> {
11610 Literal(::std::boxed::Box<Literal<'tree>>),
11611 Crate(::std::boxed::Box<Crate<'tree>>),
11612 Identifier(::std::boxed::Box<Identifier<'tree>>),
11613 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11614 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11615 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11616 SelfType(::std::boxed::Box<SelfType<'tree>>),
11617 Super(::std::boxed::Box<Super<'tree>>),
11618 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
11619 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
11620}
11621impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreeChildren<'tree> {
11622 #[allow(clippy::collapsible_else_if)]
11623 fn from_node(
11624 node: ::tree_sitter::Node<'tree>,
11625 src: &'tree [u8],
11626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11627 match node.kind() {
11628 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11629 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11630 ))),
11631 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11632 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11633 ))),
11634 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11635 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11636 ))),
11637 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11638 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11639 ))),
11640 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11641 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11642 ))),
11643 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11644 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11645 ))),
11646 "super" => Ok(Self::Super(::std::boxed::Box::new(
11647 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11648 ))),
11649 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
11650 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)?,
11651 ))),
11652 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
11653 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)?,
11654 ))),
11655 _other => {
11656 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
11657 Ok(Self::Literal(::std::boxed::Box::new(v)))
11658 } else {
11659 Err(::treesitter_types::ParseError::unexpected_kind(
11660 _other, node,
11661 ))
11662 }
11663 }
11664 }
11665 }
11666}
11667impl ::treesitter_types::Spanned for TokenTreeChildren<'_> {
11668 fn span(&self) -> ::treesitter_types::Span {
11669 match self {
11670 Self::Literal(inner) => inner.span(),
11671 Self::Crate(inner) => inner.span(),
11672 Self::Identifier(inner) => inner.span(),
11673 Self::Metavariable(inner) => inner.span(),
11674 Self::MutableSpecifier(inner) => inner.span(),
11675 Self::PrimitiveType(inner) => inner.span(),
11676 Self::SelfType(inner) => inner.span(),
11677 Self::Super(inner) => inner.span(),
11678 Self::TokenRepetition(inner) => inner.span(),
11679 Self::TokenTree(inner) => inner.span(),
11680 }
11681 }
11682}
11683#[derive(Debug, Clone)]
11684pub enum TokenTreePatternChildren<'tree> {
11685 Literal(::std::boxed::Box<Literal<'tree>>),
11686 Crate(::std::boxed::Box<Crate<'tree>>),
11687 Identifier(::std::boxed::Box<Identifier<'tree>>),
11688 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11689 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11690 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11691 SelfType(::std::boxed::Box<SelfType<'tree>>),
11692 Super(::std::boxed::Box<Super<'tree>>),
11693 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
11694 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
11695 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
11696}
11697impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePatternChildren<'tree> {
11698 #[allow(clippy::collapsible_else_if)]
11699 fn from_node(
11700 node: ::tree_sitter::Node<'tree>,
11701 src: &'tree [u8],
11702 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11703 match node.kind() {
11704 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11705 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11706 ))),
11707 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11708 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11709 ))),
11710 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11711 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11712 ))),
11713 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11714 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11715 ))),
11716 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11717 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11718 ))),
11719 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11720 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11721 ))),
11722 "super" => Ok(Self::Super(::std::boxed::Box::new(
11723 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11724 ))),
11725 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
11726 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11727 ))),
11728 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
11729 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11730 ))),
11731 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
11732 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11733 ))),
11734 _other => {
11735 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
11736 Ok(Self::Literal(::std::boxed::Box::new(v)))
11737 } else {
11738 Err(::treesitter_types::ParseError::unexpected_kind(
11739 _other, node,
11740 ))
11741 }
11742 }
11743 }
11744 }
11745}
11746impl ::treesitter_types::Spanned for TokenTreePatternChildren<'_> {
11747 fn span(&self) -> ::treesitter_types::Span {
11748 match self {
11749 Self::Literal(inner) => inner.span(),
11750 Self::Crate(inner) => inner.span(),
11751 Self::Identifier(inner) => inner.span(),
11752 Self::Metavariable(inner) => inner.span(),
11753 Self::MutableSpecifier(inner) => inner.span(),
11754 Self::PrimitiveType(inner) => inner.span(),
11755 Self::SelfType(inner) => inner.span(),
11756 Self::Super(inner) => inner.span(),
11757 Self::TokenBindingPattern(inner) => inner.span(),
11758 Self::TokenRepetitionPattern(inner) => inner.span(),
11759 Self::TokenTreePattern(inner) => inner.span(),
11760 }
11761 }
11762}
11763#[derive(Debug, Clone)]
11764pub enum TraitBoundsChildren<'tree> {
11765 Type(::std::boxed::Box<Type<'tree>>),
11766 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
11767 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
11768}
11769impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBoundsChildren<'tree> {
11770 #[allow(clippy::collapsible_else_if)]
11771 fn from_node(
11772 node: ::tree_sitter::Node<'tree>,
11773 src: &'tree [u8],
11774 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11775 match node.kind() {
11776 "higher_ranked_trait_bound" => {
11777 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
11778 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
11779 )))
11780 }
11781 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
11782 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
11783 ))),
11784 _other => {
11785 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11786 Ok(Self::Type(::std::boxed::Box::new(v)))
11787 } else {
11788 Err(::treesitter_types::ParseError::unexpected_kind(
11789 _other, node,
11790 ))
11791 }
11792 }
11793 }
11794 }
11795}
11796impl ::treesitter_types::Spanned for TraitBoundsChildren<'_> {
11797 fn span(&self) -> ::treesitter_types::Span {
11798 match self {
11799 Self::Type(inner) => inner.span(),
11800 Self::HigherRankedTraitBound(inner) => inner.span(),
11801 Self::Lifetime(inner) => inner.span(),
11802 }
11803 }
11804}
11805#[derive(Debug, Clone)]
11806pub enum TraitItemChildren<'tree> {
11807 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11808 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11809}
11810impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItemChildren<'tree> {
11811 #[allow(clippy::collapsible_else_if)]
11812 fn from_node(
11813 node: ::tree_sitter::Node<'tree>,
11814 src: &'tree [u8],
11815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11816 match node.kind() {
11817 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11818 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11819 ))),
11820 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11821 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11822 ))),
11823 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11824 }
11825 }
11826}
11827impl ::treesitter_types::Spanned for TraitItemChildren<'_> {
11828 fn span(&self) -> ::treesitter_types::Span {
11829 match self {
11830 Self::VisibilityModifier(inner) => inner.span(),
11831 Self::WhereClause(inner) => inner.span(),
11832 }
11833 }
11834}
11835#[derive(Debug, Clone)]
11836pub enum TupleExpressionChildren<'tree> {
11837 Expression(::std::boxed::Box<Expression<'tree>>),
11838 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11839}
11840impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpressionChildren<'tree> {
11841 #[allow(clippy::collapsible_else_if)]
11842 fn from_node(
11843 node: ::tree_sitter::Node<'tree>,
11844 src: &'tree [u8],
11845 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11846 match node.kind() {
11847 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11848 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11849 ))),
11850 _other => {
11851 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11852 Ok(Self::Expression(::std::boxed::Box::new(v)))
11853 } else {
11854 Err(::treesitter_types::ParseError::unexpected_kind(
11855 _other, node,
11856 ))
11857 }
11858 }
11859 }
11860 }
11861}
11862impl ::treesitter_types::Spanned for TupleExpressionChildren<'_> {
11863 fn span(&self) -> ::treesitter_types::Span {
11864 match self {
11865 Self::Expression(inner) => inner.span(),
11866 Self::AttributeItem(inner) => inner.span(),
11867 }
11868 }
11869}
11870#[derive(Debug, Clone)]
11871pub enum TuplePatternChildren<'tree> {
11872 Pattern(::std::boxed::Box<Pattern<'tree>>),
11873 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
11874}
11875impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
11876 #[allow(clippy::collapsible_else_if)]
11877 fn from_node(
11878 node: ::tree_sitter::Node<'tree>,
11879 src: &'tree [u8],
11880 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11881 match node.kind() {
11882 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
11883 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11884 ))),
11885 _other => {
11886 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
11887 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11888 } else {
11889 Err(::treesitter_types::ParseError::unexpected_kind(
11890 _other, node,
11891 ))
11892 }
11893 }
11894 }
11895 }
11896}
11897impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
11898 fn span(&self) -> ::treesitter_types::Span {
11899 match self {
11900 Self::Pattern(inner) => inner.span(),
11901 Self::ClosureExpression(inner) => inner.span(),
11902 }
11903 }
11904}
11905#[derive(Debug, Clone)]
11906pub enum TupleStructPatternType<'tree> {
11907 GenericType(::std::boxed::Box<GenericType<'tree>>),
11908 Identifier(::std::boxed::Box<Identifier<'tree>>),
11909 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11910}
11911impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPatternType<'tree> {
11912 #[allow(clippy::collapsible_else_if)]
11913 fn from_node(
11914 node: ::tree_sitter::Node<'tree>,
11915 src: &'tree [u8],
11916 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11917 match node.kind() {
11918 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11919 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
11920 ))),
11921 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11922 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11923 ))),
11924 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11925 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11926 ))),
11927 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11928 }
11929 }
11930}
11931impl ::treesitter_types::Spanned for TupleStructPatternType<'_> {
11932 fn span(&self) -> ::treesitter_types::Span {
11933 match self {
11934 Self::GenericType(inner) => inner.span(),
11935 Self::Identifier(inner) => inner.span(),
11936 Self::ScopedIdentifier(inner) => inner.span(),
11937 }
11938 }
11939}
11940#[derive(Debug, Clone)]
11941pub enum TypeArgumentsChildren<'tree> {
11942 Literal(::std::boxed::Box<Literal<'tree>>),
11943 Type(::std::boxed::Box<Type<'tree>>),
11944 Block(::std::boxed::Box<Block<'tree>>),
11945 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
11946 TraitBounds(::std::boxed::Box<TraitBounds<'tree>>),
11947 TypeBinding(::std::boxed::Box<TypeBinding<'tree>>),
11948}
11949impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
11950 #[allow(clippy::collapsible_else_if)]
11951 fn from_node(
11952 node: ::tree_sitter::Node<'tree>,
11953 src: &'tree [u8],
11954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11955 match node.kind() {
11956 "block" => Ok(Self::Block(::std::boxed::Box::new(
11957 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
11958 ))),
11959 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
11960 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
11961 ))),
11962 "trait_bounds" => Ok(Self::TraitBounds(::std::boxed::Box::new(
11963 <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)?,
11964 ))),
11965 "type_binding" => Ok(Self::TypeBinding(::std::boxed::Box::new(
11966 <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)?,
11967 ))),
11968 _other => {
11969 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
11970 Ok(Self::Literal(::std::boxed::Box::new(v)))
11971 } else {
11972 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11973 Ok(Self::Type(::std::boxed::Box::new(v)))
11974 } else {
11975 Err(::treesitter_types::ParseError::unexpected_kind(
11976 _other, node,
11977 ))
11978 }
11979 }
11980 }
11981 }
11982 }
11983}
11984impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
11985 fn span(&self) -> ::treesitter_types::Span {
11986 match self {
11987 Self::Literal(inner) => inner.span(),
11988 Self::Type(inner) => inner.span(),
11989 Self::Block(inner) => inner.span(),
11990 Self::Lifetime(inner) => inner.span(),
11991 Self::TraitBounds(inner) => inner.span(),
11992 Self::TypeBinding(inner) => inner.span(),
11993 }
11994 }
11995}
11996#[derive(Debug, Clone)]
11997pub enum TypeItemChildren<'tree> {
11998 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11999 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
12000}
12001impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItemChildren<'tree> {
12002 #[allow(clippy::collapsible_else_if)]
12003 fn from_node(
12004 node: ::tree_sitter::Node<'tree>,
12005 src: &'tree [u8],
12006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12007 match node.kind() {
12008 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12009 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12010 ))),
12011 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
12012 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12013 ))),
12014 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12015 }
12016 }
12017}
12018impl ::treesitter_types::Spanned for TypeItemChildren<'_> {
12019 fn span(&self) -> ::treesitter_types::Span {
12020 match self {
12021 Self::VisibilityModifier(inner) => inner.span(),
12022 Self::WhereClause(inner) => inner.span(),
12023 }
12024 }
12025}
12026#[derive(Debug, Clone)]
12027pub enum TypeParametersChildren<'tree> {
12028 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
12029 ConstParameter(::std::boxed::Box<ConstParameter<'tree>>),
12030 LifetimeParameter(::std::boxed::Box<LifetimeParameter<'tree>>),
12031 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12032 TypeParameter(::std::boxed::Box<TypeParameter<'tree>>),
12033}
12034impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParametersChildren<'tree> {
12035 #[allow(clippy::collapsible_else_if)]
12036 fn from_node(
12037 node: ::tree_sitter::Node<'tree>,
12038 src: &'tree [u8],
12039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12040 match node.kind() {
12041 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
12042 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
12043 ))),
12044 "const_parameter" => Ok(Self::ConstParameter(::std::boxed::Box::new(
12045 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
12046 ))),
12047 "lifetime_parameter" => Ok(Self::LifetimeParameter(::std::boxed::Box::new(
12048 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
12049 ))),
12050 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12051 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12052 ))),
12053 "type_parameter" => Ok(Self::TypeParameter(::std::boxed::Box::new(
12054 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
12055 ))),
12056 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12057 }
12058 }
12059}
12060impl ::treesitter_types::Spanned for TypeParametersChildren<'_> {
12061 fn span(&self) -> ::treesitter_types::Span {
12062 match self {
12063 Self::AttributeItem(inner) => inner.span(),
12064 Self::ConstParameter(inner) => inner.span(),
12065 Self::LifetimeParameter(inner) => inner.span(),
12066 Self::Metavariable(inner) => inner.span(),
12067 Self::TypeParameter(inner) => inner.span(),
12068 }
12069 }
12070}
12071#[derive(Debug, Clone)]
12072pub enum UnionItemChildren<'tree> {
12073 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
12074 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
12075}
12076impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItemChildren<'tree> {
12077 #[allow(clippy::collapsible_else_if)]
12078 fn from_node(
12079 node: ::tree_sitter::Node<'tree>,
12080 src: &'tree [u8],
12081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12082 match node.kind() {
12083 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12084 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12085 ))),
12086 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
12087 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12088 ))),
12089 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12090 }
12091 }
12092}
12093impl ::treesitter_types::Spanned for UnionItemChildren<'_> {
12094 fn span(&self) -> ::treesitter_types::Span {
12095 match self {
12096 Self::VisibilityModifier(inner) => inner.span(),
12097 Self::WhereClause(inner) => inner.span(),
12098 }
12099 }
12100}
12101#[derive(Debug, Clone)]
12102pub enum UseAsClausePath<'tree> {
12103 Crate(::std::boxed::Box<Crate<'tree>>),
12104 Identifier(::std::boxed::Box<Identifier<'tree>>),
12105 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12106 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12107 SelfType(::std::boxed::Box<SelfType<'tree>>),
12108 Super(::std::boxed::Box<Super<'tree>>),
12109}
12110impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClausePath<'tree> {
12111 #[allow(clippy::collapsible_else_if)]
12112 fn from_node(
12113 node: ::tree_sitter::Node<'tree>,
12114 src: &'tree [u8],
12115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12116 match node.kind() {
12117 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12118 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12119 ))),
12120 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12121 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12122 ))),
12123 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12124 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12125 ))),
12126 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12127 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12128 ))),
12129 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12130 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12131 ))),
12132 "super" => Ok(Self::Super(::std::boxed::Box::new(
12133 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12134 ))),
12135 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12136 }
12137 }
12138}
12139impl ::treesitter_types::Spanned for UseAsClausePath<'_> {
12140 fn span(&self) -> ::treesitter_types::Span {
12141 match self {
12142 Self::Crate(inner) => inner.span(),
12143 Self::Identifier(inner) => inner.span(),
12144 Self::Metavariable(inner) => inner.span(),
12145 Self::ScopedIdentifier(inner) => inner.span(),
12146 Self::SelfType(inner) => inner.span(),
12147 Self::Super(inner) => inner.span(),
12148 }
12149 }
12150}
12151#[derive(Debug, Clone)]
12152pub enum UseBoundsChildren<'tree> {
12153 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12154 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12155}
12156impl<'tree> ::treesitter_types::FromNode<'tree> for UseBoundsChildren<'tree> {
12157 #[allow(clippy::collapsible_else_if)]
12158 fn from_node(
12159 node: ::tree_sitter::Node<'tree>,
12160 src: &'tree [u8],
12161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12162 match node.kind() {
12163 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12164 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
12165 ))),
12166 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12167 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12168 ))),
12169 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12170 }
12171 }
12172}
12173impl ::treesitter_types::Spanned for UseBoundsChildren<'_> {
12174 fn span(&self) -> ::treesitter_types::Span {
12175 match self {
12176 Self::Lifetime(inner) => inner.span(),
12177 Self::TypeIdentifier(inner) => inner.span(),
12178 }
12179 }
12180}
12181#[derive(Debug, Clone)]
12182pub enum UseDeclarationArgument<'tree> {
12183 Crate(::std::boxed::Box<Crate<'tree>>),
12184 Identifier(::std::boxed::Box<Identifier<'tree>>),
12185 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12186 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12187 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
12188 SelfType(::std::boxed::Box<SelfType<'tree>>),
12189 Super(::std::boxed::Box<Super<'tree>>),
12190 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
12191 UseList(::std::boxed::Box<UseList<'tree>>),
12192 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
12193}
12194impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclarationArgument<'tree> {
12195 #[allow(clippy::collapsible_else_if)]
12196 fn from_node(
12197 node: ::tree_sitter::Node<'tree>,
12198 src: &'tree [u8],
12199 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12200 match node.kind() {
12201 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12202 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12203 ))),
12204 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12205 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12206 ))),
12207 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12208 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12209 ))),
12210 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12211 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12212 ))),
12213 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
12214 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)?,
12215 ))),
12216 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12217 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12218 ))),
12219 "super" => Ok(Self::Super(::std::boxed::Box::new(
12220 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12221 ))),
12222 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
12223 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12224 ))),
12225 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
12226 <UseList as ::treesitter_types::FromNode>::from_node(node, src)?,
12227 ))),
12228 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
12229 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
12230 ))),
12231 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12232 }
12233 }
12234}
12235impl ::treesitter_types::Spanned for UseDeclarationArgument<'_> {
12236 fn span(&self) -> ::treesitter_types::Span {
12237 match self {
12238 Self::Crate(inner) => inner.span(),
12239 Self::Identifier(inner) => inner.span(),
12240 Self::Metavariable(inner) => inner.span(),
12241 Self::ScopedIdentifier(inner) => inner.span(),
12242 Self::ScopedUseList(inner) => inner.span(),
12243 Self::SelfType(inner) => inner.span(),
12244 Self::Super(inner) => inner.span(),
12245 Self::UseAsClause(inner) => inner.span(),
12246 Self::UseList(inner) => inner.span(),
12247 Self::UseWildcard(inner) => inner.span(),
12248 }
12249 }
12250}
12251#[derive(Debug, Clone)]
12252pub enum UseListChildren<'tree> {
12253 Crate(::std::boxed::Box<Crate<'tree>>),
12254 Identifier(::std::boxed::Box<Identifier<'tree>>),
12255 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12256 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12257 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
12258 SelfType(::std::boxed::Box<SelfType<'tree>>),
12259 Super(::std::boxed::Box<Super<'tree>>),
12260 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
12261 UseList(::std::boxed::Box<UseList<'tree>>),
12262 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
12263}
12264impl<'tree> ::treesitter_types::FromNode<'tree> for UseListChildren<'tree> {
12265 #[allow(clippy::collapsible_else_if)]
12266 fn from_node(
12267 node: ::tree_sitter::Node<'tree>,
12268 src: &'tree [u8],
12269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12270 match node.kind() {
12271 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12272 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12273 ))),
12274 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12275 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12276 ))),
12277 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12278 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12279 ))),
12280 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12281 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12282 ))),
12283 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
12284 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)?,
12285 ))),
12286 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12287 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12288 ))),
12289 "super" => Ok(Self::Super(::std::boxed::Box::new(
12290 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12291 ))),
12292 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
12293 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12294 ))),
12295 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
12296 <UseList as ::treesitter_types::FromNode>::from_node(node, src)?,
12297 ))),
12298 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
12299 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
12300 ))),
12301 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12302 }
12303 }
12304}
12305impl ::treesitter_types::Spanned for UseListChildren<'_> {
12306 fn span(&self) -> ::treesitter_types::Span {
12307 match self {
12308 Self::Crate(inner) => inner.span(),
12309 Self::Identifier(inner) => inner.span(),
12310 Self::Metavariable(inner) => inner.span(),
12311 Self::ScopedIdentifier(inner) => inner.span(),
12312 Self::ScopedUseList(inner) => inner.span(),
12313 Self::SelfType(inner) => inner.span(),
12314 Self::Super(inner) => inner.span(),
12315 Self::UseAsClause(inner) => inner.span(),
12316 Self::UseList(inner) => inner.span(),
12317 Self::UseWildcard(inner) => inner.span(),
12318 }
12319 }
12320}
12321#[derive(Debug, Clone)]
12322pub enum UseWildcardChildren<'tree> {
12323 Crate(::std::boxed::Box<Crate<'tree>>),
12324 Identifier(::std::boxed::Box<Identifier<'tree>>),
12325 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12326 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12327 SelfType(::std::boxed::Box<SelfType<'tree>>),
12328 Super(::std::boxed::Box<Super<'tree>>),
12329}
12330impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcardChildren<'tree> {
12331 #[allow(clippy::collapsible_else_if)]
12332 fn from_node(
12333 node: ::tree_sitter::Node<'tree>,
12334 src: &'tree [u8],
12335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12336 match node.kind() {
12337 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12338 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12339 ))),
12340 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12341 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12342 ))),
12343 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12344 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12345 ))),
12346 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12347 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12348 ))),
12349 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12350 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12351 ))),
12352 "super" => Ok(Self::Super(::std::boxed::Box::new(
12353 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12354 ))),
12355 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12356 }
12357 }
12358}
12359impl ::treesitter_types::Spanned for UseWildcardChildren<'_> {
12360 fn span(&self) -> ::treesitter_types::Span {
12361 match self {
12362 Self::Crate(inner) => inner.span(),
12363 Self::Identifier(inner) => inner.span(),
12364 Self::Metavariable(inner) => inner.span(),
12365 Self::ScopedIdentifier(inner) => inner.span(),
12366 Self::SelfType(inner) => inner.span(),
12367 Self::Super(inner) => inner.span(),
12368 }
12369 }
12370}
12371#[derive(Debug, Clone)]
12372pub enum VisibilityModifierChildren<'tree> {
12373 Crate(::std::boxed::Box<Crate<'tree>>),
12374 Identifier(::std::boxed::Box<Identifier<'tree>>),
12375 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12376 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12377 SelfType(::std::boxed::Box<SelfType<'tree>>),
12378 Super(::std::boxed::Box<Super<'tree>>),
12379}
12380impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifierChildren<'tree> {
12381 #[allow(clippy::collapsible_else_if)]
12382 fn from_node(
12383 node: ::tree_sitter::Node<'tree>,
12384 src: &'tree [u8],
12385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12386 match node.kind() {
12387 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12388 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12389 ))),
12390 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12391 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12392 ))),
12393 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12394 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12395 ))),
12396 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12397 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12398 ))),
12399 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12400 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12401 ))),
12402 "super" => Ok(Self::Super(::std::boxed::Box::new(
12403 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12404 ))),
12405 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12406 }
12407 }
12408}
12409impl ::treesitter_types::Spanned for VisibilityModifierChildren<'_> {
12410 fn span(&self) -> ::treesitter_types::Span {
12411 match self {
12412 Self::Crate(inner) => inner.span(),
12413 Self::Identifier(inner) => inner.span(),
12414 Self::Metavariable(inner) => inner.span(),
12415 Self::ScopedIdentifier(inner) => inner.span(),
12416 Self::SelfType(inner) => inner.span(),
12417 Self::Super(inner) => inner.span(),
12418 }
12419 }
12420}
12421#[derive(Debug, Clone)]
12422pub enum WherePredicateLeft<'tree> {
12423 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
12424 GenericType(::std::boxed::Box<GenericType<'tree>>),
12425 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
12426 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12427 PointerType(::std::boxed::Box<PointerType<'tree>>),
12428 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12429 ReferenceType(::std::boxed::Box<ReferenceType<'tree>>),
12430 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12431 TupleType(::std::boxed::Box<TupleType<'tree>>),
12432 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12433}
12434impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicateLeft<'tree> {
12435 #[allow(clippy::collapsible_else_if)]
12436 fn from_node(
12437 node: ::tree_sitter::Node<'tree>,
12438 src: &'tree [u8],
12439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12440 match node.kind() {
12441 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
12442 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
12443 ))),
12444 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
12445 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
12446 ))),
12447 "higher_ranked_trait_bound" => {
12448 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
12449 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
12450 )))
12451 }
12452 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12453 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
12454 ))),
12455 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
12456 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
12457 ))),
12458 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12459 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12460 ))),
12461 "reference_type" => Ok(Self::ReferenceType(::std::boxed::Box::new(
12462 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)?,
12463 ))),
12464 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12465 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12466 ))),
12467 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
12468 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
12469 ))),
12470 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12471 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12472 ))),
12473 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12474 }
12475 }
12476}
12477impl ::treesitter_types::Spanned for WherePredicateLeft<'_> {
12478 fn span(&self) -> ::treesitter_types::Span {
12479 match self {
12480 Self::ArrayType(inner) => inner.span(),
12481 Self::GenericType(inner) => inner.span(),
12482 Self::HigherRankedTraitBound(inner) => inner.span(),
12483 Self::Lifetime(inner) => inner.span(),
12484 Self::PointerType(inner) => inner.span(),
12485 Self::PrimitiveType(inner) => inner.span(),
12486 Self::ReferenceType(inner) => inner.span(),
12487 Self::ScopedTypeIdentifier(inner) => inner.span(),
12488 Self::TupleType(inner) => inner.span(),
12489 Self::TypeIdentifier(inner) => inner.span(),
12490 }
12491 }
12492}
12493#[derive(Debug, Clone)]
12494pub enum WhileExpressionCondition<'tree> {
12495 Expression(::std::boxed::Box<Expression<'tree>>),
12496 LetChain(::std::boxed::Box<LetChain<'tree>>),
12497 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
12498}
12499impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpressionCondition<'tree> {
12500 #[allow(clippy::collapsible_else_if)]
12501 fn from_node(
12502 node: ::tree_sitter::Node<'tree>,
12503 src: &'tree [u8],
12504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12505 match node.kind() {
12506 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
12507 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
12508 ))),
12509 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
12510 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
12511 ))),
12512 _other => {
12513 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12514 Ok(Self::Expression(::std::boxed::Box::new(v)))
12515 } else {
12516 Err(::treesitter_types::ParseError::unexpected_kind(
12517 _other, node,
12518 ))
12519 }
12520 }
12521 }
12522 }
12523}
12524impl ::treesitter_types::Spanned for WhileExpressionCondition<'_> {
12525 fn span(&self) -> ::treesitter_types::Span {
12526 match self {
12527 Self::Expression(inner) => inner.span(),
12528 Self::LetChain(inner) => inner.span(),
12529 Self::LetCondition(inner) => inner.span(),
12530 }
12531 }
12532}
12533#[derive(Debug, Clone)]
12534pub enum AnyNode<'tree> {
12535 DeclarationStatement(DeclarationStatement<'tree>),
12536 Expression(Expression<'tree>),
12537 Literal(Literal<'tree>),
12538 LiteralPattern(LiteralPattern<'tree>),
12539 Pattern(Pattern<'tree>),
12540 Type(Type<'tree>),
12541 AbstractType(AbstractType<'tree>),
12542 Arguments(Arguments<'tree>),
12543 ArrayExpression(ArrayExpression<'tree>),
12544 ArrayType(ArrayType<'tree>),
12545 AssignmentExpression(AssignmentExpression<'tree>),
12546 AssociatedType(AssociatedType<'tree>),
12547 AsyncBlock(AsyncBlock<'tree>),
12548 Attribute(Attribute<'tree>),
12549 AttributeItem(AttributeItem<'tree>),
12550 AwaitExpression(AwaitExpression<'tree>),
12551 BaseFieldInitializer(BaseFieldInitializer<'tree>),
12552 BinaryExpression(BinaryExpression<'tree>),
12553 Block(Block<'tree>),
12554 BlockComment(BlockComment<'tree>),
12555 BooleanLiteral(BooleanLiteral<'tree>),
12556 BoundedType(BoundedType<'tree>),
12557 BracketedType(BracketedType<'tree>),
12558 BreakExpression(BreakExpression<'tree>),
12559 CallExpression(CallExpression<'tree>),
12560 CapturedPattern(CapturedPattern<'tree>),
12561 ClosureExpression(ClosureExpression<'tree>),
12562 ClosureParameters(ClosureParameters<'tree>),
12563 CompoundAssignmentExpr(CompoundAssignmentExpr<'tree>),
12564 ConstBlock(ConstBlock<'tree>),
12565 ConstItem(ConstItem<'tree>),
12566 ConstParameter(ConstParameter<'tree>),
12567 ContinueExpression(ContinueExpression<'tree>),
12568 DeclarationList(DeclarationList<'tree>),
12569 DynamicType(DynamicType<'tree>),
12570 ElseClause(ElseClause<'tree>),
12571 EmptyStatement(EmptyStatement<'tree>),
12572 EnumItem(EnumItem<'tree>),
12573 EnumVariant(EnumVariant<'tree>),
12574 EnumVariantList(EnumVariantList<'tree>),
12575 ExpressionStatement(ExpressionStatement<'tree>),
12576 ExternCrateDeclaration(ExternCrateDeclaration<'tree>),
12577 ExternModifier(ExternModifier<'tree>),
12578 FieldDeclaration(FieldDeclaration<'tree>),
12579 FieldDeclarationList(FieldDeclarationList<'tree>),
12580 FieldExpression(FieldExpression<'tree>),
12581 FieldInitializer(FieldInitializer<'tree>),
12582 FieldInitializerList(FieldInitializerList<'tree>),
12583 FieldPattern(FieldPattern<'tree>),
12584 ForExpression(ForExpression<'tree>),
12585 ForLifetimes(ForLifetimes<'tree>),
12586 ForeignModItem(ForeignModItem<'tree>),
12587 FragmentSpecifier(FragmentSpecifier<'tree>),
12588 FunctionItem(FunctionItem<'tree>),
12589 FunctionModifiers(FunctionModifiers<'tree>),
12590 FunctionSignatureItem(FunctionSignatureItem<'tree>),
12591 FunctionType(FunctionType<'tree>),
12592 GenBlock(GenBlock<'tree>),
12593 GenericFunction(GenericFunction<'tree>),
12594 GenericPattern(GenericPattern<'tree>),
12595 GenericType(GenericType<'tree>),
12596 GenericTypeWithTurbofish(GenericTypeWithTurbofish<'tree>),
12597 HigherRankedTraitBound(HigherRankedTraitBound<'tree>),
12598 IfExpression(IfExpression<'tree>),
12599 ImplItem(ImplItem<'tree>),
12600 IndexExpression(IndexExpression<'tree>),
12601 InnerAttributeItem(InnerAttributeItem<'tree>),
12602 InnerDocCommentMarker(InnerDocCommentMarker<'tree>),
12603 Label(Label<'tree>),
12604 LetChain(LetChain<'tree>),
12605 LetCondition(LetCondition<'tree>),
12606 LetDeclaration(LetDeclaration<'tree>),
12607 Lifetime(Lifetime<'tree>),
12608 LifetimeParameter(LifetimeParameter<'tree>),
12609 LineComment(LineComment<'tree>),
12610 LoopExpression(LoopExpression<'tree>),
12611 MacroDefinition(MacroDefinition<'tree>),
12612 MacroInvocation(MacroInvocation<'tree>),
12613 MacroRule(MacroRule<'tree>),
12614 MatchArm(MatchArm<'tree>),
12615 MatchBlock(MatchBlock<'tree>),
12616 MatchExpression(MatchExpression<'tree>),
12617 MatchPattern(MatchPattern<'tree>),
12618 ModItem(ModItem<'tree>),
12619 MutPattern(MutPattern<'tree>),
12620 NegativeLiteral(NegativeLiteral<'tree>),
12621 NeverType(NeverType<'tree>),
12622 OrPattern(OrPattern<'tree>),
12623 OrderedFieldDeclarationList(OrderedFieldDeclarationList<'tree>),
12624 OuterDocCommentMarker(OuterDocCommentMarker<'tree>),
12625 Parameter(Parameter<'tree>),
12626 Parameters(Parameters<'tree>),
12627 ParenthesizedExpression(ParenthesizedExpression<'tree>),
12628 PointerType(PointerType<'tree>),
12629 QualifiedType(QualifiedType<'tree>),
12630 RangeExpression(RangeExpression<'tree>),
12631 RangePattern(RangePattern<'tree>),
12632 RawStringLiteral(RawStringLiteral<'tree>),
12633 RefPattern(RefPattern<'tree>),
12634 ReferenceExpression(ReferenceExpression<'tree>),
12635 ReferencePattern(ReferencePattern<'tree>),
12636 ReferenceType(ReferenceType<'tree>),
12637 RemainingFieldPattern(RemainingFieldPattern<'tree>),
12638 RemovedTraitBound(RemovedTraitBound<'tree>),
12639 ReturnExpression(ReturnExpression<'tree>),
12640 ScopedIdentifier(ScopedIdentifier<'tree>),
12641 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
12642 ScopedUseList(ScopedUseList<'tree>),
12643 SelfParameter(SelfParameter<'tree>),
12644 ShorthandFieldInitializer(ShorthandFieldInitializer<'tree>),
12645 SlicePattern(SlicePattern<'tree>),
12646 SourceFile(SourceFile<'tree>),
12647 StaticItem(StaticItem<'tree>),
12648 StringLiteral(StringLiteral<'tree>),
12649 StructExpression(StructExpression<'tree>),
12650 StructItem(StructItem<'tree>),
12651 StructPattern(StructPattern<'tree>),
12652 TokenBindingPattern(TokenBindingPattern<'tree>),
12653 TokenRepetition(TokenRepetition<'tree>),
12654 TokenRepetitionPattern(TokenRepetitionPattern<'tree>),
12655 TokenTree(TokenTree<'tree>),
12656 TokenTreePattern(TokenTreePattern<'tree>),
12657 TraitBounds(TraitBounds<'tree>),
12658 TraitItem(TraitItem<'tree>),
12659 TryBlock(TryBlock<'tree>),
12660 TryExpression(TryExpression<'tree>),
12661 TupleExpression(TupleExpression<'tree>),
12662 TuplePattern(TuplePattern<'tree>),
12663 TupleStructPattern(TupleStructPattern<'tree>),
12664 TupleType(TupleType<'tree>),
12665 TypeArguments(TypeArguments<'tree>),
12666 TypeBinding(TypeBinding<'tree>),
12667 TypeCastExpression(TypeCastExpression<'tree>),
12668 TypeItem(TypeItem<'tree>),
12669 TypeParameter(TypeParameter<'tree>),
12670 TypeParameters(TypeParameters<'tree>),
12671 UnaryExpression(UnaryExpression<'tree>),
12672 UnionItem(UnionItem<'tree>),
12673 UnitExpression(UnitExpression<'tree>),
12674 UnitType(UnitType<'tree>),
12675 UnsafeBlock(UnsafeBlock<'tree>),
12676 UseAsClause(UseAsClause<'tree>),
12677 UseBounds(UseBounds<'tree>),
12678 UseDeclaration(UseDeclaration<'tree>),
12679 UseList(UseList<'tree>),
12680 UseWildcard(UseWildcard<'tree>),
12681 VariadicParameter(VariadicParameter<'tree>),
12682 VisibilityModifier(VisibilityModifier<'tree>),
12683 WhereClause(WhereClause<'tree>),
12684 WherePredicate(WherePredicate<'tree>),
12685 WhileExpression(WhileExpression<'tree>),
12686 YieldExpression(YieldExpression<'tree>),
12687 CharLiteral(CharLiteral<'tree>),
12688 Crate(Crate<'tree>),
12689 DocComment(DocComment<'tree>),
12690 EscapeSequence(EscapeSequence<'tree>),
12691 FieldIdentifier(FieldIdentifier<'tree>),
12692 FloatLiteral(FloatLiteral<'tree>),
12693 Identifier(Identifier<'tree>),
12694 IntegerLiteral(IntegerLiteral<'tree>),
12695 Metavariable(Metavariable<'tree>),
12696 MutableSpecifier(MutableSpecifier<'tree>),
12697 PrimitiveType(PrimitiveType<'tree>),
12698 SelfType(SelfType<'tree>),
12699 Shebang(Shebang<'tree>),
12700 ShorthandFieldIdentifier(ShorthandFieldIdentifier<'tree>),
12701 StringContent(StringContent<'tree>),
12702 Super(Super<'tree>),
12703 TypeIdentifier(TypeIdentifier<'tree>),
12704 Unknown(::tree_sitter::Node<'tree>),
12705}
12706impl<'tree> AnyNode<'tree> {
12707 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
12708 match node.kind() {
12709 "_declaration_statement" => {
12710 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
12711 .map(Self::DeclarationStatement)
12712 .unwrap_or(Self::Unknown(node))
12713 }
12714 "_expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12715 .map(Self::Expression)
12716 .unwrap_or(Self::Unknown(node)),
12717 "_literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
12718 .map(Self::Literal)
12719 .unwrap_or(Self::Unknown(node)),
12720 "_literal_pattern" => {
12721 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
12722 .map(Self::LiteralPattern)
12723 .unwrap_or(Self::Unknown(node))
12724 }
12725 "_pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12726 .map(Self::Pattern)
12727 .unwrap_or(Self::Unknown(node)),
12728 "_type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
12729 .map(Self::Type)
12730 .unwrap_or(Self::Unknown(node)),
12731 "abstract_type" => <AbstractType as ::treesitter_types::FromNode>::from_node(node, src)
12732 .map(Self::AbstractType)
12733 .unwrap_or(Self::Unknown(node)),
12734 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
12735 .map(Self::Arguments)
12736 .unwrap_or(Self::Unknown(node)),
12737 "array_expression" => {
12738 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)
12739 .map(Self::ArrayExpression)
12740 .unwrap_or(Self::Unknown(node))
12741 }
12742 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
12743 .map(Self::ArrayType)
12744 .unwrap_or(Self::Unknown(node)),
12745 "assignment_expression" => {
12746 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
12747 .map(Self::AssignmentExpression)
12748 .unwrap_or(Self::Unknown(node))
12749 }
12750 "associated_type" => {
12751 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
12752 .map(Self::AssociatedType)
12753 .unwrap_or(Self::Unknown(node))
12754 }
12755 "async_block" => <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)
12756 .map(Self::AsyncBlock)
12757 .unwrap_or(Self::Unknown(node)),
12758 "attribute" => <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
12759 .map(Self::Attribute)
12760 .unwrap_or(Self::Unknown(node)),
12761 "attribute_item" => {
12762 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12763 .map(Self::AttributeItem)
12764 .unwrap_or(Self::Unknown(node))
12765 }
12766 "await_expression" => {
12767 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
12768 .map(Self::AwaitExpression)
12769 .unwrap_or(Self::Unknown(node))
12770 }
12771 "base_field_initializer" => {
12772 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12773 .map(Self::BaseFieldInitializer)
12774 .unwrap_or(Self::Unknown(node))
12775 }
12776 "binary_expression" => {
12777 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12778 .map(Self::BinaryExpression)
12779 .unwrap_or(Self::Unknown(node))
12780 }
12781 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
12782 .map(Self::Block)
12783 .unwrap_or(Self::Unknown(node)),
12784 "block_comment" => <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
12785 .map(Self::BlockComment)
12786 .unwrap_or(Self::Unknown(node)),
12787 "boolean_literal" => {
12788 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12789 .map(Self::BooleanLiteral)
12790 .unwrap_or(Self::Unknown(node))
12791 }
12792 "bounded_type" => <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)
12793 .map(Self::BoundedType)
12794 .unwrap_or(Self::Unknown(node)),
12795 "bracketed_type" => {
12796 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)
12797 .map(Self::BracketedType)
12798 .unwrap_or(Self::Unknown(node))
12799 }
12800 "break_expression" => {
12801 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)
12802 .map(Self::BreakExpression)
12803 .unwrap_or(Self::Unknown(node))
12804 }
12805 "call_expression" => {
12806 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12807 .map(Self::CallExpression)
12808 .unwrap_or(Self::Unknown(node))
12809 }
12810 "captured_pattern" => {
12811 <CapturedPattern as ::treesitter_types::FromNode>::from_node(node, src)
12812 .map(Self::CapturedPattern)
12813 .unwrap_or(Self::Unknown(node))
12814 }
12815 "closure_expression" => {
12816 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
12817 .map(Self::ClosureExpression)
12818 .unwrap_or(Self::Unknown(node))
12819 }
12820 "closure_parameters" => {
12821 <ClosureParameters as ::treesitter_types::FromNode>::from_node(node, src)
12822 .map(Self::ClosureParameters)
12823 .unwrap_or(Self::Unknown(node))
12824 }
12825 "compound_assignment_expr" => {
12826 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)
12827 .map(Self::CompoundAssignmentExpr)
12828 .unwrap_or(Self::Unknown(node))
12829 }
12830 "const_block" => <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
12831 .map(Self::ConstBlock)
12832 .unwrap_or(Self::Unknown(node)),
12833 "const_item" => <ConstItem as ::treesitter_types::FromNode>::from_node(node, src)
12834 .map(Self::ConstItem)
12835 .unwrap_or(Self::Unknown(node)),
12836 "const_parameter" => {
12837 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)
12838 .map(Self::ConstParameter)
12839 .unwrap_or(Self::Unknown(node))
12840 }
12841 "continue_expression" => {
12842 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)
12843 .map(Self::ContinueExpression)
12844 .unwrap_or(Self::Unknown(node))
12845 }
12846 "declaration_list" => {
12847 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
12848 .map(Self::DeclarationList)
12849 .unwrap_or(Self::Unknown(node))
12850 }
12851 "dynamic_type" => <DynamicType as ::treesitter_types::FromNode>::from_node(node, src)
12852 .map(Self::DynamicType)
12853 .unwrap_or(Self::Unknown(node)),
12854 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
12855 .map(Self::ElseClause)
12856 .unwrap_or(Self::Unknown(node)),
12857 "empty_statement" => {
12858 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
12859 .map(Self::EmptyStatement)
12860 .unwrap_or(Self::Unknown(node))
12861 }
12862 "enum_item" => <EnumItem as ::treesitter_types::FromNode>::from_node(node, src)
12863 .map(Self::EnumItem)
12864 .unwrap_or(Self::Unknown(node)),
12865 "enum_variant" => <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)
12866 .map(Self::EnumVariant)
12867 .unwrap_or(Self::Unknown(node)),
12868 "enum_variant_list" => {
12869 <EnumVariantList as ::treesitter_types::FromNode>::from_node(node, src)
12870 .map(Self::EnumVariantList)
12871 .unwrap_or(Self::Unknown(node))
12872 }
12873 "expression_statement" => {
12874 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
12875 .map(Self::ExpressionStatement)
12876 .unwrap_or(Self::Unknown(node))
12877 }
12878 "extern_crate_declaration" => {
12879 <ExternCrateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12880 .map(Self::ExternCrateDeclaration)
12881 .unwrap_or(Self::Unknown(node))
12882 }
12883 "extern_modifier" => {
12884 <ExternModifier as ::treesitter_types::FromNode>::from_node(node, src)
12885 .map(Self::ExternModifier)
12886 .unwrap_or(Self::Unknown(node))
12887 }
12888 "field_declaration" => {
12889 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12890 .map(Self::FieldDeclaration)
12891 .unwrap_or(Self::Unknown(node))
12892 }
12893 "field_declaration_list" => {
12894 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
12895 .map(Self::FieldDeclarationList)
12896 .unwrap_or(Self::Unknown(node))
12897 }
12898 "field_expression" => {
12899 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
12900 .map(Self::FieldExpression)
12901 .unwrap_or(Self::Unknown(node))
12902 }
12903 "field_initializer" => {
12904 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
12905 .map(Self::FieldInitializer)
12906 .unwrap_or(Self::Unknown(node))
12907 }
12908 "field_initializer_list" => {
12909 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
12910 .map(Self::FieldInitializerList)
12911 .unwrap_or(Self::Unknown(node))
12912 }
12913 "field_pattern" => <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
12914 .map(Self::FieldPattern)
12915 .unwrap_or(Self::Unknown(node)),
12916 "for_expression" => {
12917 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)
12918 .map(Self::ForExpression)
12919 .unwrap_or(Self::Unknown(node))
12920 }
12921 "for_lifetimes" => <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)
12922 .map(Self::ForLifetimes)
12923 .unwrap_or(Self::Unknown(node)),
12924 "foreign_mod_item" => {
12925 <ForeignModItem as ::treesitter_types::FromNode>::from_node(node, src)
12926 .map(Self::ForeignModItem)
12927 .unwrap_or(Self::Unknown(node))
12928 }
12929 "fragment_specifier" => {
12930 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12931 .map(Self::FragmentSpecifier)
12932 .unwrap_or(Self::Unknown(node))
12933 }
12934 "function_item" => <FunctionItem as ::treesitter_types::FromNode>::from_node(node, src)
12935 .map(Self::FunctionItem)
12936 .unwrap_or(Self::Unknown(node)),
12937 "function_modifiers" => {
12938 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
12939 .map(Self::FunctionModifiers)
12940 .unwrap_or(Self::Unknown(node))
12941 }
12942 "function_signature_item" => {
12943 <FunctionSignatureItem as ::treesitter_types::FromNode>::from_node(node, src)
12944 .map(Self::FunctionSignatureItem)
12945 .unwrap_or(Self::Unknown(node))
12946 }
12947 "function_type" => <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
12948 .map(Self::FunctionType)
12949 .unwrap_or(Self::Unknown(node)),
12950 "gen_block" => <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)
12951 .map(Self::GenBlock)
12952 .unwrap_or(Self::Unknown(node)),
12953 "generic_function" => {
12954 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)
12955 .map(Self::GenericFunction)
12956 .unwrap_or(Self::Unknown(node))
12957 }
12958 "generic_pattern" => {
12959 <GenericPattern as ::treesitter_types::FromNode>::from_node(node, src)
12960 .map(Self::GenericPattern)
12961 .unwrap_or(Self::Unknown(node))
12962 }
12963 "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
12964 .map(Self::GenericType)
12965 .unwrap_or(Self::Unknown(node)),
12966 "generic_type_with_turbofish" => {
12967 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(node, src)
12968 .map(Self::GenericTypeWithTurbofish)
12969 .unwrap_or(Self::Unknown(node))
12970 }
12971 "higher_ranked_trait_bound" => {
12972 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
12973 .map(Self::HigherRankedTraitBound)
12974 .unwrap_or(Self::Unknown(node))
12975 }
12976 "if_expression" => <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
12977 .map(Self::IfExpression)
12978 .unwrap_or(Self::Unknown(node)),
12979 "impl_item" => <ImplItem as ::treesitter_types::FromNode>::from_node(node, src)
12980 .map(Self::ImplItem)
12981 .unwrap_or(Self::Unknown(node)),
12982 "index_expression" => {
12983 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
12984 .map(Self::IndexExpression)
12985 .unwrap_or(Self::Unknown(node))
12986 }
12987 "inner_attribute_item" => {
12988 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
12989 .map(Self::InnerAttributeItem)
12990 .unwrap_or(Self::Unknown(node))
12991 }
12992 "inner_doc_comment_marker" => {
12993 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
12994 .map(Self::InnerDocCommentMarker)
12995 .unwrap_or(Self::Unknown(node))
12996 }
12997 "label" => <Label as ::treesitter_types::FromNode>::from_node(node, src)
12998 .map(Self::Label)
12999 .unwrap_or(Self::Unknown(node)),
13000 "let_chain" => <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
13001 .map(Self::LetChain)
13002 .unwrap_or(Self::Unknown(node)),
13003 "let_condition" => <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
13004 .map(Self::LetCondition)
13005 .unwrap_or(Self::Unknown(node)),
13006 "let_declaration" => {
13007 <LetDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13008 .map(Self::LetDeclaration)
13009 .unwrap_or(Self::Unknown(node))
13010 }
13011 "lifetime" => <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
13012 .map(Self::Lifetime)
13013 .unwrap_or(Self::Unknown(node)),
13014 "lifetime_parameter" => {
13015 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)
13016 .map(Self::LifetimeParameter)
13017 .unwrap_or(Self::Unknown(node))
13018 }
13019 "line_comment" => <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
13020 .map(Self::LineComment)
13021 .unwrap_or(Self::Unknown(node)),
13022 "loop_expression" => {
13023 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)
13024 .map(Self::LoopExpression)
13025 .unwrap_or(Self::Unknown(node))
13026 }
13027 "macro_definition" => {
13028 <MacroDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13029 .map(Self::MacroDefinition)
13030 .unwrap_or(Self::Unknown(node))
13031 }
13032 "macro_invocation" => {
13033 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
13034 .map(Self::MacroInvocation)
13035 .unwrap_or(Self::Unknown(node))
13036 }
13037 "macro_rule" => <MacroRule as ::treesitter_types::FromNode>::from_node(node, src)
13038 .map(Self::MacroRule)
13039 .unwrap_or(Self::Unknown(node)),
13040 "match_arm" => <MatchArm as ::treesitter_types::FromNode>::from_node(node, src)
13041 .map(Self::MatchArm)
13042 .unwrap_or(Self::Unknown(node)),
13043 "match_block" => <MatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
13044 .map(Self::MatchBlock)
13045 .unwrap_or(Self::Unknown(node)),
13046 "match_expression" => {
13047 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
13048 .map(Self::MatchExpression)
13049 .unwrap_or(Self::Unknown(node))
13050 }
13051 "match_pattern" => <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
13052 .map(Self::MatchPattern)
13053 .unwrap_or(Self::Unknown(node)),
13054 "mod_item" => <ModItem as ::treesitter_types::FromNode>::from_node(node, src)
13055 .map(Self::ModItem)
13056 .unwrap_or(Self::Unknown(node)),
13057 "mut_pattern" => <MutPattern as ::treesitter_types::FromNode>::from_node(node, src)
13058 .map(Self::MutPattern)
13059 .unwrap_or(Self::Unknown(node)),
13060 "negative_literal" => {
13061 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13062 .map(Self::NegativeLiteral)
13063 .unwrap_or(Self::Unknown(node))
13064 }
13065 "never_type" => <NeverType as ::treesitter_types::FromNode>::from_node(node, src)
13066 .map(Self::NeverType)
13067 .unwrap_or(Self::Unknown(node)),
13068 "or_pattern" => <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
13069 .map(Self::OrPattern)
13070 .unwrap_or(Self::Unknown(node)),
13071 "ordered_field_declaration_list" => {
13072 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
13073 .map(Self::OrderedFieldDeclarationList)
13074 .unwrap_or(Self::Unknown(node))
13075 }
13076 "outer_doc_comment_marker" => {
13077 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
13078 .map(Self::OuterDocCommentMarker)
13079 .unwrap_or(Self::Unknown(node))
13080 }
13081 "parameter" => <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
13082 .map(Self::Parameter)
13083 .unwrap_or(Self::Unknown(node)),
13084 "parameters" => <Parameters as ::treesitter_types::FromNode>::from_node(node, src)
13085 .map(Self::Parameters)
13086 .unwrap_or(Self::Unknown(node)),
13087 "parenthesized_expression" => {
13088 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13089 .map(Self::ParenthesizedExpression)
13090 .unwrap_or(Self::Unknown(node))
13091 }
13092 "pointer_type" => <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
13093 .map(Self::PointerType)
13094 .unwrap_or(Self::Unknown(node)),
13095 "qualified_type" => {
13096 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
13097 .map(Self::QualifiedType)
13098 .unwrap_or(Self::Unknown(node))
13099 }
13100 "range_expression" => {
13101 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
13102 .map(Self::RangeExpression)
13103 .unwrap_or(Self::Unknown(node))
13104 }
13105 "range_pattern" => <RangePattern as ::treesitter_types::FromNode>::from_node(node, src)
13106 .map(Self::RangePattern)
13107 .unwrap_or(Self::Unknown(node)),
13108 "raw_string_literal" => {
13109 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13110 .map(Self::RawStringLiteral)
13111 .unwrap_or(Self::Unknown(node))
13112 }
13113 "ref_pattern" => <RefPattern as ::treesitter_types::FromNode>::from_node(node, src)
13114 .map(Self::RefPattern)
13115 .unwrap_or(Self::Unknown(node)),
13116 "reference_expression" => {
13117 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
13118 .map(Self::ReferenceExpression)
13119 .unwrap_or(Self::Unknown(node))
13120 }
13121 "reference_pattern" => {
13122 <ReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
13123 .map(Self::ReferencePattern)
13124 .unwrap_or(Self::Unknown(node))
13125 }
13126 "reference_type" => {
13127 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)
13128 .map(Self::ReferenceType)
13129 .unwrap_or(Self::Unknown(node))
13130 }
13131 "remaining_field_pattern" => {
13132 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
13133 .map(Self::RemainingFieldPattern)
13134 .unwrap_or(Self::Unknown(node))
13135 }
13136 "removed_trait_bound" => {
13137 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
13138 .map(Self::RemovedTraitBound)
13139 .unwrap_or(Self::Unknown(node))
13140 }
13141 "return_expression" => {
13142 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)
13143 .map(Self::ReturnExpression)
13144 .unwrap_or(Self::Unknown(node))
13145 }
13146 "scoped_identifier" => {
13147 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13148 .map(Self::ScopedIdentifier)
13149 .unwrap_or(Self::Unknown(node))
13150 }
13151 "scoped_type_identifier" => {
13152 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13153 .map(Self::ScopedTypeIdentifier)
13154 .unwrap_or(Self::Unknown(node))
13155 }
13156 "scoped_use_list" => {
13157 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)
13158 .map(Self::ScopedUseList)
13159 .unwrap_or(Self::Unknown(node))
13160 }
13161 "self_parameter" => {
13162 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)
13163 .map(Self::SelfParameter)
13164 .unwrap_or(Self::Unknown(node))
13165 }
13166 "shorthand_field_initializer" => {
13167 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
13168 .map(Self::ShorthandFieldInitializer)
13169 .unwrap_or(Self::Unknown(node))
13170 }
13171 "slice_pattern" => <SlicePattern as ::treesitter_types::FromNode>::from_node(node, src)
13172 .map(Self::SlicePattern)
13173 .unwrap_or(Self::Unknown(node)),
13174 "source_file" => <SourceFile as ::treesitter_types::FromNode>::from_node(node, src)
13175 .map(Self::SourceFile)
13176 .unwrap_or(Self::Unknown(node)),
13177 "static_item" => <StaticItem as ::treesitter_types::FromNode>::from_node(node, src)
13178 .map(Self::StaticItem)
13179 .unwrap_or(Self::Unknown(node)),
13180 "string_literal" => {
13181 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13182 .map(Self::StringLiteral)
13183 .unwrap_or(Self::Unknown(node))
13184 }
13185 "struct_expression" => {
13186 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)
13187 .map(Self::StructExpression)
13188 .unwrap_or(Self::Unknown(node))
13189 }
13190 "struct_item" => <StructItem as ::treesitter_types::FromNode>::from_node(node, src)
13191 .map(Self::StructItem)
13192 .unwrap_or(Self::Unknown(node)),
13193 "struct_pattern" => {
13194 <StructPattern as ::treesitter_types::FromNode>::from_node(node, src)
13195 .map(Self::StructPattern)
13196 .unwrap_or(Self::Unknown(node))
13197 }
13198 "token_binding_pattern" => {
13199 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)
13200 .map(Self::TokenBindingPattern)
13201 .unwrap_or(Self::Unknown(node))
13202 }
13203 "token_repetition" => {
13204 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)
13205 .map(Self::TokenRepetition)
13206 .unwrap_or(Self::Unknown(node))
13207 }
13208 "token_repetition_pattern" => {
13209 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)
13210 .map(Self::TokenRepetitionPattern)
13211 .unwrap_or(Self::Unknown(node))
13212 }
13213 "token_tree" => <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)
13214 .map(Self::TokenTree)
13215 .unwrap_or(Self::Unknown(node)),
13216 "token_tree_pattern" => {
13217 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)
13218 .map(Self::TokenTreePattern)
13219 .unwrap_or(Self::Unknown(node))
13220 }
13221 "trait_bounds" => <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)
13222 .map(Self::TraitBounds)
13223 .unwrap_or(Self::Unknown(node)),
13224 "trait_item" => <TraitItem as ::treesitter_types::FromNode>::from_node(node, src)
13225 .map(Self::TraitItem)
13226 .unwrap_or(Self::Unknown(node)),
13227 "try_block" => <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)
13228 .map(Self::TryBlock)
13229 .unwrap_or(Self::Unknown(node)),
13230 "try_expression" => {
13231 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13232 .map(Self::TryExpression)
13233 .unwrap_or(Self::Unknown(node))
13234 }
13235 "tuple_expression" => {
13236 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
13237 .map(Self::TupleExpression)
13238 .unwrap_or(Self::Unknown(node))
13239 }
13240 "tuple_pattern" => <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
13241 .map(Self::TuplePattern)
13242 .unwrap_or(Self::Unknown(node)),
13243 "tuple_struct_pattern" => {
13244 <TupleStructPattern as ::treesitter_types::FromNode>::from_node(node, src)
13245 .map(Self::TupleStructPattern)
13246 .unwrap_or(Self::Unknown(node))
13247 }
13248 "tuple_type" => <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
13249 .map(Self::TupleType)
13250 .unwrap_or(Self::Unknown(node)),
13251 "type_arguments" => {
13252 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
13253 .map(Self::TypeArguments)
13254 .unwrap_or(Self::Unknown(node))
13255 }
13256 "type_binding" => <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)
13257 .map(Self::TypeBinding)
13258 .unwrap_or(Self::Unknown(node)),
13259 "type_cast_expression" => {
13260 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)
13261 .map(Self::TypeCastExpression)
13262 .unwrap_or(Self::Unknown(node))
13263 }
13264 "type_item" => <TypeItem as ::treesitter_types::FromNode>::from_node(node, src)
13265 .map(Self::TypeItem)
13266 .unwrap_or(Self::Unknown(node)),
13267 "type_parameter" => {
13268 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
13269 .map(Self::TypeParameter)
13270 .unwrap_or(Self::Unknown(node))
13271 }
13272 "type_parameters" => {
13273 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
13274 .map(Self::TypeParameters)
13275 .unwrap_or(Self::Unknown(node))
13276 }
13277 "unary_expression" => {
13278 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13279 .map(Self::UnaryExpression)
13280 .unwrap_or(Self::Unknown(node))
13281 }
13282 "union_item" => <UnionItem as ::treesitter_types::FromNode>::from_node(node, src)
13283 .map(Self::UnionItem)
13284 .unwrap_or(Self::Unknown(node)),
13285 "unit_expression" => {
13286 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)
13287 .map(Self::UnitExpression)
13288 .unwrap_or(Self::Unknown(node))
13289 }
13290 "unit_type" => <UnitType as ::treesitter_types::FromNode>::from_node(node, src)
13291 .map(Self::UnitType)
13292 .unwrap_or(Self::Unknown(node)),
13293 "unsafe_block" => <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)
13294 .map(Self::UnsafeBlock)
13295 .unwrap_or(Self::Unknown(node)),
13296 "use_as_clause" => <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
13297 .map(Self::UseAsClause)
13298 .unwrap_or(Self::Unknown(node)),
13299 "use_bounds" => <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)
13300 .map(Self::UseBounds)
13301 .unwrap_or(Self::Unknown(node)),
13302 "use_declaration" => {
13303 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13304 .map(Self::UseDeclaration)
13305 .unwrap_or(Self::Unknown(node))
13306 }
13307 "use_list" => <UseList as ::treesitter_types::FromNode>::from_node(node, src)
13308 .map(Self::UseList)
13309 .unwrap_or(Self::Unknown(node)),
13310 "use_wildcard" => <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)
13311 .map(Self::UseWildcard)
13312 .unwrap_or(Self::Unknown(node)),
13313 "variadic_parameter" => {
13314 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
13315 .map(Self::VariadicParameter)
13316 .unwrap_or(Self::Unknown(node))
13317 }
13318 "visibility_modifier" => {
13319 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13320 .map(Self::VisibilityModifier)
13321 .unwrap_or(Self::Unknown(node))
13322 }
13323 "where_clause" => <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
13324 .map(Self::WhereClause)
13325 .unwrap_or(Self::Unknown(node)),
13326 "where_predicate" => {
13327 <WherePredicate as ::treesitter_types::FromNode>::from_node(node, src)
13328 .map(Self::WherePredicate)
13329 .unwrap_or(Self::Unknown(node))
13330 }
13331 "while_expression" => {
13332 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)
13333 .map(Self::WhileExpression)
13334 .unwrap_or(Self::Unknown(node))
13335 }
13336 "yield_expression" => {
13337 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
13338 .map(Self::YieldExpression)
13339 .unwrap_or(Self::Unknown(node))
13340 }
13341 "char_literal" => <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13342 .map(Self::CharLiteral)
13343 .unwrap_or(Self::Unknown(node)),
13344 "crate" => <Crate as ::treesitter_types::FromNode>::from_node(node, src)
13345 .map(Self::Crate)
13346 .unwrap_or(Self::Unknown(node)),
13347 "doc_comment" => <DocComment as ::treesitter_types::FromNode>::from_node(node, src)
13348 .map(Self::DocComment)
13349 .unwrap_or(Self::Unknown(node)),
13350 "escape_sequence" => {
13351 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
13352 .map(Self::EscapeSequence)
13353 .unwrap_or(Self::Unknown(node))
13354 }
13355 "field_identifier" => {
13356 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13357 .map(Self::FieldIdentifier)
13358 .unwrap_or(Self::Unknown(node))
13359 }
13360 "float_literal" => <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13361 .map(Self::FloatLiteral)
13362 .unwrap_or(Self::Unknown(node)),
13363 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
13364 .map(Self::Identifier)
13365 .unwrap_or(Self::Unknown(node)),
13366 "integer_literal" => {
13367 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13368 .map(Self::IntegerLiteral)
13369 .unwrap_or(Self::Unknown(node))
13370 }
13371 "metavariable" => <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
13372 .map(Self::Metavariable)
13373 .unwrap_or(Self::Unknown(node)),
13374 "mutable_specifier" => {
13375 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13376 .map(Self::MutableSpecifier)
13377 .unwrap_or(Self::Unknown(node))
13378 }
13379 "primitive_type" => {
13380 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13381 .map(Self::PrimitiveType)
13382 .unwrap_or(Self::Unknown(node))
13383 }
13384 "self" => <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
13385 .map(Self::SelfType)
13386 .unwrap_or(Self::Unknown(node)),
13387 "shebang" => <Shebang as ::treesitter_types::FromNode>::from_node(node, src)
13388 .map(Self::Shebang)
13389 .unwrap_or(Self::Unknown(node)),
13390 "shorthand_field_identifier" => {
13391 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13392 .map(Self::ShorthandFieldIdentifier)
13393 .unwrap_or(Self::Unknown(node))
13394 }
13395 "string_content" => {
13396 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
13397 .map(Self::StringContent)
13398 .unwrap_or(Self::Unknown(node))
13399 }
13400 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
13401 .map(Self::Super)
13402 .unwrap_or(Self::Unknown(node)),
13403 "type_identifier" => {
13404 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13405 .map(Self::TypeIdentifier)
13406 .unwrap_or(Self::Unknown(node))
13407 }
13408 _ => Self::Unknown(node),
13409 }
13410 }
13411}
13412impl ::treesitter_types::Spanned for AnyNode<'_> {
13413 fn span(&self) -> ::treesitter_types::Span {
13414 match self {
13415 Self::DeclarationStatement(inner) => inner.span(),
13416 Self::Expression(inner) => inner.span(),
13417 Self::Literal(inner) => inner.span(),
13418 Self::LiteralPattern(inner) => inner.span(),
13419 Self::Pattern(inner) => inner.span(),
13420 Self::Type(inner) => inner.span(),
13421 Self::AbstractType(inner) => inner.span(),
13422 Self::Arguments(inner) => inner.span(),
13423 Self::ArrayExpression(inner) => inner.span(),
13424 Self::ArrayType(inner) => inner.span(),
13425 Self::AssignmentExpression(inner) => inner.span(),
13426 Self::AssociatedType(inner) => inner.span(),
13427 Self::AsyncBlock(inner) => inner.span(),
13428 Self::Attribute(inner) => inner.span(),
13429 Self::AttributeItem(inner) => inner.span(),
13430 Self::AwaitExpression(inner) => inner.span(),
13431 Self::BaseFieldInitializer(inner) => inner.span(),
13432 Self::BinaryExpression(inner) => inner.span(),
13433 Self::Block(inner) => inner.span(),
13434 Self::BlockComment(inner) => inner.span(),
13435 Self::BooleanLiteral(inner) => inner.span(),
13436 Self::BoundedType(inner) => inner.span(),
13437 Self::BracketedType(inner) => inner.span(),
13438 Self::BreakExpression(inner) => inner.span(),
13439 Self::CallExpression(inner) => inner.span(),
13440 Self::CapturedPattern(inner) => inner.span(),
13441 Self::ClosureExpression(inner) => inner.span(),
13442 Self::ClosureParameters(inner) => inner.span(),
13443 Self::CompoundAssignmentExpr(inner) => inner.span(),
13444 Self::ConstBlock(inner) => inner.span(),
13445 Self::ConstItem(inner) => inner.span(),
13446 Self::ConstParameter(inner) => inner.span(),
13447 Self::ContinueExpression(inner) => inner.span(),
13448 Self::DeclarationList(inner) => inner.span(),
13449 Self::DynamicType(inner) => inner.span(),
13450 Self::ElseClause(inner) => inner.span(),
13451 Self::EmptyStatement(inner) => inner.span(),
13452 Self::EnumItem(inner) => inner.span(),
13453 Self::EnumVariant(inner) => inner.span(),
13454 Self::EnumVariantList(inner) => inner.span(),
13455 Self::ExpressionStatement(inner) => inner.span(),
13456 Self::ExternCrateDeclaration(inner) => inner.span(),
13457 Self::ExternModifier(inner) => inner.span(),
13458 Self::FieldDeclaration(inner) => inner.span(),
13459 Self::FieldDeclarationList(inner) => inner.span(),
13460 Self::FieldExpression(inner) => inner.span(),
13461 Self::FieldInitializer(inner) => inner.span(),
13462 Self::FieldInitializerList(inner) => inner.span(),
13463 Self::FieldPattern(inner) => inner.span(),
13464 Self::ForExpression(inner) => inner.span(),
13465 Self::ForLifetimes(inner) => inner.span(),
13466 Self::ForeignModItem(inner) => inner.span(),
13467 Self::FragmentSpecifier(inner) => inner.span(),
13468 Self::FunctionItem(inner) => inner.span(),
13469 Self::FunctionModifiers(inner) => inner.span(),
13470 Self::FunctionSignatureItem(inner) => inner.span(),
13471 Self::FunctionType(inner) => inner.span(),
13472 Self::GenBlock(inner) => inner.span(),
13473 Self::GenericFunction(inner) => inner.span(),
13474 Self::GenericPattern(inner) => inner.span(),
13475 Self::GenericType(inner) => inner.span(),
13476 Self::GenericTypeWithTurbofish(inner) => inner.span(),
13477 Self::HigherRankedTraitBound(inner) => inner.span(),
13478 Self::IfExpression(inner) => inner.span(),
13479 Self::ImplItem(inner) => inner.span(),
13480 Self::IndexExpression(inner) => inner.span(),
13481 Self::InnerAttributeItem(inner) => inner.span(),
13482 Self::InnerDocCommentMarker(inner) => inner.span(),
13483 Self::Label(inner) => inner.span(),
13484 Self::LetChain(inner) => inner.span(),
13485 Self::LetCondition(inner) => inner.span(),
13486 Self::LetDeclaration(inner) => inner.span(),
13487 Self::Lifetime(inner) => inner.span(),
13488 Self::LifetimeParameter(inner) => inner.span(),
13489 Self::LineComment(inner) => inner.span(),
13490 Self::LoopExpression(inner) => inner.span(),
13491 Self::MacroDefinition(inner) => inner.span(),
13492 Self::MacroInvocation(inner) => inner.span(),
13493 Self::MacroRule(inner) => inner.span(),
13494 Self::MatchArm(inner) => inner.span(),
13495 Self::MatchBlock(inner) => inner.span(),
13496 Self::MatchExpression(inner) => inner.span(),
13497 Self::MatchPattern(inner) => inner.span(),
13498 Self::ModItem(inner) => inner.span(),
13499 Self::MutPattern(inner) => inner.span(),
13500 Self::NegativeLiteral(inner) => inner.span(),
13501 Self::NeverType(inner) => inner.span(),
13502 Self::OrPattern(inner) => inner.span(),
13503 Self::OrderedFieldDeclarationList(inner) => inner.span(),
13504 Self::OuterDocCommentMarker(inner) => inner.span(),
13505 Self::Parameter(inner) => inner.span(),
13506 Self::Parameters(inner) => inner.span(),
13507 Self::ParenthesizedExpression(inner) => inner.span(),
13508 Self::PointerType(inner) => inner.span(),
13509 Self::QualifiedType(inner) => inner.span(),
13510 Self::RangeExpression(inner) => inner.span(),
13511 Self::RangePattern(inner) => inner.span(),
13512 Self::RawStringLiteral(inner) => inner.span(),
13513 Self::RefPattern(inner) => inner.span(),
13514 Self::ReferenceExpression(inner) => inner.span(),
13515 Self::ReferencePattern(inner) => inner.span(),
13516 Self::ReferenceType(inner) => inner.span(),
13517 Self::RemainingFieldPattern(inner) => inner.span(),
13518 Self::RemovedTraitBound(inner) => inner.span(),
13519 Self::ReturnExpression(inner) => inner.span(),
13520 Self::ScopedIdentifier(inner) => inner.span(),
13521 Self::ScopedTypeIdentifier(inner) => inner.span(),
13522 Self::ScopedUseList(inner) => inner.span(),
13523 Self::SelfParameter(inner) => inner.span(),
13524 Self::ShorthandFieldInitializer(inner) => inner.span(),
13525 Self::SlicePattern(inner) => inner.span(),
13526 Self::SourceFile(inner) => inner.span(),
13527 Self::StaticItem(inner) => inner.span(),
13528 Self::StringLiteral(inner) => inner.span(),
13529 Self::StructExpression(inner) => inner.span(),
13530 Self::StructItem(inner) => inner.span(),
13531 Self::StructPattern(inner) => inner.span(),
13532 Self::TokenBindingPattern(inner) => inner.span(),
13533 Self::TokenRepetition(inner) => inner.span(),
13534 Self::TokenRepetitionPattern(inner) => inner.span(),
13535 Self::TokenTree(inner) => inner.span(),
13536 Self::TokenTreePattern(inner) => inner.span(),
13537 Self::TraitBounds(inner) => inner.span(),
13538 Self::TraitItem(inner) => inner.span(),
13539 Self::TryBlock(inner) => inner.span(),
13540 Self::TryExpression(inner) => inner.span(),
13541 Self::TupleExpression(inner) => inner.span(),
13542 Self::TuplePattern(inner) => inner.span(),
13543 Self::TupleStructPattern(inner) => inner.span(),
13544 Self::TupleType(inner) => inner.span(),
13545 Self::TypeArguments(inner) => inner.span(),
13546 Self::TypeBinding(inner) => inner.span(),
13547 Self::TypeCastExpression(inner) => inner.span(),
13548 Self::TypeItem(inner) => inner.span(),
13549 Self::TypeParameter(inner) => inner.span(),
13550 Self::TypeParameters(inner) => inner.span(),
13551 Self::UnaryExpression(inner) => inner.span(),
13552 Self::UnionItem(inner) => inner.span(),
13553 Self::UnitExpression(inner) => inner.span(),
13554 Self::UnitType(inner) => inner.span(),
13555 Self::UnsafeBlock(inner) => inner.span(),
13556 Self::UseAsClause(inner) => inner.span(),
13557 Self::UseBounds(inner) => inner.span(),
13558 Self::UseDeclaration(inner) => inner.span(),
13559 Self::UseList(inner) => inner.span(),
13560 Self::UseWildcard(inner) => inner.span(),
13561 Self::VariadicParameter(inner) => inner.span(),
13562 Self::VisibilityModifier(inner) => inner.span(),
13563 Self::WhereClause(inner) => inner.span(),
13564 Self::WherePredicate(inner) => inner.span(),
13565 Self::WhileExpression(inner) => inner.span(),
13566 Self::YieldExpression(inner) => inner.span(),
13567 Self::CharLiteral(inner) => inner.span(),
13568 Self::Crate(inner) => inner.span(),
13569 Self::DocComment(inner) => inner.span(),
13570 Self::EscapeSequence(inner) => inner.span(),
13571 Self::FieldIdentifier(inner) => inner.span(),
13572 Self::FloatLiteral(inner) => inner.span(),
13573 Self::Identifier(inner) => inner.span(),
13574 Self::IntegerLiteral(inner) => inner.span(),
13575 Self::Metavariable(inner) => inner.span(),
13576 Self::MutableSpecifier(inner) => inner.span(),
13577 Self::PrimitiveType(inner) => inner.span(),
13578 Self::SelfType(inner) => inner.span(),
13579 Self::Shebang(inner) => inner.span(),
13580 Self::ShorthandFieldIdentifier(inner) => inner.span(),
13581 Self::StringContent(inner) => inner.span(),
13582 Self::Super(inner) => inner.span(),
13583 Self::TypeIdentifier(inner) => inner.span(),
13584 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
13585 }
13586 }
13587}