1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum DeclarationStatement<'tree> {
3 AssociatedType(::std::boxed::Box<AssociatedType<'tree>>),
4 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
5 ConstItem(::std::boxed::Box<ConstItem<'tree>>),
6 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7 EnumItem(::std::boxed::Box<EnumItem<'tree>>),
8 ExternCrateDeclaration(::std::boxed::Box<ExternCrateDeclaration<'tree>>),
9 ForeignModItem(::std::boxed::Box<ForeignModItem<'tree>>),
10 FunctionItem(::std::boxed::Box<FunctionItem<'tree>>),
11 FunctionSignatureItem(::std::boxed::Box<FunctionSignatureItem<'tree>>),
12 ImplItem(::std::boxed::Box<ImplItem<'tree>>),
13 InnerAttributeItem(::std::boxed::Box<InnerAttributeItem<'tree>>),
14 LetDeclaration(::std::boxed::Box<LetDeclaration<'tree>>),
15 MacroDefinition(::std::boxed::Box<MacroDefinition<'tree>>),
16 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
17 ModItem(::std::boxed::Box<ModItem<'tree>>),
18 StaticItem(::std::boxed::Box<StaticItem<'tree>>),
19 StructItem(::std::boxed::Box<StructItem<'tree>>),
20 TraitItem(::std::boxed::Box<TraitItem<'tree>>),
21 TypeItem(::std::boxed::Box<TypeItem<'tree>>),
22 UnionItem(::std::boxed::Box<UnionItem<'tree>>),
23 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
24}
25impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationStatement<'tree> {
26 #[allow(clippy::collapsible_else_if)]
27 fn from_node(
28 node: ::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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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, PartialEq, Eq)]
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 let candidate = fallback_cursor.node();
1030 #[allow(clippy::needless_question_mark)]
1031 if (|| -> ::core::result::Result<
1032 _,
1033 ::treesitter_types::ParseError,
1034 > {
1035 let child = candidate;
1036 Ok(
1037 <Block as ::treesitter_types::FromNode>::from_node(
1038 child,
1039 src,
1040 )?,
1041 )
1042 })()
1043 .is_ok()
1044 {
1045 fallback_child = Some(candidate);
1046 break;
1047 }
1048 }
1049 if !fallback_cursor.goto_next_sibling() {
1050 break;
1051 }
1052 }
1053 }
1054 if fallback_child.is_none() {
1055 let mut cursor2 = node.walk();
1056 if cursor2.goto_first_child() {
1057 loop {
1058 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1059 let candidate = cursor2.node();
1060 #[allow(clippy::needless_question_mark)]
1061 if (|| -> ::core::result::Result<
1062 _,
1063 ::treesitter_types::ParseError,
1064 > {
1065 let child = candidate;
1066 Ok(
1067 <Block as ::treesitter_types::FromNode>::from_node(
1068 child,
1069 src,
1070 )?,
1071 )
1072 })()
1073 .is_ok()
1074 {
1075 fallback_child = Some(candidate);
1076 break;
1077 }
1078 }
1079 if !cursor2.goto_next_sibling() {
1080 break;
1081 }
1082 }
1083 }
1084 }
1085 fallback_child.ok_or_else(|| {
1086 ::treesitter_types::ParseError::missing_field("children", node)
1087 })?
1088 };
1089 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
1090 },
1091 })
1092 }
1093}
1094impl ::treesitter_types::Spanned for AsyncBlock<'_> {
1095 fn span(&self) -> ::treesitter_types::Span {
1096 self.span
1097 }
1098}
1099#[derive(Debug, Clone, PartialEq, Eq)]
1100pub struct Attribute<'tree> {
1101 pub span: ::treesitter_types::Span,
1102 pub arguments: ::core::option::Option<TokenTree<'tree>>,
1103 pub value: ::core::option::Option<Expression<'tree>>,
1104 pub children: AttributeChildren<'tree>,
1105}
1106impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1108 fn from_node(
1109 node: ::tree_sitter::Node<'tree>,
1110 src: &'tree [u8],
1111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1112 debug_assert_eq!(node.kind(), "attribute");
1113 Ok(Self {
1114 span: ::treesitter_types::Span::from(node),
1115 arguments: match node.child_by_field_name("arguments") {
1116 Some(child) => Some(<TokenTree as ::treesitter_types::FromNode>::from_node(
1117 child, src,
1118 )?),
1119 None => None,
1120 },
1121 value: match node.child_by_field_name("value") {
1122 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
1123 child, src,
1124 )?),
1125 None => None,
1126 },
1127 children: {
1128 #[allow(clippy::suspicious_else_formatting)]
1129 let non_field_children = {
1130 let mut cursor = node.walk();
1131 let mut result = ::std::vec::Vec::new();
1132 if cursor.goto_first_child() {
1133 loop {
1134 if cursor.field_name().is_none()
1135 && cursor.node().is_named()
1136 && !cursor.node().is_extra()
1137 {
1138 result.push(cursor.node());
1139 }
1140 if !cursor.goto_next_sibling() {
1141 break;
1142 }
1143 }
1144 }
1145 result
1146 };
1147 let child = if let Some(&c) = non_field_children.first() {
1148 c
1149 } else {
1150 let mut fallback_cursor = node.walk();
1151 let mut fallback_child = None;
1152 if fallback_cursor.goto_first_child() {
1153 loop {
1154 if fallback_cursor.field_name().is_none()
1155 && !fallback_cursor.node().is_extra()
1156 {
1157 let candidate = fallback_cursor.node();
1158 #[allow(clippy::needless_question_mark)]
1159 if (|| -> ::core::result::Result<
1160 _,
1161 ::treesitter_types::ParseError,
1162 > {
1163 let child = candidate;
1164 Ok(
1165 <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1166 child,
1167 src,
1168 )?,
1169 )
1170 })()
1171 .is_ok()
1172 {
1173 fallback_child = Some(candidate);
1174 break;
1175 }
1176 }
1177 if !fallback_cursor.goto_next_sibling() {
1178 break;
1179 }
1180 }
1181 }
1182 if fallback_child.is_none() {
1183 let mut cursor2 = node.walk();
1184 if cursor2.goto_first_child() {
1185 loop {
1186 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1187 let candidate = cursor2.node();
1188 #[allow(clippy::needless_question_mark)]
1189 if (|| -> ::core::result::Result<
1190 _,
1191 ::treesitter_types::ParseError,
1192 > {
1193 let child = candidate;
1194 Ok(
1195 <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1196 child,
1197 src,
1198 )?,
1199 )
1200 })()
1201 .is_ok()
1202 {
1203 fallback_child = Some(candidate);
1204 break;
1205 }
1206 }
1207 if !cursor2.goto_next_sibling() {
1208 break;
1209 }
1210 }
1211 }
1212 }
1213 fallback_child.ok_or_else(|| {
1214 ::treesitter_types::ParseError::missing_field("children", node)
1215 })?
1216 };
1217 <AttributeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1218 },
1219 })
1220 }
1221}
1222impl ::treesitter_types::Spanned for Attribute<'_> {
1223 fn span(&self) -> ::treesitter_types::Span {
1224 self.span
1225 }
1226}
1227#[derive(Debug, Clone, PartialEq, Eq)]
1228pub struct AttributeItem<'tree> {
1229 pub span: ::treesitter_types::Span,
1230 pub children: Attribute<'tree>,
1231}
1232impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeItem<'tree> {
1233 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1234 fn from_node(
1235 node: ::tree_sitter::Node<'tree>,
1236 src: &'tree [u8],
1237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1238 debug_assert_eq!(node.kind(), "attribute_item");
1239 Ok(Self {
1240 span: ::treesitter_types::Span::from(node),
1241 children: {
1242 #[allow(clippy::suspicious_else_formatting)]
1243 let non_field_children = {
1244 let mut cursor = node.walk();
1245 let mut result = ::std::vec::Vec::new();
1246 if cursor.goto_first_child() {
1247 loop {
1248 if cursor.field_name().is_none()
1249 && cursor.node().is_named()
1250 && !cursor.node().is_extra()
1251 {
1252 result.push(cursor.node());
1253 }
1254 if !cursor.goto_next_sibling() {
1255 break;
1256 }
1257 }
1258 }
1259 result
1260 };
1261 let child = if let Some(&c) = non_field_children.first() {
1262 c
1263 } else {
1264 let mut fallback_cursor = node.walk();
1265 let mut fallback_child = None;
1266 if fallback_cursor.goto_first_child() {
1267 loop {
1268 if fallback_cursor.field_name().is_none()
1269 && !fallback_cursor.node().is_extra()
1270 {
1271 let candidate = fallback_cursor.node();
1272 #[allow(clippy::needless_question_mark)]
1273 if (|| -> ::core::result::Result<
1274 _,
1275 ::treesitter_types::ParseError,
1276 > {
1277 let child = candidate;
1278 Ok(
1279 <Attribute as ::treesitter_types::FromNode>::from_node(
1280 child,
1281 src,
1282 )?,
1283 )
1284 })()
1285 .is_ok()
1286 {
1287 fallback_child = Some(candidate);
1288 break;
1289 }
1290 }
1291 if !fallback_cursor.goto_next_sibling() {
1292 break;
1293 }
1294 }
1295 }
1296 if fallback_child.is_none() {
1297 let mut cursor2 = node.walk();
1298 if cursor2.goto_first_child() {
1299 loop {
1300 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1301 let candidate = cursor2.node();
1302 #[allow(clippy::needless_question_mark)]
1303 if (|| -> ::core::result::Result<
1304 _,
1305 ::treesitter_types::ParseError,
1306 > {
1307 let child = candidate;
1308 Ok(
1309 <Attribute as ::treesitter_types::FromNode>::from_node(
1310 child,
1311 src,
1312 )?,
1313 )
1314 })()
1315 .is_ok()
1316 {
1317 fallback_child = Some(candidate);
1318 break;
1319 }
1320 }
1321 if !cursor2.goto_next_sibling() {
1322 break;
1323 }
1324 }
1325 }
1326 }
1327 fallback_child.ok_or_else(|| {
1328 ::treesitter_types::ParseError::missing_field("children", node)
1329 })?
1330 };
1331 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)?
1332 },
1333 })
1334 }
1335}
1336impl ::treesitter_types::Spanned for AttributeItem<'_> {
1337 fn span(&self) -> ::treesitter_types::Span {
1338 self.span
1339 }
1340}
1341#[derive(Debug, Clone, PartialEq, Eq)]
1342pub struct AwaitExpression<'tree> {
1343 pub span: ::treesitter_types::Span,
1344 pub children: Expression<'tree>,
1345}
1346impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
1347 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1348 fn from_node(
1349 node: ::tree_sitter::Node<'tree>,
1350 src: &'tree [u8],
1351 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1352 debug_assert_eq!(node.kind(), "await_expression");
1353 Ok(Self {
1354 span: ::treesitter_types::Span::from(node),
1355 children: {
1356 #[allow(clippy::suspicious_else_formatting)]
1357 let non_field_children = {
1358 let mut cursor = node.walk();
1359 let mut result = ::std::vec::Vec::new();
1360 if cursor.goto_first_child() {
1361 loop {
1362 if cursor.field_name().is_none()
1363 && cursor.node().is_named()
1364 && !cursor.node().is_extra()
1365 {
1366 result.push(cursor.node());
1367 }
1368 if !cursor.goto_next_sibling() {
1369 break;
1370 }
1371 }
1372 }
1373 result
1374 };
1375 let child = if let Some(&c) = non_field_children.first() {
1376 c
1377 } else {
1378 let mut fallback_cursor = node.walk();
1379 let mut fallback_child = None;
1380 if fallback_cursor.goto_first_child() {
1381 loop {
1382 if fallback_cursor.field_name().is_none()
1383 && !fallback_cursor.node().is_extra()
1384 {
1385 let candidate = fallback_cursor.node();
1386 #[allow(clippy::needless_question_mark)]
1387 if (|| -> ::core::result::Result<
1388 _,
1389 ::treesitter_types::ParseError,
1390 > {
1391 let child = candidate;
1392 Ok(
1393 <Expression as ::treesitter_types::FromNode>::from_node(
1394 child,
1395 src,
1396 )?,
1397 )
1398 })()
1399 .is_ok()
1400 {
1401 fallback_child = Some(candidate);
1402 break;
1403 }
1404 }
1405 if !fallback_cursor.goto_next_sibling() {
1406 break;
1407 }
1408 }
1409 }
1410 if fallback_child.is_none() {
1411 let mut cursor2 = node.walk();
1412 if cursor2.goto_first_child() {
1413 loop {
1414 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1415 let candidate = cursor2.node();
1416 #[allow(clippy::needless_question_mark)]
1417 if (|| -> ::core::result::Result<
1418 _,
1419 ::treesitter_types::ParseError,
1420 > {
1421 let child = candidate;
1422 Ok(
1423 <Expression as ::treesitter_types::FromNode>::from_node(
1424 child,
1425 src,
1426 )?,
1427 )
1428 })()
1429 .is_ok()
1430 {
1431 fallback_child = Some(candidate);
1432 break;
1433 }
1434 }
1435 if !cursor2.goto_next_sibling() {
1436 break;
1437 }
1438 }
1439 }
1440 }
1441 fallback_child.ok_or_else(|| {
1442 ::treesitter_types::ParseError::missing_field("children", node)
1443 })?
1444 };
1445 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1446 },
1447 })
1448 }
1449}
1450impl ::treesitter_types::Spanned for AwaitExpression<'_> {
1451 fn span(&self) -> ::treesitter_types::Span {
1452 self.span
1453 }
1454}
1455#[derive(Debug, Clone, PartialEq, Eq)]
1456pub struct BaseFieldInitializer<'tree> {
1457 pub span: ::treesitter_types::Span,
1458 pub children: Expression<'tree>,
1459}
1460impl<'tree> ::treesitter_types::FromNode<'tree> for BaseFieldInitializer<'tree> {
1461 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1462 fn from_node(
1463 node: ::tree_sitter::Node<'tree>,
1464 src: &'tree [u8],
1465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1466 debug_assert_eq!(node.kind(), "base_field_initializer");
1467 Ok(Self {
1468 span: ::treesitter_types::Span::from(node),
1469 children: {
1470 #[allow(clippy::suspicious_else_formatting)]
1471 let non_field_children = {
1472 let mut cursor = node.walk();
1473 let mut result = ::std::vec::Vec::new();
1474 if cursor.goto_first_child() {
1475 loop {
1476 if cursor.field_name().is_none()
1477 && cursor.node().is_named()
1478 && !cursor.node().is_extra()
1479 {
1480 result.push(cursor.node());
1481 }
1482 if !cursor.goto_next_sibling() {
1483 break;
1484 }
1485 }
1486 }
1487 result
1488 };
1489 let child = if let Some(&c) = non_field_children.first() {
1490 c
1491 } else {
1492 let mut fallback_cursor = node.walk();
1493 let mut fallback_child = None;
1494 if fallback_cursor.goto_first_child() {
1495 loop {
1496 if fallback_cursor.field_name().is_none()
1497 && !fallback_cursor.node().is_extra()
1498 {
1499 let candidate = fallback_cursor.node();
1500 #[allow(clippy::needless_question_mark)]
1501 if (|| -> ::core::result::Result<
1502 _,
1503 ::treesitter_types::ParseError,
1504 > {
1505 let child = candidate;
1506 Ok(
1507 <Expression as ::treesitter_types::FromNode>::from_node(
1508 child,
1509 src,
1510 )?,
1511 )
1512 })()
1513 .is_ok()
1514 {
1515 fallback_child = Some(candidate);
1516 break;
1517 }
1518 }
1519 if !fallback_cursor.goto_next_sibling() {
1520 break;
1521 }
1522 }
1523 }
1524 if fallback_child.is_none() {
1525 let mut cursor2 = node.walk();
1526 if cursor2.goto_first_child() {
1527 loop {
1528 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1529 let candidate = cursor2.node();
1530 #[allow(clippy::needless_question_mark)]
1531 if (|| -> ::core::result::Result<
1532 _,
1533 ::treesitter_types::ParseError,
1534 > {
1535 let child = candidate;
1536 Ok(
1537 <Expression as ::treesitter_types::FromNode>::from_node(
1538 child,
1539 src,
1540 )?,
1541 )
1542 })()
1543 .is_ok()
1544 {
1545 fallback_child = Some(candidate);
1546 break;
1547 }
1548 }
1549 if !cursor2.goto_next_sibling() {
1550 break;
1551 }
1552 }
1553 }
1554 }
1555 fallback_child.ok_or_else(|| {
1556 ::treesitter_types::ParseError::missing_field("children", node)
1557 })?
1558 };
1559 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1560 },
1561 })
1562 }
1563}
1564impl ::treesitter_types::Spanned for BaseFieldInitializer<'_> {
1565 fn span(&self) -> ::treesitter_types::Span {
1566 self.span
1567 }
1568}
1569#[derive(Debug, Clone, PartialEq, Eq)]
1570pub struct BinaryExpression<'tree> {
1571 pub span: ::treesitter_types::Span,
1572 pub left: Expression<'tree>,
1573 pub operator: BinaryExpressionOperator,
1574 pub right: Expression<'tree>,
1575}
1576impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1577 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1578 fn from_node(
1579 node: ::tree_sitter::Node<'tree>,
1580 src: &'tree [u8],
1581 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1582 debug_assert_eq!(node.kind(), "binary_expression");
1583 Ok(Self {
1584 span: ::treesitter_types::Span::from(node),
1585 left: {
1586 let child = node
1587 .child_by_field_name("left")
1588 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1589 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1590 },
1591 operator: {
1592 let child = node.child_by_field_name("operator").ok_or_else(|| {
1593 ::treesitter_types::ParseError::missing_field("operator", node)
1594 })?;
1595 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1596 },
1597 right: {
1598 let child = node
1599 .child_by_field_name("right")
1600 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1601 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1602 },
1603 })
1604 }
1605}
1606impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1607 fn span(&self) -> ::treesitter_types::Span {
1608 self.span
1609 }
1610}
1611#[derive(Debug, Clone, PartialEq, Eq)]
1612pub struct Block<'tree> {
1613 pub span: ::treesitter_types::Span,
1614 pub children: ::std::vec::Vec<BlockChildren<'tree>>,
1615}
1616impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
1617 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1618 fn from_node(
1619 node: ::tree_sitter::Node<'tree>,
1620 src: &'tree [u8],
1621 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1622 debug_assert_eq!(node.kind(), "block");
1623 Ok(Self {
1624 span: ::treesitter_types::Span::from(node),
1625 children: {
1626 #[allow(clippy::suspicious_else_formatting)]
1627 let non_field_children = {
1628 let mut cursor = node.walk();
1629 let mut result = ::std::vec::Vec::new();
1630 if cursor.goto_first_child() {
1631 loop {
1632 if cursor.field_name().is_none()
1633 && cursor.node().is_named()
1634 && !cursor.node().is_extra()
1635 {
1636 result.push(cursor.node());
1637 }
1638 if !cursor.goto_next_sibling() {
1639 break;
1640 }
1641 }
1642 }
1643 result
1644 };
1645 let mut items = ::std::vec::Vec::new();
1646 for child in non_field_children {
1647 items.push(<BlockChildren as ::treesitter_types::FromNode>::from_node(
1648 child, src,
1649 )?);
1650 }
1651 items
1652 },
1653 })
1654 }
1655}
1656impl ::treesitter_types::Spanned for Block<'_> {
1657 fn span(&self) -> ::treesitter_types::Span {
1658 self.span
1659 }
1660}
1661#[derive(Debug, Clone, PartialEq, Eq)]
1662pub struct BlockComment<'tree> {
1663 pub span: ::treesitter_types::Span,
1664 pub doc: ::core::option::Option<DocComment<'tree>>,
1665 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
1666 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
1667}
1668impl<'tree> ::treesitter_types::FromNode<'tree> for BlockComment<'tree> {
1669 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1670 fn from_node(
1671 node: ::tree_sitter::Node<'tree>,
1672 src: &'tree [u8],
1673 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1674 debug_assert_eq!(node.kind(), "block_comment");
1675 Ok(Self {
1676 span: ::treesitter_types::Span::from(node),
1677 doc: match node.child_by_field_name("doc") {
1678 Some(child) => Some(<DocComment as ::treesitter_types::FromNode>::from_node(
1679 child, src,
1680 )?),
1681 None => None,
1682 },
1683 inner: match node.child_by_field_name("inner") {
1684 Some(child) => Some(
1685 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
1686 ),
1687 None => None,
1688 },
1689 outer: match node.child_by_field_name("outer") {
1690 Some(child) => Some(
1691 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
1692 ),
1693 None => None,
1694 },
1695 })
1696 }
1697}
1698impl ::treesitter_types::Spanned for BlockComment<'_> {
1699 fn span(&self) -> ::treesitter_types::Span {
1700 self.span
1701 }
1702}
1703#[derive(Debug, Clone, PartialEq, Eq)]
1704pub struct BooleanLiteral<'tree> {
1705 pub span: ::treesitter_types::Span,
1706 text: &'tree str,
1707}
1708impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanLiteral<'tree> {
1709 fn from_node(
1710 node: ::tree_sitter::Node<'tree>,
1711 src: &'tree [u8],
1712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1713 debug_assert_eq!(node.kind(), "boolean_literal");
1714 Ok(Self {
1715 span: ::treesitter_types::Span::from(node),
1716 text: node.utf8_text(src)?,
1717 })
1718 }
1719}
1720impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanLiteral<'tree> {
1721 fn text(&self) -> &'tree str {
1722 self.text
1723 }
1724}
1725impl ::treesitter_types::Spanned for BooleanLiteral<'_> {
1726 fn span(&self) -> ::treesitter_types::Span {
1727 self.span
1728 }
1729}
1730#[derive(Debug, Clone, PartialEq, Eq)]
1731pub struct BoundedType<'tree> {
1732 pub span: ::treesitter_types::Span,
1733 pub children: ::std::vec::Vec<BoundedTypeChildren<'tree>>,
1734}
1735impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedType<'tree> {
1736 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1737 fn from_node(
1738 node: ::tree_sitter::Node<'tree>,
1739 src: &'tree [u8],
1740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1741 debug_assert_eq!(node.kind(), "bounded_type");
1742 Ok(Self {
1743 span: ::treesitter_types::Span::from(node),
1744 children: {
1745 #[allow(clippy::suspicious_else_formatting)]
1746 let non_field_children = {
1747 let mut cursor = node.walk();
1748 let mut result = ::std::vec::Vec::new();
1749 if cursor.goto_first_child() {
1750 loop {
1751 if cursor.field_name().is_none()
1752 && cursor.node().is_named()
1753 && !cursor.node().is_extra()
1754 {
1755 result.push(cursor.node());
1756 }
1757 if !cursor.goto_next_sibling() {
1758 break;
1759 }
1760 }
1761 }
1762 result
1763 };
1764 let mut items = ::std::vec::Vec::new();
1765 for child in non_field_children {
1766 items.push(
1767 <BoundedTypeChildren as ::treesitter_types::FromNode>::from_node(
1768 child, src,
1769 )?,
1770 );
1771 }
1772 items
1773 },
1774 })
1775 }
1776}
1777impl ::treesitter_types::Spanned for BoundedType<'_> {
1778 fn span(&self) -> ::treesitter_types::Span {
1779 self.span
1780 }
1781}
1782#[derive(Debug, Clone, PartialEq, Eq)]
1783pub struct BracketedType<'tree> {
1784 pub span: ::treesitter_types::Span,
1785 pub children: BracketedTypeChildren<'tree>,
1786}
1787impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedType<'tree> {
1788 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1789 fn from_node(
1790 node: ::tree_sitter::Node<'tree>,
1791 src: &'tree [u8],
1792 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1793 debug_assert_eq!(node.kind(), "bracketed_type");
1794 Ok(Self {
1795 span: ::treesitter_types::Span::from(node),
1796 children: {
1797 #[allow(clippy::suspicious_else_formatting)]
1798 let non_field_children = {
1799 let mut cursor = node.walk();
1800 let mut result = ::std::vec::Vec::new();
1801 if cursor.goto_first_child() {
1802 loop {
1803 if cursor.field_name().is_none()
1804 && cursor.node().is_named()
1805 && !cursor.node().is_extra()
1806 {
1807 result.push(cursor.node());
1808 }
1809 if !cursor.goto_next_sibling() {
1810 break;
1811 }
1812 }
1813 }
1814 result
1815 };
1816 let child = if let Some(&c) = non_field_children.first() {
1817 c
1818 } else {
1819 let mut fallback_cursor = node.walk();
1820 let mut fallback_child = None;
1821 if fallback_cursor.goto_first_child() {
1822 loop {
1823 if fallback_cursor.field_name().is_none()
1824 && !fallback_cursor.node().is_extra()
1825 {
1826 let candidate = fallback_cursor.node();
1827 #[allow(clippy::needless_question_mark)]
1828 if (|| -> ::core::result::Result<
1829 _,
1830 ::treesitter_types::ParseError,
1831 > {
1832 let child = candidate;
1833 Ok(
1834 <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(
1835 child,
1836 src,
1837 )?,
1838 )
1839 })()
1840 .is_ok()
1841 {
1842 fallback_child = Some(candidate);
1843 break;
1844 }
1845 }
1846 if !fallback_cursor.goto_next_sibling() {
1847 break;
1848 }
1849 }
1850 }
1851 if fallback_child.is_none() {
1852 let mut cursor2 = node.walk();
1853 if cursor2.goto_first_child() {
1854 loop {
1855 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1856 let candidate = cursor2.node();
1857 #[allow(clippy::needless_question_mark)]
1858 if (|| -> ::core::result::Result<
1859 _,
1860 ::treesitter_types::ParseError,
1861 > {
1862 let child = candidate;
1863 Ok(
1864 <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(
1865 child,
1866 src,
1867 )?,
1868 )
1869 })()
1870 .is_ok()
1871 {
1872 fallback_child = Some(candidate);
1873 break;
1874 }
1875 }
1876 if !cursor2.goto_next_sibling() {
1877 break;
1878 }
1879 }
1880 }
1881 }
1882 fallback_child.ok_or_else(|| {
1883 ::treesitter_types::ParseError::missing_field("children", node)
1884 })?
1885 };
1886 <BracketedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1887 },
1888 })
1889 }
1890}
1891impl ::treesitter_types::Spanned for BracketedType<'_> {
1892 fn span(&self) -> ::treesitter_types::Span {
1893 self.span
1894 }
1895}
1896#[derive(Debug, Clone, PartialEq, Eq)]
1897pub struct BreakExpression<'tree> {
1898 pub span: ::treesitter_types::Span,
1899 pub children: ::std::vec::Vec<BreakExpressionChildren<'tree>>,
1900}
1901impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpression<'tree> {
1902 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1903 fn from_node(
1904 node: ::tree_sitter::Node<'tree>,
1905 src: &'tree [u8],
1906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1907 debug_assert_eq!(node.kind(), "break_expression");
1908 Ok(Self {
1909 span: ::treesitter_types::Span::from(node),
1910 children: {
1911 #[allow(clippy::suspicious_else_formatting)]
1912 let non_field_children = {
1913 let mut cursor = node.walk();
1914 let mut result = ::std::vec::Vec::new();
1915 if cursor.goto_first_child() {
1916 loop {
1917 if cursor.field_name().is_none()
1918 && cursor.node().is_named()
1919 && !cursor.node().is_extra()
1920 {
1921 result.push(cursor.node());
1922 }
1923 if !cursor.goto_next_sibling() {
1924 break;
1925 }
1926 }
1927 }
1928 result
1929 };
1930 let mut items = ::std::vec::Vec::new();
1931 for child in non_field_children {
1932 items.push(
1933 <BreakExpressionChildren as ::treesitter_types::FromNode>::from_node(
1934 child, src,
1935 )?,
1936 );
1937 }
1938 items
1939 },
1940 })
1941 }
1942}
1943impl ::treesitter_types::Spanned for BreakExpression<'_> {
1944 fn span(&self) -> ::treesitter_types::Span {
1945 self.span
1946 }
1947}
1948#[derive(Debug, Clone, PartialEq, Eq)]
1949pub struct CallExpression<'tree> {
1950 pub span: ::treesitter_types::Span,
1951 pub arguments: Arguments<'tree>,
1952 pub function: CallExpressionFunction<'tree>,
1953}
1954impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1955 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1956 fn from_node(
1957 node: ::tree_sitter::Node<'tree>,
1958 src: &'tree [u8],
1959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1960 debug_assert_eq!(node.kind(), "call_expression");
1961 Ok(Self {
1962 span: ::treesitter_types::Span::from(node),
1963 arguments: {
1964 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1965 ::treesitter_types::ParseError::missing_field("arguments", node)
1966 })?;
1967 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
1968 },
1969 function: {
1970 let child = node.child_by_field_name("function").ok_or_else(|| {
1971 ::treesitter_types::ParseError::missing_field("function", node)
1972 })?;
1973 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
1974 },
1975 })
1976 }
1977}
1978impl ::treesitter_types::Spanned for CallExpression<'_> {
1979 fn span(&self) -> ::treesitter_types::Span {
1980 self.span
1981 }
1982}
1983#[derive(Debug, Clone, PartialEq, Eq)]
1984pub struct CapturedPattern<'tree> {
1985 pub span: ::treesitter_types::Span,
1986 pub children: ::std::vec::Vec<Pattern<'tree>>,
1987}
1988impl<'tree> ::treesitter_types::FromNode<'tree> for CapturedPattern<'tree> {
1989 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1990 fn from_node(
1991 node: ::tree_sitter::Node<'tree>,
1992 src: &'tree [u8],
1993 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1994 debug_assert_eq!(node.kind(), "captured_pattern");
1995 Ok(Self {
1996 span: ::treesitter_types::Span::from(node),
1997 children: {
1998 #[allow(clippy::suspicious_else_formatting)]
1999 let non_field_children = {
2000 let mut cursor = node.walk();
2001 let mut result = ::std::vec::Vec::new();
2002 if cursor.goto_first_child() {
2003 loop {
2004 if cursor.field_name().is_none()
2005 && cursor.node().is_named()
2006 && !cursor.node().is_extra()
2007 {
2008 result.push(cursor.node());
2009 }
2010 if !cursor.goto_next_sibling() {
2011 break;
2012 }
2013 }
2014 }
2015 result
2016 };
2017 let mut items = ::std::vec::Vec::new();
2018 for child in non_field_children {
2019 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
2020 child, src,
2021 )?);
2022 }
2023 items
2024 },
2025 })
2026 }
2027}
2028impl ::treesitter_types::Spanned for CapturedPattern<'_> {
2029 fn span(&self) -> ::treesitter_types::Span {
2030 self.span
2031 }
2032}
2033#[derive(Debug, Clone, PartialEq, Eq)]
2034pub struct ClosureExpression<'tree> {
2035 pub span: ::treesitter_types::Span,
2036 pub body: ClosureExpressionBody<'tree>,
2037 pub parameters: ClosureParameters<'tree>,
2038 pub return_type: ::core::option::Option<Type<'tree>>,
2039}
2040impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpression<'tree> {
2041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2042 fn from_node(
2043 node: ::tree_sitter::Node<'tree>,
2044 src: &'tree [u8],
2045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2046 debug_assert_eq!(node.kind(), "closure_expression");
2047 Ok(Self {
2048 span: ::treesitter_types::Span::from(node),
2049 body: {
2050 let child = node
2051 .child_by_field_name("body")
2052 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2053 <ClosureExpressionBody as ::treesitter_types::FromNode>::from_node(child, src)?
2054 },
2055 parameters: {
2056 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2057 ::treesitter_types::ParseError::missing_field("parameters", node)
2058 })?;
2059 <ClosureParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2060 },
2061 return_type: match node.child_by_field_name("return_type") {
2062 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
2063 child, src,
2064 )?),
2065 None => None,
2066 },
2067 })
2068 }
2069}
2070impl ::treesitter_types::Spanned for ClosureExpression<'_> {
2071 fn span(&self) -> ::treesitter_types::Span {
2072 self.span
2073 }
2074}
2075#[derive(Debug, Clone, PartialEq, Eq)]
2076pub struct ClosureParameters<'tree> {
2077 pub span: ::treesitter_types::Span,
2078 pub children: ::std::vec::Vec<ClosureParametersChildren<'tree>>,
2079}
2080impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParameters<'tree> {
2081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2082 fn from_node(
2083 node: ::tree_sitter::Node<'tree>,
2084 src: &'tree [u8],
2085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2086 debug_assert_eq!(node.kind(), "closure_parameters");
2087 Ok(Self {
2088 span: ::treesitter_types::Span::from(node),
2089 children: {
2090 #[allow(clippy::suspicious_else_formatting)]
2091 let non_field_children = {
2092 let mut cursor = node.walk();
2093 let mut result = ::std::vec::Vec::new();
2094 if cursor.goto_first_child() {
2095 loop {
2096 if cursor.field_name().is_none()
2097 && cursor.node().is_named()
2098 && !cursor.node().is_extra()
2099 {
2100 result.push(cursor.node());
2101 }
2102 if !cursor.goto_next_sibling() {
2103 break;
2104 }
2105 }
2106 }
2107 result
2108 };
2109 let mut items = ::std::vec::Vec::new();
2110 for child in non_field_children {
2111 items.push(
2112 <ClosureParametersChildren as ::treesitter_types::FromNode>::from_node(
2113 child, src,
2114 )?,
2115 );
2116 }
2117 items
2118 },
2119 })
2120 }
2121}
2122impl ::treesitter_types::Spanned for ClosureParameters<'_> {
2123 fn span(&self) -> ::treesitter_types::Span {
2124 self.span
2125 }
2126}
2127#[derive(Debug, Clone, PartialEq, Eq)]
2128pub struct CompoundAssignmentExpr<'tree> {
2129 pub span: ::treesitter_types::Span,
2130 pub left: Expression<'tree>,
2131 pub operator: CompoundAssignmentExprOperator,
2132 pub right: Expression<'tree>,
2133}
2134impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExpr<'tree> {
2135 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2136 fn from_node(
2137 node: ::tree_sitter::Node<'tree>,
2138 src: &'tree [u8],
2139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2140 debug_assert_eq!(node.kind(), "compound_assignment_expr");
2141 Ok(Self {
2142 span: ::treesitter_types::Span::from(node),
2143 left: {
2144 let child = node
2145 .child_by_field_name("left")
2146 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2147 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2148 },
2149 operator: {
2150 let child = node.child_by_field_name("operator").ok_or_else(|| {
2151 ::treesitter_types::ParseError::missing_field("operator", node)
2152 })?;
2153 <CompoundAssignmentExprOperator as ::treesitter_types::FromNode>::from_node(
2154 child, src,
2155 )?
2156 },
2157 right: {
2158 let child = node
2159 .child_by_field_name("right")
2160 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2161 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2162 },
2163 })
2164 }
2165}
2166impl ::treesitter_types::Spanned for CompoundAssignmentExpr<'_> {
2167 fn span(&self) -> ::treesitter_types::Span {
2168 self.span
2169 }
2170}
2171#[derive(Debug, Clone, PartialEq, Eq)]
2172pub struct ConstBlock<'tree> {
2173 pub span: ::treesitter_types::Span,
2174 pub body: Block<'tree>,
2175}
2176impl<'tree> ::treesitter_types::FromNode<'tree> for ConstBlock<'tree> {
2177 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2178 fn from_node(
2179 node: ::tree_sitter::Node<'tree>,
2180 src: &'tree [u8],
2181 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2182 debug_assert_eq!(node.kind(), "const_block");
2183 Ok(Self {
2184 span: ::treesitter_types::Span::from(node),
2185 body: {
2186 let child = node
2187 .child_by_field_name("body")
2188 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2189 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
2190 },
2191 })
2192 }
2193}
2194impl ::treesitter_types::Spanned for ConstBlock<'_> {
2195 fn span(&self) -> ::treesitter_types::Span {
2196 self.span
2197 }
2198}
2199#[derive(Debug, Clone, PartialEq, Eq)]
2200pub struct ConstItem<'tree> {
2201 pub span: ::treesitter_types::Span,
2202 pub name: Identifier<'tree>,
2203 pub r#type: Type<'tree>,
2204 pub value: ::core::option::Option<Expression<'tree>>,
2205 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2206}
2207impl<'tree> ::treesitter_types::FromNode<'tree> for ConstItem<'tree> {
2208 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2209 fn from_node(
2210 node: ::tree_sitter::Node<'tree>,
2211 src: &'tree [u8],
2212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2213 debug_assert_eq!(node.kind(), "const_item");
2214 Ok(Self {
2215 span: ::treesitter_types::Span::from(node),
2216 name: {
2217 let child = node
2218 .child_by_field_name("name")
2219 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2220 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2221 },
2222 r#type: {
2223 let child = node
2224 .child_by_field_name("type")
2225 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2226 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2227 },
2228 value: match node.child_by_field_name("value") {
2229 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2230 child, src,
2231 )?),
2232 None => None,
2233 },
2234 children: {
2235 #[allow(clippy::suspicious_else_formatting)]
2236 let non_field_children = {
2237 let mut cursor = node.walk();
2238 let mut result = ::std::vec::Vec::new();
2239 if cursor.goto_first_child() {
2240 loop {
2241 if cursor.field_name().is_none()
2242 && cursor.node().is_named()
2243 && !cursor.node().is_extra()
2244 {
2245 result.push(cursor.node());
2246 }
2247 if !cursor.goto_next_sibling() {
2248 break;
2249 }
2250 }
2251 }
2252 result
2253 };
2254 match non_field_children.first() {
2255 Some(&child) => Some(
2256 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
2257 child, src,
2258 )?,
2259 ),
2260 None => None,
2261 }
2262 },
2263 })
2264 }
2265}
2266impl ::treesitter_types::Spanned for ConstItem<'_> {
2267 fn span(&self) -> ::treesitter_types::Span {
2268 self.span
2269 }
2270}
2271#[derive(Debug, Clone, PartialEq, Eq)]
2272pub struct ConstParameter<'tree> {
2273 pub span: ::treesitter_types::Span,
2274 pub name: Identifier<'tree>,
2275 pub r#type: Type<'tree>,
2276 pub value: ::core::option::Option<ConstParameterValue<'tree>>,
2277}
2278impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameter<'tree> {
2279 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2280 fn from_node(
2281 node: ::tree_sitter::Node<'tree>,
2282 src: &'tree [u8],
2283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2284 debug_assert_eq!(node.kind(), "const_parameter");
2285 Ok(Self {
2286 span: ::treesitter_types::Span::from(node),
2287 name: {
2288 let child = node
2289 .child_by_field_name("name")
2290 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2291 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2292 },
2293 r#type: {
2294 let child = node
2295 .child_by_field_name("type")
2296 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2297 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2298 },
2299 value: match node.child_by_field_name("value") {
2300 Some(child) => Some(
2301 <ConstParameterValue as ::treesitter_types::FromNode>::from_node(child, src)?,
2302 ),
2303 None => None,
2304 },
2305 })
2306 }
2307}
2308impl ::treesitter_types::Spanned for ConstParameter<'_> {
2309 fn span(&self) -> ::treesitter_types::Span {
2310 self.span
2311 }
2312}
2313#[derive(Debug, Clone, PartialEq, Eq)]
2314pub struct ContinueExpression<'tree> {
2315 pub span: ::treesitter_types::Span,
2316 pub children: ::core::option::Option<Label<'tree>>,
2317}
2318impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueExpression<'tree> {
2319 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2320 fn from_node(
2321 node: ::tree_sitter::Node<'tree>,
2322 src: &'tree [u8],
2323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2324 debug_assert_eq!(node.kind(), "continue_expression");
2325 Ok(Self {
2326 span: ::treesitter_types::Span::from(node),
2327 children: {
2328 #[allow(clippy::suspicious_else_formatting)]
2329 let non_field_children = {
2330 let mut cursor = node.walk();
2331 let mut result = ::std::vec::Vec::new();
2332 if cursor.goto_first_child() {
2333 loop {
2334 if cursor.field_name().is_none()
2335 && cursor.node().is_named()
2336 && !cursor.node().is_extra()
2337 {
2338 result.push(cursor.node());
2339 }
2340 if !cursor.goto_next_sibling() {
2341 break;
2342 }
2343 }
2344 }
2345 result
2346 };
2347 match non_field_children.first() {
2348 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
2349 child, src,
2350 )?),
2351 None => None,
2352 }
2353 },
2354 })
2355 }
2356}
2357impl ::treesitter_types::Spanned for ContinueExpression<'_> {
2358 fn span(&self) -> ::treesitter_types::Span {
2359 self.span
2360 }
2361}
2362#[derive(Debug, Clone, PartialEq, Eq)]
2363pub struct DeclarationList<'tree> {
2364 pub span: ::treesitter_types::Span,
2365 pub children: ::std::vec::Vec<DeclarationStatement<'tree>>,
2366}
2367impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2369 fn from_node(
2370 node: ::tree_sitter::Node<'tree>,
2371 src: &'tree [u8],
2372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2373 debug_assert_eq!(node.kind(), "declaration_list");
2374 Ok(Self {
2375 span: ::treesitter_types::Span::from(node),
2376 children: {
2377 #[allow(clippy::suspicious_else_formatting)]
2378 let non_field_children = {
2379 let mut cursor = node.walk();
2380 let mut result = ::std::vec::Vec::new();
2381 if cursor.goto_first_child() {
2382 loop {
2383 if cursor.field_name().is_none()
2384 && cursor.node().is_named()
2385 && !cursor.node().is_extra()
2386 {
2387 result.push(cursor.node());
2388 }
2389 if !cursor.goto_next_sibling() {
2390 break;
2391 }
2392 }
2393 }
2394 result
2395 };
2396 let mut items = ::std::vec::Vec::new();
2397 for child in non_field_children {
2398 items.push(
2399 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(
2400 child, src,
2401 )?,
2402 );
2403 }
2404 items
2405 },
2406 })
2407 }
2408}
2409impl ::treesitter_types::Spanned for DeclarationList<'_> {
2410 fn span(&self) -> ::treesitter_types::Span {
2411 self.span
2412 }
2413}
2414#[derive(Debug, Clone, PartialEq, Eq)]
2415pub struct DynamicType<'tree> {
2416 pub span: ::treesitter_types::Span,
2417 pub r#trait: DynamicTypeTrait<'tree>,
2418}
2419impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicType<'tree> {
2420 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2421 fn from_node(
2422 node: ::tree_sitter::Node<'tree>,
2423 src: &'tree [u8],
2424 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2425 debug_assert_eq!(node.kind(), "dynamic_type");
2426 Ok(Self {
2427 span: ::treesitter_types::Span::from(node),
2428 r#trait: {
2429 let child = node
2430 .child_by_field_name("trait")
2431 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("trait", node))?;
2432 <DynamicTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)?
2433 },
2434 })
2435 }
2436}
2437impl ::treesitter_types::Spanned for DynamicType<'_> {
2438 fn span(&self) -> ::treesitter_types::Span {
2439 self.span
2440 }
2441}
2442#[derive(Debug, Clone, PartialEq, Eq)]
2443pub struct ElseClause<'tree> {
2444 pub span: ::treesitter_types::Span,
2445 pub children: ElseClauseChildren<'tree>,
2446}
2447impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'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(), "else_clause");
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 let candidate = fallback_cursor.node();
2487 #[allow(clippy::needless_question_mark)]
2488 if (|| -> ::core::result::Result<
2489 _,
2490 ::treesitter_types::ParseError,
2491 > {
2492 let child = candidate;
2493 Ok(
2494 <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(
2495 child,
2496 src,
2497 )?,
2498 )
2499 })()
2500 .is_ok()
2501 {
2502 fallback_child = Some(candidate);
2503 break;
2504 }
2505 }
2506 if !fallback_cursor.goto_next_sibling() {
2507 break;
2508 }
2509 }
2510 }
2511 if fallback_child.is_none() {
2512 let mut cursor2 = node.walk();
2513 if cursor2.goto_first_child() {
2514 loop {
2515 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2516 let candidate = cursor2.node();
2517 #[allow(clippy::needless_question_mark)]
2518 if (|| -> ::core::result::Result<
2519 _,
2520 ::treesitter_types::ParseError,
2521 > {
2522 let child = candidate;
2523 Ok(
2524 <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(
2525 child,
2526 src,
2527 )?,
2528 )
2529 })()
2530 .is_ok()
2531 {
2532 fallback_child = Some(candidate);
2533 break;
2534 }
2535 }
2536 if !cursor2.goto_next_sibling() {
2537 break;
2538 }
2539 }
2540 }
2541 }
2542 fallback_child.ok_or_else(|| {
2543 ::treesitter_types::ParseError::missing_field("children", node)
2544 })?
2545 };
2546 <ElseClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2547 },
2548 })
2549 }
2550}
2551impl ::treesitter_types::Spanned for ElseClause<'_> {
2552 fn span(&self) -> ::treesitter_types::Span {
2553 self.span
2554 }
2555}
2556#[derive(Debug, Clone, PartialEq, Eq)]
2557pub struct EmptyStatement<'tree> {
2558 pub span: ::treesitter_types::Span,
2559 text: &'tree str,
2560}
2561impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
2562 fn from_node(
2563 node: ::tree_sitter::Node<'tree>,
2564 src: &'tree [u8],
2565 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2566 debug_assert_eq!(node.kind(), "empty_statement");
2567 Ok(Self {
2568 span: ::treesitter_types::Span::from(node),
2569 text: node.utf8_text(src)?,
2570 })
2571 }
2572}
2573impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
2574 fn text(&self) -> &'tree str {
2575 self.text
2576 }
2577}
2578impl ::treesitter_types::Spanned for EmptyStatement<'_> {
2579 fn span(&self) -> ::treesitter_types::Span {
2580 self.span
2581 }
2582}
2583#[derive(Debug, Clone, PartialEq, Eq)]
2584pub struct EnumItem<'tree> {
2585 pub span: ::treesitter_types::Span,
2586 pub body: EnumVariantList<'tree>,
2587 pub name: TypeIdentifier<'tree>,
2588 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2589 pub children: ::std::vec::Vec<EnumItemChildren<'tree>>,
2590}
2591impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItem<'tree> {
2592 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2593 fn from_node(
2594 node: ::tree_sitter::Node<'tree>,
2595 src: &'tree [u8],
2596 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2597 debug_assert_eq!(node.kind(), "enum_item");
2598 Ok(Self {
2599 span: ::treesitter_types::Span::from(node),
2600 body: {
2601 let child = node
2602 .child_by_field_name("body")
2603 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2604 <EnumVariantList as ::treesitter_types::FromNode>::from_node(child, src)?
2605 },
2606 name: {
2607 let child = node
2608 .child_by_field_name("name")
2609 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2610 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
2611 },
2612 type_parameters: match node.child_by_field_name("type_parameters") {
2613 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2614 child, src,
2615 )?),
2616 None => None,
2617 },
2618 children: {
2619 #[allow(clippy::suspicious_else_formatting)]
2620 let non_field_children = {
2621 let mut cursor = node.walk();
2622 let mut result = ::std::vec::Vec::new();
2623 if cursor.goto_first_child() {
2624 loop {
2625 if cursor.field_name().is_none()
2626 && cursor.node().is_named()
2627 && !cursor.node().is_extra()
2628 {
2629 result.push(cursor.node());
2630 }
2631 if !cursor.goto_next_sibling() {
2632 break;
2633 }
2634 }
2635 }
2636 result
2637 };
2638 let mut items = ::std::vec::Vec::new();
2639 for child in non_field_children {
2640 items.push(
2641 <EnumItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2642 );
2643 }
2644 items
2645 },
2646 })
2647 }
2648}
2649impl ::treesitter_types::Spanned for EnumItem<'_> {
2650 fn span(&self) -> ::treesitter_types::Span {
2651 self.span
2652 }
2653}
2654#[derive(Debug, Clone, PartialEq, Eq)]
2655pub struct EnumVariant<'tree> {
2656 pub span: ::treesitter_types::Span,
2657 pub body: ::core::option::Option<EnumVariantBody<'tree>>,
2658 pub name: Identifier<'tree>,
2659 pub value: ::core::option::Option<Expression<'tree>>,
2660 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
2661}
2662impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariant<'tree> {
2663 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2664 fn from_node(
2665 node: ::tree_sitter::Node<'tree>,
2666 src: &'tree [u8],
2667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2668 debug_assert_eq!(node.kind(), "enum_variant");
2669 Ok(Self {
2670 span: ::treesitter_types::Span::from(node),
2671 body: match node.child_by_field_name("body") {
2672 Some(child) => {
2673 Some(<EnumVariantBody as ::treesitter_types::FromNode>::from_node(child, src)?)
2674 }
2675 None => None,
2676 },
2677 name: {
2678 let child = node
2679 .child_by_field_name("name")
2680 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2681 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2682 },
2683 value: match node.child_by_field_name("value") {
2684 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2685 child, src,
2686 )?),
2687 None => None,
2688 },
2689 children: {
2690 #[allow(clippy::suspicious_else_formatting)]
2691 let non_field_children = {
2692 let mut cursor = node.walk();
2693 let mut result = ::std::vec::Vec::new();
2694 if cursor.goto_first_child() {
2695 loop {
2696 if cursor.field_name().is_none()
2697 && cursor.node().is_named()
2698 && !cursor.node().is_extra()
2699 {
2700 result.push(cursor.node());
2701 }
2702 if !cursor.goto_next_sibling() {
2703 break;
2704 }
2705 }
2706 }
2707 result
2708 };
2709 match non_field_children.first() {
2710 Some(&child) => Some(
2711 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
2712 child, src,
2713 )?,
2714 ),
2715 None => None,
2716 }
2717 },
2718 })
2719 }
2720}
2721impl ::treesitter_types::Spanned for EnumVariant<'_> {
2722 fn span(&self) -> ::treesitter_types::Span {
2723 self.span
2724 }
2725}
2726#[derive(Debug, Clone, PartialEq, Eq)]
2727pub struct EnumVariantList<'tree> {
2728 pub span: ::treesitter_types::Span,
2729 pub children: ::std::vec::Vec<EnumVariantListChildren<'tree>>,
2730}
2731impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantList<'tree> {
2732 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2733 fn from_node(
2734 node: ::tree_sitter::Node<'tree>,
2735 src: &'tree [u8],
2736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2737 debug_assert_eq!(node.kind(), "enum_variant_list");
2738 Ok(Self {
2739 span: ::treesitter_types::Span::from(node),
2740 children: {
2741 #[allow(clippy::suspicious_else_formatting)]
2742 let non_field_children = {
2743 let mut cursor = node.walk();
2744 let mut result = ::std::vec::Vec::new();
2745 if cursor.goto_first_child() {
2746 loop {
2747 if cursor.field_name().is_none()
2748 && cursor.node().is_named()
2749 && !cursor.node().is_extra()
2750 {
2751 result.push(cursor.node());
2752 }
2753 if !cursor.goto_next_sibling() {
2754 break;
2755 }
2756 }
2757 }
2758 result
2759 };
2760 let mut items = ::std::vec::Vec::new();
2761 for child in non_field_children {
2762 items.push(
2763 <EnumVariantListChildren as ::treesitter_types::FromNode>::from_node(
2764 child, src,
2765 )?,
2766 );
2767 }
2768 items
2769 },
2770 })
2771 }
2772}
2773impl ::treesitter_types::Spanned for EnumVariantList<'_> {
2774 fn span(&self) -> ::treesitter_types::Span {
2775 self.span
2776 }
2777}
2778#[derive(Debug, Clone, PartialEq, Eq)]
2779pub struct ExpressionStatement<'tree> {
2780 pub span: ::treesitter_types::Span,
2781 pub children: Expression<'tree>,
2782}
2783impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
2784 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2785 fn from_node(
2786 node: ::tree_sitter::Node<'tree>,
2787 src: &'tree [u8],
2788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2789 debug_assert_eq!(node.kind(), "expression_statement");
2790 Ok(Self {
2791 span: ::treesitter_types::Span::from(node),
2792 children: {
2793 #[allow(clippy::suspicious_else_formatting)]
2794 let non_field_children = {
2795 let mut cursor = node.walk();
2796 let mut result = ::std::vec::Vec::new();
2797 if cursor.goto_first_child() {
2798 loop {
2799 if cursor.field_name().is_none()
2800 && cursor.node().is_named()
2801 && !cursor.node().is_extra()
2802 {
2803 result.push(cursor.node());
2804 }
2805 if !cursor.goto_next_sibling() {
2806 break;
2807 }
2808 }
2809 }
2810 result
2811 };
2812 let child = if let Some(&c) = non_field_children.first() {
2813 c
2814 } else {
2815 let mut fallback_cursor = node.walk();
2816 let mut fallback_child = None;
2817 if fallback_cursor.goto_first_child() {
2818 loop {
2819 if fallback_cursor.field_name().is_none()
2820 && !fallback_cursor.node().is_extra()
2821 {
2822 let candidate = fallback_cursor.node();
2823 #[allow(clippy::needless_question_mark)]
2824 if (|| -> ::core::result::Result<
2825 _,
2826 ::treesitter_types::ParseError,
2827 > {
2828 let child = candidate;
2829 Ok(
2830 <Expression as ::treesitter_types::FromNode>::from_node(
2831 child,
2832 src,
2833 )?,
2834 )
2835 })()
2836 .is_ok()
2837 {
2838 fallback_child = Some(candidate);
2839 break;
2840 }
2841 }
2842 if !fallback_cursor.goto_next_sibling() {
2843 break;
2844 }
2845 }
2846 }
2847 if fallback_child.is_none() {
2848 let mut cursor2 = node.walk();
2849 if cursor2.goto_first_child() {
2850 loop {
2851 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2852 let candidate = cursor2.node();
2853 #[allow(clippy::needless_question_mark)]
2854 if (|| -> ::core::result::Result<
2855 _,
2856 ::treesitter_types::ParseError,
2857 > {
2858 let child = candidate;
2859 Ok(
2860 <Expression as ::treesitter_types::FromNode>::from_node(
2861 child,
2862 src,
2863 )?,
2864 )
2865 })()
2866 .is_ok()
2867 {
2868 fallback_child = Some(candidate);
2869 break;
2870 }
2871 }
2872 if !cursor2.goto_next_sibling() {
2873 break;
2874 }
2875 }
2876 }
2877 }
2878 fallback_child.ok_or_else(|| {
2879 ::treesitter_types::ParseError::missing_field("children", node)
2880 })?
2881 };
2882 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2883 },
2884 })
2885 }
2886}
2887impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2888 fn span(&self) -> ::treesitter_types::Span {
2889 self.span
2890 }
2891}
2892#[derive(Debug, Clone, PartialEq, Eq)]
2893pub struct ExternCrateDeclaration<'tree> {
2894 pub span: ::treesitter_types::Span,
2895 pub alias: ::core::option::Option<Identifier<'tree>>,
2896 pub name: Identifier<'tree>,
2897 pub children: ::std::vec::Vec<ExternCrateDeclarationChildren<'tree>>,
2898}
2899impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclaration<'tree> {
2900 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2901 fn from_node(
2902 node: ::tree_sitter::Node<'tree>,
2903 src: &'tree [u8],
2904 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2905 debug_assert_eq!(node.kind(), "extern_crate_declaration");
2906 Ok(Self {
2907 span: ::treesitter_types::Span::from(node),
2908 alias: match node.child_by_field_name("alias") {
2909 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2910 child, src,
2911 )?),
2912 None => None,
2913 },
2914 name: {
2915 let child = node
2916 .child_by_field_name("name")
2917 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2918 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2919 },
2920 children: {
2921 #[allow(clippy::suspicious_else_formatting)]
2922 let non_field_children = {
2923 let mut cursor = node.walk();
2924 let mut result = ::std::vec::Vec::new();
2925 if cursor.goto_first_child() {
2926 loop {
2927 if cursor.field_name().is_none()
2928 && cursor.node().is_named()
2929 && !cursor.node().is_extra()
2930 {
2931 result.push(cursor.node());
2932 }
2933 if !cursor.goto_next_sibling() {
2934 break;
2935 }
2936 }
2937 }
2938 result
2939 };
2940 let mut items = ::std::vec::Vec::new();
2941 for child in non_field_children {
2942 items
2943 .push(
2944 <ExternCrateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2945 child,
2946 src,
2947 )?,
2948 );
2949 }
2950 items
2951 },
2952 })
2953 }
2954}
2955impl ::treesitter_types::Spanned for ExternCrateDeclaration<'_> {
2956 fn span(&self) -> ::treesitter_types::Span {
2957 self.span
2958 }
2959}
2960#[derive(Debug, Clone, PartialEq, Eq)]
2961pub struct ExternModifier<'tree> {
2962 pub span: ::treesitter_types::Span,
2963 pub children: ::core::option::Option<StringLiteral<'tree>>,
2964}
2965impl<'tree> ::treesitter_types::FromNode<'tree> for ExternModifier<'tree> {
2966 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2967 fn from_node(
2968 node: ::tree_sitter::Node<'tree>,
2969 src: &'tree [u8],
2970 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2971 debug_assert_eq!(node.kind(), "extern_modifier");
2972 Ok(Self {
2973 span: ::treesitter_types::Span::from(node),
2974 children: {
2975 #[allow(clippy::suspicious_else_formatting)]
2976 let non_field_children = {
2977 let mut cursor = node.walk();
2978 let mut result = ::std::vec::Vec::new();
2979 if cursor.goto_first_child() {
2980 loop {
2981 if cursor.field_name().is_none()
2982 && cursor.node().is_named()
2983 && !cursor.node().is_extra()
2984 {
2985 result.push(cursor.node());
2986 }
2987 if !cursor.goto_next_sibling() {
2988 break;
2989 }
2990 }
2991 }
2992 result
2993 };
2994 match non_field_children.first() {
2995 Some(&child) => Some(
2996 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?,
2997 ),
2998 None => None,
2999 }
3000 },
3001 })
3002 }
3003}
3004impl ::treesitter_types::Spanned for ExternModifier<'_> {
3005 fn span(&self) -> ::treesitter_types::Span {
3006 self.span
3007 }
3008}
3009#[derive(Debug, Clone, PartialEq, Eq)]
3010pub struct FieldDeclaration<'tree> {
3011 pub span: ::treesitter_types::Span,
3012 pub name: FieldIdentifier<'tree>,
3013 pub r#type: Type<'tree>,
3014 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
3015}
3016impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
3017 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3018 fn from_node(
3019 node: ::tree_sitter::Node<'tree>,
3020 src: &'tree [u8],
3021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3022 debug_assert_eq!(node.kind(), "field_declaration");
3023 Ok(Self {
3024 span: ::treesitter_types::Span::from(node),
3025 name: {
3026 let child = node
3027 .child_by_field_name("name")
3028 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3029 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
3030 },
3031 r#type: {
3032 let child = node
3033 .child_by_field_name("type")
3034 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3035 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3036 },
3037 children: {
3038 #[allow(clippy::suspicious_else_formatting)]
3039 let non_field_children = {
3040 let mut cursor = node.walk();
3041 let mut result = ::std::vec::Vec::new();
3042 if cursor.goto_first_child() {
3043 loop {
3044 if cursor.field_name().is_none()
3045 && cursor.node().is_named()
3046 && !cursor.node().is_extra()
3047 {
3048 result.push(cursor.node());
3049 }
3050 if !cursor.goto_next_sibling() {
3051 break;
3052 }
3053 }
3054 }
3055 result
3056 };
3057 match non_field_children.first() {
3058 Some(&child) => Some(
3059 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
3060 child, src,
3061 )?,
3062 ),
3063 None => None,
3064 }
3065 },
3066 })
3067 }
3068}
3069impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
3070 fn span(&self) -> ::treesitter_types::Span {
3071 self.span
3072 }
3073}
3074#[derive(Debug, Clone, PartialEq, Eq)]
3075pub struct FieldDeclarationList<'tree> {
3076 pub span: ::treesitter_types::Span,
3077 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
3078}
3079impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
3080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3081 fn from_node(
3082 node: ::tree_sitter::Node<'tree>,
3083 src: &'tree [u8],
3084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3085 debug_assert_eq!(node.kind(), "field_declaration_list");
3086 Ok(Self {
3087 span: ::treesitter_types::Span::from(node),
3088 children: {
3089 #[allow(clippy::suspicious_else_formatting)]
3090 let non_field_children = {
3091 let mut cursor = node.walk();
3092 let mut result = ::std::vec::Vec::new();
3093 if cursor.goto_first_child() {
3094 loop {
3095 if cursor.field_name().is_none()
3096 && cursor.node().is_named()
3097 && !cursor.node().is_extra()
3098 {
3099 result.push(cursor.node());
3100 }
3101 if !cursor.goto_next_sibling() {
3102 break;
3103 }
3104 }
3105 }
3106 result
3107 };
3108 let mut items = ::std::vec::Vec::new();
3109 for child in non_field_children {
3110 items.push(
3111 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3112 child, src,
3113 )?,
3114 );
3115 }
3116 items
3117 },
3118 })
3119 }
3120}
3121impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
3122 fn span(&self) -> ::treesitter_types::Span {
3123 self.span
3124 }
3125}
3126#[derive(Debug, Clone, PartialEq, Eq)]
3127pub struct FieldExpression<'tree> {
3128 pub span: ::treesitter_types::Span,
3129 pub field: FieldExpressionField<'tree>,
3130 pub value: Expression<'tree>,
3131}
3132impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
3133 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3134 fn from_node(
3135 node: ::tree_sitter::Node<'tree>,
3136 src: &'tree [u8],
3137 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3138 debug_assert_eq!(node.kind(), "field_expression");
3139 Ok(Self {
3140 span: ::treesitter_types::Span::from(node),
3141 field: {
3142 let child = node
3143 .child_by_field_name("field")
3144 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3145 <FieldExpressionField as ::treesitter_types::FromNode>::from_node(child, src)?
3146 },
3147 value: {
3148 let child = node
3149 .child_by_field_name("value")
3150 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3151 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3152 },
3153 })
3154 }
3155}
3156impl ::treesitter_types::Spanned for FieldExpression<'_> {
3157 fn span(&self) -> ::treesitter_types::Span {
3158 self.span
3159 }
3160}
3161#[derive(Debug, Clone, PartialEq, Eq)]
3162pub struct FieldInitializer<'tree> {
3163 pub span: ::treesitter_types::Span,
3164 pub field: FieldInitializerField<'tree>,
3165 pub value: Expression<'tree>,
3166 pub children: ::std::vec::Vec<AttributeItem<'tree>>,
3167}
3168impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializer<'tree> {
3169 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3170 fn from_node(
3171 node: ::tree_sitter::Node<'tree>,
3172 src: &'tree [u8],
3173 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3174 debug_assert_eq!(node.kind(), "field_initializer");
3175 Ok(Self {
3176 span: ::treesitter_types::Span::from(node),
3177 field: {
3178 let child = node
3179 .child_by_field_name("field")
3180 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3181 <FieldInitializerField as ::treesitter_types::FromNode>::from_node(child, src)?
3182 },
3183 value: {
3184 let child = node
3185 .child_by_field_name("value")
3186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3187 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3188 },
3189 children: {
3190 #[allow(clippy::suspicious_else_formatting)]
3191 let non_field_children = {
3192 let mut cursor = node.walk();
3193 let mut result = ::std::vec::Vec::new();
3194 if cursor.goto_first_child() {
3195 loop {
3196 if cursor.field_name().is_none()
3197 && cursor.node().is_named()
3198 && !cursor.node().is_extra()
3199 {
3200 result.push(cursor.node());
3201 }
3202 if !cursor.goto_next_sibling() {
3203 break;
3204 }
3205 }
3206 }
3207 result
3208 };
3209 let mut items = ::std::vec::Vec::new();
3210 for child in non_field_children {
3211 items.push(<AttributeItem as ::treesitter_types::FromNode>::from_node(
3212 child, src,
3213 )?);
3214 }
3215 items
3216 },
3217 })
3218 }
3219}
3220impl ::treesitter_types::Spanned for FieldInitializer<'_> {
3221 fn span(&self) -> ::treesitter_types::Span {
3222 self.span
3223 }
3224}
3225#[derive(Debug, Clone, PartialEq, Eq)]
3226pub struct FieldInitializerList<'tree> {
3227 pub span: ::treesitter_types::Span,
3228 pub children: ::std::vec::Vec<FieldInitializerListChildren<'tree>>,
3229}
3230impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerList<'tree> {
3231 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3232 fn from_node(
3233 node: ::tree_sitter::Node<'tree>,
3234 src: &'tree [u8],
3235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3236 debug_assert_eq!(node.kind(), "field_initializer_list");
3237 Ok(Self {
3238 span: ::treesitter_types::Span::from(node),
3239 children: {
3240 #[allow(clippy::suspicious_else_formatting)]
3241 let non_field_children = {
3242 let mut cursor = node.walk();
3243 let mut result = ::std::vec::Vec::new();
3244 if cursor.goto_first_child() {
3245 loop {
3246 if cursor.field_name().is_none()
3247 && cursor.node().is_named()
3248 && !cursor.node().is_extra()
3249 {
3250 result.push(cursor.node());
3251 }
3252 if !cursor.goto_next_sibling() {
3253 break;
3254 }
3255 }
3256 }
3257 result
3258 };
3259 let mut items = ::std::vec::Vec::new();
3260 for child in non_field_children {
3261 items.push(
3262 <FieldInitializerListChildren as ::treesitter_types::FromNode>::from_node(
3263 child, src,
3264 )?,
3265 );
3266 }
3267 items
3268 },
3269 })
3270 }
3271}
3272impl ::treesitter_types::Spanned for FieldInitializerList<'_> {
3273 fn span(&self) -> ::treesitter_types::Span {
3274 self.span
3275 }
3276}
3277#[derive(Debug, Clone, PartialEq, Eq)]
3278pub struct FieldPattern<'tree> {
3279 pub span: ::treesitter_types::Span,
3280 pub name: FieldPatternName<'tree>,
3281 pub pattern: ::core::option::Option<Pattern<'tree>>,
3282 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
3283}
3284impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPattern<'tree> {
3285 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3286 fn from_node(
3287 node: ::tree_sitter::Node<'tree>,
3288 src: &'tree [u8],
3289 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3290 debug_assert_eq!(node.kind(), "field_pattern");
3291 Ok(Self {
3292 span: ::treesitter_types::Span::from(node),
3293 name: {
3294 let child = node
3295 .child_by_field_name("name")
3296 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3297 <FieldPatternName as ::treesitter_types::FromNode>::from_node(child, src)?
3298 },
3299 pattern: match node.child_by_field_name("pattern") {
3300 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
3301 child, src,
3302 )?),
3303 None => None,
3304 },
3305 children: {
3306 #[allow(clippy::suspicious_else_formatting)]
3307 let non_field_children = {
3308 let mut cursor = node.walk();
3309 let mut result = ::std::vec::Vec::new();
3310 if cursor.goto_first_child() {
3311 loop {
3312 if cursor.field_name().is_none()
3313 && cursor.node().is_named()
3314 && !cursor.node().is_extra()
3315 {
3316 result.push(cursor.node());
3317 }
3318 if !cursor.goto_next_sibling() {
3319 break;
3320 }
3321 }
3322 }
3323 result
3324 };
3325 match non_field_children.first() {
3326 Some(&child) => Some(
3327 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
3328 ),
3329 None => None,
3330 }
3331 },
3332 })
3333 }
3334}
3335impl ::treesitter_types::Spanned for FieldPattern<'_> {
3336 fn span(&self) -> ::treesitter_types::Span {
3337 self.span
3338 }
3339}
3340#[derive(Debug, Clone, PartialEq, Eq)]
3341pub struct ForExpression<'tree> {
3342 pub span: ::treesitter_types::Span,
3343 pub body: Block<'tree>,
3344 pub pattern: Pattern<'tree>,
3345 pub value: Expression<'tree>,
3346 pub children: ::core::option::Option<Label<'tree>>,
3347}
3348impl<'tree> ::treesitter_types::FromNode<'tree> for ForExpression<'tree> {
3349 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3350 fn from_node(
3351 node: ::tree_sitter::Node<'tree>,
3352 src: &'tree [u8],
3353 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3354 debug_assert_eq!(node.kind(), "for_expression");
3355 Ok(Self {
3356 span: ::treesitter_types::Span::from(node),
3357 body: {
3358 let child = node
3359 .child_by_field_name("body")
3360 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3361 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3362 },
3363 pattern: {
3364 let child = node.child_by_field_name("pattern").ok_or_else(|| {
3365 ::treesitter_types::ParseError::missing_field("pattern", node)
3366 })?;
3367 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
3368 },
3369 value: {
3370 let child = node
3371 .child_by_field_name("value")
3372 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3373 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3374 },
3375 children: {
3376 #[allow(clippy::suspicious_else_formatting)]
3377 let non_field_children = {
3378 let mut cursor = node.walk();
3379 let mut result = ::std::vec::Vec::new();
3380 if cursor.goto_first_child() {
3381 loop {
3382 if cursor.field_name().is_none()
3383 && cursor.node().is_named()
3384 && !cursor.node().is_extra()
3385 {
3386 result.push(cursor.node());
3387 }
3388 if !cursor.goto_next_sibling() {
3389 break;
3390 }
3391 }
3392 }
3393 result
3394 };
3395 match non_field_children.first() {
3396 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
3397 child, src,
3398 )?),
3399 None => None,
3400 }
3401 },
3402 })
3403 }
3404}
3405impl ::treesitter_types::Spanned for ForExpression<'_> {
3406 fn span(&self) -> ::treesitter_types::Span {
3407 self.span
3408 }
3409}
3410#[derive(Debug, Clone, PartialEq, Eq)]
3411pub struct ForLifetimes<'tree> {
3412 pub span: ::treesitter_types::Span,
3413 pub children: ::std::vec::Vec<Lifetime<'tree>>,
3414}
3415impl<'tree> ::treesitter_types::FromNode<'tree> for ForLifetimes<'tree> {
3416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3417 fn from_node(
3418 node: ::tree_sitter::Node<'tree>,
3419 src: &'tree [u8],
3420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3421 debug_assert_eq!(node.kind(), "for_lifetimes");
3422 Ok(Self {
3423 span: ::treesitter_types::Span::from(node),
3424 children: {
3425 #[allow(clippy::suspicious_else_formatting)]
3426 let non_field_children = {
3427 let mut cursor = node.walk();
3428 let mut result = ::std::vec::Vec::new();
3429 if cursor.goto_first_child() {
3430 loop {
3431 if cursor.field_name().is_none()
3432 && cursor.node().is_named()
3433 && !cursor.node().is_extra()
3434 {
3435 result.push(cursor.node());
3436 }
3437 if !cursor.goto_next_sibling() {
3438 break;
3439 }
3440 }
3441 }
3442 result
3443 };
3444 let mut items = ::std::vec::Vec::new();
3445 for child in non_field_children {
3446 items.push(<Lifetime as ::treesitter_types::FromNode>::from_node(
3447 child, src,
3448 )?);
3449 }
3450 items
3451 },
3452 })
3453 }
3454}
3455impl ::treesitter_types::Spanned for ForLifetimes<'_> {
3456 fn span(&self) -> ::treesitter_types::Span {
3457 self.span
3458 }
3459}
3460#[derive(Debug, Clone, PartialEq, Eq)]
3461pub struct ForeignModItem<'tree> {
3462 pub span: ::treesitter_types::Span,
3463 pub body: ::core::option::Option<DeclarationList<'tree>>,
3464 pub children: ExternModifier<'tree>,
3465}
3466impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignModItem<'tree> {
3467 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3468 fn from_node(
3469 node: ::tree_sitter::Node<'tree>,
3470 src: &'tree [u8],
3471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3472 debug_assert_eq!(node.kind(), "foreign_mod_item");
3473 Ok(Self {
3474 span: ::treesitter_types::Span::from(node),
3475 body: match node.child_by_field_name("body") {
3476 Some(child) => {
3477 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
3478 }
3479 None => None,
3480 },
3481 children: {
3482 #[allow(clippy::suspicious_else_formatting)]
3483 let non_field_children = {
3484 let mut cursor = node.walk();
3485 let mut result = ::std::vec::Vec::new();
3486 if cursor.goto_first_child() {
3487 loop {
3488 if cursor.field_name().is_none()
3489 && cursor.node().is_named()
3490 && !cursor.node().is_extra()
3491 {
3492 result.push(cursor.node());
3493 }
3494 if !cursor.goto_next_sibling() {
3495 break;
3496 }
3497 }
3498 }
3499 result
3500 };
3501 let child = if let Some(&c) = non_field_children.first() {
3502 c
3503 } else {
3504 let mut fallback_cursor = node.walk();
3505 let mut fallback_child = None;
3506 if fallback_cursor.goto_first_child() {
3507 loop {
3508 if fallback_cursor.field_name().is_none()
3509 && !fallback_cursor.node().is_extra()
3510 {
3511 let candidate = fallback_cursor.node();
3512 #[allow(clippy::needless_question_mark)]
3513 if (|| -> ::core::result::Result<
3514 _,
3515 ::treesitter_types::ParseError,
3516 > {
3517 let child = candidate;
3518 Ok(
3519 <ExternModifier as ::treesitter_types::FromNode>::from_node(
3520 child,
3521 src,
3522 )?,
3523 )
3524 })()
3525 .is_ok()
3526 {
3527 fallback_child = Some(candidate);
3528 break;
3529 }
3530 }
3531 if !fallback_cursor.goto_next_sibling() {
3532 break;
3533 }
3534 }
3535 }
3536 if fallback_child.is_none() {
3537 let mut cursor2 = node.walk();
3538 if cursor2.goto_first_child() {
3539 loop {
3540 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3541 let candidate = cursor2.node();
3542 #[allow(clippy::needless_question_mark)]
3543 if (|| -> ::core::result::Result<
3544 _,
3545 ::treesitter_types::ParseError,
3546 > {
3547 let child = candidate;
3548 Ok(
3549 <ExternModifier as ::treesitter_types::FromNode>::from_node(
3550 child,
3551 src,
3552 )?,
3553 )
3554 })()
3555 .is_ok()
3556 {
3557 fallback_child = Some(candidate);
3558 break;
3559 }
3560 }
3561 if !cursor2.goto_next_sibling() {
3562 break;
3563 }
3564 }
3565 }
3566 }
3567 fallback_child.ok_or_else(|| {
3568 ::treesitter_types::ParseError::missing_field("children", node)
3569 })?
3570 };
3571 <ExternModifier as ::treesitter_types::FromNode>::from_node(child, src)?
3572 },
3573 })
3574 }
3575}
3576impl ::treesitter_types::Spanned for ForeignModItem<'_> {
3577 fn span(&self) -> ::treesitter_types::Span {
3578 self.span
3579 }
3580}
3581#[derive(Debug, Clone, PartialEq, Eq)]
3582pub struct FragmentSpecifier<'tree> {
3583 pub span: ::treesitter_types::Span,
3584 text: &'tree str,
3585}
3586impl<'tree> ::treesitter_types::FromNode<'tree> for FragmentSpecifier<'tree> {
3587 fn from_node(
3588 node: ::tree_sitter::Node<'tree>,
3589 src: &'tree [u8],
3590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3591 debug_assert_eq!(node.kind(), "fragment_specifier");
3592 Ok(Self {
3593 span: ::treesitter_types::Span::from(node),
3594 text: node.utf8_text(src)?,
3595 })
3596 }
3597}
3598impl<'tree> ::treesitter_types::LeafNode<'tree> for FragmentSpecifier<'tree> {
3599 fn text(&self) -> &'tree str {
3600 self.text
3601 }
3602}
3603impl ::treesitter_types::Spanned for FragmentSpecifier<'_> {
3604 fn span(&self) -> ::treesitter_types::Span {
3605 self.span
3606 }
3607}
3608#[derive(Debug, Clone, PartialEq, Eq)]
3609pub struct FunctionItem<'tree> {
3610 pub span: ::treesitter_types::Span,
3611 pub body: Block<'tree>,
3612 pub name: FunctionItemName<'tree>,
3613 pub parameters: Parameters<'tree>,
3614 pub return_type: ::core::option::Option<Type<'tree>>,
3615 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3616 pub children: ::std::vec::Vec<FunctionItemChildren<'tree>>,
3617}
3618impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItem<'tree> {
3619 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3620 fn from_node(
3621 node: ::tree_sitter::Node<'tree>,
3622 src: &'tree [u8],
3623 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3624 debug_assert_eq!(node.kind(), "function_item");
3625 Ok(Self {
3626 span: ::treesitter_types::Span::from(node),
3627 body: {
3628 let child = node
3629 .child_by_field_name("body")
3630 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3631 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
3632 },
3633 name: {
3634 let child = node
3635 .child_by_field_name("name")
3636 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3637 <FunctionItemName as ::treesitter_types::FromNode>::from_node(child, src)?
3638 },
3639 parameters: {
3640 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3641 ::treesitter_types::ParseError::missing_field("parameters", node)
3642 })?;
3643 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3644 },
3645 return_type: match node.child_by_field_name("return_type") {
3646 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3647 child, src,
3648 )?),
3649 None => None,
3650 },
3651 type_parameters: match node.child_by_field_name("type_parameters") {
3652 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3653 child, src,
3654 )?),
3655 None => None,
3656 },
3657 children: {
3658 #[allow(clippy::suspicious_else_formatting)]
3659 let non_field_children = {
3660 let mut cursor = node.walk();
3661 let mut result = ::std::vec::Vec::new();
3662 if cursor.goto_first_child() {
3663 loop {
3664 if cursor.field_name().is_none()
3665 && cursor.node().is_named()
3666 && !cursor.node().is_extra()
3667 {
3668 result.push(cursor.node());
3669 }
3670 if !cursor.goto_next_sibling() {
3671 break;
3672 }
3673 }
3674 }
3675 result
3676 };
3677 let mut items = ::std::vec::Vec::new();
3678 for child in non_field_children {
3679 items.push(
3680 <FunctionItemChildren as ::treesitter_types::FromNode>::from_node(
3681 child, src,
3682 )?,
3683 );
3684 }
3685 items
3686 },
3687 })
3688 }
3689}
3690impl ::treesitter_types::Spanned for FunctionItem<'_> {
3691 fn span(&self) -> ::treesitter_types::Span {
3692 self.span
3693 }
3694}
3695#[derive(Debug, Clone, PartialEq, Eq)]
3696pub struct FunctionModifiers<'tree> {
3697 pub span: ::treesitter_types::Span,
3698 pub children: ::std::vec::Vec<ExternModifier<'tree>>,
3699}
3700impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionModifiers<'tree> {
3701 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3702 fn from_node(
3703 node: ::tree_sitter::Node<'tree>,
3704 src: &'tree [u8],
3705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3706 debug_assert_eq!(node.kind(), "function_modifiers");
3707 Ok(Self {
3708 span: ::treesitter_types::Span::from(node),
3709 children: {
3710 #[allow(clippy::suspicious_else_formatting)]
3711 let non_field_children = {
3712 let mut cursor = node.walk();
3713 let mut result = ::std::vec::Vec::new();
3714 if cursor.goto_first_child() {
3715 loop {
3716 if cursor.field_name().is_none()
3717 && cursor.node().is_named()
3718 && !cursor.node().is_extra()
3719 {
3720 result.push(cursor.node());
3721 }
3722 if !cursor.goto_next_sibling() {
3723 break;
3724 }
3725 }
3726 }
3727 result
3728 };
3729 let mut items = ::std::vec::Vec::new();
3730 for child in non_field_children {
3731 items.push(<ExternModifier as ::treesitter_types::FromNode>::from_node(
3732 child, src,
3733 )?);
3734 }
3735 items
3736 },
3737 })
3738 }
3739}
3740impl ::treesitter_types::Spanned for FunctionModifiers<'_> {
3741 fn span(&self) -> ::treesitter_types::Span {
3742 self.span
3743 }
3744}
3745#[derive(Debug, Clone, PartialEq, Eq)]
3746pub struct FunctionSignatureItem<'tree> {
3747 pub span: ::treesitter_types::Span,
3748 pub name: FunctionSignatureItemName<'tree>,
3749 pub parameters: Parameters<'tree>,
3750 pub return_type: ::core::option::Option<Type<'tree>>,
3751 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3752 pub children: ::std::vec::Vec<FunctionSignatureItemChildren<'tree>>,
3753}
3754impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItem<'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(), "function_signature_item");
3761 Ok(Self {
3762 span: ::treesitter_types::Span::from(node),
3763 name: {
3764 let child = node
3765 .child_by_field_name("name")
3766 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3767 <FunctionSignatureItemName as ::treesitter_types::FromNode>::from_node(child, src)?
3768 },
3769 parameters: {
3770 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3771 ::treesitter_types::ParseError::missing_field("parameters", node)
3772 })?;
3773 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3774 },
3775 return_type: match node.child_by_field_name("return_type") {
3776 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3777 child, src,
3778 )?),
3779 None => None,
3780 },
3781 type_parameters: match node.child_by_field_name("type_parameters") {
3782 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3783 child, src,
3784 )?),
3785 None => None,
3786 },
3787 children: {
3788 #[allow(clippy::suspicious_else_formatting)]
3789 let non_field_children = {
3790 let mut cursor = node.walk();
3791 let mut result = ::std::vec::Vec::new();
3792 if cursor.goto_first_child() {
3793 loop {
3794 if cursor.field_name().is_none()
3795 && cursor.node().is_named()
3796 && !cursor.node().is_extra()
3797 {
3798 result.push(cursor.node());
3799 }
3800 if !cursor.goto_next_sibling() {
3801 break;
3802 }
3803 }
3804 }
3805 result
3806 };
3807 let mut items = ::std::vec::Vec::new();
3808 for child in non_field_children {
3809 items.push(
3810 <FunctionSignatureItemChildren as ::treesitter_types::FromNode>::from_node(
3811 child, src,
3812 )?,
3813 );
3814 }
3815 items
3816 },
3817 })
3818 }
3819}
3820impl ::treesitter_types::Spanned for FunctionSignatureItem<'_> {
3821 fn span(&self) -> ::treesitter_types::Span {
3822 self.span
3823 }
3824}
3825#[derive(Debug, Clone, PartialEq, Eq)]
3826pub struct FunctionType<'tree> {
3827 pub span: ::treesitter_types::Span,
3828 pub parameters: Parameters<'tree>,
3829 pub return_type: ::core::option::Option<Type<'tree>>,
3830 pub r#trait: ::core::option::Option<FunctionTypeTrait<'tree>>,
3831 pub children: ::std::vec::Vec<FunctionTypeChildren<'tree>>,
3832}
3833impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
3834 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3835 fn from_node(
3836 node: ::tree_sitter::Node<'tree>,
3837 src: &'tree [u8],
3838 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3839 debug_assert_eq!(node.kind(), "function_type");
3840 Ok(Self {
3841 span: ::treesitter_types::Span::from(node),
3842 parameters: {
3843 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3844 ::treesitter_types::ParseError::missing_field("parameters", node)
3845 })?;
3846 <Parameters as ::treesitter_types::FromNode>::from_node(child, src)?
3847 },
3848 return_type: match node.child_by_field_name("return_type") {
3849 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3850 child, src,
3851 )?),
3852 None => None,
3853 },
3854 r#trait: match node.child_by_field_name("trait") {
3855 Some(child) => Some(
3856 <FunctionTypeTrait as ::treesitter_types::FromNode>::from_node(child, src)?,
3857 ),
3858 None => None,
3859 },
3860 children: {
3861 #[allow(clippy::suspicious_else_formatting)]
3862 let non_field_children = {
3863 let mut cursor = node.walk();
3864 let mut result = ::std::vec::Vec::new();
3865 if cursor.goto_first_child() {
3866 loop {
3867 if cursor.field_name().is_none()
3868 && cursor.node().is_named()
3869 && !cursor.node().is_extra()
3870 {
3871 result.push(cursor.node());
3872 }
3873 if !cursor.goto_next_sibling() {
3874 break;
3875 }
3876 }
3877 }
3878 result
3879 };
3880 let mut items = ::std::vec::Vec::new();
3881 for child in non_field_children {
3882 items.push(
3883 <FunctionTypeChildren as ::treesitter_types::FromNode>::from_node(
3884 child, src,
3885 )?,
3886 );
3887 }
3888 items
3889 },
3890 })
3891 }
3892}
3893impl ::treesitter_types::Spanned for FunctionType<'_> {
3894 fn span(&self) -> ::treesitter_types::Span {
3895 self.span
3896 }
3897}
3898#[derive(Debug, Clone, PartialEq, Eq)]
3899pub struct GenBlock<'tree> {
3900 pub span: ::treesitter_types::Span,
3901 pub children: Block<'tree>,
3902}
3903impl<'tree> ::treesitter_types::FromNode<'tree> for GenBlock<'tree> {
3904 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3905 fn from_node(
3906 node: ::tree_sitter::Node<'tree>,
3907 src: &'tree [u8],
3908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3909 debug_assert_eq!(node.kind(), "gen_block");
3910 Ok(Self {
3911 span: ::treesitter_types::Span::from(node),
3912 children: {
3913 #[allow(clippy::suspicious_else_formatting)]
3914 let non_field_children = {
3915 let mut cursor = node.walk();
3916 let mut result = ::std::vec::Vec::new();
3917 if cursor.goto_first_child() {
3918 loop {
3919 if cursor.field_name().is_none()
3920 && cursor.node().is_named()
3921 && !cursor.node().is_extra()
3922 {
3923 result.push(cursor.node());
3924 }
3925 if !cursor.goto_next_sibling() {
3926 break;
3927 }
3928 }
3929 }
3930 result
3931 };
3932 let child = if let Some(&c) = non_field_children.first() {
3933 c
3934 } else {
3935 let mut fallback_cursor = node.walk();
3936 let mut fallback_child = None;
3937 if fallback_cursor.goto_first_child() {
3938 loop {
3939 if fallback_cursor.field_name().is_none()
3940 && !fallback_cursor.node().is_extra()
3941 {
3942 let candidate = fallback_cursor.node();
3943 #[allow(clippy::needless_question_mark)]
3944 if (|| -> ::core::result::Result<
3945 _,
3946 ::treesitter_types::ParseError,
3947 > {
3948 let child = candidate;
3949 Ok(
3950 <Block as ::treesitter_types::FromNode>::from_node(
3951 child,
3952 src,
3953 )?,
3954 )
3955 })()
3956 .is_ok()
3957 {
3958 fallback_child = Some(candidate);
3959 break;
3960 }
3961 }
3962 if !fallback_cursor.goto_next_sibling() {
3963 break;
3964 }
3965 }
3966 }
3967 if fallback_child.is_none() {
3968 let mut cursor2 = node.walk();
3969 if cursor2.goto_first_child() {
3970 loop {
3971 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3972 let candidate = cursor2.node();
3973 #[allow(clippy::needless_question_mark)]
3974 if (|| -> ::core::result::Result<
3975 _,
3976 ::treesitter_types::ParseError,
3977 > {
3978 let child = candidate;
3979 Ok(
3980 <Block as ::treesitter_types::FromNode>::from_node(
3981 child,
3982 src,
3983 )?,
3984 )
3985 })()
3986 .is_ok()
3987 {
3988 fallback_child = Some(candidate);
3989 break;
3990 }
3991 }
3992 if !cursor2.goto_next_sibling() {
3993 break;
3994 }
3995 }
3996 }
3997 }
3998 fallback_child.ok_or_else(|| {
3999 ::treesitter_types::ParseError::missing_field("children", node)
4000 })?
4001 };
4002 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
4003 },
4004 })
4005 }
4006}
4007impl ::treesitter_types::Spanned for GenBlock<'_> {
4008 fn span(&self) -> ::treesitter_types::Span {
4009 self.span
4010 }
4011}
4012#[derive(Debug, Clone, PartialEq, Eq)]
4013pub struct GenericFunction<'tree> {
4014 pub span: ::treesitter_types::Span,
4015 pub function: GenericFunctionFunction<'tree>,
4016 pub type_arguments: TypeArguments<'tree>,
4017}
4018impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunction<'tree> {
4019 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4020 fn from_node(
4021 node: ::tree_sitter::Node<'tree>,
4022 src: &'tree [u8],
4023 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4024 debug_assert_eq!(node.kind(), "generic_function");
4025 Ok(Self {
4026 span: ::treesitter_types::Span::from(node),
4027 function: {
4028 let child = node.child_by_field_name("function").ok_or_else(|| {
4029 ::treesitter_types::ParseError::missing_field("function", node)
4030 })?;
4031 <GenericFunctionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
4032 },
4033 type_arguments: {
4034 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4035 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4036 })?;
4037 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
4038 },
4039 })
4040 }
4041}
4042impl ::treesitter_types::Spanned for GenericFunction<'_> {
4043 fn span(&self) -> ::treesitter_types::Span {
4044 self.span
4045 }
4046}
4047#[derive(Debug, Clone, PartialEq, Eq)]
4048pub struct GenericPattern<'tree> {
4049 pub span: ::treesitter_types::Span,
4050 pub type_arguments: TypeArguments<'tree>,
4051 pub children: GenericPatternChildren<'tree>,
4052}
4053impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPattern<'tree> {
4054 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4055 fn from_node(
4056 node: ::tree_sitter::Node<'tree>,
4057 src: &'tree [u8],
4058 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4059 debug_assert_eq!(node.kind(), "generic_pattern");
4060 Ok(Self {
4061 span: ::treesitter_types::Span::from(node),
4062 type_arguments: {
4063 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4064 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4065 })?;
4066 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
4067 },
4068 children: {
4069 #[allow(clippy::suspicious_else_formatting)]
4070 let non_field_children = {
4071 let mut cursor = node.walk();
4072 let mut result = ::std::vec::Vec::new();
4073 if cursor.goto_first_child() {
4074 loop {
4075 if cursor.field_name().is_none()
4076 && cursor.node().is_named()
4077 && !cursor.node().is_extra()
4078 {
4079 result.push(cursor.node());
4080 }
4081 if !cursor.goto_next_sibling() {
4082 break;
4083 }
4084 }
4085 }
4086 result
4087 };
4088 let child = if let Some(&c) = non_field_children.first() {
4089 c
4090 } else {
4091 let mut fallback_cursor = node.walk();
4092 let mut fallback_child = None;
4093 if fallback_cursor.goto_first_child() {
4094 loop {
4095 if fallback_cursor.field_name().is_none()
4096 && !fallback_cursor.node().is_extra()
4097 {
4098 let candidate = fallback_cursor.node();
4099 #[allow(clippy::needless_question_mark)]
4100 if (|| -> ::core::result::Result<
4101 _,
4102 ::treesitter_types::ParseError,
4103 > {
4104 let child = candidate;
4105 Ok(
4106 <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(
4107 child,
4108 src,
4109 )?,
4110 )
4111 })()
4112 .is_ok()
4113 {
4114 fallback_child = Some(candidate);
4115 break;
4116 }
4117 }
4118 if !fallback_cursor.goto_next_sibling() {
4119 break;
4120 }
4121 }
4122 }
4123 if fallback_child.is_none() {
4124 let mut cursor2 = node.walk();
4125 if cursor2.goto_first_child() {
4126 loop {
4127 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4128 let candidate = cursor2.node();
4129 #[allow(clippy::needless_question_mark)]
4130 if (|| -> ::core::result::Result<
4131 _,
4132 ::treesitter_types::ParseError,
4133 > {
4134 let child = candidate;
4135 Ok(
4136 <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(
4137 child,
4138 src,
4139 )?,
4140 )
4141 })()
4142 .is_ok()
4143 {
4144 fallback_child = Some(candidate);
4145 break;
4146 }
4147 }
4148 if !cursor2.goto_next_sibling() {
4149 break;
4150 }
4151 }
4152 }
4153 }
4154 fallback_child.ok_or_else(|| {
4155 ::treesitter_types::ParseError::missing_field("children", node)
4156 })?
4157 };
4158 <GenericPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4159 },
4160 })
4161 }
4162}
4163impl ::treesitter_types::Spanned for GenericPattern<'_> {
4164 fn span(&self) -> ::treesitter_types::Span {
4165 self.span
4166 }
4167}
4168#[derive(Debug, Clone, PartialEq, Eq)]
4169pub struct GenericType<'tree> {
4170 pub span: ::treesitter_types::Span,
4171 pub r#type: GenericTypeType<'tree>,
4172 pub type_arguments: TypeArguments<'tree>,
4173}
4174impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
4175 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4176 fn from_node(
4177 node: ::tree_sitter::Node<'tree>,
4178 src: &'tree [u8],
4179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4180 debug_assert_eq!(node.kind(), "generic_type");
4181 Ok(Self {
4182 span: ::treesitter_types::Span::from(node),
4183 r#type: {
4184 let child = node
4185 .child_by_field_name("type")
4186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4187 <GenericTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
4188 },
4189 type_arguments: {
4190 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4191 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4192 })?;
4193 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
4194 },
4195 })
4196 }
4197}
4198impl ::treesitter_types::Spanned for GenericType<'_> {
4199 fn span(&self) -> ::treesitter_types::Span {
4200 self.span
4201 }
4202}
4203#[derive(Debug, Clone, PartialEq, Eq)]
4204pub struct GenericTypeWithTurbofish<'tree> {
4205 pub span: ::treesitter_types::Span,
4206 pub r#type: GenericTypeWithTurbofishType<'tree>,
4207 pub type_arguments: TypeArguments<'tree>,
4208}
4209impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofish<'tree> {
4210 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4211 fn from_node(
4212 node: ::tree_sitter::Node<'tree>,
4213 src: &'tree [u8],
4214 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4215 debug_assert_eq!(node.kind(), "generic_type_with_turbofish");
4216 Ok(Self {
4217 span: ::treesitter_types::Span::from(node),
4218 r#type: {
4219 let child = node
4220 .child_by_field_name("type")
4221 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4222 <GenericTypeWithTurbofishType as ::treesitter_types::FromNode>::from_node(
4223 child, src,
4224 )?
4225 },
4226 type_arguments: {
4227 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4228 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4229 })?;
4230 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
4231 },
4232 })
4233 }
4234}
4235impl ::treesitter_types::Spanned for GenericTypeWithTurbofish<'_> {
4236 fn span(&self) -> ::treesitter_types::Span {
4237 self.span
4238 }
4239}
4240#[derive(Debug, Clone, PartialEq, Eq)]
4241pub struct HigherRankedTraitBound<'tree> {
4242 pub span: ::treesitter_types::Span,
4243 pub r#type: Type<'tree>,
4244 pub type_parameters: TypeParameters<'tree>,
4245}
4246impl<'tree> ::treesitter_types::FromNode<'tree> for HigherRankedTraitBound<'tree> {
4247 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4248 fn from_node(
4249 node: ::tree_sitter::Node<'tree>,
4250 src: &'tree [u8],
4251 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4252 debug_assert_eq!(node.kind(), "higher_ranked_trait_bound");
4253 Ok(Self {
4254 span: ::treesitter_types::Span::from(node),
4255 r#type: {
4256 let child = node
4257 .child_by_field_name("type")
4258 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4259 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
4260 },
4261 type_parameters: {
4262 let child = node.child_by_field_name("type_parameters").ok_or_else(|| {
4263 ::treesitter_types::ParseError::missing_field("type_parameters", node)
4264 })?;
4265 <TypeParameters as ::treesitter_types::FromNode>::from_node(child, src)?
4266 },
4267 })
4268 }
4269}
4270impl ::treesitter_types::Spanned for HigherRankedTraitBound<'_> {
4271 fn span(&self) -> ::treesitter_types::Span {
4272 self.span
4273 }
4274}
4275#[derive(Debug, Clone, PartialEq, Eq)]
4276pub struct IfExpression<'tree> {
4277 pub span: ::treesitter_types::Span,
4278 pub alternative: ::core::option::Option<ElseClause<'tree>>,
4279 pub condition: IfExpressionCondition<'tree>,
4280 pub consequence: Block<'tree>,
4281}
4282impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpression<'tree> {
4283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4284 fn from_node(
4285 node: ::tree_sitter::Node<'tree>,
4286 src: &'tree [u8],
4287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4288 debug_assert_eq!(node.kind(), "if_expression");
4289 Ok(Self {
4290 span: ::treesitter_types::Span::from(node),
4291 alternative: match node.child_by_field_name("alternative") {
4292 Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
4293 child, src,
4294 )?),
4295 None => None,
4296 },
4297 condition: {
4298 let child = node.child_by_field_name("condition").ok_or_else(|| {
4299 ::treesitter_types::ParseError::missing_field("condition", node)
4300 })?;
4301 <IfExpressionCondition as ::treesitter_types::FromNode>::from_node(child, src)?
4302 },
4303 consequence: {
4304 let child = node.child_by_field_name("consequence").ok_or_else(|| {
4305 ::treesitter_types::ParseError::missing_field("consequence", node)
4306 })?;
4307 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
4308 },
4309 })
4310 }
4311}
4312impl ::treesitter_types::Spanned for IfExpression<'_> {
4313 fn span(&self) -> ::treesitter_types::Span {
4314 self.span
4315 }
4316}
4317#[derive(Debug, Clone, PartialEq, Eq)]
4318pub struct ImplItem<'tree> {
4319 pub span: ::treesitter_types::Span,
4320 pub body: ::core::option::Option<DeclarationList<'tree>>,
4321 pub r#trait: ::core::option::Option<ImplItemTrait<'tree>>,
4322 pub r#type: Type<'tree>,
4323 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4324 pub children: ::core::option::Option<WhereClause<'tree>>,
4325}
4326impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItem<'tree> {
4327 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4328 fn from_node(
4329 node: ::tree_sitter::Node<'tree>,
4330 src: &'tree [u8],
4331 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4332 debug_assert_eq!(node.kind(), "impl_item");
4333 Ok(Self {
4334 span: ::treesitter_types::Span::from(node),
4335 body: match node.child_by_field_name("body") {
4336 Some(child) => {
4337 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
4338 }
4339 None => None,
4340 },
4341 r#trait: match node.child_by_field_name("trait") {
4342 Some(child) => Some(<ImplItemTrait as ::treesitter_types::FromNode>::from_node(
4343 child, src,
4344 )?),
4345 None => None,
4346 },
4347 r#type: {
4348 let child = node
4349 .child_by_field_name("type")
4350 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4351 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
4352 },
4353 type_parameters: match node.child_by_field_name("type_parameters") {
4354 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
4355 child, src,
4356 )?),
4357 None => None,
4358 },
4359 children: {
4360 #[allow(clippy::suspicious_else_formatting)]
4361 let non_field_children = {
4362 let mut cursor = node.walk();
4363 let mut result = ::std::vec::Vec::new();
4364 if cursor.goto_first_child() {
4365 loop {
4366 if cursor.field_name().is_none()
4367 && cursor.node().is_named()
4368 && !cursor.node().is_extra()
4369 {
4370 result.push(cursor.node());
4371 }
4372 if !cursor.goto_next_sibling() {
4373 break;
4374 }
4375 }
4376 }
4377 result
4378 };
4379 match non_field_children.first() {
4380 Some(&child) => Some(<WhereClause as ::treesitter_types::FromNode>::from_node(
4381 child, src,
4382 )?),
4383 None => None,
4384 }
4385 },
4386 })
4387 }
4388}
4389impl ::treesitter_types::Spanned for ImplItem<'_> {
4390 fn span(&self) -> ::treesitter_types::Span {
4391 self.span
4392 }
4393}
4394#[derive(Debug, Clone, PartialEq, Eq)]
4395pub struct IndexExpression<'tree> {
4396 pub span: ::treesitter_types::Span,
4397 pub children: ::std::vec::Vec<Expression<'tree>>,
4398}
4399impl<'tree> ::treesitter_types::FromNode<'tree> for IndexExpression<'tree> {
4400 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4401 fn from_node(
4402 node: ::tree_sitter::Node<'tree>,
4403 src: &'tree [u8],
4404 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4405 debug_assert_eq!(node.kind(), "index_expression");
4406 Ok(Self {
4407 span: ::treesitter_types::Span::from(node),
4408 children: {
4409 #[allow(clippy::suspicious_else_formatting)]
4410 let non_field_children = {
4411 let mut cursor = node.walk();
4412 let mut result = ::std::vec::Vec::new();
4413 if cursor.goto_first_child() {
4414 loop {
4415 if cursor.field_name().is_none()
4416 && cursor.node().is_named()
4417 && !cursor.node().is_extra()
4418 {
4419 result.push(cursor.node());
4420 }
4421 if !cursor.goto_next_sibling() {
4422 break;
4423 }
4424 }
4425 }
4426 result
4427 };
4428 let mut items = ::std::vec::Vec::new();
4429 for child in non_field_children {
4430 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
4431 child, src,
4432 )?);
4433 }
4434 items
4435 },
4436 })
4437 }
4438}
4439impl ::treesitter_types::Spanned for IndexExpression<'_> {
4440 fn span(&self) -> ::treesitter_types::Span {
4441 self.span
4442 }
4443}
4444#[derive(Debug, Clone, PartialEq, Eq)]
4445pub struct InnerAttributeItem<'tree> {
4446 pub span: ::treesitter_types::Span,
4447 pub children: Attribute<'tree>,
4448}
4449impl<'tree> ::treesitter_types::FromNode<'tree> for InnerAttributeItem<'tree> {
4450 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4451 fn from_node(
4452 node: ::tree_sitter::Node<'tree>,
4453 src: &'tree [u8],
4454 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4455 debug_assert_eq!(node.kind(), "inner_attribute_item");
4456 Ok(Self {
4457 span: ::treesitter_types::Span::from(node),
4458 children: {
4459 #[allow(clippy::suspicious_else_formatting)]
4460 let non_field_children = {
4461 let mut cursor = node.walk();
4462 let mut result = ::std::vec::Vec::new();
4463 if cursor.goto_first_child() {
4464 loop {
4465 if cursor.field_name().is_none()
4466 && cursor.node().is_named()
4467 && !cursor.node().is_extra()
4468 {
4469 result.push(cursor.node());
4470 }
4471 if !cursor.goto_next_sibling() {
4472 break;
4473 }
4474 }
4475 }
4476 result
4477 };
4478 let child = if let Some(&c) = non_field_children.first() {
4479 c
4480 } else {
4481 let mut fallback_cursor = node.walk();
4482 let mut fallback_child = None;
4483 if fallback_cursor.goto_first_child() {
4484 loop {
4485 if fallback_cursor.field_name().is_none()
4486 && !fallback_cursor.node().is_extra()
4487 {
4488 let candidate = fallback_cursor.node();
4489 #[allow(clippy::needless_question_mark)]
4490 if (|| -> ::core::result::Result<
4491 _,
4492 ::treesitter_types::ParseError,
4493 > {
4494 let child = candidate;
4495 Ok(
4496 <Attribute as ::treesitter_types::FromNode>::from_node(
4497 child,
4498 src,
4499 )?,
4500 )
4501 })()
4502 .is_ok()
4503 {
4504 fallback_child = Some(candidate);
4505 break;
4506 }
4507 }
4508 if !fallback_cursor.goto_next_sibling() {
4509 break;
4510 }
4511 }
4512 }
4513 if fallback_child.is_none() {
4514 let mut cursor2 = node.walk();
4515 if cursor2.goto_first_child() {
4516 loop {
4517 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4518 let candidate = cursor2.node();
4519 #[allow(clippy::needless_question_mark)]
4520 if (|| -> ::core::result::Result<
4521 _,
4522 ::treesitter_types::ParseError,
4523 > {
4524 let child = candidate;
4525 Ok(
4526 <Attribute as ::treesitter_types::FromNode>::from_node(
4527 child,
4528 src,
4529 )?,
4530 )
4531 })()
4532 .is_ok()
4533 {
4534 fallback_child = Some(candidate);
4535 break;
4536 }
4537 }
4538 if !cursor2.goto_next_sibling() {
4539 break;
4540 }
4541 }
4542 }
4543 }
4544 fallback_child.ok_or_else(|| {
4545 ::treesitter_types::ParseError::missing_field("children", node)
4546 })?
4547 };
4548 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)?
4549 },
4550 })
4551 }
4552}
4553impl ::treesitter_types::Spanned for InnerAttributeItem<'_> {
4554 fn span(&self) -> ::treesitter_types::Span {
4555 self.span
4556 }
4557}
4558#[derive(Debug, Clone, PartialEq, Eq)]
4559pub struct InnerDocCommentMarker<'tree> {
4560 pub span: ::treesitter_types::Span,
4561 text: &'tree str,
4562}
4563impl<'tree> ::treesitter_types::FromNode<'tree> for InnerDocCommentMarker<'tree> {
4564 fn from_node(
4565 node: ::tree_sitter::Node<'tree>,
4566 src: &'tree [u8],
4567 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4568 debug_assert_eq!(node.kind(), "inner_doc_comment_marker");
4569 Ok(Self {
4570 span: ::treesitter_types::Span::from(node),
4571 text: node.utf8_text(src)?,
4572 })
4573 }
4574}
4575impl<'tree> ::treesitter_types::LeafNode<'tree> for InnerDocCommentMarker<'tree> {
4576 fn text(&self) -> &'tree str {
4577 self.text
4578 }
4579}
4580impl ::treesitter_types::Spanned for InnerDocCommentMarker<'_> {
4581 fn span(&self) -> ::treesitter_types::Span {
4582 self.span
4583 }
4584}
4585#[derive(Debug, Clone, PartialEq, Eq)]
4586pub struct Label<'tree> {
4587 pub span: ::treesitter_types::Span,
4588 pub children: Identifier<'tree>,
4589}
4590impl<'tree> ::treesitter_types::FromNode<'tree> for Label<'tree> {
4591 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4592 fn from_node(
4593 node: ::tree_sitter::Node<'tree>,
4594 src: &'tree [u8],
4595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4596 debug_assert_eq!(node.kind(), "label");
4597 Ok(Self {
4598 span: ::treesitter_types::Span::from(node),
4599 children: {
4600 #[allow(clippy::suspicious_else_formatting)]
4601 let non_field_children = {
4602 let mut cursor = node.walk();
4603 let mut result = ::std::vec::Vec::new();
4604 if cursor.goto_first_child() {
4605 loop {
4606 if cursor.field_name().is_none()
4607 && cursor.node().is_named()
4608 && !cursor.node().is_extra()
4609 {
4610 result.push(cursor.node());
4611 }
4612 if !cursor.goto_next_sibling() {
4613 break;
4614 }
4615 }
4616 }
4617 result
4618 };
4619 let child = if let Some(&c) = non_field_children.first() {
4620 c
4621 } else {
4622 let mut fallback_cursor = node.walk();
4623 let mut fallback_child = None;
4624 if fallback_cursor.goto_first_child() {
4625 loop {
4626 if fallback_cursor.field_name().is_none()
4627 && !fallback_cursor.node().is_extra()
4628 {
4629 let candidate = fallback_cursor.node();
4630 #[allow(clippy::needless_question_mark)]
4631 if (|| -> ::core::result::Result<
4632 _,
4633 ::treesitter_types::ParseError,
4634 > {
4635 let child = candidate;
4636 Ok(
4637 <Identifier as ::treesitter_types::FromNode>::from_node(
4638 child,
4639 src,
4640 )?,
4641 )
4642 })()
4643 .is_ok()
4644 {
4645 fallback_child = Some(candidate);
4646 break;
4647 }
4648 }
4649 if !fallback_cursor.goto_next_sibling() {
4650 break;
4651 }
4652 }
4653 }
4654 if fallback_child.is_none() {
4655 let mut cursor2 = node.walk();
4656 if cursor2.goto_first_child() {
4657 loop {
4658 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4659 let candidate = cursor2.node();
4660 #[allow(clippy::needless_question_mark)]
4661 if (|| -> ::core::result::Result<
4662 _,
4663 ::treesitter_types::ParseError,
4664 > {
4665 let child = candidate;
4666 Ok(
4667 <Identifier as ::treesitter_types::FromNode>::from_node(
4668 child,
4669 src,
4670 )?,
4671 )
4672 })()
4673 .is_ok()
4674 {
4675 fallback_child = Some(candidate);
4676 break;
4677 }
4678 }
4679 if !cursor2.goto_next_sibling() {
4680 break;
4681 }
4682 }
4683 }
4684 }
4685 fallback_child.ok_or_else(|| {
4686 ::treesitter_types::ParseError::missing_field("children", node)
4687 })?
4688 };
4689 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4690 },
4691 })
4692 }
4693}
4694impl ::treesitter_types::Spanned for Label<'_> {
4695 fn span(&self) -> ::treesitter_types::Span {
4696 self.span
4697 }
4698}
4699#[derive(Debug, Clone, PartialEq, Eq)]
4700pub struct LetChain<'tree> {
4701 pub span: ::treesitter_types::Span,
4702 pub children: ::std::vec::Vec<LetChainChildren<'tree>>,
4703}
4704impl<'tree> ::treesitter_types::FromNode<'tree> for LetChain<'tree> {
4705 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4706 fn from_node(
4707 node: ::tree_sitter::Node<'tree>,
4708 src: &'tree [u8],
4709 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4710 debug_assert_eq!(node.kind(), "let_chain");
4711 Ok(Self {
4712 span: ::treesitter_types::Span::from(node),
4713 children: {
4714 #[allow(clippy::suspicious_else_formatting)]
4715 let non_field_children = {
4716 let mut cursor = node.walk();
4717 let mut result = ::std::vec::Vec::new();
4718 if cursor.goto_first_child() {
4719 loop {
4720 if cursor.field_name().is_none()
4721 && cursor.node().is_named()
4722 && !cursor.node().is_extra()
4723 {
4724 result.push(cursor.node());
4725 }
4726 if !cursor.goto_next_sibling() {
4727 break;
4728 }
4729 }
4730 }
4731 result
4732 };
4733 let mut items = ::std::vec::Vec::new();
4734 for child in non_field_children {
4735 items.push(
4736 <LetChainChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4737 );
4738 }
4739 items
4740 },
4741 })
4742 }
4743}
4744impl ::treesitter_types::Spanned for LetChain<'_> {
4745 fn span(&self) -> ::treesitter_types::Span {
4746 self.span
4747 }
4748}
4749#[derive(Debug, Clone, PartialEq, Eq)]
4750pub struct LetCondition<'tree> {
4751 pub span: ::treesitter_types::Span,
4752 pub pattern: Pattern<'tree>,
4753 pub value: Expression<'tree>,
4754}
4755impl<'tree> ::treesitter_types::FromNode<'tree> for LetCondition<'tree> {
4756 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4757 fn from_node(
4758 node: ::tree_sitter::Node<'tree>,
4759 src: &'tree [u8],
4760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4761 debug_assert_eq!(node.kind(), "let_condition");
4762 Ok(Self {
4763 span: ::treesitter_types::Span::from(node),
4764 pattern: {
4765 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4766 ::treesitter_types::ParseError::missing_field("pattern", node)
4767 })?;
4768 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
4769 },
4770 value: {
4771 let child = node
4772 .child_by_field_name("value")
4773 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4774 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4775 },
4776 })
4777 }
4778}
4779impl ::treesitter_types::Spanned for LetCondition<'_> {
4780 fn span(&self) -> ::treesitter_types::Span {
4781 self.span
4782 }
4783}
4784#[derive(Debug, Clone, PartialEq, Eq)]
4785pub struct LetDeclaration<'tree> {
4786 pub span: ::treesitter_types::Span,
4787 pub alternative: ::core::option::Option<Block<'tree>>,
4788 pub pattern: Pattern<'tree>,
4789 pub r#type: ::core::option::Option<Type<'tree>>,
4790 pub value: ::core::option::Option<Expression<'tree>>,
4791 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
4792}
4793impl<'tree> ::treesitter_types::FromNode<'tree> for LetDeclaration<'tree> {
4794 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4795 fn from_node(
4796 node: ::tree_sitter::Node<'tree>,
4797 src: &'tree [u8],
4798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4799 debug_assert_eq!(node.kind(), "let_declaration");
4800 Ok(Self {
4801 span: ::treesitter_types::Span::from(node),
4802 alternative: match node.child_by_field_name("alternative") {
4803 Some(child) => Some(<Block as ::treesitter_types::FromNode>::from_node(
4804 child, src,
4805 )?),
4806 None => None,
4807 },
4808 pattern: {
4809 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4810 ::treesitter_types::ParseError::missing_field("pattern", node)
4811 })?;
4812 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
4813 },
4814 r#type: match node.child_by_field_name("type") {
4815 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
4816 child, src,
4817 )?),
4818 None => None,
4819 },
4820 value: match node.child_by_field_name("value") {
4821 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4822 child, src,
4823 )?),
4824 None => None,
4825 },
4826 children: {
4827 #[allow(clippy::suspicious_else_formatting)]
4828 let non_field_children = {
4829 let mut cursor = node.walk();
4830 let mut result = ::std::vec::Vec::new();
4831 if cursor.goto_first_child() {
4832 loop {
4833 if cursor.field_name().is_none()
4834 && cursor.node().is_named()
4835 && !cursor.node().is_extra()
4836 {
4837 result.push(cursor.node());
4838 }
4839 if !cursor.goto_next_sibling() {
4840 break;
4841 }
4842 }
4843 }
4844 result
4845 };
4846 match non_field_children.first() {
4847 Some(&child) => Some(
4848 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
4849 ),
4850 None => None,
4851 }
4852 },
4853 })
4854 }
4855}
4856impl ::treesitter_types::Spanned for LetDeclaration<'_> {
4857 fn span(&self) -> ::treesitter_types::Span {
4858 self.span
4859 }
4860}
4861#[derive(Debug, Clone, PartialEq, Eq)]
4862pub struct Lifetime<'tree> {
4863 pub span: ::treesitter_types::Span,
4864 pub children: Identifier<'tree>,
4865}
4866impl<'tree> ::treesitter_types::FromNode<'tree> for Lifetime<'tree> {
4867 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4868 fn from_node(
4869 node: ::tree_sitter::Node<'tree>,
4870 src: &'tree [u8],
4871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4872 debug_assert_eq!(node.kind(), "lifetime");
4873 Ok(Self {
4874 span: ::treesitter_types::Span::from(node),
4875 children: {
4876 #[allow(clippy::suspicious_else_formatting)]
4877 let non_field_children = {
4878 let mut cursor = node.walk();
4879 let mut result = ::std::vec::Vec::new();
4880 if cursor.goto_first_child() {
4881 loop {
4882 if cursor.field_name().is_none()
4883 && cursor.node().is_named()
4884 && !cursor.node().is_extra()
4885 {
4886 result.push(cursor.node());
4887 }
4888 if !cursor.goto_next_sibling() {
4889 break;
4890 }
4891 }
4892 }
4893 result
4894 };
4895 let child = if let Some(&c) = non_field_children.first() {
4896 c
4897 } else {
4898 let mut fallback_cursor = node.walk();
4899 let mut fallback_child = None;
4900 if fallback_cursor.goto_first_child() {
4901 loop {
4902 if fallback_cursor.field_name().is_none()
4903 && !fallback_cursor.node().is_extra()
4904 {
4905 let candidate = fallback_cursor.node();
4906 #[allow(clippy::needless_question_mark)]
4907 if (|| -> ::core::result::Result<
4908 _,
4909 ::treesitter_types::ParseError,
4910 > {
4911 let child = candidate;
4912 Ok(
4913 <Identifier as ::treesitter_types::FromNode>::from_node(
4914 child,
4915 src,
4916 )?,
4917 )
4918 })()
4919 .is_ok()
4920 {
4921 fallback_child = Some(candidate);
4922 break;
4923 }
4924 }
4925 if !fallback_cursor.goto_next_sibling() {
4926 break;
4927 }
4928 }
4929 }
4930 if fallback_child.is_none() {
4931 let mut cursor2 = node.walk();
4932 if cursor2.goto_first_child() {
4933 loop {
4934 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4935 let candidate = cursor2.node();
4936 #[allow(clippy::needless_question_mark)]
4937 if (|| -> ::core::result::Result<
4938 _,
4939 ::treesitter_types::ParseError,
4940 > {
4941 let child = candidate;
4942 Ok(
4943 <Identifier as ::treesitter_types::FromNode>::from_node(
4944 child,
4945 src,
4946 )?,
4947 )
4948 })()
4949 .is_ok()
4950 {
4951 fallback_child = Some(candidate);
4952 break;
4953 }
4954 }
4955 if !cursor2.goto_next_sibling() {
4956 break;
4957 }
4958 }
4959 }
4960 }
4961 fallback_child.ok_or_else(|| {
4962 ::treesitter_types::ParseError::missing_field("children", node)
4963 })?
4964 };
4965 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4966 },
4967 })
4968 }
4969}
4970impl ::treesitter_types::Spanned for Lifetime<'_> {
4971 fn span(&self) -> ::treesitter_types::Span {
4972 self.span
4973 }
4974}
4975#[derive(Debug, Clone, PartialEq, Eq)]
4976pub struct LifetimeParameter<'tree> {
4977 pub span: ::treesitter_types::Span,
4978 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
4979 pub name: Lifetime<'tree>,
4980}
4981impl<'tree> ::treesitter_types::FromNode<'tree> for LifetimeParameter<'tree> {
4982 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4983 fn from_node(
4984 node: ::tree_sitter::Node<'tree>,
4985 src: &'tree [u8],
4986 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4987 debug_assert_eq!(node.kind(), "lifetime_parameter");
4988 Ok(Self {
4989 span: ::treesitter_types::Span::from(node),
4990 bounds: match node.child_by_field_name("bounds") {
4991 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
4992 child, src,
4993 )?),
4994 None => None,
4995 },
4996 name: {
4997 let child = node
4998 .child_by_field_name("name")
4999 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5000 <Lifetime as ::treesitter_types::FromNode>::from_node(child, src)?
5001 },
5002 })
5003 }
5004}
5005impl ::treesitter_types::Spanned for LifetimeParameter<'_> {
5006 fn span(&self) -> ::treesitter_types::Span {
5007 self.span
5008 }
5009}
5010#[derive(Debug, Clone, PartialEq, Eq)]
5011pub struct LineComment<'tree> {
5012 pub span: ::treesitter_types::Span,
5013 pub doc: ::core::option::Option<DocComment<'tree>>,
5014 pub inner: ::core::option::Option<InnerDocCommentMarker<'tree>>,
5015 pub outer: ::core::option::Option<OuterDocCommentMarker<'tree>>,
5016}
5017impl<'tree> ::treesitter_types::FromNode<'tree> for LineComment<'tree> {
5018 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5019 fn from_node(
5020 node: ::tree_sitter::Node<'tree>,
5021 src: &'tree [u8],
5022 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5023 debug_assert_eq!(node.kind(), "line_comment");
5024 Ok(Self {
5025 span: ::treesitter_types::Span::from(node),
5026 doc: match node.child_by_field_name("doc") {
5027 Some(child) => Some(<DocComment as ::treesitter_types::FromNode>::from_node(
5028 child, src,
5029 )?),
5030 None => None,
5031 },
5032 inner: match node.child_by_field_name("inner") {
5033 Some(child) => Some(
5034 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
5035 ),
5036 None => None,
5037 },
5038 outer: match node.child_by_field_name("outer") {
5039 Some(child) => Some(
5040 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(child, src)?,
5041 ),
5042 None => None,
5043 },
5044 })
5045 }
5046}
5047impl ::treesitter_types::Spanned for LineComment<'_> {
5048 fn span(&self) -> ::treesitter_types::Span {
5049 self.span
5050 }
5051}
5052#[derive(Debug, Clone, PartialEq, Eq)]
5053pub struct LoopExpression<'tree> {
5054 pub span: ::treesitter_types::Span,
5055 pub body: Block<'tree>,
5056 pub children: ::core::option::Option<Label<'tree>>,
5057}
5058impl<'tree> ::treesitter_types::FromNode<'tree> for LoopExpression<'tree> {
5059 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5060 fn from_node(
5061 node: ::tree_sitter::Node<'tree>,
5062 src: &'tree [u8],
5063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5064 debug_assert_eq!(node.kind(), "loop_expression");
5065 Ok(Self {
5066 span: ::treesitter_types::Span::from(node),
5067 body: {
5068 let child = node
5069 .child_by_field_name("body")
5070 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5071 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
5072 },
5073 children: {
5074 #[allow(clippy::suspicious_else_formatting)]
5075 let non_field_children = {
5076 let mut cursor = node.walk();
5077 let mut result = ::std::vec::Vec::new();
5078 if cursor.goto_first_child() {
5079 loop {
5080 if cursor.field_name().is_none()
5081 && cursor.node().is_named()
5082 && !cursor.node().is_extra()
5083 {
5084 result.push(cursor.node());
5085 }
5086 if !cursor.goto_next_sibling() {
5087 break;
5088 }
5089 }
5090 }
5091 result
5092 };
5093 match non_field_children.first() {
5094 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
5095 child, src,
5096 )?),
5097 None => None,
5098 }
5099 },
5100 })
5101 }
5102}
5103impl ::treesitter_types::Spanned for LoopExpression<'_> {
5104 fn span(&self) -> ::treesitter_types::Span {
5105 self.span
5106 }
5107}
5108#[derive(Debug, Clone, PartialEq, Eq)]
5109pub struct MacroDefinition<'tree> {
5110 pub span: ::treesitter_types::Span,
5111 pub name: Identifier<'tree>,
5112 pub children: ::std::vec::Vec<MacroRule<'tree>>,
5113}
5114impl<'tree> ::treesitter_types::FromNode<'tree> for MacroDefinition<'tree> {
5115 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5116 fn from_node(
5117 node: ::tree_sitter::Node<'tree>,
5118 src: &'tree [u8],
5119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5120 debug_assert_eq!(node.kind(), "macro_definition");
5121 Ok(Self {
5122 span: ::treesitter_types::Span::from(node),
5123 name: {
5124 let child = node
5125 .child_by_field_name("name")
5126 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5127 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5128 },
5129 children: {
5130 #[allow(clippy::suspicious_else_formatting)]
5131 let non_field_children = {
5132 let mut cursor = node.walk();
5133 let mut result = ::std::vec::Vec::new();
5134 if cursor.goto_first_child() {
5135 loop {
5136 if cursor.field_name().is_none()
5137 && cursor.node().is_named()
5138 && !cursor.node().is_extra()
5139 {
5140 result.push(cursor.node());
5141 }
5142 if !cursor.goto_next_sibling() {
5143 break;
5144 }
5145 }
5146 }
5147 result
5148 };
5149 let mut items = ::std::vec::Vec::new();
5150 for child in non_field_children {
5151 items.push(<MacroRule as ::treesitter_types::FromNode>::from_node(
5152 child, src,
5153 )?);
5154 }
5155 items
5156 },
5157 })
5158 }
5159}
5160impl ::treesitter_types::Spanned for MacroDefinition<'_> {
5161 fn span(&self) -> ::treesitter_types::Span {
5162 self.span
5163 }
5164}
5165#[derive(Debug, Clone, PartialEq, Eq)]
5166pub struct MacroInvocation<'tree> {
5167 pub span: ::treesitter_types::Span,
5168 pub r#macro: MacroInvocationMacro<'tree>,
5169 pub children: TokenTree<'tree>,
5170}
5171impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocation<'tree> {
5172 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5173 fn from_node(
5174 node: ::tree_sitter::Node<'tree>,
5175 src: &'tree [u8],
5176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5177 debug_assert_eq!(node.kind(), "macro_invocation");
5178 Ok(Self {
5179 span: ::treesitter_types::Span::from(node),
5180 r#macro: {
5181 let child = node
5182 .child_by_field_name("macro")
5183 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("macro", node))?;
5184 <MacroInvocationMacro as ::treesitter_types::FromNode>::from_node(child, src)?
5185 },
5186 children: {
5187 #[allow(clippy::suspicious_else_formatting)]
5188 let non_field_children = {
5189 let mut cursor = node.walk();
5190 let mut result = ::std::vec::Vec::new();
5191 if cursor.goto_first_child() {
5192 loop {
5193 if cursor.field_name().is_none()
5194 && cursor.node().is_named()
5195 && !cursor.node().is_extra()
5196 {
5197 result.push(cursor.node());
5198 }
5199 if !cursor.goto_next_sibling() {
5200 break;
5201 }
5202 }
5203 }
5204 result
5205 };
5206 let child = if let Some(&c) = non_field_children.first() {
5207 c
5208 } else {
5209 let mut fallback_cursor = node.walk();
5210 let mut fallback_child = None;
5211 if fallback_cursor.goto_first_child() {
5212 loop {
5213 if fallback_cursor.field_name().is_none()
5214 && !fallback_cursor.node().is_extra()
5215 {
5216 let candidate = fallback_cursor.node();
5217 #[allow(clippy::needless_question_mark)]
5218 if (|| -> ::core::result::Result<
5219 _,
5220 ::treesitter_types::ParseError,
5221 > {
5222 let child = candidate;
5223 Ok(
5224 <TokenTree as ::treesitter_types::FromNode>::from_node(
5225 child,
5226 src,
5227 )?,
5228 )
5229 })()
5230 .is_ok()
5231 {
5232 fallback_child = Some(candidate);
5233 break;
5234 }
5235 }
5236 if !fallback_cursor.goto_next_sibling() {
5237 break;
5238 }
5239 }
5240 }
5241 if fallback_child.is_none() {
5242 let mut cursor2 = node.walk();
5243 if cursor2.goto_first_child() {
5244 loop {
5245 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5246 let candidate = cursor2.node();
5247 #[allow(clippy::needless_question_mark)]
5248 if (|| -> ::core::result::Result<
5249 _,
5250 ::treesitter_types::ParseError,
5251 > {
5252 let child = candidate;
5253 Ok(
5254 <TokenTree as ::treesitter_types::FromNode>::from_node(
5255 child,
5256 src,
5257 )?,
5258 )
5259 })()
5260 .is_ok()
5261 {
5262 fallback_child = Some(candidate);
5263 break;
5264 }
5265 }
5266 if !cursor2.goto_next_sibling() {
5267 break;
5268 }
5269 }
5270 }
5271 }
5272 fallback_child.ok_or_else(|| {
5273 ::treesitter_types::ParseError::missing_field("children", node)
5274 })?
5275 };
5276 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)?
5277 },
5278 })
5279 }
5280}
5281impl ::treesitter_types::Spanned for MacroInvocation<'_> {
5282 fn span(&self) -> ::treesitter_types::Span {
5283 self.span
5284 }
5285}
5286#[derive(Debug, Clone, PartialEq, Eq)]
5287pub struct MacroRule<'tree> {
5288 pub span: ::treesitter_types::Span,
5289 pub left: TokenTreePattern<'tree>,
5290 pub right: TokenTree<'tree>,
5291}
5292impl<'tree> ::treesitter_types::FromNode<'tree> for MacroRule<'tree> {
5293 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5294 fn from_node(
5295 node: ::tree_sitter::Node<'tree>,
5296 src: &'tree [u8],
5297 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5298 debug_assert_eq!(node.kind(), "macro_rule");
5299 Ok(Self {
5300 span: ::treesitter_types::Span::from(node),
5301 left: {
5302 let child = node
5303 .child_by_field_name("left")
5304 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5305 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(child, src)?
5306 },
5307 right: {
5308 let child = node
5309 .child_by_field_name("right")
5310 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5311 <TokenTree as ::treesitter_types::FromNode>::from_node(child, src)?
5312 },
5313 })
5314 }
5315}
5316impl ::treesitter_types::Spanned for MacroRule<'_> {
5317 fn span(&self) -> ::treesitter_types::Span {
5318 self.span
5319 }
5320}
5321#[derive(Debug, Clone, PartialEq, Eq)]
5322pub struct MatchArm<'tree> {
5323 pub span: ::treesitter_types::Span,
5324 pub pattern: MatchPattern<'tree>,
5325 pub value: Expression<'tree>,
5326 pub children: ::std::vec::Vec<MatchArmChildren<'tree>>,
5327}
5328impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArm<'tree> {
5329 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5330 fn from_node(
5331 node: ::tree_sitter::Node<'tree>,
5332 src: &'tree [u8],
5333 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5334 debug_assert_eq!(node.kind(), "match_arm");
5335 Ok(Self {
5336 span: ::treesitter_types::Span::from(node),
5337 pattern: {
5338 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5339 ::treesitter_types::ParseError::missing_field("pattern", node)
5340 })?;
5341 <MatchPattern as ::treesitter_types::FromNode>::from_node(child, src)?
5342 },
5343 value: {
5344 let child = node
5345 .child_by_field_name("value")
5346 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5347 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5348 },
5349 children: {
5350 #[allow(clippy::suspicious_else_formatting)]
5351 let non_field_children = {
5352 let mut cursor = node.walk();
5353 let mut result = ::std::vec::Vec::new();
5354 if cursor.goto_first_child() {
5355 loop {
5356 if cursor.field_name().is_none()
5357 && cursor.node().is_named()
5358 && !cursor.node().is_extra()
5359 {
5360 result.push(cursor.node());
5361 }
5362 if !cursor.goto_next_sibling() {
5363 break;
5364 }
5365 }
5366 }
5367 result
5368 };
5369 let mut items = ::std::vec::Vec::new();
5370 for child in non_field_children {
5371 items.push(
5372 <MatchArmChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5373 );
5374 }
5375 items
5376 },
5377 })
5378 }
5379}
5380impl ::treesitter_types::Spanned for MatchArm<'_> {
5381 fn span(&self) -> ::treesitter_types::Span {
5382 self.span
5383 }
5384}
5385#[derive(Debug, Clone, PartialEq, Eq)]
5386pub struct MatchBlock<'tree> {
5387 pub span: ::treesitter_types::Span,
5388 pub children: ::std::vec::Vec<MatchArm<'tree>>,
5389}
5390impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlock<'tree> {
5391 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5392 fn from_node(
5393 node: ::tree_sitter::Node<'tree>,
5394 src: &'tree [u8],
5395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5396 debug_assert_eq!(node.kind(), "match_block");
5397 Ok(Self {
5398 span: ::treesitter_types::Span::from(node),
5399 children: {
5400 #[allow(clippy::suspicious_else_formatting)]
5401 let non_field_children = {
5402 let mut cursor = node.walk();
5403 let mut result = ::std::vec::Vec::new();
5404 if cursor.goto_first_child() {
5405 loop {
5406 if cursor.field_name().is_none()
5407 && cursor.node().is_named()
5408 && !cursor.node().is_extra()
5409 {
5410 result.push(cursor.node());
5411 }
5412 if !cursor.goto_next_sibling() {
5413 break;
5414 }
5415 }
5416 }
5417 result
5418 };
5419 let mut items = ::std::vec::Vec::new();
5420 for child in non_field_children {
5421 items.push(<MatchArm as ::treesitter_types::FromNode>::from_node(
5422 child, src,
5423 )?);
5424 }
5425 items
5426 },
5427 })
5428 }
5429}
5430impl ::treesitter_types::Spanned for MatchBlock<'_> {
5431 fn span(&self) -> ::treesitter_types::Span {
5432 self.span
5433 }
5434}
5435#[derive(Debug, Clone, PartialEq, Eq)]
5436pub struct MatchExpression<'tree> {
5437 pub span: ::treesitter_types::Span,
5438 pub body: MatchBlock<'tree>,
5439 pub value: Expression<'tree>,
5440}
5441impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
5442 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5443 fn from_node(
5444 node: ::tree_sitter::Node<'tree>,
5445 src: &'tree [u8],
5446 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5447 debug_assert_eq!(node.kind(), "match_expression");
5448 Ok(Self {
5449 span: ::treesitter_types::Span::from(node),
5450 body: {
5451 let child = node
5452 .child_by_field_name("body")
5453 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5454 <MatchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
5455 },
5456 value: {
5457 let child = node
5458 .child_by_field_name("value")
5459 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5460 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5461 },
5462 })
5463 }
5464}
5465impl ::treesitter_types::Spanned for MatchExpression<'_> {
5466 fn span(&self) -> ::treesitter_types::Span {
5467 self.span
5468 }
5469}
5470#[derive(Debug, Clone, PartialEq, Eq)]
5471pub struct MatchPattern<'tree> {
5472 pub span: ::treesitter_types::Span,
5473 pub condition: ::core::option::Option<MatchPatternCondition<'tree>>,
5474 pub children: Pattern<'tree>,
5475}
5476impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPattern<'tree> {
5477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5478 fn from_node(
5479 node: ::tree_sitter::Node<'tree>,
5480 src: &'tree [u8],
5481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5482 debug_assert_eq!(node.kind(), "match_pattern");
5483 Ok(Self {
5484 span: ::treesitter_types::Span::from(node),
5485 condition: match node.child_by_field_name("condition") {
5486 Some(child) => Some(
5487 <MatchPatternCondition as ::treesitter_types::FromNode>::from_node(child, src)?,
5488 ),
5489 None => None,
5490 },
5491 children: {
5492 #[allow(clippy::suspicious_else_formatting)]
5493 let non_field_children = {
5494 let mut cursor = node.walk();
5495 let mut result = ::std::vec::Vec::new();
5496 if cursor.goto_first_child() {
5497 loop {
5498 if cursor.field_name().is_none()
5499 && cursor.node().is_named()
5500 && !cursor.node().is_extra()
5501 {
5502 result.push(cursor.node());
5503 }
5504 if !cursor.goto_next_sibling() {
5505 break;
5506 }
5507 }
5508 }
5509 result
5510 };
5511 let child = if let Some(&c) = non_field_children.first() {
5512 c
5513 } else {
5514 let mut fallback_cursor = node.walk();
5515 let mut fallback_child = None;
5516 if fallback_cursor.goto_first_child() {
5517 loop {
5518 if fallback_cursor.field_name().is_none()
5519 && !fallback_cursor.node().is_extra()
5520 {
5521 let candidate = fallback_cursor.node();
5522 #[allow(clippy::needless_question_mark)]
5523 if (|| -> ::core::result::Result<
5524 _,
5525 ::treesitter_types::ParseError,
5526 > {
5527 let child = candidate;
5528 Ok(
5529 <Pattern as ::treesitter_types::FromNode>::from_node(
5530 child,
5531 src,
5532 )?,
5533 )
5534 })()
5535 .is_ok()
5536 {
5537 fallback_child = Some(candidate);
5538 break;
5539 }
5540 }
5541 if !fallback_cursor.goto_next_sibling() {
5542 break;
5543 }
5544 }
5545 }
5546 if fallback_child.is_none() {
5547 let mut cursor2 = node.walk();
5548 if cursor2.goto_first_child() {
5549 loop {
5550 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5551 let candidate = cursor2.node();
5552 #[allow(clippy::needless_question_mark)]
5553 if (|| -> ::core::result::Result<
5554 _,
5555 ::treesitter_types::ParseError,
5556 > {
5557 let child = candidate;
5558 Ok(
5559 <Pattern as ::treesitter_types::FromNode>::from_node(
5560 child,
5561 src,
5562 )?,
5563 )
5564 })()
5565 .is_ok()
5566 {
5567 fallback_child = Some(candidate);
5568 break;
5569 }
5570 }
5571 if !cursor2.goto_next_sibling() {
5572 break;
5573 }
5574 }
5575 }
5576 }
5577 fallback_child.ok_or_else(|| {
5578 ::treesitter_types::ParseError::missing_field("children", node)
5579 })?
5580 };
5581 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
5582 },
5583 })
5584 }
5585}
5586impl ::treesitter_types::Spanned for MatchPattern<'_> {
5587 fn span(&self) -> ::treesitter_types::Span {
5588 self.span
5589 }
5590}
5591#[derive(Debug, Clone, PartialEq, Eq)]
5592pub struct ModItem<'tree> {
5593 pub span: ::treesitter_types::Span,
5594 pub body: ::core::option::Option<DeclarationList<'tree>>,
5595 pub name: Identifier<'tree>,
5596 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
5597}
5598impl<'tree> ::treesitter_types::FromNode<'tree> for ModItem<'tree> {
5599 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5600 fn from_node(
5601 node: ::tree_sitter::Node<'tree>,
5602 src: &'tree [u8],
5603 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5604 debug_assert_eq!(node.kind(), "mod_item");
5605 Ok(Self {
5606 span: ::treesitter_types::Span::from(node),
5607 body: match node.child_by_field_name("body") {
5608 Some(child) => {
5609 Some(<DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?)
5610 }
5611 None => None,
5612 },
5613 name: {
5614 let child = node
5615 .child_by_field_name("name")
5616 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5617 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5618 },
5619 children: {
5620 #[allow(clippy::suspicious_else_formatting)]
5621 let non_field_children = {
5622 let mut cursor = node.walk();
5623 let mut result = ::std::vec::Vec::new();
5624 if cursor.goto_first_child() {
5625 loop {
5626 if cursor.field_name().is_none()
5627 && cursor.node().is_named()
5628 && !cursor.node().is_extra()
5629 {
5630 result.push(cursor.node());
5631 }
5632 if !cursor.goto_next_sibling() {
5633 break;
5634 }
5635 }
5636 }
5637 result
5638 };
5639 match non_field_children.first() {
5640 Some(&child) => Some(
5641 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
5642 child, src,
5643 )?,
5644 ),
5645 None => None,
5646 }
5647 },
5648 })
5649 }
5650}
5651impl ::treesitter_types::Spanned for ModItem<'_> {
5652 fn span(&self) -> ::treesitter_types::Span {
5653 self.span
5654 }
5655}
5656#[derive(Debug, Clone, PartialEq, Eq)]
5657pub struct MutPattern<'tree> {
5658 pub span: ::treesitter_types::Span,
5659 pub children: ::std::vec::Vec<MutPatternChildren<'tree>>,
5660}
5661impl<'tree> ::treesitter_types::FromNode<'tree> for MutPattern<'tree> {
5662 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5663 fn from_node(
5664 node: ::tree_sitter::Node<'tree>,
5665 src: &'tree [u8],
5666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5667 debug_assert_eq!(node.kind(), "mut_pattern");
5668 Ok(Self {
5669 span: ::treesitter_types::Span::from(node),
5670 children: {
5671 #[allow(clippy::suspicious_else_formatting)]
5672 let non_field_children = {
5673 let mut cursor = node.walk();
5674 let mut result = ::std::vec::Vec::new();
5675 if cursor.goto_first_child() {
5676 loop {
5677 if cursor.field_name().is_none()
5678 && cursor.node().is_named()
5679 && !cursor.node().is_extra()
5680 {
5681 result.push(cursor.node());
5682 }
5683 if !cursor.goto_next_sibling() {
5684 break;
5685 }
5686 }
5687 }
5688 result
5689 };
5690 let mut items = ::std::vec::Vec::new();
5691 for child in non_field_children {
5692 items.push(
5693 <MutPatternChildren as ::treesitter_types::FromNode>::from_node(
5694 child, src,
5695 )?,
5696 );
5697 }
5698 items
5699 },
5700 })
5701 }
5702}
5703impl ::treesitter_types::Spanned for MutPattern<'_> {
5704 fn span(&self) -> ::treesitter_types::Span {
5705 self.span
5706 }
5707}
5708#[derive(Debug, Clone, PartialEq, Eq)]
5709pub struct NegativeLiteral<'tree> {
5710 pub span: ::treesitter_types::Span,
5711 pub children: NegativeLiteralChildren<'tree>,
5712}
5713impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteral<'tree> {
5714 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5715 fn from_node(
5716 node: ::tree_sitter::Node<'tree>,
5717 src: &'tree [u8],
5718 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5719 debug_assert_eq!(node.kind(), "negative_literal");
5720 Ok(Self {
5721 span: ::treesitter_types::Span::from(node),
5722 children: {
5723 #[allow(clippy::suspicious_else_formatting)]
5724 let non_field_children = {
5725 let mut cursor = node.walk();
5726 let mut result = ::std::vec::Vec::new();
5727 if cursor.goto_first_child() {
5728 loop {
5729 if cursor.field_name().is_none()
5730 && cursor.node().is_named()
5731 && !cursor.node().is_extra()
5732 {
5733 result.push(cursor.node());
5734 }
5735 if !cursor.goto_next_sibling() {
5736 break;
5737 }
5738 }
5739 }
5740 result
5741 };
5742 let child = if let Some(&c) = non_field_children.first() {
5743 c
5744 } else {
5745 let mut fallback_cursor = node.walk();
5746 let mut fallback_child = None;
5747 if fallback_cursor.goto_first_child() {
5748 loop {
5749 if fallback_cursor.field_name().is_none()
5750 && !fallback_cursor.node().is_extra()
5751 {
5752 let candidate = fallback_cursor.node();
5753 #[allow(clippy::needless_question_mark)]
5754 if (|| -> ::core::result::Result<
5755 _,
5756 ::treesitter_types::ParseError,
5757 > {
5758 let child = candidate;
5759 Ok(
5760 <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(
5761 child,
5762 src,
5763 )?,
5764 )
5765 })()
5766 .is_ok()
5767 {
5768 fallback_child = Some(candidate);
5769 break;
5770 }
5771 }
5772 if !fallback_cursor.goto_next_sibling() {
5773 break;
5774 }
5775 }
5776 }
5777 if fallback_child.is_none() {
5778 let mut cursor2 = node.walk();
5779 if cursor2.goto_first_child() {
5780 loop {
5781 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5782 let candidate = cursor2.node();
5783 #[allow(clippy::needless_question_mark)]
5784 if (|| -> ::core::result::Result<
5785 _,
5786 ::treesitter_types::ParseError,
5787 > {
5788 let child = candidate;
5789 Ok(
5790 <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(
5791 child,
5792 src,
5793 )?,
5794 )
5795 })()
5796 .is_ok()
5797 {
5798 fallback_child = Some(candidate);
5799 break;
5800 }
5801 }
5802 if !cursor2.goto_next_sibling() {
5803 break;
5804 }
5805 }
5806 }
5807 }
5808 fallback_child.ok_or_else(|| {
5809 ::treesitter_types::ParseError::missing_field("children", node)
5810 })?
5811 };
5812 <NegativeLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5813 },
5814 })
5815 }
5816}
5817impl ::treesitter_types::Spanned for NegativeLiteral<'_> {
5818 fn span(&self) -> ::treesitter_types::Span {
5819 self.span
5820 }
5821}
5822#[derive(Debug, Clone, PartialEq, Eq)]
5823pub struct NeverType<'tree> {
5824 pub span: ::treesitter_types::Span,
5825 text: &'tree str,
5826}
5827impl<'tree> ::treesitter_types::FromNode<'tree> for NeverType<'tree> {
5828 fn from_node(
5829 node: ::tree_sitter::Node<'tree>,
5830 src: &'tree [u8],
5831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5832 debug_assert_eq!(node.kind(), "never_type");
5833 Ok(Self {
5834 span: ::treesitter_types::Span::from(node),
5835 text: node.utf8_text(src)?,
5836 })
5837 }
5838}
5839impl<'tree> ::treesitter_types::LeafNode<'tree> for NeverType<'tree> {
5840 fn text(&self) -> &'tree str {
5841 self.text
5842 }
5843}
5844impl ::treesitter_types::Spanned for NeverType<'_> {
5845 fn span(&self) -> ::treesitter_types::Span {
5846 self.span
5847 }
5848}
5849#[derive(Debug, Clone, PartialEq, Eq)]
5850pub struct OrPattern<'tree> {
5851 pub span: ::treesitter_types::Span,
5852 pub children: ::std::vec::Vec<Pattern<'tree>>,
5853}
5854impl<'tree> ::treesitter_types::FromNode<'tree> for OrPattern<'tree> {
5855 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5856 fn from_node(
5857 node: ::tree_sitter::Node<'tree>,
5858 src: &'tree [u8],
5859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5860 debug_assert_eq!(node.kind(), "or_pattern");
5861 Ok(Self {
5862 span: ::treesitter_types::Span::from(node),
5863 children: {
5864 #[allow(clippy::suspicious_else_formatting)]
5865 let non_field_children = {
5866 let mut cursor = node.walk();
5867 let mut result = ::std::vec::Vec::new();
5868 if cursor.goto_first_child() {
5869 loop {
5870 if cursor.field_name().is_none()
5871 && cursor.node().is_named()
5872 && !cursor.node().is_extra()
5873 {
5874 result.push(cursor.node());
5875 }
5876 if !cursor.goto_next_sibling() {
5877 break;
5878 }
5879 }
5880 }
5881 result
5882 };
5883 let mut items = ::std::vec::Vec::new();
5884 for child in non_field_children {
5885 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
5886 child, src,
5887 )?);
5888 }
5889 items
5890 },
5891 })
5892 }
5893}
5894impl ::treesitter_types::Spanned for OrPattern<'_> {
5895 fn span(&self) -> ::treesitter_types::Span {
5896 self.span
5897 }
5898}
5899#[derive(Debug, Clone, PartialEq, Eq)]
5900pub struct OrderedFieldDeclarationList<'tree> {
5901 pub span: ::treesitter_types::Span,
5902 pub r#type: ::std::vec::Vec<Type<'tree>>,
5903 pub children: ::std::vec::Vec<OrderedFieldDeclarationListChildren<'tree>>,
5904}
5905impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationList<'tree> {
5906 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5907 fn from_node(
5908 node: ::tree_sitter::Node<'tree>,
5909 src: &'tree [u8],
5910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5911 debug_assert_eq!(node.kind(), "ordered_field_declaration_list");
5912 Ok(Self {
5913 span: ::treesitter_types::Span::from(node),
5914 r#type: {
5915 let mut cursor = node.walk();
5916 let mut items = ::std::vec::Vec::new();
5917 for child in node.children_by_field_name("type", &mut cursor) {
5918 items.push(<Type as ::treesitter_types::FromNode>::from_node(
5919 child, src,
5920 )?);
5921 }
5922 items
5923 },
5924 children: {
5925 #[allow(clippy::suspicious_else_formatting)]
5926 let non_field_children = {
5927 let mut cursor = node.walk();
5928 let mut result = ::std::vec::Vec::new();
5929 if cursor.goto_first_child() {
5930 loop {
5931 if cursor.field_name().is_none()
5932 && cursor.node().is_named()
5933 && !cursor.node().is_extra()
5934 {
5935 result.push(cursor.node());
5936 }
5937 if !cursor.goto_next_sibling() {
5938 break;
5939 }
5940 }
5941 }
5942 result
5943 };
5944 let mut items = ::std::vec::Vec::new();
5945 for child in non_field_children {
5946 items
5947 .push(
5948 <OrderedFieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
5949 child,
5950 src,
5951 )?,
5952 );
5953 }
5954 items
5955 },
5956 })
5957 }
5958}
5959impl ::treesitter_types::Spanned for OrderedFieldDeclarationList<'_> {
5960 fn span(&self) -> ::treesitter_types::Span {
5961 self.span
5962 }
5963}
5964#[derive(Debug, Clone, PartialEq, Eq)]
5965pub struct OuterDocCommentMarker<'tree> {
5966 pub span: ::treesitter_types::Span,
5967 text: &'tree str,
5968}
5969impl<'tree> ::treesitter_types::FromNode<'tree> for OuterDocCommentMarker<'tree> {
5970 fn from_node(
5971 node: ::tree_sitter::Node<'tree>,
5972 src: &'tree [u8],
5973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5974 debug_assert_eq!(node.kind(), "outer_doc_comment_marker");
5975 Ok(Self {
5976 span: ::treesitter_types::Span::from(node),
5977 text: node.utf8_text(src)?,
5978 })
5979 }
5980}
5981impl<'tree> ::treesitter_types::LeafNode<'tree> for OuterDocCommentMarker<'tree> {
5982 fn text(&self) -> &'tree str {
5983 self.text
5984 }
5985}
5986impl ::treesitter_types::Spanned for OuterDocCommentMarker<'_> {
5987 fn span(&self) -> ::treesitter_types::Span {
5988 self.span
5989 }
5990}
5991#[derive(Debug, Clone, PartialEq, Eq)]
5992pub struct Parameter<'tree> {
5993 pub span: ::treesitter_types::Span,
5994 pub pattern: ParameterPattern<'tree>,
5995 pub r#type: Type<'tree>,
5996 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
5997}
5998impl<'tree> ::treesitter_types::FromNode<'tree> for Parameter<'tree> {
5999 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6000 fn from_node(
6001 node: ::tree_sitter::Node<'tree>,
6002 src: &'tree [u8],
6003 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6004 debug_assert_eq!(node.kind(), "parameter");
6005 Ok(Self {
6006 span: ::treesitter_types::Span::from(node),
6007 pattern: {
6008 let child = node.child_by_field_name("pattern").ok_or_else(|| {
6009 ::treesitter_types::ParseError::missing_field("pattern", node)
6010 })?;
6011 <ParameterPattern as ::treesitter_types::FromNode>::from_node(child, src)?
6012 },
6013 r#type: {
6014 let child = node
6015 .child_by_field_name("type")
6016 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6017 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6018 },
6019 children: {
6020 #[allow(clippy::suspicious_else_formatting)]
6021 let non_field_children = {
6022 let mut cursor = node.walk();
6023 let mut result = ::std::vec::Vec::new();
6024 if cursor.goto_first_child() {
6025 loop {
6026 if cursor.field_name().is_none()
6027 && cursor.node().is_named()
6028 && !cursor.node().is_extra()
6029 {
6030 result.push(cursor.node());
6031 }
6032 if !cursor.goto_next_sibling() {
6033 break;
6034 }
6035 }
6036 }
6037 result
6038 };
6039 match non_field_children.first() {
6040 Some(&child) => Some(
6041 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
6042 ),
6043 None => None,
6044 }
6045 },
6046 })
6047 }
6048}
6049impl ::treesitter_types::Spanned for Parameter<'_> {
6050 fn span(&self) -> ::treesitter_types::Span {
6051 self.span
6052 }
6053}
6054#[derive(Debug, Clone, PartialEq, Eq)]
6055pub struct Parameters<'tree> {
6056 pub span: ::treesitter_types::Span,
6057 pub children: ::std::vec::Vec<ParametersChildren<'tree>>,
6058}
6059impl<'tree> ::treesitter_types::FromNode<'tree> for Parameters<'tree> {
6060 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6061 fn from_node(
6062 node: ::tree_sitter::Node<'tree>,
6063 src: &'tree [u8],
6064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6065 debug_assert_eq!(node.kind(), "parameters");
6066 Ok(Self {
6067 span: ::treesitter_types::Span::from(node),
6068 children: {
6069 #[allow(clippy::suspicious_else_formatting)]
6070 let non_field_children = {
6071 let mut cursor = node.walk();
6072 let mut result = ::std::vec::Vec::new();
6073 if cursor.goto_first_child() {
6074 loop {
6075 if cursor.field_name().is_none()
6076 && cursor.node().is_named()
6077 && !cursor.node().is_extra()
6078 {
6079 result.push(cursor.node());
6080 }
6081 if !cursor.goto_next_sibling() {
6082 break;
6083 }
6084 }
6085 }
6086 result
6087 };
6088 let mut items = ::std::vec::Vec::new();
6089 for child in non_field_children {
6090 items.push(
6091 <ParametersChildren as ::treesitter_types::FromNode>::from_node(
6092 child, src,
6093 )?,
6094 );
6095 }
6096 items
6097 },
6098 })
6099 }
6100}
6101impl ::treesitter_types::Spanned for Parameters<'_> {
6102 fn span(&self) -> ::treesitter_types::Span {
6103 self.span
6104 }
6105}
6106#[derive(Debug, Clone, PartialEq, Eq)]
6107pub struct ParenthesizedExpression<'tree> {
6108 pub span: ::treesitter_types::Span,
6109 pub children: Expression<'tree>,
6110}
6111impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
6112 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6113 fn from_node(
6114 node: ::tree_sitter::Node<'tree>,
6115 src: &'tree [u8],
6116 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6117 debug_assert_eq!(node.kind(), "parenthesized_expression");
6118 Ok(Self {
6119 span: ::treesitter_types::Span::from(node),
6120 children: {
6121 #[allow(clippy::suspicious_else_formatting)]
6122 let non_field_children = {
6123 let mut cursor = node.walk();
6124 let mut result = ::std::vec::Vec::new();
6125 if cursor.goto_first_child() {
6126 loop {
6127 if cursor.field_name().is_none()
6128 && cursor.node().is_named()
6129 && !cursor.node().is_extra()
6130 {
6131 result.push(cursor.node());
6132 }
6133 if !cursor.goto_next_sibling() {
6134 break;
6135 }
6136 }
6137 }
6138 result
6139 };
6140 let child = if let Some(&c) = non_field_children.first() {
6141 c
6142 } else {
6143 let mut fallback_cursor = node.walk();
6144 let mut fallback_child = None;
6145 if fallback_cursor.goto_first_child() {
6146 loop {
6147 if fallback_cursor.field_name().is_none()
6148 && !fallback_cursor.node().is_extra()
6149 {
6150 let candidate = fallback_cursor.node();
6151 #[allow(clippy::needless_question_mark)]
6152 if (|| -> ::core::result::Result<
6153 _,
6154 ::treesitter_types::ParseError,
6155 > {
6156 let child = candidate;
6157 Ok(
6158 <Expression as ::treesitter_types::FromNode>::from_node(
6159 child,
6160 src,
6161 )?,
6162 )
6163 })()
6164 .is_ok()
6165 {
6166 fallback_child = Some(candidate);
6167 break;
6168 }
6169 }
6170 if !fallback_cursor.goto_next_sibling() {
6171 break;
6172 }
6173 }
6174 }
6175 if fallback_child.is_none() {
6176 let mut cursor2 = node.walk();
6177 if cursor2.goto_first_child() {
6178 loop {
6179 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6180 let candidate = cursor2.node();
6181 #[allow(clippy::needless_question_mark)]
6182 if (|| -> ::core::result::Result<
6183 _,
6184 ::treesitter_types::ParseError,
6185 > {
6186 let child = candidate;
6187 Ok(
6188 <Expression as ::treesitter_types::FromNode>::from_node(
6189 child,
6190 src,
6191 )?,
6192 )
6193 })()
6194 .is_ok()
6195 {
6196 fallback_child = Some(candidate);
6197 break;
6198 }
6199 }
6200 if !cursor2.goto_next_sibling() {
6201 break;
6202 }
6203 }
6204 }
6205 }
6206 fallback_child.ok_or_else(|| {
6207 ::treesitter_types::ParseError::missing_field("children", node)
6208 })?
6209 };
6210 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6211 },
6212 })
6213 }
6214}
6215impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
6216 fn span(&self) -> ::treesitter_types::Span {
6217 self.span
6218 }
6219}
6220#[derive(Debug, Clone, PartialEq, Eq)]
6221pub struct PointerType<'tree> {
6222 pub span: ::treesitter_types::Span,
6223 pub r#type: Type<'tree>,
6224 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
6225}
6226impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
6227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6228 fn from_node(
6229 node: ::tree_sitter::Node<'tree>,
6230 src: &'tree [u8],
6231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6232 debug_assert_eq!(node.kind(), "pointer_type");
6233 Ok(Self {
6234 span: ::treesitter_types::Span::from(node),
6235 r#type: {
6236 let child = node
6237 .child_by_field_name("type")
6238 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6239 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6240 },
6241 children: {
6242 #[allow(clippy::suspicious_else_formatting)]
6243 let non_field_children = {
6244 let mut cursor = node.walk();
6245 let mut result = ::std::vec::Vec::new();
6246 if cursor.goto_first_child() {
6247 loop {
6248 if cursor.field_name().is_none()
6249 && cursor.node().is_named()
6250 && !cursor.node().is_extra()
6251 {
6252 result.push(cursor.node());
6253 }
6254 if !cursor.goto_next_sibling() {
6255 break;
6256 }
6257 }
6258 }
6259 result
6260 };
6261 match non_field_children.first() {
6262 Some(&child) => Some(
6263 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
6264 ),
6265 None => None,
6266 }
6267 },
6268 })
6269 }
6270}
6271impl ::treesitter_types::Spanned for PointerType<'_> {
6272 fn span(&self) -> ::treesitter_types::Span {
6273 self.span
6274 }
6275}
6276#[derive(Debug, Clone, PartialEq, Eq)]
6277pub struct QualifiedType<'tree> {
6278 pub span: ::treesitter_types::Span,
6279 pub alias: Type<'tree>,
6280 pub r#type: Type<'tree>,
6281}
6282impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedType<'tree> {
6283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6284 fn from_node(
6285 node: ::tree_sitter::Node<'tree>,
6286 src: &'tree [u8],
6287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6288 debug_assert_eq!(node.kind(), "qualified_type");
6289 Ok(Self {
6290 span: ::treesitter_types::Span::from(node),
6291 alias: {
6292 let child = node
6293 .child_by_field_name("alias")
6294 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
6295 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6296 },
6297 r#type: {
6298 let child = node
6299 .child_by_field_name("type")
6300 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6301 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6302 },
6303 })
6304 }
6305}
6306impl ::treesitter_types::Spanned for QualifiedType<'_> {
6307 fn span(&self) -> ::treesitter_types::Span {
6308 self.span
6309 }
6310}
6311#[derive(Debug, Clone, PartialEq, Eq)]
6312pub struct RangeExpression<'tree> {
6313 pub span: ::treesitter_types::Span,
6314 pub children: ::std::vec::Vec<Expression<'tree>>,
6315}
6316impl<'tree> ::treesitter_types::FromNode<'tree> for RangeExpression<'tree> {
6317 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6318 fn from_node(
6319 node: ::tree_sitter::Node<'tree>,
6320 src: &'tree [u8],
6321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6322 debug_assert_eq!(node.kind(), "range_expression");
6323 Ok(Self {
6324 span: ::treesitter_types::Span::from(node),
6325 children: {
6326 #[allow(clippy::suspicious_else_formatting)]
6327 let non_field_children = {
6328 let mut cursor = node.walk();
6329 let mut result = ::std::vec::Vec::new();
6330 if cursor.goto_first_child() {
6331 loop {
6332 if cursor.field_name().is_none()
6333 && cursor.node().is_named()
6334 && !cursor.node().is_extra()
6335 {
6336 result.push(cursor.node());
6337 }
6338 if !cursor.goto_next_sibling() {
6339 break;
6340 }
6341 }
6342 }
6343 result
6344 };
6345 let mut items = ::std::vec::Vec::new();
6346 for child in non_field_children {
6347 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
6348 child, src,
6349 )?);
6350 }
6351 items
6352 },
6353 })
6354 }
6355}
6356impl ::treesitter_types::Spanned for RangeExpression<'_> {
6357 fn span(&self) -> ::treesitter_types::Span {
6358 self.span
6359 }
6360}
6361#[derive(Debug, Clone, PartialEq, Eq)]
6362pub struct RangePattern<'tree> {
6363 pub span: ::treesitter_types::Span,
6364 pub left: ::core::option::Option<RangePatternLeft<'tree>>,
6365 pub right: ::core::option::Option<RangePatternRight<'tree>>,
6366}
6367impl<'tree> ::treesitter_types::FromNode<'tree> for RangePattern<'tree> {
6368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6369 fn from_node(
6370 node: ::tree_sitter::Node<'tree>,
6371 src: &'tree [u8],
6372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6373 debug_assert_eq!(node.kind(), "range_pattern");
6374 Ok(Self {
6375 span: ::treesitter_types::Span::from(node),
6376 left: match node.child_by_field_name("left") {
6377 Some(child) => {
6378 Some(<RangePatternLeft as ::treesitter_types::FromNode>::from_node(child, src)?)
6379 }
6380 None => None,
6381 },
6382 right: match node.child_by_field_name("right") {
6383 Some(child) => Some(
6384 <RangePatternRight as ::treesitter_types::FromNode>::from_node(child, src)?,
6385 ),
6386 None => None,
6387 },
6388 })
6389 }
6390}
6391impl ::treesitter_types::Spanned for RangePattern<'_> {
6392 fn span(&self) -> ::treesitter_types::Span {
6393 self.span
6394 }
6395}
6396#[derive(Debug, Clone, PartialEq, Eq)]
6397pub struct RawStringLiteral<'tree> {
6398 pub span: ::treesitter_types::Span,
6399 pub children: StringContent<'tree>,
6400}
6401impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
6402 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6403 fn from_node(
6404 node: ::tree_sitter::Node<'tree>,
6405 src: &'tree [u8],
6406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6407 debug_assert_eq!(node.kind(), "raw_string_literal");
6408 Ok(Self {
6409 span: ::treesitter_types::Span::from(node),
6410 children: {
6411 #[allow(clippy::suspicious_else_formatting)]
6412 let non_field_children = {
6413 let mut cursor = node.walk();
6414 let mut result = ::std::vec::Vec::new();
6415 if cursor.goto_first_child() {
6416 loop {
6417 if cursor.field_name().is_none()
6418 && cursor.node().is_named()
6419 && !cursor.node().is_extra()
6420 {
6421 result.push(cursor.node());
6422 }
6423 if !cursor.goto_next_sibling() {
6424 break;
6425 }
6426 }
6427 }
6428 result
6429 };
6430 let child = if let Some(&c) = non_field_children.first() {
6431 c
6432 } else {
6433 let mut fallback_cursor = node.walk();
6434 let mut fallback_child = None;
6435 if fallback_cursor.goto_first_child() {
6436 loop {
6437 if fallback_cursor.field_name().is_none()
6438 && !fallback_cursor.node().is_extra()
6439 {
6440 let candidate = fallback_cursor.node();
6441 #[allow(clippy::needless_question_mark)]
6442 if (|| -> ::core::result::Result<
6443 _,
6444 ::treesitter_types::ParseError,
6445 > {
6446 let child = candidate;
6447 Ok(
6448 <StringContent as ::treesitter_types::FromNode>::from_node(
6449 child,
6450 src,
6451 )?,
6452 )
6453 })()
6454 .is_ok()
6455 {
6456 fallback_child = Some(candidate);
6457 break;
6458 }
6459 }
6460 if !fallback_cursor.goto_next_sibling() {
6461 break;
6462 }
6463 }
6464 }
6465 if fallback_child.is_none() {
6466 let mut cursor2 = node.walk();
6467 if cursor2.goto_first_child() {
6468 loop {
6469 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6470 let candidate = cursor2.node();
6471 #[allow(clippy::needless_question_mark)]
6472 if (|| -> ::core::result::Result<
6473 _,
6474 ::treesitter_types::ParseError,
6475 > {
6476 let child = candidate;
6477 Ok(
6478 <StringContent as ::treesitter_types::FromNode>::from_node(
6479 child,
6480 src,
6481 )?,
6482 )
6483 })()
6484 .is_ok()
6485 {
6486 fallback_child = Some(candidate);
6487 break;
6488 }
6489 }
6490 if !cursor2.goto_next_sibling() {
6491 break;
6492 }
6493 }
6494 }
6495 }
6496 fallback_child.ok_or_else(|| {
6497 ::treesitter_types::ParseError::missing_field("children", node)
6498 })?
6499 };
6500 <StringContent as ::treesitter_types::FromNode>::from_node(child, src)?
6501 },
6502 })
6503 }
6504}
6505impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
6506 fn span(&self) -> ::treesitter_types::Span {
6507 self.span
6508 }
6509}
6510#[derive(Debug, Clone, PartialEq, Eq)]
6511pub struct RefPattern<'tree> {
6512 pub span: ::treesitter_types::Span,
6513 pub children: Pattern<'tree>,
6514}
6515impl<'tree> ::treesitter_types::FromNode<'tree> for RefPattern<'tree> {
6516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6517 fn from_node(
6518 node: ::tree_sitter::Node<'tree>,
6519 src: &'tree [u8],
6520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6521 debug_assert_eq!(node.kind(), "ref_pattern");
6522 Ok(Self {
6523 span: ::treesitter_types::Span::from(node),
6524 children: {
6525 #[allow(clippy::suspicious_else_formatting)]
6526 let non_field_children = {
6527 let mut cursor = node.walk();
6528 let mut result = ::std::vec::Vec::new();
6529 if cursor.goto_first_child() {
6530 loop {
6531 if cursor.field_name().is_none()
6532 && cursor.node().is_named()
6533 && !cursor.node().is_extra()
6534 {
6535 result.push(cursor.node());
6536 }
6537 if !cursor.goto_next_sibling() {
6538 break;
6539 }
6540 }
6541 }
6542 result
6543 };
6544 let child = if let Some(&c) = non_field_children.first() {
6545 c
6546 } else {
6547 let mut fallback_cursor = node.walk();
6548 let mut fallback_child = None;
6549 if fallback_cursor.goto_first_child() {
6550 loop {
6551 if fallback_cursor.field_name().is_none()
6552 && !fallback_cursor.node().is_extra()
6553 {
6554 let candidate = fallback_cursor.node();
6555 #[allow(clippy::needless_question_mark)]
6556 if (|| -> ::core::result::Result<
6557 _,
6558 ::treesitter_types::ParseError,
6559 > {
6560 let child = candidate;
6561 Ok(
6562 <Pattern as ::treesitter_types::FromNode>::from_node(
6563 child,
6564 src,
6565 )?,
6566 )
6567 })()
6568 .is_ok()
6569 {
6570 fallback_child = Some(candidate);
6571 break;
6572 }
6573 }
6574 if !fallback_cursor.goto_next_sibling() {
6575 break;
6576 }
6577 }
6578 }
6579 if fallback_child.is_none() {
6580 let mut cursor2 = node.walk();
6581 if cursor2.goto_first_child() {
6582 loop {
6583 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6584 let candidate = cursor2.node();
6585 #[allow(clippy::needless_question_mark)]
6586 if (|| -> ::core::result::Result<
6587 _,
6588 ::treesitter_types::ParseError,
6589 > {
6590 let child = candidate;
6591 Ok(
6592 <Pattern as ::treesitter_types::FromNode>::from_node(
6593 child,
6594 src,
6595 )?,
6596 )
6597 })()
6598 .is_ok()
6599 {
6600 fallback_child = Some(candidate);
6601 break;
6602 }
6603 }
6604 if !cursor2.goto_next_sibling() {
6605 break;
6606 }
6607 }
6608 }
6609 }
6610 fallback_child.ok_or_else(|| {
6611 ::treesitter_types::ParseError::missing_field("children", node)
6612 })?
6613 };
6614 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
6615 },
6616 })
6617 }
6618}
6619impl ::treesitter_types::Spanned for RefPattern<'_> {
6620 fn span(&self) -> ::treesitter_types::Span {
6621 self.span
6622 }
6623}
6624#[derive(Debug, Clone, PartialEq, Eq)]
6625pub struct ReferenceExpression<'tree> {
6626 pub span: ::treesitter_types::Span,
6627 pub value: Expression<'tree>,
6628 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
6629}
6630impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceExpression<'tree> {
6631 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6632 fn from_node(
6633 node: ::tree_sitter::Node<'tree>,
6634 src: &'tree [u8],
6635 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6636 debug_assert_eq!(node.kind(), "reference_expression");
6637 Ok(Self {
6638 span: ::treesitter_types::Span::from(node),
6639 value: {
6640 let child = node
6641 .child_by_field_name("value")
6642 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6643 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6644 },
6645 children: {
6646 #[allow(clippy::suspicious_else_formatting)]
6647 let non_field_children = {
6648 let mut cursor = node.walk();
6649 let mut result = ::std::vec::Vec::new();
6650 if cursor.goto_first_child() {
6651 loop {
6652 if cursor.field_name().is_none()
6653 && cursor.node().is_named()
6654 && !cursor.node().is_extra()
6655 {
6656 result.push(cursor.node());
6657 }
6658 if !cursor.goto_next_sibling() {
6659 break;
6660 }
6661 }
6662 }
6663 result
6664 };
6665 match non_field_children.first() {
6666 Some(&child) => Some(
6667 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
6668 ),
6669 None => None,
6670 }
6671 },
6672 })
6673 }
6674}
6675impl ::treesitter_types::Spanned for ReferenceExpression<'_> {
6676 fn span(&self) -> ::treesitter_types::Span {
6677 self.span
6678 }
6679}
6680#[derive(Debug, Clone, PartialEq, Eq)]
6681pub struct ReferencePattern<'tree> {
6682 pub span: ::treesitter_types::Span,
6683 pub children: ::std::vec::Vec<ReferencePatternChildren<'tree>>,
6684}
6685impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePattern<'tree> {
6686 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6687 fn from_node(
6688 node: ::tree_sitter::Node<'tree>,
6689 src: &'tree [u8],
6690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6691 debug_assert_eq!(node.kind(), "reference_pattern");
6692 Ok(Self {
6693 span: ::treesitter_types::Span::from(node),
6694 children: {
6695 #[allow(clippy::suspicious_else_formatting)]
6696 let non_field_children = {
6697 let mut cursor = node.walk();
6698 let mut result = ::std::vec::Vec::new();
6699 if cursor.goto_first_child() {
6700 loop {
6701 if cursor.field_name().is_none()
6702 && cursor.node().is_named()
6703 && !cursor.node().is_extra()
6704 {
6705 result.push(cursor.node());
6706 }
6707 if !cursor.goto_next_sibling() {
6708 break;
6709 }
6710 }
6711 }
6712 result
6713 };
6714 let mut items = ::std::vec::Vec::new();
6715 for child in non_field_children {
6716 items.push(
6717 <ReferencePatternChildren as ::treesitter_types::FromNode>::from_node(
6718 child, src,
6719 )?,
6720 );
6721 }
6722 items
6723 },
6724 })
6725 }
6726}
6727impl ::treesitter_types::Spanned for ReferencePattern<'_> {
6728 fn span(&self) -> ::treesitter_types::Span {
6729 self.span
6730 }
6731}
6732#[derive(Debug, Clone, PartialEq, Eq)]
6733pub struct ReferenceType<'tree> {
6734 pub span: ::treesitter_types::Span,
6735 pub r#type: Type<'tree>,
6736 pub children: ::std::vec::Vec<ReferenceTypeChildren<'tree>>,
6737}
6738impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceType<'tree> {
6739 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6740 fn from_node(
6741 node: ::tree_sitter::Node<'tree>,
6742 src: &'tree [u8],
6743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6744 debug_assert_eq!(node.kind(), "reference_type");
6745 Ok(Self {
6746 span: ::treesitter_types::Span::from(node),
6747 r#type: {
6748 let child = node
6749 .child_by_field_name("type")
6750 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6751 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6752 },
6753 children: {
6754 #[allow(clippy::suspicious_else_formatting)]
6755 let non_field_children = {
6756 let mut cursor = node.walk();
6757 let mut result = ::std::vec::Vec::new();
6758 if cursor.goto_first_child() {
6759 loop {
6760 if cursor.field_name().is_none()
6761 && cursor.node().is_named()
6762 && !cursor.node().is_extra()
6763 {
6764 result.push(cursor.node());
6765 }
6766 if !cursor.goto_next_sibling() {
6767 break;
6768 }
6769 }
6770 }
6771 result
6772 };
6773 let mut items = ::std::vec::Vec::new();
6774 for child in non_field_children {
6775 items.push(
6776 <ReferenceTypeChildren as ::treesitter_types::FromNode>::from_node(
6777 child, src,
6778 )?,
6779 );
6780 }
6781 items
6782 },
6783 })
6784 }
6785}
6786impl ::treesitter_types::Spanned for ReferenceType<'_> {
6787 fn span(&self) -> ::treesitter_types::Span {
6788 self.span
6789 }
6790}
6791#[derive(Debug, Clone, PartialEq, Eq)]
6792pub struct RemainingFieldPattern<'tree> {
6793 pub span: ::treesitter_types::Span,
6794 text: &'tree str,
6795}
6796impl<'tree> ::treesitter_types::FromNode<'tree> for RemainingFieldPattern<'tree> {
6797 fn from_node(
6798 node: ::tree_sitter::Node<'tree>,
6799 src: &'tree [u8],
6800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6801 debug_assert_eq!(node.kind(), "remaining_field_pattern");
6802 Ok(Self {
6803 span: ::treesitter_types::Span::from(node),
6804 text: node.utf8_text(src)?,
6805 })
6806 }
6807}
6808impl<'tree> ::treesitter_types::LeafNode<'tree> for RemainingFieldPattern<'tree> {
6809 fn text(&self) -> &'tree str {
6810 self.text
6811 }
6812}
6813impl ::treesitter_types::Spanned for RemainingFieldPattern<'_> {
6814 fn span(&self) -> ::treesitter_types::Span {
6815 self.span
6816 }
6817}
6818#[derive(Debug, Clone, PartialEq, Eq)]
6819pub struct RemovedTraitBound<'tree> {
6820 pub span: ::treesitter_types::Span,
6821 pub children: Type<'tree>,
6822}
6823impl<'tree> ::treesitter_types::FromNode<'tree> for RemovedTraitBound<'tree> {
6824 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6825 fn from_node(
6826 node: ::tree_sitter::Node<'tree>,
6827 src: &'tree [u8],
6828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6829 debug_assert_eq!(node.kind(), "removed_trait_bound");
6830 Ok(Self {
6831 span: ::treesitter_types::Span::from(node),
6832 children: {
6833 #[allow(clippy::suspicious_else_formatting)]
6834 let non_field_children = {
6835 let mut cursor = node.walk();
6836 let mut result = ::std::vec::Vec::new();
6837 if cursor.goto_first_child() {
6838 loop {
6839 if cursor.field_name().is_none()
6840 && cursor.node().is_named()
6841 && !cursor.node().is_extra()
6842 {
6843 result.push(cursor.node());
6844 }
6845 if !cursor.goto_next_sibling() {
6846 break;
6847 }
6848 }
6849 }
6850 result
6851 };
6852 let child = if let Some(&c) = non_field_children.first() {
6853 c
6854 } else {
6855 let mut fallback_cursor = node.walk();
6856 let mut fallback_child = None;
6857 if fallback_cursor.goto_first_child() {
6858 loop {
6859 if fallback_cursor.field_name().is_none()
6860 && !fallback_cursor.node().is_extra()
6861 {
6862 let candidate = fallback_cursor.node();
6863 #[allow(clippy::needless_question_mark)]
6864 if (|| -> ::core::result::Result<
6865 _,
6866 ::treesitter_types::ParseError,
6867 > {
6868 let child = candidate;
6869 Ok(
6870 <Type as ::treesitter_types::FromNode>::from_node(
6871 child,
6872 src,
6873 )?,
6874 )
6875 })()
6876 .is_ok()
6877 {
6878 fallback_child = Some(candidate);
6879 break;
6880 }
6881 }
6882 if !fallback_cursor.goto_next_sibling() {
6883 break;
6884 }
6885 }
6886 }
6887 if fallback_child.is_none() {
6888 let mut cursor2 = node.walk();
6889 if cursor2.goto_first_child() {
6890 loop {
6891 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6892 let candidate = cursor2.node();
6893 #[allow(clippy::needless_question_mark)]
6894 if (|| -> ::core::result::Result<
6895 _,
6896 ::treesitter_types::ParseError,
6897 > {
6898 let child = candidate;
6899 Ok(
6900 <Type as ::treesitter_types::FromNode>::from_node(
6901 child,
6902 src,
6903 )?,
6904 )
6905 })()
6906 .is_ok()
6907 {
6908 fallback_child = Some(candidate);
6909 break;
6910 }
6911 }
6912 if !cursor2.goto_next_sibling() {
6913 break;
6914 }
6915 }
6916 }
6917 }
6918 fallback_child.ok_or_else(|| {
6919 ::treesitter_types::ParseError::missing_field("children", node)
6920 })?
6921 };
6922 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6923 },
6924 })
6925 }
6926}
6927impl ::treesitter_types::Spanned for RemovedTraitBound<'_> {
6928 fn span(&self) -> ::treesitter_types::Span {
6929 self.span
6930 }
6931}
6932#[derive(Debug, Clone, PartialEq, Eq)]
6933pub struct ReturnExpression<'tree> {
6934 pub span: ::treesitter_types::Span,
6935 pub children: ::core::option::Option<Expression<'tree>>,
6936}
6937impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnExpression<'tree> {
6938 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6939 fn from_node(
6940 node: ::tree_sitter::Node<'tree>,
6941 src: &'tree [u8],
6942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6943 debug_assert_eq!(node.kind(), "return_expression");
6944 Ok(Self {
6945 span: ::treesitter_types::Span::from(node),
6946 children: {
6947 #[allow(clippy::suspicious_else_formatting)]
6948 let non_field_children = {
6949 let mut cursor = node.walk();
6950 let mut result = ::std::vec::Vec::new();
6951 if cursor.goto_first_child() {
6952 loop {
6953 if cursor.field_name().is_none()
6954 && cursor.node().is_named()
6955 && !cursor.node().is_extra()
6956 {
6957 result.push(cursor.node());
6958 }
6959 if !cursor.goto_next_sibling() {
6960 break;
6961 }
6962 }
6963 }
6964 result
6965 };
6966 match non_field_children.first() {
6967 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6968 child, src,
6969 )?),
6970 None => None,
6971 }
6972 },
6973 })
6974 }
6975}
6976impl ::treesitter_types::Spanned for ReturnExpression<'_> {
6977 fn span(&self) -> ::treesitter_types::Span {
6978 self.span
6979 }
6980}
6981#[derive(Debug, Clone, PartialEq, Eq)]
6982pub struct ScopedIdentifier<'tree> {
6983 pub span: ::treesitter_types::Span,
6984 pub name: ScopedIdentifierName<'tree>,
6985 pub path: ::core::option::Option<ScopedIdentifierPath<'tree>>,
6986}
6987impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifier<'tree> {
6988 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6989 fn from_node(
6990 node: ::tree_sitter::Node<'tree>,
6991 src: &'tree [u8],
6992 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6993 debug_assert_eq!(node.kind(), "scoped_identifier");
6994 Ok(Self {
6995 span: ::treesitter_types::Span::from(node),
6996 name: {
6997 let child = node
6998 .child_by_field_name("name")
6999 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7000 <ScopedIdentifierName as ::treesitter_types::FromNode>::from_node(child, src)?
7001 },
7002 path: match node.child_by_field_name("path") {
7003 Some(child) => Some(
7004 <ScopedIdentifierPath as ::treesitter_types::FromNode>::from_node(child, src)?,
7005 ),
7006 None => None,
7007 },
7008 })
7009 }
7010}
7011impl ::treesitter_types::Spanned for ScopedIdentifier<'_> {
7012 fn span(&self) -> ::treesitter_types::Span {
7013 self.span
7014 }
7015}
7016#[derive(Debug, Clone, PartialEq, Eq)]
7017pub struct ScopedTypeIdentifier<'tree> {
7018 pub span: ::treesitter_types::Span,
7019 pub name: TypeIdentifier<'tree>,
7020 pub path: ::core::option::Option<ScopedTypeIdentifierPath<'tree>>,
7021}
7022impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifier<'tree> {
7023 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7024 fn from_node(
7025 node: ::tree_sitter::Node<'tree>,
7026 src: &'tree [u8],
7027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7028 debug_assert_eq!(node.kind(), "scoped_type_identifier");
7029 Ok(Self {
7030 span: ::treesitter_types::Span::from(node),
7031 name: {
7032 let child = node
7033 .child_by_field_name("name")
7034 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7035 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7036 },
7037 path: match node.child_by_field_name("path") {
7038 Some(child) => Some(
7039 <ScopedTypeIdentifierPath as ::treesitter_types::FromNode>::from_node(
7040 child, src,
7041 )?,
7042 ),
7043 None => None,
7044 },
7045 })
7046 }
7047}
7048impl ::treesitter_types::Spanned for ScopedTypeIdentifier<'_> {
7049 fn span(&self) -> ::treesitter_types::Span {
7050 self.span
7051 }
7052}
7053#[derive(Debug, Clone, PartialEq, Eq)]
7054pub struct ScopedUseList<'tree> {
7055 pub span: ::treesitter_types::Span,
7056 pub list: UseList<'tree>,
7057 pub path: ::core::option::Option<ScopedUseListPath<'tree>>,
7058}
7059impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseList<'tree> {
7060 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7061 fn from_node(
7062 node: ::tree_sitter::Node<'tree>,
7063 src: &'tree [u8],
7064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7065 debug_assert_eq!(node.kind(), "scoped_use_list");
7066 Ok(Self {
7067 span: ::treesitter_types::Span::from(node),
7068 list: {
7069 let child = node
7070 .child_by_field_name("list")
7071 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("list", node))?;
7072 <UseList as ::treesitter_types::FromNode>::from_node(child, src)?
7073 },
7074 path: match node.child_by_field_name("path") {
7075 Some(child) => Some(
7076 <ScopedUseListPath as ::treesitter_types::FromNode>::from_node(child, src)?,
7077 ),
7078 None => None,
7079 },
7080 })
7081 }
7082}
7083impl ::treesitter_types::Spanned for ScopedUseList<'_> {
7084 fn span(&self) -> ::treesitter_types::Span {
7085 self.span
7086 }
7087}
7088#[derive(Debug, Clone, PartialEq, Eq)]
7089pub struct SelfParameter<'tree> {
7090 pub span: ::treesitter_types::Span,
7091 pub children: ::std::vec::Vec<SelfParameterChildren<'tree>>,
7092}
7093impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameter<'tree> {
7094 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7095 fn from_node(
7096 node: ::tree_sitter::Node<'tree>,
7097 src: &'tree [u8],
7098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7099 debug_assert_eq!(node.kind(), "self_parameter");
7100 Ok(Self {
7101 span: ::treesitter_types::Span::from(node),
7102 children: {
7103 #[allow(clippy::suspicious_else_formatting)]
7104 let non_field_children = {
7105 let mut cursor = node.walk();
7106 let mut result = ::std::vec::Vec::new();
7107 if cursor.goto_first_child() {
7108 loop {
7109 if cursor.field_name().is_none()
7110 && cursor.node().is_named()
7111 && !cursor.node().is_extra()
7112 {
7113 result.push(cursor.node());
7114 }
7115 if !cursor.goto_next_sibling() {
7116 break;
7117 }
7118 }
7119 }
7120 result
7121 };
7122 let mut items = ::std::vec::Vec::new();
7123 for child in non_field_children {
7124 items.push(
7125 <SelfParameterChildren as ::treesitter_types::FromNode>::from_node(
7126 child, src,
7127 )?,
7128 );
7129 }
7130 items
7131 },
7132 })
7133 }
7134}
7135impl ::treesitter_types::Spanned for SelfParameter<'_> {
7136 fn span(&self) -> ::treesitter_types::Span {
7137 self.span
7138 }
7139}
7140#[derive(Debug, Clone, PartialEq, Eq)]
7141pub struct ShorthandFieldInitializer<'tree> {
7142 pub span: ::treesitter_types::Span,
7143 pub children: ::std::vec::Vec<ShorthandFieldInitializerChildren<'tree>>,
7144}
7145impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializer<'tree> {
7146 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7147 fn from_node(
7148 node: ::tree_sitter::Node<'tree>,
7149 src: &'tree [u8],
7150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7151 debug_assert_eq!(node.kind(), "shorthand_field_initializer");
7152 Ok(Self {
7153 span: ::treesitter_types::Span::from(node),
7154 children: {
7155 #[allow(clippy::suspicious_else_formatting)]
7156 let non_field_children = {
7157 let mut cursor = node.walk();
7158 let mut result = ::std::vec::Vec::new();
7159 if cursor.goto_first_child() {
7160 loop {
7161 if cursor.field_name().is_none()
7162 && cursor.node().is_named()
7163 && !cursor.node().is_extra()
7164 {
7165 result.push(cursor.node());
7166 }
7167 if !cursor.goto_next_sibling() {
7168 break;
7169 }
7170 }
7171 }
7172 result
7173 };
7174 let mut items = ::std::vec::Vec::new();
7175 for child in non_field_children {
7176 items
7177 .push(
7178 <ShorthandFieldInitializerChildren as ::treesitter_types::FromNode>::from_node(
7179 child,
7180 src,
7181 )?,
7182 );
7183 }
7184 items
7185 },
7186 })
7187 }
7188}
7189impl ::treesitter_types::Spanned for ShorthandFieldInitializer<'_> {
7190 fn span(&self) -> ::treesitter_types::Span {
7191 self.span
7192 }
7193}
7194#[derive(Debug, Clone, PartialEq, Eq)]
7195pub struct SlicePattern<'tree> {
7196 pub span: ::treesitter_types::Span,
7197 pub children: ::std::vec::Vec<Pattern<'tree>>,
7198}
7199impl<'tree> ::treesitter_types::FromNode<'tree> for SlicePattern<'tree> {
7200 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7201 fn from_node(
7202 node: ::tree_sitter::Node<'tree>,
7203 src: &'tree [u8],
7204 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7205 debug_assert_eq!(node.kind(), "slice_pattern");
7206 Ok(Self {
7207 span: ::treesitter_types::Span::from(node),
7208 children: {
7209 #[allow(clippy::suspicious_else_formatting)]
7210 let non_field_children = {
7211 let mut cursor = node.walk();
7212 let mut result = ::std::vec::Vec::new();
7213 if cursor.goto_first_child() {
7214 loop {
7215 if cursor.field_name().is_none()
7216 && cursor.node().is_named()
7217 && !cursor.node().is_extra()
7218 {
7219 result.push(cursor.node());
7220 }
7221 if !cursor.goto_next_sibling() {
7222 break;
7223 }
7224 }
7225 }
7226 result
7227 };
7228 let mut items = ::std::vec::Vec::new();
7229 for child in non_field_children {
7230 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
7231 child, src,
7232 )?);
7233 }
7234 items
7235 },
7236 })
7237 }
7238}
7239impl ::treesitter_types::Spanned for SlicePattern<'_> {
7240 fn span(&self) -> ::treesitter_types::Span {
7241 self.span
7242 }
7243}
7244#[derive(Debug, Clone, PartialEq, Eq)]
7245pub struct SourceFile<'tree> {
7246 pub span: ::treesitter_types::Span,
7247 pub children: ::std::vec::Vec<SourceFileChildren<'tree>>,
7248}
7249impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFile<'tree> {
7250 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7251 fn from_node(
7252 node: ::tree_sitter::Node<'tree>,
7253 src: &'tree [u8],
7254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7255 debug_assert_eq!(node.kind(), "source_file");
7256 Ok(Self {
7257 span: ::treesitter_types::Span::from(node),
7258 children: {
7259 #[allow(clippy::suspicious_else_formatting)]
7260 let non_field_children = {
7261 let mut cursor = node.walk();
7262 let mut result = ::std::vec::Vec::new();
7263 if cursor.goto_first_child() {
7264 loop {
7265 if cursor.field_name().is_none()
7266 && cursor.node().is_named()
7267 && !cursor.node().is_extra()
7268 {
7269 result.push(cursor.node());
7270 }
7271 if !cursor.goto_next_sibling() {
7272 break;
7273 }
7274 }
7275 }
7276 result
7277 };
7278 let mut items = ::std::vec::Vec::new();
7279 for child in non_field_children {
7280 items.push(
7281 <SourceFileChildren as ::treesitter_types::FromNode>::from_node(
7282 child, src,
7283 )?,
7284 );
7285 }
7286 items
7287 },
7288 })
7289 }
7290}
7291impl ::treesitter_types::Spanned for SourceFile<'_> {
7292 fn span(&self) -> ::treesitter_types::Span {
7293 self.span
7294 }
7295}
7296#[derive(Debug, Clone, PartialEq, Eq)]
7297pub struct StaticItem<'tree> {
7298 pub span: ::treesitter_types::Span,
7299 pub name: Identifier<'tree>,
7300 pub r#type: Type<'tree>,
7301 pub value: ::core::option::Option<Expression<'tree>>,
7302 pub children: ::std::vec::Vec<StaticItemChildren<'tree>>,
7303}
7304impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItem<'tree> {
7305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7306 fn from_node(
7307 node: ::tree_sitter::Node<'tree>,
7308 src: &'tree [u8],
7309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7310 debug_assert_eq!(node.kind(), "static_item");
7311 Ok(Self {
7312 span: ::treesitter_types::Span::from(node),
7313 name: {
7314 let child = node
7315 .child_by_field_name("name")
7316 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7317 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7318 },
7319 r#type: {
7320 let child = node
7321 .child_by_field_name("type")
7322 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7323 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7324 },
7325 value: match node.child_by_field_name("value") {
7326 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
7327 child, src,
7328 )?),
7329 None => None,
7330 },
7331 children: {
7332 #[allow(clippy::suspicious_else_formatting)]
7333 let non_field_children = {
7334 let mut cursor = node.walk();
7335 let mut result = ::std::vec::Vec::new();
7336 if cursor.goto_first_child() {
7337 loop {
7338 if cursor.field_name().is_none()
7339 && cursor.node().is_named()
7340 && !cursor.node().is_extra()
7341 {
7342 result.push(cursor.node());
7343 }
7344 if !cursor.goto_next_sibling() {
7345 break;
7346 }
7347 }
7348 }
7349 result
7350 };
7351 let mut items = ::std::vec::Vec::new();
7352 for child in non_field_children {
7353 items.push(
7354 <StaticItemChildren as ::treesitter_types::FromNode>::from_node(
7355 child, src,
7356 )?,
7357 );
7358 }
7359 items
7360 },
7361 })
7362 }
7363}
7364impl ::treesitter_types::Spanned for StaticItem<'_> {
7365 fn span(&self) -> ::treesitter_types::Span {
7366 self.span
7367 }
7368}
7369#[derive(Debug, Clone, PartialEq, Eq)]
7370pub struct StringLiteral<'tree> {
7371 pub span: ::treesitter_types::Span,
7372 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
7373}
7374impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
7375 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7376 fn from_node(
7377 node: ::tree_sitter::Node<'tree>,
7378 src: &'tree [u8],
7379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7380 debug_assert_eq!(node.kind(), "string_literal");
7381 Ok(Self {
7382 span: ::treesitter_types::Span::from(node),
7383 children: {
7384 #[allow(clippy::suspicious_else_formatting)]
7385 let non_field_children = {
7386 let mut cursor = node.walk();
7387 let mut result = ::std::vec::Vec::new();
7388 if cursor.goto_first_child() {
7389 loop {
7390 if cursor.field_name().is_none()
7391 && cursor.node().is_named()
7392 && !cursor.node().is_extra()
7393 {
7394 result.push(cursor.node());
7395 }
7396 if !cursor.goto_next_sibling() {
7397 break;
7398 }
7399 }
7400 }
7401 result
7402 };
7403 let mut items = ::std::vec::Vec::new();
7404 for child in non_field_children {
7405 items.push(
7406 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
7407 child, src,
7408 )?,
7409 );
7410 }
7411 items
7412 },
7413 })
7414 }
7415}
7416impl ::treesitter_types::Spanned for StringLiteral<'_> {
7417 fn span(&self) -> ::treesitter_types::Span {
7418 self.span
7419 }
7420}
7421#[derive(Debug, Clone, PartialEq, Eq)]
7422pub struct StructExpression<'tree> {
7423 pub span: ::treesitter_types::Span,
7424 pub body: FieldInitializerList<'tree>,
7425 pub name: StructExpressionName<'tree>,
7426}
7427impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpression<'tree> {
7428 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7429 fn from_node(
7430 node: ::tree_sitter::Node<'tree>,
7431 src: &'tree [u8],
7432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7433 debug_assert_eq!(node.kind(), "struct_expression");
7434 Ok(Self {
7435 span: ::treesitter_types::Span::from(node),
7436 body: {
7437 let child = node
7438 .child_by_field_name("body")
7439 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7440 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(child, src)?
7441 },
7442 name: {
7443 let child = node
7444 .child_by_field_name("name")
7445 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7446 <StructExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
7447 },
7448 })
7449 }
7450}
7451impl ::treesitter_types::Spanned for StructExpression<'_> {
7452 fn span(&self) -> ::treesitter_types::Span {
7453 self.span
7454 }
7455}
7456#[derive(Debug, Clone, PartialEq, Eq)]
7457pub struct StructItem<'tree> {
7458 pub span: ::treesitter_types::Span,
7459 pub body: ::core::option::Option<StructItemBody<'tree>>,
7460 pub name: TypeIdentifier<'tree>,
7461 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7462 pub children: ::std::vec::Vec<StructItemChildren<'tree>>,
7463}
7464impl<'tree> ::treesitter_types::FromNode<'tree> for StructItem<'tree> {
7465 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7466 fn from_node(
7467 node: ::tree_sitter::Node<'tree>,
7468 src: &'tree [u8],
7469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7470 debug_assert_eq!(node.kind(), "struct_item");
7471 Ok(Self {
7472 span: ::treesitter_types::Span::from(node),
7473 body: match node.child_by_field_name("body") {
7474 Some(child) => Some(<StructItemBody as ::treesitter_types::FromNode>::from_node(
7475 child, src,
7476 )?),
7477 None => None,
7478 },
7479 name: {
7480 let child = node
7481 .child_by_field_name("name")
7482 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7483 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7484 },
7485 type_parameters: match node.child_by_field_name("type_parameters") {
7486 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
7487 child, src,
7488 )?),
7489 None => None,
7490 },
7491 children: {
7492 #[allow(clippy::suspicious_else_formatting)]
7493 let non_field_children = {
7494 let mut cursor = node.walk();
7495 let mut result = ::std::vec::Vec::new();
7496 if cursor.goto_first_child() {
7497 loop {
7498 if cursor.field_name().is_none()
7499 && cursor.node().is_named()
7500 && !cursor.node().is_extra()
7501 {
7502 result.push(cursor.node());
7503 }
7504 if !cursor.goto_next_sibling() {
7505 break;
7506 }
7507 }
7508 }
7509 result
7510 };
7511 let mut items = ::std::vec::Vec::new();
7512 for child in non_field_children {
7513 items.push(
7514 <StructItemChildren as ::treesitter_types::FromNode>::from_node(
7515 child, src,
7516 )?,
7517 );
7518 }
7519 items
7520 },
7521 })
7522 }
7523}
7524impl ::treesitter_types::Spanned for StructItem<'_> {
7525 fn span(&self) -> ::treesitter_types::Span {
7526 self.span
7527 }
7528}
7529#[derive(Debug, Clone, PartialEq, Eq)]
7530pub struct StructPattern<'tree> {
7531 pub span: ::treesitter_types::Span,
7532 pub r#type: StructPatternType<'tree>,
7533 pub children: ::std::vec::Vec<StructPatternChildren<'tree>>,
7534}
7535impl<'tree> ::treesitter_types::FromNode<'tree> for StructPattern<'tree> {
7536 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7537 fn from_node(
7538 node: ::tree_sitter::Node<'tree>,
7539 src: &'tree [u8],
7540 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7541 debug_assert_eq!(node.kind(), "struct_pattern");
7542 Ok(Self {
7543 span: ::treesitter_types::Span::from(node),
7544 r#type: {
7545 let child = node
7546 .child_by_field_name("type")
7547 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7548 <StructPatternType as ::treesitter_types::FromNode>::from_node(child, src)?
7549 },
7550 children: {
7551 #[allow(clippy::suspicious_else_formatting)]
7552 let non_field_children = {
7553 let mut cursor = node.walk();
7554 let mut result = ::std::vec::Vec::new();
7555 if cursor.goto_first_child() {
7556 loop {
7557 if cursor.field_name().is_none()
7558 && cursor.node().is_named()
7559 && !cursor.node().is_extra()
7560 {
7561 result.push(cursor.node());
7562 }
7563 if !cursor.goto_next_sibling() {
7564 break;
7565 }
7566 }
7567 }
7568 result
7569 };
7570 let mut items = ::std::vec::Vec::new();
7571 for child in non_field_children {
7572 items.push(
7573 <StructPatternChildren as ::treesitter_types::FromNode>::from_node(
7574 child, src,
7575 )?,
7576 );
7577 }
7578 items
7579 },
7580 })
7581 }
7582}
7583impl ::treesitter_types::Spanned for StructPattern<'_> {
7584 fn span(&self) -> ::treesitter_types::Span {
7585 self.span
7586 }
7587}
7588#[derive(Debug, Clone, PartialEq, Eq)]
7589pub struct TokenBindingPattern<'tree> {
7590 pub span: ::treesitter_types::Span,
7591 pub name: Metavariable<'tree>,
7592 pub r#type: FragmentSpecifier<'tree>,
7593}
7594impl<'tree> ::treesitter_types::FromNode<'tree> for TokenBindingPattern<'tree> {
7595 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7596 fn from_node(
7597 node: ::tree_sitter::Node<'tree>,
7598 src: &'tree [u8],
7599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7600 debug_assert_eq!(node.kind(), "token_binding_pattern");
7601 Ok(Self {
7602 span: ::treesitter_types::Span::from(node),
7603 name: {
7604 let child = node
7605 .child_by_field_name("name")
7606 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7607 <Metavariable as ::treesitter_types::FromNode>::from_node(child, src)?
7608 },
7609 r#type: {
7610 let child = node
7611 .child_by_field_name("type")
7612 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7613 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
7614 },
7615 })
7616 }
7617}
7618impl ::treesitter_types::Spanned for TokenBindingPattern<'_> {
7619 fn span(&self) -> ::treesitter_types::Span {
7620 self.span
7621 }
7622}
7623#[derive(Debug, Clone, PartialEq, Eq)]
7624pub struct TokenRepetition<'tree> {
7625 pub span: ::treesitter_types::Span,
7626 pub children: ::std::vec::Vec<TokenRepetitionChildren<'tree>>,
7627}
7628impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetition<'tree> {
7629 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7630 fn from_node(
7631 node: ::tree_sitter::Node<'tree>,
7632 src: &'tree [u8],
7633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7634 debug_assert_eq!(node.kind(), "token_repetition");
7635 Ok(Self {
7636 span: ::treesitter_types::Span::from(node),
7637 children: {
7638 #[allow(clippy::suspicious_else_formatting)]
7639 let non_field_children = {
7640 let mut cursor = node.walk();
7641 let mut result = ::std::vec::Vec::new();
7642 if cursor.goto_first_child() {
7643 loop {
7644 if cursor.field_name().is_none()
7645 && cursor.node().is_named()
7646 && !cursor.node().is_extra()
7647 {
7648 result.push(cursor.node());
7649 }
7650 if !cursor.goto_next_sibling() {
7651 break;
7652 }
7653 }
7654 }
7655 result
7656 };
7657 let mut items = ::std::vec::Vec::new();
7658 for child in non_field_children {
7659 items.push(
7660 <TokenRepetitionChildren as ::treesitter_types::FromNode>::from_node(
7661 child, src,
7662 )?,
7663 );
7664 }
7665 items
7666 },
7667 })
7668 }
7669}
7670impl ::treesitter_types::Spanned for TokenRepetition<'_> {
7671 fn span(&self) -> ::treesitter_types::Span {
7672 self.span
7673 }
7674}
7675#[derive(Debug, Clone, PartialEq, Eq)]
7676pub struct TokenRepetitionPattern<'tree> {
7677 pub span: ::treesitter_types::Span,
7678 pub children: ::std::vec::Vec<TokenRepetitionPatternChildren<'tree>>,
7679}
7680impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPattern<'tree> {
7681 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7682 fn from_node(
7683 node: ::tree_sitter::Node<'tree>,
7684 src: &'tree [u8],
7685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7686 debug_assert_eq!(node.kind(), "token_repetition_pattern");
7687 Ok(Self {
7688 span: ::treesitter_types::Span::from(node),
7689 children: {
7690 #[allow(clippy::suspicious_else_formatting)]
7691 let non_field_children = {
7692 let mut cursor = node.walk();
7693 let mut result = ::std::vec::Vec::new();
7694 if cursor.goto_first_child() {
7695 loop {
7696 if cursor.field_name().is_none()
7697 && cursor.node().is_named()
7698 && !cursor.node().is_extra()
7699 {
7700 result.push(cursor.node());
7701 }
7702 if !cursor.goto_next_sibling() {
7703 break;
7704 }
7705 }
7706 }
7707 result
7708 };
7709 let mut items = ::std::vec::Vec::new();
7710 for child in non_field_children {
7711 items
7712 .push(
7713 <TokenRepetitionPatternChildren as ::treesitter_types::FromNode>::from_node(
7714 child,
7715 src,
7716 )?,
7717 );
7718 }
7719 items
7720 },
7721 })
7722 }
7723}
7724impl ::treesitter_types::Spanned for TokenRepetitionPattern<'_> {
7725 fn span(&self) -> ::treesitter_types::Span {
7726 self.span
7727 }
7728}
7729#[derive(Debug, Clone, PartialEq, Eq)]
7730pub struct TokenTree<'tree> {
7731 pub span: ::treesitter_types::Span,
7732 pub children: ::std::vec::Vec<TokenTreeChildren<'tree>>,
7733}
7734impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTree<'tree> {
7735 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7736 fn from_node(
7737 node: ::tree_sitter::Node<'tree>,
7738 src: &'tree [u8],
7739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7740 debug_assert_eq!(node.kind(), "token_tree");
7741 Ok(Self {
7742 span: ::treesitter_types::Span::from(node),
7743 children: {
7744 #[allow(clippy::suspicious_else_formatting)]
7745 let non_field_children = {
7746 let mut cursor = node.walk();
7747 let mut result = ::std::vec::Vec::new();
7748 if cursor.goto_first_child() {
7749 loop {
7750 if cursor.field_name().is_none()
7751 && cursor.node().is_named()
7752 && !cursor.node().is_extra()
7753 {
7754 result.push(cursor.node());
7755 }
7756 if !cursor.goto_next_sibling() {
7757 break;
7758 }
7759 }
7760 }
7761 result
7762 };
7763 let mut items = ::std::vec::Vec::new();
7764 for child in non_field_children {
7765 items.push(
7766 <TokenTreeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7767 );
7768 }
7769 items
7770 },
7771 })
7772 }
7773}
7774impl ::treesitter_types::Spanned for TokenTree<'_> {
7775 fn span(&self) -> ::treesitter_types::Span {
7776 self.span
7777 }
7778}
7779#[derive(Debug, Clone, PartialEq, Eq)]
7780pub struct TokenTreePattern<'tree> {
7781 pub span: ::treesitter_types::Span,
7782 pub children: ::std::vec::Vec<TokenTreePatternChildren<'tree>>,
7783}
7784impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePattern<'tree> {
7785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7786 fn from_node(
7787 node: ::tree_sitter::Node<'tree>,
7788 src: &'tree [u8],
7789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7790 debug_assert_eq!(node.kind(), "token_tree_pattern");
7791 Ok(Self {
7792 span: ::treesitter_types::Span::from(node),
7793 children: {
7794 #[allow(clippy::suspicious_else_formatting)]
7795 let non_field_children = {
7796 let mut cursor = node.walk();
7797 let mut result = ::std::vec::Vec::new();
7798 if cursor.goto_first_child() {
7799 loop {
7800 if cursor.field_name().is_none()
7801 && cursor.node().is_named()
7802 && !cursor.node().is_extra()
7803 {
7804 result.push(cursor.node());
7805 }
7806 if !cursor.goto_next_sibling() {
7807 break;
7808 }
7809 }
7810 }
7811 result
7812 };
7813 let mut items = ::std::vec::Vec::new();
7814 for child in non_field_children {
7815 items.push(
7816 <TokenTreePatternChildren as ::treesitter_types::FromNode>::from_node(
7817 child, src,
7818 )?,
7819 );
7820 }
7821 items
7822 },
7823 })
7824 }
7825}
7826impl ::treesitter_types::Spanned for TokenTreePattern<'_> {
7827 fn span(&self) -> ::treesitter_types::Span {
7828 self.span
7829 }
7830}
7831#[derive(Debug, Clone, PartialEq, Eq)]
7832pub struct TraitBounds<'tree> {
7833 pub span: ::treesitter_types::Span,
7834 pub children: ::std::vec::Vec<TraitBoundsChildren<'tree>>,
7835}
7836impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBounds<'tree> {
7837 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7838 fn from_node(
7839 node: ::tree_sitter::Node<'tree>,
7840 src: &'tree [u8],
7841 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7842 debug_assert_eq!(node.kind(), "trait_bounds");
7843 Ok(Self {
7844 span: ::treesitter_types::Span::from(node),
7845 children: {
7846 #[allow(clippy::suspicious_else_formatting)]
7847 let non_field_children = {
7848 let mut cursor = node.walk();
7849 let mut result = ::std::vec::Vec::new();
7850 if cursor.goto_first_child() {
7851 loop {
7852 if cursor.field_name().is_none()
7853 && cursor.node().is_named()
7854 && !cursor.node().is_extra()
7855 {
7856 result.push(cursor.node());
7857 }
7858 if !cursor.goto_next_sibling() {
7859 break;
7860 }
7861 }
7862 }
7863 result
7864 };
7865 let mut items = ::std::vec::Vec::new();
7866 for child in non_field_children {
7867 items.push(
7868 <TraitBoundsChildren as ::treesitter_types::FromNode>::from_node(
7869 child, src,
7870 )?,
7871 );
7872 }
7873 items
7874 },
7875 })
7876 }
7877}
7878impl ::treesitter_types::Spanned for TraitBounds<'_> {
7879 fn span(&self) -> ::treesitter_types::Span {
7880 self.span
7881 }
7882}
7883#[derive(Debug, Clone, PartialEq, Eq)]
7884pub struct TraitItem<'tree> {
7885 pub span: ::treesitter_types::Span,
7886 pub body: DeclarationList<'tree>,
7887 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
7888 pub name: TypeIdentifier<'tree>,
7889 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7890 pub children: ::std::vec::Vec<TraitItemChildren<'tree>>,
7891}
7892impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItem<'tree> {
7893 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7894 fn from_node(
7895 node: ::tree_sitter::Node<'tree>,
7896 src: &'tree [u8],
7897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7898 debug_assert_eq!(node.kind(), "trait_item");
7899 Ok(Self {
7900 span: ::treesitter_types::Span::from(node),
7901 body: {
7902 let child = node
7903 .child_by_field_name("body")
7904 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7905 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
7906 },
7907 bounds: match node.child_by_field_name("bounds") {
7908 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
7909 child, src,
7910 )?),
7911 None => None,
7912 },
7913 name: {
7914 let child = node
7915 .child_by_field_name("name")
7916 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7917 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7918 },
7919 type_parameters: match node.child_by_field_name("type_parameters") {
7920 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
7921 child, src,
7922 )?),
7923 None => None,
7924 },
7925 children: {
7926 #[allow(clippy::suspicious_else_formatting)]
7927 let non_field_children = {
7928 let mut cursor = node.walk();
7929 let mut result = ::std::vec::Vec::new();
7930 if cursor.goto_first_child() {
7931 loop {
7932 if cursor.field_name().is_none()
7933 && cursor.node().is_named()
7934 && !cursor.node().is_extra()
7935 {
7936 result.push(cursor.node());
7937 }
7938 if !cursor.goto_next_sibling() {
7939 break;
7940 }
7941 }
7942 }
7943 result
7944 };
7945 let mut items = ::std::vec::Vec::new();
7946 for child in non_field_children {
7947 items.push(
7948 <TraitItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7949 );
7950 }
7951 items
7952 },
7953 })
7954 }
7955}
7956impl ::treesitter_types::Spanned for TraitItem<'_> {
7957 fn span(&self) -> ::treesitter_types::Span {
7958 self.span
7959 }
7960}
7961#[derive(Debug, Clone, PartialEq, Eq)]
7962pub struct TryBlock<'tree> {
7963 pub span: ::treesitter_types::Span,
7964 pub children: Block<'tree>,
7965}
7966impl<'tree> ::treesitter_types::FromNode<'tree> for TryBlock<'tree> {
7967 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7968 fn from_node(
7969 node: ::tree_sitter::Node<'tree>,
7970 src: &'tree [u8],
7971 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7972 debug_assert_eq!(node.kind(), "try_block");
7973 Ok(Self {
7974 span: ::treesitter_types::Span::from(node),
7975 children: {
7976 #[allow(clippy::suspicious_else_formatting)]
7977 let non_field_children = {
7978 let mut cursor = node.walk();
7979 let mut result = ::std::vec::Vec::new();
7980 if cursor.goto_first_child() {
7981 loop {
7982 if cursor.field_name().is_none()
7983 && cursor.node().is_named()
7984 && !cursor.node().is_extra()
7985 {
7986 result.push(cursor.node());
7987 }
7988 if !cursor.goto_next_sibling() {
7989 break;
7990 }
7991 }
7992 }
7993 result
7994 };
7995 let child = if let Some(&c) = non_field_children.first() {
7996 c
7997 } else {
7998 let mut fallback_cursor = node.walk();
7999 let mut fallback_child = None;
8000 if fallback_cursor.goto_first_child() {
8001 loop {
8002 if fallback_cursor.field_name().is_none()
8003 && !fallback_cursor.node().is_extra()
8004 {
8005 let candidate = fallback_cursor.node();
8006 #[allow(clippy::needless_question_mark)]
8007 if (|| -> ::core::result::Result<
8008 _,
8009 ::treesitter_types::ParseError,
8010 > {
8011 let child = candidate;
8012 Ok(
8013 <Block as ::treesitter_types::FromNode>::from_node(
8014 child,
8015 src,
8016 )?,
8017 )
8018 })()
8019 .is_ok()
8020 {
8021 fallback_child = Some(candidate);
8022 break;
8023 }
8024 }
8025 if !fallback_cursor.goto_next_sibling() {
8026 break;
8027 }
8028 }
8029 }
8030 if fallback_child.is_none() {
8031 let mut cursor2 = node.walk();
8032 if cursor2.goto_first_child() {
8033 loop {
8034 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8035 let candidate = cursor2.node();
8036 #[allow(clippy::needless_question_mark)]
8037 if (|| -> ::core::result::Result<
8038 _,
8039 ::treesitter_types::ParseError,
8040 > {
8041 let child = candidate;
8042 Ok(
8043 <Block as ::treesitter_types::FromNode>::from_node(
8044 child,
8045 src,
8046 )?,
8047 )
8048 })()
8049 .is_ok()
8050 {
8051 fallback_child = Some(candidate);
8052 break;
8053 }
8054 }
8055 if !cursor2.goto_next_sibling() {
8056 break;
8057 }
8058 }
8059 }
8060 }
8061 fallback_child.ok_or_else(|| {
8062 ::treesitter_types::ParseError::missing_field("children", node)
8063 })?
8064 };
8065 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
8066 },
8067 })
8068 }
8069}
8070impl ::treesitter_types::Spanned for TryBlock<'_> {
8071 fn span(&self) -> ::treesitter_types::Span {
8072 self.span
8073 }
8074}
8075#[derive(Debug, Clone, PartialEq, Eq)]
8076pub struct TryExpression<'tree> {
8077 pub span: ::treesitter_types::Span,
8078 pub children: Expression<'tree>,
8079}
8080impl<'tree> ::treesitter_types::FromNode<'tree> for TryExpression<'tree> {
8081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8082 fn from_node(
8083 node: ::tree_sitter::Node<'tree>,
8084 src: &'tree [u8],
8085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8086 debug_assert_eq!(node.kind(), "try_expression");
8087 Ok(Self {
8088 span: ::treesitter_types::Span::from(node),
8089 children: {
8090 #[allow(clippy::suspicious_else_formatting)]
8091 let non_field_children = {
8092 let mut cursor = node.walk();
8093 let mut result = ::std::vec::Vec::new();
8094 if cursor.goto_first_child() {
8095 loop {
8096 if cursor.field_name().is_none()
8097 && cursor.node().is_named()
8098 && !cursor.node().is_extra()
8099 {
8100 result.push(cursor.node());
8101 }
8102 if !cursor.goto_next_sibling() {
8103 break;
8104 }
8105 }
8106 }
8107 result
8108 };
8109 let child = if let Some(&c) = non_field_children.first() {
8110 c
8111 } else {
8112 let mut fallback_cursor = node.walk();
8113 let mut fallback_child = None;
8114 if fallback_cursor.goto_first_child() {
8115 loop {
8116 if fallback_cursor.field_name().is_none()
8117 && !fallback_cursor.node().is_extra()
8118 {
8119 let candidate = fallback_cursor.node();
8120 #[allow(clippy::needless_question_mark)]
8121 if (|| -> ::core::result::Result<
8122 _,
8123 ::treesitter_types::ParseError,
8124 > {
8125 let child = candidate;
8126 Ok(
8127 <Expression as ::treesitter_types::FromNode>::from_node(
8128 child,
8129 src,
8130 )?,
8131 )
8132 })()
8133 .is_ok()
8134 {
8135 fallback_child = Some(candidate);
8136 break;
8137 }
8138 }
8139 if !fallback_cursor.goto_next_sibling() {
8140 break;
8141 }
8142 }
8143 }
8144 if fallback_child.is_none() {
8145 let mut cursor2 = node.walk();
8146 if cursor2.goto_first_child() {
8147 loop {
8148 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8149 let candidate = cursor2.node();
8150 #[allow(clippy::needless_question_mark)]
8151 if (|| -> ::core::result::Result<
8152 _,
8153 ::treesitter_types::ParseError,
8154 > {
8155 let child = candidate;
8156 Ok(
8157 <Expression as ::treesitter_types::FromNode>::from_node(
8158 child,
8159 src,
8160 )?,
8161 )
8162 })()
8163 .is_ok()
8164 {
8165 fallback_child = Some(candidate);
8166 break;
8167 }
8168 }
8169 if !cursor2.goto_next_sibling() {
8170 break;
8171 }
8172 }
8173 }
8174 }
8175 fallback_child.ok_or_else(|| {
8176 ::treesitter_types::ParseError::missing_field("children", node)
8177 })?
8178 };
8179 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8180 },
8181 })
8182 }
8183}
8184impl ::treesitter_types::Spanned for TryExpression<'_> {
8185 fn span(&self) -> ::treesitter_types::Span {
8186 self.span
8187 }
8188}
8189#[derive(Debug, Clone, PartialEq, Eq)]
8190pub struct TupleExpression<'tree> {
8191 pub span: ::treesitter_types::Span,
8192 pub children: ::std::vec::Vec<TupleExpressionChildren<'tree>>,
8193}
8194impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpression<'tree> {
8195 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8196 fn from_node(
8197 node: ::tree_sitter::Node<'tree>,
8198 src: &'tree [u8],
8199 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8200 debug_assert_eq!(node.kind(), "tuple_expression");
8201 Ok(Self {
8202 span: ::treesitter_types::Span::from(node),
8203 children: {
8204 #[allow(clippy::suspicious_else_formatting)]
8205 let non_field_children = {
8206 let mut cursor = node.walk();
8207 let mut result = ::std::vec::Vec::new();
8208 if cursor.goto_first_child() {
8209 loop {
8210 if cursor.field_name().is_none()
8211 && cursor.node().is_named()
8212 && !cursor.node().is_extra()
8213 {
8214 result.push(cursor.node());
8215 }
8216 if !cursor.goto_next_sibling() {
8217 break;
8218 }
8219 }
8220 }
8221 result
8222 };
8223 let mut items = ::std::vec::Vec::new();
8224 for child in non_field_children {
8225 items.push(
8226 <TupleExpressionChildren as ::treesitter_types::FromNode>::from_node(
8227 child, src,
8228 )?,
8229 );
8230 }
8231 items
8232 },
8233 })
8234 }
8235}
8236impl ::treesitter_types::Spanned for TupleExpression<'_> {
8237 fn span(&self) -> ::treesitter_types::Span {
8238 self.span
8239 }
8240}
8241#[derive(Debug, Clone, PartialEq, Eq)]
8242pub struct TuplePattern<'tree> {
8243 pub span: ::treesitter_types::Span,
8244 pub children: ::std::vec::Vec<TuplePatternChildren<'tree>>,
8245}
8246impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePattern<'tree> {
8247 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8248 fn from_node(
8249 node: ::tree_sitter::Node<'tree>,
8250 src: &'tree [u8],
8251 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8252 debug_assert_eq!(node.kind(), "tuple_pattern");
8253 Ok(Self {
8254 span: ::treesitter_types::Span::from(node),
8255 children: {
8256 #[allow(clippy::suspicious_else_formatting)]
8257 let non_field_children = {
8258 let mut cursor = node.walk();
8259 let mut result = ::std::vec::Vec::new();
8260 if cursor.goto_first_child() {
8261 loop {
8262 if cursor.field_name().is_none()
8263 && cursor.node().is_named()
8264 && !cursor.node().is_extra()
8265 {
8266 result.push(cursor.node());
8267 }
8268 if !cursor.goto_next_sibling() {
8269 break;
8270 }
8271 }
8272 }
8273 result
8274 };
8275 let mut items = ::std::vec::Vec::new();
8276 for child in non_field_children {
8277 items.push(
8278 <TuplePatternChildren as ::treesitter_types::FromNode>::from_node(
8279 child, src,
8280 )?,
8281 );
8282 }
8283 items
8284 },
8285 })
8286 }
8287}
8288impl ::treesitter_types::Spanned for TuplePattern<'_> {
8289 fn span(&self) -> ::treesitter_types::Span {
8290 self.span
8291 }
8292}
8293#[derive(Debug, Clone, PartialEq, Eq)]
8294pub struct TupleStructPattern<'tree> {
8295 pub span: ::treesitter_types::Span,
8296 pub r#type: TupleStructPatternType<'tree>,
8297 pub children: ::std::vec::Vec<Pattern<'tree>>,
8298}
8299impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPattern<'tree> {
8300 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8301 fn from_node(
8302 node: ::tree_sitter::Node<'tree>,
8303 src: &'tree [u8],
8304 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8305 debug_assert_eq!(node.kind(), "tuple_struct_pattern");
8306 Ok(Self {
8307 span: ::treesitter_types::Span::from(node),
8308 r#type: {
8309 let child = node
8310 .child_by_field_name("type")
8311 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8312 <TupleStructPatternType as ::treesitter_types::FromNode>::from_node(child, src)?
8313 },
8314 children: {
8315 #[allow(clippy::suspicious_else_formatting)]
8316 let non_field_children = {
8317 let mut cursor = node.walk();
8318 let mut result = ::std::vec::Vec::new();
8319 if cursor.goto_first_child() {
8320 loop {
8321 if cursor.field_name().is_none()
8322 && cursor.node().is_named()
8323 && !cursor.node().is_extra()
8324 {
8325 result.push(cursor.node());
8326 }
8327 if !cursor.goto_next_sibling() {
8328 break;
8329 }
8330 }
8331 }
8332 result
8333 };
8334 let mut items = ::std::vec::Vec::new();
8335 for child in non_field_children {
8336 items.push(<Pattern as ::treesitter_types::FromNode>::from_node(
8337 child, src,
8338 )?);
8339 }
8340 items
8341 },
8342 })
8343 }
8344}
8345impl ::treesitter_types::Spanned for TupleStructPattern<'_> {
8346 fn span(&self) -> ::treesitter_types::Span {
8347 self.span
8348 }
8349}
8350#[derive(Debug, Clone, PartialEq, Eq)]
8351pub struct TupleType<'tree> {
8352 pub span: ::treesitter_types::Span,
8353 pub children: ::std::vec::Vec<Type<'tree>>,
8354}
8355impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
8356 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8357 fn from_node(
8358 node: ::tree_sitter::Node<'tree>,
8359 src: &'tree [u8],
8360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8361 debug_assert_eq!(node.kind(), "tuple_type");
8362 Ok(Self {
8363 span: ::treesitter_types::Span::from(node),
8364 children: {
8365 #[allow(clippy::suspicious_else_formatting)]
8366 let non_field_children = {
8367 let mut cursor = node.walk();
8368 let mut result = ::std::vec::Vec::new();
8369 if cursor.goto_first_child() {
8370 loop {
8371 if cursor.field_name().is_none()
8372 && cursor.node().is_named()
8373 && !cursor.node().is_extra()
8374 {
8375 result.push(cursor.node());
8376 }
8377 if !cursor.goto_next_sibling() {
8378 break;
8379 }
8380 }
8381 }
8382 result
8383 };
8384 let mut items = ::std::vec::Vec::new();
8385 for child in non_field_children {
8386 items.push(<Type as ::treesitter_types::FromNode>::from_node(
8387 child, src,
8388 )?);
8389 }
8390 items
8391 },
8392 })
8393 }
8394}
8395impl ::treesitter_types::Spanned for TupleType<'_> {
8396 fn span(&self) -> ::treesitter_types::Span {
8397 self.span
8398 }
8399}
8400#[derive(Debug, Clone, PartialEq, Eq)]
8401pub struct TypeArguments<'tree> {
8402 pub span: ::treesitter_types::Span,
8403 pub children: ::std::vec::Vec<TypeArgumentsChildren<'tree>>,
8404}
8405impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
8406 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8407 fn from_node(
8408 node: ::tree_sitter::Node<'tree>,
8409 src: &'tree [u8],
8410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8411 debug_assert_eq!(node.kind(), "type_arguments");
8412 Ok(Self {
8413 span: ::treesitter_types::Span::from(node),
8414 children: {
8415 #[allow(clippy::suspicious_else_formatting)]
8416 let non_field_children = {
8417 let mut cursor = node.walk();
8418 let mut result = ::std::vec::Vec::new();
8419 if cursor.goto_first_child() {
8420 loop {
8421 if cursor.field_name().is_none()
8422 && cursor.node().is_named()
8423 && !cursor.node().is_extra()
8424 {
8425 result.push(cursor.node());
8426 }
8427 if !cursor.goto_next_sibling() {
8428 break;
8429 }
8430 }
8431 }
8432 result
8433 };
8434 let mut items = ::std::vec::Vec::new();
8435 for child in non_field_children {
8436 items.push(
8437 <TypeArgumentsChildren as ::treesitter_types::FromNode>::from_node(
8438 child, src,
8439 )?,
8440 );
8441 }
8442 items
8443 },
8444 })
8445 }
8446}
8447impl ::treesitter_types::Spanned for TypeArguments<'_> {
8448 fn span(&self) -> ::treesitter_types::Span {
8449 self.span
8450 }
8451}
8452#[derive(Debug, Clone, PartialEq, Eq)]
8453pub struct TypeBinding<'tree> {
8454 pub span: ::treesitter_types::Span,
8455 pub name: TypeIdentifier<'tree>,
8456 pub r#type: Type<'tree>,
8457 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
8458}
8459impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBinding<'tree> {
8460 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8461 fn from_node(
8462 node: ::tree_sitter::Node<'tree>,
8463 src: &'tree [u8],
8464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8465 debug_assert_eq!(node.kind(), "type_binding");
8466 Ok(Self {
8467 span: ::treesitter_types::Span::from(node),
8468 name: {
8469 let child = node
8470 .child_by_field_name("name")
8471 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8472 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
8473 },
8474 r#type: {
8475 let child = node
8476 .child_by_field_name("type")
8477 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8478 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8479 },
8480 type_arguments: match node.child_by_field_name("type_arguments") {
8481 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
8482 child, src,
8483 )?),
8484 None => None,
8485 },
8486 })
8487 }
8488}
8489impl ::treesitter_types::Spanned for TypeBinding<'_> {
8490 fn span(&self) -> ::treesitter_types::Span {
8491 self.span
8492 }
8493}
8494#[derive(Debug, Clone, PartialEq, Eq)]
8495pub struct TypeCastExpression<'tree> {
8496 pub span: ::treesitter_types::Span,
8497 pub r#type: Type<'tree>,
8498 pub value: Expression<'tree>,
8499}
8500impl<'tree> ::treesitter_types::FromNode<'tree> for TypeCastExpression<'tree> {
8501 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8502 fn from_node(
8503 node: ::tree_sitter::Node<'tree>,
8504 src: &'tree [u8],
8505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8506 debug_assert_eq!(node.kind(), "type_cast_expression");
8507 Ok(Self {
8508 span: ::treesitter_types::Span::from(node),
8509 r#type: {
8510 let child = node
8511 .child_by_field_name("type")
8512 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8513 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8514 },
8515 value: {
8516 let child = node
8517 .child_by_field_name("value")
8518 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
8519 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8520 },
8521 })
8522 }
8523}
8524impl ::treesitter_types::Spanned for TypeCastExpression<'_> {
8525 fn span(&self) -> ::treesitter_types::Span {
8526 self.span
8527 }
8528}
8529#[derive(Debug, Clone, PartialEq, Eq)]
8530pub struct TypeItem<'tree> {
8531 pub span: ::treesitter_types::Span,
8532 pub name: TypeIdentifier<'tree>,
8533 pub r#type: Type<'tree>,
8534 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
8535 pub children: ::std::vec::Vec<TypeItemChildren<'tree>>,
8536}
8537impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItem<'tree> {
8538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8539 fn from_node(
8540 node: ::tree_sitter::Node<'tree>,
8541 src: &'tree [u8],
8542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8543 debug_assert_eq!(node.kind(), "type_item");
8544 Ok(Self {
8545 span: ::treesitter_types::Span::from(node),
8546 name: {
8547 let child = node
8548 .child_by_field_name("name")
8549 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8550 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
8551 },
8552 r#type: {
8553 let child = node
8554 .child_by_field_name("type")
8555 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8556 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8557 },
8558 type_parameters: match node.child_by_field_name("type_parameters") {
8559 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
8560 child, src,
8561 )?),
8562 None => None,
8563 },
8564 children: {
8565 #[allow(clippy::suspicious_else_formatting)]
8566 let non_field_children = {
8567 let mut cursor = node.walk();
8568 let mut result = ::std::vec::Vec::new();
8569 if cursor.goto_first_child() {
8570 loop {
8571 if cursor.field_name().is_none()
8572 && cursor.node().is_named()
8573 && !cursor.node().is_extra()
8574 {
8575 result.push(cursor.node());
8576 }
8577 if !cursor.goto_next_sibling() {
8578 break;
8579 }
8580 }
8581 }
8582 result
8583 };
8584 let mut items = ::std::vec::Vec::new();
8585 for child in non_field_children {
8586 items.push(
8587 <TypeItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8588 );
8589 }
8590 items
8591 },
8592 })
8593 }
8594}
8595impl ::treesitter_types::Spanned for TypeItem<'_> {
8596 fn span(&self) -> ::treesitter_types::Span {
8597 self.span
8598 }
8599}
8600#[derive(Debug, Clone, PartialEq, Eq)]
8601pub struct TypeParameter<'tree> {
8602 pub span: ::treesitter_types::Span,
8603 pub bounds: ::core::option::Option<TraitBounds<'tree>>,
8604 pub default_type: ::core::option::Option<Type<'tree>>,
8605 pub name: TypeIdentifier<'tree>,
8606}
8607impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
8608 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8609 fn from_node(
8610 node: ::tree_sitter::Node<'tree>,
8611 src: &'tree [u8],
8612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8613 debug_assert_eq!(node.kind(), "type_parameter");
8614 Ok(Self {
8615 span: ::treesitter_types::Span::from(node),
8616 bounds: match node.child_by_field_name("bounds") {
8617 Some(child) => Some(<TraitBounds as ::treesitter_types::FromNode>::from_node(
8618 child, src,
8619 )?),
8620 None => None,
8621 },
8622 default_type: match node.child_by_field_name("default_type") {
8623 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
8624 child, src,
8625 )?),
8626 None => None,
8627 },
8628 name: {
8629 let child = node
8630 .child_by_field_name("name")
8631 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8632 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
8633 },
8634 })
8635 }
8636}
8637impl ::treesitter_types::Spanned for TypeParameter<'_> {
8638 fn span(&self) -> ::treesitter_types::Span {
8639 self.span
8640 }
8641}
8642#[derive(Debug, Clone, PartialEq, Eq)]
8643pub struct TypeParameters<'tree> {
8644 pub span: ::treesitter_types::Span,
8645 pub children: ::std::vec::Vec<TypeParametersChildren<'tree>>,
8646}
8647impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
8648 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8649 fn from_node(
8650 node: ::tree_sitter::Node<'tree>,
8651 src: &'tree [u8],
8652 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8653 debug_assert_eq!(node.kind(), "type_parameters");
8654 Ok(Self {
8655 span: ::treesitter_types::Span::from(node),
8656 children: {
8657 #[allow(clippy::suspicious_else_formatting)]
8658 let non_field_children = {
8659 let mut cursor = node.walk();
8660 let mut result = ::std::vec::Vec::new();
8661 if cursor.goto_first_child() {
8662 loop {
8663 if cursor.field_name().is_none()
8664 && cursor.node().is_named()
8665 && !cursor.node().is_extra()
8666 {
8667 result.push(cursor.node());
8668 }
8669 if !cursor.goto_next_sibling() {
8670 break;
8671 }
8672 }
8673 }
8674 result
8675 };
8676 let mut items = ::std::vec::Vec::new();
8677 for child in non_field_children {
8678 items.push(
8679 <TypeParametersChildren as ::treesitter_types::FromNode>::from_node(
8680 child, src,
8681 )?,
8682 );
8683 }
8684 items
8685 },
8686 })
8687 }
8688}
8689impl ::treesitter_types::Spanned for TypeParameters<'_> {
8690 fn span(&self) -> ::treesitter_types::Span {
8691 self.span
8692 }
8693}
8694#[derive(Debug, Clone, PartialEq, Eq)]
8695pub struct UnaryExpression<'tree> {
8696 pub span: ::treesitter_types::Span,
8697 pub children: Expression<'tree>,
8698}
8699impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
8700 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8701 fn from_node(
8702 node: ::tree_sitter::Node<'tree>,
8703 src: &'tree [u8],
8704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8705 debug_assert_eq!(node.kind(), "unary_expression");
8706 Ok(Self {
8707 span: ::treesitter_types::Span::from(node),
8708 children: {
8709 #[allow(clippy::suspicious_else_formatting)]
8710 let non_field_children = {
8711 let mut cursor = node.walk();
8712 let mut result = ::std::vec::Vec::new();
8713 if cursor.goto_first_child() {
8714 loop {
8715 if cursor.field_name().is_none()
8716 && cursor.node().is_named()
8717 && !cursor.node().is_extra()
8718 {
8719 result.push(cursor.node());
8720 }
8721 if !cursor.goto_next_sibling() {
8722 break;
8723 }
8724 }
8725 }
8726 result
8727 };
8728 let child = if let Some(&c) = non_field_children.first() {
8729 c
8730 } else {
8731 let mut fallback_cursor = node.walk();
8732 let mut fallback_child = None;
8733 if fallback_cursor.goto_first_child() {
8734 loop {
8735 if fallback_cursor.field_name().is_none()
8736 && !fallback_cursor.node().is_extra()
8737 {
8738 let candidate = fallback_cursor.node();
8739 #[allow(clippy::needless_question_mark)]
8740 if (|| -> ::core::result::Result<
8741 _,
8742 ::treesitter_types::ParseError,
8743 > {
8744 let child = candidate;
8745 Ok(
8746 <Expression as ::treesitter_types::FromNode>::from_node(
8747 child,
8748 src,
8749 )?,
8750 )
8751 })()
8752 .is_ok()
8753 {
8754 fallback_child = Some(candidate);
8755 break;
8756 }
8757 }
8758 if !fallback_cursor.goto_next_sibling() {
8759 break;
8760 }
8761 }
8762 }
8763 if fallback_child.is_none() {
8764 let mut cursor2 = node.walk();
8765 if cursor2.goto_first_child() {
8766 loop {
8767 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8768 let candidate = cursor2.node();
8769 #[allow(clippy::needless_question_mark)]
8770 if (|| -> ::core::result::Result<
8771 _,
8772 ::treesitter_types::ParseError,
8773 > {
8774 let child = candidate;
8775 Ok(
8776 <Expression as ::treesitter_types::FromNode>::from_node(
8777 child,
8778 src,
8779 )?,
8780 )
8781 })()
8782 .is_ok()
8783 {
8784 fallback_child = Some(candidate);
8785 break;
8786 }
8787 }
8788 if !cursor2.goto_next_sibling() {
8789 break;
8790 }
8791 }
8792 }
8793 }
8794 fallback_child.ok_or_else(|| {
8795 ::treesitter_types::ParseError::missing_field("children", node)
8796 })?
8797 };
8798 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8799 },
8800 })
8801 }
8802}
8803impl ::treesitter_types::Spanned for UnaryExpression<'_> {
8804 fn span(&self) -> ::treesitter_types::Span {
8805 self.span
8806 }
8807}
8808#[derive(Debug, Clone, PartialEq, Eq)]
8809pub struct UnionItem<'tree> {
8810 pub span: ::treesitter_types::Span,
8811 pub body: FieldDeclarationList<'tree>,
8812 pub name: TypeIdentifier<'tree>,
8813 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
8814 pub children: ::std::vec::Vec<UnionItemChildren<'tree>>,
8815}
8816impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItem<'tree> {
8817 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8818 fn from_node(
8819 node: ::tree_sitter::Node<'tree>,
8820 src: &'tree [u8],
8821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8822 debug_assert_eq!(node.kind(), "union_item");
8823 Ok(Self {
8824 span: ::treesitter_types::Span::from(node),
8825 body: {
8826 let child = node
8827 .child_by_field_name("body")
8828 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8829 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
8830 },
8831 name: {
8832 let child = node
8833 .child_by_field_name("name")
8834 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8835 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
8836 },
8837 type_parameters: match node.child_by_field_name("type_parameters") {
8838 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
8839 child, src,
8840 )?),
8841 None => None,
8842 },
8843 children: {
8844 #[allow(clippy::suspicious_else_formatting)]
8845 let non_field_children = {
8846 let mut cursor = node.walk();
8847 let mut result = ::std::vec::Vec::new();
8848 if cursor.goto_first_child() {
8849 loop {
8850 if cursor.field_name().is_none()
8851 && cursor.node().is_named()
8852 && !cursor.node().is_extra()
8853 {
8854 result.push(cursor.node());
8855 }
8856 if !cursor.goto_next_sibling() {
8857 break;
8858 }
8859 }
8860 }
8861 result
8862 };
8863 let mut items = ::std::vec::Vec::new();
8864 for child in non_field_children {
8865 items.push(
8866 <UnionItemChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8867 );
8868 }
8869 items
8870 },
8871 })
8872 }
8873}
8874impl ::treesitter_types::Spanned for UnionItem<'_> {
8875 fn span(&self) -> ::treesitter_types::Span {
8876 self.span
8877 }
8878}
8879#[derive(Debug, Clone, PartialEq, Eq)]
8880pub struct UnitExpression<'tree> {
8881 pub span: ::treesitter_types::Span,
8882 text: &'tree str,
8883}
8884impl<'tree> ::treesitter_types::FromNode<'tree> for UnitExpression<'tree> {
8885 fn from_node(
8886 node: ::tree_sitter::Node<'tree>,
8887 src: &'tree [u8],
8888 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8889 debug_assert_eq!(node.kind(), "unit_expression");
8890 Ok(Self {
8891 span: ::treesitter_types::Span::from(node),
8892 text: node.utf8_text(src)?,
8893 })
8894 }
8895}
8896impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitExpression<'tree> {
8897 fn text(&self) -> &'tree str {
8898 self.text
8899 }
8900}
8901impl ::treesitter_types::Spanned for UnitExpression<'_> {
8902 fn span(&self) -> ::treesitter_types::Span {
8903 self.span
8904 }
8905}
8906#[derive(Debug, Clone, PartialEq, Eq)]
8907pub struct UnitType<'tree> {
8908 pub span: ::treesitter_types::Span,
8909 text: &'tree str,
8910}
8911impl<'tree> ::treesitter_types::FromNode<'tree> for UnitType<'tree> {
8912 fn from_node(
8913 node: ::tree_sitter::Node<'tree>,
8914 src: &'tree [u8],
8915 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8916 debug_assert_eq!(node.kind(), "unit_type");
8917 Ok(Self {
8918 span: ::treesitter_types::Span::from(node),
8919 text: node.utf8_text(src)?,
8920 })
8921 }
8922}
8923impl<'tree> ::treesitter_types::LeafNode<'tree> for UnitType<'tree> {
8924 fn text(&self) -> &'tree str {
8925 self.text
8926 }
8927}
8928impl ::treesitter_types::Spanned for UnitType<'_> {
8929 fn span(&self) -> ::treesitter_types::Span {
8930 self.span
8931 }
8932}
8933#[derive(Debug, Clone, PartialEq, Eq)]
8934pub struct UnsafeBlock<'tree> {
8935 pub span: ::treesitter_types::Span,
8936 pub children: Block<'tree>,
8937}
8938impl<'tree> ::treesitter_types::FromNode<'tree> for UnsafeBlock<'tree> {
8939 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8940 fn from_node(
8941 node: ::tree_sitter::Node<'tree>,
8942 src: &'tree [u8],
8943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8944 debug_assert_eq!(node.kind(), "unsafe_block");
8945 Ok(Self {
8946 span: ::treesitter_types::Span::from(node),
8947 children: {
8948 #[allow(clippy::suspicious_else_formatting)]
8949 let non_field_children = {
8950 let mut cursor = node.walk();
8951 let mut result = ::std::vec::Vec::new();
8952 if cursor.goto_first_child() {
8953 loop {
8954 if cursor.field_name().is_none()
8955 && cursor.node().is_named()
8956 && !cursor.node().is_extra()
8957 {
8958 result.push(cursor.node());
8959 }
8960 if !cursor.goto_next_sibling() {
8961 break;
8962 }
8963 }
8964 }
8965 result
8966 };
8967 let child = if let Some(&c) = non_field_children.first() {
8968 c
8969 } else {
8970 let mut fallback_cursor = node.walk();
8971 let mut fallback_child = None;
8972 if fallback_cursor.goto_first_child() {
8973 loop {
8974 if fallback_cursor.field_name().is_none()
8975 && !fallback_cursor.node().is_extra()
8976 {
8977 let candidate = fallback_cursor.node();
8978 #[allow(clippy::needless_question_mark)]
8979 if (|| -> ::core::result::Result<
8980 _,
8981 ::treesitter_types::ParseError,
8982 > {
8983 let child = candidate;
8984 Ok(
8985 <Block as ::treesitter_types::FromNode>::from_node(
8986 child,
8987 src,
8988 )?,
8989 )
8990 })()
8991 .is_ok()
8992 {
8993 fallback_child = Some(candidate);
8994 break;
8995 }
8996 }
8997 if !fallback_cursor.goto_next_sibling() {
8998 break;
8999 }
9000 }
9001 }
9002 if fallback_child.is_none() {
9003 let mut cursor2 = node.walk();
9004 if cursor2.goto_first_child() {
9005 loop {
9006 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9007 let candidate = cursor2.node();
9008 #[allow(clippy::needless_question_mark)]
9009 if (|| -> ::core::result::Result<
9010 _,
9011 ::treesitter_types::ParseError,
9012 > {
9013 let child = candidate;
9014 Ok(
9015 <Block as ::treesitter_types::FromNode>::from_node(
9016 child,
9017 src,
9018 )?,
9019 )
9020 })()
9021 .is_ok()
9022 {
9023 fallback_child = Some(candidate);
9024 break;
9025 }
9026 }
9027 if !cursor2.goto_next_sibling() {
9028 break;
9029 }
9030 }
9031 }
9032 }
9033 fallback_child.ok_or_else(|| {
9034 ::treesitter_types::ParseError::missing_field("children", node)
9035 })?
9036 };
9037 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
9038 },
9039 })
9040 }
9041}
9042impl ::treesitter_types::Spanned for UnsafeBlock<'_> {
9043 fn span(&self) -> ::treesitter_types::Span {
9044 self.span
9045 }
9046}
9047#[derive(Debug, Clone, PartialEq, Eq)]
9048pub struct UseAsClause<'tree> {
9049 pub span: ::treesitter_types::Span,
9050 pub alias: Identifier<'tree>,
9051 pub path: UseAsClausePath<'tree>,
9052}
9053impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClause<'tree> {
9054 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9055 fn from_node(
9056 node: ::tree_sitter::Node<'tree>,
9057 src: &'tree [u8],
9058 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9059 debug_assert_eq!(node.kind(), "use_as_clause");
9060 Ok(Self {
9061 span: ::treesitter_types::Span::from(node),
9062 alias: {
9063 let child = node
9064 .child_by_field_name("alias")
9065 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("alias", node))?;
9066 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
9067 },
9068 path: {
9069 let child = node
9070 .child_by_field_name("path")
9071 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
9072 <UseAsClausePath as ::treesitter_types::FromNode>::from_node(child, src)?
9073 },
9074 })
9075 }
9076}
9077impl ::treesitter_types::Spanned for UseAsClause<'_> {
9078 fn span(&self) -> ::treesitter_types::Span {
9079 self.span
9080 }
9081}
9082#[derive(Debug, Clone, PartialEq, Eq)]
9083pub struct UseBounds<'tree> {
9084 pub span: ::treesitter_types::Span,
9085 pub children: ::std::vec::Vec<UseBoundsChildren<'tree>>,
9086}
9087impl<'tree> ::treesitter_types::FromNode<'tree> for UseBounds<'tree> {
9088 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9089 fn from_node(
9090 node: ::tree_sitter::Node<'tree>,
9091 src: &'tree [u8],
9092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9093 debug_assert_eq!(node.kind(), "use_bounds");
9094 Ok(Self {
9095 span: ::treesitter_types::Span::from(node),
9096 children: {
9097 #[allow(clippy::suspicious_else_formatting)]
9098 let non_field_children = {
9099 let mut cursor = node.walk();
9100 let mut result = ::std::vec::Vec::new();
9101 if cursor.goto_first_child() {
9102 loop {
9103 if cursor.field_name().is_none()
9104 && cursor.node().is_named()
9105 && !cursor.node().is_extra()
9106 {
9107 result.push(cursor.node());
9108 }
9109 if !cursor.goto_next_sibling() {
9110 break;
9111 }
9112 }
9113 }
9114 result
9115 };
9116 let mut items = ::std::vec::Vec::new();
9117 for child in non_field_children {
9118 items.push(
9119 <UseBoundsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
9120 );
9121 }
9122 items
9123 },
9124 })
9125 }
9126}
9127impl ::treesitter_types::Spanned for UseBounds<'_> {
9128 fn span(&self) -> ::treesitter_types::Span {
9129 self.span
9130 }
9131}
9132#[derive(Debug, Clone, PartialEq, Eq)]
9133pub struct UseDeclaration<'tree> {
9134 pub span: ::treesitter_types::Span,
9135 pub argument: UseDeclarationArgument<'tree>,
9136 pub children: ::core::option::Option<VisibilityModifier<'tree>>,
9137}
9138impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclaration<'tree> {
9139 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9140 fn from_node(
9141 node: ::tree_sitter::Node<'tree>,
9142 src: &'tree [u8],
9143 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9144 debug_assert_eq!(node.kind(), "use_declaration");
9145 Ok(Self {
9146 span: ::treesitter_types::Span::from(node),
9147 argument: {
9148 let child = node.child_by_field_name("argument").ok_or_else(|| {
9149 ::treesitter_types::ParseError::missing_field("argument", node)
9150 })?;
9151 <UseDeclarationArgument as ::treesitter_types::FromNode>::from_node(child, src)?
9152 },
9153 children: {
9154 #[allow(clippy::suspicious_else_formatting)]
9155 let non_field_children = {
9156 let mut cursor = node.walk();
9157 let mut result = ::std::vec::Vec::new();
9158 if cursor.goto_first_child() {
9159 loop {
9160 if cursor.field_name().is_none()
9161 && cursor.node().is_named()
9162 && !cursor.node().is_extra()
9163 {
9164 result.push(cursor.node());
9165 }
9166 if !cursor.goto_next_sibling() {
9167 break;
9168 }
9169 }
9170 }
9171 result
9172 };
9173 match non_field_children.first() {
9174 Some(&child) => Some(
9175 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(
9176 child, src,
9177 )?,
9178 ),
9179 None => None,
9180 }
9181 },
9182 })
9183 }
9184}
9185impl ::treesitter_types::Spanned for UseDeclaration<'_> {
9186 fn span(&self) -> ::treesitter_types::Span {
9187 self.span
9188 }
9189}
9190#[derive(Debug, Clone, PartialEq, Eq)]
9191pub struct UseList<'tree> {
9192 pub span: ::treesitter_types::Span,
9193 pub children: ::std::vec::Vec<UseListChildren<'tree>>,
9194}
9195impl<'tree> ::treesitter_types::FromNode<'tree> for UseList<'tree> {
9196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9197 fn from_node(
9198 node: ::tree_sitter::Node<'tree>,
9199 src: &'tree [u8],
9200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9201 debug_assert_eq!(node.kind(), "use_list");
9202 Ok(Self {
9203 span: ::treesitter_types::Span::from(node),
9204 children: {
9205 #[allow(clippy::suspicious_else_formatting)]
9206 let non_field_children = {
9207 let mut cursor = node.walk();
9208 let mut result = ::std::vec::Vec::new();
9209 if cursor.goto_first_child() {
9210 loop {
9211 if cursor.field_name().is_none()
9212 && cursor.node().is_named()
9213 && !cursor.node().is_extra()
9214 {
9215 result.push(cursor.node());
9216 }
9217 if !cursor.goto_next_sibling() {
9218 break;
9219 }
9220 }
9221 }
9222 result
9223 };
9224 let mut items = ::std::vec::Vec::new();
9225 for child in non_field_children {
9226 items.push(
9227 <UseListChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
9228 );
9229 }
9230 items
9231 },
9232 })
9233 }
9234}
9235impl ::treesitter_types::Spanned for UseList<'_> {
9236 fn span(&self) -> ::treesitter_types::Span {
9237 self.span
9238 }
9239}
9240#[derive(Debug, Clone, PartialEq, Eq)]
9241pub struct UseWildcard<'tree> {
9242 pub span: ::treesitter_types::Span,
9243 pub children: ::core::option::Option<UseWildcardChildren<'tree>>,
9244}
9245impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcard<'tree> {
9246 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9247 fn from_node(
9248 node: ::tree_sitter::Node<'tree>,
9249 src: &'tree [u8],
9250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9251 debug_assert_eq!(node.kind(), "use_wildcard");
9252 Ok(Self {
9253 span: ::treesitter_types::Span::from(node),
9254 children: {
9255 #[allow(clippy::suspicious_else_formatting)]
9256 let non_field_children = {
9257 let mut cursor = node.walk();
9258 let mut result = ::std::vec::Vec::new();
9259 if cursor.goto_first_child() {
9260 loop {
9261 if cursor.field_name().is_none()
9262 && cursor.node().is_named()
9263 && !cursor.node().is_extra()
9264 {
9265 result.push(cursor.node());
9266 }
9267 if !cursor.goto_next_sibling() {
9268 break;
9269 }
9270 }
9271 }
9272 result
9273 };
9274 match non_field_children.first() {
9275 Some(&child) => Some(
9276 <UseWildcardChildren as ::treesitter_types::FromNode>::from_node(
9277 child, src,
9278 )?,
9279 ),
9280 None => None,
9281 }
9282 },
9283 })
9284 }
9285}
9286impl ::treesitter_types::Spanned for UseWildcard<'_> {
9287 fn span(&self) -> ::treesitter_types::Span {
9288 self.span
9289 }
9290}
9291#[derive(Debug, Clone, PartialEq, Eq)]
9292pub struct VariadicParameter<'tree> {
9293 pub span: ::treesitter_types::Span,
9294 pub pattern: ::core::option::Option<Pattern<'tree>>,
9295 pub children: ::core::option::Option<MutableSpecifier<'tree>>,
9296}
9297impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
9298 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9299 fn from_node(
9300 node: ::tree_sitter::Node<'tree>,
9301 src: &'tree [u8],
9302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9303 debug_assert_eq!(node.kind(), "variadic_parameter");
9304 Ok(Self {
9305 span: ::treesitter_types::Span::from(node),
9306 pattern: match node.child_by_field_name("pattern") {
9307 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
9308 child, src,
9309 )?),
9310 None => None,
9311 },
9312 children: {
9313 #[allow(clippy::suspicious_else_formatting)]
9314 let non_field_children = {
9315 let mut cursor = node.walk();
9316 let mut result = ::std::vec::Vec::new();
9317 if cursor.goto_first_child() {
9318 loop {
9319 if cursor.field_name().is_none()
9320 && cursor.node().is_named()
9321 && !cursor.node().is_extra()
9322 {
9323 result.push(cursor.node());
9324 }
9325 if !cursor.goto_next_sibling() {
9326 break;
9327 }
9328 }
9329 }
9330 result
9331 };
9332 match non_field_children.first() {
9333 Some(&child) => Some(
9334 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
9335 ),
9336 None => None,
9337 }
9338 },
9339 })
9340 }
9341}
9342impl ::treesitter_types::Spanned for VariadicParameter<'_> {
9343 fn span(&self) -> ::treesitter_types::Span {
9344 self.span
9345 }
9346}
9347#[derive(Debug, Clone, PartialEq, Eq)]
9348pub struct VisibilityModifier<'tree> {
9349 pub span: ::treesitter_types::Span,
9350 pub children: ::core::option::Option<VisibilityModifierChildren<'tree>>,
9351}
9352impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifier<'tree> {
9353 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9354 fn from_node(
9355 node: ::tree_sitter::Node<'tree>,
9356 src: &'tree [u8],
9357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9358 debug_assert_eq!(node.kind(), "visibility_modifier");
9359 Ok(Self {
9360 span: ::treesitter_types::Span::from(node),
9361 children: {
9362 #[allow(clippy::suspicious_else_formatting)]
9363 let non_field_children = {
9364 let mut cursor = node.walk();
9365 let mut result = ::std::vec::Vec::new();
9366 if cursor.goto_first_child() {
9367 loop {
9368 if cursor.field_name().is_none()
9369 && cursor.node().is_named()
9370 && !cursor.node().is_extra()
9371 {
9372 result.push(cursor.node());
9373 }
9374 if !cursor.goto_next_sibling() {
9375 break;
9376 }
9377 }
9378 }
9379 result
9380 };
9381 match non_field_children.first() {
9382 Some(&child) => Some(
9383 <VisibilityModifierChildren as ::treesitter_types::FromNode>::from_node(
9384 child, src,
9385 )?,
9386 ),
9387 None => None,
9388 }
9389 },
9390 })
9391 }
9392}
9393impl ::treesitter_types::Spanned for VisibilityModifier<'_> {
9394 fn span(&self) -> ::treesitter_types::Span {
9395 self.span
9396 }
9397}
9398#[derive(Debug, Clone, PartialEq, Eq)]
9399pub struct WhereClause<'tree> {
9400 pub span: ::treesitter_types::Span,
9401 pub children: ::std::vec::Vec<WherePredicate<'tree>>,
9402}
9403impl<'tree> ::treesitter_types::FromNode<'tree> for WhereClause<'tree> {
9404 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9405 fn from_node(
9406 node: ::tree_sitter::Node<'tree>,
9407 src: &'tree [u8],
9408 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9409 debug_assert_eq!(node.kind(), "where_clause");
9410 Ok(Self {
9411 span: ::treesitter_types::Span::from(node),
9412 children: {
9413 #[allow(clippy::suspicious_else_formatting)]
9414 let non_field_children = {
9415 let mut cursor = node.walk();
9416 let mut result = ::std::vec::Vec::new();
9417 if cursor.goto_first_child() {
9418 loop {
9419 if cursor.field_name().is_none()
9420 && cursor.node().is_named()
9421 && !cursor.node().is_extra()
9422 {
9423 result.push(cursor.node());
9424 }
9425 if !cursor.goto_next_sibling() {
9426 break;
9427 }
9428 }
9429 }
9430 result
9431 };
9432 let mut items = ::std::vec::Vec::new();
9433 for child in non_field_children {
9434 items.push(<WherePredicate as ::treesitter_types::FromNode>::from_node(
9435 child, src,
9436 )?);
9437 }
9438 items
9439 },
9440 })
9441 }
9442}
9443impl ::treesitter_types::Spanned for WhereClause<'_> {
9444 fn span(&self) -> ::treesitter_types::Span {
9445 self.span
9446 }
9447}
9448#[derive(Debug, Clone, PartialEq, Eq)]
9449pub struct WherePredicate<'tree> {
9450 pub span: ::treesitter_types::Span,
9451 pub bounds: TraitBounds<'tree>,
9452 pub left: WherePredicateLeft<'tree>,
9453}
9454impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicate<'tree> {
9455 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9456 fn from_node(
9457 node: ::tree_sitter::Node<'tree>,
9458 src: &'tree [u8],
9459 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9460 debug_assert_eq!(node.kind(), "where_predicate");
9461 Ok(Self {
9462 span: ::treesitter_types::Span::from(node),
9463 bounds: {
9464 let child = node
9465 .child_by_field_name("bounds")
9466 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bounds", node))?;
9467 <TraitBounds as ::treesitter_types::FromNode>::from_node(child, src)?
9468 },
9469 left: {
9470 let child = node
9471 .child_by_field_name("left")
9472 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
9473 <WherePredicateLeft as ::treesitter_types::FromNode>::from_node(child, src)?
9474 },
9475 })
9476 }
9477}
9478impl ::treesitter_types::Spanned for WherePredicate<'_> {
9479 fn span(&self) -> ::treesitter_types::Span {
9480 self.span
9481 }
9482}
9483#[derive(Debug, Clone, PartialEq, Eq)]
9484pub struct WhileExpression<'tree> {
9485 pub span: ::treesitter_types::Span,
9486 pub body: Block<'tree>,
9487 pub condition: WhileExpressionCondition<'tree>,
9488 pub children: ::core::option::Option<Label<'tree>>,
9489}
9490impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpression<'tree> {
9491 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9492 fn from_node(
9493 node: ::tree_sitter::Node<'tree>,
9494 src: &'tree [u8],
9495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9496 debug_assert_eq!(node.kind(), "while_expression");
9497 Ok(Self {
9498 span: ::treesitter_types::Span::from(node),
9499 body: {
9500 let child = node
9501 .child_by_field_name("body")
9502 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9503 <Block as ::treesitter_types::FromNode>::from_node(child, src)?
9504 },
9505 condition: {
9506 let child = node.child_by_field_name("condition").ok_or_else(|| {
9507 ::treesitter_types::ParseError::missing_field("condition", node)
9508 })?;
9509 <WhileExpressionCondition as ::treesitter_types::FromNode>::from_node(child, src)?
9510 },
9511 children: {
9512 #[allow(clippy::suspicious_else_formatting)]
9513 let non_field_children = {
9514 let mut cursor = node.walk();
9515 let mut result = ::std::vec::Vec::new();
9516 if cursor.goto_first_child() {
9517 loop {
9518 if cursor.field_name().is_none()
9519 && cursor.node().is_named()
9520 && !cursor.node().is_extra()
9521 {
9522 result.push(cursor.node());
9523 }
9524 if !cursor.goto_next_sibling() {
9525 break;
9526 }
9527 }
9528 }
9529 result
9530 };
9531 match non_field_children.first() {
9532 Some(&child) => Some(<Label as ::treesitter_types::FromNode>::from_node(
9533 child, src,
9534 )?),
9535 None => None,
9536 }
9537 },
9538 })
9539 }
9540}
9541impl ::treesitter_types::Spanned for WhileExpression<'_> {
9542 fn span(&self) -> ::treesitter_types::Span {
9543 self.span
9544 }
9545}
9546#[derive(Debug, Clone, PartialEq, Eq)]
9547pub struct YieldExpression<'tree> {
9548 pub span: ::treesitter_types::Span,
9549 pub children: ::core::option::Option<Expression<'tree>>,
9550}
9551impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
9552 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9553 fn from_node(
9554 node: ::tree_sitter::Node<'tree>,
9555 src: &'tree [u8],
9556 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9557 debug_assert_eq!(node.kind(), "yield_expression");
9558 Ok(Self {
9559 span: ::treesitter_types::Span::from(node),
9560 children: {
9561 #[allow(clippy::suspicious_else_formatting)]
9562 let non_field_children = {
9563 let mut cursor = node.walk();
9564 let mut result = ::std::vec::Vec::new();
9565 if cursor.goto_first_child() {
9566 loop {
9567 if cursor.field_name().is_none()
9568 && cursor.node().is_named()
9569 && !cursor.node().is_extra()
9570 {
9571 result.push(cursor.node());
9572 }
9573 if !cursor.goto_next_sibling() {
9574 break;
9575 }
9576 }
9577 }
9578 result
9579 };
9580 match non_field_children.first() {
9581 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
9582 child, src,
9583 )?),
9584 None => None,
9585 }
9586 },
9587 })
9588 }
9589}
9590impl ::treesitter_types::Spanned for YieldExpression<'_> {
9591 fn span(&self) -> ::treesitter_types::Span {
9592 self.span
9593 }
9594}
9595#[derive(Debug, Clone, PartialEq, Eq)]
9596pub struct CharLiteral<'tree> {
9597 pub span: ::treesitter_types::Span,
9598 text: &'tree str,
9599}
9600impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
9601 fn from_node(
9602 node: ::tree_sitter::Node<'tree>,
9603 src: &'tree [u8],
9604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9605 debug_assert_eq!(node.kind(), "char_literal");
9606 Ok(Self {
9607 span: ::treesitter_types::Span::from(node),
9608 text: node.utf8_text(src)?,
9609 })
9610 }
9611}
9612impl<'tree> ::treesitter_types::LeafNode<'tree> for CharLiteral<'tree> {
9613 fn text(&self) -> &'tree str {
9614 self.text
9615 }
9616}
9617impl ::treesitter_types::Spanned for CharLiteral<'_> {
9618 fn span(&self) -> ::treesitter_types::Span {
9619 self.span
9620 }
9621}
9622#[derive(Debug, Clone, PartialEq, Eq)]
9623pub struct Crate<'tree> {
9624 pub span: ::treesitter_types::Span,
9625 text: &'tree str,
9626}
9627impl<'tree> ::treesitter_types::FromNode<'tree> for Crate<'tree> {
9628 fn from_node(
9629 node: ::tree_sitter::Node<'tree>,
9630 src: &'tree [u8],
9631 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9632 debug_assert_eq!(node.kind(), "crate");
9633 Ok(Self {
9634 span: ::treesitter_types::Span::from(node),
9635 text: node.utf8_text(src)?,
9636 })
9637 }
9638}
9639impl<'tree> ::treesitter_types::LeafNode<'tree> for Crate<'tree> {
9640 fn text(&self) -> &'tree str {
9641 self.text
9642 }
9643}
9644impl ::treesitter_types::Spanned for Crate<'_> {
9645 fn span(&self) -> ::treesitter_types::Span {
9646 self.span
9647 }
9648}
9649#[derive(Debug, Clone, PartialEq, Eq)]
9650pub struct DocComment<'tree> {
9651 pub span: ::treesitter_types::Span,
9652 text: &'tree str,
9653}
9654impl<'tree> ::treesitter_types::FromNode<'tree> for DocComment<'tree> {
9655 fn from_node(
9656 node: ::tree_sitter::Node<'tree>,
9657 src: &'tree [u8],
9658 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9659 debug_assert_eq!(node.kind(), "doc_comment");
9660 Ok(Self {
9661 span: ::treesitter_types::Span::from(node),
9662 text: node.utf8_text(src)?,
9663 })
9664 }
9665}
9666impl<'tree> ::treesitter_types::LeafNode<'tree> for DocComment<'tree> {
9667 fn text(&self) -> &'tree str {
9668 self.text
9669 }
9670}
9671impl ::treesitter_types::Spanned for DocComment<'_> {
9672 fn span(&self) -> ::treesitter_types::Span {
9673 self.span
9674 }
9675}
9676#[derive(Debug, Clone, PartialEq, Eq)]
9677pub struct EscapeSequence<'tree> {
9678 pub span: ::treesitter_types::Span,
9679 text: &'tree str,
9680}
9681impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
9682 fn from_node(
9683 node: ::tree_sitter::Node<'tree>,
9684 src: &'tree [u8],
9685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9686 debug_assert_eq!(node.kind(), "escape_sequence");
9687 Ok(Self {
9688 span: ::treesitter_types::Span::from(node),
9689 text: node.utf8_text(src)?,
9690 })
9691 }
9692}
9693impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
9694 fn text(&self) -> &'tree str {
9695 self.text
9696 }
9697}
9698impl ::treesitter_types::Spanned for EscapeSequence<'_> {
9699 fn span(&self) -> ::treesitter_types::Span {
9700 self.span
9701 }
9702}
9703#[derive(Debug, Clone, PartialEq, Eq)]
9704pub struct FieldIdentifier<'tree> {
9705 pub span: ::treesitter_types::Span,
9706 text: &'tree str,
9707}
9708impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
9709 fn from_node(
9710 node: ::tree_sitter::Node<'tree>,
9711 src: &'tree [u8],
9712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9713 debug_assert_eq!(node.kind(), "field_identifier");
9714 Ok(Self {
9715 span: ::treesitter_types::Span::from(node),
9716 text: node.utf8_text(src)?,
9717 })
9718 }
9719}
9720impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
9721 fn text(&self) -> &'tree str {
9722 self.text
9723 }
9724}
9725impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
9726 fn span(&self) -> ::treesitter_types::Span {
9727 self.span
9728 }
9729}
9730#[derive(Debug, Clone, PartialEq, Eq)]
9731pub struct FloatLiteral<'tree> {
9732 pub span: ::treesitter_types::Span,
9733 text: &'tree str,
9734}
9735impl<'tree> ::treesitter_types::FromNode<'tree> for FloatLiteral<'tree> {
9736 fn from_node(
9737 node: ::tree_sitter::Node<'tree>,
9738 src: &'tree [u8],
9739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9740 debug_assert_eq!(node.kind(), "float_literal");
9741 Ok(Self {
9742 span: ::treesitter_types::Span::from(node),
9743 text: node.utf8_text(src)?,
9744 })
9745 }
9746}
9747impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatLiteral<'tree> {
9748 fn text(&self) -> &'tree str {
9749 self.text
9750 }
9751}
9752impl ::treesitter_types::Spanned for FloatLiteral<'_> {
9753 fn span(&self) -> ::treesitter_types::Span {
9754 self.span
9755 }
9756}
9757#[derive(Debug, Clone, PartialEq, Eq)]
9758pub struct Identifier<'tree> {
9759 pub span: ::treesitter_types::Span,
9760 text: &'tree str,
9761}
9762impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
9763 fn from_node(
9764 node: ::tree_sitter::Node<'tree>,
9765 src: &'tree [u8],
9766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9767 debug_assert_eq!(node.kind(), "identifier");
9768 Ok(Self {
9769 span: ::treesitter_types::Span::from(node),
9770 text: node.utf8_text(src)?,
9771 })
9772 }
9773}
9774impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
9775 fn text(&self) -> &'tree str {
9776 self.text
9777 }
9778}
9779impl ::treesitter_types::Spanned for Identifier<'_> {
9780 fn span(&self) -> ::treesitter_types::Span {
9781 self.span
9782 }
9783}
9784#[derive(Debug, Clone, PartialEq, Eq)]
9785pub struct IntegerLiteral<'tree> {
9786 pub span: ::treesitter_types::Span,
9787 text: &'tree str,
9788}
9789impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerLiteral<'tree> {
9790 fn from_node(
9791 node: ::tree_sitter::Node<'tree>,
9792 src: &'tree [u8],
9793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9794 debug_assert_eq!(node.kind(), "integer_literal");
9795 Ok(Self {
9796 span: ::treesitter_types::Span::from(node),
9797 text: node.utf8_text(src)?,
9798 })
9799 }
9800}
9801impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerLiteral<'tree> {
9802 fn text(&self) -> &'tree str {
9803 self.text
9804 }
9805}
9806impl ::treesitter_types::Spanned for IntegerLiteral<'_> {
9807 fn span(&self) -> ::treesitter_types::Span {
9808 self.span
9809 }
9810}
9811#[derive(Debug, Clone, PartialEq, Eq)]
9812pub struct Metavariable<'tree> {
9813 pub span: ::treesitter_types::Span,
9814 text: &'tree str,
9815}
9816impl<'tree> ::treesitter_types::FromNode<'tree> for Metavariable<'tree> {
9817 fn from_node(
9818 node: ::tree_sitter::Node<'tree>,
9819 src: &'tree [u8],
9820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9821 debug_assert_eq!(node.kind(), "metavariable");
9822 Ok(Self {
9823 span: ::treesitter_types::Span::from(node),
9824 text: node.utf8_text(src)?,
9825 })
9826 }
9827}
9828impl<'tree> ::treesitter_types::LeafNode<'tree> for Metavariable<'tree> {
9829 fn text(&self) -> &'tree str {
9830 self.text
9831 }
9832}
9833impl ::treesitter_types::Spanned for Metavariable<'_> {
9834 fn span(&self) -> ::treesitter_types::Span {
9835 self.span
9836 }
9837}
9838#[derive(Debug, Clone, PartialEq, Eq)]
9839pub struct MutableSpecifier<'tree> {
9840 pub span: ::treesitter_types::Span,
9841 text: &'tree str,
9842}
9843impl<'tree> ::treesitter_types::FromNode<'tree> for MutableSpecifier<'tree> {
9844 fn from_node(
9845 node: ::tree_sitter::Node<'tree>,
9846 src: &'tree [u8],
9847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9848 debug_assert_eq!(node.kind(), "mutable_specifier");
9849 Ok(Self {
9850 span: ::treesitter_types::Span::from(node),
9851 text: node.utf8_text(src)?,
9852 })
9853 }
9854}
9855impl<'tree> ::treesitter_types::LeafNode<'tree> for MutableSpecifier<'tree> {
9856 fn text(&self) -> &'tree str {
9857 self.text
9858 }
9859}
9860impl ::treesitter_types::Spanned for MutableSpecifier<'_> {
9861 fn span(&self) -> ::treesitter_types::Span {
9862 self.span
9863 }
9864}
9865#[derive(Debug, Clone, PartialEq, Eq)]
9866pub struct PrimitiveType<'tree> {
9867 pub span: ::treesitter_types::Span,
9868 text: &'tree str,
9869}
9870impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
9871 fn from_node(
9872 node: ::tree_sitter::Node<'tree>,
9873 src: &'tree [u8],
9874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9875 debug_assert_eq!(node.kind(), "primitive_type");
9876 Ok(Self {
9877 span: ::treesitter_types::Span::from(node),
9878 text: node.utf8_text(src)?,
9879 })
9880 }
9881}
9882impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
9883 fn text(&self) -> &'tree str {
9884 self.text
9885 }
9886}
9887impl ::treesitter_types::Spanned for PrimitiveType<'_> {
9888 fn span(&self) -> ::treesitter_types::Span {
9889 self.span
9890 }
9891}
9892#[derive(Debug, Clone, PartialEq, Eq)]
9893pub struct SelfType<'tree> {
9894 pub span: ::treesitter_types::Span,
9895 text: &'tree str,
9896}
9897impl<'tree> ::treesitter_types::FromNode<'tree> for SelfType<'tree> {
9898 fn from_node(
9899 node: ::tree_sitter::Node<'tree>,
9900 src: &'tree [u8],
9901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9902 debug_assert_eq!(node.kind(), "self");
9903 Ok(Self {
9904 span: ::treesitter_types::Span::from(node),
9905 text: node.utf8_text(src)?,
9906 })
9907 }
9908}
9909impl<'tree> ::treesitter_types::LeafNode<'tree> for SelfType<'tree> {
9910 fn text(&self) -> &'tree str {
9911 self.text
9912 }
9913}
9914impl ::treesitter_types::Spanned for SelfType<'_> {
9915 fn span(&self) -> ::treesitter_types::Span {
9916 self.span
9917 }
9918}
9919#[derive(Debug, Clone, PartialEq, Eq)]
9920pub struct Shebang<'tree> {
9921 pub span: ::treesitter_types::Span,
9922 text: &'tree str,
9923}
9924impl<'tree> ::treesitter_types::FromNode<'tree> for Shebang<'tree> {
9925 fn from_node(
9926 node: ::tree_sitter::Node<'tree>,
9927 src: &'tree [u8],
9928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9929 debug_assert_eq!(node.kind(), "shebang");
9930 Ok(Self {
9931 span: ::treesitter_types::Span::from(node),
9932 text: node.utf8_text(src)?,
9933 })
9934 }
9935}
9936impl<'tree> ::treesitter_types::LeafNode<'tree> for Shebang<'tree> {
9937 fn text(&self) -> &'tree str {
9938 self.text
9939 }
9940}
9941impl ::treesitter_types::Spanned for Shebang<'_> {
9942 fn span(&self) -> ::treesitter_types::Span {
9943 self.span
9944 }
9945}
9946#[derive(Debug, Clone, PartialEq, Eq)]
9947pub struct ShorthandFieldIdentifier<'tree> {
9948 pub span: ::treesitter_types::Span,
9949 text: &'tree str,
9950}
9951impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldIdentifier<'tree> {
9952 fn from_node(
9953 node: ::tree_sitter::Node<'tree>,
9954 src: &'tree [u8],
9955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9956 debug_assert_eq!(node.kind(), "shorthand_field_identifier");
9957 Ok(Self {
9958 span: ::treesitter_types::Span::from(node),
9959 text: node.utf8_text(src)?,
9960 })
9961 }
9962}
9963impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandFieldIdentifier<'tree> {
9964 fn text(&self) -> &'tree str {
9965 self.text
9966 }
9967}
9968impl ::treesitter_types::Spanned for ShorthandFieldIdentifier<'_> {
9969 fn span(&self) -> ::treesitter_types::Span {
9970 self.span
9971 }
9972}
9973#[derive(Debug, Clone, PartialEq, Eq)]
9974pub struct StringContent<'tree> {
9975 pub span: ::treesitter_types::Span,
9976 text: &'tree str,
9977}
9978impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
9979 fn from_node(
9980 node: ::tree_sitter::Node<'tree>,
9981 src: &'tree [u8],
9982 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9983 debug_assert_eq!(node.kind(), "string_content");
9984 Ok(Self {
9985 span: ::treesitter_types::Span::from(node),
9986 text: node.utf8_text(src)?,
9987 })
9988 }
9989}
9990impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
9991 fn text(&self) -> &'tree str {
9992 self.text
9993 }
9994}
9995impl ::treesitter_types::Spanned for StringContent<'_> {
9996 fn span(&self) -> ::treesitter_types::Span {
9997 self.span
9998 }
9999}
10000#[derive(Debug, Clone, PartialEq, Eq)]
10001pub struct Super<'tree> {
10002 pub span: ::treesitter_types::Span,
10003 text: &'tree str,
10004}
10005impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
10006 fn from_node(
10007 node: ::tree_sitter::Node<'tree>,
10008 src: &'tree [u8],
10009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10010 debug_assert_eq!(node.kind(), "super");
10011 Ok(Self {
10012 span: ::treesitter_types::Span::from(node),
10013 text: node.utf8_text(src)?,
10014 })
10015 }
10016}
10017impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
10018 fn text(&self) -> &'tree str {
10019 self.text
10020 }
10021}
10022impl ::treesitter_types::Spanned for Super<'_> {
10023 fn span(&self) -> ::treesitter_types::Span {
10024 self.span
10025 }
10026}
10027#[derive(Debug, Clone, PartialEq, Eq)]
10028pub struct TypeIdentifier<'tree> {
10029 pub span: ::treesitter_types::Span,
10030 text: &'tree str,
10031}
10032impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
10033 fn from_node(
10034 node: ::tree_sitter::Node<'tree>,
10035 src: &'tree [u8],
10036 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10037 debug_assert_eq!(node.kind(), "type_identifier");
10038 Ok(Self {
10039 span: ::treesitter_types::Span::from(node),
10040 text: node.utf8_text(src)?,
10041 })
10042 }
10043}
10044impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
10045 fn text(&self) -> &'tree str {
10046 self.text
10047 }
10048}
10049impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
10050 fn span(&self) -> ::treesitter_types::Span {
10051 self.span
10052 }
10053}
10054#[derive(Debug, Clone, PartialEq, Eq)]
10055pub enum AbstractTypeTrait<'tree> {
10056 BoundedType(::std::boxed::Box<BoundedType<'tree>>),
10057 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
10058 GenericType(::std::boxed::Box<GenericType<'tree>>),
10059 RemovedTraitBound(::std::boxed::Box<RemovedTraitBound<'tree>>),
10060 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10061 TupleType(::std::boxed::Box<TupleType<'tree>>),
10062 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10063}
10064impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractTypeTrait<'tree> {
10065 #[allow(clippy::collapsible_else_if)]
10066 fn from_node(
10067 node: ::tree_sitter::Node<'tree>,
10068 src: &'tree [u8],
10069 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10070 match node.kind() {
10071 "bounded_type" => Ok(Self::BoundedType(::std::boxed::Box::new(
10072 <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)?,
10073 ))),
10074 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
10075 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
10076 ))),
10077 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10078 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10079 ))),
10080 "removed_trait_bound" => Ok(Self::RemovedTraitBound(::std::boxed::Box::new(
10081 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
10082 ))),
10083 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10084 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10085 ))),
10086 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
10087 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
10088 ))),
10089 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10090 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10091 ))),
10092 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10093 }
10094 }
10095}
10096impl ::treesitter_types::Spanned for AbstractTypeTrait<'_> {
10097 fn span(&self) -> ::treesitter_types::Span {
10098 match self {
10099 Self::BoundedType(inner) => inner.span(),
10100 Self::FunctionType(inner) => inner.span(),
10101 Self::GenericType(inner) => inner.span(),
10102 Self::RemovedTraitBound(inner) => inner.span(),
10103 Self::ScopedTypeIdentifier(inner) => inner.span(),
10104 Self::TupleType(inner) => inner.span(),
10105 Self::TypeIdentifier(inner) => inner.span(),
10106 }
10107 }
10108}
10109#[derive(Debug, Clone, PartialEq, Eq)]
10110pub enum ArgumentsChildren<'tree> {
10111 Expression(::std::boxed::Box<Expression<'tree>>),
10112 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10113}
10114impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
10115 #[allow(clippy::collapsible_else_if)]
10116 fn from_node(
10117 node: ::tree_sitter::Node<'tree>,
10118 src: &'tree [u8],
10119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10120 match node.kind() {
10121 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10122 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10123 ))),
10124 _other => {
10125 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10126 Ok(Self::Expression(::std::boxed::Box::new(v)))
10127 } else {
10128 Err(::treesitter_types::ParseError::unexpected_kind(
10129 _other, node,
10130 ))
10131 }
10132 }
10133 }
10134 }
10135}
10136impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
10137 fn span(&self) -> ::treesitter_types::Span {
10138 match self {
10139 Self::Expression(inner) => inner.span(),
10140 Self::AttributeItem(inner) => inner.span(),
10141 }
10142 }
10143}
10144#[derive(Debug, Clone, PartialEq, Eq)]
10145pub enum ArrayExpressionChildren<'tree> {
10146 Expression(::std::boxed::Box<Expression<'tree>>),
10147 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10148}
10149impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayExpressionChildren<'tree> {
10150 #[allow(clippy::collapsible_else_if)]
10151 fn from_node(
10152 node: ::tree_sitter::Node<'tree>,
10153 src: &'tree [u8],
10154 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10155 match node.kind() {
10156 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
10157 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
10158 ))),
10159 _other => {
10160 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10161 Ok(Self::Expression(::std::boxed::Box::new(v)))
10162 } else {
10163 Err(::treesitter_types::ParseError::unexpected_kind(
10164 _other, node,
10165 ))
10166 }
10167 }
10168 }
10169 }
10170}
10171impl ::treesitter_types::Spanned for ArrayExpressionChildren<'_> {
10172 fn span(&self) -> ::treesitter_types::Span {
10173 match self {
10174 Self::Expression(inner) => inner.span(),
10175 Self::AttributeItem(inner) => inner.span(),
10176 }
10177 }
10178}
10179#[derive(Debug, Clone, PartialEq, Eq)]
10180pub enum AttributeChildren<'tree> {
10181 Crate(::std::boxed::Box<Crate<'tree>>),
10182 Identifier(::std::boxed::Box<Identifier<'tree>>),
10183 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10184 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10185 SelfType(::std::boxed::Box<SelfType<'tree>>),
10186 Super(::std::boxed::Box<Super<'tree>>),
10187}
10188impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeChildren<'tree> {
10189 #[allow(clippy::collapsible_else_if)]
10190 fn from_node(
10191 node: ::tree_sitter::Node<'tree>,
10192 src: &'tree [u8],
10193 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10194 match node.kind() {
10195 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
10196 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
10197 ))),
10198 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10199 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10200 ))),
10201 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10202 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10203 ))),
10204 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10205 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10206 ))),
10207 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10208 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10209 ))),
10210 "super" => Ok(Self::Super(::std::boxed::Box::new(
10211 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
10212 ))),
10213 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10214 }
10215 }
10216}
10217impl ::treesitter_types::Spanned for AttributeChildren<'_> {
10218 fn span(&self) -> ::treesitter_types::Span {
10219 match self {
10220 Self::Crate(inner) => inner.span(),
10221 Self::Identifier(inner) => inner.span(),
10222 Self::Metavariable(inner) => inner.span(),
10223 Self::ScopedIdentifier(inner) => inner.span(),
10224 Self::SelfType(inner) => inner.span(),
10225 Self::Super(inner) => inner.span(),
10226 }
10227 }
10228}
10229#[derive(Debug, Clone, PartialEq, Eq)]
10230pub enum BinaryExpressionOperator {
10231 NotEq(::treesitter_types::Span),
10232 Percent(::treesitter_types::Span),
10233 Amp(::treesitter_types::Span),
10234 AmpAmp(::treesitter_types::Span),
10235 Star(::treesitter_types::Span),
10236 Plus(::treesitter_types::Span),
10237 Minus(::treesitter_types::Span),
10238 Slash(::treesitter_types::Span),
10239 Lt(::treesitter_types::Span),
10240 Shl(::treesitter_types::Span),
10241 LtEq(::treesitter_types::Span),
10242 EqEq(::treesitter_types::Span),
10243 Gt(::treesitter_types::Span),
10244 GtEq(::treesitter_types::Span),
10245 Shr(::treesitter_types::Span),
10246 Caret(::treesitter_types::Span),
10247 Pipe(::treesitter_types::Span),
10248 PipePipe(::treesitter_types::Span),
10249}
10250impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
10251 #[allow(clippy::collapsible_else_if)]
10252 fn from_node(
10253 node: ::tree_sitter::Node<'tree>,
10254 _src: &'tree [u8],
10255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10256 match node.kind() {
10257 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
10258 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
10259 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
10260 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
10261 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
10262 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10263 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10264 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
10265 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
10266 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
10267 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
10268 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
10269 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
10270 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
10271 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
10272 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
10273 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
10274 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
10275 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10276 }
10277 }
10278}
10279impl ::treesitter_types::Spanned for BinaryExpressionOperator {
10280 fn span(&self) -> ::treesitter_types::Span {
10281 match self {
10282 Self::NotEq(span) => *span,
10283 Self::Percent(span) => *span,
10284 Self::Amp(span) => *span,
10285 Self::AmpAmp(span) => *span,
10286 Self::Star(span) => *span,
10287 Self::Plus(span) => *span,
10288 Self::Minus(span) => *span,
10289 Self::Slash(span) => *span,
10290 Self::Lt(span) => *span,
10291 Self::Shl(span) => *span,
10292 Self::LtEq(span) => *span,
10293 Self::EqEq(span) => *span,
10294 Self::Gt(span) => *span,
10295 Self::GtEq(span) => *span,
10296 Self::Shr(span) => *span,
10297 Self::Caret(span) => *span,
10298 Self::Pipe(span) => *span,
10299 Self::PipePipe(span) => *span,
10300 }
10301 }
10302}
10303#[derive(Debug, Clone, PartialEq, Eq)]
10304pub enum BlockChildren<'tree> {
10305 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
10306 Expression(::std::boxed::Box<Expression<'tree>>),
10307 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
10308 Label(::std::boxed::Box<Label<'tree>>),
10309}
10310impl<'tree> ::treesitter_types::FromNode<'tree> for BlockChildren<'tree> {
10311 #[allow(clippy::collapsible_else_if)]
10312 fn from_node(
10313 node: ::tree_sitter::Node<'tree>,
10314 src: &'tree [u8],
10315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10316 match node.kind() {
10317 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
10318 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
10319 ))),
10320 "label" => Ok(Self::Label(::std::boxed::Box::new(
10321 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
10322 ))),
10323 _other => {
10324 if let Ok(v) =
10325 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
10326 {
10327 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
10328 } else {
10329 if let Ok(v) =
10330 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10331 {
10332 Ok(Self::Expression(::std::boxed::Box::new(v)))
10333 } else {
10334 Err(::treesitter_types::ParseError::unexpected_kind(
10335 _other, node,
10336 ))
10337 }
10338 }
10339 }
10340 }
10341 }
10342}
10343impl ::treesitter_types::Spanned for BlockChildren<'_> {
10344 fn span(&self) -> ::treesitter_types::Span {
10345 match self {
10346 Self::DeclarationStatement(inner) => inner.span(),
10347 Self::Expression(inner) => inner.span(),
10348 Self::ExpressionStatement(inner) => inner.span(),
10349 Self::Label(inner) => inner.span(),
10350 }
10351 }
10352}
10353#[derive(Debug, Clone, PartialEq, Eq)]
10354pub enum BoundedTypeChildren<'tree> {
10355 Type(::std::boxed::Box<Type<'tree>>),
10356 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
10357 UseBounds(::std::boxed::Box<UseBounds<'tree>>),
10358}
10359impl<'tree> ::treesitter_types::FromNode<'tree> for BoundedTypeChildren<'tree> {
10360 #[allow(clippy::collapsible_else_if)]
10361 fn from_node(
10362 node: ::tree_sitter::Node<'tree>,
10363 src: &'tree [u8],
10364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10365 match node.kind() {
10366 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
10367 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
10368 ))),
10369 "use_bounds" => Ok(Self::UseBounds(::std::boxed::Box::new(
10370 <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)?,
10371 ))),
10372 _other => {
10373 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10374 Ok(Self::Type(::std::boxed::Box::new(v)))
10375 } else {
10376 Err(::treesitter_types::ParseError::unexpected_kind(
10377 _other, node,
10378 ))
10379 }
10380 }
10381 }
10382 }
10383}
10384impl ::treesitter_types::Spanned for BoundedTypeChildren<'_> {
10385 fn span(&self) -> ::treesitter_types::Span {
10386 match self {
10387 Self::Type(inner) => inner.span(),
10388 Self::Lifetime(inner) => inner.span(),
10389 Self::UseBounds(inner) => inner.span(),
10390 }
10391 }
10392}
10393#[derive(Debug, Clone, PartialEq, Eq)]
10394pub enum BracketedTypeChildren<'tree> {
10395 Type(::std::boxed::Box<Type<'tree>>),
10396 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
10397}
10398impl<'tree> ::treesitter_types::FromNode<'tree> for BracketedTypeChildren<'tree> {
10399 #[allow(clippy::collapsible_else_if)]
10400 fn from_node(
10401 node: ::tree_sitter::Node<'tree>,
10402 src: &'tree [u8],
10403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10404 match node.kind() {
10405 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
10406 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)?,
10407 ))),
10408 _other => {
10409 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10410 Ok(Self::Type(::std::boxed::Box::new(v)))
10411 } else {
10412 Err(::treesitter_types::ParseError::unexpected_kind(
10413 _other, node,
10414 ))
10415 }
10416 }
10417 }
10418 }
10419}
10420impl ::treesitter_types::Spanned for BracketedTypeChildren<'_> {
10421 fn span(&self) -> ::treesitter_types::Span {
10422 match self {
10423 Self::Type(inner) => inner.span(),
10424 Self::QualifiedType(inner) => inner.span(),
10425 }
10426 }
10427}
10428#[derive(Debug, Clone, PartialEq, Eq)]
10429pub enum BreakExpressionChildren<'tree> {
10430 Expression(::std::boxed::Box<Expression<'tree>>),
10431 Label(::std::boxed::Box<Label<'tree>>),
10432}
10433impl<'tree> ::treesitter_types::FromNode<'tree> for BreakExpressionChildren<'tree> {
10434 #[allow(clippy::collapsible_else_if)]
10435 fn from_node(
10436 node: ::tree_sitter::Node<'tree>,
10437 src: &'tree [u8],
10438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10439 match node.kind() {
10440 "label" => Ok(Self::Label(::std::boxed::Box::new(
10441 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
10442 ))),
10443 _other => {
10444 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10445 Ok(Self::Expression(::std::boxed::Box::new(v)))
10446 } else {
10447 Err(::treesitter_types::ParseError::unexpected_kind(
10448 _other, node,
10449 ))
10450 }
10451 }
10452 }
10453 }
10454}
10455impl ::treesitter_types::Spanned for BreakExpressionChildren<'_> {
10456 fn span(&self) -> ::treesitter_types::Span {
10457 match self {
10458 Self::Expression(inner) => inner.span(),
10459 Self::Label(inner) => inner.span(),
10460 }
10461 }
10462}
10463#[derive(Debug, Clone, PartialEq, Eq)]
10464pub enum CallExpressionFunction<'tree> {
10465 Literal(::std::boxed::Box<Literal<'tree>>),
10466 ArrayExpression(::std::boxed::Box<ArrayExpression<'tree>>),
10467 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
10468 AsyncBlock(::std::boxed::Box<AsyncBlock<'tree>>),
10469 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
10470 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
10471 Block(::std::boxed::Box<Block<'tree>>),
10472 BreakExpression(::std::boxed::Box<BreakExpression<'tree>>),
10473 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
10474 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
10475 CompoundAssignmentExpr(::std::boxed::Box<CompoundAssignmentExpr<'tree>>),
10476 ConstBlock(::std::boxed::Box<ConstBlock<'tree>>),
10477 ContinueExpression(::std::boxed::Box<ContinueExpression<'tree>>),
10478 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
10479 ForExpression(::std::boxed::Box<ForExpression<'tree>>),
10480 GenBlock(::std::boxed::Box<GenBlock<'tree>>),
10481 GenericFunction(::std::boxed::Box<GenericFunction<'tree>>),
10482 Identifier(::std::boxed::Box<Identifier<'tree>>),
10483 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
10484 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
10485 LoopExpression(::std::boxed::Box<LoopExpression<'tree>>),
10486 MacroInvocation(::std::boxed::Box<MacroInvocation<'tree>>),
10487 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
10488 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
10489 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10490 ReferenceExpression(::std::boxed::Box<ReferenceExpression<'tree>>),
10491 ReturnExpression(::std::boxed::Box<ReturnExpression<'tree>>),
10492 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
10493 SelfType(::std::boxed::Box<SelfType<'tree>>),
10494 StructExpression(::std::boxed::Box<StructExpression<'tree>>),
10495 TryBlock(::std::boxed::Box<TryBlock<'tree>>),
10496 TryExpression(::std::boxed::Box<TryExpression<'tree>>),
10497 TupleExpression(::std::boxed::Box<TupleExpression<'tree>>),
10498 TypeCastExpression(::std::boxed::Box<TypeCastExpression<'tree>>),
10499 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
10500 UnitExpression(::std::boxed::Box<UnitExpression<'tree>>),
10501 UnsafeBlock(::std::boxed::Box<UnsafeBlock<'tree>>),
10502 WhileExpression(::std::boxed::Box<WhileExpression<'tree>>),
10503 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
10504}
10505impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
10506 #[allow(clippy::collapsible_else_if)]
10507 fn from_node(
10508 node: ::tree_sitter::Node<'tree>,
10509 src: &'tree [u8],
10510 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10511 match node.kind() {
10512 "array_expression" => Ok(Self::ArrayExpression(::std::boxed::Box::new(
10513 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10514 ))),
10515 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
10516 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10517 ))),
10518 "async_block" => Ok(Self::AsyncBlock(::std::boxed::Box::new(
10519 <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10520 ))),
10521 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
10522 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10523 ))),
10524 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
10525 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10526 ))),
10527 "block" => Ok(Self::Block(::std::boxed::Box::new(
10528 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
10529 ))),
10530 "break_expression" => Ok(Self::BreakExpression(::std::boxed::Box::new(
10531 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10532 ))),
10533 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
10534 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10535 ))),
10536 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
10537 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10538 ))),
10539 "compound_assignment_expr" => Ok(Self::CompoundAssignmentExpr(::std::boxed::Box::new(
10540 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)?,
10541 ))),
10542 "const_block" => Ok(Self::ConstBlock(::std::boxed::Box::new(
10543 <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10544 ))),
10545 "continue_expression" => Ok(Self::ContinueExpression(::std::boxed::Box::new(
10546 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10547 ))),
10548 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
10549 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10550 ))),
10551 "for_expression" => Ok(Self::ForExpression(::std::boxed::Box::new(
10552 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10553 ))),
10554 "gen_block" => Ok(Self::GenBlock(::std::boxed::Box::new(
10555 <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10556 ))),
10557 "generic_function" => Ok(Self::GenericFunction(::std::boxed::Box::new(
10558 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
10559 ))),
10560 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10561 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10562 ))),
10563 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
10564 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10565 ))),
10566 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
10567 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10568 ))),
10569 "loop_expression" => Ok(Self::LoopExpression(::std::boxed::Box::new(
10570 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10571 ))),
10572 "macro_invocation" => Ok(Self::MacroInvocation(::std::boxed::Box::new(
10573 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)?,
10574 ))),
10575 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
10576 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10577 ))),
10578 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
10579 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
10580 ))),
10581 "parenthesized_expression" => {
10582 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
10583 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
10584 node, src,
10585 )?,
10586 )))
10587 }
10588 "reference_expression" => Ok(Self::ReferenceExpression(::std::boxed::Box::new(
10589 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10590 ))),
10591 "return_expression" => Ok(Self::ReturnExpression(::std::boxed::Box::new(
10592 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10593 ))),
10594 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
10595 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10596 ))),
10597 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
10598 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
10599 ))),
10600 "struct_expression" => Ok(Self::StructExpression(::std::boxed::Box::new(
10601 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10602 ))),
10603 "try_block" => Ok(Self::TryBlock(::std::boxed::Box::new(
10604 <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10605 ))),
10606 "try_expression" => Ok(Self::TryExpression(::std::boxed::Box::new(
10607 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10608 ))),
10609 "tuple_expression" => Ok(Self::TupleExpression(::std::boxed::Box::new(
10610 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10611 ))),
10612 "type_cast_expression" => Ok(Self::TypeCastExpression(::std::boxed::Box::new(
10613 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10614 ))),
10615 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
10616 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10617 ))),
10618 "unit_expression" => Ok(Self::UnitExpression(::std::boxed::Box::new(
10619 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10620 ))),
10621 "unsafe_block" => Ok(Self::UnsafeBlock(::std::boxed::Box::new(
10622 <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10623 ))),
10624 "while_expression" => Ok(Self::WhileExpression(::std::boxed::Box::new(
10625 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10626 ))),
10627 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
10628 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10629 ))),
10630 _other => {
10631 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
10632 Ok(Self::Literal(::std::boxed::Box::new(v)))
10633 } else {
10634 Err(::treesitter_types::ParseError::unexpected_kind(
10635 _other, node,
10636 ))
10637 }
10638 }
10639 }
10640 }
10641}
10642impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
10643 fn span(&self) -> ::treesitter_types::Span {
10644 match self {
10645 Self::Literal(inner) => inner.span(),
10646 Self::ArrayExpression(inner) => inner.span(),
10647 Self::AssignmentExpression(inner) => inner.span(),
10648 Self::AsyncBlock(inner) => inner.span(),
10649 Self::AwaitExpression(inner) => inner.span(),
10650 Self::BinaryExpression(inner) => inner.span(),
10651 Self::Block(inner) => inner.span(),
10652 Self::BreakExpression(inner) => inner.span(),
10653 Self::CallExpression(inner) => inner.span(),
10654 Self::ClosureExpression(inner) => inner.span(),
10655 Self::CompoundAssignmentExpr(inner) => inner.span(),
10656 Self::ConstBlock(inner) => inner.span(),
10657 Self::ContinueExpression(inner) => inner.span(),
10658 Self::FieldExpression(inner) => inner.span(),
10659 Self::ForExpression(inner) => inner.span(),
10660 Self::GenBlock(inner) => inner.span(),
10661 Self::GenericFunction(inner) => inner.span(),
10662 Self::Identifier(inner) => inner.span(),
10663 Self::IfExpression(inner) => inner.span(),
10664 Self::IndexExpression(inner) => inner.span(),
10665 Self::LoopExpression(inner) => inner.span(),
10666 Self::MacroInvocation(inner) => inner.span(),
10667 Self::MatchExpression(inner) => inner.span(),
10668 Self::Metavariable(inner) => inner.span(),
10669 Self::ParenthesizedExpression(inner) => inner.span(),
10670 Self::ReferenceExpression(inner) => inner.span(),
10671 Self::ReturnExpression(inner) => inner.span(),
10672 Self::ScopedIdentifier(inner) => inner.span(),
10673 Self::SelfType(inner) => inner.span(),
10674 Self::StructExpression(inner) => inner.span(),
10675 Self::TryBlock(inner) => inner.span(),
10676 Self::TryExpression(inner) => inner.span(),
10677 Self::TupleExpression(inner) => inner.span(),
10678 Self::TypeCastExpression(inner) => inner.span(),
10679 Self::UnaryExpression(inner) => inner.span(),
10680 Self::UnitExpression(inner) => inner.span(),
10681 Self::UnsafeBlock(inner) => inner.span(),
10682 Self::WhileExpression(inner) => inner.span(),
10683 Self::YieldExpression(inner) => inner.span(),
10684 }
10685 }
10686}
10687#[derive(Debug, Clone, PartialEq, Eq)]
10688pub enum ClosureExpressionBody<'tree> {
10689 Blank(::treesitter_types::Span),
10690 Expression(::std::boxed::Box<Expression<'tree>>),
10691}
10692impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureExpressionBody<'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 "_" => Ok(Self::Blank(::treesitter_types::Span::from(node))),
10700 _other => {
10701 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10702 Ok(Self::Expression(::std::boxed::Box::new(v)))
10703 } else {
10704 Err(::treesitter_types::ParseError::unexpected_kind(
10705 _other, node,
10706 ))
10707 }
10708 }
10709 }
10710 }
10711}
10712impl ::treesitter_types::Spanned for ClosureExpressionBody<'_> {
10713 fn span(&self) -> ::treesitter_types::Span {
10714 match self {
10715 Self::Blank(span) => *span,
10716 Self::Expression(inner) => inner.span(),
10717 }
10718 }
10719}
10720#[derive(Debug, Clone, PartialEq, Eq)]
10721pub enum ClosureParametersChildren<'tree> {
10722 Pattern(::std::boxed::Box<Pattern<'tree>>),
10723 Parameter(::std::boxed::Box<Parameter<'tree>>),
10724}
10725impl<'tree> ::treesitter_types::FromNode<'tree> for ClosureParametersChildren<'tree> {
10726 #[allow(clippy::collapsible_else_if)]
10727 fn from_node(
10728 node: ::tree_sitter::Node<'tree>,
10729 src: &'tree [u8],
10730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10731 match node.kind() {
10732 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
10733 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10734 ))),
10735 _other => {
10736 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10737 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10738 } else {
10739 Err(::treesitter_types::ParseError::unexpected_kind(
10740 _other, node,
10741 ))
10742 }
10743 }
10744 }
10745 }
10746}
10747impl ::treesitter_types::Spanned for ClosureParametersChildren<'_> {
10748 fn span(&self) -> ::treesitter_types::Span {
10749 match self {
10750 Self::Pattern(inner) => inner.span(),
10751 Self::Parameter(inner) => inner.span(),
10752 }
10753 }
10754}
10755#[derive(Debug, Clone, PartialEq, Eq)]
10756pub enum CompoundAssignmentExprOperator {
10757 PercentEq(::treesitter_types::Span),
10758 AmpEq(::treesitter_types::Span),
10759 StarEq(::treesitter_types::Span),
10760 PlusEq(::treesitter_types::Span),
10761 MinusEq(::treesitter_types::Span),
10762 SlashEq(::treesitter_types::Span),
10763 ShlEq(::treesitter_types::Span),
10764 ShrEq(::treesitter_types::Span),
10765 CaretEq(::treesitter_types::Span),
10766 PipeEq(::treesitter_types::Span),
10767}
10768impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundAssignmentExprOperator {
10769 #[allow(clippy::collapsible_else_if)]
10770 fn from_node(
10771 node: ::tree_sitter::Node<'tree>,
10772 _src: &'tree [u8],
10773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10774 match node.kind() {
10775 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
10776 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
10777 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
10778 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
10779 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
10780 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
10781 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
10782 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
10783 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
10784 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
10785 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10786 }
10787 }
10788}
10789impl ::treesitter_types::Spanned for CompoundAssignmentExprOperator {
10790 fn span(&self) -> ::treesitter_types::Span {
10791 match self {
10792 Self::PercentEq(span) => *span,
10793 Self::AmpEq(span) => *span,
10794 Self::StarEq(span) => *span,
10795 Self::PlusEq(span) => *span,
10796 Self::MinusEq(span) => *span,
10797 Self::SlashEq(span) => *span,
10798 Self::ShlEq(span) => *span,
10799 Self::ShrEq(span) => *span,
10800 Self::CaretEq(span) => *span,
10801 Self::PipeEq(span) => *span,
10802 }
10803 }
10804}
10805#[derive(Debug, Clone, PartialEq, Eq)]
10806pub enum ConstParameterValue<'tree> {
10807 Literal(::std::boxed::Box<Literal<'tree>>),
10808 Block(::std::boxed::Box<Block<'tree>>),
10809 Identifier(::std::boxed::Box<Identifier<'tree>>),
10810 NegativeLiteral(::std::boxed::Box<NegativeLiteral<'tree>>),
10811}
10812impl<'tree> ::treesitter_types::FromNode<'tree> for ConstParameterValue<'tree> {
10813 #[allow(clippy::collapsible_else_if)]
10814 fn from_node(
10815 node: ::tree_sitter::Node<'tree>,
10816 src: &'tree [u8],
10817 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10818 match node.kind() {
10819 "block" => Ok(Self::Block(::std::boxed::Box::new(
10820 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
10821 ))),
10822 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10823 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10824 ))),
10825 "negative_literal" => Ok(Self::NegativeLiteral(::std::boxed::Box::new(
10826 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
10827 ))),
10828 _other => {
10829 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
10830 Ok(Self::Literal(::std::boxed::Box::new(v)))
10831 } else {
10832 Err(::treesitter_types::ParseError::unexpected_kind(
10833 _other, node,
10834 ))
10835 }
10836 }
10837 }
10838 }
10839}
10840impl ::treesitter_types::Spanned for ConstParameterValue<'_> {
10841 fn span(&self) -> ::treesitter_types::Span {
10842 match self {
10843 Self::Literal(inner) => inner.span(),
10844 Self::Block(inner) => inner.span(),
10845 Self::Identifier(inner) => inner.span(),
10846 Self::NegativeLiteral(inner) => inner.span(),
10847 }
10848 }
10849}
10850#[derive(Debug, Clone, PartialEq, Eq)]
10851pub enum DynamicTypeTrait<'tree> {
10852 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
10853 GenericType(::std::boxed::Box<GenericType<'tree>>),
10854 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
10855 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
10856 TupleType(::std::boxed::Box<TupleType<'tree>>),
10857 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10858}
10859impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicTypeTrait<'tree> {
10860 #[allow(clippy::collapsible_else_if)]
10861 fn from_node(
10862 node: ::tree_sitter::Node<'tree>,
10863 src: &'tree [u8],
10864 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10865 match node.kind() {
10866 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
10867 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
10868 ))),
10869 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10870 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10871 ))),
10872 "higher_ranked_trait_bound" => {
10873 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
10874 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
10875 )))
10876 }
10877 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
10878 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10879 ))),
10880 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
10881 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
10882 ))),
10883 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10884 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10885 ))),
10886 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10887 }
10888 }
10889}
10890impl ::treesitter_types::Spanned for DynamicTypeTrait<'_> {
10891 fn span(&self) -> ::treesitter_types::Span {
10892 match self {
10893 Self::FunctionType(inner) => inner.span(),
10894 Self::GenericType(inner) => inner.span(),
10895 Self::HigherRankedTraitBound(inner) => inner.span(),
10896 Self::ScopedTypeIdentifier(inner) => inner.span(),
10897 Self::TupleType(inner) => inner.span(),
10898 Self::TypeIdentifier(inner) => inner.span(),
10899 }
10900 }
10901}
10902#[derive(Debug, Clone, PartialEq, Eq)]
10903pub enum ElseClauseChildren<'tree> {
10904 Block(::std::boxed::Box<Block<'tree>>),
10905 IfExpression(::std::boxed::Box<IfExpression<'tree>>),
10906}
10907impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClauseChildren<'tree> {
10908 #[allow(clippy::collapsible_else_if)]
10909 fn from_node(
10910 node: ::tree_sitter::Node<'tree>,
10911 src: &'tree [u8],
10912 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10913 match node.kind() {
10914 "block" => Ok(Self::Block(::std::boxed::Box::new(
10915 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
10916 ))),
10917 "if_expression" => Ok(Self::IfExpression(::std::boxed::Box::new(
10918 <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10919 ))),
10920 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10921 }
10922 }
10923}
10924impl ::treesitter_types::Spanned for ElseClauseChildren<'_> {
10925 fn span(&self) -> ::treesitter_types::Span {
10926 match self {
10927 Self::Block(inner) => inner.span(),
10928 Self::IfExpression(inner) => inner.span(),
10929 }
10930 }
10931}
10932#[derive(Debug, Clone, PartialEq, Eq)]
10933pub enum EnumItemChildren<'tree> {
10934 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10935 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
10936}
10937impl<'tree> ::treesitter_types::FromNode<'tree> for EnumItemChildren<'tree> {
10938 #[allow(clippy::collapsible_else_if)]
10939 fn from_node(
10940 node: ::tree_sitter::Node<'tree>,
10941 src: &'tree [u8],
10942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10943 match node.kind() {
10944 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10945 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10946 ))),
10947 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
10948 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10949 ))),
10950 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10951 }
10952 }
10953}
10954impl ::treesitter_types::Spanned for EnumItemChildren<'_> {
10955 fn span(&self) -> ::treesitter_types::Span {
10956 match self {
10957 Self::VisibilityModifier(inner) => inner.span(),
10958 Self::WhereClause(inner) => inner.span(),
10959 }
10960 }
10961}
10962#[derive(Debug, Clone, PartialEq, Eq)]
10963pub enum EnumVariantBody<'tree> {
10964 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
10965 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
10966}
10967impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantBody<'tree> {
10968 #[allow(clippy::collapsible_else_if)]
10969 fn from_node(
10970 node: ::tree_sitter::Node<'tree>,
10971 src: &'tree [u8],
10972 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10973 match node.kind() {
10974 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
10975 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)?,
10976 ))),
10977 "ordered_field_declaration_list" => {
10978 Ok(Self::OrderedFieldDeclarationList(::std::boxed::Box::new(
10979 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
10980 node, src,
10981 )?,
10982 )))
10983 }
10984 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10985 }
10986 }
10987}
10988impl ::treesitter_types::Spanned for EnumVariantBody<'_> {
10989 fn span(&self) -> ::treesitter_types::Span {
10990 match self {
10991 Self::FieldDeclarationList(inner) => inner.span(),
10992 Self::OrderedFieldDeclarationList(inner) => inner.span(),
10993 }
10994 }
10995}
10996#[derive(Debug, Clone, PartialEq, Eq)]
10997pub enum EnumVariantListChildren<'tree> {
10998 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
10999 EnumVariant(::std::boxed::Box<EnumVariant<'tree>>),
11000}
11001impl<'tree> ::treesitter_types::FromNode<'tree> for EnumVariantListChildren<'tree> {
11002 #[allow(clippy::collapsible_else_if)]
11003 fn from_node(
11004 node: ::tree_sitter::Node<'tree>,
11005 src: &'tree [u8],
11006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11007 match node.kind() {
11008 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11009 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11010 ))),
11011 "enum_variant" => Ok(Self::EnumVariant(::std::boxed::Box::new(
11012 <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)?,
11013 ))),
11014 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11015 }
11016 }
11017}
11018impl ::treesitter_types::Spanned for EnumVariantListChildren<'_> {
11019 fn span(&self) -> ::treesitter_types::Span {
11020 match self {
11021 Self::AttributeItem(inner) => inner.span(),
11022 Self::EnumVariant(inner) => inner.span(),
11023 }
11024 }
11025}
11026#[derive(Debug, Clone, PartialEq, Eq)]
11027pub enum ExternCrateDeclarationChildren<'tree> {
11028 Crate(::std::boxed::Box<Crate<'tree>>),
11029 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11030}
11031impl<'tree> ::treesitter_types::FromNode<'tree> for ExternCrateDeclarationChildren<'tree> {
11032 #[allow(clippy::collapsible_else_if)]
11033 fn from_node(
11034 node: ::tree_sitter::Node<'tree>,
11035 src: &'tree [u8],
11036 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11037 match node.kind() {
11038 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11039 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11040 ))),
11041 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11042 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11043 ))),
11044 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11045 }
11046 }
11047}
11048impl ::treesitter_types::Spanned for ExternCrateDeclarationChildren<'_> {
11049 fn span(&self) -> ::treesitter_types::Span {
11050 match self {
11051 Self::Crate(inner) => inner.span(),
11052 Self::VisibilityModifier(inner) => inner.span(),
11053 }
11054 }
11055}
11056#[derive(Debug, Clone, PartialEq, Eq)]
11057pub enum FieldDeclarationListChildren<'tree> {
11058 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11059 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
11060}
11061impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
11062 #[allow(clippy::collapsible_else_if)]
11063 fn from_node(
11064 node: ::tree_sitter::Node<'tree>,
11065 src: &'tree [u8],
11066 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11067 match node.kind() {
11068 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11069 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11070 ))),
11071 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
11072 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
11073 ))),
11074 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11075 }
11076 }
11077}
11078impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
11079 fn span(&self) -> ::treesitter_types::Span {
11080 match self {
11081 Self::AttributeItem(inner) => inner.span(),
11082 Self::FieldDeclaration(inner) => inner.span(),
11083 }
11084 }
11085}
11086#[derive(Debug, Clone, PartialEq, Eq)]
11087pub enum FieldExpressionField<'tree> {
11088 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11089 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
11090}
11091impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionField<'tree> {
11092 #[allow(clippy::collapsible_else_if)]
11093 fn from_node(
11094 node: ::tree_sitter::Node<'tree>,
11095 src: &'tree [u8],
11096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11097 match node.kind() {
11098 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11099 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11100 ))),
11101 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
11102 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11103 ))),
11104 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11105 }
11106 }
11107}
11108impl ::treesitter_types::Spanned for FieldExpressionField<'_> {
11109 fn span(&self) -> ::treesitter_types::Span {
11110 match self {
11111 Self::FieldIdentifier(inner) => inner.span(),
11112 Self::IntegerLiteral(inner) => inner.span(),
11113 }
11114 }
11115}
11116#[derive(Debug, Clone, PartialEq, Eq)]
11117pub enum FieldInitializerField<'tree> {
11118 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11119 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
11120}
11121impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerField<'tree> {
11122 #[allow(clippy::collapsible_else_if)]
11123 fn from_node(
11124 node: ::tree_sitter::Node<'tree>,
11125 src: &'tree [u8],
11126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11127 match node.kind() {
11128 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11129 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11130 ))),
11131 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
11132 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11133 ))),
11134 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11135 }
11136 }
11137}
11138impl ::treesitter_types::Spanned for FieldInitializerField<'_> {
11139 fn span(&self) -> ::treesitter_types::Span {
11140 match self {
11141 Self::FieldIdentifier(inner) => inner.span(),
11142 Self::IntegerLiteral(inner) => inner.span(),
11143 }
11144 }
11145}
11146#[derive(Debug, Clone, PartialEq, Eq)]
11147pub enum FieldInitializerListChildren<'tree> {
11148 BaseFieldInitializer(::std::boxed::Box<BaseFieldInitializer<'tree>>),
11149 FieldInitializer(::std::boxed::Box<FieldInitializer<'tree>>),
11150 ShorthandFieldInitializer(::std::boxed::Box<ShorthandFieldInitializer<'tree>>),
11151}
11152impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerListChildren<'tree> {
11153 #[allow(clippy::collapsible_else_if)]
11154 fn from_node(
11155 node: ::tree_sitter::Node<'tree>,
11156 src: &'tree [u8],
11157 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11158 match node.kind() {
11159 "base_field_initializer" => Ok(Self::BaseFieldInitializer(::std::boxed::Box::new(
11160 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
11161 ))),
11162 "field_initializer" => Ok(Self::FieldInitializer(::std::boxed::Box::new(
11163 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)?,
11164 ))),
11165 "shorthand_field_initializer" => {
11166 Ok(Self::ShorthandFieldInitializer(::std::boxed::Box::new(
11167 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(
11168 node, src,
11169 )?,
11170 )))
11171 }
11172 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11173 }
11174 }
11175}
11176impl ::treesitter_types::Spanned for FieldInitializerListChildren<'_> {
11177 fn span(&self) -> ::treesitter_types::Span {
11178 match self {
11179 Self::BaseFieldInitializer(inner) => inner.span(),
11180 Self::FieldInitializer(inner) => inner.span(),
11181 Self::ShorthandFieldInitializer(inner) => inner.span(),
11182 }
11183 }
11184}
11185#[derive(Debug, Clone, PartialEq, Eq)]
11186pub enum FieldPatternName<'tree> {
11187 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
11188 ShorthandFieldIdentifier(::std::boxed::Box<ShorthandFieldIdentifier<'tree>>),
11189}
11190impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternName<'tree> {
11191 #[allow(clippy::collapsible_else_if)]
11192 fn from_node(
11193 node: ::tree_sitter::Node<'tree>,
11194 src: &'tree [u8],
11195 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11196 match node.kind() {
11197 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
11198 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11199 ))),
11200 "shorthand_field_identifier" => {
11201 Ok(Self::ShorthandFieldIdentifier(::std::boxed::Box::new(
11202 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(
11203 node, src,
11204 )?,
11205 )))
11206 }
11207 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11208 }
11209 }
11210}
11211impl ::treesitter_types::Spanned for FieldPatternName<'_> {
11212 fn span(&self) -> ::treesitter_types::Span {
11213 match self {
11214 Self::FieldIdentifier(inner) => inner.span(),
11215 Self::ShorthandFieldIdentifier(inner) => inner.span(),
11216 }
11217 }
11218}
11219#[derive(Debug, Clone, PartialEq, Eq)]
11220pub enum FunctionItemName<'tree> {
11221 Identifier(::std::boxed::Box<Identifier<'tree>>),
11222 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11223}
11224impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemName<'tree> {
11225 #[allow(clippy::collapsible_else_if)]
11226 fn from_node(
11227 node: ::tree_sitter::Node<'tree>,
11228 src: &'tree [u8],
11229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11230 match node.kind() {
11231 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11232 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11233 ))),
11234 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11235 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11236 ))),
11237 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11238 }
11239 }
11240}
11241impl ::treesitter_types::Spanned for FunctionItemName<'_> {
11242 fn span(&self) -> ::treesitter_types::Span {
11243 match self {
11244 Self::Identifier(inner) => inner.span(),
11245 Self::Metavariable(inner) => inner.span(),
11246 }
11247 }
11248}
11249#[derive(Debug, Clone, PartialEq, Eq)]
11250pub enum FunctionItemChildren<'tree> {
11251 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
11252 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11253 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11254}
11255impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionItemChildren<'tree> {
11256 #[allow(clippy::collapsible_else_if)]
11257 fn from_node(
11258 node: ::tree_sitter::Node<'tree>,
11259 src: &'tree [u8],
11260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11261 match node.kind() {
11262 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
11263 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
11264 ))),
11265 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11266 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11267 ))),
11268 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11269 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11270 ))),
11271 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11272 }
11273 }
11274}
11275impl ::treesitter_types::Spanned for FunctionItemChildren<'_> {
11276 fn span(&self) -> ::treesitter_types::Span {
11277 match self {
11278 Self::FunctionModifiers(inner) => inner.span(),
11279 Self::VisibilityModifier(inner) => inner.span(),
11280 Self::WhereClause(inner) => inner.span(),
11281 }
11282 }
11283}
11284#[derive(Debug, Clone, PartialEq, Eq)]
11285pub enum FunctionSignatureItemName<'tree> {
11286 Identifier(::std::boxed::Box<Identifier<'tree>>),
11287 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11288}
11289impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemName<'tree> {
11290 #[allow(clippy::collapsible_else_if)]
11291 fn from_node(
11292 node: ::tree_sitter::Node<'tree>,
11293 src: &'tree [u8],
11294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11295 match node.kind() {
11296 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11297 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11298 ))),
11299 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11300 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11301 ))),
11302 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11303 }
11304 }
11305}
11306impl ::treesitter_types::Spanned for FunctionSignatureItemName<'_> {
11307 fn span(&self) -> ::treesitter_types::Span {
11308 match self {
11309 Self::Identifier(inner) => inner.span(),
11310 Self::Metavariable(inner) => inner.span(),
11311 }
11312 }
11313}
11314#[derive(Debug, Clone, PartialEq, Eq)]
11315pub enum FunctionSignatureItemChildren<'tree> {
11316 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
11317 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11318 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
11319}
11320impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureItemChildren<'tree> {
11321 #[allow(clippy::collapsible_else_if)]
11322 fn from_node(
11323 node: ::tree_sitter::Node<'tree>,
11324 src: &'tree [u8],
11325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11326 match node.kind() {
11327 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
11328 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
11329 ))),
11330 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11331 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11332 ))),
11333 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
11334 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11335 ))),
11336 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11337 }
11338 }
11339}
11340impl ::treesitter_types::Spanned for FunctionSignatureItemChildren<'_> {
11341 fn span(&self) -> ::treesitter_types::Span {
11342 match self {
11343 Self::FunctionModifiers(inner) => inner.span(),
11344 Self::VisibilityModifier(inner) => inner.span(),
11345 Self::WhereClause(inner) => inner.span(),
11346 }
11347 }
11348}
11349#[derive(Debug, Clone, PartialEq, Eq)]
11350pub enum FunctionTypeTrait<'tree> {
11351 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11352 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11353}
11354impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeTrait<'tree> {
11355 #[allow(clippy::collapsible_else_if)]
11356 fn from_node(
11357 node: ::tree_sitter::Node<'tree>,
11358 src: &'tree [u8],
11359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11360 match node.kind() {
11361 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11362 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11363 ))),
11364 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11365 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11366 ))),
11367 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11368 }
11369 }
11370}
11371impl ::treesitter_types::Spanned for FunctionTypeTrait<'_> {
11372 fn span(&self) -> ::treesitter_types::Span {
11373 match self {
11374 Self::ScopedTypeIdentifier(inner) => inner.span(),
11375 Self::TypeIdentifier(inner) => inner.span(),
11376 }
11377 }
11378}
11379#[derive(Debug, Clone, PartialEq, Eq)]
11380pub enum FunctionTypeChildren<'tree> {
11381 ForLifetimes(::std::boxed::Box<ForLifetimes<'tree>>),
11382 FunctionModifiers(::std::boxed::Box<FunctionModifiers<'tree>>),
11383}
11384impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeChildren<'tree> {
11385 #[allow(clippy::collapsible_else_if)]
11386 fn from_node(
11387 node: ::tree_sitter::Node<'tree>,
11388 src: &'tree [u8],
11389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11390 match node.kind() {
11391 "for_lifetimes" => Ok(Self::ForLifetimes(::std::boxed::Box::new(
11392 <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)?,
11393 ))),
11394 "function_modifiers" => Ok(Self::FunctionModifiers(::std::boxed::Box::new(
11395 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
11396 ))),
11397 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11398 }
11399 }
11400}
11401impl ::treesitter_types::Spanned for FunctionTypeChildren<'_> {
11402 fn span(&self) -> ::treesitter_types::Span {
11403 match self {
11404 Self::ForLifetimes(inner) => inner.span(),
11405 Self::FunctionModifiers(inner) => inner.span(),
11406 }
11407 }
11408}
11409#[derive(Debug, Clone, PartialEq, Eq)]
11410pub enum GenericFunctionFunction<'tree> {
11411 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
11412 Identifier(::std::boxed::Box<Identifier<'tree>>),
11413 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11414}
11415impl<'tree> ::treesitter_types::FromNode<'tree> for GenericFunctionFunction<'tree> {
11416 #[allow(clippy::collapsible_else_if)]
11417 fn from_node(
11418 node: ::tree_sitter::Node<'tree>,
11419 src: &'tree [u8],
11420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11421 match node.kind() {
11422 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
11423 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11424 ))),
11425 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11426 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11427 ))),
11428 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11429 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11430 ))),
11431 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11432 }
11433 }
11434}
11435impl ::treesitter_types::Spanned for GenericFunctionFunction<'_> {
11436 fn span(&self) -> ::treesitter_types::Span {
11437 match self {
11438 Self::FieldExpression(inner) => inner.span(),
11439 Self::Identifier(inner) => inner.span(),
11440 Self::ScopedIdentifier(inner) => inner.span(),
11441 }
11442 }
11443}
11444#[derive(Debug, Clone, PartialEq, Eq)]
11445pub enum GenericPatternChildren<'tree> {
11446 Identifier(::std::boxed::Box<Identifier<'tree>>),
11447 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11448}
11449impl<'tree> ::treesitter_types::FromNode<'tree> for GenericPatternChildren<'tree> {
11450 #[allow(clippy::collapsible_else_if)]
11451 fn from_node(
11452 node: ::tree_sitter::Node<'tree>,
11453 src: &'tree [u8],
11454 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11455 match node.kind() {
11456 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11457 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11458 ))),
11459 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11460 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11461 ))),
11462 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11463 }
11464 }
11465}
11466impl ::treesitter_types::Spanned for GenericPatternChildren<'_> {
11467 fn span(&self) -> ::treesitter_types::Span {
11468 match self {
11469 Self::Identifier(inner) => inner.span(),
11470 Self::ScopedIdentifier(inner) => inner.span(),
11471 }
11472 }
11473}
11474#[derive(Debug, Clone, PartialEq, Eq)]
11475pub enum GenericTypeType<'tree> {
11476 Identifier(::std::boxed::Box<Identifier<'tree>>),
11477 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11478 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11479 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11480}
11481impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeType<'tree> {
11482 #[allow(clippy::collapsible_else_if)]
11483 fn from_node(
11484 node: ::tree_sitter::Node<'tree>,
11485 src: &'tree [u8],
11486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11487 match node.kind() {
11488 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11489 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11490 ))),
11491 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11492 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11493 ))),
11494 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11495 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11496 ))),
11497 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11498 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11499 ))),
11500 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11501 }
11502 }
11503}
11504impl ::treesitter_types::Spanned for GenericTypeType<'_> {
11505 fn span(&self) -> ::treesitter_types::Span {
11506 match self {
11507 Self::Identifier(inner) => inner.span(),
11508 Self::ScopedIdentifier(inner) => inner.span(),
11509 Self::ScopedTypeIdentifier(inner) => inner.span(),
11510 Self::TypeIdentifier(inner) => inner.span(),
11511 }
11512 }
11513}
11514#[derive(Debug, Clone, PartialEq, Eq)]
11515pub enum GenericTypeWithTurbofishType<'tree> {
11516 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11517 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11518}
11519impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeWithTurbofishType<'tree> {
11520 #[allow(clippy::collapsible_else_if)]
11521 fn from_node(
11522 node: ::tree_sitter::Node<'tree>,
11523 src: &'tree [u8],
11524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11525 match node.kind() {
11526 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11527 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11528 ))),
11529 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11530 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11531 ))),
11532 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11533 }
11534 }
11535}
11536impl ::treesitter_types::Spanned for GenericTypeWithTurbofishType<'_> {
11537 fn span(&self) -> ::treesitter_types::Span {
11538 match self {
11539 Self::ScopedIdentifier(inner) => inner.span(),
11540 Self::TypeIdentifier(inner) => inner.span(),
11541 }
11542 }
11543}
11544#[derive(Debug, Clone, PartialEq, Eq)]
11545pub enum IfExpressionCondition<'tree> {
11546 Expression(::std::boxed::Box<Expression<'tree>>),
11547 LetChain(::std::boxed::Box<LetChain<'tree>>),
11548 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
11549}
11550impl<'tree> ::treesitter_types::FromNode<'tree> for IfExpressionCondition<'tree> {
11551 #[allow(clippy::collapsible_else_if)]
11552 fn from_node(
11553 node: ::tree_sitter::Node<'tree>,
11554 src: &'tree [u8],
11555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11556 match node.kind() {
11557 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
11558 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
11559 ))),
11560 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
11561 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
11562 ))),
11563 _other => {
11564 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11565 Ok(Self::Expression(::std::boxed::Box::new(v)))
11566 } else {
11567 Err(::treesitter_types::ParseError::unexpected_kind(
11568 _other, node,
11569 ))
11570 }
11571 }
11572 }
11573 }
11574}
11575impl ::treesitter_types::Spanned for IfExpressionCondition<'_> {
11576 fn span(&self) -> ::treesitter_types::Span {
11577 match self {
11578 Self::Expression(inner) => inner.span(),
11579 Self::LetChain(inner) => inner.span(),
11580 Self::LetCondition(inner) => inner.span(),
11581 }
11582 }
11583}
11584#[derive(Debug, Clone, PartialEq, Eq)]
11585pub enum ImplItemTrait<'tree> {
11586 GenericType(::std::boxed::Box<GenericType<'tree>>),
11587 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
11588 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11589}
11590impl<'tree> ::treesitter_types::FromNode<'tree> for ImplItemTrait<'tree> {
11591 #[allow(clippy::collapsible_else_if)]
11592 fn from_node(
11593 node: ::tree_sitter::Node<'tree>,
11594 src: &'tree [u8],
11595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11596 match node.kind() {
11597 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
11598 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
11599 ))),
11600 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
11601 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11602 ))),
11603 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11604 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11605 ))),
11606 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11607 }
11608 }
11609}
11610impl ::treesitter_types::Spanned for ImplItemTrait<'_> {
11611 fn span(&self) -> ::treesitter_types::Span {
11612 match self {
11613 Self::GenericType(inner) => inner.span(),
11614 Self::ScopedTypeIdentifier(inner) => inner.span(),
11615 Self::TypeIdentifier(inner) => inner.span(),
11616 }
11617 }
11618}
11619#[derive(Debug, Clone, PartialEq, Eq)]
11620pub enum LetChainChildren<'tree> {
11621 Expression(::std::boxed::Box<Expression<'tree>>),
11622 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
11623}
11624impl<'tree> ::treesitter_types::FromNode<'tree> for LetChainChildren<'tree> {
11625 #[allow(clippy::collapsible_else_if)]
11626 fn from_node(
11627 node: ::tree_sitter::Node<'tree>,
11628 src: &'tree [u8],
11629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11630 match node.kind() {
11631 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
11632 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
11633 ))),
11634 _other => {
11635 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11636 Ok(Self::Expression(::std::boxed::Box::new(v)))
11637 } else {
11638 Err(::treesitter_types::ParseError::unexpected_kind(
11639 _other, node,
11640 ))
11641 }
11642 }
11643 }
11644 }
11645}
11646impl ::treesitter_types::Spanned for LetChainChildren<'_> {
11647 fn span(&self) -> ::treesitter_types::Span {
11648 match self {
11649 Self::Expression(inner) => inner.span(),
11650 Self::LetCondition(inner) => inner.span(),
11651 }
11652 }
11653}
11654#[derive(Debug, Clone, PartialEq, Eq)]
11655pub enum MacroInvocationMacro<'tree> {
11656 Identifier(::std::boxed::Box<Identifier<'tree>>),
11657 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11658}
11659impl<'tree> ::treesitter_types::FromNode<'tree> for MacroInvocationMacro<'tree> {
11660 #[allow(clippy::collapsible_else_if)]
11661 fn from_node(
11662 node: ::tree_sitter::Node<'tree>,
11663 src: &'tree [u8],
11664 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11665 match node.kind() {
11666 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11667 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11668 ))),
11669 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11670 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11671 ))),
11672 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11673 }
11674 }
11675}
11676impl ::treesitter_types::Spanned for MacroInvocationMacro<'_> {
11677 fn span(&self) -> ::treesitter_types::Span {
11678 match self {
11679 Self::Identifier(inner) => inner.span(),
11680 Self::ScopedIdentifier(inner) => inner.span(),
11681 }
11682 }
11683}
11684#[derive(Debug, Clone, PartialEq, Eq)]
11685pub enum MatchArmChildren<'tree> {
11686 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11687 InnerAttributeItem(::std::boxed::Box<InnerAttributeItem<'tree>>),
11688}
11689impl<'tree> ::treesitter_types::FromNode<'tree> for MatchArmChildren<'tree> {
11690 #[allow(clippy::collapsible_else_if)]
11691 fn from_node(
11692 node: ::tree_sitter::Node<'tree>,
11693 src: &'tree [u8],
11694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11695 match node.kind() {
11696 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11697 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11698 ))),
11699 "inner_attribute_item" => Ok(Self::InnerAttributeItem(::std::boxed::Box::new(
11700 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11701 ))),
11702 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11703 }
11704 }
11705}
11706impl ::treesitter_types::Spanned for MatchArmChildren<'_> {
11707 fn span(&self) -> ::treesitter_types::Span {
11708 match self {
11709 Self::AttributeItem(inner) => inner.span(),
11710 Self::InnerAttributeItem(inner) => inner.span(),
11711 }
11712 }
11713}
11714#[derive(Debug, Clone, PartialEq, Eq)]
11715pub enum MatchPatternCondition<'tree> {
11716 Expression(::std::boxed::Box<Expression<'tree>>),
11717 LetChain(::std::boxed::Box<LetChain<'tree>>),
11718 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
11719}
11720impl<'tree> ::treesitter_types::FromNode<'tree> for MatchPatternCondition<'tree> {
11721 #[allow(clippy::collapsible_else_if)]
11722 fn from_node(
11723 node: ::tree_sitter::Node<'tree>,
11724 src: &'tree [u8],
11725 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11726 match node.kind() {
11727 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
11728 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
11729 ))),
11730 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
11731 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
11732 ))),
11733 _other => {
11734 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11735 Ok(Self::Expression(::std::boxed::Box::new(v)))
11736 } else {
11737 Err(::treesitter_types::ParseError::unexpected_kind(
11738 _other, node,
11739 ))
11740 }
11741 }
11742 }
11743 }
11744}
11745impl ::treesitter_types::Spanned for MatchPatternCondition<'_> {
11746 fn span(&self) -> ::treesitter_types::Span {
11747 match self {
11748 Self::Expression(inner) => inner.span(),
11749 Self::LetChain(inner) => inner.span(),
11750 Self::LetCondition(inner) => inner.span(),
11751 }
11752 }
11753}
11754#[derive(Debug, Clone, PartialEq, Eq)]
11755pub enum MutPatternChildren<'tree> {
11756 Pattern(::std::boxed::Box<Pattern<'tree>>),
11757 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
11758}
11759impl<'tree> ::treesitter_types::FromNode<'tree> for MutPatternChildren<'tree> {
11760 #[allow(clippy::collapsible_else_if)]
11761 fn from_node(
11762 node: ::tree_sitter::Node<'tree>,
11763 src: &'tree [u8],
11764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11765 match node.kind() {
11766 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
11767 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11768 ))),
11769 _other => {
11770 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
11771 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11772 } else {
11773 Err(::treesitter_types::ParseError::unexpected_kind(
11774 _other, node,
11775 ))
11776 }
11777 }
11778 }
11779 }
11780}
11781impl ::treesitter_types::Spanned for MutPatternChildren<'_> {
11782 fn span(&self) -> ::treesitter_types::Span {
11783 match self {
11784 Self::Pattern(inner) => inner.span(),
11785 Self::MutableSpecifier(inner) => inner.span(),
11786 }
11787 }
11788}
11789#[derive(Debug, Clone, PartialEq, Eq)]
11790pub enum NegativeLiteralChildren<'tree> {
11791 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
11792 IntegerLiteral(::std::boxed::Box<IntegerLiteral<'tree>>),
11793}
11794impl<'tree> ::treesitter_types::FromNode<'tree> for NegativeLiteralChildren<'tree> {
11795 #[allow(clippy::collapsible_else_if)]
11796 fn from_node(
11797 node: ::tree_sitter::Node<'tree>,
11798 src: &'tree [u8],
11799 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11800 match node.kind() {
11801 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
11802 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11803 ))),
11804 "integer_literal" => Ok(Self::IntegerLiteral(::std::boxed::Box::new(
11805 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11806 ))),
11807 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11808 }
11809 }
11810}
11811impl ::treesitter_types::Spanned for NegativeLiteralChildren<'_> {
11812 fn span(&self) -> ::treesitter_types::Span {
11813 match self {
11814 Self::FloatLiteral(inner) => inner.span(),
11815 Self::IntegerLiteral(inner) => inner.span(),
11816 }
11817 }
11818}
11819#[derive(Debug, Clone, PartialEq, Eq)]
11820pub enum OrderedFieldDeclarationListChildren<'tree> {
11821 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11822 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11823}
11824impl<'tree> ::treesitter_types::FromNode<'tree> for OrderedFieldDeclarationListChildren<'tree> {
11825 #[allow(clippy::collapsible_else_if)]
11826 fn from_node(
11827 node: ::tree_sitter::Node<'tree>,
11828 src: &'tree [u8],
11829 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11830 match node.kind() {
11831 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11832 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11833 ))),
11834 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11835 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11836 ))),
11837 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11838 }
11839 }
11840}
11841impl ::treesitter_types::Spanned for OrderedFieldDeclarationListChildren<'_> {
11842 fn span(&self) -> ::treesitter_types::Span {
11843 match self {
11844 Self::AttributeItem(inner) => inner.span(),
11845 Self::VisibilityModifier(inner) => inner.span(),
11846 }
11847 }
11848}
11849#[derive(Debug, Clone, PartialEq, Eq)]
11850pub enum ParameterPattern<'tree> {
11851 Pattern(::std::boxed::Box<Pattern<'tree>>),
11852 SelfType(::std::boxed::Box<SelfType<'tree>>),
11853}
11854impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPattern<'tree> {
11855 #[allow(clippy::collapsible_else_if)]
11856 fn from_node(
11857 node: ::tree_sitter::Node<'tree>,
11858 src: &'tree [u8],
11859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11860 match node.kind() {
11861 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11862 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11863 ))),
11864 _other => {
11865 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
11866 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11867 } else {
11868 Err(::treesitter_types::ParseError::unexpected_kind(
11869 _other, node,
11870 ))
11871 }
11872 }
11873 }
11874 }
11875}
11876impl ::treesitter_types::Spanned for ParameterPattern<'_> {
11877 fn span(&self) -> ::treesitter_types::Span {
11878 match self {
11879 Self::Pattern(inner) => inner.span(),
11880 Self::SelfType(inner) => inner.span(),
11881 }
11882 }
11883}
11884#[derive(Debug, Clone, PartialEq, Eq)]
11885pub enum ParametersChildren<'tree> {
11886 Type(::std::boxed::Box<Type<'tree>>),
11887 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
11888 Parameter(::std::boxed::Box<Parameter<'tree>>),
11889 SelfParameter(::std::boxed::Box<SelfParameter<'tree>>),
11890 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
11891}
11892impl<'tree> ::treesitter_types::FromNode<'tree> for ParametersChildren<'tree> {
11893 #[allow(clippy::collapsible_else_if)]
11894 fn from_node(
11895 node: ::tree_sitter::Node<'tree>,
11896 src: &'tree [u8],
11897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11898 match node.kind() {
11899 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
11900 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
11901 ))),
11902 "parameter" => Ok(Self::Parameter(::std::boxed::Box::new(
11903 <Parameter as ::treesitter_types::FromNode>::from_node(node, src)?,
11904 ))),
11905 "self_parameter" => Ok(Self::SelfParameter(::std::boxed::Box::new(
11906 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
11907 ))),
11908 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
11909 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
11910 ))),
11911 _other => {
11912 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11913 Ok(Self::Type(::std::boxed::Box::new(v)))
11914 } else {
11915 Err(::treesitter_types::ParseError::unexpected_kind(
11916 _other, node,
11917 ))
11918 }
11919 }
11920 }
11921 }
11922}
11923impl ::treesitter_types::Spanned for ParametersChildren<'_> {
11924 fn span(&self) -> ::treesitter_types::Span {
11925 match self {
11926 Self::Type(inner) => inner.span(),
11927 Self::AttributeItem(inner) => inner.span(),
11928 Self::Parameter(inner) => inner.span(),
11929 Self::SelfParameter(inner) => inner.span(),
11930 Self::VariadicParameter(inner) => inner.span(),
11931 }
11932 }
11933}
11934#[derive(Debug, Clone, PartialEq, Eq)]
11935pub enum RangePatternLeft<'tree> {
11936 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
11937 Crate(::std::boxed::Box<Crate<'tree>>),
11938 Identifier(::std::boxed::Box<Identifier<'tree>>),
11939 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
11940 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
11941 SelfType(::std::boxed::Box<SelfType<'tree>>),
11942 Super(::std::boxed::Box<Super<'tree>>),
11943}
11944impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternLeft<'tree> {
11945 #[allow(clippy::collapsible_else_if)]
11946 fn from_node(
11947 node: ::tree_sitter::Node<'tree>,
11948 src: &'tree [u8],
11949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11950 match node.kind() {
11951 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
11952 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
11953 ))),
11954 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11955 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11956 ))),
11957 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
11958 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
11959 ))),
11960 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
11961 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11962 ))),
11963 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
11964 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
11965 ))),
11966 "super" => Ok(Self::Super(::std::boxed::Box::new(
11967 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
11968 ))),
11969 _other => {
11970 if let Ok(v) =
11971 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
11972 {
11973 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
11974 } else {
11975 Err(::treesitter_types::ParseError::unexpected_kind(
11976 _other, node,
11977 ))
11978 }
11979 }
11980 }
11981 }
11982}
11983impl ::treesitter_types::Spanned for RangePatternLeft<'_> {
11984 fn span(&self) -> ::treesitter_types::Span {
11985 match self {
11986 Self::LiteralPattern(inner) => inner.span(),
11987 Self::Crate(inner) => inner.span(),
11988 Self::Identifier(inner) => inner.span(),
11989 Self::Metavariable(inner) => inner.span(),
11990 Self::ScopedIdentifier(inner) => inner.span(),
11991 Self::SelfType(inner) => inner.span(),
11992 Self::Super(inner) => inner.span(),
11993 }
11994 }
11995}
11996#[derive(Debug, Clone, PartialEq, Eq)]
11997pub enum RangePatternRight<'tree> {
11998 LiteralPattern(::std::boxed::Box<LiteralPattern<'tree>>),
11999 Crate(::std::boxed::Box<Crate<'tree>>),
12000 Identifier(::std::boxed::Box<Identifier<'tree>>),
12001 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12002 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12003 SelfType(::std::boxed::Box<SelfType<'tree>>),
12004 Super(::std::boxed::Box<Super<'tree>>),
12005}
12006impl<'tree> ::treesitter_types::FromNode<'tree> for RangePatternRight<'tree> {
12007 #[allow(clippy::collapsible_else_if)]
12008 fn from_node(
12009 node: ::tree_sitter::Node<'tree>,
12010 src: &'tree [u8],
12011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12012 match node.kind() {
12013 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12014 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12015 ))),
12016 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12017 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12018 ))),
12019 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12020 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12021 ))),
12022 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12023 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12024 ))),
12025 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12026 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12027 ))),
12028 "super" => Ok(Self::Super(::std::boxed::Box::new(
12029 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12030 ))),
12031 _other => {
12032 if let Ok(v) =
12033 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
12034 {
12035 Ok(Self::LiteralPattern(::std::boxed::Box::new(v)))
12036 } else {
12037 Err(::treesitter_types::ParseError::unexpected_kind(
12038 _other, node,
12039 ))
12040 }
12041 }
12042 }
12043 }
12044}
12045impl ::treesitter_types::Spanned for RangePatternRight<'_> {
12046 fn span(&self) -> ::treesitter_types::Span {
12047 match self {
12048 Self::LiteralPattern(inner) => inner.span(),
12049 Self::Crate(inner) => inner.span(),
12050 Self::Identifier(inner) => inner.span(),
12051 Self::Metavariable(inner) => inner.span(),
12052 Self::ScopedIdentifier(inner) => inner.span(),
12053 Self::SelfType(inner) => inner.span(),
12054 Self::Super(inner) => inner.span(),
12055 }
12056 }
12057}
12058#[derive(Debug, Clone, PartialEq, Eq)]
12059pub enum ReferencePatternChildren<'tree> {
12060 Pattern(::std::boxed::Box<Pattern<'tree>>),
12061 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12062}
12063impl<'tree> ::treesitter_types::FromNode<'tree> for ReferencePatternChildren<'tree> {
12064 #[allow(clippy::collapsible_else_if)]
12065 fn from_node(
12066 node: ::tree_sitter::Node<'tree>,
12067 src: &'tree [u8],
12068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12069 match node.kind() {
12070 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12071 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12072 ))),
12073 _other => {
12074 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12075 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12076 } else {
12077 Err(::treesitter_types::ParseError::unexpected_kind(
12078 _other, node,
12079 ))
12080 }
12081 }
12082 }
12083 }
12084}
12085impl ::treesitter_types::Spanned for ReferencePatternChildren<'_> {
12086 fn span(&self) -> ::treesitter_types::Span {
12087 match self {
12088 Self::Pattern(inner) => inner.span(),
12089 Self::MutableSpecifier(inner) => inner.span(),
12090 }
12091 }
12092}
12093#[derive(Debug, Clone, PartialEq, Eq)]
12094pub enum ReferenceTypeChildren<'tree> {
12095 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12096 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12097}
12098impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceTypeChildren<'tree> {
12099 #[allow(clippy::collapsible_else_if)]
12100 fn from_node(
12101 node: ::tree_sitter::Node<'tree>,
12102 src: &'tree [u8],
12103 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12104 match node.kind() {
12105 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12106 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
12107 ))),
12108 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12109 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12110 ))),
12111 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12112 }
12113 }
12114}
12115impl ::treesitter_types::Spanned for ReferenceTypeChildren<'_> {
12116 fn span(&self) -> ::treesitter_types::Span {
12117 match self {
12118 Self::Lifetime(inner) => inner.span(),
12119 Self::MutableSpecifier(inner) => inner.span(),
12120 }
12121 }
12122}
12123#[derive(Debug, Clone, PartialEq, Eq)]
12124pub enum ScopedIdentifierName<'tree> {
12125 Identifier(::std::boxed::Box<Identifier<'tree>>),
12126 Super(::std::boxed::Box<Super<'tree>>),
12127}
12128impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierName<'tree> {
12129 #[allow(clippy::collapsible_else_if)]
12130 fn from_node(
12131 node: ::tree_sitter::Node<'tree>,
12132 src: &'tree [u8],
12133 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12134 match node.kind() {
12135 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12136 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12137 ))),
12138 "super" => Ok(Self::Super(::std::boxed::Box::new(
12139 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12140 ))),
12141 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12142 }
12143 }
12144}
12145impl ::treesitter_types::Spanned for ScopedIdentifierName<'_> {
12146 fn span(&self) -> ::treesitter_types::Span {
12147 match self {
12148 Self::Identifier(inner) => inner.span(),
12149 Self::Super(inner) => inner.span(),
12150 }
12151 }
12152}
12153#[derive(Debug, Clone, PartialEq, Eq)]
12154pub enum ScopedIdentifierPath<'tree> {
12155 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
12156 Crate(::std::boxed::Box<Crate<'tree>>),
12157 GenericType(::std::boxed::Box<GenericType<'tree>>),
12158 Identifier(::std::boxed::Box<Identifier<'tree>>),
12159 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12160 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12161 SelfType(::std::boxed::Box<SelfType<'tree>>),
12162 Super(::std::boxed::Box<Super<'tree>>),
12163}
12164impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedIdentifierPath<'tree> {
12165 #[allow(clippy::collapsible_else_if)]
12166 fn from_node(
12167 node: ::tree_sitter::Node<'tree>,
12168 src: &'tree [u8],
12169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12170 match node.kind() {
12171 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
12172 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)?,
12173 ))),
12174 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12175 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12176 ))),
12177 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
12178 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
12179 ))),
12180 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12181 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12182 ))),
12183 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12184 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12185 ))),
12186 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12187 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12188 ))),
12189 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12190 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12191 ))),
12192 "super" => Ok(Self::Super(::std::boxed::Box::new(
12193 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12194 ))),
12195 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12196 }
12197 }
12198}
12199impl ::treesitter_types::Spanned for ScopedIdentifierPath<'_> {
12200 fn span(&self) -> ::treesitter_types::Span {
12201 match self {
12202 Self::BracketedType(inner) => inner.span(),
12203 Self::Crate(inner) => inner.span(),
12204 Self::GenericType(inner) => inner.span(),
12205 Self::Identifier(inner) => inner.span(),
12206 Self::Metavariable(inner) => inner.span(),
12207 Self::ScopedIdentifier(inner) => inner.span(),
12208 Self::SelfType(inner) => inner.span(),
12209 Self::Super(inner) => inner.span(),
12210 }
12211 }
12212}
12213#[derive(Debug, Clone, PartialEq, Eq)]
12214pub enum ScopedTypeIdentifierPath<'tree> {
12215 BracketedType(::std::boxed::Box<BracketedType<'tree>>),
12216 Crate(::std::boxed::Box<Crate<'tree>>),
12217 GenericType(::std::boxed::Box<GenericType<'tree>>),
12218 Identifier(::std::boxed::Box<Identifier<'tree>>),
12219 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12220 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12221 SelfType(::std::boxed::Box<SelfType<'tree>>),
12222 Super(::std::boxed::Box<Super<'tree>>),
12223}
12224impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedTypeIdentifierPath<'tree> {
12225 #[allow(clippy::collapsible_else_if)]
12226 fn from_node(
12227 node: ::tree_sitter::Node<'tree>,
12228 src: &'tree [u8],
12229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12230 match node.kind() {
12231 "bracketed_type" => Ok(Self::BracketedType(::std::boxed::Box::new(
12232 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)?,
12233 ))),
12234 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12235 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12236 ))),
12237 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
12238 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
12239 ))),
12240 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12241 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12242 ))),
12243 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12244 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12245 ))),
12246 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12247 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12248 ))),
12249 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12250 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12251 ))),
12252 "super" => Ok(Self::Super(::std::boxed::Box::new(
12253 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12254 ))),
12255 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12256 }
12257 }
12258}
12259impl ::treesitter_types::Spanned for ScopedTypeIdentifierPath<'_> {
12260 fn span(&self) -> ::treesitter_types::Span {
12261 match self {
12262 Self::BracketedType(inner) => inner.span(),
12263 Self::Crate(inner) => inner.span(),
12264 Self::GenericType(inner) => inner.span(),
12265 Self::Identifier(inner) => inner.span(),
12266 Self::Metavariable(inner) => inner.span(),
12267 Self::ScopedIdentifier(inner) => inner.span(),
12268 Self::SelfType(inner) => inner.span(),
12269 Self::Super(inner) => inner.span(),
12270 }
12271 }
12272}
12273#[derive(Debug, Clone, PartialEq, Eq)]
12274pub enum ScopedUseListPath<'tree> {
12275 Crate(::std::boxed::Box<Crate<'tree>>),
12276 Identifier(::std::boxed::Box<Identifier<'tree>>),
12277 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12278 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
12279 SelfType(::std::boxed::Box<SelfType<'tree>>),
12280 Super(::std::boxed::Box<Super<'tree>>),
12281}
12282impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedUseListPath<'tree> {
12283 #[allow(clippy::collapsible_else_if)]
12284 fn from_node(
12285 node: ::tree_sitter::Node<'tree>,
12286 src: &'tree [u8],
12287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12288 match node.kind() {
12289 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12290 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12291 ))),
12292 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12293 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12294 ))),
12295 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12296 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12297 ))),
12298 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
12299 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12300 ))),
12301 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12302 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12303 ))),
12304 "super" => Ok(Self::Super(::std::boxed::Box::new(
12305 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12306 ))),
12307 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12308 }
12309 }
12310}
12311impl ::treesitter_types::Spanned for ScopedUseListPath<'_> {
12312 fn span(&self) -> ::treesitter_types::Span {
12313 match self {
12314 Self::Crate(inner) => inner.span(),
12315 Self::Identifier(inner) => inner.span(),
12316 Self::Metavariable(inner) => inner.span(),
12317 Self::ScopedIdentifier(inner) => inner.span(),
12318 Self::SelfType(inner) => inner.span(),
12319 Self::Super(inner) => inner.span(),
12320 }
12321 }
12322}
12323#[derive(Debug, Clone, PartialEq, Eq)]
12324pub enum SelfParameterChildren<'tree> {
12325 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12326 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12327 SelfType(::std::boxed::Box<SelfType<'tree>>),
12328}
12329impl<'tree> ::treesitter_types::FromNode<'tree> for SelfParameterChildren<'tree> {
12330 #[allow(clippy::collapsible_else_if)]
12331 fn from_node(
12332 node: ::tree_sitter::Node<'tree>,
12333 src: &'tree [u8],
12334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12335 match node.kind() {
12336 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12337 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
12338 ))),
12339 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12340 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12341 ))),
12342 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12343 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12344 ))),
12345 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12346 }
12347 }
12348}
12349impl ::treesitter_types::Spanned for SelfParameterChildren<'_> {
12350 fn span(&self) -> ::treesitter_types::Span {
12351 match self {
12352 Self::Lifetime(inner) => inner.span(),
12353 Self::MutableSpecifier(inner) => inner.span(),
12354 Self::SelfType(inner) => inner.span(),
12355 }
12356 }
12357}
12358#[derive(Debug, Clone, PartialEq, Eq)]
12359pub enum ShorthandFieldInitializerChildren<'tree> {
12360 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
12361 Identifier(::std::boxed::Box<Identifier<'tree>>),
12362}
12363impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandFieldInitializerChildren<'tree> {
12364 #[allow(clippy::collapsible_else_if)]
12365 fn from_node(
12366 node: ::tree_sitter::Node<'tree>,
12367 src: &'tree [u8],
12368 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12369 match node.kind() {
12370 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
12371 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
12372 ))),
12373 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12374 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12375 ))),
12376 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12377 }
12378 }
12379}
12380impl ::treesitter_types::Spanned for ShorthandFieldInitializerChildren<'_> {
12381 fn span(&self) -> ::treesitter_types::Span {
12382 match self {
12383 Self::AttributeItem(inner) => inner.span(),
12384 Self::Identifier(inner) => inner.span(),
12385 }
12386 }
12387}
12388#[derive(Debug, Clone, PartialEq, Eq)]
12389pub enum SourceFileChildren<'tree> {
12390 DeclarationStatement(::std::boxed::Box<DeclarationStatement<'tree>>),
12391 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
12392 Shebang(::std::boxed::Box<Shebang<'tree>>),
12393}
12394impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFileChildren<'tree> {
12395 #[allow(clippy::collapsible_else_if)]
12396 fn from_node(
12397 node: ::tree_sitter::Node<'tree>,
12398 src: &'tree [u8],
12399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12400 match node.kind() {
12401 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
12402 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12403 ))),
12404 "shebang" => Ok(Self::Shebang(::std::boxed::Box::new(
12405 <Shebang as ::treesitter_types::FromNode>::from_node(node, src)?,
12406 ))),
12407 _other => {
12408 if let Ok(v) =
12409 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
12410 {
12411 Ok(Self::DeclarationStatement(::std::boxed::Box::new(v)))
12412 } else {
12413 Err(::treesitter_types::ParseError::unexpected_kind(
12414 _other, node,
12415 ))
12416 }
12417 }
12418 }
12419 }
12420}
12421impl ::treesitter_types::Spanned for SourceFileChildren<'_> {
12422 fn span(&self) -> ::treesitter_types::Span {
12423 match self {
12424 Self::DeclarationStatement(inner) => inner.span(),
12425 Self::ExpressionStatement(inner) => inner.span(),
12426 Self::Shebang(inner) => inner.span(),
12427 }
12428 }
12429}
12430#[derive(Debug, Clone, PartialEq, Eq)]
12431pub enum StaticItemChildren<'tree> {
12432 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12433 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
12434}
12435impl<'tree> ::treesitter_types::FromNode<'tree> for StaticItemChildren<'tree> {
12436 #[allow(clippy::collapsible_else_if)]
12437 fn from_node(
12438 node: ::tree_sitter::Node<'tree>,
12439 src: &'tree [u8],
12440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12441 match node.kind() {
12442 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12443 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12444 ))),
12445 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12446 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12447 ))),
12448 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12449 }
12450 }
12451}
12452impl ::treesitter_types::Spanned for StaticItemChildren<'_> {
12453 fn span(&self) -> ::treesitter_types::Span {
12454 match self {
12455 Self::MutableSpecifier(inner) => inner.span(),
12456 Self::VisibilityModifier(inner) => inner.span(),
12457 }
12458 }
12459}
12460#[derive(Debug, Clone, PartialEq, Eq)]
12461pub enum StringLiteralChildren<'tree> {
12462 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
12463 StringContent(::std::boxed::Box<StringContent<'tree>>),
12464}
12465impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
12466 #[allow(clippy::collapsible_else_if)]
12467 fn from_node(
12468 node: ::tree_sitter::Node<'tree>,
12469 src: &'tree [u8],
12470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12471 match node.kind() {
12472 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
12473 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
12474 ))),
12475 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
12476 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
12477 ))),
12478 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12479 }
12480 }
12481}
12482impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
12483 fn span(&self) -> ::treesitter_types::Span {
12484 match self {
12485 Self::EscapeSequence(inner) => inner.span(),
12486 Self::StringContent(inner) => inner.span(),
12487 }
12488 }
12489}
12490#[derive(Debug, Clone, PartialEq, Eq)]
12491pub enum StructExpressionName<'tree> {
12492 GenericTypeWithTurbofish(::std::boxed::Box<GenericTypeWithTurbofish<'tree>>),
12493 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12494 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12495}
12496impl<'tree> ::treesitter_types::FromNode<'tree> for StructExpressionName<'tree> {
12497 #[allow(clippy::collapsible_else_if)]
12498 fn from_node(
12499 node: ::tree_sitter::Node<'tree>,
12500 src: &'tree [u8],
12501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12502 match node.kind() {
12503 "generic_type_with_turbofish" => {
12504 Ok(Self::GenericTypeWithTurbofish(::std::boxed::Box::new(
12505 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(
12506 node, src,
12507 )?,
12508 )))
12509 }
12510 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12511 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12512 ))),
12513 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12514 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12515 ))),
12516 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12517 }
12518 }
12519}
12520impl ::treesitter_types::Spanned for StructExpressionName<'_> {
12521 fn span(&self) -> ::treesitter_types::Span {
12522 match self {
12523 Self::GenericTypeWithTurbofish(inner) => inner.span(),
12524 Self::ScopedTypeIdentifier(inner) => inner.span(),
12525 Self::TypeIdentifier(inner) => inner.span(),
12526 }
12527 }
12528}
12529#[derive(Debug, Clone, PartialEq, Eq)]
12530pub enum StructItemBody<'tree> {
12531 FieldDeclarationList(::std::boxed::Box<FieldDeclarationList<'tree>>),
12532 OrderedFieldDeclarationList(::std::boxed::Box<OrderedFieldDeclarationList<'tree>>),
12533}
12534impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemBody<'tree> {
12535 #[allow(clippy::collapsible_else_if)]
12536 fn from_node(
12537 node: ::tree_sitter::Node<'tree>,
12538 src: &'tree [u8],
12539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12540 match node.kind() {
12541 "field_declaration_list" => Ok(Self::FieldDeclarationList(::std::boxed::Box::new(
12542 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)?,
12543 ))),
12544 "ordered_field_declaration_list" => {
12545 Ok(Self::OrderedFieldDeclarationList(::std::boxed::Box::new(
12546 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(
12547 node, src,
12548 )?,
12549 )))
12550 }
12551 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12552 }
12553 }
12554}
12555impl ::treesitter_types::Spanned for StructItemBody<'_> {
12556 fn span(&self) -> ::treesitter_types::Span {
12557 match self {
12558 Self::FieldDeclarationList(inner) => inner.span(),
12559 Self::OrderedFieldDeclarationList(inner) => inner.span(),
12560 }
12561 }
12562}
12563#[derive(Debug, Clone, PartialEq, Eq)]
12564pub enum StructItemChildren<'tree> {
12565 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
12566 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
12567}
12568impl<'tree> ::treesitter_types::FromNode<'tree> for StructItemChildren<'tree> {
12569 #[allow(clippy::collapsible_else_if)]
12570 fn from_node(
12571 node: ::tree_sitter::Node<'tree>,
12572 src: &'tree [u8],
12573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12574 match node.kind() {
12575 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12576 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12577 ))),
12578 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
12579 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12580 ))),
12581 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12582 }
12583 }
12584}
12585impl ::treesitter_types::Spanned for StructItemChildren<'_> {
12586 fn span(&self) -> ::treesitter_types::Span {
12587 match self {
12588 Self::VisibilityModifier(inner) => inner.span(),
12589 Self::WhereClause(inner) => inner.span(),
12590 }
12591 }
12592}
12593#[derive(Debug, Clone, PartialEq, Eq)]
12594pub enum StructPatternType<'tree> {
12595 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
12596 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12597}
12598impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternType<'tree> {
12599 #[allow(clippy::collapsible_else_if)]
12600 fn from_node(
12601 node: ::tree_sitter::Node<'tree>,
12602 src: &'tree [u8],
12603 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12604 match node.kind() {
12605 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
12606 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12607 ))),
12608 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12609 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12610 ))),
12611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12612 }
12613 }
12614}
12615impl ::treesitter_types::Spanned for StructPatternType<'_> {
12616 fn span(&self) -> ::treesitter_types::Span {
12617 match self {
12618 Self::ScopedTypeIdentifier(inner) => inner.span(),
12619 Self::TypeIdentifier(inner) => inner.span(),
12620 }
12621 }
12622}
12623#[derive(Debug, Clone, PartialEq, Eq)]
12624pub enum StructPatternChildren<'tree> {
12625 FieldPattern(::std::boxed::Box<FieldPattern<'tree>>),
12626 RemainingFieldPattern(::std::boxed::Box<RemainingFieldPattern<'tree>>),
12627}
12628impl<'tree> ::treesitter_types::FromNode<'tree> for StructPatternChildren<'tree> {
12629 #[allow(clippy::collapsible_else_if)]
12630 fn from_node(
12631 node: ::tree_sitter::Node<'tree>,
12632 src: &'tree [u8],
12633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12634 match node.kind() {
12635 "field_pattern" => Ok(Self::FieldPattern(::std::boxed::Box::new(
12636 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12637 ))),
12638 "remaining_field_pattern" => Ok(Self::RemainingFieldPattern(::std::boxed::Box::new(
12639 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12640 ))),
12641 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12642 }
12643 }
12644}
12645impl ::treesitter_types::Spanned for StructPatternChildren<'_> {
12646 fn span(&self) -> ::treesitter_types::Span {
12647 match self {
12648 Self::FieldPattern(inner) => inner.span(),
12649 Self::RemainingFieldPattern(inner) => inner.span(),
12650 }
12651 }
12652}
12653#[derive(Debug, Clone, PartialEq, Eq)]
12654pub enum TokenRepetitionChildren<'tree> {
12655 Literal(::std::boxed::Box<Literal<'tree>>),
12656 Crate(::std::boxed::Box<Crate<'tree>>),
12657 Identifier(::std::boxed::Box<Identifier<'tree>>),
12658 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12659 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12660 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12661 SelfType(::std::boxed::Box<SelfType<'tree>>),
12662 Super(::std::boxed::Box<Super<'tree>>),
12663 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
12664 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
12665}
12666impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionChildren<'tree> {
12667 #[allow(clippy::collapsible_else_if)]
12668 fn from_node(
12669 node: ::tree_sitter::Node<'tree>,
12670 src: &'tree [u8],
12671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12672 match node.kind() {
12673 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12674 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12675 ))),
12676 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12677 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12678 ))),
12679 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12680 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12681 ))),
12682 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12683 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12684 ))),
12685 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12686 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12687 ))),
12688 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12689 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12690 ))),
12691 "super" => Ok(Self::Super(::std::boxed::Box::new(
12692 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12693 ))),
12694 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
12695 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)?,
12696 ))),
12697 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
12698 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)?,
12699 ))),
12700 _other => {
12701 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
12702 Ok(Self::Literal(::std::boxed::Box::new(v)))
12703 } else {
12704 Err(::treesitter_types::ParseError::unexpected_kind(
12705 _other, node,
12706 ))
12707 }
12708 }
12709 }
12710 }
12711}
12712impl ::treesitter_types::Spanned for TokenRepetitionChildren<'_> {
12713 fn span(&self) -> ::treesitter_types::Span {
12714 match self {
12715 Self::Literal(inner) => inner.span(),
12716 Self::Crate(inner) => inner.span(),
12717 Self::Identifier(inner) => inner.span(),
12718 Self::Metavariable(inner) => inner.span(),
12719 Self::MutableSpecifier(inner) => inner.span(),
12720 Self::PrimitiveType(inner) => inner.span(),
12721 Self::SelfType(inner) => inner.span(),
12722 Self::Super(inner) => inner.span(),
12723 Self::TokenRepetition(inner) => inner.span(),
12724 Self::TokenTree(inner) => inner.span(),
12725 }
12726 }
12727}
12728#[derive(Debug, Clone, PartialEq, Eq)]
12729pub enum TokenRepetitionPatternChildren<'tree> {
12730 Literal(::std::boxed::Box<Literal<'tree>>),
12731 Crate(::std::boxed::Box<Crate<'tree>>),
12732 Identifier(::std::boxed::Box<Identifier<'tree>>),
12733 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12734 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12735 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12736 SelfType(::std::boxed::Box<SelfType<'tree>>),
12737 Super(::std::boxed::Box<Super<'tree>>),
12738 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
12739 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
12740 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
12741}
12742impl<'tree> ::treesitter_types::FromNode<'tree> for TokenRepetitionPatternChildren<'tree> {
12743 #[allow(clippy::collapsible_else_if)]
12744 fn from_node(
12745 node: ::tree_sitter::Node<'tree>,
12746 src: &'tree [u8],
12747 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12748 match node.kind() {
12749 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12750 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12751 ))),
12752 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12753 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12754 ))),
12755 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12756 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12757 ))),
12758 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12759 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12760 ))),
12761 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12762 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12763 ))),
12764 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12765 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12766 ))),
12767 "super" => Ok(Self::Super(::std::boxed::Box::new(
12768 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12769 ))),
12770 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
12771 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12772 ))),
12773 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
12774 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12775 ))),
12776 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
12777 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12778 ))),
12779 _other => {
12780 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
12781 Ok(Self::Literal(::std::boxed::Box::new(v)))
12782 } else {
12783 Err(::treesitter_types::ParseError::unexpected_kind(
12784 _other, node,
12785 ))
12786 }
12787 }
12788 }
12789 }
12790}
12791impl ::treesitter_types::Spanned for TokenRepetitionPatternChildren<'_> {
12792 fn span(&self) -> ::treesitter_types::Span {
12793 match self {
12794 Self::Literal(inner) => inner.span(),
12795 Self::Crate(inner) => inner.span(),
12796 Self::Identifier(inner) => inner.span(),
12797 Self::Metavariable(inner) => inner.span(),
12798 Self::MutableSpecifier(inner) => inner.span(),
12799 Self::PrimitiveType(inner) => inner.span(),
12800 Self::SelfType(inner) => inner.span(),
12801 Self::Super(inner) => inner.span(),
12802 Self::TokenBindingPattern(inner) => inner.span(),
12803 Self::TokenRepetitionPattern(inner) => inner.span(),
12804 Self::TokenTreePattern(inner) => inner.span(),
12805 }
12806 }
12807}
12808#[derive(Debug, Clone, PartialEq, Eq)]
12809pub enum TokenTreeChildren<'tree> {
12810 Literal(::std::boxed::Box<Literal<'tree>>),
12811 Crate(::std::boxed::Box<Crate<'tree>>),
12812 Identifier(::std::boxed::Box<Identifier<'tree>>),
12813 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12814 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12815 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12816 SelfType(::std::boxed::Box<SelfType<'tree>>),
12817 Super(::std::boxed::Box<Super<'tree>>),
12818 TokenRepetition(::std::boxed::Box<TokenRepetition<'tree>>),
12819 TokenTree(::std::boxed::Box<TokenTree<'tree>>),
12820}
12821impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreeChildren<'tree> {
12822 #[allow(clippy::collapsible_else_if)]
12823 fn from_node(
12824 node: ::tree_sitter::Node<'tree>,
12825 src: &'tree [u8],
12826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12827 match node.kind() {
12828 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12829 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12830 ))),
12831 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12832 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12833 ))),
12834 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12835 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12836 ))),
12837 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12838 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12839 ))),
12840 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12841 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12842 ))),
12843 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12844 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12845 ))),
12846 "super" => Ok(Self::Super(::std::boxed::Box::new(
12847 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12848 ))),
12849 "token_repetition" => Ok(Self::TokenRepetition(::std::boxed::Box::new(
12850 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)?,
12851 ))),
12852 "token_tree" => Ok(Self::TokenTree(::std::boxed::Box::new(
12853 <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)?,
12854 ))),
12855 _other => {
12856 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
12857 Ok(Self::Literal(::std::boxed::Box::new(v)))
12858 } else {
12859 Err(::treesitter_types::ParseError::unexpected_kind(
12860 _other, node,
12861 ))
12862 }
12863 }
12864 }
12865 }
12866}
12867impl ::treesitter_types::Spanned for TokenTreeChildren<'_> {
12868 fn span(&self) -> ::treesitter_types::Span {
12869 match self {
12870 Self::Literal(inner) => inner.span(),
12871 Self::Crate(inner) => inner.span(),
12872 Self::Identifier(inner) => inner.span(),
12873 Self::Metavariable(inner) => inner.span(),
12874 Self::MutableSpecifier(inner) => inner.span(),
12875 Self::PrimitiveType(inner) => inner.span(),
12876 Self::SelfType(inner) => inner.span(),
12877 Self::Super(inner) => inner.span(),
12878 Self::TokenRepetition(inner) => inner.span(),
12879 Self::TokenTree(inner) => inner.span(),
12880 }
12881 }
12882}
12883#[derive(Debug, Clone, PartialEq, Eq)]
12884pub enum TokenTreePatternChildren<'tree> {
12885 Literal(::std::boxed::Box<Literal<'tree>>),
12886 Crate(::std::boxed::Box<Crate<'tree>>),
12887 Identifier(::std::boxed::Box<Identifier<'tree>>),
12888 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
12889 MutableSpecifier(::std::boxed::Box<MutableSpecifier<'tree>>),
12890 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12891 SelfType(::std::boxed::Box<SelfType<'tree>>),
12892 Super(::std::boxed::Box<Super<'tree>>),
12893 TokenBindingPattern(::std::boxed::Box<TokenBindingPattern<'tree>>),
12894 TokenRepetitionPattern(::std::boxed::Box<TokenRepetitionPattern<'tree>>),
12895 TokenTreePattern(::std::boxed::Box<TokenTreePattern<'tree>>),
12896}
12897impl<'tree> ::treesitter_types::FromNode<'tree> for TokenTreePatternChildren<'tree> {
12898 #[allow(clippy::collapsible_else_if)]
12899 fn from_node(
12900 node: ::tree_sitter::Node<'tree>,
12901 src: &'tree [u8],
12902 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12903 match node.kind() {
12904 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
12905 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
12906 ))),
12907 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12908 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12909 ))),
12910 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
12911 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
12912 ))),
12913 "mutable_specifier" => Ok(Self::MutableSpecifier(::std::boxed::Box::new(
12914 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12915 ))),
12916 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12917 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12918 ))),
12919 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
12920 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
12921 ))),
12922 "super" => Ok(Self::Super(::std::boxed::Box::new(
12923 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
12924 ))),
12925 "token_binding_pattern" => Ok(Self::TokenBindingPattern(::std::boxed::Box::new(
12926 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12927 ))),
12928 "token_repetition_pattern" => Ok(Self::TokenRepetitionPattern(::std::boxed::Box::new(
12929 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12930 ))),
12931 "token_tree_pattern" => Ok(Self::TokenTreePattern(::std::boxed::Box::new(
12932 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12933 ))),
12934 _other => {
12935 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
12936 Ok(Self::Literal(::std::boxed::Box::new(v)))
12937 } else {
12938 Err(::treesitter_types::ParseError::unexpected_kind(
12939 _other, node,
12940 ))
12941 }
12942 }
12943 }
12944 }
12945}
12946impl ::treesitter_types::Spanned for TokenTreePatternChildren<'_> {
12947 fn span(&self) -> ::treesitter_types::Span {
12948 match self {
12949 Self::Literal(inner) => inner.span(),
12950 Self::Crate(inner) => inner.span(),
12951 Self::Identifier(inner) => inner.span(),
12952 Self::Metavariable(inner) => inner.span(),
12953 Self::MutableSpecifier(inner) => inner.span(),
12954 Self::PrimitiveType(inner) => inner.span(),
12955 Self::SelfType(inner) => inner.span(),
12956 Self::Super(inner) => inner.span(),
12957 Self::TokenBindingPattern(inner) => inner.span(),
12958 Self::TokenRepetitionPattern(inner) => inner.span(),
12959 Self::TokenTreePattern(inner) => inner.span(),
12960 }
12961 }
12962}
12963#[derive(Debug, Clone, PartialEq, Eq)]
12964pub enum TraitBoundsChildren<'tree> {
12965 Type(::std::boxed::Box<Type<'tree>>),
12966 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
12967 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
12968}
12969impl<'tree> ::treesitter_types::FromNode<'tree> for TraitBoundsChildren<'tree> {
12970 #[allow(clippy::collapsible_else_if)]
12971 fn from_node(
12972 node: ::tree_sitter::Node<'tree>,
12973 src: &'tree [u8],
12974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12975 match node.kind() {
12976 "higher_ranked_trait_bound" => {
12977 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
12978 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
12979 )))
12980 }
12981 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
12982 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
12983 ))),
12984 _other => {
12985 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
12986 Ok(Self::Type(::std::boxed::Box::new(v)))
12987 } else {
12988 Err(::treesitter_types::ParseError::unexpected_kind(
12989 _other, node,
12990 ))
12991 }
12992 }
12993 }
12994 }
12995}
12996impl ::treesitter_types::Spanned for TraitBoundsChildren<'_> {
12997 fn span(&self) -> ::treesitter_types::Span {
12998 match self {
12999 Self::Type(inner) => inner.span(),
13000 Self::HigherRankedTraitBound(inner) => inner.span(),
13001 Self::Lifetime(inner) => inner.span(),
13002 }
13003 }
13004}
13005#[derive(Debug, Clone, PartialEq, Eq)]
13006pub enum TraitItemChildren<'tree> {
13007 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13008 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
13009}
13010impl<'tree> ::treesitter_types::FromNode<'tree> for TraitItemChildren<'tree> {
13011 #[allow(clippy::collapsible_else_if)]
13012 fn from_node(
13013 node: ::tree_sitter::Node<'tree>,
13014 src: &'tree [u8],
13015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13016 match node.kind() {
13017 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13018 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13019 ))),
13020 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
13021 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13022 ))),
13023 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13024 }
13025 }
13026}
13027impl ::treesitter_types::Spanned for TraitItemChildren<'_> {
13028 fn span(&self) -> ::treesitter_types::Span {
13029 match self {
13030 Self::VisibilityModifier(inner) => inner.span(),
13031 Self::WhereClause(inner) => inner.span(),
13032 }
13033 }
13034}
13035#[derive(Debug, Clone, PartialEq, Eq)]
13036pub enum TupleExpressionChildren<'tree> {
13037 Expression(::std::boxed::Box<Expression<'tree>>),
13038 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
13039}
13040impl<'tree> ::treesitter_types::FromNode<'tree> for TupleExpressionChildren<'tree> {
13041 #[allow(clippy::collapsible_else_if)]
13042 fn from_node(
13043 node: ::tree_sitter::Node<'tree>,
13044 src: &'tree [u8],
13045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13046 match node.kind() {
13047 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
13048 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
13049 ))),
13050 _other => {
13051 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13052 Ok(Self::Expression(::std::boxed::Box::new(v)))
13053 } else {
13054 Err(::treesitter_types::ParseError::unexpected_kind(
13055 _other, node,
13056 ))
13057 }
13058 }
13059 }
13060 }
13061}
13062impl ::treesitter_types::Spanned for TupleExpressionChildren<'_> {
13063 fn span(&self) -> ::treesitter_types::Span {
13064 match self {
13065 Self::Expression(inner) => inner.span(),
13066 Self::AttributeItem(inner) => inner.span(),
13067 }
13068 }
13069}
13070#[derive(Debug, Clone, PartialEq, Eq)]
13071pub enum TuplePatternChildren<'tree> {
13072 Pattern(::std::boxed::Box<Pattern<'tree>>),
13073 ClosureExpression(::std::boxed::Box<ClosureExpression<'tree>>),
13074}
13075impl<'tree> ::treesitter_types::FromNode<'tree> for TuplePatternChildren<'tree> {
13076 #[allow(clippy::collapsible_else_if)]
13077 fn from_node(
13078 node: ::tree_sitter::Node<'tree>,
13079 src: &'tree [u8],
13080 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13081 match node.kind() {
13082 "closure_expression" => Ok(Self::ClosureExpression(::std::boxed::Box::new(
13083 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13084 ))),
13085 _other => {
13086 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
13087 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13088 } else {
13089 Err(::treesitter_types::ParseError::unexpected_kind(
13090 _other, node,
13091 ))
13092 }
13093 }
13094 }
13095 }
13096}
13097impl ::treesitter_types::Spanned for TuplePatternChildren<'_> {
13098 fn span(&self) -> ::treesitter_types::Span {
13099 match self {
13100 Self::Pattern(inner) => inner.span(),
13101 Self::ClosureExpression(inner) => inner.span(),
13102 }
13103 }
13104}
13105#[derive(Debug, Clone, PartialEq, Eq)]
13106pub enum TupleStructPatternType<'tree> {
13107 GenericType(::std::boxed::Box<GenericType<'tree>>),
13108 Identifier(::std::boxed::Box<Identifier<'tree>>),
13109 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13110}
13111impl<'tree> ::treesitter_types::FromNode<'tree> for TupleStructPatternType<'tree> {
13112 #[allow(clippy::collapsible_else_if)]
13113 fn from_node(
13114 node: ::tree_sitter::Node<'tree>,
13115 src: &'tree [u8],
13116 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13117 match node.kind() {
13118 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
13119 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
13120 ))),
13121 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13122 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13123 ))),
13124 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13125 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13126 ))),
13127 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13128 }
13129 }
13130}
13131impl ::treesitter_types::Spanned for TupleStructPatternType<'_> {
13132 fn span(&self) -> ::treesitter_types::Span {
13133 match self {
13134 Self::GenericType(inner) => inner.span(),
13135 Self::Identifier(inner) => inner.span(),
13136 Self::ScopedIdentifier(inner) => inner.span(),
13137 }
13138 }
13139}
13140#[derive(Debug, Clone, PartialEq, Eq)]
13141pub enum TypeArgumentsChildren<'tree> {
13142 Literal(::std::boxed::Box<Literal<'tree>>),
13143 Type(::std::boxed::Box<Type<'tree>>),
13144 Block(::std::boxed::Box<Block<'tree>>),
13145 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
13146 TraitBounds(::std::boxed::Box<TraitBounds<'tree>>),
13147 TypeBinding(::std::boxed::Box<TypeBinding<'tree>>),
13148}
13149impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArgumentsChildren<'tree> {
13150 #[allow(clippy::collapsible_else_if)]
13151 fn from_node(
13152 node: ::tree_sitter::Node<'tree>,
13153 src: &'tree [u8],
13154 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13155 match node.kind() {
13156 "block" => Ok(Self::Block(::std::boxed::Box::new(
13157 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
13158 ))),
13159 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
13160 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
13161 ))),
13162 "trait_bounds" => Ok(Self::TraitBounds(::std::boxed::Box::new(
13163 <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)?,
13164 ))),
13165 "type_binding" => Ok(Self::TypeBinding(::std::boxed::Box::new(
13166 <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)?,
13167 ))),
13168 _other => {
13169 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
13170 Ok(Self::Literal(::std::boxed::Box::new(v)))
13171 } else {
13172 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
13173 Ok(Self::Type(::std::boxed::Box::new(v)))
13174 } else {
13175 Err(::treesitter_types::ParseError::unexpected_kind(
13176 _other, node,
13177 ))
13178 }
13179 }
13180 }
13181 }
13182 }
13183}
13184impl ::treesitter_types::Spanned for TypeArgumentsChildren<'_> {
13185 fn span(&self) -> ::treesitter_types::Span {
13186 match self {
13187 Self::Literal(inner) => inner.span(),
13188 Self::Type(inner) => inner.span(),
13189 Self::Block(inner) => inner.span(),
13190 Self::Lifetime(inner) => inner.span(),
13191 Self::TraitBounds(inner) => inner.span(),
13192 Self::TypeBinding(inner) => inner.span(),
13193 }
13194 }
13195}
13196#[derive(Debug, Clone, PartialEq, Eq)]
13197pub enum TypeItemChildren<'tree> {
13198 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13199 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
13200}
13201impl<'tree> ::treesitter_types::FromNode<'tree> for TypeItemChildren<'tree> {
13202 #[allow(clippy::collapsible_else_if)]
13203 fn from_node(
13204 node: ::tree_sitter::Node<'tree>,
13205 src: &'tree [u8],
13206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13207 match node.kind() {
13208 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13209 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13210 ))),
13211 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
13212 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13213 ))),
13214 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13215 }
13216 }
13217}
13218impl ::treesitter_types::Spanned for TypeItemChildren<'_> {
13219 fn span(&self) -> ::treesitter_types::Span {
13220 match self {
13221 Self::VisibilityModifier(inner) => inner.span(),
13222 Self::WhereClause(inner) => inner.span(),
13223 }
13224 }
13225}
13226#[derive(Debug, Clone, PartialEq, Eq)]
13227pub enum TypeParametersChildren<'tree> {
13228 AttributeItem(::std::boxed::Box<AttributeItem<'tree>>),
13229 ConstParameter(::std::boxed::Box<ConstParameter<'tree>>),
13230 LifetimeParameter(::std::boxed::Box<LifetimeParameter<'tree>>),
13231 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13232 TypeParameter(::std::boxed::Box<TypeParameter<'tree>>),
13233}
13234impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParametersChildren<'tree> {
13235 #[allow(clippy::collapsible_else_if)]
13236 fn from_node(
13237 node: ::tree_sitter::Node<'tree>,
13238 src: &'tree [u8],
13239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13240 match node.kind() {
13241 "attribute_item" => Ok(Self::AttributeItem(::std::boxed::Box::new(
13242 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)?,
13243 ))),
13244 "const_parameter" => Ok(Self::ConstParameter(::std::boxed::Box::new(
13245 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
13246 ))),
13247 "lifetime_parameter" => Ok(Self::LifetimeParameter(::std::boxed::Box::new(
13248 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
13249 ))),
13250 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13251 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13252 ))),
13253 "type_parameter" => Ok(Self::TypeParameter(::std::boxed::Box::new(
13254 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
13255 ))),
13256 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13257 }
13258 }
13259}
13260impl ::treesitter_types::Spanned for TypeParametersChildren<'_> {
13261 fn span(&self) -> ::treesitter_types::Span {
13262 match self {
13263 Self::AttributeItem(inner) => inner.span(),
13264 Self::ConstParameter(inner) => inner.span(),
13265 Self::LifetimeParameter(inner) => inner.span(),
13266 Self::Metavariable(inner) => inner.span(),
13267 Self::TypeParameter(inner) => inner.span(),
13268 }
13269 }
13270}
13271#[derive(Debug, Clone, PartialEq, Eq)]
13272pub enum UnionItemChildren<'tree> {
13273 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13274 WhereClause(::std::boxed::Box<WhereClause<'tree>>),
13275}
13276impl<'tree> ::treesitter_types::FromNode<'tree> for UnionItemChildren<'tree> {
13277 #[allow(clippy::collapsible_else_if)]
13278 fn from_node(
13279 node: ::tree_sitter::Node<'tree>,
13280 src: &'tree [u8],
13281 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13282 match node.kind() {
13283 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13284 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13285 ))),
13286 "where_clause" => Ok(Self::WhereClause(::std::boxed::Box::new(
13287 <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13288 ))),
13289 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13290 }
13291 }
13292}
13293impl ::treesitter_types::Spanned for UnionItemChildren<'_> {
13294 fn span(&self) -> ::treesitter_types::Span {
13295 match self {
13296 Self::VisibilityModifier(inner) => inner.span(),
13297 Self::WhereClause(inner) => inner.span(),
13298 }
13299 }
13300}
13301#[derive(Debug, Clone, PartialEq, Eq)]
13302pub enum UseAsClausePath<'tree> {
13303 Crate(::std::boxed::Box<Crate<'tree>>),
13304 Identifier(::std::boxed::Box<Identifier<'tree>>),
13305 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13306 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13307 SelfType(::std::boxed::Box<SelfType<'tree>>),
13308 Super(::std::boxed::Box<Super<'tree>>),
13309}
13310impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClausePath<'tree> {
13311 #[allow(clippy::collapsible_else_if)]
13312 fn from_node(
13313 node: ::tree_sitter::Node<'tree>,
13314 src: &'tree [u8],
13315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13316 match node.kind() {
13317 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13318 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
13319 ))),
13320 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13321 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13322 ))),
13323 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13324 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13325 ))),
13326 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13327 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13328 ))),
13329 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13330 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
13331 ))),
13332 "super" => Ok(Self::Super(::std::boxed::Box::new(
13333 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
13334 ))),
13335 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13336 }
13337 }
13338}
13339impl ::treesitter_types::Spanned for UseAsClausePath<'_> {
13340 fn span(&self) -> ::treesitter_types::Span {
13341 match self {
13342 Self::Crate(inner) => inner.span(),
13343 Self::Identifier(inner) => inner.span(),
13344 Self::Metavariable(inner) => inner.span(),
13345 Self::ScopedIdentifier(inner) => inner.span(),
13346 Self::SelfType(inner) => inner.span(),
13347 Self::Super(inner) => inner.span(),
13348 }
13349 }
13350}
13351#[derive(Debug, Clone, PartialEq, Eq)]
13352pub enum UseBoundsChildren<'tree> {
13353 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
13354 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13355}
13356impl<'tree> ::treesitter_types::FromNode<'tree> for UseBoundsChildren<'tree> {
13357 #[allow(clippy::collapsible_else_if)]
13358 fn from_node(
13359 node: ::tree_sitter::Node<'tree>,
13360 src: &'tree [u8],
13361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13362 match node.kind() {
13363 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
13364 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
13365 ))),
13366 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13367 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13368 ))),
13369 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13370 }
13371 }
13372}
13373impl ::treesitter_types::Spanned for UseBoundsChildren<'_> {
13374 fn span(&self) -> ::treesitter_types::Span {
13375 match self {
13376 Self::Lifetime(inner) => inner.span(),
13377 Self::TypeIdentifier(inner) => inner.span(),
13378 }
13379 }
13380}
13381#[derive(Debug, Clone, PartialEq, Eq)]
13382pub enum UseDeclarationArgument<'tree> {
13383 Crate(::std::boxed::Box<Crate<'tree>>),
13384 Identifier(::std::boxed::Box<Identifier<'tree>>),
13385 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13386 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13387 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
13388 SelfType(::std::boxed::Box<SelfType<'tree>>),
13389 Super(::std::boxed::Box<Super<'tree>>),
13390 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
13391 UseList(::std::boxed::Box<UseList<'tree>>),
13392 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
13393}
13394impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclarationArgument<'tree> {
13395 #[allow(clippy::collapsible_else_if)]
13396 fn from_node(
13397 node: ::tree_sitter::Node<'tree>,
13398 src: &'tree [u8],
13399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13400 match node.kind() {
13401 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13402 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
13403 ))),
13404 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13405 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13406 ))),
13407 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13408 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13409 ))),
13410 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13411 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13412 ))),
13413 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
13414 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)?,
13415 ))),
13416 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13417 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
13418 ))),
13419 "super" => Ok(Self::Super(::std::boxed::Box::new(
13420 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
13421 ))),
13422 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
13423 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13424 ))),
13425 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
13426 <UseList as ::treesitter_types::FromNode>::from_node(node, src)?,
13427 ))),
13428 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
13429 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
13430 ))),
13431 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13432 }
13433 }
13434}
13435impl ::treesitter_types::Spanned for UseDeclarationArgument<'_> {
13436 fn span(&self) -> ::treesitter_types::Span {
13437 match self {
13438 Self::Crate(inner) => inner.span(),
13439 Self::Identifier(inner) => inner.span(),
13440 Self::Metavariable(inner) => inner.span(),
13441 Self::ScopedIdentifier(inner) => inner.span(),
13442 Self::ScopedUseList(inner) => inner.span(),
13443 Self::SelfType(inner) => inner.span(),
13444 Self::Super(inner) => inner.span(),
13445 Self::UseAsClause(inner) => inner.span(),
13446 Self::UseList(inner) => inner.span(),
13447 Self::UseWildcard(inner) => inner.span(),
13448 }
13449 }
13450}
13451#[derive(Debug, Clone, PartialEq, Eq)]
13452pub enum UseListChildren<'tree> {
13453 Crate(::std::boxed::Box<Crate<'tree>>),
13454 Identifier(::std::boxed::Box<Identifier<'tree>>),
13455 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13456 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13457 ScopedUseList(::std::boxed::Box<ScopedUseList<'tree>>),
13458 SelfType(::std::boxed::Box<SelfType<'tree>>),
13459 Super(::std::boxed::Box<Super<'tree>>),
13460 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
13461 UseList(::std::boxed::Box<UseList<'tree>>),
13462 UseWildcard(::std::boxed::Box<UseWildcard<'tree>>),
13463}
13464impl<'tree> ::treesitter_types::FromNode<'tree> for UseListChildren<'tree> {
13465 #[allow(clippy::collapsible_else_if)]
13466 fn from_node(
13467 node: ::tree_sitter::Node<'tree>,
13468 src: &'tree [u8],
13469 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13470 match node.kind() {
13471 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13472 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
13473 ))),
13474 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13475 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13476 ))),
13477 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13478 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13479 ))),
13480 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13481 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13482 ))),
13483 "scoped_use_list" => Ok(Self::ScopedUseList(::std::boxed::Box::new(
13484 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)?,
13485 ))),
13486 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13487 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
13488 ))),
13489 "super" => Ok(Self::Super(::std::boxed::Box::new(
13490 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
13491 ))),
13492 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
13493 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13494 ))),
13495 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
13496 <UseList as ::treesitter_types::FromNode>::from_node(node, src)?,
13497 ))),
13498 "use_wildcard" => Ok(Self::UseWildcard(::std::boxed::Box::new(
13499 <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
13500 ))),
13501 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13502 }
13503 }
13504}
13505impl ::treesitter_types::Spanned for UseListChildren<'_> {
13506 fn span(&self) -> ::treesitter_types::Span {
13507 match self {
13508 Self::Crate(inner) => inner.span(),
13509 Self::Identifier(inner) => inner.span(),
13510 Self::Metavariable(inner) => inner.span(),
13511 Self::ScopedIdentifier(inner) => inner.span(),
13512 Self::ScopedUseList(inner) => inner.span(),
13513 Self::SelfType(inner) => inner.span(),
13514 Self::Super(inner) => inner.span(),
13515 Self::UseAsClause(inner) => inner.span(),
13516 Self::UseList(inner) => inner.span(),
13517 Self::UseWildcard(inner) => inner.span(),
13518 }
13519 }
13520}
13521#[derive(Debug, Clone, PartialEq, Eq)]
13522pub enum UseWildcardChildren<'tree> {
13523 Crate(::std::boxed::Box<Crate<'tree>>),
13524 Identifier(::std::boxed::Box<Identifier<'tree>>),
13525 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13526 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13527 SelfType(::std::boxed::Box<SelfType<'tree>>),
13528 Super(::std::boxed::Box<Super<'tree>>),
13529}
13530impl<'tree> ::treesitter_types::FromNode<'tree> for UseWildcardChildren<'tree> {
13531 #[allow(clippy::collapsible_else_if)]
13532 fn from_node(
13533 node: ::tree_sitter::Node<'tree>,
13534 src: &'tree [u8],
13535 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13536 match node.kind() {
13537 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13538 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
13539 ))),
13540 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13541 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13542 ))),
13543 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13544 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13545 ))),
13546 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13547 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13548 ))),
13549 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13550 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
13551 ))),
13552 "super" => Ok(Self::Super(::std::boxed::Box::new(
13553 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
13554 ))),
13555 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13556 }
13557 }
13558}
13559impl ::treesitter_types::Spanned for UseWildcardChildren<'_> {
13560 fn span(&self) -> ::treesitter_types::Span {
13561 match self {
13562 Self::Crate(inner) => inner.span(),
13563 Self::Identifier(inner) => inner.span(),
13564 Self::Metavariable(inner) => inner.span(),
13565 Self::ScopedIdentifier(inner) => inner.span(),
13566 Self::SelfType(inner) => inner.span(),
13567 Self::Super(inner) => inner.span(),
13568 }
13569 }
13570}
13571#[derive(Debug, Clone, PartialEq, Eq)]
13572pub enum VisibilityModifierChildren<'tree> {
13573 Crate(::std::boxed::Box<Crate<'tree>>),
13574 Identifier(::std::boxed::Box<Identifier<'tree>>),
13575 Metavariable(::std::boxed::Box<Metavariable<'tree>>),
13576 ScopedIdentifier(::std::boxed::Box<ScopedIdentifier<'tree>>),
13577 SelfType(::std::boxed::Box<SelfType<'tree>>),
13578 Super(::std::boxed::Box<Super<'tree>>),
13579}
13580impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifierChildren<'tree> {
13581 #[allow(clippy::collapsible_else_if)]
13582 fn from_node(
13583 node: ::tree_sitter::Node<'tree>,
13584 src: &'tree [u8],
13585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13586 match node.kind() {
13587 "crate" => Ok(Self::Crate(::std::boxed::Box::new(
13588 <Crate as ::treesitter_types::FromNode>::from_node(node, src)?,
13589 ))),
13590 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13591 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13592 ))),
13593 "metavariable" => Ok(Self::Metavariable(::std::boxed::Box::new(
13594 <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)?,
13595 ))),
13596 "scoped_identifier" => Ok(Self::ScopedIdentifier(::std::boxed::Box::new(
13597 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13598 ))),
13599 "self" => Ok(Self::SelfType(::std::boxed::Box::new(
13600 <SelfType as ::treesitter_types::FromNode>::from_node(node, src)?,
13601 ))),
13602 "super" => Ok(Self::Super(::std::boxed::Box::new(
13603 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
13604 ))),
13605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13606 }
13607 }
13608}
13609impl ::treesitter_types::Spanned for VisibilityModifierChildren<'_> {
13610 fn span(&self) -> ::treesitter_types::Span {
13611 match self {
13612 Self::Crate(inner) => inner.span(),
13613 Self::Identifier(inner) => inner.span(),
13614 Self::Metavariable(inner) => inner.span(),
13615 Self::ScopedIdentifier(inner) => inner.span(),
13616 Self::SelfType(inner) => inner.span(),
13617 Self::Super(inner) => inner.span(),
13618 }
13619 }
13620}
13621#[derive(Debug, Clone, PartialEq, Eq)]
13622pub enum WherePredicateLeft<'tree> {
13623 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
13624 GenericType(::std::boxed::Box<GenericType<'tree>>),
13625 HigherRankedTraitBound(::std::boxed::Box<HigherRankedTraitBound<'tree>>),
13626 Lifetime(::std::boxed::Box<Lifetime<'tree>>),
13627 PointerType(::std::boxed::Box<PointerType<'tree>>),
13628 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13629 ReferenceType(::std::boxed::Box<ReferenceType<'tree>>),
13630 ScopedTypeIdentifier(::std::boxed::Box<ScopedTypeIdentifier<'tree>>),
13631 TupleType(::std::boxed::Box<TupleType<'tree>>),
13632 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13633}
13634impl<'tree> ::treesitter_types::FromNode<'tree> for WherePredicateLeft<'tree> {
13635 #[allow(clippy::collapsible_else_if)]
13636 fn from_node(
13637 node: ::tree_sitter::Node<'tree>,
13638 src: &'tree [u8],
13639 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13640 match node.kind() {
13641 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
13642 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
13643 ))),
13644 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
13645 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
13646 ))),
13647 "higher_ranked_trait_bound" => {
13648 Ok(Self::HigherRankedTraitBound(::std::boxed::Box::new(
13649 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)?,
13650 )))
13651 }
13652 "lifetime" => Ok(Self::Lifetime(::std::boxed::Box::new(
13653 <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)?,
13654 ))),
13655 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
13656 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)?,
13657 ))),
13658 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13659 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
13660 ))),
13661 "reference_type" => Ok(Self::ReferenceType(::std::boxed::Box::new(
13662 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)?,
13663 ))),
13664 "scoped_type_identifier" => Ok(Self::ScopedTypeIdentifier(::std::boxed::Box::new(
13665 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13666 ))),
13667 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
13668 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
13669 ))),
13670 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13671 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13672 ))),
13673 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13674 }
13675 }
13676}
13677impl ::treesitter_types::Spanned for WherePredicateLeft<'_> {
13678 fn span(&self) -> ::treesitter_types::Span {
13679 match self {
13680 Self::ArrayType(inner) => inner.span(),
13681 Self::GenericType(inner) => inner.span(),
13682 Self::HigherRankedTraitBound(inner) => inner.span(),
13683 Self::Lifetime(inner) => inner.span(),
13684 Self::PointerType(inner) => inner.span(),
13685 Self::PrimitiveType(inner) => inner.span(),
13686 Self::ReferenceType(inner) => inner.span(),
13687 Self::ScopedTypeIdentifier(inner) => inner.span(),
13688 Self::TupleType(inner) => inner.span(),
13689 Self::TypeIdentifier(inner) => inner.span(),
13690 }
13691 }
13692}
13693#[derive(Debug, Clone, PartialEq, Eq)]
13694pub enum WhileExpressionCondition<'tree> {
13695 Expression(::std::boxed::Box<Expression<'tree>>),
13696 LetChain(::std::boxed::Box<LetChain<'tree>>),
13697 LetCondition(::std::boxed::Box<LetCondition<'tree>>),
13698}
13699impl<'tree> ::treesitter_types::FromNode<'tree> for WhileExpressionCondition<'tree> {
13700 #[allow(clippy::collapsible_else_if)]
13701 fn from_node(
13702 node: ::tree_sitter::Node<'tree>,
13703 src: &'tree [u8],
13704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13705 match node.kind() {
13706 "let_chain" => Ok(Self::LetChain(::std::boxed::Box::new(
13707 <LetChain as ::treesitter_types::FromNode>::from_node(node, src)?,
13708 ))),
13709 "let_condition" => Ok(Self::LetCondition(::std::boxed::Box::new(
13710 <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)?,
13711 ))),
13712 _other => {
13713 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13714 Ok(Self::Expression(::std::boxed::Box::new(v)))
13715 } else {
13716 Err(::treesitter_types::ParseError::unexpected_kind(
13717 _other, node,
13718 ))
13719 }
13720 }
13721 }
13722 }
13723}
13724impl ::treesitter_types::Spanned for WhileExpressionCondition<'_> {
13725 fn span(&self) -> ::treesitter_types::Span {
13726 match self {
13727 Self::Expression(inner) => inner.span(),
13728 Self::LetChain(inner) => inner.span(),
13729 Self::LetCondition(inner) => inner.span(),
13730 }
13731 }
13732}
13733#[derive(Debug, Clone, PartialEq, Eq)]
13734pub enum AnyNode<'tree> {
13735 DeclarationStatement(DeclarationStatement<'tree>),
13736 Expression(Expression<'tree>),
13737 Literal(Literal<'tree>),
13738 LiteralPattern(LiteralPattern<'tree>),
13739 Pattern(Pattern<'tree>),
13740 Type(Type<'tree>),
13741 AbstractType(AbstractType<'tree>),
13742 Arguments(Arguments<'tree>),
13743 ArrayExpression(ArrayExpression<'tree>),
13744 ArrayType(ArrayType<'tree>),
13745 AssignmentExpression(AssignmentExpression<'tree>),
13746 AssociatedType(AssociatedType<'tree>),
13747 AsyncBlock(AsyncBlock<'tree>),
13748 Attribute(Attribute<'tree>),
13749 AttributeItem(AttributeItem<'tree>),
13750 AwaitExpression(AwaitExpression<'tree>),
13751 BaseFieldInitializer(BaseFieldInitializer<'tree>),
13752 BinaryExpression(BinaryExpression<'tree>),
13753 Block(Block<'tree>),
13754 BlockComment(BlockComment<'tree>),
13755 BooleanLiteral(BooleanLiteral<'tree>),
13756 BoundedType(BoundedType<'tree>),
13757 BracketedType(BracketedType<'tree>),
13758 BreakExpression(BreakExpression<'tree>),
13759 CallExpression(CallExpression<'tree>),
13760 CapturedPattern(CapturedPattern<'tree>),
13761 ClosureExpression(ClosureExpression<'tree>),
13762 ClosureParameters(ClosureParameters<'tree>),
13763 CompoundAssignmentExpr(CompoundAssignmentExpr<'tree>),
13764 ConstBlock(ConstBlock<'tree>),
13765 ConstItem(ConstItem<'tree>),
13766 ConstParameter(ConstParameter<'tree>),
13767 ContinueExpression(ContinueExpression<'tree>),
13768 DeclarationList(DeclarationList<'tree>),
13769 DynamicType(DynamicType<'tree>),
13770 ElseClause(ElseClause<'tree>),
13771 EmptyStatement(EmptyStatement<'tree>),
13772 EnumItem(EnumItem<'tree>),
13773 EnumVariant(EnumVariant<'tree>),
13774 EnumVariantList(EnumVariantList<'tree>),
13775 ExpressionStatement(ExpressionStatement<'tree>),
13776 ExternCrateDeclaration(ExternCrateDeclaration<'tree>),
13777 ExternModifier(ExternModifier<'tree>),
13778 FieldDeclaration(FieldDeclaration<'tree>),
13779 FieldDeclarationList(FieldDeclarationList<'tree>),
13780 FieldExpression(FieldExpression<'tree>),
13781 FieldInitializer(FieldInitializer<'tree>),
13782 FieldInitializerList(FieldInitializerList<'tree>),
13783 FieldPattern(FieldPattern<'tree>),
13784 ForExpression(ForExpression<'tree>),
13785 ForLifetimes(ForLifetimes<'tree>),
13786 ForeignModItem(ForeignModItem<'tree>),
13787 FragmentSpecifier(FragmentSpecifier<'tree>),
13788 FunctionItem(FunctionItem<'tree>),
13789 FunctionModifiers(FunctionModifiers<'tree>),
13790 FunctionSignatureItem(FunctionSignatureItem<'tree>),
13791 FunctionType(FunctionType<'tree>),
13792 GenBlock(GenBlock<'tree>),
13793 GenericFunction(GenericFunction<'tree>),
13794 GenericPattern(GenericPattern<'tree>),
13795 GenericType(GenericType<'tree>),
13796 GenericTypeWithTurbofish(GenericTypeWithTurbofish<'tree>),
13797 HigherRankedTraitBound(HigherRankedTraitBound<'tree>),
13798 IfExpression(IfExpression<'tree>),
13799 ImplItem(ImplItem<'tree>),
13800 IndexExpression(IndexExpression<'tree>),
13801 InnerAttributeItem(InnerAttributeItem<'tree>),
13802 InnerDocCommentMarker(InnerDocCommentMarker<'tree>),
13803 Label(Label<'tree>),
13804 LetChain(LetChain<'tree>),
13805 LetCondition(LetCondition<'tree>),
13806 LetDeclaration(LetDeclaration<'tree>),
13807 Lifetime(Lifetime<'tree>),
13808 LifetimeParameter(LifetimeParameter<'tree>),
13809 LineComment(LineComment<'tree>),
13810 LoopExpression(LoopExpression<'tree>),
13811 MacroDefinition(MacroDefinition<'tree>),
13812 MacroInvocation(MacroInvocation<'tree>),
13813 MacroRule(MacroRule<'tree>),
13814 MatchArm(MatchArm<'tree>),
13815 MatchBlock(MatchBlock<'tree>),
13816 MatchExpression(MatchExpression<'tree>),
13817 MatchPattern(MatchPattern<'tree>),
13818 ModItem(ModItem<'tree>),
13819 MutPattern(MutPattern<'tree>),
13820 NegativeLiteral(NegativeLiteral<'tree>),
13821 NeverType(NeverType<'tree>),
13822 OrPattern(OrPattern<'tree>),
13823 OrderedFieldDeclarationList(OrderedFieldDeclarationList<'tree>),
13824 OuterDocCommentMarker(OuterDocCommentMarker<'tree>),
13825 Parameter(Parameter<'tree>),
13826 Parameters(Parameters<'tree>),
13827 ParenthesizedExpression(ParenthesizedExpression<'tree>),
13828 PointerType(PointerType<'tree>),
13829 QualifiedType(QualifiedType<'tree>),
13830 RangeExpression(RangeExpression<'tree>),
13831 RangePattern(RangePattern<'tree>),
13832 RawStringLiteral(RawStringLiteral<'tree>),
13833 RefPattern(RefPattern<'tree>),
13834 ReferenceExpression(ReferenceExpression<'tree>),
13835 ReferencePattern(ReferencePattern<'tree>),
13836 ReferenceType(ReferenceType<'tree>),
13837 RemainingFieldPattern(RemainingFieldPattern<'tree>),
13838 RemovedTraitBound(RemovedTraitBound<'tree>),
13839 ReturnExpression(ReturnExpression<'tree>),
13840 ScopedIdentifier(ScopedIdentifier<'tree>),
13841 ScopedTypeIdentifier(ScopedTypeIdentifier<'tree>),
13842 ScopedUseList(ScopedUseList<'tree>),
13843 SelfParameter(SelfParameter<'tree>),
13844 ShorthandFieldInitializer(ShorthandFieldInitializer<'tree>),
13845 SlicePattern(SlicePattern<'tree>),
13846 SourceFile(SourceFile<'tree>),
13847 StaticItem(StaticItem<'tree>),
13848 StringLiteral(StringLiteral<'tree>),
13849 StructExpression(StructExpression<'tree>),
13850 StructItem(StructItem<'tree>),
13851 StructPattern(StructPattern<'tree>),
13852 TokenBindingPattern(TokenBindingPattern<'tree>),
13853 TokenRepetition(TokenRepetition<'tree>),
13854 TokenRepetitionPattern(TokenRepetitionPattern<'tree>),
13855 TokenTree(TokenTree<'tree>),
13856 TokenTreePattern(TokenTreePattern<'tree>),
13857 TraitBounds(TraitBounds<'tree>),
13858 TraitItem(TraitItem<'tree>),
13859 TryBlock(TryBlock<'tree>),
13860 TryExpression(TryExpression<'tree>),
13861 TupleExpression(TupleExpression<'tree>),
13862 TuplePattern(TuplePattern<'tree>),
13863 TupleStructPattern(TupleStructPattern<'tree>),
13864 TupleType(TupleType<'tree>),
13865 TypeArguments(TypeArguments<'tree>),
13866 TypeBinding(TypeBinding<'tree>),
13867 TypeCastExpression(TypeCastExpression<'tree>),
13868 TypeItem(TypeItem<'tree>),
13869 TypeParameter(TypeParameter<'tree>),
13870 TypeParameters(TypeParameters<'tree>),
13871 UnaryExpression(UnaryExpression<'tree>),
13872 UnionItem(UnionItem<'tree>),
13873 UnitExpression(UnitExpression<'tree>),
13874 UnitType(UnitType<'tree>),
13875 UnsafeBlock(UnsafeBlock<'tree>),
13876 UseAsClause(UseAsClause<'tree>),
13877 UseBounds(UseBounds<'tree>),
13878 UseDeclaration(UseDeclaration<'tree>),
13879 UseList(UseList<'tree>),
13880 UseWildcard(UseWildcard<'tree>),
13881 VariadicParameter(VariadicParameter<'tree>),
13882 VisibilityModifier(VisibilityModifier<'tree>),
13883 WhereClause(WhereClause<'tree>),
13884 WherePredicate(WherePredicate<'tree>),
13885 WhileExpression(WhileExpression<'tree>),
13886 YieldExpression(YieldExpression<'tree>),
13887 CharLiteral(CharLiteral<'tree>),
13888 Crate(Crate<'tree>),
13889 DocComment(DocComment<'tree>),
13890 EscapeSequence(EscapeSequence<'tree>),
13891 FieldIdentifier(FieldIdentifier<'tree>),
13892 FloatLiteral(FloatLiteral<'tree>),
13893 Identifier(Identifier<'tree>),
13894 IntegerLiteral(IntegerLiteral<'tree>),
13895 Metavariable(Metavariable<'tree>),
13896 MutableSpecifier(MutableSpecifier<'tree>),
13897 PrimitiveType(PrimitiveType<'tree>),
13898 SelfType(SelfType<'tree>),
13899 Shebang(Shebang<'tree>),
13900 ShorthandFieldIdentifier(ShorthandFieldIdentifier<'tree>),
13901 StringContent(StringContent<'tree>),
13902 Super(Super<'tree>),
13903 TypeIdentifier(TypeIdentifier<'tree>),
13904 Unknown(::tree_sitter::Node<'tree>),
13905}
13906impl<'tree> AnyNode<'tree> {
13907 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
13908 match node.kind() {
13909 "_declaration_statement" => {
13910 <DeclarationStatement as ::treesitter_types::FromNode>::from_node(node, src)
13911 .map(Self::DeclarationStatement)
13912 .unwrap_or(Self::Unknown(node))
13913 }
13914 "_expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13915 .map(Self::Expression)
13916 .unwrap_or(Self::Unknown(node)),
13917 "_literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
13918 .map(Self::Literal)
13919 .unwrap_or(Self::Unknown(node)),
13920 "_literal_pattern" => {
13921 <LiteralPattern as ::treesitter_types::FromNode>::from_node(node, src)
13922 .map(Self::LiteralPattern)
13923 .unwrap_or(Self::Unknown(node))
13924 }
13925 "_pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13926 .map(Self::Pattern)
13927 .unwrap_or(Self::Unknown(node)),
13928 "_type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
13929 .map(Self::Type)
13930 .unwrap_or(Self::Unknown(node)),
13931 "abstract_type" => <AbstractType as ::treesitter_types::FromNode>::from_node(node, src)
13932 .map(Self::AbstractType)
13933 .unwrap_or(Self::Unknown(node)),
13934 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
13935 .map(Self::Arguments)
13936 .unwrap_or(Self::Unknown(node)),
13937 "array_expression" => {
13938 <ArrayExpression as ::treesitter_types::FromNode>::from_node(node, src)
13939 .map(Self::ArrayExpression)
13940 .unwrap_or(Self::Unknown(node))
13941 }
13942 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
13943 .map(Self::ArrayType)
13944 .unwrap_or(Self::Unknown(node)),
13945 "assignment_expression" => {
13946 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
13947 .map(Self::AssignmentExpression)
13948 .unwrap_or(Self::Unknown(node))
13949 }
13950 "associated_type" => {
13951 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
13952 .map(Self::AssociatedType)
13953 .unwrap_or(Self::Unknown(node))
13954 }
13955 "async_block" => <AsyncBlock as ::treesitter_types::FromNode>::from_node(node, src)
13956 .map(Self::AsyncBlock)
13957 .unwrap_or(Self::Unknown(node)),
13958 "attribute" => <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
13959 .map(Self::Attribute)
13960 .unwrap_or(Self::Unknown(node)),
13961 "attribute_item" => {
13962 <AttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
13963 .map(Self::AttributeItem)
13964 .unwrap_or(Self::Unknown(node))
13965 }
13966 "await_expression" => {
13967 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
13968 .map(Self::AwaitExpression)
13969 .unwrap_or(Self::Unknown(node))
13970 }
13971 "base_field_initializer" => {
13972 <BaseFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
13973 .map(Self::BaseFieldInitializer)
13974 .unwrap_or(Self::Unknown(node))
13975 }
13976 "binary_expression" => {
13977 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13978 .map(Self::BinaryExpression)
13979 .unwrap_or(Self::Unknown(node))
13980 }
13981 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
13982 .map(Self::Block)
13983 .unwrap_or(Self::Unknown(node)),
13984 "block_comment" => <BlockComment as ::treesitter_types::FromNode>::from_node(node, src)
13985 .map(Self::BlockComment)
13986 .unwrap_or(Self::Unknown(node)),
13987 "boolean_literal" => {
13988 <BooleanLiteral as ::treesitter_types::FromNode>::from_node(node, src)
13989 .map(Self::BooleanLiteral)
13990 .unwrap_or(Self::Unknown(node))
13991 }
13992 "bounded_type" => <BoundedType as ::treesitter_types::FromNode>::from_node(node, src)
13993 .map(Self::BoundedType)
13994 .unwrap_or(Self::Unknown(node)),
13995 "bracketed_type" => {
13996 <BracketedType as ::treesitter_types::FromNode>::from_node(node, src)
13997 .map(Self::BracketedType)
13998 .unwrap_or(Self::Unknown(node))
13999 }
14000 "break_expression" => {
14001 <BreakExpression as ::treesitter_types::FromNode>::from_node(node, src)
14002 .map(Self::BreakExpression)
14003 .unwrap_or(Self::Unknown(node))
14004 }
14005 "call_expression" => {
14006 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14007 .map(Self::CallExpression)
14008 .unwrap_or(Self::Unknown(node))
14009 }
14010 "captured_pattern" => {
14011 <CapturedPattern as ::treesitter_types::FromNode>::from_node(node, src)
14012 .map(Self::CapturedPattern)
14013 .unwrap_or(Self::Unknown(node))
14014 }
14015 "closure_expression" => {
14016 <ClosureExpression as ::treesitter_types::FromNode>::from_node(node, src)
14017 .map(Self::ClosureExpression)
14018 .unwrap_or(Self::Unknown(node))
14019 }
14020 "closure_parameters" => {
14021 <ClosureParameters as ::treesitter_types::FromNode>::from_node(node, src)
14022 .map(Self::ClosureParameters)
14023 .unwrap_or(Self::Unknown(node))
14024 }
14025 "compound_assignment_expr" => {
14026 <CompoundAssignmentExpr as ::treesitter_types::FromNode>::from_node(node, src)
14027 .map(Self::CompoundAssignmentExpr)
14028 .unwrap_or(Self::Unknown(node))
14029 }
14030 "const_block" => <ConstBlock as ::treesitter_types::FromNode>::from_node(node, src)
14031 .map(Self::ConstBlock)
14032 .unwrap_or(Self::Unknown(node)),
14033 "const_item" => <ConstItem as ::treesitter_types::FromNode>::from_node(node, src)
14034 .map(Self::ConstItem)
14035 .unwrap_or(Self::Unknown(node)),
14036 "const_parameter" => {
14037 <ConstParameter as ::treesitter_types::FromNode>::from_node(node, src)
14038 .map(Self::ConstParameter)
14039 .unwrap_or(Self::Unknown(node))
14040 }
14041 "continue_expression" => {
14042 <ContinueExpression as ::treesitter_types::FromNode>::from_node(node, src)
14043 .map(Self::ContinueExpression)
14044 .unwrap_or(Self::Unknown(node))
14045 }
14046 "declaration_list" => {
14047 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
14048 .map(Self::DeclarationList)
14049 .unwrap_or(Self::Unknown(node))
14050 }
14051 "dynamic_type" => <DynamicType as ::treesitter_types::FromNode>::from_node(node, src)
14052 .map(Self::DynamicType)
14053 .unwrap_or(Self::Unknown(node)),
14054 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
14055 .map(Self::ElseClause)
14056 .unwrap_or(Self::Unknown(node)),
14057 "empty_statement" => {
14058 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
14059 .map(Self::EmptyStatement)
14060 .unwrap_or(Self::Unknown(node))
14061 }
14062 "enum_item" => <EnumItem as ::treesitter_types::FromNode>::from_node(node, src)
14063 .map(Self::EnumItem)
14064 .unwrap_or(Self::Unknown(node)),
14065 "enum_variant" => <EnumVariant as ::treesitter_types::FromNode>::from_node(node, src)
14066 .map(Self::EnumVariant)
14067 .unwrap_or(Self::Unknown(node)),
14068 "enum_variant_list" => {
14069 <EnumVariantList as ::treesitter_types::FromNode>::from_node(node, src)
14070 .map(Self::EnumVariantList)
14071 .unwrap_or(Self::Unknown(node))
14072 }
14073 "expression_statement" => {
14074 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
14075 .map(Self::ExpressionStatement)
14076 .unwrap_or(Self::Unknown(node))
14077 }
14078 "extern_crate_declaration" => {
14079 <ExternCrateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14080 .map(Self::ExternCrateDeclaration)
14081 .unwrap_or(Self::Unknown(node))
14082 }
14083 "extern_modifier" => {
14084 <ExternModifier as ::treesitter_types::FromNode>::from_node(node, src)
14085 .map(Self::ExternModifier)
14086 .unwrap_or(Self::Unknown(node))
14087 }
14088 "field_declaration" => {
14089 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14090 .map(Self::FieldDeclaration)
14091 .unwrap_or(Self::Unknown(node))
14092 }
14093 "field_declaration_list" => {
14094 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
14095 .map(Self::FieldDeclarationList)
14096 .unwrap_or(Self::Unknown(node))
14097 }
14098 "field_expression" => {
14099 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
14100 .map(Self::FieldExpression)
14101 .unwrap_or(Self::Unknown(node))
14102 }
14103 "field_initializer" => {
14104 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
14105 .map(Self::FieldInitializer)
14106 .unwrap_or(Self::Unknown(node))
14107 }
14108 "field_initializer_list" => {
14109 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
14110 .map(Self::FieldInitializerList)
14111 .unwrap_or(Self::Unknown(node))
14112 }
14113 "field_pattern" => <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
14114 .map(Self::FieldPattern)
14115 .unwrap_or(Self::Unknown(node)),
14116 "for_expression" => {
14117 <ForExpression as ::treesitter_types::FromNode>::from_node(node, src)
14118 .map(Self::ForExpression)
14119 .unwrap_or(Self::Unknown(node))
14120 }
14121 "for_lifetimes" => <ForLifetimes as ::treesitter_types::FromNode>::from_node(node, src)
14122 .map(Self::ForLifetimes)
14123 .unwrap_or(Self::Unknown(node)),
14124 "foreign_mod_item" => {
14125 <ForeignModItem as ::treesitter_types::FromNode>::from_node(node, src)
14126 .map(Self::ForeignModItem)
14127 .unwrap_or(Self::Unknown(node))
14128 }
14129 "fragment_specifier" => {
14130 <FragmentSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14131 .map(Self::FragmentSpecifier)
14132 .unwrap_or(Self::Unknown(node))
14133 }
14134 "function_item" => <FunctionItem as ::treesitter_types::FromNode>::from_node(node, src)
14135 .map(Self::FunctionItem)
14136 .unwrap_or(Self::Unknown(node)),
14137 "function_modifiers" => {
14138 <FunctionModifiers as ::treesitter_types::FromNode>::from_node(node, src)
14139 .map(Self::FunctionModifiers)
14140 .unwrap_or(Self::Unknown(node))
14141 }
14142 "function_signature_item" => {
14143 <FunctionSignatureItem as ::treesitter_types::FromNode>::from_node(node, src)
14144 .map(Self::FunctionSignatureItem)
14145 .unwrap_or(Self::Unknown(node))
14146 }
14147 "function_type" => <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
14148 .map(Self::FunctionType)
14149 .unwrap_or(Self::Unknown(node)),
14150 "gen_block" => <GenBlock as ::treesitter_types::FromNode>::from_node(node, src)
14151 .map(Self::GenBlock)
14152 .unwrap_or(Self::Unknown(node)),
14153 "generic_function" => {
14154 <GenericFunction as ::treesitter_types::FromNode>::from_node(node, src)
14155 .map(Self::GenericFunction)
14156 .unwrap_or(Self::Unknown(node))
14157 }
14158 "generic_pattern" => {
14159 <GenericPattern as ::treesitter_types::FromNode>::from_node(node, src)
14160 .map(Self::GenericPattern)
14161 .unwrap_or(Self::Unknown(node))
14162 }
14163 "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
14164 .map(Self::GenericType)
14165 .unwrap_or(Self::Unknown(node)),
14166 "generic_type_with_turbofish" => {
14167 <GenericTypeWithTurbofish as ::treesitter_types::FromNode>::from_node(node, src)
14168 .map(Self::GenericTypeWithTurbofish)
14169 .unwrap_or(Self::Unknown(node))
14170 }
14171 "higher_ranked_trait_bound" => {
14172 <HigherRankedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
14173 .map(Self::HigherRankedTraitBound)
14174 .unwrap_or(Self::Unknown(node))
14175 }
14176 "if_expression" => <IfExpression as ::treesitter_types::FromNode>::from_node(node, src)
14177 .map(Self::IfExpression)
14178 .unwrap_or(Self::Unknown(node)),
14179 "impl_item" => <ImplItem as ::treesitter_types::FromNode>::from_node(node, src)
14180 .map(Self::ImplItem)
14181 .unwrap_or(Self::Unknown(node)),
14182 "index_expression" => {
14183 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
14184 .map(Self::IndexExpression)
14185 .unwrap_or(Self::Unknown(node))
14186 }
14187 "inner_attribute_item" => {
14188 <InnerAttributeItem as ::treesitter_types::FromNode>::from_node(node, src)
14189 .map(Self::InnerAttributeItem)
14190 .unwrap_or(Self::Unknown(node))
14191 }
14192 "inner_doc_comment_marker" => {
14193 <InnerDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
14194 .map(Self::InnerDocCommentMarker)
14195 .unwrap_or(Self::Unknown(node))
14196 }
14197 "label" => <Label as ::treesitter_types::FromNode>::from_node(node, src)
14198 .map(Self::Label)
14199 .unwrap_or(Self::Unknown(node)),
14200 "let_chain" => <LetChain as ::treesitter_types::FromNode>::from_node(node, src)
14201 .map(Self::LetChain)
14202 .unwrap_or(Self::Unknown(node)),
14203 "let_condition" => <LetCondition as ::treesitter_types::FromNode>::from_node(node, src)
14204 .map(Self::LetCondition)
14205 .unwrap_or(Self::Unknown(node)),
14206 "let_declaration" => {
14207 <LetDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14208 .map(Self::LetDeclaration)
14209 .unwrap_or(Self::Unknown(node))
14210 }
14211 "lifetime" => <Lifetime as ::treesitter_types::FromNode>::from_node(node, src)
14212 .map(Self::Lifetime)
14213 .unwrap_or(Self::Unknown(node)),
14214 "lifetime_parameter" => {
14215 <LifetimeParameter as ::treesitter_types::FromNode>::from_node(node, src)
14216 .map(Self::LifetimeParameter)
14217 .unwrap_or(Self::Unknown(node))
14218 }
14219 "line_comment" => <LineComment as ::treesitter_types::FromNode>::from_node(node, src)
14220 .map(Self::LineComment)
14221 .unwrap_or(Self::Unknown(node)),
14222 "loop_expression" => {
14223 <LoopExpression as ::treesitter_types::FromNode>::from_node(node, src)
14224 .map(Self::LoopExpression)
14225 .unwrap_or(Self::Unknown(node))
14226 }
14227 "macro_definition" => {
14228 <MacroDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14229 .map(Self::MacroDefinition)
14230 .unwrap_or(Self::Unknown(node))
14231 }
14232 "macro_invocation" => {
14233 <MacroInvocation as ::treesitter_types::FromNode>::from_node(node, src)
14234 .map(Self::MacroInvocation)
14235 .unwrap_or(Self::Unknown(node))
14236 }
14237 "macro_rule" => <MacroRule as ::treesitter_types::FromNode>::from_node(node, src)
14238 .map(Self::MacroRule)
14239 .unwrap_or(Self::Unknown(node)),
14240 "match_arm" => <MatchArm as ::treesitter_types::FromNode>::from_node(node, src)
14241 .map(Self::MatchArm)
14242 .unwrap_or(Self::Unknown(node)),
14243 "match_block" => <MatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
14244 .map(Self::MatchBlock)
14245 .unwrap_or(Self::Unknown(node)),
14246 "match_expression" => {
14247 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
14248 .map(Self::MatchExpression)
14249 .unwrap_or(Self::Unknown(node))
14250 }
14251 "match_pattern" => <MatchPattern as ::treesitter_types::FromNode>::from_node(node, src)
14252 .map(Self::MatchPattern)
14253 .unwrap_or(Self::Unknown(node)),
14254 "mod_item" => <ModItem as ::treesitter_types::FromNode>::from_node(node, src)
14255 .map(Self::ModItem)
14256 .unwrap_or(Self::Unknown(node)),
14257 "mut_pattern" => <MutPattern as ::treesitter_types::FromNode>::from_node(node, src)
14258 .map(Self::MutPattern)
14259 .unwrap_or(Self::Unknown(node)),
14260 "negative_literal" => {
14261 <NegativeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14262 .map(Self::NegativeLiteral)
14263 .unwrap_or(Self::Unknown(node))
14264 }
14265 "never_type" => <NeverType as ::treesitter_types::FromNode>::from_node(node, src)
14266 .map(Self::NeverType)
14267 .unwrap_or(Self::Unknown(node)),
14268 "or_pattern" => <OrPattern as ::treesitter_types::FromNode>::from_node(node, src)
14269 .map(Self::OrPattern)
14270 .unwrap_or(Self::Unknown(node)),
14271 "ordered_field_declaration_list" => {
14272 <OrderedFieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
14273 .map(Self::OrderedFieldDeclarationList)
14274 .unwrap_or(Self::Unknown(node))
14275 }
14276 "outer_doc_comment_marker" => {
14277 <OuterDocCommentMarker as ::treesitter_types::FromNode>::from_node(node, src)
14278 .map(Self::OuterDocCommentMarker)
14279 .unwrap_or(Self::Unknown(node))
14280 }
14281 "parameter" => <Parameter as ::treesitter_types::FromNode>::from_node(node, src)
14282 .map(Self::Parameter)
14283 .unwrap_or(Self::Unknown(node)),
14284 "parameters" => <Parameters as ::treesitter_types::FromNode>::from_node(node, src)
14285 .map(Self::Parameters)
14286 .unwrap_or(Self::Unknown(node)),
14287 "parenthesized_expression" => {
14288 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14289 .map(Self::ParenthesizedExpression)
14290 .unwrap_or(Self::Unknown(node))
14291 }
14292 "pointer_type" => <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
14293 .map(Self::PointerType)
14294 .unwrap_or(Self::Unknown(node)),
14295 "qualified_type" => {
14296 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
14297 .map(Self::QualifiedType)
14298 .unwrap_or(Self::Unknown(node))
14299 }
14300 "range_expression" => {
14301 <RangeExpression as ::treesitter_types::FromNode>::from_node(node, src)
14302 .map(Self::RangeExpression)
14303 .unwrap_or(Self::Unknown(node))
14304 }
14305 "range_pattern" => <RangePattern as ::treesitter_types::FromNode>::from_node(node, src)
14306 .map(Self::RangePattern)
14307 .unwrap_or(Self::Unknown(node)),
14308 "raw_string_literal" => {
14309 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14310 .map(Self::RawStringLiteral)
14311 .unwrap_or(Self::Unknown(node))
14312 }
14313 "ref_pattern" => <RefPattern as ::treesitter_types::FromNode>::from_node(node, src)
14314 .map(Self::RefPattern)
14315 .unwrap_or(Self::Unknown(node)),
14316 "reference_expression" => {
14317 <ReferenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
14318 .map(Self::ReferenceExpression)
14319 .unwrap_or(Self::Unknown(node))
14320 }
14321 "reference_pattern" => {
14322 <ReferencePattern as ::treesitter_types::FromNode>::from_node(node, src)
14323 .map(Self::ReferencePattern)
14324 .unwrap_or(Self::Unknown(node))
14325 }
14326 "reference_type" => {
14327 <ReferenceType as ::treesitter_types::FromNode>::from_node(node, src)
14328 .map(Self::ReferenceType)
14329 .unwrap_or(Self::Unknown(node))
14330 }
14331 "remaining_field_pattern" => {
14332 <RemainingFieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
14333 .map(Self::RemainingFieldPattern)
14334 .unwrap_or(Self::Unknown(node))
14335 }
14336 "removed_trait_bound" => {
14337 <RemovedTraitBound as ::treesitter_types::FromNode>::from_node(node, src)
14338 .map(Self::RemovedTraitBound)
14339 .unwrap_or(Self::Unknown(node))
14340 }
14341 "return_expression" => {
14342 <ReturnExpression as ::treesitter_types::FromNode>::from_node(node, src)
14343 .map(Self::ReturnExpression)
14344 .unwrap_or(Self::Unknown(node))
14345 }
14346 "scoped_identifier" => {
14347 <ScopedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14348 .map(Self::ScopedIdentifier)
14349 .unwrap_or(Self::Unknown(node))
14350 }
14351 "scoped_type_identifier" => {
14352 <ScopedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14353 .map(Self::ScopedTypeIdentifier)
14354 .unwrap_or(Self::Unknown(node))
14355 }
14356 "scoped_use_list" => {
14357 <ScopedUseList as ::treesitter_types::FromNode>::from_node(node, src)
14358 .map(Self::ScopedUseList)
14359 .unwrap_or(Self::Unknown(node))
14360 }
14361 "self_parameter" => {
14362 <SelfParameter as ::treesitter_types::FromNode>::from_node(node, src)
14363 .map(Self::SelfParameter)
14364 .unwrap_or(Self::Unknown(node))
14365 }
14366 "shorthand_field_initializer" => {
14367 <ShorthandFieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
14368 .map(Self::ShorthandFieldInitializer)
14369 .unwrap_or(Self::Unknown(node))
14370 }
14371 "slice_pattern" => <SlicePattern as ::treesitter_types::FromNode>::from_node(node, src)
14372 .map(Self::SlicePattern)
14373 .unwrap_or(Self::Unknown(node)),
14374 "source_file" => <SourceFile as ::treesitter_types::FromNode>::from_node(node, src)
14375 .map(Self::SourceFile)
14376 .unwrap_or(Self::Unknown(node)),
14377 "static_item" => <StaticItem as ::treesitter_types::FromNode>::from_node(node, src)
14378 .map(Self::StaticItem)
14379 .unwrap_or(Self::Unknown(node)),
14380 "string_literal" => {
14381 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14382 .map(Self::StringLiteral)
14383 .unwrap_or(Self::Unknown(node))
14384 }
14385 "struct_expression" => {
14386 <StructExpression as ::treesitter_types::FromNode>::from_node(node, src)
14387 .map(Self::StructExpression)
14388 .unwrap_or(Self::Unknown(node))
14389 }
14390 "struct_item" => <StructItem as ::treesitter_types::FromNode>::from_node(node, src)
14391 .map(Self::StructItem)
14392 .unwrap_or(Self::Unknown(node)),
14393 "struct_pattern" => {
14394 <StructPattern as ::treesitter_types::FromNode>::from_node(node, src)
14395 .map(Self::StructPattern)
14396 .unwrap_or(Self::Unknown(node))
14397 }
14398 "token_binding_pattern" => {
14399 <TokenBindingPattern as ::treesitter_types::FromNode>::from_node(node, src)
14400 .map(Self::TokenBindingPattern)
14401 .unwrap_or(Self::Unknown(node))
14402 }
14403 "token_repetition" => {
14404 <TokenRepetition as ::treesitter_types::FromNode>::from_node(node, src)
14405 .map(Self::TokenRepetition)
14406 .unwrap_or(Self::Unknown(node))
14407 }
14408 "token_repetition_pattern" => {
14409 <TokenRepetitionPattern as ::treesitter_types::FromNode>::from_node(node, src)
14410 .map(Self::TokenRepetitionPattern)
14411 .unwrap_or(Self::Unknown(node))
14412 }
14413 "token_tree" => <TokenTree as ::treesitter_types::FromNode>::from_node(node, src)
14414 .map(Self::TokenTree)
14415 .unwrap_or(Self::Unknown(node)),
14416 "token_tree_pattern" => {
14417 <TokenTreePattern as ::treesitter_types::FromNode>::from_node(node, src)
14418 .map(Self::TokenTreePattern)
14419 .unwrap_or(Self::Unknown(node))
14420 }
14421 "trait_bounds" => <TraitBounds as ::treesitter_types::FromNode>::from_node(node, src)
14422 .map(Self::TraitBounds)
14423 .unwrap_or(Self::Unknown(node)),
14424 "trait_item" => <TraitItem as ::treesitter_types::FromNode>::from_node(node, src)
14425 .map(Self::TraitItem)
14426 .unwrap_or(Self::Unknown(node)),
14427 "try_block" => <TryBlock as ::treesitter_types::FromNode>::from_node(node, src)
14428 .map(Self::TryBlock)
14429 .unwrap_or(Self::Unknown(node)),
14430 "try_expression" => {
14431 <TryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14432 .map(Self::TryExpression)
14433 .unwrap_or(Self::Unknown(node))
14434 }
14435 "tuple_expression" => {
14436 <TupleExpression as ::treesitter_types::FromNode>::from_node(node, src)
14437 .map(Self::TupleExpression)
14438 .unwrap_or(Self::Unknown(node))
14439 }
14440 "tuple_pattern" => <TuplePattern as ::treesitter_types::FromNode>::from_node(node, src)
14441 .map(Self::TuplePattern)
14442 .unwrap_or(Self::Unknown(node)),
14443 "tuple_struct_pattern" => {
14444 <TupleStructPattern as ::treesitter_types::FromNode>::from_node(node, src)
14445 .map(Self::TupleStructPattern)
14446 .unwrap_or(Self::Unknown(node))
14447 }
14448 "tuple_type" => <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
14449 .map(Self::TupleType)
14450 .unwrap_or(Self::Unknown(node)),
14451 "type_arguments" => {
14452 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
14453 .map(Self::TypeArguments)
14454 .unwrap_or(Self::Unknown(node))
14455 }
14456 "type_binding" => <TypeBinding as ::treesitter_types::FromNode>::from_node(node, src)
14457 .map(Self::TypeBinding)
14458 .unwrap_or(Self::Unknown(node)),
14459 "type_cast_expression" => {
14460 <TypeCastExpression as ::treesitter_types::FromNode>::from_node(node, src)
14461 .map(Self::TypeCastExpression)
14462 .unwrap_or(Self::Unknown(node))
14463 }
14464 "type_item" => <TypeItem as ::treesitter_types::FromNode>::from_node(node, src)
14465 .map(Self::TypeItem)
14466 .unwrap_or(Self::Unknown(node)),
14467 "type_parameter" => {
14468 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
14469 .map(Self::TypeParameter)
14470 .unwrap_or(Self::Unknown(node))
14471 }
14472 "type_parameters" => {
14473 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
14474 .map(Self::TypeParameters)
14475 .unwrap_or(Self::Unknown(node))
14476 }
14477 "unary_expression" => {
14478 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14479 .map(Self::UnaryExpression)
14480 .unwrap_or(Self::Unknown(node))
14481 }
14482 "union_item" => <UnionItem as ::treesitter_types::FromNode>::from_node(node, src)
14483 .map(Self::UnionItem)
14484 .unwrap_or(Self::Unknown(node)),
14485 "unit_expression" => {
14486 <UnitExpression as ::treesitter_types::FromNode>::from_node(node, src)
14487 .map(Self::UnitExpression)
14488 .unwrap_or(Self::Unknown(node))
14489 }
14490 "unit_type" => <UnitType as ::treesitter_types::FromNode>::from_node(node, src)
14491 .map(Self::UnitType)
14492 .unwrap_or(Self::Unknown(node)),
14493 "unsafe_block" => <UnsafeBlock as ::treesitter_types::FromNode>::from_node(node, src)
14494 .map(Self::UnsafeBlock)
14495 .unwrap_or(Self::Unknown(node)),
14496 "use_as_clause" => <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
14497 .map(Self::UseAsClause)
14498 .unwrap_or(Self::Unknown(node)),
14499 "use_bounds" => <UseBounds as ::treesitter_types::FromNode>::from_node(node, src)
14500 .map(Self::UseBounds)
14501 .unwrap_or(Self::Unknown(node)),
14502 "use_declaration" => {
14503 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14504 .map(Self::UseDeclaration)
14505 .unwrap_or(Self::Unknown(node))
14506 }
14507 "use_list" => <UseList as ::treesitter_types::FromNode>::from_node(node, src)
14508 .map(Self::UseList)
14509 .unwrap_or(Self::Unknown(node)),
14510 "use_wildcard" => <UseWildcard as ::treesitter_types::FromNode>::from_node(node, src)
14511 .map(Self::UseWildcard)
14512 .unwrap_or(Self::Unknown(node)),
14513 "variadic_parameter" => {
14514 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
14515 .map(Self::VariadicParameter)
14516 .unwrap_or(Self::Unknown(node))
14517 }
14518 "visibility_modifier" => {
14519 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
14520 .map(Self::VisibilityModifier)
14521 .unwrap_or(Self::Unknown(node))
14522 }
14523 "where_clause" => <WhereClause as ::treesitter_types::FromNode>::from_node(node, src)
14524 .map(Self::WhereClause)
14525 .unwrap_or(Self::Unknown(node)),
14526 "where_predicate" => {
14527 <WherePredicate as ::treesitter_types::FromNode>::from_node(node, src)
14528 .map(Self::WherePredicate)
14529 .unwrap_or(Self::Unknown(node))
14530 }
14531 "while_expression" => {
14532 <WhileExpression as ::treesitter_types::FromNode>::from_node(node, src)
14533 .map(Self::WhileExpression)
14534 .unwrap_or(Self::Unknown(node))
14535 }
14536 "yield_expression" => {
14537 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
14538 .map(Self::YieldExpression)
14539 .unwrap_or(Self::Unknown(node))
14540 }
14541 "char_literal" => <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14542 .map(Self::CharLiteral)
14543 .unwrap_or(Self::Unknown(node)),
14544 "crate" => <Crate as ::treesitter_types::FromNode>::from_node(node, src)
14545 .map(Self::Crate)
14546 .unwrap_or(Self::Unknown(node)),
14547 "doc_comment" => <DocComment as ::treesitter_types::FromNode>::from_node(node, src)
14548 .map(Self::DocComment)
14549 .unwrap_or(Self::Unknown(node)),
14550 "escape_sequence" => {
14551 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
14552 .map(Self::EscapeSequence)
14553 .unwrap_or(Self::Unknown(node))
14554 }
14555 "field_identifier" => {
14556 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14557 .map(Self::FieldIdentifier)
14558 .unwrap_or(Self::Unknown(node))
14559 }
14560 "float_literal" => <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14561 .map(Self::FloatLiteral)
14562 .unwrap_or(Self::Unknown(node)),
14563 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14564 .map(Self::Identifier)
14565 .unwrap_or(Self::Unknown(node)),
14566 "integer_literal" => {
14567 <IntegerLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14568 .map(Self::IntegerLiteral)
14569 .unwrap_or(Self::Unknown(node))
14570 }
14571 "metavariable" => <Metavariable as ::treesitter_types::FromNode>::from_node(node, src)
14572 .map(Self::Metavariable)
14573 .unwrap_or(Self::Unknown(node)),
14574 "mutable_specifier" => {
14575 <MutableSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14576 .map(Self::MutableSpecifier)
14577 .unwrap_or(Self::Unknown(node))
14578 }
14579 "primitive_type" => {
14580 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
14581 .map(Self::PrimitiveType)
14582 .unwrap_or(Self::Unknown(node))
14583 }
14584 "self" => <SelfType as ::treesitter_types::FromNode>::from_node(node, src)
14585 .map(Self::SelfType)
14586 .unwrap_or(Self::Unknown(node)),
14587 "shebang" => <Shebang as ::treesitter_types::FromNode>::from_node(node, src)
14588 .map(Self::Shebang)
14589 .unwrap_or(Self::Unknown(node)),
14590 "shorthand_field_identifier" => {
14591 <ShorthandFieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14592 .map(Self::ShorthandFieldIdentifier)
14593 .unwrap_or(Self::Unknown(node))
14594 }
14595 "string_content" => {
14596 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
14597 .map(Self::StringContent)
14598 .unwrap_or(Self::Unknown(node))
14599 }
14600 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
14601 .map(Self::Super)
14602 .unwrap_or(Self::Unknown(node)),
14603 "type_identifier" => {
14604 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14605 .map(Self::TypeIdentifier)
14606 .unwrap_or(Self::Unknown(node))
14607 }
14608 _ => Self::Unknown(node),
14609 }
14610 }
14611}
14612impl ::treesitter_types::Spanned for AnyNode<'_> {
14613 fn span(&self) -> ::treesitter_types::Span {
14614 match self {
14615 Self::DeclarationStatement(inner) => inner.span(),
14616 Self::Expression(inner) => inner.span(),
14617 Self::Literal(inner) => inner.span(),
14618 Self::LiteralPattern(inner) => inner.span(),
14619 Self::Pattern(inner) => inner.span(),
14620 Self::Type(inner) => inner.span(),
14621 Self::AbstractType(inner) => inner.span(),
14622 Self::Arguments(inner) => inner.span(),
14623 Self::ArrayExpression(inner) => inner.span(),
14624 Self::ArrayType(inner) => inner.span(),
14625 Self::AssignmentExpression(inner) => inner.span(),
14626 Self::AssociatedType(inner) => inner.span(),
14627 Self::AsyncBlock(inner) => inner.span(),
14628 Self::Attribute(inner) => inner.span(),
14629 Self::AttributeItem(inner) => inner.span(),
14630 Self::AwaitExpression(inner) => inner.span(),
14631 Self::BaseFieldInitializer(inner) => inner.span(),
14632 Self::BinaryExpression(inner) => inner.span(),
14633 Self::Block(inner) => inner.span(),
14634 Self::BlockComment(inner) => inner.span(),
14635 Self::BooleanLiteral(inner) => inner.span(),
14636 Self::BoundedType(inner) => inner.span(),
14637 Self::BracketedType(inner) => inner.span(),
14638 Self::BreakExpression(inner) => inner.span(),
14639 Self::CallExpression(inner) => inner.span(),
14640 Self::CapturedPattern(inner) => inner.span(),
14641 Self::ClosureExpression(inner) => inner.span(),
14642 Self::ClosureParameters(inner) => inner.span(),
14643 Self::CompoundAssignmentExpr(inner) => inner.span(),
14644 Self::ConstBlock(inner) => inner.span(),
14645 Self::ConstItem(inner) => inner.span(),
14646 Self::ConstParameter(inner) => inner.span(),
14647 Self::ContinueExpression(inner) => inner.span(),
14648 Self::DeclarationList(inner) => inner.span(),
14649 Self::DynamicType(inner) => inner.span(),
14650 Self::ElseClause(inner) => inner.span(),
14651 Self::EmptyStatement(inner) => inner.span(),
14652 Self::EnumItem(inner) => inner.span(),
14653 Self::EnumVariant(inner) => inner.span(),
14654 Self::EnumVariantList(inner) => inner.span(),
14655 Self::ExpressionStatement(inner) => inner.span(),
14656 Self::ExternCrateDeclaration(inner) => inner.span(),
14657 Self::ExternModifier(inner) => inner.span(),
14658 Self::FieldDeclaration(inner) => inner.span(),
14659 Self::FieldDeclarationList(inner) => inner.span(),
14660 Self::FieldExpression(inner) => inner.span(),
14661 Self::FieldInitializer(inner) => inner.span(),
14662 Self::FieldInitializerList(inner) => inner.span(),
14663 Self::FieldPattern(inner) => inner.span(),
14664 Self::ForExpression(inner) => inner.span(),
14665 Self::ForLifetimes(inner) => inner.span(),
14666 Self::ForeignModItem(inner) => inner.span(),
14667 Self::FragmentSpecifier(inner) => inner.span(),
14668 Self::FunctionItem(inner) => inner.span(),
14669 Self::FunctionModifiers(inner) => inner.span(),
14670 Self::FunctionSignatureItem(inner) => inner.span(),
14671 Self::FunctionType(inner) => inner.span(),
14672 Self::GenBlock(inner) => inner.span(),
14673 Self::GenericFunction(inner) => inner.span(),
14674 Self::GenericPattern(inner) => inner.span(),
14675 Self::GenericType(inner) => inner.span(),
14676 Self::GenericTypeWithTurbofish(inner) => inner.span(),
14677 Self::HigherRankedTraitBound(inner) => inner.span(),
14678 Self::IfExpression(inner) => inner.span(),
14679 Self::ImplItem(inner) => inner.span(),
14680 Self::IndexExpression(inner) => inner.span(),
14681 Self::InnerAttributeItem(inner) => inner.span(),
14682 Self::InnerDocCommentMarker(inner) => inner.span(),
14683 Self::Label(inner) => inner.span(),
14684 Self::LetChain(inner) => inner.span(),
14685 Self::LetCondition(inner) => inner.span(),
14686 Self::LetDeclaration(inner) => inner.span(),
14687 Self::Lifetime(inner) => inner.span(),
14688 Self::LifetimeParameter(inner) => inner.span(),
14689 Self::LineComment(inner) => inner.span(),
14690 Self::LoopExpression(inner) => inner.span(),
14691 Self::MacroDefinition(inner) => inner.span(),
14692 Self::MacroInvocation(inner) => inner.span(),
14693 Self::MacroRule(inner) => inner.span(),
14694 Self::MatchArm(inner) => inner.span(),
14695 Self::MatchBlock(inner) => inner.span(),
14696 Self::MatchExpression(inner) => inner.span(),
14697 Self::MatchPattern(inner) => inner.span(),
14698 Self::ModItem(inner) => inner.span(),
14699 Self::MutPattern(inner) => inner.span(),
14700 Self::NegativeLiteral(inner) => inner.span(),
14701 Self::NeverType(inner) => inner.span(),
14702 Self::OrPattern(inner) => inner.span(),
14703 Self::OrderedFieldDeclarationList(inner) => inner.span(),
14704 Self::OuterDocCommentMarker(inner) => inner.span(),
14705 Self::Parameter(inner) => inner.span(),
14706 Self::Parameters(inner) => inner.span(),
14707 Self::ParenthesizedExpression(inner) => inner.span(),
14708 Self::PointerType(inner) => inner.span(),
14709 Self::QualifiedType(inner) => inner.span(),
14710 Self::RangeExpression(inner) => inner.span(),
14711 Self::RangePattern(inner) => inner.span(),
14712 Self::RawStringLiteral(inner) => inner.span(),
14713 Self::RefPattern(inner) => inner.span(),
14714 Self::ReferenceExpression(inner) => inner.span(),
14715 Self::ReferencePattern(inner) => inner.span(),
14716 Self::ReferenceType(inner) => inner.span(),
14717 Self::RemainingFieldPattern(inner) => inner.span(),
14718 Self::RemovedTraitBound(inner) => inner.span(),
14719 Self::ReturnExpression(inner) => inner.span(),
14720 Self::ScopedIdentifier(inner) => inner.span(),
14721 Self::ScopedTypeIdentifier(inner) => inner.span(),
14722 Self::ScopedUseList(inner) => inner.span(),
14723 Self::SelfParameter(inner) => inner.span(),
14724 Self::ShorthandFieldInitializer(inner) => inner.span(),
14725 Self::SlicePattern(inner) => inner.span(),
14726 Self::SourceFile(inner) => inner.span(),
14727 Self::StaticItem(inner) => inner.span(),
14728 Self::StringLiteral(inner) => inner.span(),
14729 Self::StructExpression(inner) => inner.span(),
14730 Self::StructItem(inner) => inner.span(),
14731 Self::StructPattern(inner) => inner.span(),
14732 Self::TokenBindingPattern(inner) => inner.span(),
14733 Self::TokenRepetition(inner) => inner.span(),
14734 Self::TokenRepetitionPattern(inner) => inner.span(),
14735 Self::TokenTree(inner) => inner.span(),
14736 Self::TokenTreePattern(inner) => inner.span(),
14737 Self::TraitBounds(inner) => inner.span(),
14738 Self::TraitItem(inner) => inner.span(),
14739 Self::TryBlock(inner) => inner.span(),
14740 Self::TryExpression(inner) => inner.span(),
14741 Self::TupleExpression(inner) => inner.span(),
14742 Self::TuplePattern(inner) => inner.span(),
14743 Self::TupleStructPattern(inner) => inner.span(),
14744 Self::TupleType(inner) => inner.span(),
14745 Self::TypeArguments(inner) => inner.span(),
14746 Self::TypeBinding(inner) => inner.span(),
14747 Self::TypeCastExpression(inner) => inner.span(),
14748 Self::TypeItem(inner) => inner.span(),
14749 Self::TypeParameter(inner) => inner.span(),
14750 Self::TypeParameters(inner) => inner.span(),
14751 Self::UnaryExpression(inner) => inner.span(),
14752 Self::UnionItem(inner) => inner.span(),
14753 Self::UnitExpression(inner) => inner.span(),
14754 Self::UnitType(inner) => inner.span(),
14755 Self::UnsafeBlock(inner) => inner.span(),
14756 Self::UseAsClause(inner) => inner.span(),
14757 Self::UseBounds(inner) => inner.span(),
14758 Self::UseDeclaration(inner) => inner.span(),
14759 Self::UseList(inner) => inner.span(),
14760 Self::UseWildcard(inner) => inner.span(),
14761 Self::VariadicParameter(inner) => inner.span(),
14762 Self::VisibilityModifier(inner) => inner.span(),
14763 Self::WhereClause(inner) => inner.span(),
14764 Self::WherePredicate(inner) => inner.span(),
14765 Self::WhileExpression(inner) => inner.span(),
14766 Self::YieldExpression(inner) => inner.span(),
14767 Self::CharLiteral(inner) => inner.span(),
14768 Self::Crate(inner) => inner.span(),
14769 Self::DocComment(inner) => inner.span(),
14770 Self::EscapeSequence(inner) => inner.span(),
14771 Self::FieldIdentifier(inner) => inner.span(),
14772 Self::FloatLiteral(inner) => inner.span(),
14773 Self::Identifier(inner) => inner.span(),
14774 Self::IntegerLiteral(inner) => inner.span(),
14775 Self::Metavariable(inner) => inner.span(),
14776 Self::MutableSpecifier(inner) => inner.span(),
14777 Self::PrimitiveType(inner) => inner.span(),
14778 Self::SelfType(inner) => inner.span(),
14779 Self::Shebang(inner) => inner.span(),
14780 Self::ShorthandFieldIdentifier(inner) => inner.span(),
14781 Self::StringContent(inner) => inner.span(),
14782 Self::Super(inner) => inner.span(),
14783 Self::TypeIdentifier(inner) => inner.span(),
14784 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
14785 }
14786 }
14787}