1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Expression<'tree> {
3 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
4 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
5 CompositeLiteral(::std::boxed::Box<CompositeLiteral<'tree>>),
6 False(::std::boxed::Box<False<'tree>>),
7 FloatLiteral(::std::boxed::Box<FloatLiteral<'tree>>),
8 FuncLiteral(::std::boxed::Box<FuncLiteral<'tree>>),
9 Identifier(::std::boxed::Box<Identifier<'tree>>),
10 ImaginaryLiteral(::std::boxed::Box<ImaginaryLiteral<'tree>>),
11 IndexExpression(::std::boxed::Box<IndexExpression<'tree>>),
12 IntLiteral(::std::boxed::Box<IntLiteral<'tree>>),
13 InterpretedStringLiteral(::std::boxed::Box<InterpretedStringLiteral<'tree>>),
14 Iota(::std::boxed::Box<Iota<'tree>>),
15 Nil(::std::boxed::Box<Nil<'tree>>),
16 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
18 RuneLiteral(::std::boxed::Box<RuneLiteral<'tree>>),
19 SelectorExpression(::std::boxed::Box<SelectorExpression<'tree>>),
20 SliceExpression(::std::boxed::Box<SliceExpression<'tree>>),
21 True(::std::boxed::Box<True<'tree>>),
22 TypeAssertionExpression(::std::boxed::Box<TypeAssertionExpression<'tree>>),
23 TypeConversionExpression(::std::boxed::Box<TypeConversionExpression<'tree>>),
24 TypeInstantiationExpression(::std::boxed::Box<TypeInstantiationExpression<'tree>>),
25 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
26}
27impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
28 #[allow(clippy::collapsible_else_if)]
29 fn from_node(
30 node: ::treesitter_types::tree_sitter::Node<'tree>,
31 src: &'tree [u8],
32 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
33 match node.kind() {
34 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
35 ::treesitter_types::runtime::maybe_grow_stack(|| {
36 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
37 })?,
38 ))),
39 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
40 ::treesitter_types::runtime::maybe_grow_stack(|| {
41 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
42 })?,
43 ))),
44 "composite_literal" => Ok(Self::CompositeLiteral(::std::boxed::Box::new(
45 ::treesitter_types::runtime::maybe_grow_stack(|| {
46 <CompositeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
47 })?,
48 ))),
49 "false" => Ok(Self::False(::std::boxed::Box::new(
50 ::treesitter_types::runtime::maybe_grow_stack(|| {
51 <False as ::treesitter_types::FromNode>::from_node(node, src)
52 })?,
53 ))),
54 "float_literal" => Ok(Self::FloatLiteral(::std::boxed::Box::new(
55 ::treesitter_types::runtime::maybe_grow_stack(|| {
56 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
57 })?,
58 ))),
59 "func_literal" => Ok(Self::FuncLiteral(::std::boxed::Box::new(
60 ::treesitter_types::runtime::maybe_grow_stack(|| {
61 <FuncLiteral as ::treesitter_types::FromNode>::from_node(node, src)
62 })?,
63 ))),
64 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
65 ::treesitter_types::runtime::maybe_grow_stack(|| {
66 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
67 })?,
68 ))),
69 "imaginary_literal" => Ok(Self::ImaginaryLiteral(::std::boxed::Box::new(
70 ::treesitter_types::runtime::maybe_grow_stack(|| {
71 <ImaginaryLiteral as ::treesitter_types::FromNode>::from_node(node, src)
72 })?,
73 ))),
74 "index_expression" => Ok(Self::IndexExpression(::std::boxed::Box::new(
75 ::treesitter_types::runtime::maybe_grow_stack(|| {
76 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
77 })?,
78 ))),
79 "int_literal" => Ok(Self::IntLiteral(::std::boxed::Box::new(
80 ::treesitter_types::runtime::maybe_grow_stack(|| {
81 <IntLiteral as ::treesitter_types::FromNode>::from_node(node, src)
82 })?,
83 ))),
84 "interpreted_string_literal" => Ok(Self::InterpretedStringLiteral(
85 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
86 <InterpretedStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
87 })?),
88 )),
89 "iota" => Ok(Self::Iota(::std::boxed::Box::new(
90 ::treesitter_types::runtime::maybe_grow_stack(|| {
91 <Iota as ::treesitter_types::FromNode>::from_node(node, src)
92 })?,
93 ))),
94 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
95 ::treesitter_types::runtime::maybe_grow_stack(|| {
96 <Nil as ::treesitter_types::FromNode>::from_node(node, src)
97 })?,
98 ))),
99 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
100 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
101 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
102 })?),
103 )),
104 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
105 ::treesitter_types::runtime::maybe_grow_stack(|| {
106 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
107 })?,
108 ))),
109 "rune_literal" => Ok(Self::RuneLiteral(::std::boxed::Box::new(
110 ::treesitter_types::runtime::maybe_grow_stack(|| {
111 <RuneLiteral as ::treesitter_types::FromNode>::from_node(node, src)
112 })?,
113 ))),
114 "selector_expression" => Ok(Self::SelectorExpression(::std::boxed::Box::new(
115 ::treesitter_types::runtime::maybe_grow_stack(|| {
116 <SelectorExpression as ::treesitter_types::FromNode>::from_node(node, src)
117 })?,
118 ))),
119 "slice_expression" => Ok(Self::SliceExpression(::std::boxed::Box::new(
120 ::treesitter_types::runtime::maybe_grow_stack(|| {
121 <SliceExpression as ::treesitter_types::FromNode>::from_node(node, src)
122 })?,
123 ))),
124 "true" => Ok(Self::True(::std::boxed::Box::new(
125 ::treesitter_types::runtime::maybe_grow_stack(|| {
126 <True as ::treesitter_types::FromNode>::from_node(node, src)
127 })?,
128 ))),
129 "type_assertion_expression" => Ok(Self::TypeAssertionExpression(
130 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
131 <TypeAssertionExpression as ::treesitter_types::FromNode>::from_node(node, src)
132 })?),
133 )),
134 "type_conversion_expression" => Ok(Self::TypeConversionExpression(
135 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
136 <TypeConversionExpression as ::treesitter_types::FromNode>::from_node(node, src)
137 })?),
138 )),
139 "type_instantiation_expression" => Ok(Self::TypeInstantiationExpression(
140 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
141 <TypeInstantiationExpression as ::treesitter_types::FromNode>::from_node(
142 node, src,
143 )
144 })?),
145 )),
146 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
147 ::treesitter_types::runtime::maybe_grow_stack(|| {
148 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
149 })?,
150 ))),
151 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
152 }
153 }
154}
155impl ::treesitter_types::Spanned for Expression<'_> {
156 fn span(&self) -> ::treesitter_types::Span {
157 match self {
158 Self::BinaryExpression(inner) => inner.span(),
159 Self::CallExpression(inner) => inner.span(),
160 Self::CompositeLiteral(inner) => inner.span(),
161 Self::False(inner) => inner.span(),
162 Self::FloatLiteral(inner) => inner.span(),
163 Self::FuncLiteral(inner) => inner.span(),
164 Self::Identifier(inner) => inner.span(),
165 Self::ImaginaryLiteral(inner) => inner.span(),
166 Self::IndexExpression(inner) => inner.span(),
167 Self::IntLiteral(inner) => inner.span(),
168 Self::InterpretedStringLiteral(inner) => inner.span(),
169 Self::Iota(inner) => inner.span(),
170 Self::Nil(inner) => inner.span(),
171 Self::ParenthesizedExpression(inner) => inner.span(),
172 Self::RawStringLiteral(inner) => inner.span(),
173 Self::RuneLiteral(inner) => inner.span(),
174 Self::SelectorExpression(inner) => inner.span(),
175 Self::SliceExpression(inner) => inner.span(),
176 Self::True(inner) => inner.span(),
177 Self::TypeAssertionExpression(inner) => inner.span(),
178 Self::TypeConversionExpression(inner) => inner.span(),
179 Self::TypeInstantiationExpression(inner) => inner.span(),
180 Self::UnaryExpression(inner) => inner.span(),
181 }
182 }
183}
184#[derive(Debug, Clone, PartialEq, Eq)]
185pub enum SimpleStatement<'tree> {
186 AssignmentStatement(::std::boxed::Box<AssignmentStatement<'tree>>),
187 DecStatement(::std::boxed::Box<DecStatement<'tree>>),
188 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
189 IncStatement(::std::boxed::Box<IncStatement<'tree>>),
190 SendStatement(::std::boxed::Box<SendStatement<'tree>>),
191 ShortVarDeclaration(::std::boxed::Box<ShortVarDeclaration<'tree>>),
192}
193impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleStatement<'tree> {
194 #[allow(clippy::collapsible_else_if)]
195 fn from_node(
196 node: ::treesitter_types::tree_sitter::Node<'tree>,
197 src: &'tree [u8],
198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
199 match node.kind() {
200 "assignment_statement" => Ok(Self::AssignmentStatement(::std::boxed::Box::new(
201 ::treesitter_types::runtime::maybe_grow_stack(|| {
202 <AssignmentStatement as ::treesitter_types::FromNode>::from_node(node, src)
203 })?,
204 ))),
205 "dec_statement" => Ok(Self::DecStatement(::std::boxed::Box::new(
206 ::treesitter_types::runtime::maybe_grow_stack(|| {
207 <DecStatement as ::treesitter_types::FromNode>::from_node(node, src)
208 })?,
209 ))),
210 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
211 ::treesitter_types::runtime::maybe_grow_stack(|| {
212 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
213 })?,
214 ))),
215 "inc_statement" => Ok(Self::IncStatement(::std::boxed::Box::new(
216 ::treesitter_types::runtime::maybe_grow_stack(|| {
217 <IncStatement as ::treesitter_types::FromNode>::from_node(node, src)
218 })?,
219 ))),
220 "send_statement" => Ok(Self::SendStatement(::std::boxed::Box::new(
221 ::treesitter_types::runtime::maybe_grow_stack(|| {
222 <SendStatement as ::treesitter_types::FromNode>::from_node(node, src)
223 })?,
224 ))),
225 "short_var_declaration" => Ok(Self::ShortVarDeclaration(::std::boxed::Box::new(
226 ::treesitter_types::runtime::maybe_grow_stack(|| {
227 <ShortVarDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
228 })?,
229 ))),
230 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
231 }
232 }
233}
234impl ::treesitter_types::Spanned for SimpleStatement<'_> {
235 fn span(&self) -> ::treesitter_types::Span {
236 match self {
237 Self::AssignmentStatement(inner) => inner.span(),
238 Self::DecStatement(inner) => inner.span(),
239 Self::ExpressionStatement(inner) => inner.span(),
240 Self::IncStatement(inner) => inner.span(),
241 Self::SendStatement(inner) => inner.span(),
242 Self::ShortVarDeclaration(inner) => inner.span(),
243 }
244 }
245}
246#[derive(Debug, Clone, PartialEq, Eq)]
247pub enum SimpleType<'tree> {
248 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
249 ChannelType(::std::boxed::Box<ChannelType<'tree>>),
250 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
251 GenericType(::std::boxed::Box<GenericType<'tree>>),
252 InterfaceType(::std::boxed::Box<InterfaceType<'tree>>),
253 MapType(::std::boxed::Box<MapType<'tree>>),
254 NegatedType(::std::boxed::Box<NegatedType<'tree>>),
255 PointerType(::std::boxed::Box<PointerType<'tree>>),
256 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
257 SliceType(::std::boxed::Box<SliceType<'tree>>),
258 StructType(::std::boxed::Box<StructType<'tree>>),
259 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
260}
261impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleType<'tree> {
262 #[allow(clippy::collapsible_else_if)]
263 fn from_node(
264 node: ::treesitter_types::tree_sitter::Node<'tree>,
265 src: &'tree [u8],
266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
267 match node.kind() {
268 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
269 ::treesitter_types::runtime::maybe_grow_stack(|| {
270 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
271 })?,
272 ))),
273 "channel_type" => Ok(Self::ChannelType(::std::boxed::Box::new(
274 ::treesitter_types::runtime::maybe_grow_stack(|| {
275 <ChannelType as ::treesitter_types::FromNode>::from_node(node, src)
276 })?,
277 ))),
278 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
279 ::treesitter_types::runtime::maybe_grow_stack(|| {
280 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
281 })?,
282 ))),
283 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
284 ::treesitter_types::runtime::maybe_grow_stack(|| {
285 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
286 })?,
287 ))),
288 "interface_type" => Ok(Self::InterfaceType(::std::boxed::Box::new(
289 ::treesitter_types::runtime::maybe_grow_stack(|| {
290 <InterfaceType as ::treesitter_types::FromNode>::from_node(node, src)
291 })?,
292 ))),
293 "map_type" => Ok(Self::MapType(::std::boxed::Box::new(
294 ::treesitter_types::runtime::maybe_grow_stack(|| {
295 <MapType as ::treesitter_types::FromNode>::from_node(node, src)
296 })?,
297 ))),
298 "negated_type" => Ok(Self::NegatedType(::std::boxed::Box::new(
299 ::treesitter_types::runtime::maybe_grow_stack(|| {
300 <NegatedType as ::treesitter_types::FromNode>::from_node(node, src)
301 })?,
302 ))),
303 "pointer_type" => Ok(Self::PointerType(::std::boxed::Box::new(
304 ::treesitter_types::runtime::maybe_grow_stack(|| {
305 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
306 })?,
307 ))),
308 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
309 ::treesitter_types::runtime::maybe_grow_stack(|| {
310 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
311 })?,
312 ))),
313 "slice_type" => Ok(Self::SliceType(::std::boxed::Box::new(
314 ::treesitter_types::runtime::maybe_grow_stack(|| {
315 <SliceType as ::treesitter_types::FromNode>::from_node(node, src)
316 })?,
317 ))),
318 "struct_type" => Ok(Self::StructType(::std::boxed::Box::new(
319 ::treesitter_types::runtime::maybe_grow_stack(|| {
320 <StructType as ::treesitter_types::FromNode>::from_node(node, src)
321 })?,
322 ))),
323 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
324 ::treesitter_types::runtime::maybe_grow_stack(|| {
325 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
326 })?,
327 ))),
328 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
329 }
330 }
331}
332impl ::treesitter_types::Spanned for SimpleType<'_> {
333 fn span(&self) -> ::treesitter_types::Span {
334 match self {
335 Self::ArrayType(inner) => inner.span(),
336 Self::ChannelType(inner) => inner.span(),
337 Self::FunctionType(inner) => inner.span(),
338 Self::GenericType(inner) => inner.span(),
339 Self::InterfaceType(inner) => inner.span(),
340 Self::MapType(inner) => inner.span(),
341 Self::NegatedType(inner) => inner.span(),
342 Self::PointerType(inner) => inner.span(),
343 Self::QualifiedType(inner) => inner.span(),
344 Self::SliceType(inner) => inner.span(),
345 Self::StructType(inner) => inner.span(),
346 Self::TypeIdentifier(inner) => inner.span(),
347 }
348 }
349}
350#[derive(Debug, Clone, PartialEq, Eq)]
351pub enum Statement<'tree> {
352 SimpleStatement(::std::boxed::Box<SimpleStatement<'tree>>),
353 Block(::std::boxed::Box<Block<'tree>>),
354 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
355 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
356 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
357 DeferStatement(::std::boxed::Box<DeferStatement<'tree>>),
358 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
359 ExpressionSwitchStatement(::std::boxed::Box<ExpressionSwitchStatement<'tree>>),
360 FallthroughStatement(::std::boxed::Box<FallthroughStatement<'tree>>),
361 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
362 GoStatement(::std::boxed::Box<GoStatement<'tree>>),
363 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
364 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
365 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
366 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
367 SelectStatement(::std::boxed::Box<SelectStatement<'tree>>),
368 TypeDeclaration(::std::boxed::Box<TypeDeclaration<'tree>>),
369 TypeSwitchStatement(::std::boxed::Box<TypeSwitchStatement<'tree>>),
370 VarDeclaration(::std::boxed::Box<VarDeclaration<'tree>>),
371}
372impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
373 #[allow(clippy::collapsible_else_if)]
374 fn from_node(
375 node: ::treesitter_types::tree_sitter::Node<'tree>,
376 src: &'tree [u8],
377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
378 match node.kind() {
379 "block" => Ok(Self::Block(::std::boxed::Box::new(
380 ::treesitter_types::runtime::maybe_grow_stack(|| {
381 <Block as ::treesitter_types::FromNode>::from_node(node, src)
382 })?,
383 ))),
384 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
385 ::treesitter_types::runtime::maybe_grow_stack(|| {
386 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
387 })?,
388 ))),
389 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
390 ::treesitter_types::runtime::maybe_grow_stack(|| {
391 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
392 })?,
393 ))),
394 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
395 ::treesitter_types::runtime::maybe_grow_stack(|| {
396 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
397 })?,
398 ))),
399 "defer_statement" => Ok(Self::DeferStatement(::std::boxed::Box::new(
400 ::treesitter_types::runtime::maybe_grow_stack(|| {
401 <DeferStatement as ::treesitter_types::FromNode>::from_node(node, src)
402 })?,
403 ))),
404 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
405 ::treesitter_types::runtime::maybe_grow_stack(|| {
406 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
407 })?,
408 ))),
409 "expression_switch_statement" => Ok(Self::ExpressionSwitchStatement(
410 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
411 <ExpressionSwitchStatement as ::treesitter_types::FromNode>::from_node(
412 node, src,
413 )
414 })?),
415 )),
416 "fallthrough_statement" => Ok(Self::FallthroughStatement(::std::boxed::Box::new(
417 ::treesitter_types::runtime::maybe_grow_stack(|| {
418 <FallthroughStatement as ::treesitter_types::FromNode>::from_node(node, src)
419 })?,
420 ))),
421 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
422 ::treesitter_types::runtime::maybe_grow_stack(|| {
423 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
424 })?,
425 ))),
426 "go_statement" => Ok(Self::GoStatement(::std::boxed::Box::new(
427 ::treesitter_types::runtime::maybe_grow_stack(|| {
428 <GoStatement as ::treesitter_types::FromNode>::from_node(node, src)
429 })?,
430 ))),
431 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
432 ::treesitter_types::runtime::maybe_grow_stack(|| {
433 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
434 })?,
435 ))),
436 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
437 ::treesitter_types::runtime::maybe_grow_stack(|| {
438 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
439 })?,
440 ))),
441 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
442 ::treesitter_types::runtime::maybe_grow_stack(|| {
443 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
444 })?,
445 ))),
446 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
447 ::treesitter_types::runtime::maybe_grow_stack(|| {
448 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
449 })?,
450 ))),
451 "select_statement" => Ok(Self::SelectStatement(::std::boxed::Box::new(
452 ::treesitter_types::runtime::maybe_grow_stack(|| {
453 <SelectStatement as ::treesitter_types::FromNode>::from_node(node, src)
454 })?,
455 ))),
456 "type_declaration" => Ok(Self::TypeDeclaration(::std::boxed::Box::new(
457 ::treesitter_types::runtime::maybe_grow_stack(|| {
458 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
459 })?,
460 ))),
461 "type_switch_statement" => Ok(Self::TypeSwitchStatement(::std::boxed::Box::new(
462 ::treesitter_types::runtime::maybe_grow_stack(|| {
463 <TypeSwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
464 })?,
465 ))),
466 "var_declaration" => Ok(Self::VarDeclaration(::std::boxed::Box::new(
467 ::treesitter_types::runtime::maybe_grow_stack(|| {
468 <VarDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
469 })?,
470 ))),
471 _other => {
472 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
473 <SimpleStatement as ::treesitter_types::FromNode>::from_node(node, src)
474 }) {
475 Ok(Self::SimpleStatement(::std::boxed::Box::new(v)))
476 } else {
477 Err(::treesitter_types::ParseError::unexpected_kind(
478 _other, node,
479 ))
480 }
481 }
482 }
483 }
484}
485impl ::treesitter_types::Spanned for Statement<'_> {
486 fn span(&self) -> ::treesitter_types::Span {
487 match self {
488 Self::SimpleStatement(inner) => inner.span(),
489 Self::Block(inner) => inner.span(),
490 Self::BreakStatement(inner) => inner.span(),
491 Self::ConstDeclaration(inner) => inner.span(),
492 Self::ContinueStatement(inner) => inner.span(),
493 Self::DeferStatement(inner) => inner.span(),
494 Self::EmptyStatement(inner) => inner.span(),
495 Self::ExpressionSwitchStatement(inner) => inner.span(),
496 Self::FallthroughStatement(inner) => inner.span(),
497 Self::ForStatement(inner) => inner.span(),
498 Self::GoStatement(inner) => inner.span(),
499 Self::GotoStatement(inner) => inner.span(),
500 Self::IfStatement(inner) => inner.span(),
501 Self::LabeledStatement(inner) => inner.span(),
502 Self::ReturnStatement(inner) => inner.span(),
503 Self::SelectStatement(inner) => inner.span(),
504 Self::TypeDeclaration(inner) => inner.span(),
505 Self::TypeSwitchStatement(inner) => inner.span(),
506 Self::VarDeclaration(inner) => inner.span(),
507 }
508 }
509}
510#[derive(Debug, Clone, PartialEq, Eq)]
511pub enum Type<'tree> {
512 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
513 ParenthesizedType(::std::boxed::Box<ParenthesizedType<'tree>>),
514}
515impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
516 #[allow(clippy::collapsible_else_if)]
517 fn from_node(
518 node: ::treesitter_types::tree_sitter::Node<'tree>,
519 src: &'tree [u8],
520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
521 match node.kind() {
522 "parenthesized_type" => Ok(Self::ParenthesizedType(::std::boxed::Box::new(
523 ::treesitter_types::runtime::maybe_grow_stack(|| {
524 <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)
525 })?,
526 ))),
527 _other => {
528 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
529 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
530 }) {
531 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
532 } else {
533 Err(::treesitter_types::ParseError::unexpected_kind(
534 _other, node,
535 ))
536 }
537 }
538 }
539 }
540}
541impl ::treesitter_types::Spanned for Type<'_> {
542 fn span(&self) -> ::treesitter_types::Span {
543 match self {
544 Self::SimpleType(inner) => inner.span(),
545 Self::ParenthesizedType(inner) => inner.span(),
546 }
547 }
548}
549#[derive(Debug, Clone, PartialEq, Eq)]
550pub struct ArgumentList<'tree> {
551 pub span: ::treesitter_types::Span,
552 pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
553}
554impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
555 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
556 fn from_node(
557 node: ::treesitter_types::tree_sitter::Node<'tree>,
558 src: &'tree [u8],
559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
560 debug_assert_eq!(node.kind(), "argument_list");
561 Ok(Self {
562 span: ::treesitter_types::Span::from(node),
563 children: {
564 #[allow(clippy::suspicious_else_formatting)]
565 let non_field_children = {
566 let mut cursor = node.walk();
567 let mut result = ::std::vec::Vec::new();
568 if cursor.goto_first_child() {
569 loop {
570 if cursor.field_name().is_none()
571 && cursor.node().is_named()
572 && !cursor.node().is_extra()
573 {
574 result.push(cursor.node());
575 }
576 if !cursor.goto_next_sibling() {
577 break;
578 }
579 }
580 }
581 result
582 };
583 let mut items = ::std::vec::Vec::new();
584 for child in non_field_children {
585 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
586 <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
587 child, src,
588 )
589 })?);
590 }
591 items
592 },
593 })
594 }
595}
596impl ::treesitter_types::Spanned for ArgumentList<'_> {
597 fn span(&self) -> ::treesitter_types::Span {
598 self.span
599 }
600}
601#[derive(Debug, Clone, PartialEq, Eq)]
602pub struct ArrayType<'tree> {
603 pub span: ::treesitter_types::Span,
604 pub element: Type<'tree>,
605 pub length: Expression<'tree>,
606}
607impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
608 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
609 fn from_node(
610 node: ::treesitter_types::tree_sitter::Node<'tree>,
611 src: &'tree [u8],
612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
613 debug_assert_eq!(node.kind(), "array_type");
614 Ok(Self {
615 span: ::treesitter_types::Span::from(node),
616 element: {
617 let child = node.child_by_field_name("element").ok_or_else(|| {
618 ::treesitter_types::ParseError::missing_field("element", node)
619 })?;
620 ::treesitter_types::runtime::maybe_grow_stack(|| {
621 <Type as ::treesitter_types::FromNode>::from_node(child, src)
622 })?
623 },
624 length: {
625 let child = node
626 .child_by_field_name("length")
627 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("length", node))?;
628 ::treesitter_types::runtime::maybe_grow_stack(|| {
629 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
630 })?
631 },
632 })
633 }
634}
635impl ::treesitter_types::Spanned for ArrayType<'_> {
636 fn span(&self) -> ::treesitter_types::Span {
637 self.span
638 }
639}
640#[derive(Debug, Clone, PartialEq, Eq)]
641pub struct AssignmentStatement<'tree> {
642 pub span: ::treesitter_types::Span,
643 pub left: ExpressionList<'tree>,
644 pub operator: AssignmentStatementOperator,
645 pub right: ExpressionList<'tree>,
646}
647impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentStatement<'tree> {
648 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
649 fn from_node(
650 node: ::treesitter_types::tree_sitter::Node<'tree>,
651 src: &'tree [u8],
652 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
653 debug_assert_eq!(node.kind(), "assignment_statement");
654 Ok(Self {
655 span: ::treesitter_types::Span::from(node),
656 left: {
657 let child = node
658 .child_by_field_name("left")
659 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
660 ::treesitter_types::runtime::maybe_grow_stack(|| {
661 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
662 })?
663 },
664 operator: {
665 let child = node.child_by_field_name("operator").ok_or_else(|| {
666 ::treesitter_types::ParseError::missing_field("operator", node)
667 })?;
668 ::treesitter_types::runtime::maybe_grow_stack(|| {
669 <AssignmentStatementOperator as ::treesitter_types::FromNode>::from_node(
670 child, src,
671 )
672 })?
673 },
674 right: {
675 let child = node
676 .child_by_field_name("right")
677 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
678 ::treesitter_types::runtime::maybe_grow_stack(|| {
679 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
680 })?
681 },
682 })
683 }
684}
685impl ::treesitter_types::Spanned for AssignmentStatement<'_> {
686 fn span(&self) -> ::treesitter_types::Span {
687 self.span
688 }
689}
690#[derive(Debug, Clone, PartialEq, Eq)]
691pub struct BinaryExpression<'tree> {
692 pub span: ::treesitter_types::Span,
693 pub left: Expression<'tree>,
694 pub operator: BinaryExpressionOperator,
695 pub right: Expression<'tree>,
696}
697impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
698 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
699 fn from_node(
700 node: ::treesitter_types::tree_sitter::Node<'tree>,
701 src: &'tree [u8],
702 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
703 debug_assert_eq!(node.kind(), "binary_expression");
704 Ok(Self {
705 span: ::treesitter_types::Span::from(node),
706 left: {
707 let child = node
708 .child_by_field_name("left")
709 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
710 ::treesitter_types::runtime::maybe_grow_stack(|| {
711 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
712 })?
713 },
714 operator: {
715 let child = node.child_by_field_name("operator").ok_or_else(|| {
716 ::treesitter_types::ParseError::missing_field("operator", node)
717 })?;
718 ::treesitter_types::runtime::maybe_grow_stack(|| {
719 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
720 child, src,
721 )
722 })?
723 },
724 right: {
725 let child = node
726 .child_by_field_name("right")
727 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
728 ::treesitter_types::runtime::maybe_grow_stack(|| {
729 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
730 })?
731 },
732 })
733 }
734}
735impl ::treesitter_types::Spanned for BinaryExpression<'_> {
736 fn span(&self) -> ::treesitter_types::Span {
737 self.span
738 }
739}
740#[derive(Debug, Clone, PartialEq, Eq)]
741pub struct Block<'tree> {
742 pub span: ::treesitter_types::Span,
743 pub children: ::core::option::Option<StatementList<'tree>>,
744}
745impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
746 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
747 fn from_node(
748 node: ::treesitter_types::tree_sitter::Node<'tree>,
749 src: &'tree [u8],
750 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
751 debug_assert_eq!(node.kind(), "block");
752 Ok(Self {
753 span: ::treesitter_types::Span::from(node),
754 children: {
755 #[allow(clippy::suspicious_else_formatting)]
756 let non_field_children = {
757 let mut cursor = node.walk();
758 let mut result = ::std::vec::Vec::new();
759 if cursor.goto_first_child() {
760 loop {
761 if cursor.field_name().is_none()
762 && cursor.node().is_named()
763 && !cursor.node().is_extra()
764 {
765 result.push(cursor.node());
766 }
767 if !cursor.goto_next_sibling() {
768 break;
769 }
770 }
771 }
772 result
773 };
774 match non_field_children.first() {
775 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
776 <StatementList as ::treesitter_types::FromNode>::from_node(child, src)
777 })?),
778 None => None,
779 }
780 },
781 })
782 }
783}
784impl ::treesitter_types::Spanned for Block<'_> {
785 fn span(&self) -> ::treesitter_types::Span {
786 self.span
787 }
788}
789#[derive(Debug, Clone, PartialEq, Eq)]
790pub struct BreakStatement<'tree> {
791 pub span: ::treesitter_types::Span,
792 pub children: ::core::option::Option<LabelName<'tree>>,
793}
794impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
795 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
796 fn from_node(
797 node: ::treesitter_types::tree_sitter::Node<'tree>,
798 src: &'tree [u8],
799 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
800 debug_assert_eq!(node.kind(), "break_statement");
801 Ok(Self {
802 span: ::treesitter_types::Span::from(node),
803 children: {
804 #[allow(clippy::suspicious_else_formatting)]
805 let non_field_children = {
806 let mut cursor = node.walk();
807 let mut result = ::std::vec::Vec::new();
808 if cursor.goto_first_child() {
809 loop {
810 if cursor.field_name().is_none()
811 && cursor.node().is_named()
812 && !cursor.node().is_extra()
813 {
814 result.push(cursor.node());
815 }
816 if !cursor.goto_next_sibling() {
817 break;
818 }
819 }
820 }
821 result
822 };
823 match non_field_children.first() {
824 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
825 <LabelName as ::treesitter_types::FromNode>::from_node(child, src)
826 })?),
827 None => None,
828 }
829 },
830 })
831 }
832}
833impl ::treesitter_types::Spanned for BreakStatement<'_> {
834 fn span(&self) -> ::treesitter_types::Span {
835 self.span
836 }
837}
838#[derive(Debug, Clone, PartialEq, Eq)]
839pub struct CallExpression<'tree> {
840 pub span: ::treesitter_types::Span,
841 pub arguments: ArgumentList<'tree>,
842 pub function: Expression<'tree>,
843 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
844}
845impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
846 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
847 fn from_node(
848 node: ::treesitter_types::tree_sitter::Node<'tree>,
849 src: &'tree [u8],
850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
851 debug_assert_eq!(node.kind(), "call_expression");
852 Ok(Self {
853 span: ::treesitter_types::Span::from(node),
854 arguments: {
855 let child = node.child_by_field_name("arguments").ok_or_else(|| {
856 ::treesitter_types::ParseError::missing_field("arguments", node)
857 })?;
858 ::treesitter_types::runtime::maybe_grow_stack(|| {
859 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
860 })?
861 },
862 function: {
863 let child = node.child_by_field_name("function").ok_or_else(|| {
864 ::treesitter_types::ParseError::missing_field("function", node)
865 })?;
866 ::treesitter_types::runtime::maybe_grow_stack(|| {
867 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
868 })?
869 },
870 type_arguments: match node.child_by_field_name("type_arguments") {
871 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
872 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
873 })?),
874 None => None,
875 },
876 })
877 }
878}
879impl ::treesitter_types::Spanned for CallExpression<'_> {
880 fn span(&self) -> ::treesitter_types::Span {
881 self.span
882 }
883}
884#[derive(Debug, Clone, PartialEq, Eq)]
885pub struct ChannelType<'tree> {
886 pub span: ::treesitter_types::Span,
887 pub value: Type<'tree>,
888}
889impl<'tree> ::treesitter_types::FromNode<'tree> for ChannelType<'tree> {
890 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
891 fn from_node(
892 node: ::treesitter_types::tree_sitter::Node<'tree>,
893 src: &'tree [u8],
894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
895 debug_assert_eq!(node.kind(), "channel_type");
896 Ok(Self {
897 span: ::treesitter_types::Span::from(node),
898 value: {
899 let child = node
900 .child_by_field_name("value")
901 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
902 ::treesitter_types::runtime::maybe_grow_stack(|| {
903 <Type as ::treesitter_types::FromNode>::from_node(child, src)
904 })?
905 },
906 })
907 }
908}
909impl ::treesitter_types::Spanned for ChannelType<'_> {
910 fn span(&self) -> ::treesitter_types::Span {
911 self.span
912 }
913}
914#[derive(Debug, Clone, PartialEq, Eq)]
915pub struct CommunicationCase<'tree> {
916 pub span: ::treesitter_types::Span,
917 pub communication: CommunicationCaseCommunication<'tree>,
918 pub children: ::core::option::Option<StatementList<'tree>>,
919}
920impl<'tree> ::treesitter_types::FromNode<'tree> for CommunicationCase<'tree> {
921 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
922 fn from_node(
923 node: ::treesitter_types::tree_sitter::Node<'tree>,
924 src: &'tree [u8],
925 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
926 debug_assert_eq!(node.kind(), "communication_case");
927 Ok(Self {
928 span: ::treesitter_types::Span::from(node),
929 communication: {
930 let child = node.child_by_field_name("communication").ok_or_else(|| {
931 ::treesitter_types::ParseError::missing_field("communication", node)
932 })?;
933 ::treesitter_types::runtime::maybe_grow_stack(|| {
934 <CommunicationCaseCommunication as ::treesitter_types::FromNode>::from_node(
935 child, src,
936 )
937 })?
938 },
939 children: {
940 #[allow(clippy::suspicious_else_formatting)]
941 let non_field_children = {
942 let mut cursor = node.walk();
943 let mut result = ::std::vec::Vec::new();
944 if cursor.goto_first_child() {
945 loop {
946 if cursor.field_name().is_none()
947 && cursor.node().is_named()
948 && !cursor.node().is_extra()
949 {
950 result.push(cursor.node());
951 }
952 if !cursor.goto_next_sibling() {
953 break;
954 }
955 }
956 }
957 result
958 };
959 match non_field_children.first() {
960 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
961 <StatementList as ::treesitter_types::FromNode>::from_node(child, src)
962 })?),
963 None => None,
964 }
965 },
966 })
967 }
968}
969impl ::treesitter_types::Spanned for CommunicationCase<'_> {
970 fn span(&self) -> ::treesitter_types::Span {
971 self.span
972 }
973}
974#[derive(Debug, Clone, PartialEq, Eq)]
975pub struct CompositeLiteral<'tree> {
976 pub span: ::treesitter_types::Span,
977 pub body: LiteralValue<'tree>,
978 pub r#type: CompositeLiteralType<'tree>,
979}
980impl<'tree> ::treesitter_types::FromNode<'tree> for CompositeLiteral<'tree> {
981 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
982 fn from_node(
983 node: ::treesitter_types::tree_sitter::Node<'tree>,
984 src: &'tree [u8],
985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
986 debug_assert_eq!(node.kind(), "composite_literal");
987 Ok(Self {
988 span: ::treesitter_types::Span::from(node),
989 body: {
990 let child = node
991 .child_by_field_name("body")
992 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
993 ::treesitter_types::runtime::maybe_grow_stack(|| {
994 <LiteralValue as ::treesitter_types::FromNode>::from_node(child, src)
995 })?
996 },
997 r#type: {
998 let child = node
999 .child_by_field_name("type")
1000 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1001 ::treesitter_types::runtime::maybe_grow_stack(|| {
1002 <CompositeLiteralType as ::treesitter_types::FromNode>::from_node(child, src)
1003 })?
1004 },
1005 })
1006 }
1007}
1008impl ::treesitter_types::Spanned for CompositeLiteral<'_> {
1009 fn span(&self) -> ::treesitter_types::Span {
1010 self.span
1011 }
1012}
1013#[derive(Debug, Clone, PartialEq, Eq)]
1014pub struct ConstDeclaration<'tree> {
1015 pub span: ::treesitter_types::Span,
1016 pub children: ::std::vec::Vec<ConstSpec<'tree>>,
1017}
1018impl<'tree> ::treesitter_types::FromNode<'tree> for ConstDeclaration<'tree> {
1019 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1020 fn from_node(
1021 node: ::treesitter_types::tree_sitter::Node<'tree>,
1022 src: &'tree [u8],
1023 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1024 debug_assert_eq!(node.kind(), "const_declaration");
1025 Ok(Self {
1026 span: ::treesitter_types::Span::from(node),
1027 children: {
1028 #[allow(clippy::suspicious_else_formatting)]
1029 let non_field_children = {
1030 let mut cursor = node.walk();
1031 let mut result = ::std::vec::Vec::new();
1032 if cursor.goto_first_child() {
1033 loop {
1034 if cursor.field_name().is_none()
1035 && cursor.node().is_named()
1036 && !cursor.node().is_extra()
1037 {
1038 result.push(cursor.node());
1039 }
1040 if !cursor.goto_next_sibling() {
1041 break;
1042 }
1043 }
1044 }
1045 result
1046 };
1047 let mut items = ::std::vec::Vec::new();
1048 for child in non_field_children {
1049 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1050 <ConstSpec as ::treesitter_types::FromNode>::from_node(child, src)
1051 })?);
1052 }
1053 items
1054 },
1055 })
1056 }
1057}
1058impl ::treesitter_types::Spanned for ConstDeclaration<'_> {
1059 fn span(&self) -> ::treesitter_types::Span {
1060 self.span
1061 }
1062}
1063#[derive(Debug, Clone, PartialEq, Eq)]
1064pub struct ConstSpec<'tree> {
1065 pub span: ::treesitter_types::Span,
1066 pub name: ::std::vec::Vec<ConstSpecName<'tree>>,
1067 pub r#type: ::core::option::Option<Type<'tree>>,
1068 pub value: ::core::option::Option<ExpressionList<'tree>>,
1069}
1070impl<'tree> ::treesitter_types::FromNode<'tree> for ConstSpec<'tree> {
1071 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1072 fn from_node(
1073 node: ::treesitter_types::tree_sitter::Node<'tree>,
1074 src: &'tree [u8],
1075 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1076 debug_assert_eq!(node.kind(), "const_spec");
1077 Ok(Self {
1078 span: ::treesitter_types::Span::from(node),
1079 name: {
1080 let mut cursor = node.walk();
1081 let mut items = ::std::vec::Vec::new();
1082 for child in node.children_by_field_name("name", &mut cursor) {
1083 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1084 <ConstSpecName as ::treesitter_types::FromNode>::from_node(child, src)
1085 })?);
1086 }
1087 items
1088 },
1089 r#type: match node.child_by_field_name("type") {
1090 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1091 <Type as ::treesitter_types::FromNode>::from_node(child, src)
1092 })?),
1093 None => None,
1094 },
1095 value: match node.child_by_field_name("value") {
1096 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1097 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
1098 })?),
1099 None => None,
1100 },
1101 })
1102 }
1103}
1104impl ::treesitter_types::Spanned for ConstSpec<'_> {
1105 fn span(&self) -> ::treesitter_types::Span {
1106 self.span
1107 }
1108}
1109#[derive(Debug, Clone, PartialEq, Eq)]
1110pub struct ContinueStatement<'tree> {
1111 pub span: ::treesitter_types::Span,
1112 pub children: ::core::option::Option<LabelName<'tree>>,
1113}
1114impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
1115 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1116 fn from_node(
1117 node: ::treesitter_types::tree_sitter::Node<'tree>,
1118 src: &'tree [u8],
1119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1120 debug_assert_eq!(node.kind(), "continue_statement");
1121 Ok(Self {
1122 span: ::treesitter_types::Span::from(node),
1123 children: {
1124 #[allow(clippy::suspicious_else_formatting)]
1125 let non_field_children = {
1126 let mut cursor = node.walk();
1127 let mut result = ::std::vec::Vec::new();
1128 if cursor.goto_first_child() {
1129 loop {
1130 if cursor.field_name().is_none()
1131 && cursor.node().is_named()
1132 && !cursor.node().is_extra()
1133 {
1134 result.push(cursor.node());
1135 }
1136 if !cursor.goto_next_sibling() {
1137 break;
1138 }
1139 }
1140 }
1141 result
1142 };
1143 match non_field_children.first() {
1144 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1145 <LabelName as ::treesitter_types::FromNode>::from_node(child, src)
1146 })?),
1147 None => None,
1148 }
1149 },
1150 })
1151 }
1152}
1153impl ::treesitter_types::Spanned for ContinueStatement<'_> {
1154 fn span(&self) -> ::treesitter_types::Span {
1155 self.span
1156 }
1157}
1158#[derive(Debug, Clone, PartialEq, Eq)]
1159pub struct DecStatement<'tree> {
1160 pub span: ::treesitter_types::Span,
1161 pub children: Expression<'tree>,
1162}
1163impl<'tree> ::treesitter_types::FromNode<'tree> for DecStatement<'tree> {
1164 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1165 fn from_node(
1166 node: ::treesitter_types::tree_sitter::Node<'tree>,
1167 src: &'tree [u8],
1168 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1169 debug_assert_eq!(node.kind(), "dec_statement");
1170 Ok(Self {
1171 span: ::treesitter_types::Span::from(node),
1172 children: {
1173 #[allow(clippy::suspicious_else_formatting)]
1174 let non_field_children = {
1175 let mut cursor = node.walk();
1176 let mut result = ::std::vec::Vec::new();
1177 if cursor.goto_first_child() {
1178 loop {
1179 if cursor.field_name().is_none()
1180 && cursor.node().is_named()
1181 && !cursor.node().is_extra()
1182 {
1183 result.push(cursor.node());
1184 }
1185 if !cursor.goto_next_sibling() {
1186 break;
1187 }
1188 }
1189 }
1190 result
1191 };
1192 let child = if let Some(&c) = non_field_children.first() {
1193 c
1194 } else {
1195 let mut fallback_cursor = node.walk();
1196 let mut fallback_child = None;
1197 if fallback_cursor.goto_first_child() {
1198 loop {
1199 if fallback_cursor.field_name().is_none()
1200 && !fallback_cursor.node().is_extra()
1201 {
1202 let candidate = fallback_cursor.node();
1203 #[allow(clippy::needless_question_mark)]
1204 if (|| -> ::core::result::Result<
1205 _,
1206 ::treesitter_types::ParseError,
1207 > {
1208 let child = candidate;
1209 Ok(
1210 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1211 child,
1212 src,
1213 ))?,
1214 )
1215 })()
1216 .is_ok()
1217 {
1218 fallback_child = Some(candidate);
1219 break;
1220 }
1221 }
1222 if !fallback_cursor.goto_next_sibling() {
1223 break;
1224 }
1225 }
1226 }
1227 if fallback_child.is_none() {
1228 let mut cursor2 = node.walk();
1229 if cursor2.goto_first_child() {
1230 loop {
1231 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1232 let candidate = cursor2.node();
1233 #[allow(clippy::needless_question_mark)]
1234 if (|| -> ::core::result::Result<
1235 _,
1236 ::treesitter_types::ParseError,
1237 > {
1238 let child = candidate;
1239 Ok(
1240 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1241 child,
1242 src,
1243 ))?,
1244 )
1245 })()
1246 .is_ok()
1247 {
1248 fallback_child = Some(candidate);
1249 break;
1250 }
1251 }
1252 if !cursor2.goto_next_sibling() {
1253 break;
1254 }
1255 }
1256 }
1257 }
1258 fallback_child.ok_or_else(|| {
1259 ::treesitter_types::ParseError::missing_field("children", node)
1260 })?
1261 };
1262 ::treesitter_types::runtime::maybe_grow_stack(|| {
1263 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1264 })?
1265 },
1266 })
1267 }
1268}
1269impl ::treesitter_types::Spanned for DecStatement<'_> {
1270 fn span(&self) -> ::treesitter_types::Span {
1271 self.span
1272 }
1273}
1274#[derive(Debug, Clone, PartialEq, Eq)]
1275pub struct DefaultCase<'tree> {
1276 pub span: ::treesitter_types::Span,
1277 pub children: ::core::option::Option<StatementList<'tree>>,
1278}
1279impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultCase<'tree> {
1280 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1281 fn from_node(
1282 node: ::treesitter_types::tree_sitter::Node<'tree>,
1283 src: &'tree [u8],
1284 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1285 debug_assert_eq!(node.kind(), "default_case");
1286 Ok(Self {
1287 span: ::treesitter_types::Span::from(node),
1288 children: {
1289 #[allow(clippy::suspicious_else_formatting)]
1290 let non_field_children = {
1291 let mut cursor = node.walk();
1292 let mut result = ::std::vec::Vec::new();
1293 if cursor.goto_first_child() {
1294 loop {
1295 if cursor.field_name().is_none()
1296 && cursor.node().is_named()
1297 && !cursor.node().is_extra()
1298 {
1299 result.push(cursor.node());
1300 }
1301 if !cursor.goto_next_sibling() {
1302 break;
1303 }
1304 }
1305 }
1306 result
1307 };
1308 match non_field_children.first() {
1309 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1310 <StatementList as ::treesitter_types::FromNode>::from_node(child, src)
1311 })?),
1312 None => None,
1313 }
1314 },
1315 })
1316 }
1317}
1318impl ::treesitter_types::Spanned for DefaultCase<'_> {
1319 fn span(&self) -> ::treesitter_types::Span {
1320 self.span
1321 }
1322}
1323#[derive(Debug, Clone, PartialEq, Eq)]
1324pub struct DeferStatement<'tree> {
1325 pub span: ::treesitter_types::Span,
1326 pub children: Expression<'tree>,
1327}
1328impl<'tree> ::treesitter_types::FromNode<'tree> for DeferStatement<'tree> {
1329 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1330 fn from_node(
1331 node: ::treesitter_types::tree_sitter::Node<'tree>,
1332 src: &'tree [u8],
1333 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1334 debug_assert_eq!(node.kind(), "defer_statement");
1335 Ok(Self {
1336 span: ::treesitter_types::Span::from(node),
1337 children: {
1338 #[allow(clippy::suspicious_else_formatting)]
1339 let non_field_children = {
1340 let mut cursor = node.walk();
1341 let mut result = ::std::vec::Vec::new();
1342 if cursor.goto_first_child() {
1343 loop {
1344 if cursor.field_name().is_none()
1345 && cursor.node().is_named()
1346 && !cursor.node().is_extra()
1347 {
1348 result.push(cursor.node());
1349 }
1350 if !cursor.goto_next_sibling() {
1351 break;
1352 }
1353 }
1354 }
1355 result
1356 };
1357 let child = if let Some(&c) = non_field_children.first() {
1358 c
1359 } else {
1360 let mut fallback_cursor = node.walk();
1361 let mut fallback_child = None;
1362 if fallback_cursor.goto_first_child() {
1363 loop {
1364 if fallback_cursor.field_name().is_none()
1365 && !fallback_cursor.node().is_extra()
1366 {
1367 let candidate = fallback_cursor.node();
1368 #[allow(clippy::needless_question_mark)]
1369 if (|| -> ::core::result::Result<
1370 _,
1371 ::treesitter_types::ParseError,
1372 > {
1373 let child = candidate;
1374 Ok(
1375 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1376 child,
1377 src,
1378 ))?,
1379 )
1380 })()
1381 .is_ok()
1382 {
1383 fallback_child = Some(candidate);
1384 break;
1385 }
1386 }
1387 if !fallback_cursor.goto_next_sibling() {
1388 break;
1389 }
1390 }
1391 }
1392 if fallback_child.is_none() {
1393 let mut cursor2 = node.walk();
1394 if cursor2.goto_first_child() {
1395 loop {
1396 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1397 let candidate = cursor2.node();
1398 #[allow(clippy::needless_question_mark)]
1399 if (|| -> ::core::result::Result<
1400 _,
1401 ::treesitter_types::ParseError,
1402 > {
1403 let child = candidate;
1404 Ok(
1405 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1406 child,
1407 src,
1408 ))?,
1409 )
1410 })()
1411 .is_ok()
1412 {
1413 fallback_child = Some(candidate);
1414 break;
1415 }
1416 }
1417 if !cursor2.goto_next_sibling() {
1418 break;
1419 }
1420 }
1421 }
1422 }
1423 fallback_child.ok_or_else(|| {
1424 ::treesitter_types::ParseError::missing_field("children", node)
1425 })?
1426 };
1427 ::treesitter_types::runtime::maybe_grow_stack(|| {
1428 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1429 })?
1430 },
1431 })
1432 }
1433}
1434impl ::treesitter_types::Spanned for DeferStatement<'_> {
1435 fn span(&self) -> ::treesitter_types::Span {
1436 self.span
1437 }
1438}
1439#[derive(Debug, Clone, PartialEq, Eq)]
1440pub struct Dot<'tree> {
1441 pub span: ::treesitter_types::Span,
1442 text: &'tree str,
1443}
1444impl<'tree> ::treesitter_types::FromNode<'tree> for Dot<'tree> {
1445 fn from_node(
1446 node: ::treesitter_types::tree_sitter::Node<'tree>,
1447 src: &'tree [u8],
1448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1449 debug_assert_eq!(node.kind(), "dot");
1450 Ok(Self {
1451 span: ::treesitter_types::Span::from(node),
1452 text: node.utf8_text(src)?,
1453 })
1454 }
1455}
1456impl<'tree> ::treesitter_types::LeafNode<'tree> for Dot<'tree> {
1457 fn text(&self) -> &'tree str {
1458 self.text
1459 }
1460}
1461impl ::treesitter_types::Spanned for Dot<'_> {
1462 fn span(&self) -> ::treesitter_types::Span {
1463 self.span
1464 }
1465}
1466#[derive(Debug, Clone, PartialEq, Eq)]
1467pub struct EmptyStatement<'tree> {
1468 pub span: ::treesitter_types::Span,
1469 text: &'tree str,
1470}
1471impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
1472 fn from_node(
1473 node: ::treesitter_types::tree_sitter::Node<'tree>,
1474 src: &'tree [u8],
1475 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1476 debug_assert_eq!(node.kind(), "empty_statement");
1477 Ok(Self {
1478 span: ::treesitter_types::Span::from(node),
1479 text: node.utf8_text(src)?,
1480 })
1481 }
1482}
1483impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
1484 fn text(&self) -> &'tree str {
1485 self.text
1486 }
1487}
1488impl ::treesitter_types::Spanned for EmptyStatement<'_> {
1489 fn span(&self) -> ::treesitter_types::Span {
1490 self.span
1491 }
1492}
1493#[derive(Debug, Clone, PartialEq, Eq)]
1494pub struct ExpressionCase<'tree> {
1495 pub span: ::treesitter_types::Span,
1496 pub value: ExpressionList<'tree>,
1497 pub children: ::core::option::Option<StatementList<'tree>>,
1498}
1499impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionCase<'tree> {
1500 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1501 fn from_node(
1502 node: ::treesitter_types::tree_sitter::Node<'tree>,
1503 src: &'tree [u8],
1504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1505 debug_assert_eq!(node.kind(), "expression_case");
1506 Ok(Self {
1507 span: ::treesitter_types::Span::from(node),
1508 value: {
1509 let child = node
1510 .child_by_field_name("value")
1511 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1512 ::treesitter_types::runtime::maybe_grow_stack(|| {
1513 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
1514 })?
1515 },
1516 children: {
1517 #[allow(clippy::suspicious_else_formatting)]
1518 let non_field_children = {
1519 let mut cursor = node.walk();
1520 let mut result = ::std::vec::Vec::new();
1521 if cursor.goto_first_child() {
1522 loop {
1523 if cursor.field_name().is_none()
1524 && cursor.node().is_named()
1525 && !cursor.node().is_extra()
1526 {
1527 result.push(cursor.node());
1528 }
1529 if !cursor.goto_next_sibling() {
1530 break;
1531 }
1532 }
1533 }
1534 result
1535 };
1536 match non_field_children.first() {
1537 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1538 <StatementList as ::treesitter_types::FromNode>::from_node(child, src)
1539 })?),
1540 None => None,
1541 }
1542 },
1543 })
1544 }
1545}
1546impl ::treesitter_types::Spanned for ExpressionCase<'_> {
1547 fn span(&self) -> ::treesitter_types::Span {
1548 self.span
1549 }
1550}
1551#[derive(Debug, Clone, PartialEq, Eq)]
1552pub struct ExpressionList<'tree> {
1553 pub span: ::treesitter_types::Span,
1554 pub children: ::std::vec::Vec<Expression<'tree>>,
1555}
1556impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionList<'tree> {
1557 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1558 fn from_node(
1559 node: ::treesitter_types::tree_sitter::Node<'tree>,
1560 src: &'tree [u8],
1561 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1562 debug_assert_eq!(node.kind(), "expression_list");
1563 Ok(Self {
1564 span: ::treesitter_types::Span::from(node),
1565 children: {
1566 #[allow(clippy::suspicious_else_formatting)]
1567 let non_field_children = {
1568 let mut cursor = node.walk();
1569 let mut result = ::std::vec::Vec::new();
1570 if cursor.goto_first_child() {
1571 loop {
1572 if cursor.field_name().is_none()
1573 && cursor.node().is_named()
1574 && !cursor.node().is_extra()
1575 {
1576 result.push(cursor.node());
1577 }
1578 if !cursor.goto_next_sibling() {
1579 break;
1580 }
1581 }
1582 }
1583 result
1584 };
1585 let mut items = ::std::vec::Vec::new();
1586 for child in non_field_children {
1587 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1588 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1589 })?);
1590 }
1591 items
1592 },
1593 })
1594 }
1595}
1596impl ::treesitter_types::Spanned for ExpressionList<'_> {
1597 fn span(&self) -> ::treesitter_types::Span {
1598 self.span
1599 }
1600}
1601#[derive(Debug, Clone, PartialEq, Eq)]
1602pub struct ExpressionStatement<'tree> {
1603 pub span: ::treesitter_types::Span,
1604 pub children: Expression<'tree>,
1605}
1606impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
1607 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1608 fn from_node(
1609 node: ::treesitter_types::tree_sitter::Node<'tree>,
1610 src: &'tree [u8],
1611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1612 debug_assert_eq!(node.kind(), "expression_statement");
1613 Ok(Self {
1614 span: ::treesitter_types::Span::from(node),
1615 children: {
1616 #[allow(clippy::suspicious_else_formatting)]
1617 let non_field_children = {
1618 let mut cursor = node.walk();
1619 let mut result = ::std::vec::Vec::new();
1620 if cursor.goto_first_child() {
1621 loop {
1622 if cursor.field_name().is_none()
1623 && cursor.node().is_named()
1624 && !cursor.node().is_extra()
1625 {
1626 result.push(cursor.node());
1627 }
1628 if !cursor.goto_next_sibling() {
1629 break;
1630 }
1631 }
1632 }
1633 result
1634 };
1635 let child = if let Some(&c) = non_field_children.first() {
1636 c
1637 } else {
1638 let mut fallback_cursor = node.walk();
1639 let mut fallback_child = None;
1640 if fallback_cursor.goto_first_child() {
1641 loop {
1642 if fallback_cursor.field_name().is_none()
1643 && !fallback_cursor.node().is_extra()
1644 {
1645 let candidate = fallback_cursor.node();
1646 #[allow(clippy::needless_question_mark)]
1647 if (|| -> ::core::result::Result<
1648 _,
1649 ::treesitter_types::ParseError,
1650 > {
1651 let child = candidate;
1652 Ok(
1653 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1654 child,
1655 src,
1656 ))?,
1657 )
1658 })()
1659 .is_ok()
1660 {
1661 fallback_child = Some(candidate);
1662 break;
1663 }
1664 }
1665 if !fallback_cursor.goto_next_sibling() {
1666 break;
1667 }
1668 }
1669 }
1670 if fallback_child.is_none() {
1671 let mut cursor2 = node.walk();
1672 if cursor2.goto_first_child() {
1673 loop {
1674 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1675 let candidate = cursor2.node();
1676 #[allow(clippy::needless_question_mark)]
1677 if (|| -> ::core::result::Result<
1678 _,
1679 ::treesitter_types::ParseError,
1680 > {
1681 let child = candidate;
1682 Ok(
1683 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1684 child,
1685 src,
1686 ))?,
1687 )
1688 })()
1689 .is_ok()
1690 {
1691 fallback_child = Some(candidate);
1692 break;
1693 }
1694 }
1695 if !cursor2.goto_next_sibling() {
1696 break;
1697 }
1698 }
1699 }
1700 }
1701 fallback_child.ok_or_else(|| {
1702 ::treesitter_types::ParseError::missing_field("children", node)
1703 })?
1704 };
1705 ::treesitter_types::runtime::maybe_grow_stack(|| {
1706 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1707 })?
1708 },
1709 })
1710 }
1711}
1712impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
1713 fn span(&self) -> ::treesitter_types::Span {
1714 self.span
1715 }
1716}
1717#[derive(Debug, Clone, PartialEq, Eq)]
1718pub struct ExpressionSwitchStatement<'tree> {
1719 pub span: ::treesitter_types::Span,
1720 pub initializer: ::core::option::Option<SimpleStatement<'tree>>,
1721 pub value: ::core::option::Option<Expression<'tree>>,
1722 pub children: ::std::vec::Vec<ExpressionSwitchStatementChildren<'tree>>,
1723}
1724impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionSwitchStatement<'tree> {
1725 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1726 fn from_node(
1727 node: ::treesitter_types::tree_sitter::Node<'tree>,
1728 src: &'tree [u8],
1729 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1730 debug_assert_eq!(node.kind(), "expression_switch_statement");
1731 Ok(Self {
1732 span: ::treesitter_types::Span::from(node),
1733 initializer: match node.child_by_field_name("initializer") {
1734 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1735 <SimpleStatement as ::treesitter_types::FromNode>::from_node(child, src)
1736 })?),
1737 None => None,
1738 },
1739 value: match node.child_by_field_name("value") {
1740 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1741 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1742 })?),
1743 None => None,
1744 },
1745 children: {
1746 #[allow(clippy::suspicious_else_formatting)]
1747 let non_field_children = {
1748 let mut cursor = node.walk();
1749 let mut result = ::std::vec::Vec::new();
1750 if cursor.goto_first_child() {
1751 loop {
1752 if cursor.field_name().is_none()
1753 && cursor.node().is_named()
1754 && !cursor.node().is_extra()
1755 {
1756 result.push(cursor.node());
1757 }
1758 if !cursor.goto_next_sibling() {
1759 break;
1760 }
1761 }
1762 }
1763 result
1764 };
1765 let mut items = ::std::vec::Vec::new();
1766 for child in non_field_children {
1767 items
1768 .push(
1769 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionSwitchStatementChildren as ::treesitter_types::FromNode>::from_node(
1770 child,
1771 src,
1772 ))?,
1773 );
1774 }
1775 items
1776 },
1777 })
1778 }
1779}
1780impl ::treesitter_types::Spanned for ExpressionSwitchStatement<'_> {
1781 fn span(&self) -> ::treesitter_types::Span {
1782 self.span
1783 }
1784}
1785#[derive(Debug, Clone, PartialEq, Eq)]
1786pub struct FallthroughStatement<'tree> {
1787 pub span: ::treesitter_types::Span,
1788 text: &'tree str,
1789}
1790impl<'tree> ::treesitter_types::FromNode<'tree> for FallthroughStatement<'tree> {
1791 fn from_node(
1792 node: ::treesitter_types::tree_sitter::Node<'tree>,
1793 src: &'tree [u8],
1794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1795 debug_assert_eq!(node.kind(), "fallthrough_statement");
1796 Ok(Self {
1797 span: ::treesitter_types::Span::from(node),
1798 text: node.utf8_text(src)?,
1799 })
1800 }
1801}
1802impl<'tree> ::treesitter_types::LeafNode<'tree> for FallthroughStatement<'tree> {
1803 fn text(&self) -> &'tree str {
1804 self.text
1805 }
1806}
1807impl ::treesitter_types::Spanned for FallthroughStatement<'_> {
1808 fn span(&self) -> ::treesitter_types::Span {
1809 self.span
1810 }
1811}
1812#[derive(Debug, Clone, PartialEq, Eq)]
1813pub struct FieldDeclaration<'tree> {
1814 pub span: ::treesitter_types::Span,
1815 pub name: ::std::vec::Vec<FieldIdentifier<'tree>>,
1816 pub tag: ::core::option::Option<FieldDeclarationTag<'tree>>,
1817 pub r#type: FieldDeclarationType<'tree>,
1818}
1819impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
1820 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1821 fn from_node(
1822 node: ::treesitter_types::tree_sitter::Node<'tree>,
1823 src: &'tree [u8],
1824 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1825 debug_assert_eq!(node.kind(), "field_declaration");
1826 Ok(Self {
1827 span: ::treesitter_types::Span::from(node),
1828 name: {
1829 let mut cursor = node.walk();
1830 let mut items = ::std::vec::Vec::new();
1831 for child in node.children_by_field_name("name", &mut cursor) {
1832 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1833 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
1834 })?);
1835 }
1836 items
1837 },
1838 tag: match node.child_by_field_name("tag") {
1839 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1840 <FieldDeclarationTag as ::treesitter_types::FromNode>::from_node(child, src)
1841 })?),
1842 None => None,
1843 },
1844 r#type: {
1845 let child = node
1846 .child_by_field_name("type")
1847 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1848 ::treesitter_types::runtime::maybe_grow_stack(|| {
1849 <FieldDeclarationType as ::treesitter_types::FromNode>::from_node(child, src)
1850 })?
1851 },
1852 })
1853 }
1854}
1855impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
1856 fn span(&self) -> ::treesitter_types::Span {
1857 self.span
1858 }
1859}
1860#[derive(Debug, Clone, PartialEq, Eq)]
1861pub struct FieldDeclarationList<'tree> {
1862 pub span: ::treesitter_types::Span,
1863 pub children: ::std::vec::Vec<FieldDeclaration<'tree>>,
1864}
1865impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
1866 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1867 fn from_node(
1868 node: ::treesitter_types::tree_sitter::Node<'tree>,
1869 src: &'tree [u8],
1870 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1871 debug_assert_eq!(node.kind(), "field_declaration_list");
1872 Ok(Self {
1873 span: ::treesitter_types::Span::from(node),
1874 children: {
1875 #[allow(clippy::suspicious_else_formatting)]
1876 let non_field_children = {
1877 let mut cursor = node.walk();
1878 let mut result = ::std::vec::Vec::new();
1879 if cursor.goto_first_child() {
1880 loop {
1881 if cursor.field_name().is_none()
1882 && cursor.node().is_named()
1883 && !cursor.node().is_extra()
1884 {
1885 result.push(cursor.node());
1886 }
1887 if !cursor.goto_next_sibling() {
1888 break;
1889 }
1890 }
1891 }
1892 result
1893 };
1894 let mut items = ::std::vec::Vec::new();
1895 for child in non_field_children {
1896 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1897 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(child, src)
1898 })?);
1899 }
1900 items
1901 },
1902 })
1903 }
1904}
1905impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
1906 fn span(&self) -> ::treesitter_types::Span {
1907 self.span
1908 }
1909}
1910#[derive(Debug, Clone, PartialEq, Eq)]
1911pub struct ForClause<'tree> {
1912 pub span: ::treesitter_types::Span,
1913 pub condition: ::core::option::Option<Expression<'tree>>,
1914 pub initializer: ::core::option::Option<SimpleStatement<'tree>>,
1915 pub update: ::core::option::Option<SimpleStatement<'tree>>,
1916}
1917impl<'tree> ::treesitter_types::FromNode<'tree> for ForClause<'tree> {
1918 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1919 fn from_node(
1920 node: ::treesitter_types::tree_sitter::Node<'tree>,
1921 src: &'tree [u8],
1922 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1923 debug_assert_eq!(node.kind(), "for_clause");
1924 Ok(Self {
1925 span: ::treesitter_types::Span::from(node),
1926 condition: match node.child_by_field_name("condition") {
1927 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1928 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1929 })?),
1930 None => None,
1931 },
1932 initializer: match node.child_by_field_name("initializer") {
1933 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1934 <SimpleStatement as ::treesitter_types::FromNode>::from_node(child, src)
1935 })?),
1936 None => None,
1937 },
1938 update: match node.child_by_field_name("update") {
1939 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1940 <SimpleStatement as ::treesitter_types::FromNode>::from_node(child, src)
1941 })?),
1942 None => None,
1943 },
1944 })
1945 }
1946}
1947impl ::treesitter_types::Spanned for ForClause<'_> {
1948 fn span(&self) -> ::treesitter_types::Span {
1949 self.span
1950 }
1951}
1952#[derive(Debug, Clone, PartialEq, Eq)]
1953pub struct ForStatement<'tree> {
1954 pub span: ::treesitter_types::Span,
1955 pub body: Block<'tree>,
1956 pub children: ::core::option::Option<ForStatementChildren<'tree>>,
1957}
1958impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
1959 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1960 fn from_node(
1961 node: ::treesitter_types::tree_sitter::Node<'tree>,
1962 src: &'tree [u8],
1963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1964 debug_assert_eq!(node.kind(), "for_statement");
1965 Ok(Self {
1966 span: ::treesitter_types::Span::from(node),
1967 body: {
1968 let child = node
1969 .child_by_field_name("body")
1970 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1971 ::treesitter_types::runtime::maybe_grow_stack(|| {
1972 <Block as ::treesitter_types::FromNode>::from_node(child, src)
1973 })?
1974 },
1975 children: {
1976 #[allow(clippy::suspicious_else_formatting)]
1977 let non_field_children = {
1978 let mut cursor = node.walk();
1979 let mut result = ::std::vec::Vec::new();
1980 if cursor.goto_first_child() {
1981 loop {
1982 if cursor.field_name().is_none()
1983 && cursor.node().is_named()
1984 && !cursor.node().is_extra()
1985 {
1986 result.push(cursor.node());
1987 }
1988 if !cursor.goto_next_sibling() {
1989 break;
1990 }
1991 }
1992 }
1993 result
1994 };
1995 match non_field_children.first() {
1996 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1997 <ForStatementChildren as ::treesitter_types::FromNode>::from_node(
1998 child, src,
1999 )
2000 })?),
2001 None => None,
2002 }
2003 },
2004 })
2005 }
2006}
2007impl ::treesitter_types::Spanned for ForStatement<'_> {
2008 fn span(&self) -> ::treesitter_types::Span {
2009 self.span
2010 }
2011}
2012#[derive(Debug, Clone, PartialEq, Eq)]
2013pub struct FuncLiteral<'tree> {
2014 pub span: ::treesitter_types::Span,
2015 pub body: Block<'tree>,
2016 pub parameters: ParameterList<'tree>,
2017 pub result: ::core::option::Option<FuncLiteralResult<'tree>>,
2018}
2019impl<'tree> ::treesitter_types::FromNode<'tree> for FuncLiteral<'tree> {
2020 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2021 fn from_node(
2022 node: ::treesitter_types::tree_sitter::Node<'tree>,
2023 src: &'tree [u8],
2024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2025 debug_assert_eq!(node.kind(), "func_literal");
2026 Ok(Self {
2027 span: ::treesitter_types::Span::from(node),
2028 body: {
2029 let child = node
2030 .child_by_field_name("body")
2031 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2032 ::treesitter_types::runtime::maybe_grow_stack(|| {
2033 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2034 })?
2035 },
2036 parameters: {
2037 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2038 ::treesitter_types::ParseError::missing_field("parameters", node)
2039 })?;
2040 ::treesitter_types::runtime::maybe_grow_stack(|| {
2041 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
2042 })?
2043 },
2044 result: match node.child_by_field_name("result") {
2045 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2046 <FuncLiteralResult as ::treesitter_types::FromNode>::from_node(child, src)
2047 })?),
2048 None => None,
2049 },
2050 })
2051 }
2052}
2053impl ::treesitter_types::Spanned for FuncLiteral<'_> {
2054 fn span(&self) -> ::treesitter_types::Span {
2055 self.span
2056 }
2057}
2058#[derive(Debug, Clone, PartialEq, Eq)]
2059pub struct FunctionDeclaration<'tree> {
2060 pub span: ::treesitter_types::Span,
2061 pub body: ::core::option::Option<Block<'tree>>,
2062 pub name: Identifier<'tree>,
2063 pub parameters: ParameterList<'tree>,
2064 pub result: ::core::option::Option<FunctionDeclarationResult<'tree>>,
2065 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
2066}
2067impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
2068 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2069 fn from_node(
2070 node: ::treesitter_types::tree_sitter::Node<'tree>,
2071 src: &'tree [u8],
2072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2073 debug_assert_eq!(node.kind(), "function_declaration");
2074 Ok(Self {
2075 span: ::treesitter_types::Span::from(node),
2076 body: match node.child_by_field_name("body") {
2077 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2078 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2079 })?),
2080 None => None,
2081 },
2082 name: {
2083 let child = node
2084 .child_by_field_name("name")
2085 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2086 ::treesitter_types::runtime::maybe_grow_stack(|| {
2087 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2088 })?
2089 },
2090 parameters: {
2091 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2092 ::treesitter_types::ParseError::missing_field("parameters", node)
2093 })?;
2094 ::treesitter_types::runtime::maybe_grow_stack(|| {
2095 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
2096 })?
2097 },
2098 result: match node.child_by_field_name("result") {
2099 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2100 <FunctionDeclarationResult as ::treesitter_types::FromNode>::from_node(
2101 child, src,
2102 )
2103 })?),
2104 None => None,
2105 },
2106 type_parameters: match node.child_by_field_name("type_parameters") {
2107 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2108 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
2109 })?),
2110 None => None,
2111 },
2112 })
2113 }
2114}
2115impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
2116 fn span(&self) -> ::treesitter_types::Span {
2117 self.span
2118 }
2119}
2120#[derive(Debug, Clone, PartialEq, Eq)]
2121pub struct FunctionType<'tree> {
2122 pub span: ::treesitter_types::Span,
2123 pub parameters: ParameterList<'tree>,
2124 pub result: ::core::option::Option<FunctionTypeResult<'tree>>,
2125}
2126impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
2127 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2128 fn from_node(
2129 node: ::treesitter_types::tree_sitter::Node<'tree>,
2130 src: &'tree [u8],
2131 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2132 debug_assert_eq!(node.kind(), "function_type");
2133 Ok(Self {
2134 span: ::treesitter_types::Span::from(node),
2135 parameters: {
2136 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2137 ::treesitter_types::ParseError::missing_field("parameters", node)
2138 })?;
2139 ::treesitter_types::runtime::maybe_grow_stack(|| {
2140 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
2141 })?
2142 },
2143 result: match node.child_by_field_name("result") {
2144 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2145 <FunctionTypeResult as ::treesitter_types::FromNode>::from_node(child, src)
2146 })?),
2147 None => None,
2148 },
2149 })
2150 }
2151}
2152impl ::treesitter_types::Spanned for FunctionType<'_> {
2153 fn span(&self) -> ::treesitter_types::Span {
2154 self.span
2155 }
2156}
2157#[derive(Debug, Clone, PartialEq, Eq)]
2158pub struct GenericType<'tree> {
2159 pub span: ::treesitter_types::Span,
2160 pub r#type: GenericTypeType<'tree>,
2161 pub type_arguments: TypeArguments<'tree>,
2162}
2163impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
2164 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2165 fn from_node(
2166 node: ::treesitter_types::tree_sitter::Node<'tree>,
2167 src: &'tree [u8],
2168 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2169 debug_assert_eq!(node.kind(), "generic_type");
2170 Ok(Self {
2171 span: ::treesitter_types::Span::from(node),
2172 r#type: {
2173 let child = node
2174 .child_by_field_name("type")
2175 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2176 ::treesitter_types::runtime::maybe_grow_stack(|| {
2177 <GenericTypeType as ::treesitter_types::FromNode>::from_node(child, src)
2178 })?
2179 },
2180 type_arguments: {
2181 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
2182 ::treesitter_types::ParseError::missing_field("type_arguments", node)
2183 })?;
2184 ::treesitter_types::runtime::maybe_grow_stack(|| {
2185 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)
2186 })?
2187 },
2188 })
2189 }
2190}
2191impl ::treesitter_types::Spanned for GenericType<'_> {
2192 fn span(&self) -> ::treesitter_types::Span {
2193 self.span
2194 }
2195}
2196#[derive(Debug, Clone, PartialEq, Eq)]
2197pub struct GoStatement<'tree> {
2198 pub span: ::treesitter_types::Span,
2199 pub children: Expression<'tree>,
2200}
2201impl<'tree> ::treesitter_types::FromNode<'tree> for GoStatement<'tree> {
2202 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2203 fn from_node(
2204 node: ::treesitter_types::tree_sitter::Node<'tree>,
2205 src: &'tree [u8],
2206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2207 debug_assert_eq!(node.kind(), "go_statement");
2208 Ok(Self {
2209 span: ::treesitter_types::Span::from(node),
2210 children: {
2211 #[allow(clippy::suspicious_else_formatting)]
2212 let non_field_children = {
2213 let mut cursor = node.walk();
2214 let mut result = ::std::vec::Vec::new();
2215 if cursor.goto_first_child() {
2216 loop {
2217 if cursor.field_name().is_none()
2218 && cursor.node().is_named()
2219 && !cursor.node().is_extra()
2220 {
2221 result.push(cursor.node());
2222 }
2223 if !cursor.goto_next_sibling() {
2224 break;
2225 }
2226 }
2227 }
2228 result
2229 };
2230 let child = if let Some(&c) = non_field_children.first() {
2231 c
2232 } else {
2233 let mut fallback_cursor = node.walk();
2234 let mut fallback_child = None;
2235 if fallback_cursor.goto_first_child() {
2236 loop {
2237 if fallback_cursor.field_name().is_none()
2238 && !fallback_cursor.node().is_extra()
2239 {
2240 let candidate = fallback_cursor.node();
2241 #[allow(clippy::needless_question_mark)]
2242 if (|| -> ::core::result::Result<
2243 _,
2244 ::treesitter_types::ParseError,
2245 > {
2246 let child = candidate;
2247 Ok(
2248 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2249 child,
2250 src,
2251 ))?,
2252 )
2253 })()
2254 .is_ok()
2255 {
2256 fallback_child = Some(candidate);
2257 break;
2258 }
2259 }
2260 if !fallback_cursor.goto_next_sibling() {
2261 break;
2262 }
2263 }
2264 }
2265 if fallback_child.is_none() {
2266 let mut cursor2 = node.walk();
2267 if cursor2.goto_first_child() {
2268 loop {
2269 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2270 let candidate = cursor2.node();
2271 #[allow(clippy::needless_question_mark)]
2272 if (|| -> ::core::result::Result<
2273 _,
2274 ::treesitter_types::ParseError,
2275 > {
2276 let child = candidate;
2277 Ok(
2278 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2279 child,
2280 src,
2281 ))?,
2282 )
2283 })()
2284 .is_ok()
2285 {
2286 fallback_child = Some(candidate);
2287 break;
2288 }
2289 }
2290 if !cursor2.goto_next_sibling() {
2291 break;
2292 }
2293 }
2294 }
2295 }
2296 fallback_child.ok_or_else(|| {
2297 ::treesitter_types::ParseError::missing_field("children", node)
2298 })?
2299 };
2300 ::treesitter_types::runtime::maybe_grow_stack(|| {
2301 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2302 })?
2303 },
2304 })
2305 }
2306}
2307impl ::treesitter_types::Spanned for GoStatement<'_> {
2308 fn span(&self) -> ::treesitter_types::Span {
2309 self.span
2310 }
2311}
2312#[derive(Debug, Clone, PartialEq, Eq)]
2313pub struct GotoStatement<'tree> {
2314 pub span: ::treesitter_types::Span,
2315 pub children: LabelName<'tree>,
2316}
2317impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
2318 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2319 fn from_node(
2320 node: ::treesitter_types::tree_sitter::Node<'tree>,
2321 src: &'tree [u8],
2322 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2323 debug_assert_eq!(node.kind(), "goto_statement");
2324 Ok(Self {
2325 span: ::treesitter_types::Span::from(node),
2326 children: {
2327 #[allow(clippy::suspicious_else_formatting)]
2328 let non_field_children = {
2329 let mut cursor = node.walk();
2330 let mut result = ::std::vec::Vec::new();
2331 if cursor.goto_first_child() {
2332 loop {
2333 if cursor.field_name().is_none()
2334 && cursor.node().is_named()
2335 && !cursor.node().is_extra()
2336 {
2337 result.push(cursor.node());
2338 }
2339 if !cursor.goto_next_sibling() {
2340 break;
2341 }
2342 }
2343 }
2344 result
2345 };
2346 let child = if let Some(&c) = non_field_children.first() {
2347 c
2348 } else {
2349 let mut fallback_cursor = node.walk();
2350 let mut fallback_child = None;
2351 if fallback_cursor.goto_first_child() {
2352 loop {
2353 if fallback_cursor.field_name().is_none()
2354 && !fallback_cursor.node().is_extra()
2355 {
2356 let candidate = fallback_cursor.node();
2357 #[allow(clippy::needless_question_mark)]
2358 if (|| -> ::core::result::Result<
2359 _,
2360 ::treesitter_types::ParseError,
2361 > {
2362 let child = candidate;
2363 Ok(
2364 ::treesitter_types::runtime::maybe_grow_stack(|| <LabelName as ::treesitter_types::FromNode>::from_node(
2365 child,
2366 src,
2367 ))?,
2368 )
2369 })()
2370 .is_ok()
2371 {
2372 fallback_child = Some(candidate);
2373 break;
2374 }
2375 }
2376 if !fallback_cursor.goto_next_sibling() {
2377 break;
2378 }
2379 }
2380 }
2381 if fallback_child.is_none() {
2382 let mut cursor2 = node.walk();
2383 if cursor2.goto_first_child() {
2384 loop {
2385 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2386 let candidate = cursor2.node();
2387 #[allow(clippy::needless_question_mark)]
2388 if (|| -> ::core::result::Result<
2389 _,
2390 ::treesitter_types::ParseError,
2391 > {
2392 let child = candidate;
2393 Ok(
2394 ::treesitter_types::runtime::maybe_grow_stack(|| <LabelName as ::treesitter_types::FromNode>::from_node(
2395 child,
2396 src,
2397 ))?,
2398 )
2399 })()
2400 .is_ok()
2401 {
2402 fallback_child = Some(candidate);
2403 break;
2404 }
2405 }
2406 if !cursor2.goto_next_sibling() {
2407 break;
2408 }
2409 }
2410 }
2411 }
2412 fallback_child.ok_or_else(|| {
2413 ::treesitter_types::ParseError::missing_field("children", node)
2414 })?
2415 };
2416 ::treesitter_types::runtime::maybe_grow_stack(|| {
2417 <LabelName as ::treesitter_types::FromNode>::from_node(child, src)
2418 })?
2419 },
2420 })
2421 }
2422}
2423impl ::treesitter_types::Spanned for GotoStatement<'_> {
2424 fn span(&self) -> ::treesitter_types::Span {
2425 self.span
2426 }
2427}
2428#[derive(Debug, Clone, PartialEq, Eq)]
2429pub struct IfStatement<'tree> {
2430 pub span: ::treesitter_types::Span,
2431 pub alternative: ::core::option::Option<IfStatementAlternative<'tree>>,
2432 pub condition: Expression<'tree>,
2433 pub consequence: Block<'tree>,
2434 pub initializer: ::core::option::Option<SimpleStatement<'tree>>,
2435}
2436impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
2437 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2438 fn from_node(
2439 node: ::treesitter_types::tree_sitter::Node<'tree>,
2440 src: &'tree [u8],
2441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2442 debug_assert_eq!(node.kind(), "if_statement");
2443 Ok(Self {
2444 span: ::treesitter_types::Span::from(node),
2445 alternative: match node.child_by_field_name("alternative") {
2446 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2447 <IfStatementAlternative as ::treesitter_types::FromNode>::from_node(child, src)
2448 })?),
2449 None => None,
2450 },
2451 condition: {
2452 let child = node.child_by_field_name("condition").ok_or_else(|| {
2453 ::treesitter_types::ParseError::missing_field("condition", node)
2454 })?;
2455 ::treesitter_types::runtime::maybe_grow_stack(|| {
2456 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2457 })?
2458 },
2459 consequence: {
2460 let child = node.child_by_field_name("consequence").ok_or_else(|| {
2461 ::treesitter_types::ParseError::missing_field("consequence", node)
2462 })?;
2463 ::treesitter_types::runtime::maybe_grow_stack(|| {
2464 <Block as ::treesitter_types::FromNode>::from_node(child, src)
2465 })?
2466 },
2467 initializer: match node.child_by_field_name("initializer") {
2468 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2469 <SimpleStatement as ::treesitter_types::FromNode>::from_node(child, src)
2470 })?),
2471 None => None,
2472 },
2473 })
2474 }
2475}
2476impl ::treesitter_types::Spanned for IfStatement<'_> {
2477 fn span(&self) -> ::treesitter_types::Span {
2478 self.span
2479 }
2480}
2481#[derive(Debug, Clone, PartialEq, Eq)]
2482pub struct ImplicitLengthArrayType<'tree> {
2483 pub span: ::treesitter_types::Span,
2484 pub element: Type<'tree>,
2485}
2486impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitLengthArrayType<'tree> {
2487 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2488 fn from_node(
2489 node: ::treesitter_types::tree_sitter::Node<'tree>,
2490 src: &'tree [u8],
2491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2492 debug_assert_eq!(node.kind(), "implicit_length_array_type");
2493 Ok(Self {
2494 span: ::treesitter_types::Span::from(node),
2495 element: {
2496 let child = node.child_by_field_name("element").ok_or_else(|| {
2497 ::treesitter_types::ParseError::missing_field("element", node)
2498 })?;
2499 ::treesitter_types::runtime::maybe_grow_stack(|| {
2500 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2501 })?
2502 },
2503 })
2504 }
2505}
2506impl ::treesitter_types::Spanned for ImplicitLengthArrayType<'_> {
2507 fn span(&self) -> ::treesitter_types::Span {
2508 self.span
2509 }
2510}
2511#[derive(Debug, Clone, PartialEq, Eq)]
2512pub struct ImportDeclaration<'tree> {
2513 pub span: ::treesitter_types::Span,
2514 pub children: ImportDeclarationChildren<'tree>,
2515}
2516impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclaration<'tree> {
2517 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2518 fn from_node(
2519 node: ::treesitter_types::tree_sitter::Node<'tree>,
2520 src: &'tree [u8],
2521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2522 debug_assert_eq!(node.kind(), "import_declaration");
2523 Ok(Self {
2524 span: ::treesitter_types::Span::from(node),
2525 children: {
2526 #[allow(clippy::suspicious_else_formatting)]
2527 let non_field_children = {
2528 let mut cursor = node.walk();
2529 let mut result = ::std::vec::Vec::new();
2530 if cursor.goto_first_child() {
2531 loop {
2532 if cursor.field_name().is_none()
2533 && cursor.node().is_named()
2534 && !cursor.node().is_extra()
2535 {
2536 result.push(cursor.node());
2537 }
2538 if !cursor.goto_next_sibling() {
2539 break;
2540 }
2541 }
2542 }
2543 result
2544 };
2545 let child = if let Some(&c) = non_field_children.first() {
2546 c
2547 } else {
2548 let mut fallback_cursor = node.walk();
2549 let mut fallback_child = None;
2550 if fallback_cursor.goto_first_child() {
2551 loop {
2552 if fallback_cursor.field_name().is_none()
2553 && !fallback_cursor.node().is_extra()
2554 {
2555 let candidate = fallback_cursor.node();
2556 #[allow(clippy::needless_question_mark)]
2557 if (|| -> ::core::result::Result<
2558 _,
2559 ::treesitter_types::ParseError,
2560 > {
2561 let child = candidate;
2562 Ok(
2563 ::treesitter_types::runtime::maybe_grow_stack(|| <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2564 child,
2565 src,
2566 ))?,
2567 )
2568 })()
2569 .is_ok()
2570 {
2571 fallback_child = Some(candidate);
2572 break;
2573 }
2574 }
2575 if !fallback_cursor.goto_next_sibling() {
2576 break;
2577 }
2578 }
2579 }
2580 if fallback_child.is_none() {
2581 let mut cursor2 = node.walk();
2582 if cursor2.goto_first_child() {
2583 loop {
2584 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2585 let candidate = cursor2.node();
2586 #[allow(clippy::needless_question_mark)]
2587 if (|| -> ::core::result::Result<
2588 _,
2589 ::treesitter_types::ParseError,
2590 > {
2591 let child = candidate;
2592 Ok(
2593 ::treesitter_types::runtime::maybe_grow_stack(|| <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2594 child,
2595 src,
2596 ))?,
2597 )
2598 })()
2599 .is_ok()
2600 {
2601 fallback_child = Some(candidate);
2602 break;
2603 }
2604 }
2605 if !cursor2.goto_next_sibling() {
2606 break;
2607 }
2608 }
2609 }
2610 }
2611 fallback_child.ok_or_else(|| {
2612 ::treesitter_types::ParseError::missing_field("children", node)
2613 })?
2614 };
2615 ::treesitter_types::runtime::maybe_grow_stack(|| {
2616 <ImportDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2617 child, src,
2618 )
2619 })?
2620 },
2621 })
2622 }
2623}
2624impl ::treesitter_types::Spanned for ImportDeclaration<'_> {
2625 fn span(&self) -> ::treesitter_types::Span {
2626 self.span
2627 }
2628}
2629#[derive(Debug, Clone, PartialEq, Eq)]
2630pub struct ImportSpec<'tree> {
2631 pub span: ::treesitter_types::Span,
2632 pub name: ::core::option::Option<ImportSpecName<'tree>>,
2633 pub path: ImportSpecPath<'tree>,
2634}
2635impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpec<'tree> {
2636 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2637 fn from_node(
2638 node: ::treesitter_types::tree_sitter::Node<'tree>,
2639 src: &'tree [u8],
2640 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2641 debug_assert_eq!(node.kind(), "import_spec");
2642 Ok(Self {
2643 span: ::treesitter_types::Span::from(node),
2644 name: match node.child_by_field_name("name") {
2645 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2646 <ImportSpecName as ::treesitter_types::FromNode>::from_node(child, src)
2647 })?),
2648 None => None,
2649 },
2650 path: {
2651 let child = node
2652 .child_by_field_name("path")
2653 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
2654 ::treesitter_types::runtime::maybe_grow_stack(|| {
2655 <ImportSpecPath as ::treesitter_types::FromNode>::from_node(child, src)
2656 })?
2657 },
2658 })
2659 }
2660}
2661impl ::treesitter_types::Spanned for ImportSpec<'_> {
2662 fn span(&self) -> ::treesitter_types::Span {
2663 self.span
2664 }
2665}
2666#[derive(Debug, Clone, PartialEq, Eq)]
2667pub struct ImportSpecList<'tree> {
2668 pub span: ::treesitter_types::Span,
2669 pub children: ::std::vec::Vec<ImportSpec<'tree>>,
2670}
2671impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecList<'tree> {
2672 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2673 fn from_node(
2674 node: ::treesitter_types::tree_sitter::Node<'tree>,
2675 src: &'tree [u8],
2676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2677 debug_assert_eq!(node.kind(), "import_spec_list");
2678 Ok(Self {
2679 span: ::treesitter_types::Span::from(node),
2680 children: {
2681 #[allow(clippy::suspicious_else_formatting)]
2682 let non_field_children = {
2683 let mut cursor = node.walk();
2684 let mut result = ::std::vec::Vec::new();
2685 if cursor.goto_first_child() {
2686 loop {
2687 if cursor.field_name().is_none()
2688 && cursor.node().is_named()
2689 && !cursor.node().is_extra()
2690 {
2691 result.push(cursor.node());
2692 }
2693 if !cursor.goto_next_sibling() {
2694 break;
2695 }
2696 }
2697 }
2698 result
2699 };
2700 let mut items = ::std::vec::Vec::new();
2701 for child in non_field_children {
2702 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2703 <ImportSpec as ::treesitter_types::FromNode>::from_node(child, src)
2704 })?);
2705 }
2706 items
2707 },
2708 })
2709 }
2710}
2711impl ::treesitter_types::Spanned for ImportSpecList<'_> {
2712 fn span(&self) -> ::treesitter_types::Span {
2713 self.span
2714 }
2715}
2716#[derive(Debug, Clone, PartialEq, Eq)]
2717pub struct IncStatement<'tree> {
2718 pub span: ::treesitter_types::Span,
2719 pub children: Expression<'tree>,
2720}
2721impl<'tree> ::treesitter_types::FromNode<'tree> for IncStatement<'tree> {
2722 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2723 fn from_node(
2724 node: ::treesitter_types::tree_sitter::Node<'tree>,
2725 src: &'tree [u8],
2726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2727 debug_assert_eq!(node.kind(), "inc_statement");
2728 Ok(Self {
2729 span: ::treesitter_types::Span::from(node),
2730 children: {
2731 #[allow(clippy::suspicious_else_formatting)]
2732 let non_field_children = {
2733 let mut cursor = node.walk();
2734 let mut result = ::std::vec::Vec::new();
2735 if cursor.goto_first_child() {
2736 loop {
2737 if cursor.field_name().is_none()
2738 && cursor.node().is_named()
2739 && !cursor.node().is_extra()
2740 {
2741 result.push(cursor.node());
2742 }
2743 if !cursor.goto_next_sibling() {
2744 break;
2745 }
2746 }
2747 }
2748 result
2749 };
2750 let child = if let Some(&c) = non_field_children.first() {
2751 c
2752 } else {
2753 let mut fallback_cursor = node.walk();
2754 let mut fallback_child = None;
2755 if fallback_cursor.goto_first_child() {
2756 loop {
2757 if fallback_cursor.field_name().is_none()
2758 && !fallback_cursor.node().is_extra()
2759 {
2760 let candidate = fallback_cursor.node();
2761 #[allow(clippy::needless_question_mark)]
2762 if (|| -> ::core::result::Result<
2763 _,
2764 ::treesitter_types::ParseError,
2765 > {
2766 let child = candidate;
2767 Ok(
2768 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2769 child,
2770 src,
2771 ))?,
2772 )
2773 })()
2774 .is_ok()
2775 {
2776 fallback_child = Some(candidate);
2777 break;
2778 }
2779 }
2780 if !fallback_cursor.goto_next_sibling() {
2781 break;
2782 }
2783 }
2784 }
2785 if fallback_child.is_none() {
2786 let mut cursor2 = node.walk();
2787 if cursor2.goto_first_child() {
2788 loop {
2789 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2790 let candidate = cursor2.node();
2791 #[allow(clippy::needless_question_mark)]
2792 if (|| -> ::core::result::Result<
2793 _,
2794 ::treesitter_types::ParseError,
2795 > {
2796 let child = candidate;
2797 Ok(
2798 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2799 child,
2800 src,
2801 ))?,
2802 )
2803 })()
2804 .is_ok()
2805 {
2806 fallback_child = Some(candidate);
2807 break;
2808 }
2809 }
2810 if !cursor2.goto_next_sibling() {
2811 break;
2812 }
2813 }
2814 }
2815 }
2816 fallback_child.ok_or_else(|| {
2817 ::treesitter_types::ParseError::missing_field("children", node)
2818 })?
2819 };
2820 ::treesitter_types::runtime::maybe_grow_stack(|| {
2821 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2822 })?
2823 },
2824 })
2825 }
2826}
2827impl ::treesitter_types::Spanned for IncStatement<'_> {
2828 fn span(&self) -> ::treesitter_types::Span {
2829 self.span
2830 }
2831}
2832#[derive(Debug, Clone, PartialEq, Eq)]
2833pub struct IndexExpression<'tree> {
2834 pub span: ::treesitter_types::Span,
2835 pub index: Expression<'tree>,
2836 pub operand: Expression<'tree>,
2837}
2838impl<'tree> ::treesitter_types::FromNode<'tree> for IndexExpression<'tree> {
2839 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2840 fn from_node(
2841 node: ::treesitter_types::tree_sitter::Node<'tree>,
2842 src: &'tree [u8],
2843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2844 debug_assert_eq!(node.kind(), "index_expression");
2845 Ok(Self {
2846 span: ::treesitter_types::Span::from(node),
2847 index: {
2848 let child = node
2849 .child_by_field_name("index")
2850 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
2851 ::treesitter_types::runtime::maybe_grow_stack(|| {
2852 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2853 })?
2854 },
2855 operand: {
2856 let child = node.child_by_field_name("operand").ok_or_else(|| {
2857 ::treesitter_types::ParseError::missing_field("operand", node)
2858 })?;
2859 ::treesitter_types::runtime::maybe_grow_stack(|| {
2860 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2861 })?
2862 },
2863 })
2864 }
2865}
2866impl ::treesitter_types::Spanned for IndexExpression<'_> {
2867 fn span(&self) -> ::treesitter_types::Span {
2868 self.span
2869 }
2870}
2871#[derive(Debug, Clone, PartialEq, Eq)]
2872pub struct InterfaceType<'tree> {
2873 pub span: ::treesitter_types::Span,
2874 pub children: ::std::vec::Vec<InterfaceTypeChildren<'tree>>,
2875}
2876impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceType<'tree> {
2877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2878 fn from_node(
2879 node: ::treesitter_types::tree_sitter::Node<'tree>,
2880 src: &'tree [u8],
2881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2882 debug_assert_eq!(node.kind(), "interface_type");
2883 Ok(Self {
2884 span: ::treesitter_types::Span::from(node),
2885 children: {
2886 #[allow(clippy::suspicious_else_formatting)]
2887 let non_field_children = {
2888 let mut cursor = node.walk();
2889 let mut result = ::std::vec::Vec::new();
2890 if cursor.goto_first_child() {
2891 loop {
2892 if cursor.field_name().is_none()
2893 && cursor.node().is_named()
2894 && !cursor.node().is_extra()
2895 {
2896 result.push(cursor.node());
2897 }
2898 if !cursor.goto_next_sibling() {
2899 break;
2900 }
2901 }
2902 }
2903 result
2904 };
2905 let mut items = ::std::vec::Vec::new();
2906 for child in non_field_children {
2907 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2908 <InterfaceTypeChildren as ::treesitter_types::FromNode>::from_node(
2909 child, src,
2910 )
2911 })?);
2912 }
2913 items
2914 },
2915 })
2916 }
2917}
2918impl ::treesitter_types::Spanned for InterfaceType<'_> {
2919 fn span(&self) -> ::treesitter_types::Span {
2920 self.span
2921 }
2922}
2923#[derive(Debug, Clone, PartialEq, Eq)]
2924pub struct InterpretedStringLiteral<'tree> {
2925 pub span: ::treesitter_types::Span,
2926 pub children: ::std::vec::Vec<InterpretedStringLiteralChildren<'tree>>,
2927}
2928impl<'tree> ::treesitter_types::FromNode<'tree> for InterpretedStringLiteral<'tree> {
2929 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2930 fn from_node(
2931 node: ::treesitter_types::tree_sitter::Node<'tree>,
2932 src: &'tree [u8],
2933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2934 debug_assert_eq!(node.kind(), "interpreted_string_literal");
2935 Ok(Self {
2936 span: ::treesitter_types::Span::from(node),
2937 children: {
2938 #[allow(clippy::suspicious_else_formatting)]
2939 let non_field_children = {
2940 let mut cursor = node.walk();
2941 let mut result = ::std::vec::Vec::new();
2942 if cursor.goto_first_child() {
2943 loop {
2944 if cursor.field_name().is_none()
2945 && cursor.node().is_named()
2946 && !cursor.node().is_extra()
2947 {
2948 result.push(cursor.node());
2949 }
2950 if !cursor.goto_next_sibling() {
2951 break;
2952 }
2953 }
2954 }
2955 result
2956 };
2957 let mut items = ::std::vec::Vec::new();
2958 for child in non_field_children {
2959 items
2960 .push(
2961 ::treesitter_types::runtime::maybe_grow_stack(|| <InterpretedStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
2962 child,
2963 src,
2964 ))?,
2965 );
2966 }
2967 items
2968 },
2969 })
2970 }
2971}
2972impl ::treesitter_types::Spanned for InterpretedStringLiteral<'_> {
2973 fn span(&self) -> ::treesitter_types::Span {
2974 self.span
2975 }
2976}
2977#[derive(Debug, Clone, PartialEq, Eq)]
2978pub struct KeyedElement<'tree> {
2979 pub span: ::treesitter_types::Span,
2980 pub key: LiteralElement<'tree>,
2981 pub value: LiteralElement<'tree>,
2982}
2983impl<'tree> ::treesitter_types::FromNode<'tree> for KeyedElement<'tree> {
2984 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2985 fn from_node(
2986 node: ::treesitter_types::tree_sitter::Node<'tree>,
2987 src: &'tree [u8],
2988 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2989 debug_assert_eq!(node.kind(), "keyed_element");
2990 Ok(Self {
2991 span: ::treesitter_types::Span::from(node),
2992 key: {
2993 let child = node
2994 .child_by_field_name("key")
2995 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
2996 ::treesitter_types::runtime::maybe_grow_stack(|| {
2997 <LiteralElement as ::treesitter_types::FromNode>::from_node(child, src)
2998 })?
2999 },
3000 value: {
3001 let child = node
3002 .child_by_field_name("value")
3003 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3004 ::treesitter_types::runtime::maybe_grow_stack(|| {
3005 <LiteralElement as ::treesitter_types::FromNode>::from_node(child, src)
3006 })?
3007 },
3008 })
3009 }
3010}
3011impl ::treesitter_types::Spanned for KeyedElement<'_> {
3012 fn span(&self) -> ::treesitter_types::Span {
3013 self.span
3014 }
3015}
3016#[derive(Debug, Clone, PartialEq, Eq)]
3017pub struct LabeledStatement<'tree> {
3018 pub span: ::treesitter_types::Span,
3019 pub label: LabelName<'tree>,
3020 pub children: ::core::option::Option<Statement<'tree>>,
3021}
3022impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
3023 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3024 fn from_node(
3025 node: ::treesitter_types::tree_sitter::Node<'tree>,
3026 src: &'tree [u8],
3027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3028 debug_assert_eq!(node.kind(), "labeled_statement");
3029 Ok(Self {
3030 span: ::treesitter_types::Span::from(node),
3031 label: {
3032 let child = node
3033 .child_by_field_name("label")
3034 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
3035 ::treesitter_types::runtime::maybe_grow_stack(|| {
3036 <LabelName as ::treesitter_types::FromNode>::from_node(child, src)
3037 })?
3038 },
3039 children: {
3040 #[allow(clippy::suspicious_else_formatting)]
3041 let non_field_children = {
3042 let mut cursor = node.walk();
3043 let mut result = ::std::vec::Vec::new();
3044 if cursor.goto_first_child() {
3045 loop {
3046 if cursor.field_name().is_none()
3047 && cursor.node().is_named()
3048 && !cursor.node().is_extra()
3049 {
3050 result.push(cursor.node());
3051 }
3052 if !cursor.goto_next_sibling() {
3053 break;
3054 }
3055 }
3056 }
3057 result
3058 };
3059 match non_field_children.first() {
3060 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3061 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3062 })?),
3063 None => None,
3064 }
3065 },
3066 })
3067 }
3068}
3069impl ::treesitter_types::Spanned for LabeledStatement<'_> {
3070 fn span(&self) -> ::treesitter_types::Span {
3071 self.span
3072 }
3073}
3074#[derive(Debug, Clone, PartialEq, Eq)]
3075pub struct LiteralElement<'tree> {
3076 pub span: ::treesitter_types::Span,
3077 pub children: LiteralElementChildren<'tree>,
3078}
3079impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralElement<'tree> {
3080 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3081 fn from_node(
3082 node: ::treesitter_types::tree_sitter::Node<'tree>,
3083 src: &'tree [u8],
3084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3085 debug_assert_eq!(node.kind(), "literal_element");
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 child = if let Some(&c) = non_field_children.first() {
3109 c
3110 } else {
3111 let mut fallback_cursor = node.walk();
3112 let mut fallback_child = None;
3113 if fallback_cursor.goto_first_child() {
3114 loop {
3115 if fallback_cursor.field_name().is_none()
3116 && !fallback_cursor.node().is_extra()
3117 {
3118 let candidate = fallback_cursor.node();
3119 #[allow(clippy::needless_question_mark)]
3120 if (|| -> ::core::result::Result<
3121 _,
3122 ::treesitter_types::ParseError,
3123 > {
3124 let child = candidate;
3125 Ok(
3126 ::treesitter_types::runtime::maybe_grow_stack(|| <LiteralElementChildren as ::treesitter_types::FromNode>::from_node(
3127 child,
3128 src,
3129 ))?,
3130 )
3131 })()
3132 .is_ok()
3133 {
3134 fallback_child = Some(candidate);
3135 break;
3136 }
3137 }
3138 if !fallback_cursor.goto_next_sibling() {
3139 break;
3140 }
3141 }
3142 }
3143 if fallback_child.is_none() {
3144 let mut cursor2 = node.walk();
3145 if cursor2.goto_first_child() {
3146 loop {
3147 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3148 let candidate = cursor2.node();
3149 #[allow(clippy::needless_question_mark)]
3150 if (|| -> ::core::result::Result<
3151 _,
3152 ::treesitter_types::ParseError,
3153 > {
3154 let child = candidate;
3155 Ok(
3156 ::treesitter_types::runtime::maybe_grow_stack(|| <LiteralElementChildren as ::treesitter_types::FromNode>::from_node(
3157 child,
3158 src,
3159 ))?,
3160 )
3161 })()
3162 .is_ok()
3163 {
3164 fallback_child = Some(candidate);
3165 break;
3166 }
3167 }
3168 if !cursor2.goto_next_sibling() {
3169 break;
3170 }
3171 }
3172 }
3173 }
3174 fallback_child.ok_or_else(|| {
3175 ::treesitter_types::ParseError::missing_field("children", node)
3176 })?
3177 };
3178 ::treesitter_types::runtime::maybe_grow_stack(|| {
3179 <LiteralElementChildren as ::treesitter_types::FromNode>::from_node(child, src)
3180 })?
3181 },
3182 })
3183 }
3184}
3185impl ::treesitter_types::Spanned for LiteralElement<'_> {
3186 fn span(&self) -> ::treesitter_types::Span {
3187 self.span
3188 }
3189}
3190#[derive(Debug, Clone, PartialEq, Eq)]
3191pub struct LiteralValue<'tree> {
3192 pub span: ::treesitter_types::Span,
3193 pub children: ::std::vec::Vec<LiteralValueChildren<'tree>>,
3194}
3195impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralValue<'tree> {
3196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3197 fn from_node(
3198 node: ::treesitter_types::tree_sitter::Node<'tree>,
3199 src: &'tree [u8],
3200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3201 debug_assert_eq!(node.kind(), "literal_value");
3202 Ok(Self {
3203 span: ::treesitter_types::Span::from(node),
3204 children: {
3205 #[allow(clippy::suspicious_else_formatting)]
3206 let non_field_children = {
3207 let mut cursor = node.walk();
3208 let mut result = ::std::vec::Vec::new();
3209 if cursor.goto_first_child() {
3210 loop {
3211 if cursor.field_name().is_none()
3212 && cursor.node().is_named()
3213 && !cursor.node().is_extra()
3214 {
3215 result.push(cursor.node());
3216 }
3217 if !cursor.goto_next_sibling() {
3218 break;
3219 }
3220 }
3221 }
3222 result
3223 };
3224 let mut items = ::std::vec::Vec::new();
3225 for child in non_field_children {
3226 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3227 <LiteralValueChildren as ::treesitter_types::FromNode>::from_node(
3228 child, src,
3229 )
3230 })?);
3231 }
3232 items
3233 },
3234 })
3235 }
3236}
3237impl ::treesitter_types::Spanned for LiteralValue<'_> {
3238 fn span(&self) -> ::treesitter_types::Span {
3239 self.span
3240 }
3241}
3242#[derive(Debug, Clone, PartialEq, Eq)]
3243pub struct MapType<'tree> {
3244 pub span: ::treesitter_types::Span,
3245 pub key: Type<'tree>,
3246 pub value: Type<'tree>,
3247}
3248impl<'tree> ::treesitter_types::FromNode<'tree> for MapType<'tree> {
3249 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3250 fn from_node(
3251 node: ::treesitter_types::tree_sitter::Node<'tree>,
3252 src: &'tree [u8],
3253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3254 debug_assert_eq!(node.kind(), "map_type");
3255 Ok(Self {
3256 span: ::treesitter_types::Span::from(node),
3257 key: {
3258 let child = node
3259 .child_by_field_name("key")
3260 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
3261 ::treesitter_types::runtime::maybe_grow_stack(|| {
3262 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3263 })?
3264 },
3265 value: {
3266 let child = node
3267 .child_by_field_name("value")
3268 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3269 ::treesitter_types::runtime::maybe_grow_stack(|| {
3270 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3271 })?
3272 },
3273 })
3274 }
3275}
3276impl ::treesitter_types::Spanned for MapType<'_> {
3277 fn span(&self) -> ::treesitter_types::Span {
3278 self.span
3279 }
3280}
3281#[derive(Debug, Clone, PartialEq, Eq)]
3282pub struct MethodDeclaration<'tree> {
3283 pub span: ::treesitter_types::Span,
3284 pub body: ::core::option::Option<Block<'tree>>,
3285 pub name: FieldIdentifier<'tree>,
3286 pub parameters: ParameterList<'tree>,
3287 pub receiver: ParameterList<'tree>,
3288 pub result: ::core::option::Option<MethodDeclarationResult<'tree>>,
3289}
3290impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
3291 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3292 fn from_node(
3293 node: ::treesitter_types::tree_sitter::Node<'tree>,
3294 src: &'tree [u8],
3295 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3296 debug_assert_eq!(node.kind(), "method_declaration");
3297 Ok(Self {
3298 span: ::treesitter_types::Span::from(node),
3299 body: match node.child_by_field_name("body") {
3300 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3301 <Block as ::treesitter_types::FromNode>::from_node(child, src)
3302 })?),
3303 None => None,
3304 },
3305 name: {
3306 let child = node
3307 .child_by_field_name("name")
3308 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3309 ::treesitter_types::runtime::maybe_grow_stack(|| {
3310 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3311 })?
3312 },
3313 parameters: {
3314 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3315 ::treesitter_types::ParseError::missing_field("parameters", node)
3316 })?;
3317 ::treesitter_types::runtime::maybe_grow_stack(|| {
3318 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
3319 })?
3320 },
3321 receiver: {
3322 let child = node.child_by_field_name("receiver").ok_or_else(|| {
3323 ::treesitter_types::ParseError::missing_field("receiver", node)
3324 })?;
3325 ::treesitter_types::runtime::maybe_grow_stack(|| {
3326 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
3327 })?
3328 },
3329 result: match node.child_by_field_name("result") {
3330 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3331 <MethodDeclarationResult as ::treesitter_types::FromNode>::from_node(child, src)
3332 })?),
3333 None => None,
3334 },
3335 })
3336 }
3337}
3338impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
3339 fn span(&self) -> ::treesitter_types::Span {
3340 self.span
3341 }
3342}
3343#[derive(Debug, Clone, PartialEq, Eq)]
3344pub struct MethodElem<'tree> {
3345 pub span: ::treesitter_types::Span,
3346 pub name: FieldIdentifier<'tree>,
3347 pub parameters: ParameterList<'tree>,
3348 pub result: ::core::option::Option<MethodElemResult<'tree>>,
3349}
3350impl<'tree> ::treesitter_types::FromNode<'tree> for MethodElem<'tree> {
3351 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3352 fn from_node(
3353 node: ::treesitter_types::tree_sitter::Node<'tree>,
3354 src: &'tree [u8],
3355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3356 debug_assert_eq!(node.kind(), "method_elem");
3357 Ok(Self {
3358 span: ::treesitter_types::Span::from(node),
3359 name: {
3360 let child = node
3361 .child_by_field_name("name")
3362 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3363 ::treesitter_types::runtime::maybe_grow_stack(|| {
3364 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3365 })?
3366 },
3367 parameters: {
3368 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3369 ::treesitter_types::ParseError::missing_field("parameters", node)
3370 })?;
3371 ::treesitter_types::runtime::maybe_grow_stack(|| {
3372 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
3373 })?
3374 },
3375 result: match node.child_by_field_name("result") {
3376 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3377 <MethodElemResult as ::treesitter_types::FromNode>::from_node(child, src)
3378 })?),
3379 None => None,
3380 },
3381 })
3382 }
3383}
3384impl ::treesitter_types::Spanned for MethodElem<'_> {
3385 fn span(&self) -> ::treesitter_types::Span {
3386 self.span
3387 }
3388}
3389#[derive(Debug, Clone, PartialEq, Eq)]
3390pub struct NegatedType<'tree> {
3391 pub span: ::treesitter_types::Span,
3392 pub children: Type<'tree>,
3393}
3394impl<'tree> ::treesitter_types::FromNode<'tree> for NegatedType<'tree> {
3395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3396 fn from_node(
3397 node: ::treesitter_types::tree_sitter::Node<'tree>,
3398 src: &'tree [u8],
3399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3400 debug_assert_eq!(node.kind(), "negated_type");
3401 Ok(Self {
3402 span: ::treesitter_types::Span::from(node),
3403 children: {
3404 #[allow(clippy::suspicious_else_formatting)]
3405 let non_field_children = {
3406 let mut cursor = node.walk();
3407 let mut result = ::std::vec::Vec::new();
3408 if cursor.goto_first_child() {
3409 loop {
3410 if cursor.field_name().is_none()
3411 && cursor.node().is_named()
3412 && !cursor.node().is_extra()
3413 {
3414 result.push(cursor.node());
3415 }
3416 if !cursor.goto_next_sibling() {
3417 break;
3418 }
3419 }
3420 }
3421 result
3422 };
3423 let child = if let Some(&c) = non_field_children.first() {
3424 c
3425 } else {
3426 let mut fallback_cursor = node.walk();
3427 let mut fallback_child = None;
3428 if fallback_cursor.goto_first_child() {
3429 loop {
3430 if fallback_cursor.field_name().is_none()
3431 && !fallback_cursor.node().is_extra()
3432 {
3433 let candidate = fallback_cursor.node();
3434 #[allow(clippy::needless_question_mark)]
3435 if (|| -> ::core::result::Result<
3436 _,
3437 ::treesitter_types::ParseError,
3438 > {
3439 let child = candidate;
3440 Ok(
3441 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
3442 child,
3443 src,
3444 ))?,
3445 )
3446 })()
3447 .is_ok()
3448 {
3449 fallback_child = Some(candidate);
3450 break;
3451 }
3452 }
3453 if !fallback_cursor.goto_next_sibling() {
3454 break;
3455 }
3456 }
3457 }
3458 if fallback_child.is_none() {
3459 let mut cursor2 = node.walk();
3460 if cursor2.goto_first_child() {
3461 loop {
3462 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3463 let candidate = cursor2.node();
3464 #[allow(clippy::needless_question_mark)]
3465 if (|| -> ::core::result::Result<
3466 _,
3467 ::treesitter_types::ParseError,
3468 > {
3469 let child = candidate;
3470 Ok(
3471 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
3472 child,
3473 src,
3474 ))?,
3475 )
3476 })()
3477 .is_ok()
3478 {
3479 fallback_child = Some(candidate);
3480 break;
3481 }
3482 }
3483 if !cursor2.goto_next_sibling() {
3484 break;
3485 }
3486 }
3487 }
3488 }
3489 fallback_child.ok_or_else(|| {
3490 ::treesitter_types::ParseError::missing_field("children", node)
3491 })?
3492 };
3493 ::treesitter_types::runtime::maybe_grow_stack(|| {
3494 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3495 })?
3496 },
3497 })
3498 }
3499}
3500impl ::treesitter_types::Spanned for NegatedType<'_> {
3501 fn span(&self) -> ::treesitter_types::Span {
3502 self.span
3503 }
3504}
3505#[derive(Debug, Clone, PartialEq, Eq)]
3506pub struct PackageClause<'tree> {
3507 pub span: ::treesitter_types::Span,
3508 pub children: PackageIdentifier<'tree>,
3509}
3510impl<'tree> ::treesitter_types::FromNode<'tree> for PackageClause<'tree> {
3511 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3512 fn from_node(
3513 node: ::treesitter_types::tree_sitter::Node<'tree>,
3514 src: &'tree [u8],
3515 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3516 debug_assert_eq!(node.kind(), "package_clause");
3517 Ok(Self {
3518 span: ::treesitter_types::Span::from(node),
3519 children: {
3520 #[allow(clippy::suspicious_else_formatting)]
3521 let non_field_children = {
3522 let mut cursor = node.walk();
3523 let mut result = ::std::vec::Vec::new();
3524 if cursor.goto_first_child() {
3525 loop {
3526 if cursor.field_name().is_none()
3527 && cursor.node().is_named()
3528 && !cursor.node().is_extra()
3529 {
3530 result.push(cursor.node());
3531 }
3532 if !cursor.goto_next_sibling() {
3533 break;
3534 }
3535 }
3536 }
3537 result
3538 };
3539 let child = if let Some(&c) = non_field_children.first() {
3540 c
3541 } else {
3542 let mut fallback_cursor = node.walk();
3543 let mut fallback_child = None;
3544 if fallback_cursor.goto_first_child() {
3545 loop {
3546 if fallback_cursor.field_name().is_none()
3547 && !fallback_cursor.node().is_extra()
3548 {
3549 let candidate = fallback_cursor.node();
3550 #[allow(clippy::needless_question_mark)]
3551 if (|| -> ::core::result::Result<
3552 _,
3553 ::treesitter_types::ParseError,
3554 > {
3555 let child = candidate;
3556 Ok(
3557 ::treesitter_types::runtime::maybe_grow_stack(|| <PackageIdentifier as ::treesitter_types::FromNode>::from_node(
3558 child,
3559 src,
3560 ))?,
3561 )
3562 })()
3563 .is_ok()
3564 {
3565 fallback_child = Some(candidate);
3566 break;
3567 }
3568 }
3569 if !fallback_cursor.goto_next_sibling() {
3570 break;
3571 }
3572 }
3573 }
3574 if fallback_child.is_none() {
3575 let mut cursor2 = node.walk();
3576 if cursor2.goto_first_child() {
3577 loop {
3578 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3579 let candidate = cursor2.node();
3580 #[allow(clippy::needless_question_mark)]
3581 if (|| -> ::core::result::Result<
3582 _,
3583 ::treesitter_types::ParseError,
3584 > {
3585 let child = candidate;
3586 Ok(
3587 ::treesitter_types::runtime::maybe_grow_stack(|| <PackageIdentifier as ::treesitter_types::FromNode>::from_node(
3588 child,
3589 src,
3590 ))?,
3591 )
3592 })()
3593 .is_ok()
3594 {
3595 fallback_child = Some(candidate);
3596 break;
3597 }
3598 }
3599 if !cursor2.goto_next_sibling() {
3600 break;
3601 }
3602 }
3603 }
3604 }
3605 fallback_child.ok_or_else(|| {
3606 ::treesitter_types::ParseError::missing_field("children", node)
3607 })?
3608 };
3609 ::treesitter_types::runtime::maybe_grow_stack(|| {
3610 <PackageIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3611 })?
3612 },
3613 })
3614 }
3615}
3616impl ::treesitter_types::Spanned for PackageClause<'_> {
3617 fn span(&self) -> ::treesitter_types::Span {
3618 self.span
3619 }
3620}
3621#[derive(Debug, Clone, PartialEq, Eq)]
3622pub struct ParameterDeclaration<'tree> {
3623 pub span: ::treesitter_types::Span,
3624 pub name: ::std::vec::Vec<Identifier<'tree>>,
3625 pub r#type: Type<'tree>,
3626}
3627impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclaration<'tree> {
3628 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3629 fn from_node(
3630 node: ::treesitter_types::tree_sitter::Node<'tree>,
3631 src: &'tree [u8],
3632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3633 debug_assert_eq!(node.kind(), "parameter_declaration");
3634 Ok(Self {
3635 span: ::treesitter_types::Span::from(node),
3636 name: {
3637 let mut cursor = node.walk();
3638 let mut items = ::std::vec::Vec::new();
3639 for child in node.children_by_field_name("name", &mut cursor) {
3640 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3641 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3642 })?);
3643 }
3644 items
3645 },
3646 r#type: {
3647 let child = node
3648 .child_by_field_name("type")
3649 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3650 ::treesitter_types::runtime::maybe_grow_stack(|| {
3651 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3652 })?
3653 },
3654 })
3655 }
3656}
3657impl ::treesitter_types::Spanned for ParameterDeclaration<'_> {
3658 fn span(&self) -> ::treesitter_types::Span {
3659 self.span
3660 }
3661}
3662#[derive(Debug, Clone, PartialEq, Eq)]
3663pub struct ParameterList<'tree> {
3664 pub span: ::treesitter_types::Span,
3665 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
3666}
3667impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
3668 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3669 fn from_node(
3670 node: ::treesitter_types::tree_sitter::Node<'tree>,
3671 src: &'tree [u8],
3672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3673 debug_assert_eq!(node.kind(), "parameter_list");
3674 Ok(Self {
3675 span: ::treesitter_types::Span::from(node),
3676 children: {
3677 #[allow(clippy::suspicious_else_formatting)]
3678 let non_field_children = {
3679 let mut cursor = node.walk();
3680 let mut result = ::std::vec::Vec::new();
3681 if cursor.goto_first_child() {
3682 loop {
3683 if cursor.field_name().is_none()
3684 && cursor.node().is_named()
3685 && !cursor.node().is_extra()
3686 {
3687 result.push(cursor.node());
3688 }
3689 if !cursor.goto_next_sibling() {
3690 break;
3691 }
3692 }
3693 }
3694 result
3695 };
3696 let mut items = ::std::vec::Vec::new();
3697 for child in non_field_children {
3698 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3699 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
3700 child, src,
3701 )
3702 })?);
3703 }
3704 items
3705 },
3706 })
3707 }
3708}
3709impl ::treesitter_types::Spanned for ParameterList<'_> {
3710 fn span(&self) -> ::treesitter_types::Span {
3711 self.span
3712 }
3713}
3714#[derive(Debug, Clone, PartialEq, Eq)]
3715pub struct ParenthesizedExpression<'tree> {
3716 pub span: ::treesitter_types::Span,
3717 pub children: Expression<'tree>,
3718}
3719impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
3720 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3721 fn from_node(
3722 node: ::treesitter_types::tree_sitter::Node<'tree>,
3723 src: &'tree [u8],
3724 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3725 debug_assert_eq!(node.kind(), "parenthesized_expression");
3726 Ok(Self {
3727 span: ::treesitter_types::Span::from(node),
3728 children: {
3729 #[allow(clippy::suspicious_else_formatting)]
3730 let non_field_children = {
3731 let mut cursor = node.walk();
3732 let mut result = ::std::vec::Vec::new();
3733 if cursor.goto_first_child() {
3734 loop {
3735 if cursor.field_name().is_none()
3736 && cursor.node().is_named()
3737 && !cursor.node().is_extra()
3738 {
3739 result.push(cursor.node());
3740 }
3741 if !cursor.goto_next_sibling() {
3742 break;
3743 }
3744 }
3745 }
3746 result
3747 };
3748 let child = if let Some(&c) = non_field_children.first() {
3749 c
3750 } else {
3751 let mut fallback_cursor = node.walk();
3752 let mut fallback_child = None;
3753 if fallback_cursor.goto_first_child() {
3754 loop {
3755 if fallback_cursor.field_name().is_none()
3756 && !fallback_cursor.node().is_extra()
3757 {
3758 let candidate = fallback_cursor.node();
3759 #[allow(clippy::needless_question_mark)]
3760 if (|| -> ::core::result::Result<
3761 _,
3762 ::treesitter_types::ParseError,
3763 > {
3764 let child = candidate;
3765 Ok(
3766 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3767 child,
3768 src,
3769 ))?,
3770 )
3771 })()
3772 .is_ok()
3773 {
3774 fallback_child = Some(candidate);
3775 break;
3776 }
3777 }
3778 if !fallback_cursor.goto_next_sibling() {
3779 break;
3780 }
3781 }
3782 }
3783 if fallback_child.is_none() {
3784 let mut cursor2 = node.walk();
3785 if cursor2.goto_first_child() {
3786 loop {
3787 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3788 let candidate = cursor2.node();
3789 #[allow(clippy::needless_question_mark)]
3790 if (|| -> ::core::result::Result<
3791 _,
3792 ::treesitter_types::ParseError,
3793 > {
3794 let child = candidate;
3795 Ok(
3796 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3797 child,
3798 src,
3799 ))?,
3800 )
3801 })()
3802 .is_ok()
3803 {
3804 fallback_child = Some(candidate);
3805 break;
3806 }
3807 }
3808 if !cursor2.goto_next_sibling() {
3809 break;
3810 }
3811 }
3812 }
3813 }
3814 fallback_child.ok_or_else(|| {
3815 ::treesitter_types::ParseError::missing_field("children", node)
3816 })?
3817 };
3818 ::treesitter_types::runtime::maybe_grow_stack(|| {
3819 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3820 })?
3821 },
3822 })
3823 }
3824}
3825impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
3826 fn span(&self) -> ::treesitter_types::Span {
3827 self.span
3828 }
3829}
3830#[derive(Debug, Clone, PartialEq, Eq)]
3831pub struct ParenthesizedType<'tree> {
3832 pub span: ::treesitter_types::Span,
3833 pub children: Type<'tree>,
3834}
3835impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedType<'tree> {
3836 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3837 fn from_node(
3838 node: ::treesitter_types::tree_sitter::Node<'tree>,
3839 src: &'tree [u8],
3840 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3841 debug_assert_eq!(node.kind(), "parenthesized_type");
3842 Ok(Self {
3843 span: ::treesitter_types::Span::from(node),
3844 children: {
3845 #[allow(clippy::suspicious_else_formatting)]
3846 let non_field_children = {
3847 let mut cursor = node.walk();
3848 let mut result = ::std::vec::Vec::new();
3849 if cursor.goto_first_child() {
3850 loop {
3851 if cursor.field_name().is_none()
3852 && cursor.node().is_named()
3853 && !cursor.node().is_extra()
3854 {
3855 result.push(cursor.node());
3856 }
3857 if !cursor.goto_next_sibling() {
3858 break;
3859 }
3860 }
3861 }
3862 result
3863 };
3864 let child = if let Some(&c) = non_field_children.first() {
3865 c
3866 } else {
3867 let mut fallback_cursor = node.walk();
3868 let mut fallback_child = None;
3869 if fallback_cursor.goto_first_child() {
3870 loop {
3871 if fallback_cursor.field_name().is_none()
3872 && !fallback_cursor.node().is_extra()
3873 {
3874 let candidate = fallback_cursor.node();
3875 #[allow(clippy::needless_question_mark)]
3876 if (|| -> ::core::result::Result<
3877 _,
3878 ::treesitter_types::ParseError,
3879 > {
3880 let child = candidate;
3881 Ok(
3882 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
3883 child,
3884 src,
3885 ))?,
3886 )
3887 })()
3888 .is_ok()
3889 {
3890 fallback_child = Some(candidate);
3891 break;
3892 }
3893 }
3894 if !fallback_cursor.goto_next_sibling() {
3895 break;
3896 }
3897 }
3898 }
3899 if fallback_child.is_none() {
3900 let mut cursor2 = node.walk();
3901 if cursor2.goto_first_child() {
3902 loop {
3903 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3904 let candidate = cursor2.node();
3905 #[allow(clippy::needless_question_mark)]
3906 if (|| -> ::core::result::Result<
3907 _,
3908 ::treesitter_types::ParseError,
3909 > {
3910 let child = candidate;
3911 Ok(
3912 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
3913 child,
3914 src,
3915 ))?,
3916 )
3917 })()
3918 .is_ok()
3919 {
3920 fallback_child = Some(candidate);
3921 break;
3922 }
3923 }
3924 if !cursor2.goto_next_sibling() {
3925 break;
3926 }
3927 }
3928 }
3929 }
3930 fallback_child.ok_or_else(|| {
3931 ::treesitter_types::ParseError::missing_field("children", node)
3932 })?
3933 };
3934 ::treesitter_types::runtime::maybe_grow_stack(|| {
3935 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3936 })?
3937 },
3938 })
3939 }
3940}
3941impl ::treesitter_types::Spanned for ParenthesizedType<'_> {
3942 fn span(&self) -> ::treesitter_types::Span {
3943 self.span
3944 }
3945}
3946#[derive(Debug, Clone, PartialEq, Eq)]
3947pub struct PointerType<'tree> {
3948 pub span: ::treesitter_types::Span,
3949 pub children: Type<'tree>,
3950}
3951impl<'tree> ::treesitter_types::FromNode<'tree> for PointerType<'tree> {
3952 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3953 fn from_node(
3954 node: ::treesitter_types::tree_sitter::Node<'tree>,
3955 src: &'tree [u8],
3956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3957 debug_assert_eq!(node.kind(), "pointer_type");
3958 Ok(Self {
3959 span: ::treesitter_types::Span::from(node),
3960 children: {
3961 #[allow(clippy::suspicious_else_formatting)]
3962 let non_field_children = {
3963 let mut cursor = node.walk();
3964 let mut result = ::std::vec::Vec::new();
3965 if cursor.goto_first_child() {
3966 loop {
3967 if cursor.field_name().is_none()
3968 && cursor.node().is_named()
3969 && !cursor.node().is_extra()
3970 {
3971 result.push(cursor.node());
3972 }
3973 if !cursor.goto_next_sibling() {
3974 break;
3975 }
3976 }
3977 }
3978 result
3979 };
3980 let child = if let Some(&c) = non_field_children.first() {
3981 c
3982 } else {
3983 let mut fallback_cursor = node.walk();
3984 let mut fallback_child = None;
3985 if fallback_cursor.goto_first_child() {
3986 loop {
3987 if fallback_cursor.field_name().is_none()
3988 && !fallback_cursor.node().is_extra()
3989 {
3990 let candidate = fallback_cursor.node();
3991 #[allow(clippy::needless_question_mark)]
3992 if (|| -> ::core::result::Result<
3993 _,
3994 ::treesitter_types::ParseError,
3995 > {
3996 let child = candidate;
3997 Ok(
3998 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
3999 child,
4000 src,
4001 ))?,
4002 )
4003 })()
4004 .is_ok()
4005 {
4006 fallback_child = Some(candidate);
4007 break;
4008 }
4009 }
4010 if !fallback_cursor.goto_next_sibling() {
4011 break;
4012 }
4013 }
4014 }
4015 if fallback_child.is_none() {
4016 let mut cursor2 = node.walk();
4017 if cursor2.goto_first_child() {
4018 loop {
4019 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4020 let candidate = cursor2.node();
4021 #[allow(clippy::needless_question_mark)]
4022 if (|| -> ::core::result::Result<
4023 _,
4024 ::treesitter_types::ParseError,
4025 > {
4026 let child = candidate;
4027 Ok(
4028 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
4029 child,
4030 src,
4031 ))?,
4032 )
4033 })()
4034 .is_ok()
4035 {
4036 fallback_child = Some(candidate);
4037 break;
4038 }
4039 }
4040 if !cursor2.goto_next_sibling() {
4041 break;
4042 }
4043 }
4044 }
4045 }
4046 fallback_child.ok_or_else(|| {
4047 ::treesitter_types::ParseError::missing_field("children", node)
4048 })?
4049 };
4050 ::treesitter_types::runtime::maybe_grow_stack(|| {
4051 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4052 })?
4053 },
4054 })
4055 }
4056}
4057impl ::treesitter_types::Spanned for PointerType<'_> {
4058 fn span(&self) -> ::treesitter_types::Span {
4059 self.span
4060 }
4061}
4062#[derive(Debug, Clone, PartialEq, Eq)]
4063pub struct QualifiedType<'tree> {
4064 pub span: ::treesitter_types::Span,
4065 pub name: TypeIdentifier<'tree>,
4066 pub package: PackageIdentifier<'tree>,
4067}
4068impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedType<'tree> {
4069 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4070 fn from_node(
4071 node: ::treesitter_types::tree_sitter::Node<'tree>,
4072 src: &'tree [u8],
4073 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4074 debug_assert_eq!(node.kind(), "qualified_type");
4075 Ok(Self {
4076 span: ::treesitter_types::Span::from(node),
4077 name: {
4078 let child = node
4079 .child_by_field_name("name")
4080 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4081 ::treesitter_types::runtime::maybe_grow_stack(|| {
4082 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4083 })?
4084 },
4085 package: {
4086 let child = node.child_by_field_name("package").ok_or_else(|| {
4087 ::treesitter_types::ParseError::missing_field("package", node)
4088 })?;
4089 ::treesitter_types::runtime::maybe_grow_stack(|| {
4090 <PackageIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4091 })?
4092 },
4093 })
4094 }
4095}
4096impl ::treesitter_types::Spanned for QualifiedType<'_> {
4097 fn span(&self) -> ::treesitter_types::Span {
4098 self.span
4099 }
4100}
4101#[derive(Debug, Clone, PartialEq, Eq)]
4102pub struct RangeClause<'tree> {
4103 pub span: ::treesitter_types::Span,
4104 pub left: ::core::option::Option<ExpressionList<'tree>>,
4105 pub right: Expression<'tree>,
4106}
4107impl<'tree> ::treesitter_types::FromNode<'tree> for RangeClause<'tree> {
4108 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4109 fn from_node(
4110 node: ::treesitter_types::tree_sitter::Node<'tree>,
4111 src: &'tree [u8],
4112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4113 debug_assert_eq!(node.kind(), "range_clause");
4114 Ok(Self {
4115 span: ::treesitter_types::Span::from(node),
4116 left: match node.child_by_field_name("left") {
4117 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4118 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
4119 })?),
4120 None => None,
4121 },
4122 right: {
4123 let child = node
4124 .child_by_field_name("right")
4125 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4126 ::treesitter_types::runtime::maybe_grow_stack(|| {
4127 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4128 })?
4129 },
4130 })
4131 }
4132}
4133impl ::treesitter_types::Spanned for RangeClause<'_> {
4134 fn span(&self) -> ::treesitter_types::Span {
4135 self.span
4136 }
4137}
4138#[derive(Debug, Clone, PartialEq, Eq)]
4139pub struct RawStringLiteral<'tree> {
4140 pub span: ::treesitter_types::Span,
4141 pub children: RawStringLiteralContent<'tree>,
4142}
4143impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
4144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4145 fn from_node(
4146 node: ::treesitter_types::tree_sitter::Node<'tree>,
4147 src: &'tree [u8],
4148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4149 debug_assert_eq!(node.kind(), "raw_string_literal");
4150 Ok(Self {
4151 span: ::treesitter_types::Span::from(node),
4152 children: {
4153 #[allow(clippy::suspicious_else_formatting)]
4154 let non_field_children = {
4155 let mut cursor = node.walk();
4156 let mut result = ::std::vec::Vec::new();
4157 if cursor.goto_first_child() {
4158 loop {
4159 if cursor.field_name().is_none()
4160 && cursor.node().is_named()
4161 && !cursor.node().is_extra()
4162 {
4163 result.push(cursor.node());
4164 }
4165 if !cursor.goto_next_sibling() {
4166 break;
4167 }
4168 }
4169 }
4170 result
4171 };
4172 let child = if let Some(&c) = non_field_children.first() {
4173 c
4174 } else {
4175 let mut fallback_cursor = node.walk();
4176 let mut fallback_child = None;
4177 if fallback_cursor.goto_first_child() {
4178 loop {
4179 if fallback_cursor.field_name().is_none()
4180 && !fallback_cursor.node().is_extra()
4181 {
4182 let candidate = fallback_cursor.node();
4183 #[allow(clippy::needless_question_mark)]
4184 if (|| -> ::core::result::Result<
4185 _,
4186 ::treesitter_types::ParseError,
4187 > {
4188 let child = candidate;
4189 Ok(
4190 ::treesitter_types::runtime::maybe_grow_stack(|| <RawStringLiteralContent as ::treesitter_types::FromNode>::from_node(
4191 child,
4192 src,
4193 ))?,
4194 )
4195 })()
4196 .is_ok()
4197 {
4198 fallback_child = Some(candidate);
4199 break;
4200 }
4201 }
4202 if !fallback_cursor.goto_next_sibling() {
4203 break;
4204 }
4205 }
4206 }
4207 if fallback_child.is_none() {
4208 let mut cursor2 = node.walk();
4209 if cursor2.goto_first_child() {
4210 loop {
4211 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4212 let candidate = cursor2.node();
4213 #[allow(clippy::needless_question_mark)]
4214 if (|| -> ::core::result::Result<
4215 _,
4216 ::treesitter_types::ParseError,
4217 > {
4218 let child = candidate;
4219 Ok(
4220 ::treesitter_types::runtime::maybe_grow_stack(|| <RawStringLiteralContent as ::treesitter_types::FromNode>::from_node(
4221 child,
4222 src,
4223 ))?,
4224 )
4225 })()
4226 .is_ok()
4227 {
4228 fallback_child = Some(candidate);
4229 break;
4230 }
4231 }
4232 if !cursor2.goto_next_sibling() {
4233 break;
4234 }
4235 }
4236 }
4237 }
4238 fallback_child.ok_or_else(|| {
4239 ::treesitter_types::ParseError::missing_field("children", node)
4240 })?
4241 };
4242 ::treesitter_types::runtime::maybe_grow_stack(|| {
4243 <RawStringLiteralContent as ::treesitter_types::FromNode>::from_node(child, src)
4244 })?
4245 },
4246 })
4247 }
4248}
4249impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
4250 fn span(&self) -> ::treesitter_types::Span {
4251 self.span
4252 }
4253}
4254#[derive(Debug, Clone, PartialEq, Eq)]
4255pub struct ReceiveStatement<'tree> {
4256 pub span: ::treesitter_types::Span,
4257 pub left: ::core::option::Option<ExpressionList<'tree>>,
4258 pub right: Expression<'tree>,
4259}
4260impl<'tree> ::treesitter_types::FromNode<'tree> for ReceiveStatement<'tree> {
4261 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4262 fn from_node(
4263 node: ::treesitter_types::tree_sitter::Node<'tree>,
4264 src: &'tree [u8],
4265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4266 debug_assert_eq!(node.kind(), "receive_statement");
4267 Ok(Self {
4268 span: ::treesitter_types::Span::from(node),
4269 left: match node.child_by_field_name("left") {
4270 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4271 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
4272 })?),
4273 None => None,
4274 },
4275 right: {
4276 let child = node
4277 .child_by_field_name("right")
4278 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4279 ::treesitter_types::runtime::maybe_grow_stack(|| {
4280 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4281 })?
4282 },
4283 })
4284 }
4285}
4286impl ::treesitter_types::Spanned for ReceiveStatement<'_> {
4287 fn span(&self) -> ::treesitter_types::Span {
4288 self.span
4289 }
4290}
4291#[derive(Debug, Clone, PartialEq, Eq)]
4292pub struct ReturnStatement<'tree> {
4293 pub span: ::treesitter_types::Span,
4294 pub children: ::core::option::Option<ExpressionList<'tree>>,
4295}
4296impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
4297 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4298 fn from_node(
4299 node: ::treesitter_types::tree_sitter::Node<'tree>,
4300 src: &'tree [u8],
4301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4302 debug_assert_eq!(node.kind(), "return_statement");
4303 Ok(Self {
4304 span: ::treesitter_types::Span::from(node),
4305 children: {
4306 #[allow(clippy::suspicious_else_formatting)]
4307 let non_field_children = {
4308 let mut cursor = node.walk();
4309 let mut result = ::std::vec::Vec::new();
4310 if cursor.goto_first_child() {
4311 loop {
4312 if cursor.field_name().is_none()
4313 && cursor.node().is_named()
4314 && !cursor.node().is_extra()
4315 {
4316 result.push(cursor.node());
4317 }
4318 if !cursor.goto_next_sibling() {
4319 break;
4320 }
4321 }
4322 }
4323 result
4324 };
4325 match non_field_children.first() {
4326 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4327 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
4328 })?),
4329 None => None,
4330 }
4331 },
4332 })
4333 }
4334}
4335impl ::treesitter_types::Spanned for ReturnStatement<'_> {
4336 fn span(&self) -> ::treesitter_types::Span {
4337 self.span
4338 }
4339}
4340#[derive(Debug, Clone, PartialEq, Eq)]
4341pub struct SelectStatement<'tree> {
4342 pub span: ::treesitter_types::Span,
4343 pub children: ::std::vec::Vec<SelectStatementChildren<'tree>>,
4344}
4345impl<'tree> ::treesitter_types::FromNode<'tree> for SelectStatement<'tree> {
4346 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4347 fn from_node(
4348 node: ::treesitter_types::tree_sitter::Node<'tree>,
4349 src: &'tree [u8],
4350 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4351 debug_assert_eq!(node.kind(), "select_statement");
4352 Ok(Self {
4353 span: ::treesitter_types::Span::from(node),
4354 children: {
4355 #[allow(clippy::suspicious_else_formatting)]
4356 let non_field_children = {
4357 let mut cursor = node.walk();
4358 let mut result = ::std::vec::Vec::new();
4359 if cursor.goto_first_child() {
4360 loop {
4361 if cursor.field_name().is_none()
4362 && cursor.node().is_named()
4363 && !cursor.node().is_extra()
4364 {
4365 result.push(cursor.node());
4366 }
4367 if !cursor.goto_next_sibling() {
4368 break;
4369 }
4370 }
4371 }
4372 result
4373 };
4374 let mut items = ::std::vec::Vec::new();
4375 for child in non_field_children {
4376 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4377 <SelectStatementChildren as ::treesitter_types::FromNode>::from_node(
4378 child, src,
4379 )
4380 })?);
4381 }
4382 items
4383 },
4384 })
4385 }
4386}
4387impl ::treesitter_types::Spanned for SelectStatement<'_> {
4388 fn span(&self) -> ::treesitter_types::Span {
4389 self.span
4390 }
4391}
4392#[derive(Debug, Clone, PartialEq, Eq)]
4393pub struct SelectorExpression<'tree> {
4394 pub span: ::treesitter_types::Span,
4395 pub field: FieldIdentifier<'tree>,
4396 pub operand: Expression<'tree>,
4397}
4398impl<'tree> ::treesitter_types::FromNode<'tree> for SelectorExpression<'tree> {
4399 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4400 fn from_node(
4401 node: ::treesitter_types::tree_sitter::Node<'tree>,
4402 src: &'tree [u8],
4403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4404 debug_assert_eq!(node.kind(), "selector_expression");
4405 Ok(Self {
4406 span: ::treesitter_types::Span::from(node),
4407 field: {
4408 let child = node
4409 .child_by_field_name("field")
4410 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
4411 ::treesitter_types::runtime::maybe_grow_stack(|| {
4412 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4413 })?
4414 },
4415 operand: {
4416 let child = node.child_by_field_name("operand").ok_or_else(|| {
4417 ::treesitter_types::ParseError::missing_field("operand", node)
4418 })?;
4419 ::treesitter_types::runtime::maybe_grow_stack(|| {
4420 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4421 })?
4422 },
4423 })
4424 }
4425}
4426impl ::treesitter_types::Spanned for SelectorExpression<'_> {
4427 fn span(&self) -> ::treesitter_types::Span {
4428 self.span
4429 }
4430}
4431#[derive(Debug, Clone, PartialEq, Eq)]
4432pub struct SendStatement<'tree> {
4433 pub span: ::treesitter_types::Span,
4434 pub channel: Expression<'tree>,
4435 pub value: Expression<'tree>,
4436}
4437impl<'tree> ::treesitter_types::FromNode<'tree> for SendStatement<'tree> {
4438 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4439 fn from_node(
4440 node: ::treesitter_types::tree_sitter::Node<'tree>,
4441 src: &'tree [u8],
4442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4443 debug_assert_eq!(node.kind(), "send_statement");
4444 Ok(Self {
4445 span: ::treesitter_types::Span::from(node),
4446 channel: {
4447 let child = node.child_by_field_name("channel").ok_or_else(|| {
4448 ::treesitter_types::ParseError::missing_field("channel", node)
4449 })?;
4450 ::treesitter_types::runtime::maybe_grow_stack(|| {
4451 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4452 })?
4453 },
4454 value: {
4455 let child = node
4456 .child_by_field_name("value")
4457 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4458 ::treesitter_types::runtime::maybe_grow_stack(|| {
4459 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4460 })?
4461 },
4462 })
4463 }
4464}
4465impl ::treesitter_types::Spanned for SendStatement<'_> {
4466 fn span(&self) -> ::treesitter_types::Span {
4467 self.span
4468 }
4469}
4470#[derive(Debug, Clone, PartialEq, Eq)]
4471pub struct ShortVarDeclaration<'tree> {
4472 pub span: ::treesitter_types::Span,
4473 pub left: ExpressionList<'tree>,
4474 pub right: ExpressionList<'tree>,
4475}
4476impl<'tree> ::treesitter_types::FromNode<'tree> for ShortVarDeclaration<'tree> {
4477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4478 fn from_node(
4479 node: ::treesitter_types::tree_sitter::Node<'tree>,
4480 src: &'tree [u8],
4481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4482 debug_assert_eq!(node.kind(), "short_var_declaration");
4483 Ok(Self {
4484 span: ::treesitter_types::Span::from(node),
4485 left: {
4486 let child = node
4487 .child_by_field_name("left")
4488 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4489 ::treesitter_types::runtime::maybe_grow_stack(|| {
4490 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
4491 })?
4492 },
4493 right: {
4494 let child = node
4495 .child_by_field_name("right")
4496 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4497 ::treesitter_types::runtime::maybe_grow_stack(|| {
4498 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
4499 })?
4500 },
4501 })
4502 }
4503}
4504impl ::treesitter_types::Spanned for ShortVarDeclaration<'_> {
4505 fn span(&self) -> ::treesitter_types::Span {
4506 self.span
4507 }
4508}
4509#[derive(Debug, Clone, PartialEq, Eq)]
4510pub struct SliceExpression<'tree> {
4511 pub span: ::treesitter_types::Span,
4512 pub capacity: ::core::option::Option<Expression<'tree>>,
4513 pub end: ::core::option::Option<Expression<'tree>>,
4514 pub operand: Expression<'tree>,
4515 pub start: ::core::option::Option<Expression<'tree>>,
4516}
4517impl<'tree> ::treesitter_types::FromNode<'tree> for SliceExpression<'tree> {
4518 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4519 fn from_node(
4520 node: ::treesitter_types::tree_sitter::Node<'tree>,
4521 src: &'tree [u8],
4522 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4523 debug_assert_eq!(node.kind(), "slice_expression");
4524 Ok(Self {
4525 span: ::treesitter_types::Span::from(node),
4526 capacity: match node.child_by_field_name("capacity") {
4527 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4528 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4529 })?),
4530 None => None,
4531 },
4532 end: match node.child_by_field_name("end") {
4533 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4534 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4535 })?),
4536 None => None,
4537 },
4538 operand: {
4539 let child = node.child_by_field_name("operand").ok_or_else(|| {
4540 ::treesitter_types::ParseError::missing_field("operand", node)
4541 })?;
4542 ::treesitter_types::runtime::maybe_grow_stack(|| {
4543 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4544 })?
4545 },
4546 start: match node.child_by_field_name("start") {
4547 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4548 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4549 })?),
4550 None => None,
4551 },
4552 })
4553 }
4554}
4555impl ::treesitter_types::Spanned for SliceExpression<'_> {
4556 fn span(&self) -> ::treesitter_types::Span {
4557 self.span
4558 }
4559}
4560#[derive(Debug, Clone, PartialEq, Eq)]
4561pub struct SliceType<'tree> {
4562 pub span: ::treesitter_types::Span,
4563 pub element: Type<'tree>,
4564}
4565impl<'tree> ::treesitter_types::FromNode<'tree> for SliceType<'tree> {
4566 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4567 fn from_node(
4568 node: ::treesitter_types::tree_sitter::Node<'tree>,
4569 src: &'tree [u8],
4570 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4571 debug_assert_eq!(node.kind(), "slice_type");
4572 Ok(Self {
4573 span: ::treesitter_types::Span::from(node),
4574 element: {
4575 let child = node.child_by_field_name("element").ok_or_else(|| {
4576 ::treesitter_types::ParseError::missing_field("element", node)
4577 })?;
4578 ::treesitter_types::runtime::maybe_grow_stack(|| {
4579 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4580 })?
4581 },
4582 })
4583 }
4584}
4585impl ::treesitter_types::Spanned for SliceType<'_> {
4586 fn span(&self) -> ::treesitter_types::Span {
4587 self.span
4588 }
4589}
4590#[derive(Debug, Clone, PartialEq, Eq)]
4591pub struct SourceFile<'tree> {
4592 pub span: ::treesitter_types::Span,
4593 pub children: ::std::vec::Vec<SourceFileChildren<'tree>>,
4594}
4595impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFile<'tree> {
4596 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4597 fn from_node(
4598 node: ::treesitter_types::tree_sitter::Node<'tree>,
4599 src: &'tree [u8],
4600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4601 debug_assert_eq!(node.kind(), "source_file");
4602 Ok(Self {
4603 span: ::treesitter_types::Span::from(node),
4604 children: {
4605 #[allow(clippy::suspicious_else_formatting)]
4606 let non_field_children = {
4607 let mut cursor = node.walk();
4608 let mut result = ::std::vec::Vec::new();
4609 if cursor.goto_first_child() {
4610 loop {
4611 if cursor.field_name().is_none()
4612 && cursor.node().is_named()
4613 && !cursor.node().is_extra()
4614 {
4615 result.push(cursor.node());
4616 }
4617 if !cursor.goto_next_sibling() {
4618 break;
4619 }
4620 }
4621 }
4622 result
4623 };
4624 let mut items = ::std::vec::Vec::new();
4625 for child in non_field_children {
4626 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4627 <SourceFileChildren as ::treesitter_types::FromNode>::from_node(child, src)
4628 })?);
4629 }
4630 items
4631 },
4632 })
4633 }
4634}
4635impl ::treesitter_types::Spanned for SourceFile<'_> {
4636 fn span(&self) -> ::treesitter_types::Span {
4637 self.span
4638 }
4639}
4640#[derive(Debug, Clone, PartialEq, Eq)]
4641pub struct StatementList<'tree> {
4642 pub span: ::treesitter_types::Span,
4643 pub children: ::std::vec::Vec<Statement<'tree>>,
4644}
4645impl<'tree> ::treesitter_types::FromNode<'tree> for StatementList<'tree> {
4646 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4647 fn from_node(
4648 node: ::treesitter_types::tree_sitter::Node<'tree>,
4649 src: &'tree [u8],
4650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4651 debug_assert_eq!(node.kind(), "statement_list");
4652 Ok(Self {
4653 span: ::treesitter_types::Span::from(node),
4654 children: {
4655 #[allow(clippy::suspicious_else_formatting)]
4656 let non_field_children = {
4657 let mut cursor = node.walk();
4658 let mut result = ::std::vec::Vec::new();
4659 if cursor.goto_first_child() {
4660 loop {
4661 if cursor.field_name().is_none()
4662 && cursor.node().is_named()
4663 && !cursor.node().is_extra()
4664 {
4665 result.push(cursor.node());
4666 }
4667 if !cursor.goto_next_sibling() {
4668 break;
4669 }
4670 }
4671 }
4672 result
4673 };
4674 let mut items = ::std::vec::Vec::new();
4675 for child in non_field_children {
4676 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4677 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4678 })?);
4679 }
4680 items
4681 },
4682 })
4683 }
4684}
4685impl ::treesitter_types::Spanned for StatementList<'_> {
4686 fn span(&self) -> ::treesitter_types::Span {
4687 self.span
4688 }
4689}
4690#[derive(Debug, Clone, PartialEq, Eq)]
4691pub struct StructType<'tree> {
4692 pub span: ::treesitter_types::Span,
4693 pub children: FieldDeclarationList<'tree>,
4694}
4695impl<'tree> ::treesitter_types::FromNode<'tree> for StructType<'tree> {
4696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4697 fn from_node(
4698 node: ::treesitter_types::tree_sitter::Node<'tree>,
4699 src: &'tree [u8],
4700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4701 debug_assert_eq!(node.kind(), "struct_type");
4702 Ok(Self {
4703 span: ::treesitter_types::Span::from(node),
4704 children: {
4705 #[allow(clippy::suspicious_else_formatting)]
4706 let non_field_children = {
4707 let mut cursor = node.walk();
4708 let mut result = ::std::vec::Vec::new();
4709 if cursor.goto_first_child() {
4710 loop {
4711 if cursor.field_name().is_none()
4712 && cursor.node().is_named()
4713 && !cursor.node().is_extra()
4714 {
4715 result.push(cursor.node());
4716 }
4717 if !cursor.goto_next_sibling() {
4718 break;
4719 }
4720 }
4721 }
4722 result
4723 };
4724 let child = if let Some(&c) = non_field_children.first() {
4725 c
4726 } else {
4727 let mut fallback_cursor = node.walk();
4728 let mut fallback_child = None;
4729 if fallback_cursor.goto_first_child() {
4730 loop {
4731 if fallback_cursor.field_name().is_none()
4732 && !fallback_cursor.node().is_extra()
4733 {
4734 let candidate = fallback_cursor.node();
4735 #[allow(clippy::needless_question_mark)]
4736 if (|| -> ::core::result::Result<
4737 _,
4738 ::treesitter_types::ParseError,
4739 > {
4740 let child = candidate;
4741 Ok(
4742 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(
4743 child,
4744 src,
4745 ))?,
4746 )
4747 })()
4748 .is_ok()
4749 {
4750 fallback_child = Some(candidate);
4751 break;
4752 }
4753 }
4754 if !fallback_cursor.goto_next_sibling() {
4755 break;
4756 }
4757 }
4758 }
4759 if fallback_child.is_none() {
4760 let mut cursor2 = node.walk();
4761 if cursor2.goto_first_child() {
4762 loop {
4763 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4764 let candidate = cursor2.node();
4765 #[allow(clippy::needless_question_mark)]
4766 if (|| -> ::core::result::Result<
4767 _,
4768 ::treesitter_types::ParseError,
4769 > {
4770 let child = candidate;
4771 Ok(
4772 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(
4773 child,
4774 src,
4775 ))?,
4776 )
4777 })()
4778 .is_ok()
4779 {
4780 fallback_child = Some(candidate);
4781 break;
4782 }
4783 }
4784 if !cursor2.goto_next_sibling() {
4785 break;
4786 }
4787 }
4788 }
4789 }
4790 fallback_child.ok_or_else(|| {
4791 ::treesitter_types::ParseError::missing_field("children", node)
4792 })?
4793 };
4794 ::treesitter_types::runtime::maybe_grow_stack(|| {
4795 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
4796 })?
4797 },
4798 })
4799 }
4800}
4801impl ::treesitter_types::Spanned for StructType<'_> {
4802 fn span(&self) -> ::treesitter_types::Span {
4803 self.span
4804 }
4805}
4806#[derive(Debug, Clone, PartialEq, Eq)]
4807pub struct TypeAlias<'tree> {
4808 pub span: ::treesitter_types::Span,
4809 pub name: TypeIdentifier<'tree>,
4810 pub r#type: Type<'tree>,
4811 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
4812}
4813impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAlias<'tree> {
4814 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4815 fn from_node(
4816 node: ::treesitter_types::tree_sitter::Node<'tree>,
4817 src: &'tree [u8],
4818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4819 debug_assert_eq!(node.kind(), "type_alias");
4820 Ok(Self {
4821 span: ::treesitter_types::Span::from(node),
4822 name: {
4823 let child = node
4824 .child_by_field_name("name")
4825 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4826 ::treesitter_types::runtime::maybe_grow_stack(|| {
4827 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4828 })?
4829 },
4830 r#type: {
4831 let child = node
4832 .child_by_field_name("type")
4833 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4834 ::treesitter_types::runtime::maybe_grow_stack(|| {
4835 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4836 })?
4837 },
4838 type_parameters: match node.child_by_field_name("type_parameters") {
4839 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4840 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
4841 })?),
4842 None => None,
4843 },
4844 })
4845 }
4846}
4847impl ::treesitter_types::Spanned for TypeAlias<'_> {
4848 fn span(&self) -> ::treesitter_types::Span {
4849 self.span
4850 }
4851}
4852#[derive(Debug, Clone, PartialEq, Eq)]
4853pub struct TypeArguments<'tree> {
4854 pub span: ::treesitter_types::Span,
4855 pub children: ::std::vec::Vec<TypeElem<'tree>>,
4856}
4857impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
4858 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4859 fn from_node(
4860 node: ::treesitter_types::tree_sitter::Node<'tree>,
4861 src: &'tree [u8],
4862 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4863 debug_assert_eq!(node.kind(), "type_arguments");
4864 Ok(Self {
4865 span: ::treesitter_types::Span::from(node),
4866 children: {
4867 #[allow(clippy::suspicious_else_formatting)]
4868 let non_field_children = {
4869 let mut cursor = node.walk();
4870 let mut result = ::std::vec::Vec::new();
4871 if cursor.goto_first_child() {
4872 loop {
4873 if cursor.field_name().is_none()
4874 && cursor.node().is_named()
4875 && !cursor.node().is_extra()
4876 {
4877 result.push(cursor.node());
4878 }
4879 if !cursor.goto_next_sibling() {
4880 break;
4881 }
4882 }
4883 }
4884 result
4885 };
4886 let mut items = ::std::vec::Vec::new();
4887 for child in non_field_children {
4888 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4889 <TypeElem as ::treesitter_types::FromNode>::from_node(child, src)
4890 })?);
4891 }
4892 items
4893 },
4894 })
4895 }
4896}
4897impl ::treesitter_types::Spanned for TypeArguments<'_> {
4898 fn span(&self) -> ::treesitter_types::Span {
4899 self.span
4900 }
4901}
4902#[derive(Debug, Clone, PartialEq, Eq)]
4903pub struct TypeAssertionExpression<'tree> {
4904 pub span: ::treesitter_types::Span,
4905 pub operand: Expression<'tree>,
4906 pub r#type: Type<'tree>,
4907}
4908impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAssertionExpression<'tree> {
4909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4910 fn from_node(
4911 node: ::treesitter_types::tree_sitter::Node<'tree>,
4912 src: &'tree [u8],
4913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4914 debug_assert_eq!(node.kind(), "type_assertion_expression");
4915 Ok(Self {
4916 span: ::treesitter_types::Span::from(node),
4917 operand: {
4918 let child = node.child_by_field_name("operand").ok_or_else(|| {
4919 ::treesitter_types::ParseError::missing_field("operand", node)
4920 })?;
4921 ::treesitter_types::runtime::maybe_grow_stack(|| {
4922 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4923 })?
4924 },
4925 r#type: {
4926 let child = node
4927 .child_by_field_name("type")
4928 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4929 ::treesitter_types::runtime::maybe_grow_stack(|| {
4930 <Type as ::treesitter_types::FromNode>::from_node(child, src)
4931 })?
4932 },
4933 })
4934 }
4935}
4936impl ::treesitter_types::Spanned for TypeAssertionExpression<'_> {
4937 fn span(&self) -> ::treesitter_types::Span {
4938 self.span
4939 }
4940}
4941#[derive(Debug, Clone, PartialEq, Eq)]
4942pub struct TypeCase<'tree> {
4943 pub span: ::treesitter_types::Span,
4944 pub r#type: ::std::vec::Vec<TypeCaseType<'tree>>,
4945 pub children: ::core::option::Option<StatementList<'tree>>,
4946}
4947impl<'tree> ::treesitter_types::FromNode<'tree> for TypeCase<'tree> {
4948 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4949 fn from_node(
4950 node: ::treesitter_types::tree_sitter::Node<'tree>,
4951 src: &'tree [u8],
4952 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4953 debug_assert_eq!(node.kind(), "type_case");
4954 Ok(Self {
4955 span: ::treesitter_types::Span::from(node),
4956 r#type: {
4957 let mut cursor = node.walk();
4958 let mut items = ::std::vec::Vec::new();
4959 for child in node.children_by_field_name("type", &mut cursor) {
4960 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4961 <TypeCaseType as ::treesitter_types::FromNode>::from_node(child, src)
4962 })?);
4963 }
4964 items
4965 },
4966 children: {
4967 #[allow(clippy::suspicious_else_formatting)]
4968 let non_field_children = {
4969 let mut cursor = node.walk();
4970 let mut result = ::std::vec::Vec::new();
4971 if cursor.goto_first_child() {
4972 loop {
4973 if cursor.field_name().is_none()
4974 && cursor.node().is_named()
4975 && !cursor.node().is_extra()
4976 {
4977 result.push(cursor.node());
4978 }
4979 if !cursor.goto_next_sibling() {
4980 break;
4981 }
4982 }
4983 }
4984 result
4985 };
4986 match non_field_children.first() {
4987 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4988 <StatementList as ::treesitter_types::FromNode>::from_node(child, src)
4989 })?),
4990 None => None,
4991 }
4992 },
4993 })
4994 }
4995}
4996impl ::treesitter_types::Spanned for TypeCase<'_> {
4997 fn span(&self) -> ::treesitter_types::Span {
4998 self.span
4999 }
5000}
5001#[derive(Debug, Clone, PartialEq, Eq)]
5002pub struct TypeConstraint<'tree> {
5003 pub span: ::treesitter_types::Span,
5004 pub children: ::std::vec::Vec<Type<'tree>>,
5005}
5006impl<'tree> ::treesitter_types::FromNode<'tree> for TypeConstraint<'tree> {
5007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5008 fn from_node(
5009 node: ::treesitter_types::tree_sitter::Node<'tree>,
5010 src: &'tree [u8],
5011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5012 debug_assert_eq!(node.kind(), "type_constraint");
5013 Ok(Self {
5014 span: ::treesitter_types::Span::from(node),
5015 children: {
5016 #[allow(clippy::suspicious_else_formatting)]
5017 let non_field_children = {
5018 let mut cursor = node.walk();
5019 let mut result = ::std::vec::Vec::new();
5020 if cursor.goto_first_child() {
5021 loop {
5022 if cursor.field_name().is_none()
5023 && cursor.node().is_named()
5024 && !cursor.node().is_extra()
5025 {
5026 result.push(cursor.node());
5027 }
5028 if !cursor.goto_next_sibling() {
5029 break;
5030 }
5031 }
5032 }
5033 result
5034 };
5035 let mut items = ::std::vec::Vec::new();
5036 for child in non_field_children {
5037 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5038 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5039 })?);
5040 }
5041 items
5042 },
5043 })
5044 }
5045}
5046impl ::treesitter_types::Spanned for TypeConstraint<'_> {
5047 fn span(&self) -> ::treesitter_types::Span {
5048 self.span
5049 }
5050}
5051#[derive(Debug, Clone, PartialEq, Eq)]
5052pub struct TypeConversionExpression<'tree> {
5053 pub span: ::treesitter_types::Span,
5054 pub operand: Expression<'tree>,
5055 pub r#type: Type<'tree>,
5056}
5057impl<'tree> ::treesitter_types::FromNode<'tree> for TypeConversionExpression<'tree> {
5058 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5059 fn from_node(
5060 node: ::treesitter_types::tree_sitter::Node<'tree>,
5061 src: &'tree [u8],
5062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5063 debug_assert_eq!(node.kind(), "type_conversion_expression");
5064 Ok(Self {
5065 span: ::treesitter_types::Span::from(node),
5066 operand: {
5067 let child = node.child_by_field_name("operand").ok_or_else(|| {
5068 ::treesitter_types::ParseError::missing_field("operand", node)
5069 })?;
5070 ::treesitter_types::runtime::maybe_grow_stack(|| {
5071 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5072 })?
5073 },
5074 r#type: {
5075 let child = node
5076 .child_by_field_name("type")
5077 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5078 ::treesitter_types::runtime::maybe_grow_stack(|| {
5079 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5080 })?
5081 },
5082 })
5083 }
5084}
5085impl ::treesitter_types::Spanned for TypeConversionExpression<'_> {
5086 fn span(&self) -> ::treesitter_types::Span {
5087 self.span
5088 }
5089}
5090#[derive(Debug, Clone, PartialEq, Eq)]
5091pub struct TypeDeclaration<'tree> {
5092 pub span: ::treesitter_types::Span,
5093 pub children: ::std::vec::Vec<TypeDeclarationChildren<'tree>>,
5094}
5095impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclaration<'tree> {
5096 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5097 fn from_node(
5098 node: ::treesitter_types::tree_sitter::Node<'tree>,
5099 src: &'tree [u8],
5100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5101 debug_assert_eq!(node.kind(), "type_declaration");
5102 Ok(Self {
5103 span: ::treesitter_types::Span::from(node),
5104 children: {
5105 #[allow(clippy::suspicious_else_formatting)]
5106 let non_field_children = {
5107 let mut cursor = node.walk();
5108 let mut result = ::std::vec::Vec::new();
5109 if cursor.goto_first_child() {
5110 loop {
5111 if cursor.field_name().is_none()
5112 && cursor.node().is_named()
5113 && !cursor.node().is_extra()
5114 {
5115 result.push(cursor.node());
5116 }
5117 if !cursor.goto_next_sibling() {
5118 break;
5119 }
5120 }
5121 }
5122 result
5123 };
5124 let mut items = ::std::vec::Vec::new();
5125 for child in non_field_children {
5126 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5127 <TypeDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5128 child, src,
5129 )
5130 })?);
5131 }
5132 items
5133 },
5134 })
5135 }
5136}
5137impl ::treesitter_types::Spanned for TypeDeclaration<'_> {
5138 fn span(&self) -> ::treesitter_types::Span {
5139 self.span
5140 }
5141}
5142#[derive(Debug, Clone, PartialEq, Eq)]
5143pub struct TypeElem<'tree> {
5144 pub span: ::treesitter_types::Span,
5145 pub children: ::std::vec::Vec<Type<'tree>>,
5146}
5147impl<'tree> ::treesitter_types::FromNode<'tree> for TypeElem<'tree> {
5148 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5149 fn from_node(
5150 node: ::treesitter_types::tree_sitter::Node<'tree>,
5151 src: &'tree [u8],
5152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5153 debug_assert_eq!(node.kind(), "type_elem");
5154 Ok(Self {
5155 span: ::treesitter_types::Span::from(node),
5156 children: {
5157 #[allow(clippy::suspicious_else_formatting)]
5158 let non_field_children = {
5159 let mut cursor = node.walk();
5160 let mut result = ::std::vec::Vec::new();
5161 if cursor.goto_first_child() {
5162 loop {
5163 if cursor.field_name().is_none()
5164 && cursor.node().is_named()
5165 && !cursor.node().is_extra()
5166 {
5167 result.push(cursor.node());
5168 }
5169 if !cursor.goto_next_sibling() {
5170 break;
5171 }
5172 }
5173 }
5174 result
5175 };
5176 let mut items = ::std::vec::Vec::new();
5177 for child in non_field_children {
5178 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5179 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5180 })?);
5181 }
5182 items
5183 },
5184 })
5185 }
5186}
5187impl ::treesitter_types::Spanned for TypeElem<'_> {
5188 fn span(&self) -> ::treesitter_types::Span {
5189 self.span
5190 }
5191}
5192#[derive(Debug, Clone, PartialEq, Eq)]
5193pub struct TypeInstantiationExpression<'tree> {
5194 pub span: ::treesitter_types::Span,
5195 pub r#type: Type<'tree>,
5196 pub children: ::std::vec::Vec<Type<'tree>>,
5197}
5198impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstantiationExpression<'tree> {
5199 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5200 fn from_node(
5201 node: ::treesitter_types::tree_sitter::Node<'tree>,
5202 src: &'tree [u8],
5203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5204 debug_assert_eq!(node.kind(), "type_instantiation_expression");
5205 Ok(Self {
5206 span: ::treesitter_types::Span::from(node),
5207 r#type: {
5208 let child = node
5209 .child_by_field_name("type")
5210 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5211 ::treesitter_types::runtime::maybe_grow_stack(|| {
5212 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5213 })?
5214 },
5215 children: {
5216 #[allow(clippy::suspicious_else_formatting)]
5217 let non_field_children = {
5218 let mut cursor = node.walk();
5219 let mut result = ::std::vec::Vec::new();
5220 if cursor.goto_first_child() {
5221 loop {
5222 if cursor.field_name().is_none()
5223 && cursor.node().is_named()
5224 && !cursor.node().is_extra()
5225 {
5226 result.push(cursor.node());
5227 }
5228 if !cursor.goto_next_sibling() {
5229 break;
5230 }
5231 }
5232 }
5233 result
5234 };
5235 let mut items = ::std::vec::Vec::new();
5236 for child in non_field_children {
5237 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5238 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5239 })?);
5240 }
5241 items
5242 },
5243 })
5244 }
5245}
5246impl ::treesitter_types::Spanned for TypeInstantiationExpression<'_> {
5247 fn span(&self) -> ::treesitter_types::Span {
5248 self.span
5249 }
5250}
5251#[derive(Debug, Clone, PartialEq, Eq)]
5252pub struct TypeParameterDeclaration<'tree> {
5253 pub span: ::treesitter_types::Span,
5254 pub name: ::std::vec::Vec<Identifier<'tree>>,
5255 pub r#type: TypeConstraint<'tree>,
5256}
5257impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterDeclaration<'tree> {
5258 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5259 fn from_node(
5260 node: ::treesitter_types::tree_sitter::Node<'tree>,
5261 src: &'tree [u8],
5262 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5263 debug_assert_eq!(node.kind(), "type_parameter_declaration");
5264 Ok(Self {
5265 span: ::treesitter_types::Span::from(node),
5266 name: {
5267 let mut cursor = node.walk();
5268 let mut items = ::std::vec::Vec::new();
5269 for child in node.children_by_field_name("name", &mut cursor) {
5270 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5271 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5272 })?);
5273 }
5274 items
5275 },
5276 r#type: {
5277 let child = node
5278 .child_by_field_name("type")
5279 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5280 ::treesitter_types::runtime::maybe_grow_stack(|| {
5281 <TypeConstraint as ::treesitter_types::FromNode>::from_node(child, src)
5282 })?
5283 },
5284 })
5285 }
5286}
5287impl ::treesitter_types::Spanned for TypeParameterDeclaration<'_> {
5288 fn span(&self) -> ::treesitter_types::Span {
5289 self.span
5290 }
5291}
5292#[derive(Debug, Clone, PartialEq, Eq)]
5293pub struct TypeParameterList<'tree> {
5294 pub span: ::treesitter_types::Span,
5295 pub children: ::std::vec::Vec<TypeParameterDeclaration<'tree>>,
5296}
5297impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterList<'tree> {
5298 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5299 fn from_node(
5300 node: ::treesitter_types::tree_sitter::Node<'tree>,
5301 src: &'tree [u8],
5302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5303 debug_assert_eq!(node.kind(), "type_parameter_list");
5304 Ok(Self {
5305 span: ::treesitter_types::Span::from(node),
5306 children: {
5307 #[allow(clippy::suspicious_else_formatting)]
5308 let non_field_children = {
5309 let mut cursor = node.walk();
5310 let mut result = ::std::vec::Vec::new();
5311 if cursor.goto_first_child() {
5312 loop {
5313 if cursor.field_name().is_none()
5314 && cursor.node().is_named()
5315 && !cursor.node().is_extra()
5316 {
5317 result.push(cursor.node());
5318 }
5319 if !cursor.goto_next_sibling() {
5320 break;
5321 }
5322 }
5323 }
5324 result
5325 };
5326 let mut items = ::std::vec::Vec::new();
5327 for child in non_field_children {
5328 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5329 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
5330 child, src,
5331 )
5332 })?);
5333 }
5334 items
5335 },
5336 })
5337 }
5338}
5339impl ::treesitter_types::Spanned for TypeParameterList<'_> {
5340 fn span(&self) -> ::treesitter_types::Span {
5341 self.span
5342 }
5343}
5344#[derive(Debug, Clone, PartialEq, Eq)]
5345pub struct TypeSpec<'tree> {
5346 pub span: ::treesitter_types::Span,
5347 pub name: TypeIdentifier<'tree>,
5348 pub r#type: Type<'tree>,
5349 pub type_parameters: ::core::option::Option<TypeParameterList<'tree>>,
5350}
5351impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSpec<'tree> {
5352 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5353 fn from_node(
5354 node: ::treesitter_types::tree_sitter::Node<'tree>,
5355 src: &'tree [u8],
5356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5357 debug_assert_eq!(node.kind(), "type_spec");
5358 Ok(Self {
5359 span: ::treesitter_types::Span::from(node),
5360 name: {
5361 let child = node
5362 .child_by_field_name("name")
5363 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5364 ::treesitter_types::runtime::maybe_grow_stack(|| {
5365 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
5366 })?
5367 },
5368 r#type: {
5369 let child = node
5370 .child_by_field_name("type")
5371 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5372 ::treesitter_types::runtime::maybe_grow_stack(|| {
5373 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5374 })?
5375 },
5376 type_parameters: match node.child_by_field_name("type_parameters") {
5377 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5378 <TypeParameterList as ::treesitter_types::FromNode>::from_node(child, src)
5379 })?),
5380 None => None,
5381 },
5382 })
5383 }
5384}
5385impl ::treesitter_types::Spanned for TypeSpec<'_> {
5386 fn span(&self) -> ::treesitter_types::Span {
5387 self.span
5388 }
5389}
5390#[derive(Debug, Clone, PartialEq, Eq)]
5391pub struct TypeSwitchStatement<'tree> {
5392 pub span: ::treesitter_types::Span,
5393 pub alias: ::core::option::Option<ExpressionList<'tree>>,
5394 pub initializer: ::core::option::Option<SimpleStatement<'tree>>,
5395 pub value: Expression<'tree>,
5396 pub children: ::std::vec::Vec<TypeSwitchStatementChildren<'tree>>,
5397}
5398impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSwitchStatement<'tree> {
5399 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5400 fn from_node(
5401 node: ::treesitter_types::tree_sitter::Node<'tree>,
5402 src: &'tree [u8],
5403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5404 debug_assert_eq!(node.kind(), "type_switch_statement");
5405 Ok(Self {
5406 span: ::treesitter_types::Span::from(node),
5407 alias: match node.child_by_field_name("alias") {
5408 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5409 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
5410 })?),
5411 None => None,
5412 },
5413 initializer: match node.child_by_field_name("initializer") {
5414 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5415 <SimpleStatement as ::treesitter_types::FromNode>::from_node(child, src)
5416 })?),
5417 None => None,
5418 },
5419 value: {
5420 let child = node
5421 .child_by_field_name("value")
5422 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5423 ::treesitter_types::runtime::maybe_grow_stack(|| {
5424 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5425 })?
5426 },
5427 children: {
5428 #[allow(clippy::suspicious_else_formatting)]
5429 let non_field_children = {
5430 let mut cursor = node.walk();
5431 let mut result = ::std::vec::Vec::new();
5432 if cursor.goto_first_child() {
5433 loop {
5434 if cursor.field_name().is_none()
5435 && cursor.node().is_named()
5436 && !cursor.node().is_extra()
5437 {
5438 result.push(cursor.node());
5439 }
5440 if !cursor.goto_next_sibling() {
5441 break;
5442 }
5443 }
5444 }
5445 result
5446 };
5447 let mut items = ::std::vec::Vec::new();
5448 for child in non_field_children {
5449 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5450 <TypeSwitchStatementChildren as ::treesitter_types::FromNode>::from_node(
5451 child, src,
5452 )
5453 })?);
5454 }
5455 items
5456 },
5457 })
5458 }
5459}
5460impl ::treesitter_types::Spanned for TypeSwitchStatement<'_> {
5461 fn span(&self) -> ::treesitter_types::Span {
5462 self.span
5463 }
5464}
5465#[derive(Debug, Clone, PartialEq, Eq)]
5466pub struct UnaryExpression<'tree> {
5467 pub span: ::treesitter_types::Span,
5468 pub operand: Expression<'tree>,
5469 pub operator: UnaryExpressionOperator,
5470}
5471impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
5472 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5473 fn from_node(
5474 node: ::treesitter_types::tree_sitter::Node<'tree>,
5475 src: &'tree [u8],
5476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5477 debug_assert_eq!(node.kind(), "unary_expression");
5478 Ok(Self {
5479 span: ::treesitter_types::Span::from(node),
5480 operand: {
5481 let child = node.child_by_field_name("operand").ok_or_else(|| {
5482 ::treesitter_types::ParseError::missing_field("operand", node)
5483 })?;
5484 ::treesitter_types::runtime::maybe_grow_stack(|| {
5485 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5486 })?
5487 },
5488 operator: {
5489 let child = node.child_by_field_name("operator").ok_or_else(|| {
5490 ::treesitter_types::ParseError::missing_field("operator", node)
5491 })?;
5492 ::treesitter_types::runtime::maybe_grow_stack(|| {
5493 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
5494 })?
5495 },
5496 })
5497 }
5498}
5499impl ::treesitter_types::Spanned for UnaryExpression<'_> {
5500 fn span(&self) -> ::treesitter_types::Span {
5501 self.span
5502 }
5503}
5504#[derive(Debug, Clone, PartialEq, Eq)]
5505pub struct VarDeclaration<'tree> {
5506 pub span: ::treesitter_types::Span,
5507 pub children: VarDeclarationChildren<'tree>,
5508}
5509impl<'tree> ::treesitter_types::FromNode<'tree> for VarDeclaration<'tree> {
5510 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5511 fn from_node(
5512 node: ::treesitter_types::tree_sitter::Node<'tree>,
5513 src: &'tree [u8],
5514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5515 debug_assert_eq!(node.kind(), "var_declaration");
5516 Ok(Self {
5517 span: ::treesitter_types::Span::from(node),
5518 children: {
5519 #[allow(clippy::suspicious_else_formatting)]
5520 let non_field_children = {
5521 let mut cursor = node.walk();
5522 let mut result = ::std::vec::Vec::new();
5523 if cursor.goto_first_child() {
5524 loop {
5525 if cursor.field_name().is_none()
5526 && cursor.node().is_named()
5527 && !cursor.node().is_extra()
5528 {
5529 result.push(cursor.node());
5530 }
5531 if !cursor.goto_next_sibling() {
5532 break;
5533 }
5534 }
5535 }
5536 result
5537 };
5538 let child = if let Some(&c) = non_field_children.first() {
5539 c
5540 } else {
5541 let mut fallback_cursor = node.walk();
5542 let mut fallback_child = None;
5543 if fallback_cursor.goto_first_child() {
5544 loop {
5545 if fallback_cursor.field_name().is_none()
5546 && !fallback_cursor.node().is_extra()
5547 {
5548 let candidate = fallback_cursor.node();
5549 #[allow(clippy::needless_question_mark)]
5550 if (|| -> ::core::result::Result<
5551 _,
5552 ::treesitter_types::ParseError,
5553 > {
5554 let child = candidate;
5555 Ok(
5556 ::treesitter_types::runtime::maybe_grow_stack(|| <VarDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5557 child,
5558 src,
5559 ))?,
5560 )
5561 })()
5562 .is_ok()
5563 {
5564 fallback_child = Some(candidate);
5565 break;
5566 }
5567 }
5568 if !fallback_cursor.goto_next_sibling() {
5569 break;
5570 }
5571 }
5572 }
5573 if fallback_child.is_none() {
5574 let mut cursor2 = node.walk();
5575 if cursor2.goto_first_child() {
5576 loop {
5577 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5578 let candidate = cursor2.node();
5579 #[allow(clippy::needless_question_mark)]
5580 if (|| -> ::core::result::Result<
5581 _,
5582 ::treesitter_types::ParseError,
5583 > {
5584 let child = candidate;
5585 Ok(
5586 ::treesitter_types::runtime::maybe_grow_stack(|| <VarDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5587 child,
5588 src,
5589 ))?,
5590 )
5591 })()
5592 .is_ok()
5593 {
5594 fallback_child = Some(candidate);
5595 break;
5596 }
5597 }
5598 if !cursor2.goto_next_sibling() {
5599 break;
5600 }
5601 }
5602 }
5603 }
5604 fallback_child.ok_or_else(|| {
5605 ::treesitter_types::ParseError::missing_field("children", node)
5606 })?
5607 };
5608 ::treesitter_types::runtime::maybe_grow_stack(|| {
5609 <VarDeclarationChildren as ::treesitter_types::FromNode>::from_node(child, src)
5610 })?
5611 },
5612 })
5613 }
5614}
5615impl ::treesitter_types::Spanned for VarDeclaration<'_> {
5616 fn span(&self) -> ::treesitter_types::Span {
5617 self.span
5618 }
5619}
5620#[derive(Debug, Clone, PartialEq, Eq)]
5621pub struct VarSpec<'tree> {
5622 pub span: ::treesitter_types::Span,
5623 pub name: ::std::vec::Vec<Identifier<'tree>>,
5624 pub r#type: ::core::option::Option<Type<'tree>>,
5625 pub value: ::core::option::Option<ExpressionList<'tree>>,
5626}
5627impl<'tree> ::treesitter_types::FromNode<'tree> for VarSpec<'tree> {
5628 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5629 fn from_node(
5630 node: ::treesitter_types::tree_sitter::Node<'tree>,
5631 src: &'tree [u8],
5632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5633 debug_assert_eq!(node.kind(), "var_spec");
5634 Ok(Self {
5635 span: ::treesitter_types::Span::from(node),
5636 name: {
5637 let mut cursor = node.walk();
5638 let mut items = ::std::vec::Vec::new();
5639 for child in node.children_by_field_name("name", &mut cursor) {
5640 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5641 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5642 })?);
5643 }
5644 items
5645 },
5646 r#type: match node.child_by_field_name("type") {
5647 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5648 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5649 })?),
5650 None => None,
5651 },
5652 value: match node.child_by_field_name("value") {
5653 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5654 <ExpressionList as ::treesitter_types::FromNode>::from_node(child, src)
5655 })?),
5656 None => None,
5657 },
5658 })
5659 }
5660}
5661impl ::treesitter_types::Spanned for VarSpec<'_> {
5662 fn span(&self) -> ::treesitter_types::Span {
5663 self.span
5664 }
5665}
5666#[derive(Debug, Clone, PartialEq, Eq)]
5667pub struct VarSpecList<'tree> {
5668 pub span: ::treesitter_types::Span,
5669 pub children: ::std::vec::Vec<VarSpec<'tree>>,
5670}
5671impl<'tree> ::treesitter_types::FromNode<'tree> for VarSpecList<'tree> {
5672 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5673 fn from_node(
5674 node: ::treesitter_types::tree_sitter::Node<'tree>,
5675 src: &'tree [u8],
5676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5677 debug_assert_eq!(node.kind(), "var_spec_list");
5678 Ok(Self {
5679 span: ::treesitter_types::Span::from(node),
5680 children: {
5681 #[allow(clippy::suspicious_else_formatting)]
5682 let non_field_children = {
5683 let mut cursor = node.walk();
5684 let mut result = ::std::vec::Vec::new();
5685 if cursor.goto_first_child() {
5686 loop {
5687 if cursor.field_name().is_none()
5688 && cursor.node().is_named()
5689 && !cursor.node().is_extra()
5690 {
5691 result.push(cursor.node());
5692 }
5693 if !cursor.goto_next_sibling() {
5694 break;
5695 }
5696 }
5697 }
5698 result
5699 };
5700 let mut items = ::std::vec::Vec::new();
5701 for child in non_field_children {
5702 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5703 <VarSpec as ::treesitter_types::FromNode>::from_node(child, src)
5704 })?);
5705 }
5706 items
5707 },
5708 })
5709 }
5710}
5711impl ::treesitter_types::Spanned for VarSpecList<'_> {
5712 fn span(&self) -> ::treesitter_types::Span {
5713 self.span
5714 }
5715}
5716#[derive(Debug, Clone, PartialEq, Eq)]
5717pub struct VariadicArgument<'tree> {
5718 pub span: ::treesitter_types::Span,
5719 pub children: Expression<'tree>,
5720}
5721impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicArgument<'tree> {
5722 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5723 fn from_node(
5724 node: ::treesitter_types::tree_sitter::Node<'tree>,
5725 src: &'tree [u8],
5726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5727 debug_assert_eq!(node.kind(), "variadic_argument");
5728 Ok(Self {
5729 span: ::treesitter_types::Span::from(node),
5730 children: {
5731 #[allow(clippy::suspicious_else_formatting)]
5732 let non_field_children = {
5733 let mut cursor = node.walk();
5734 let mut result = ::std::vec::Vec::new();
5735 if cursor.goto_first_child() {
5736 loop {
5737 if cursor.field_name().is_none()
5738 && cursor.node().is_named()
5739 && !cursor.node().is_extra()
5740 {
5741 result.push(cursor.node());
5742 }
5743 if !cursor.goto_next_sibling() {
5744 break;
5745 }
5746 }
5747 }
5748 result
5749 };
5750 let child = if let Some(&c) = non_field_children.first() {
5751 c
5752 } else {
5753 let mut fallback_cursor = node.walk();
5754 let mut fallback_child = None;
5755 if fallback_cursor.goto_first_child() {
5756 loop {
5757 if fallback_cursor.field_name().is_none()
5758 && !fallback_cursor.node().is_extra()
5759 {
5760 let candidate = fallback_cursor.node();
5761 #[allow(clippy::needless_question_mark)]
5762 if (|| -> ::core::result::Result<
5763 _,
5764 ::treesitter_types::ParseError,
5765 > {
5766 let child = candidate;
5767 Ok(
5768 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5769 child,
5770 src,
5771 ))?,
5772 )
5773 })()
5774 .is_ok()
5775 {
5776 fallback_child = Some(candidate);
5777 break;
5778 }
5779 }
5780 if !fallback_cursor.goto_next_sibling() {
5781 break;
5782 }
5783 }
5784 }
5785 if fallback_child.is_none() {
5786 let mut cursor2 = node.walk();
5787 if cursor2.goto_first_child() {
5788 loop {
5789 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5790 let candidate = cursor2.node();
5791 #[allow(clippy::needless_question_mark)]
5792 if (|| -> ::core::result::Result<
5793 _,
5794 ::treesitter_types::ParseError,
5795 > {
5796 let child = candidate;
5797 Ok(
5798 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
5799 child,
5800 src,
5801 ))?,
5802 )
5803 })()
5804 .is_ok()
5805 {
5806 fallback_child = Some(candidate);
5807 break;
5808 }
5809 }
5810 if !cursor2.goto_next_sibling() {
5811 break;
5812 }
5813 }
5814 }
5815 }
5816 fallback_child.ok_or_else(|| {
5817 ::treesitter_types::ParseError::missing_field("children", node)
5818 })?
5819 };
5820 ::treesitter_types::runtime::maybe_grow_stack(|| {
5821 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5822 })?
5823 },
5824 })
5825 }
5826}
5827impl ::treesitter_types::Spanned for VariadicArgument<'_> {
5828 fn span(&self) -> ::treesitter_types::Span {
5829 self.span
5830 }
5831}
5832#[derive(Debug, Clone, PartialEq, Eq)]
5833pub struct VariadicParameterDeclaration<'tree> {
5834 pub span: ::treesitter_types::Span,
5835 pub name: ::core::option::Option<Identifier<'tree>>,
5836 pub r#type: Type<'tree>,
5837}
5838impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclaration<'tree> {
5839 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5840 fn from_node(
5841 node: ::treesitter_types::tree_sitter::Node<'tree>,
5842 src: &'tree [u8],
5843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5844 debug_assert_eq!(node.kind(), "variadic_parameter_declaration");
5845 Ok(Self {
5846 span: ::treesitter_types::Span::from(node),
5847 name: match node.child_by_field_name("name") {
5848 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5849 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5850 })?),
5851 None => None,
5852 },
5853 r#type: {
5854 let child = node
5855 .child_by_field_name("type")
5856 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5857 ::treesitter_types::runtime::maybe_grow_stack(|| {
5858 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5859 })?
5860 },
5861 })
5862 }
5863}
5864impl ::treesitter_types::Spanned for VariadicParameterDeclaration<'_> {
5865 fn span(&self) -> ::treesitter_types::Span {
5866 self.span
5867 }
5868}
5869#[derive(Debug, Clone, PartialEq, Eq)]
5870pub struct BlankIdentifier<'tree> {
5871 pub span: ::treesitter_types::Span,
5872 text: &'tree str,
5873}
5874impl<'tree> ::treesitter_types::FromNode<'tree> for BlankIdentifier<'tree> {
5875 fn from_node(
5876 node: ::treesitter_types::tree_sitter::Node<'tree>,
5877 src: &'tree [u8],
5878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5879 debug_assert_eq!(node.kind(), "blank_identifier");
5880 Ok(Self {
5881 span: ::treesitter_types::Span::from(node),
5882 text: node.utf8_text(src)?,
5883 })
5884 }
5885}
5886impl<'tree> ::treesitter_types::LeafNode<'tree> for BlankIdentifier<'tree> {
5887 fn text(&self) -> &'tree str {
5888 self.text
5889 }
5890}
5891impl ::treesitter_types::Spanned for BlankIdentifier<'_> {
5892 fn span(&self) -> ::treesitter_types::Span {
5893 self.span
5894 }
5895}
5896#[derive(Debug, Clone, PartialEq, Eq)]
5897pub struct Comment<'tree> {
5898 pub span: ::treesitter_types::Span,
5899 text: &'tree str,
5900}
5901impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
5902 fn from_node(
5903 node: ::treesitter_types::tree_sitter::Node<'tree>,
5904 src: &'tree [u8],
5905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5906 debug_assert_eq!(node.kind(), "comment");
5907 Ok(Self {
5908 span: ::treesitter_types::Span::from(node),
5909 text: node.utf8_text(src)?,
5910 })
5911 }
5912}
5913impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
5914 fn text(&self) -> &'tree str {
5915 self.text
5916 }
5917}
5918impl ::treesitter_types::Spanned for Comment<'_> {
5919 fn span(&self) -> ::treesitter_types::Span {
5920 self.span
5921 }
5922}
5923#[derive(Debug, Clone, PartialEq, Eq)]
5924pub struct EscapeSequence<'tree> {
5925 pub span: ::treesitter_types::Span,
5926 text: &'tree str,
5927}
5928impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
5929 fn from_node(
5930 node: ::treesitter_types::tree_sitter::Node<'tree>,
5931 src: &'tree [u8],
5932 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5933 debug_assert_eq!(node.kind(), "escape_sequence");
5934 Ok(Self {
5935 span: ::treesitter_types::Span::from(node),
5936 text: node.utf8_text(src)?,
5937 })
5938 }
5939}
5940impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
5941 fn text(&self) -> &'tree str {
5942 self.text
5943 }
5944}
5945impl ::treesitter_types::Spanned for EscapeSequence<'_> {
5946 fn span(&self) -> ::treesitter_types::Span {
5947 self.span
5948 }
5949}
5950#[derive(Debug, Clone, PartialEq, Eq)]
5951pub struct False<'tree> {
5952 pub span: ::treesitter_types::Span,
5953 text: &'tree str,
5954}
5955impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
5956 fn from_node(
5957 node: ::treesitter_types::tree_sitter::Node<'tree>,
5958 src: &'tree [u8],
5959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5960 debug_assert_eq!(node.kind(), "false");
5961 Ok(Self {
5962 span: ::treesitter_types::Span::from(node),
5963 text: node.utf8_text(src)?,
5964 })
5965 }
5966}
5967impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
5968 fn text(&self) -> &'tree str {
5969 self.text
5970 }
5971}
5972impl ::treesitter_types::Spanned for False<'_> {
5973 fn span(&self) -> ::treesitter_types::Span {
5974 self.span
5975 }
5976}
5977#[derive(Debug, Clone, PartialEq, Eq)]
5978pub struct FieldIdentifier<'tree> {
5979 pub span: ::treesitter_types::Span,
5980 text: &'tree str,
5981}
5982impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
5983 fn from_node(
5984 node: ::treesitter_types::tree_sitter::Node<'tree>,
5985 src: &'tree [u8],
5986 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5987 debug_assert_eq!(node.kind(), "field_identifier");
5988 Ok(Self {
5989 span: ::treesitter_types::Span::from(node),
5990 text: node.utf8_text(src)?,
5991 })
5992 }
5993}
5994impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
5995 fn text(&self) -> &'tree str {
5996 self.text
5997 }
5998}
5999impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
6000 fn span(&self) -> ::treesitter_types::Span {
6001 self.span
6002 }
6003}
6004#[derive(Debug, Clone, PartialEq, Eq)]
6005pub struct FloatLiteral<'tree> {
6006 pub span: ::treesitter_types::Span,
6007 text: &'tree str,
6008}
6009impl<'tree> ::treesitter_types::FromNode<'tree> for FloatLiteral<'tree> {
6010 fn from_node(
6011 node: ::treesitter_types::tree_sitter::Node<'tree>,
6012 src: &'tree [u8],
6013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6014 debug_assert_eq!(node.kind(), "float_literal");
6015 Ok(Self {
6016 span: ::treesitter_types::Span::from(node),
6017 text: node.utf8_text(src)?,
6018 })
6019 }
6020}
6021impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatLiteral<'tree> {
6022 fn text(&self) -> &'tree str {
6023 self.text
6024 }
6025}
6026impl ::treesitter_types::Spanned for FloatLiteral<'_> {
6027 fn span(&self) -> ::treesitter_types::Span {
6028 self.span
6029 }
6030}
6031#[derive(Debug, Clone, PartialEq, Eq)]
6032pub struct Identifier<'tree> {
6033 pub span: ::treesitter_types::Span,
6034 text: &'tree str,
6035}
6036impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
6037 fn from_node(
6038 node: ::treesitter_types::tree_sitter::Node<'tree>,
6039 src: &'tree [u8],
6040 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6041 debug_assert_eq!(node.kind(), "identifier");
6042 Ok(Self {
6043 span: ::treesitter_types::Span::from(node),
6044 text: node.utf8_text(src)?,
6045 })
6046 }
6047}
6048impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
6049 fn text(&self) -> &'tree str {
6050 self.text
6051 }
6052}
6053impl ::treesitter_types::Spanned for Identifier<'_> {
6054 fn span(&self) -> ::treesitter_types::Span {
6055 self.span
6056 }
6057}
6058#[derive(Debug, Clone, PartialEq, Eq)]
6059pub struct ImaginaryLiteral<'tree> {
6060 pub span: ::treesitter_types::Span,
6061 text: &'tree str,
6062}
6063impl<'tree> ::treesitter_types::FromNode<'tree> for ImaginaryLiteral<'tree> {
6064 fn from_node(
6065 node: ::treesitter_types::tree_sitter::Node<'tree>,
6066 src: &'tree [u8],
6067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6068 debug_assert_eq!(node.kind(), "imaginary_literal");
6069 Ok(Self {
6070 span: ::treesitter_types::Span::from(node),
6071 text: node.utf8_text(src)?,
6072 })
6073 }
6074}
6075impl<'tree> ::treesitter_types::LeafNode<'tree> for ImaginaryLiteral<'tree> {
6076 fn text(&self) -> &'tree str {
6077 self.text
6078 }
6079}
6080impl ::treesitter_types::Spanned for ImaginaryLiteral<'_> {
6081 fn span(&self) -> ::treesitter_types::Span {
6082 self.span
6083 }
6084}
6085#[derive(Debug, Clone, PartialEq, Eq)]
6086pub struct IntLiteral<'tree> {
6087 pub span: ::treesitter_types::Span,
6088 text: &'tree str,
6089}
6090impl<'tree> ::treesitter_types::FromNode<'tree> for IntLiteral<'tree> {
6091 fn from_node(
6092 node: ::treesitter_types::tree_sitter::Node<'tree>,
6093 src: &'tree [u8],
6094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6095 debug_assert_eq!(node.kind(), "int_literal");
6096 Ok(Self {
6097 span: ::treesitter_types::Span::from(node),
6098 text: node.utf8_text(src)?,
6099 })
6100 }
6101}
6102impl<'tree> ::treesitter_types::LeafNode<'tree> for IntLiteral<'tree> {
6103 fn text(&self) -> &'tree str {
6104 self.text
6105 }
6106}
6107impl ::treesitter_types::Spanned for IntLiteral<'_> {
6108 fn span(&self) -> ::treesitter_types::Span {
6109 self.span
6110 }
6111}
6112#[derive(Debug, Clone, PartialEq, Eq)]
6113pub struct InterpretedStringLiteralContent<'tree> {
6114 pub span: ::treesitter_types::Span,
6115 text: &'tree str,
6116}
6117impl<'tree> ::treesitter_types::FromNode<'tree> for InterpretedStringLiteralContent<'tree> {
6118 fn from_node(
6119 node: ::treesitter_types::tree_sitter::Node<'tree>,
6120 src: &'tree [u8],
6121 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6122 debug_assert_eq!(node.kind(), "interpreted_string_literal_content");
6123 Ok(Self {
6124 span: ::treesitter_types::Span::from(node),
6125 text: node.utf8_text(src)?,
6126 })
6127 }
6128}
6129impl<'tree> ::treesitter_types::LeafNode<'tree> for InterpretedStringLiteralContent<'tree> {
6130 fn text(&self) -> &'tree str {
6131 self.text
6132 }
6133}
6134impl ::treesitter_types::Spanned for InterpretedStringLiteralContent<'_> {
6135 fn span(&self) -> ::treesitter_types::Span {
6136 self.span
6137 }
6138}
6139#[derive(Debug, Clone, PartialEq, Eq)]
6140pub struct Iota<'tree> {
6141 pub span: ::treesitter_types::Span,
6142 text: &'tree str,
6143}
6144impl<'tree> ::treesitter_types::FromNode<'tree> for Iota<'tree> {
6145 fn from_node(
6146 node: ::treesitter_types::tree_sitter::Node<'tree>,
6147 src: &'tree [u8],
6148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6149 debug_assert_eq!(node.kind(), "iota");
6150 Ok(Self {
6151 span: ::treesitter_types::Span::from(node),
6152 text: node.utf8_text(src)?,
6153 })
6154 }
6155}
6156impl<'tree> ::treesitter_types::LeafNode<'tree> for Iota<'tree> {
6157 fn text(&self) -> &'tree str {
6158 self.text
6159 }
6160}
6161impl ::treesitter_types::Spanned for Iota<'_> {
6162 fn span(&self) -> ::treesitter_types::Span {
6163 self.span
6164 }
6165}
6166#[derive(Debug, Clone, PartialEq, Eq)]
6167pub struct LabelName<'tree> {
6168 pub span: ::treesitter_types::Span,
6169 text: &'tree str,
6170}
6171impl<'tree> ::treesitter_types::FromNode<'tree> for LabelName<'tree> {
6172 fn from_node(
6173 node: ::treesitter_types::tree_sitter::Node<'tree>,
6174 src: &'tree [u8],
6175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6176 debug_assert_eq!(node.kind(), "label_name");
6177 Ok(Self {
6178 span: ::treesitter_types::Span::from(node),
6179 text: node.utf8_text(src)?,
6180 })
6181 }
6182}
6183impl<'tree> ::treesitter_types::LeafNode<'tree> for LabelName<'tree> {
6184 fn text(&self) -> &'tree str {
6185 self.text
6186 }
6187}
6188impl ::treesitter_types::Spanned for LabelName<'_> {
6189 fn span(&self) -> ::treesitter_types::Span {
6190 self.span
6191 }
6192}
6193#[derive(Debug, Clone, PartialEq, Eq)]
6194pub struct Nil<'tree> {
6195 pub span: ::treesitter_types::Span,
6196 text: &'tree str,
6197}
6198impl<'tree> ::treesitter_types::FromNode<'tree> for Nil<'tree> {
6199 fn from_node(
6200 node: ::treesitter_types::tree_sitter::Node<'tree>,
6201 src: &'tree [u8],
6202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6203 debug_assert_eq!(node.kind(), "nil");
6204 Ok(Self {
6205 span: ::treesitter_types::Span::from(node),
6206 text: node.utf8_text(src)?,
6207 })
6208 }
6209}
6210impl<'tree> ::treesitter_types::LeafNode<'tree> for Nil<'tree> {
6211 fn text(&self) -> &'tree str {
6212 self.text
6213 }
6214}
6215impl ::treesitter_types::Spanned for Nil<'_> {
6216 fn span(&self) -> ::treesitter_types::Span {
6217 self.span
6218 }
6219}
6220#[derive(Debug, Clone, PartialEq, Eq)]
6221pub struct PackageIdentifier<'tree> {
6222 pub span: ::treesitter_types::Span,
6223 text: &'tree str,
6224}
6225impl<'tree> ::treesitter_types::FromNode<'tree> for PackageIdentifier<'tree> {
6226 fn from_node(
6227 node: ::treesitter_types::tree_sitter::Node<'tree>,
6228 src: &'tree [u8],
6229 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6230 debug_assert_eq!(node.kind(), "package_identifier");
6231 Ok(Self {
6232 span: ::treesitter_types::Span::from(node),
6233 text: node.utf8_text(src)?,
6234 })
6235 }
6236}
6237impl<'tree> ::treesitter_types::LeafNode<'tree> for PackageIdentifier<'tree> {
6238 fn text(&self) -> &'tree str {
6239 self.text
6240 }
6241}
6242impl ::treesitter_types::Spanned for PackageIdentifier<'_> {
6243 fn span(&self) -> ::treesitter_types::Span {
6244 self.span
6245 }
6246}
6247#[derive(Debug, Clone, PartialEq, Eq)]
6248pub struct RawStringLiteralContent<'tree> {
6249 pub span: ::treesitter_types::Span,
6250 text: &'tree str,
6251}
6252impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralContent<'tree> {
6253 fn from_node(
6254 node: ::treesitter_types::tree_sitter::Node<'tree>,
6255 src: &'tree [u8],
6256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6257 debug_assert_eq!(node.kind(), "raw_string_literal_content");
6258 Ok(Self {
6259 span: ::treesitter_types::Span::from(node),
6260 text: node.utf8_text(src)?,
6261 })
6262 }
6263}
6264impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringLiteralContent<'tree> {
6265 fn text(&self) -> &'tree str {
6266 self.text
6267 }
6268}
6269impl ::treesitter_types::Spanned for RawStringLiteralContent<'_> {
6270 fn span(&self) -> ::treesitter_types::Span {
6271 self.span
6272 }
6273}
6274#[derive(Debug, Clone, PartialEq, Eq)]
6275pub struct RuneLiteral<'tree> {
6276 pub span: ::treesitter_types::Span,
6277 text: &'tree str,
6278}
6279impl<'tree> ::treesitter_types::FromNode<'tree> for RuneLiteral<'tree> {
6280 fn from_node(
6281 node: ::treesitter_types::tree_sitter::Node<'tree>,
6282 src: &'tree [u8],
6283 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6284 debug_assert_eq!(node.kind(), "rune_literal");
6285 Ok(Self {
6286 span: ::treesitter_types::Span::from(node),
6287 text: node.utf8_text(src)?,
6288 })
6289 }
6290}
6291impl<'tree> ::treesitter_types::LeafNode<'tree> for RuneLiteral<'tree> {
6292 fn text(&self) -> &'tree str {
6293 self.text
6294 }
6295}
6296impl ::treesitter_types::Spanned for RuneLiteral<'_> {
6297 fn span(&self) -> ::treesitter_types::Span {
6298 self.span
6299 }
6300}
6301#[derive(Debug, Clone, PartialEq, Eq)]
6302pub struct True<'tree> {
6303 pub span: ::treesitter_types::Span,
6304 text: &'tree str,
6305}
6306impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
6307 fn from_node(
6308 node: ::treesitter_types::tree_sitter::Node<'tree>,
6309 src: &'tree [u8],
6310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6311 debug_assert_eq!(node.kind(), "true");
6312 Ok(Self {
6313 span: ::treesitter_types::Span::from(node),
6314 text: node.utf8_text(src)?,
6315 })
6316 }
6317}
6318impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
6319 fn text(&self) -> &'tree str {
6320 self.text
6321 }
6322}
6323impl ::treesitter_types::Spanned for True<'_> {
6324 fn span(&self) -> ::treesitter_types::Span {
6325 self.span
6326 }
6327}
6328#[derive(Debug, Clone, PartialEq, Eq)]
6329pub struct TypeIdentifier<'tree> {
6330 pub span: ::treesitter_types::Span,
6331 text: &'tree str,
6332}
6333impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
6334 fn from_node(
6335 node: ::treesitter_types::tree_sitter::Node<'tree>,
6336 src: &'tree [u8],
6337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6338 debug_assert_eq!(node.kind(), "type_identifier");
6339 Ok(Self {
6340 span: ::treesitter_types::Span::from(node),
6341 text: node.utf8_text(src)?,
6342 })
6343 }
6344}
6345impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
6346 fn text(&self) -> &'tree str {
6347 self.text
6348 }
6349}
6350impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
6351 fn span(&self) -> ::treesitter_types::Span {
6352 self.span
6353 }
6354}
6355#[derive(Debug, Clone, PartialEq, Eq)]
6356pub enum ArgumentListChildren<'tree> {
6357 Expression(::std::boxed::Box<Expression<'tree>>),
6358 Type(::std::boxed::Box<Type<'tree>>),
6359 VariadicArgument(::std::boxed::Box<VariadicArgument<'tree>>),
6360}
6361impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
6362 #[allow(clippy::collapsible_else_if)]
6363 fn from_node(
6364 node: ::treesitter_types::tree_sitter::Node<'tree>,
6365 src: &'tree [u8],
6366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6367 match node.kind() {
6368 "variadic_argument" => Ok(Self::VariadicArgument(::std::boxed::Box::new(
6369 ::treesitter_types::runtime::maybe_grow_stack(|| {
6370 <VariadicArgument as ::treesitter_types::FromNode>::from_node(node, src)
6371 })?,
6372 ))),
6373 _other => {
6374 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6375 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6376 }) {
6377 Ok(Self::Expression(::std::boxed::Box::new(v)))
6378 } else {
6379 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6380 <Type as ::treesitter_types::FromNode>::from_node(node, src)
6381 }) {
6382 Ok(Self::Type(::std::boxed::Box::new(v)))
6383 } else {
6384 Err(::treesitter_types::ParseError::unexpected_kind(
6385 _other, node,
6386 ))
6387 }
6388 }
6389 }
6390 }
6391 }
6392}
6393impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
6394 fn span(&self) -> ::treesitter_types::Span {
6395 match self {
6396 Self::Expression(inner) => inner.span(),
6397 Self::Type(inner) => inner.span(),
6398 Self::VariadicArgument(inner) => inner.span(),
6399 }
6400 }
6401}
6402#[derive(Debug, Clone, PartialEq, Eq)]
6403pub enum AssignmentStatementOperator {
6404 PercentEq(::treesitter_types::Span),
6405 AmpEq(::treesitter_types::Span),
6406 AmpCaretEq(::treesitter_types::Span),
6407 StarEq(::treesitter_types::Span),
6408 PlusEq(::treesitter_types::Span),
6409 MinusEq(::treesitter_types::Span),
6410 SlashEq(::treesitter_types::Span),
6411 ShlEq(::treesitter_types::Span),
6412 Eq(::treesitter_types::Span),
6413 ShrEq(::treesitter_types::Span),
6414 CaretEq(::treesitter_types::Span),
6415 PipeEq(::treesitter_types::Span),
6416}
6417impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentStatementOperator {
6418 #[allow(clippy::collapsible_else_if)]
6419 fn from_node(
6420 node: ::treesitter_types::tree_sitter::Node<'tree>,
6421 _src: &'tree [u8],
6422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6423 match node.kind() {
6424 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
6425 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
6426 "&^=" => Ok(Self::AmpCaretEq(::treesitter_types::Span::from(node))),
6427 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
6428 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
6429 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
6430 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
6431 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
6432 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
6433 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
6434 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
6435 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
6436 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6437 }
6438 }
6439}
6440impl ::treesitter_types::Spanned for AssignmentStatementOperator {
6441 fn span(&self) -> ::treesitter_types::Span {
6442 match self {
6443 Self::PercentEq(span) => *span,
6444 Self::AmpEq(span) => *span,
6445 Self::AmpCaretEq(span) => *span,
6446 Self::StarEq(span) => *span,
6447 Self::PlusEq(span) => *span,
6448 Self::MinusEq(span) => *span,
6449 Self::SlashEq(span) => *span,
6450 Self::ShlEq(span) => *span,
6451 Self::Eq(span) => *span,
6452 Self::ShrEq(span) => *span,
6453 Self::CaretEq(span) => *span,
6454 Self::PipeEq(span) => *span,
6455 }
6456 }
6457}
6458#[derive(Debug, Clone, PartialEq, Eq)]
6459pub enum BinaryExpressionOperator {
6460 NotEq(::treesitter_types::Span),
6461 Percent(::treesitter_types::Span),
6462 Amp(::treesitter_types::Span),
6463 AmpAmp(::treesitter_types::Span),
6464 AmpCaret(::treesitter_types::Span),
6465 Star(::treesitter_types::Span),
6466 Plus(::treesitter_types::Span),
6467 Minus(::treesitter_types::Span),
6468 Slash(::treesitter_types::Span),
6469 Lt(::treesitter_types::Span),
6470 Shl(::treesitter_types::Span),
6471 LtEq(::treesitter_types::Span),
6472 EqEq(::treesitter_types::Span),
6473 Gt(::treesitter_types::Span),
6474 GtEq(::treesitter_types::Span),
6475 Shr(::treesitter_types::Span),
6476 Caret(::treesitter_types::Span),
6477 Pipe(::treesitter_types::Span),
6478 PipePipe(::treesitter_types::Span),
6479}
6480impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
6481 #[allow(clippy::collapsible_else_if)]
6482 fn from_node(
6483 node: ::treesitter_types::tree_sitter::Node<'tree>,
6484 _src: &'tree [u8],
6485 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6486 match node.kind() {
6487 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
6488 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
6489 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
6490 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
6491 "&^" => Ok(Self::AmpCaret(::treesitter_types::Span::from(node))),
6492 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
6493 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
6494 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
6495 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
6496 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
6497 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
6498 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
6499 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
6500 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
6501 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
6502 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
6503 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
6504 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
6505 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
6506 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6507 }
6508 }
6509}
6510impl ::treesitter_types::Spanned for BinaryExpressionOperator {
6511 fn span(&self) -> ::treesitter_types::Span {
6512 match self {
6513 Self::NotEq(span) => *span,
6514 Self::Percent(span) => *span,
6515 Self::Amp(span) => *span,
6516 Self::AmpAmp(span) => *span,
6517 Self::AmpCaret(span) => *span,
6518 Self::Star(span) => *span,
6519 Self::Plus(span) => *span,
6520 Self::Minus(span) => *span,
6521 Self::Slash(span) => *span,
6522 Self::Lt(span) => *span,
6523 Self::Shl(span) => *span,
6524 Self::LtEq(span) => *span,
6525 Self::EqEq(span) => *span,
6526 Self::Gt(span) => *span,
6527 Self::GtEq(span) => *span,
6528 Self::Shr(span) => *span,
6529 Self::Caret(span) => *span,
6530 Self::Pipe(span) => *span,
6531 Self::PipePipe(span) => *span,
6532 }
6533 }
6534}
6535#[derive(Debug, Clone, PartialEq, Eq)]
6536pub enum CommunicationCaseCommunication<'tree> {
6537 ReceiveStatement(::std::boxed::Box<ReceiveStatement<'tree>>),
6538 SendStatement(::std::boxed::Box<SendStatement<'tree>>),
6539}
6540impl<'tree> ::treesitter_types::FromNode<'tree> for CommunicationCaseCommunication<'tree> {
6541 #[allow(clippy::collapsible_else_if)]
6542 fn from_node(
6543 node: ::treesitter_types::tree_sitter::Node<'tree>,
6544 src: &'tree [u8],
6545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6546 match node.kind() {
6547 "receive_statement" => Ok(Self::ReceiveStatement(::std::boxed::Box::new(
6548 ::treesitter_types::runtime::maybe_grow_stack(|| {
6549 <ReceiveStatement as ::treesitter_types::FromNode>::from_node(node, src)
6550 })?,
6551 ))),
6552 "send_statement" => Ok(Self::SendStatement(::std::boxed::Box::new(
6553 ::treesitter_types::runtime::maybe_grow_stack(|| {
6554 <SendStatement as ::treesitter_types::FromNode>::from_node(node, src)
6555 })?,
6556 ))),
6557 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6558 }
6559 }
6560}
6561impl ::treesitter_types::Spanned for CommunicationCaseCommunication<'_> {
6562 fn span(&self) -> ::treesitter_types::Span {
6563 match self {
6564 Self::ReceiveStatement(inner) => inner.span(),
6565 Self::SendStatement(inner) => inner.span(),
6566 }
6567 }
6568}
6569#[derive(Debug, Clone, PartialEq, Eq)]
6570pub enum CompositeLiteralType<'tree> {
6571 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
6572 GenericType(::std::boxed::Box<GenericType<'tree>>),
6573 ImplicitLengthArrayType(::std::boxed::Box<ImplicitLengthArrayType<'tree>>),
6574 MapType(::std::boxed::Box<MapType<'tree>>),
6575 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
6576 SliceType(::std::boxed::Box<SliceType<'tree>>),
6577 StructType(::std::boxed::Box<StructType<'tree>>),
6578 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
6579}
6580impl<'tree> ::treesitter_types::FromNode<'tree> for CompositeLiteralType<'tree> {
6581 #[allow(clippy::collapsible_else_if)]
6582 fn from_node(
6583 node: ::treesitter_types::tree_sitter::Node<'tree>,
6584 src: &'tree [u8],
6585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6586 match node.kind() {
6587 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
6588 ::treesitter_types::runtime::maybe_grow_stack(|| {
6589 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
6590 })?,
6591 ))),
6592 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
6593 ::treesitter_types::runtime::maybe_grow_stack(|| {
6594 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
6595 })?,
6596 ))),
6597 "implicit_length_array_type" => Ok(Self::ImplicitLengthArrayType(
6598 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
6599 <ImplicitLengthArrayType as ::treesitter_types::FromNode>::from_node(node, src)
6600 })?),
6601 )),
6602 "map_type" => Ok(Self::MapType(::std::boxed::Box::new(
6603 ::treesitter_types::runtime::maybe_grow_stack(|| {
6604 <MapType as ::treesitter_types::FromNode>::from_node(node, src)
6605 })?,
6606 ))),
6607 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
6608 ::treesitter_types::runtime::maybe_grow_stack(|| {
6609 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
6610 })?,
6611 ))),
6612 "slice_type" => Ok(Self::SliceType(::std::boxed::Box::new(
6613 ::treesitter_types::runtime::maybe_grow_stack(|| {
6614 <SliceType as ::treesitter_types::FromNode>::from_node(node, src)
6615 })?,
6616 ))),
6617 "struct_type" => Ok(Self::StructType(::std::boxed::Box::new(
6618 ::treesitter_types::runtime::maybe_grow_stack(|| {
6619 <StructType as ::treesitter_types::FromNode>::from_node(node, src)
6620 })?,
6621 ))),
6622 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
6623 ::treesitter_types::runtime::maybe_grow_stack(|| {
6624 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
6625 })?,
6626 ))),
6627 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6628 }
6629 }
6630}
6631impl ::treesitter_types::Spanned for CompositeLiteralType<'_> {
6632 fn span(&self) -> ::treesitter_types::Span {
6633 match self {
6634 Self::ArrayType(inner) => inner.span(),
6635 Self::GenericType(inner) => inner.span(),
6636 Self::ImplicitLengthArrayType(inner) => inner.span(),
6637 Self::MapType(inner) => inner.span(),
6638 Self::QualifiedType(inner) => inner.span(),
6639 Self::SliceType(inner) => inner.span(),
6640 Self::StructType(inner) => inner.span(),
6641 Self::TypeIdentifier(inner) => inner.span(),
6642 }
6643 }
6644}
6645#[derive(Debug, Clone, PartialEq, Eq)]
6646pub enum ConstSpecName<'tree> {
6647 Comma(::treesitter_types::Span),
6648 Identifier(::std::boxed::Box<Identifier<'tree>>),
6649}
6650impl<'tree> ::treesitter_types::FromNode<'tree> for ConstSpecName<'tree> {
6651 #[allow(clippy::collapsible_else_if)]
6652 fn from_node(
6653 node: ::treesitter_types::tree_sitter::Node<'tree>,
6654 src: &'tree [u8],
6655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6656 match node.kind() {
6657 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
6658 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6659 ::treesitter_types::runtime::maybe_grow_stack(|| {
6660 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6661 })?,
6662 ))),
6663 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6664 }
6665 }
6666}
6667impl ::treesitter_types::Spanned for ConstSpecName<'_> {
6668 fn span(&self) -> ::treesitter_types::Span {
6669 match self {
6670 Self::Comma(span) => *span,
6671 Self::Identifier(inner) => inner.span(),
6672 }
6673 }
6674}
6675#[derive(Debug, Clone, PartialEq, Eq)]
6676pub enum ExpressionSwitchStatementChildren<'tree> {
6677 DefaultCase(::std::boxed::Box<DefaultCase<'tree>>),
6678 ExpressionCase(::std::boxed::Box<ExpressionCase<'tree>>),
6679}
6680impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionSwitchStatementChildren<'tree> {
6681 #[allow(clippy::collapsible_else_if)]
6682 fn from_node(
6683 node: ::treesitter_types::tree_sitter::Node<'tree>,
6684 src: &'tree [u8],
6685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6686 match node.kind() {
6687 "default_case" => Ok(Self::DefaultCase(::std::boxed::Box::new(
6688 ::treesitter_types::runtime::maybe_grow_stack(|| {
6689 <DefaultCase as ::treesitter_types::FromNode>::from_node(node, src)
6690 })?,
6691 ))),
6692 "expression_case" => Ok(Self::ExpressionCase(::std::boxed::Box::new(
6693 ::treesitter_types::runtime::maybe_grow_stack(|| {
6694 <ExpressionCase as ::treesitter_types::FromNode>::from_node(node, src)
6695 })?,
6696 ))),
6697 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6698 }
6699 }
6700}
6701impl ::treesitter_types::Spanned for ExpressionSwitchStatementChildren<'_> {
6702 fn span(&self) -> ::treesitter_types::Span {
6703 match self {
6704 Self::DefaultCase(inner) => inner.span(),
6705 Self::ExpressionCase(inner) => inner.span(),
6706 }
6707 }
6708}
6709#[derive(Debug, Clone, PartialEq, Eq)]
6710pub enum FieldDeclarationTag<'tree> {
6711 InterpretedStringLiteral(::std::boxed::Box<InterpretedStringLiteral<'tree>>),
6712 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
6713}
6714impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationTag<'tree> {
6715 #[allow(clippy::collapsible_else_if)]
6716 fn from_node(
6717 node: ::treesitter_types::tree_sitter::Node<'tree>,
6718 src: &'tree [u8],
6719 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6720 match node.kind() {
6721 "interpreted_string_literal" => Ok(Self::InterpretedStringLiteral(
6722 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
6723 <InterpretedStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
6724 })?),
6725 )),
6726 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
6727 ::treesitter_types::runtime::maybe_grow_stack(|| {
6728 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
6729 })?,
6730 ))),
6731 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6732 }
6733 }
6734}
6735impl ::treesitter_types::Spanned for FieldDeclarationTag<'_> {
6736 fn span(&self) -> ::treesitter_types::Span {
6737 match self {
6738 Self::InterpretedStringLiteral(inner) => inner.span(),
6739 Self::RawStringLiteral(inner) => inner.span(),
6740 }
6741 }
6742}
6743#[derive(Debug, Clone, PartialEq, Eq)]
6744pub enum FieldDeclarationType<'tree> {
6745 Type(::std::boxed::Box<Type<'tree>>),
6746 GenericType(::std::boxed::Box<GenericType<'tree>>),
6747 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
6748 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
6749}
6750impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationType<'tree> {
6751 #[allow(clippy::collapsible_else_if)]
6752 fn from_node(
6753 node: ::treesitter_types::tree_sitter::Node<'tree>,
6754 src: &'tree [u8],
6755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6756 match node.kind() {
6757 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
6758 ::treesitter_types::runtime::maybe_grow_stack(|| {
6759 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
6760 })?,
6761 ))),
6762 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
6763 ::treesitter_types::runtime::maybe_grow_stack(|| {
6764 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
6765 })?,
6766 ))),
6767 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
6768 ::treesitter_types::runtime::maybe_grow_stack(|| {
6769 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
6770 })?,
6771 ))),
6772 _other => {
6773 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6774 <Type as ::treesitter_types::FromNode>::from_node(node, src)
6775 }) {
6776 Ok(Self::Type(::std::boxed::Box::new(v)))
6777 } else {
6778 Err(::treesitter_types::ParseError::unexpected_kind(
6779 _other, node,
6780 ))
6781 }
6782 }
6783 }
6784 }
6785}
6786impl ::treesitter_types::Spanned for FieldDeclarationType<'_> {
6787 fn span(&self) -> ::treesitter_types::Span {
6788 match self {
6789 Self::Type(inner) => inner.span(),
6790 Self::GenericType(inner) => inner.span(),
6791 Self::QualifiedType(inner) => inner.span(),
6792 Self::TypeIdentifier(inner) => inner.span(),
6793 }
6794 }
6795}
6796#[derive(Debug, Clone, PartialEq, Eq)]
6797pub enum ForStatementChildren<'tree> {
6798 Expression(::std::boxed::Box<Expression<'tree>>),
6799 ForClause(::std::boxed::Box<ForClause<'tree>>),
6800 RangeClause(::std::boxed::Box<RangeClause<'tree>>),
6801}
6802impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementChildren<'tree> {
6803 #[allow(clippy::collapsible_else_if)]
6804 fn from_node(
6805 node: ::treesitter_types::tree_sitter::Node<'tree>,
6806 src: &'tree [u8],
6807 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6808 match node.kind() {
6809 "for_clause" => Ok(Self::ForClause(::std::boxed::Box::new(
6810 ::treesitter_types::runtime::maybe_grow_stack(|| {
6811 <ForClause as ::treesitter_types::FromNode>::from_node(node, src)
6812 })?,
6813 ))),
6814 "range_clause" => Ok(Self::RangeClause(::std::boxed::Box::new(
6815 ::treesitter_types::runtime::maybe_grow_stack(|| {
6816 <RangeClause as ::treesitter_types::FromNode>::from_node(node, src)
6817 })?,
6818 ))),
6819 _other => {
6820 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6821 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
6822 }) {
6823 Ok(Self::Expression(::std::boxed::Box::new(v)))
6824 } else {
6825 Err(::treesitter_types::ParseError::unexpected_kind(
6826 _other, node,
6827 ))
6828 }
6829 }
6830 }
6831 }
6832}
6833impl ::treesitter_types::Spanned for ForStatementChildren<'_> {
6834 fn span(&self) -> ::treesitter_types::Span {
6835 match self {
6836 Self::Expression(inner) => inner.span(),
6837 Self::ForClause(inner) => inner.span(),
6838 Self::RangeClause(inner) => inner.span(),
6839 }
6840 }
6841}
6842#[derive(Debug, Clone, PartialEq, Eq)]
6843pub enum FuncLiteralResult<'tree> {
6844 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
6845 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
6846}
6847impl<'tree> ::treesitter_types::FromNode<'tree> for FuncLiteralResult<'tree> {
6848 #[allow(clippy::collapsible_else_if)]
6849 fn from_node(
6850 node: ::treesitter_types::tree_sitter::Node<'tree>,
6851 src: &'tree [u8],
6852 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6853 match node.kind() {
6854 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
6855 ::treesitter_types::runtime::maybe_grow_stack(|| {
6856 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
6857 })?,
6858 ))),
6859 _other => {
6860 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6861 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
6862 }) {
6863 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
6864 } else {
6865 Err(::treesitter_types::ParseError::unexpected_kind(
6866 _other, node,
6867 ))
6868 }
6869 }
6870 }
6871 }
6872}
6873impl ::treesitter_types::Spanned for FuncLiteralResult<'_> {
6874 fn span(&self) -> ::treesitter_types::Span {
6875 match self {
6876 Self::SimpleType(inner) => inner.span(),
6877 Self::ParameterList(inner) => inner.span(),
6878 }
6879 }
6880}
6881#[derive(Debug, Clone, PartialEq, Eq)]
6882pub enum FunctionDeclarationResult<'tree> {
6883 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
6884 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
6885}
6886impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarationResult<'tree> {
6887 #[allow(clippy::collapsible_else_if)]
6888 fn from_node(
6889 node: ::treesitter_types::tree_sitter::Node<'tree>,
6890 src: &'tree [u8],
6891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6892 match node.kind() {
6893 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
6894 ::treesitter_types::runtime::maybe_grow_stack(|| {
6895 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
6896 })?,
6897 ))),
6898 _other => {
6899 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6900 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
6901 }) {
6902 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
6903 } else {
6904 Err(::treesitter_types::ParseError::unexpected_kind(
6905 _other, node,
6906 ))
6907 }
6908 }
6909 }
6910 }
6911}
6912impl ::treesitter_types::Spanned for FunctionDeclarationResult<'_> {
6913 fn span(&self) -> ::treesitter_types::Span {
6914 match self {
6915 Self::SimpleType(inner) => inner.span(),
6916 Self::ParameterList(inner) => inner.span(),
6917 }
6918 }
6919}
6920#[derive(Debug, Clone, PartialEq, Eq)]
6921pub enum FunctionTypeResult<'tree> {
6922 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
6923 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
6924}
6925impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeResult<'tree> {
6926 #[allow(clippy::collapsible_else_if)]
6927 fn from_node(
6928 node: ::treesitter_types::tree_sitter::Node<'tree>,
6929 src: &'tree [u8],
6930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6931 match node.kind() {
6932 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
6933 ::treesitter_types::runtime::maybe_grow_stack(|| {
6934 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
6935 })?,
6936 ))),
6937 _other => {
6938 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
6939 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
6940 }) {
6941 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
6942 } else {
6943 Err(::treesitter_types::ParseError::unexpected_kind(
6944 _other, node,
6945 ))
6946 }
6947 }
6948 }
6949 }
6950}
6951impl ::treesitter_types::Spanned for FunctionTypeResult<'_> {
6952 fn span(&self) -> ::treesitter_types::Span {
6953 match self {
6954 Self::SimpleType(inner) => inner.span(),
6955 Self::ParameterList(inner) => inner.span(),
6956 }
6957 }
6958}
6959#[derive(Debug, Clone, PartialEq, Eq)]
6960pub enum GenericTypeType<'tree> {
6961 NegatedType(::std::boxed::Box<NegatedType<'tree>>),
6962 QualifiedType(::std::boxed::Box<QualifiedType<'tree>>),
6963 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
6964}
6965impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeType<'tree> {
6966 #[allow(clippy::collapsible_else_if)]
6967 fn from_node(
6968 node: ::treesitter_types::tree_sitter::Node<'tree>,
6969 src: &'tree [u8],
6970 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6971 match node.kind() {
6972 "negated_type" => Ok(Self::NegatedType(::std::boxed::Box::new(
6973 ::treesitter_types::runtime::maybe_grow_stack(|| {
6974 <NegatedType as ::treesitter_types::FromNode>::from_node(node, src)
6975 })?,
6976 ))),
6977 "qualified_type" => Ok(Self::QualifiedType(::std::boxed::Box::new(
6978 ::treesitter_types::runtime::maybe_grow_stack(|| {
6979 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
6980 })?,
6981 ))),
6982 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
6983 ::treesitter_types::runtime::maybe_grow_stack(|| {
6984 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
6985 })?,
6986 ))),
6987 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6988 }
6989 }
6990}
6991impl ::treesitter_types::Spanned for GenericTypeType<'_> {
6992 fn span(&self) -> ::treesitter_types::Span {
6993 match self {
6994 Self::NegatedType(inner) => inner.span(),
6995 Self::QualifiedType(inner) => inner.span(),
6996 Self::TypeIdentifier(inner) => inner.span(),
6997 }
6998 }
6999}
7000#[derive(Debug, Clone, PartialEq, Eq)]
7001pub enum IfStatementAlternative<'tree> {
7002 Block(::std::boxed::Box<Block<'tree>>),
7003 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
7004}
7005impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementAlternative<'tree> {
7006 #[allow(clippy::collapsible_else_if)]
7007 fn from_node(
7008 node: ::treesitter_types::tree_sitter::Node<'tree>,
7009 src: &'tree [u8],
7010 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7011 match node.kind() {
7012 "block" => Ok(Self::Block(::std::boxed::Box::new(
7013 ::treesitter_types::runtime::maybe_grow_stack(|| {
7014 <Block as ::treesitter_types::FromNode>::from_node(node, src)
7015 })?,
7016 ))),
7017 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
7018 ::treesitter_types::runtime::maybe_grow_stack(|| {
7019 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
7020 })?,
7021 ))),
7022 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7023 }
7024 }
7025}
7026impl ::treesitter_types::Spanned for IfStatementAlternative<'_> {
7027 fn span(&self) -> ::treesitter_types::Span {
7028 match self {
7029 Self::Block(inner) => inner.span(),
7030 Self::IfStatement(inner) => inner.span(),
7031 }
7032 }
7033}
7034#[derive(Debug, Clone, PartialEq, Eq)]
7035pub enum ImportDeclarationChildren<'tree> {
7036 ImportSpec(::std::boxed::Box<ImportSpec<'tree>>),
7037 ImportSpecList(::std::boxed::Box<ImportSpecList<'tree>>),
7038}
7039impl<'tree> ::treesitter_types::FromNode<'tree> for ImportDeclarationChildren<'tree> {
7040 #[allow(clippy::collapsible_else_if)]
7041 fn from_node(
7042 node: ::treesitter_types::tree_sitter::Node<'tree>,
7043 src: &'tree [u8],
7044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7045 match node.kind() {
7046 "import_spec" => Ok(Self::ImportSpec(::std::boxed::Box::new(
7047 ::treesitter_types::runtime::maybe_grow_stack(|| {
7048 <ImportSpec as ::treesitter_types::FromNode>::from_node(node, src)
7049 })?,
7050 ))),
7051 "import_spec_list" => Ok(Self::ImportSpecList(::std::boxed::Box::new(
7052 ::treesitter_types::runtime::maybe_grow_stack(|| {
7053 <ImportSpecList as ::treesitter_types::FromNode>::from_node(node, src)
7054 })?,
7055 ))),
7056 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7057 }
7058 }
7059}
7060impl ::treesitter_types::Spanned for ImportDeclarationChildren<'_> {
7061 fn span(&self) -> ::treesitter_types::Span {
7062 match self {
7063 Self::ImportSpec(inner) => inner.span(),
7064 Self::ImportSpecList(inner) => inner.span(),
7065 }
7066 }
7067}
7068#[derive(Debug, Clone, PartialEq, Eq)]
7069pub enum ImportSpecName<'tree> {
7070 BlankIdentifier(::std::boxed::Box<BlankIdentifier<'tree>>),
7071 Dot(::std::boxed::Box<Dot<'tree>>),
7072 PackageIdentifier(::std::boxed::Box<PackageIdentifier<'tree>>),
7073}
7074impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecName<'tree> {
7075 #[allow(clippy::collapsible_else_if)]
7076 fn from_node(
7077 node: ::treesitter_types::tree_sitter::Node<'tree>,
7078 src: &'tree [u8],
7079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7080 match node.kind() {
7081 "blank_identifier" => Ok(Self::BlankIdentifier(::std::boxed::Box::new(
7082 ::treesitter_types::runtime::maybe_grow_stack(|| {
7083 <BlankIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
7084 })?,
7085 ))),
7086 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
7087 ::treesitter_types::runtime::maybe_grow_stack(|| {
7088 <Dot as ::treesitter_types::FromNode>::from_node(node, src)
7089 })?,
7090 ))),
7091 "package_identifier" => Ok(Self::PackageIdentifier(::std::boxed::Box::new(
7092 ::treesitter_types::runtime::maybe_grow_stack(|| {
7093 <PackageIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
7094 })?,
7095 ))),
7096 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7097 }
7098 }
7099}
7100impl ::treesitter_types::Spanned for ImportSpecName<'_> {
7101 fn span(&self) -> ::treesitter_types::Span {
7102 match self {
7103 Self::BlankIdentifier(inner) => inner.span(),
7104 Self::Dot(inner) => inner.span(),
7105 Self::PackageIdentifier(inner) => inner.span(),
7106 }
7107 }
7108}
7109#[derive(Debug, Clone, PartialEq, Eq)]
7110pub enum ImportSpecPath<'tree> {
7111 InterpretedStringLiteral(::std::boxed::Box<InterpretedStringLiteral<'tree>>),
7112 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
7113}
7114impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecPath<'tree> {
7115 #[allow(clippy::collapsible_else_if)]
7116 fn from_node(
7117 node: ::treesitter_types::tree_sitter::Node<'tree>,
7118 src: &'tree [u8],
7119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7120 match node.kind() {
7121 "interpreted_string_literal" => Ok(Self::InterpretedStringLiteral(
7122 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7123 <InterpretedStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
7124 })?),
7125 )),
7126 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
7127 ::treesitter_types::runtime::maybe_grow_stack(|| {
7128 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
7129 })?,
7130 ))),
7131 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7132 }
7133 }
7134}
7135impl ::treesitter_types::Spanned for ImportSpecPath<'_> {
7136 fn span(&self) -> ::treesitter_types::Span {
7137 match self {
7138 Self::InterpretedStringLiteral(inner) => inner.span(),
7139 Self::RawStringLiteral(inner) => inner.span(),
7140 }
7141 }
7142}
7143#[derive(Debug, Clone, PartialEq, Eq)]
7144pub enum InterfaceTypeChildren<'tree> {
7145 MethodElem(::std::boxed::Box<MethodElem<'tree>>),
7146 TypeElem(::std::boxed::Box<TypeElem<'tree>>),
7147}
7148impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceTypeChildren<'tree> {
7149 #[allow(clippy::collapsible_else_if)]
7150 fn from_node(
7151 node: ::treesitter_types::tree_sitter::Node<'tree>,
7152 src: &'tree [u8],
7153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7154 match node.kind() {
7155 "method_elem" => Ok(Self::MethodElem(::std::boxed::Box::new(
7156 ::treesitter_types::runtime::maybe_grow_stack(|| {
7157 <MethodElem as ::treesitter_types::FromNode>::from_node(node, src)
7158 })?,
7159 ))),
7160 "type_elem" => Ok(Self::TypeElem(::std::boxed::Box::new(
7161 ::treesitter_types::runtime::maybe_grow_stack(|| {
7162 <TypeElem as ::treesitter_types::FromNode>::from_node(node, src)
7163 })?,
7164 ))),
7165 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7166 }
7167 }
7168}
7169impl ::treesitter_types::Spanned for InterfaceTypeChildren<'_> {
7170 fn span(&self) -> ::treesitter_types::Span {
7171 match self {
7172 Self::MethodElem(inner) => inner.span(),
7173 Self::TypeElem(inner) => inner.span(),
7174 }
7175 }
7176}
7177#[derive(Debug, Clone, PartialEq, Eq)]
7178pub enum InterpretedStringLiteralChildren<'tree> {
7179 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
7180 InterpretedStringLiteralContent(::std::boxed::Box<InterpretedStringLiteralContent<'tree>>),
7181}
7182impl<'tree> ::treesitter_types::FromNode<'tree> for InterpretedStringLiteralChildren<'tree> {
7183 #[allow(clippy::collapsible_else_if)]
7184 fn from_node(
7185 node: ::treesitter_types::tree_sitter::Node<'tree>,
7186 src: &'tree [u8],
7187 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7188 match node.kind() {
7189 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
7190 ::treesitter_types::runtime::maybe_grow_stack(|| {
7191 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
7192 })?,
7193 ))),
7194 "interpreted_string_literal_content" => Ok(Self::InterpretedStringLiteralContent(
7195 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7196 <InterpretedStringLiteralContent as ::treesitter_types::FromNode>::from_node(
7197 node, src,
7198 )
7199 })?),
7200 )),
7201 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7202 }
7203 }
7204}
7205impl ::treesitter_types::Spanned for InterpretedStringLiteralChildren<'_> {
7206 fn span(&self) -> ::treesitter_types::Span {
7207 match self {
7208 Self::EscapeSequence(inner) => inner.span(),
7209 Self::InterpretedStringLiteralContent(inner) => inner.span(),
7210 }
7211 }
7212}
7213#[derive(Debug, Clone, PartialEq, Eq)]
7214pub enum LiteralElementChildren<'tree> {
7215 Expression(::std::boxed::Box<Expression<'tree>>),
7216 LiteralValue(::std::boxed::Box<LiteralValue<'tree>>),
7217}
7218impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralElementChildren<'tree> {
7219 #[allow(clippy::collapsible_else_if)]
7220 fn from_node(
7221 node: ::treesitter_types::tree_sitter::Node<'tree>,
7222 src: &'tree [u8],
7223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7224 match node.kind() {
7225 "literal_value" => Ok(Self::LiteralValue(::std::boxed::Box::new(
7226 ::treesitter_types::runtime::maybe_grow_stack(|| {
7227 <LiteralValue as ::treesitter_types::FromNode>::from_node(node, src)
7228 })?,
7229 ))),
7230 _other => {
7231 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7232 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7233 }) {
7234 Ok(Self::Expression(::std::boxed::Box::new(v)))
7235 } else {
7236 Err(::treesitter_types::ParseError::unexpected_kind(
7237 _other, node,
7238 ))
7239 }
7240 }
7241 }
7242 }
7243}
7244impl ::treesitter_types::Spanned for LiteralElementChildren<'_> {
7245 fn span(&self) -> ::treesitter_types::Span {
7246 match self {
7247 Self::Expression(inner) => inner.span(),
7248 Self::LiteralValue(inner) => inner.span(),
7249 }
7250 }
7251}
7252#[derive(Debug, Clone, PartialEq, Eq)]
7253pub enum LiteralValueChildren<'tree> {
7254 KeyedElement(::std::boxed::Box<KeyedElement<'tree>>),
7255 LiteralElement(::std::boxed::Box<LiteralElement<'tree>>),
7256}
7257impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralValueChildren<'tree> {
7258 #[allow(clippy::collapsible_else_if)]
7259 fn from_node(
7260 node: ::treesitter_types::tree_sitter::Node<'tree>,
7261 src: &'tree [u8],
7262 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7263 match node.kind() {
7264 "keyed_element" => Ok(Self::KeyedElement(::std::boxed::Box::new(
7265 ::treesitter_types::runtime::maybe_grow_stack(|| {
7266 <KeyedElement as ::treesitter_types::FromNode>::from_node(node, src)
7267 })?,
7268 ))),
7269 "literal_element" => Ok(Self::LiteralElement(::std::boxed::Box::new(
7270 ::treesitter_types::runtime::maybe_grow_stack(|| {
7271 <LiteralElement as ::treesitter_types::FromNode>::from_node(node, src)
7272 })?,
7273 ))),
7274 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7275 }
7276 }
7277}
7278impl ::treesitter_types::Spanned for LiteralValueChildren<'_> {
7279 fn span(&self) -> ::treesitter_types::Span {
7280 match self {
7281 Self::KeyedElement(inner) => inner.span(),
7282 Self::LiteralElement(inner) => inner.span(),
7283 }
7284 }
7285}
7286#[derive(Debug, Clone, PartialEq, Eq)]
7287pub enum MethodDeclarationResult<'tree> {
7288 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
7289 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
7290}
7291impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationResult<'tree> {
7292 #[allow(clippy::collapsible_else_if)]
7293 fn from_node(
7294 node: ::treesitter_types::tree_sitter::Node<'tree>,
7295 src: &'tree [u8],
7296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7297 match node.kind() {
7298 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
7299 ::treesitter_types::runtime::maybe_grow_stack(|| {
7300 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
7301 })?,
7302 ))),
7303 _other => {
7304 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7305 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
7306 }) {
7307 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
7308 } else {
7309 Err(::treesitter_types::ParseError::unexpected_kind(
7310 _other, node,
7311 ))
7312 }
7313 }
7314 }
7315 }
7316}
7317impl ::treesitter_types::Spanned for MethodDeclarationResult<'_> {
7318 fn span(&self) -> ::treesitter_types::Span {
7319 match self {
7320 Self::SimpleType(inner) => inner.span(),
7321 Self::ParameterList(inner) => inner.span(),
7322 }
7323 }
7324}
7325#[derive(Debug, Clone, PartialEq, Eq)]
7326pub enum MethodElemResult<'tree> {
7327 SimpleType(::std::boxed::Box<SimpleType<'tree>>),
7328 ParameterList(::std::boxed::Box<ParameterList<'tree>>),
7329}
7330impl<'tree> ::treesitter_types::FromNode<'tree> for MethodElemResult<'tree> {
7331 #[allow(clippy::collapsible_else_if)]
7332 fn from_node(
7333 node: ::treesitter_types::tree_sitter::Node<'tree>,
7334 src: &'tree [u8],
7335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7336 match node.kind() {
7337 "parameter_list" => Ok(Self::ParameterList(::std::boxed::Box::new(
7338 ::treesitter_types::runtime::maybe_grow_stack(|| {
7339 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
7340 })?,
7341 ))),
7342 _other => {
7343 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7344 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
7345 }) {
7346 Ok(Self::SimpleType(::std::boxed::Box::new(v)))
7347 } else {
7348 Err(::treesitter_types::ParseError::unexpected_kind(
7349 _other, node,
7350 ))
7351 }
7352 }
7353 }
7354 }
7355}
7356impl ::treesitter_types::Spanned for MethodElemResult<'_> {
7357 fn span(&self) -> ::treesitter_types::Span {
7358 match self {
7359 Self::SimpleType(inner) => inner.span(),
7360 Self::ParameterList(inner) => inner.span(),
7361 }
7362 }
7363}
7364#[derive(Debug, Clone, PartialEq, Eq)]
7365pub enum ParameterListChildren<'tree> {
7366 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
7367 VariadicParameterDeclaration(::std::boxed::Box<VariadicParameterDeclaration<'tree>>),
7368}
7369impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
7370 #[allow(clippy::collapsible_else_if)]
7371 fn from_node(
7372 node: ::treesitter_types::tree_sitter::Node<'tree>,
7373 src: &'tree [u8],
7374 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7375 match node.kind() {
7376 "parameter_declaration" => Ok(Self::ParameterDeclaration(::std::boxed::Box::new(
7377 ::treesitter_types::runtime::maybe_grow_stack(|| {
7378 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7379 })?,
7380 ))),
7381 "variadic_parameter_declaration" => Ok(Self::VariadicParameterDeclaration(
7382 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7383 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
7384 node, src,
7385 )
7386 })?),
7387 )),
7388 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7389 }
7390 }
7391}
7392impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
7393 fn span(&self) -> ::treesitter_types::Span {
7394 match self {
7395 Self::ParameterDeclaration(inner) => inner.span(),
7396 Self::VariadicParameterDeclaration(inner) => inner.span(),
7397 }
7398 }
7399}
7400#[derive(Debug, Clone, PartialEq, Eq)]
7401pub enum SelectStatementChildren<'tree> {
7402 CommunicationCase(::std::boxed::Box<CommunicationCase<'tree>>),
7403 DefaultCase(::std::boxed::Box<DefaultCase<'tree>>),
7404}
7405impl<'tree> ::treesitter_types::FromNode<'tree> for SelectStatementChildren<'tree> {
7406 #[allow(clippy::collapsible_else_if)]
7407 fn from_node(
7408 node: ::treesitter_types::tree_sitter::Node<'tree>,
7409 src: &'tree [u8],
7410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7411 match node.kind() {
7412 "communication_case" => Ok(Self::CommunicationCase(::std::boxed::Box::new(
7413 ::treesitter_types::runtime::maybe_grow_stack(|| {
7414 <CommunicationCase as ::treesitter_types::FromNode>::from_node(node, src)
7415 })?,
7416 ))),
7417 "default_case" => Ok(Self::DefaultCase(::std::boxed::Box::new(
7418 ::treesitter_types::runtime::maybe_grow_stack(|| {
7419 <DefaultCase as ::treesitter_types::FromNode>::from_node(node, src)
7420 })?,
7421 ))),
7422 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7423 }
7424 }
7425}
7426impl ::treesitter_types::Spanned for SelectStatementChildren<'_> {
7427 fn span(&self) -> ::treesitter_types::Span {
7428 match self {
7429 Self::CommunicationCase(inner) => inner.span(),
7430 Self::DefaultCase(inner) => inner.span(),
7431 }
7432 }
7433}
7434#[derive(Debug, Clone, PartialEq, Eq)]
7435pub enum SourceFileChildren<'tree> {
7436 Statement(::std::boxed::Box<Statement<'tree>>),
7437 FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
7438 ImportDeclaration(::std::boxed::Box<ImportDeclaration<'tree>>),
7439 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
7440 PackageClause(::std::boxed::Box<PackageClause<'tree>>),
7441}
7442impl<'tree> ::treesitter_types::FromNode<'tree> for SourceFileChildren<'tree> {
7443 #[allow(clippy::collapsible_else_if)]
7444 fn from_node(
7445 node: ::treesitter_types::tree_sitter::Node<'tree>,
7446 src: &'tree [u8],
7447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7448 match node.kind() {
7449 "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
7450 ::treesitter_types::runtime::maybe_grow_stack(|| {
7451 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7452 })?,
7453 ))),
7454 "import_declaration" => Ok(Self::ImportDeclaration(::std::boxed::Box::new(
7455 ::treesitter_types::runtime::maybe_grow_stack(|| {
7456 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7457 })?,
7458 ))),
7459 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
7460 ::treesitter_types::runtime::maybe_grow_stack(|| {
7461 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7462 })?,
7463 ))),
7464 "package_clause" => Ok(Self::PackageClause(::std::boxed::Box::new(
7465 ::treesitter_types::runtime::maybe_grow_stack(|| {
7466 <PackageClause as ::treesitter_types::FromNode>::from_node(node, src)
7467 })?,
7468 ))),
7469 _other => {
7470 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7471 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7472 }) {
7473 Ok(Self::Statement(::std::boxed::Box::new(v)))
7474 } else {
7475 Err(::treesitter_types::ParseError::unexpected_kind(
7476 _other, node,
7477 ))
7478 }
7479 }
7480 }
7481 }
7482}
7483impl ::treesitter_types::Spanned for SourceFileChildren<'_> {
7484 fn span(&self) -> ::treesitter_types::Span {
7485 match self {
7486 Self::Statement(inner) => inner.span(),
7487 Self::FunctionDeclaration(inner) => inner.span(),
7488 Self::ImportDeclaration(inner) => inner.span(),
7489 Self::MethodDeclaration(inner) => inner.span(),
7490 Self::PackageClause(inner) => inner.span(),
7491 }
7492 }
7493}
7494#[derive(Debug, Clone, PartialEq, Eq)]
7495pub enum TypeCaseType<'tree> {
7496 Comma(::treesitter_types::Span),
7497 Type(::std::boxed::Box<Type<'tree>>),
7498}
7499impl<'tree> ::treesitter_types::FromNode<'tree> for TypeCaseType<'tree> {
7500 #[allow(clippy::collapsible_else_if)]
7501 fn from_node(
7502 node: ::treesitter_types::tree_sitter::Node<'tree>,
7503 src: &'tree [u8],
7504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7505 match node.kind() {
7506 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
7507 _other => {
7508 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7509 <Type as ::treesitter_types::FromNode>::from_node(node, src)
7510 }) {
7511 Ok(Self::Type(::std::boxed::Box::new(v)))
7512 } else {
7513 Err(::treesitter_types::ParseError::unexpected_kind(
7514 _other, node,
7515 ))
7516 }
7517 }
7518 }
7519 }
7520}
7521impl ::treesitter_types::Spanned for TypeCaseType<'_> {
7522 fn span(&self) -> ::treesitter_types::Span {
7523 match self {
7524 Self::Comma(span) => *span,
7525 Self::Type(inner) => inner.span(),
7526 }
7527 }
7528}
7529#[derive(Debug, Clone, PartialEq, Eq)]
7530pub enum TypeDeclarationChildren<'tree> {
7531 TypeAlias(::std::boxed::Box<TypeAlias<'tree>>),
7532 TypeSpec(::std::boxed::Box<TypeSpec<'tree>>),
7533}
7534impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclarationChildren<'tree> {
7535 #[allow(clippy::collapsible_else_if)]
7536 fn from_node(
7537 node: ::treesitter_types::tree_sitter::Node<'tree>,
7538 src: &'tree [u8],
7539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7540 match node.kind() {
7541 "type_alias" => Ok(Self::TypeAlias(::std::boxed::Box::new(
7542 ::treesitter_types::runtime::maybe_grow_stack(|| {
7543 <TypeAlias as ::treesitter_types::FromNode>::from_node(node, src)
7544 })?,
7545 ))),
7546 "type_spec" => Ok(Self::TypeSpec(::std::boxed::Box::new(
7547 ::treesitter_types::runtime::maybe_grow_stack(|| {
7548 <TypeSpec as ::treesitter_types::FromNode>::from_node(node, src)
7549 })?,
7550 ))),
7551 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7552 }
7553 }
7554}
7555impl ::treesitter_types::Spanned for TypeDeclarationChildren<'_> {
7556 fn span(&self) -> ::treesitter_types::Span {
7557 match self {
7558 Self::TypeAlias(inner) => inner.span(),
7559 Self::TypeSpec(inner) => inner.span(),
7560 }
7561 }
7562}
7563#[derive(Debug, Clone, PartialEq, Eq)]
7564pub enum TypeSwitchStatementChildren<'tree> {
7565 DefaultCase(::std::boxed::Box<DefaultCase<'tree>>),
7566 TypeCase(::std::boxed::Box<TypeCase<'tree>>),
7567}
7568impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSwitchStatementChildren<'tree> {
7569 #[allow(clippy::collapsible_else_if)]
7570 fn from_node(
7571 node: ::treesitter_types::tree_sitter::Node<'tree>,
7572 src: &'tree [u8],
7573 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7574 match node.kind() {
7575 "default_case" => Ok(Self::DefaultCase(::std::boxed::Box::new(
7576 ::treesitter_types::runtime::maybe_grow_stack(|| {
7577 <DefaultCase as ::treesitter_types::FromNode>::from_node(node, src)
7578 })?,
7579 ))),
7580 "type_case" => Ok(Self::TypeCase(::std::boxed::Box::new(
7581 ::treesitter_types::runtime::maybe_grow_stack(|| {
7582 <TypeCase as ::treesitter_types::FromNode>::from_node(node, src)
7583 })?,
7584 ))),
7585 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7586 }
7587 }
7588}
7589impl ::treesitter_types::Spanned for TypeSwitchStatementChildren<'_> {
7590 fn span(&self) -> ::treesitter_types::Span {
7591 match self {
7592 Self::DefaultCase(inner) => inner.span(),
7593 Self::TypeCase(inner) => inner.span(),
7594 }
7595 }
7596}
7597#[derive(Debug, Clone, PartialEq, Eq)]
7598pub enum UnaryExpressionOperator {
7599 Bang(::treesitter_types::Span),
7600 Amp(::treesitter_types::Span),
7601 Star(::treesitter_types::Span),
7602 Plus(::treesitter_types::Span),
7603 Minus(::treesitter_types::Span),
7604 LArrow(::treesitter_types::Span),
7605 Caret(::treesitter_types::Span),
7606}
7607impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
7608 #[allow(clippy::collapsible_else_if)]
7609 fn from_node(
7610 node: ::treesitter_types::tree_sitter::Node<'tree>,
7611 _src: &'tree [u8],
7612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7613 match node.kind() {
7614 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
7615 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
7616 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7617 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
7618 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
7619 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
7620 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
7621 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7622 }
7623 }
7624}
7625impl ::treesitter_types::Spanned for UnaryExpressionOperator {
7626 fn span(&self) -> ::treesitter_types::Span {
7627 match self {
7628 Self::Bang(span) => *span,
7629 Self::Amp(span) => *span,
7630 Self::Star(span) => *span,
7631 Self::Plus(span) => *span,
7632 Self::Minus(span) => *span,
7633 Self::LArrow(span) => *span,
7634 Self::Caret(span) => *span,
7635 }
7636 }
7637}
7638#[derive(Debug, Clone, PartialEq, Eq)]
7639pub enum VarDeclarationChildren<'tree> {
7640 VarSpec(::std::boxed::Box<VarSpec<'tree>>),
7641 VarSpecList(::std::boxed::Box<VarSpecList<'tree>>),
7642}
7643impl<'tree> ::treesitter_types::FromNode<'tree> for VarDeclarationChildren<'tree> {
7644 #[allow(clippy::collapsible_else_if)]
7645 fn from_node(
7646 node: ::treesitter_types::tree_sitter::Node<'tree>,
7647 src: &'tree [u8],
7648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7649 match node.kind() {
7650 "var_spec" => Ok(Self::VarSpec(::std::boxed::Box::new(
7651 ::treesitter_types::runtime::maybe_grow_stack(|| {
7652 <VarSpec as ::treesitter_types::FromNode>::from_node(node, src)
7653 })?,
7654 ))),
7655 "var_spec_list" => Ok(Self::VarSpecList(::std::boxed::Box::new(
7656 ::treesitter_types::runtime::maybe_grow_stack(|| {
7657 <VarSpecList as ::treesitter_types::FromNode>::from_node(node, src)
7658 })?,
7659 ))),
7660 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7661 }
7662 }
7663}
7664impl ::treesitter_types::Spanned for VarDeclarationChildren<'_> {
7665 fn span(&self) -> ::treesitter_types::Span {
7666 match self {
7667 Self::VarSpec(inner) => inner.span(),
7668 Self::VarSpecList(inner) => inner.span(),
7669 }
7670 }
7671}
7672#[derive(Debug, Clone, PartialEq, Eq)]
7673pub enum AnyNode<'tree> {
7674 Expression(Expression<'tree>),
7675 SimpleStatement(SimpleStatement<'tree>),
7676 SimpleType(SimpleType<'tree>),
7677 Statement(Statement<'tree>),
7678 Type(Type<'tree>),
7679 ArgumentList(ArgumentList<'tree>),
7680 ArrayType(ArrayType<'tree>),
7681 AssignmentStatement(AssignmentStatement<'tree>),
7682 BinaryExpression(BinaryExpression<'tree>),
7683 Block(Block<'tree>),
7684 BreakStatement(BreakStatement<'tree>),
7685 CallExpression(CallExpression<'tree>),
7686 ChannelType(ChannelType<'tree>),
7687 CommunicationCase(CommunicationCase<'tree>),
7688 CompositeLiteral(CompositeLiteral<'tree>),
7689 ConstDeclaration(ConstDeclaration<'tree>),
7690 ConstSpec(ConstSpec<'tree>),
7691 ContinueStatement(ContinueStatement<'tree>),
7692 DecStatement(DecStatement<'tree>),
7693 DefaultCase(DefaultCase<'tree>),
7694 DeferStatement(DeferStatement<'tree>),
7695 Dot(Dot<'tree>),
7696 EmptyStatement(EmptyStatement<'tree>),
7697 ExpressionCase(ExpressionCase<'tree>),
7698 ExpressionList(ExpressionList<'tree>),
7699 ExpressionStatement(ExpressionStatement<'tree>),
7700 ExpressionSwitchStatement(ExpressionSwitchStatement<'tree>),
7701 FallthroughStatement(FallthroughStatement<'tree>),
7702 FieldDeclaration(FieldDeclaration<'tree>),
7703 FieldDeclarationList(FieldDeclarationList<'tree>),
7704 ForClause(ForClause<'tree>),
7705 ForStatement(ForStatement<'tree>),
7706 FuncLiteral(FuncLiteral<'tree>),
7707 FunctionDeclaration(FunctionDeclaration<'tree>),
7708 FunctionType(FunctionType<'tree>),
7709 GenericType(GenericType<'tree>),
7710 GoStatement(GoStatement<'tree>),
7711 GotoStatement(GotoStatement<'tree>),
7712 IfStatement(IfStatement<'tree>),
7713 ImplicitLengthArrayType(ImplicitLengthArrayType<'tree>),
7714 ImportDeclaration(ImportDeclaration<'tree>),
7715 ImportSpec(ImportSpec<'tree>),
7716 ImportSpecList(ImportSpecList<'tree>),
7717 IncStatement(IncStatement<'tree>),
7718 IndexExpression(IndexExpression<'tree>),
7719 InterfaceType(InterfaceType<'tree>),
7720 InterpretedStringLiteral(InterpretedStringLiteral<'tree>),
7721 KeyedElement(KeyedElement<'tree>),
7722 LabeledStatement(LabeledStatement<'tree>),
7723 LiteralElement(LiteralElement<'tree>),
7724 LiteralValue(LiteralValue<'tree>),
7725 MapType(MapType<'tree>),
7726 MethodDeclaration(MethodDeclaration<'tree>),
7727 MethodElem(MethodElem<'tree>),
7728 NegatedType(NegatedType<'tree>),
7729 PackageClause(PackageClause<'tree>),
7730 ParameterDeclaration(ParameterDeclaration<'tree>),
7731 ParameterList(ParameterList<'tree>),
7732 ParenthesizedExpression(ParenthesizedExpression<'tree>),
7733 ParenthesizedType(ParenthesizedType<'tree>),
7734 PointerType(PointerType<'tree>),
7735 QualifiedType(QualifiedType<'tree>),
7736 RangeClause(RangeClause<'tree>),
7737 RawStringLiteral(RawStringLiteral<'tree>),
7738 ReceiveStatement(ReceiveStatement<'tree>),
7739 ReturnStatement(ReturnStatement<'tree>),
7740 SelectStatement(SelectStatement<'tree>),
7741 SelectorExpression(SelectorExpression<'tree>),
7742 SendStatement(SendStatement<'tree>),
7743 ShortVarDeclaration(ShortVarDeclaration<'tree>),
7744 SliceExpression(SliceExpression<'tree>),
7745 SliceType(SliceType<'tree>),
7746 SourceFile(SourceFile<'tree>),
7747 StatementList(StatementList<'tree>),
7748 StructType(StructType<'tree>),
7749 TypeAlias(TypeAlias<'tree>),
7750 TypeArguments(TypeArguments<'tree>),
7751 TypeAssertionExpression(TypeAssertionExpression<'tree>),
7752 TypeCase(TypeCase<'tree>),
7753 TypeConstraint(TypeConstraint<'tree>),
7754 TypeConversionExpression(TypeConversionExpression<'tree>),
7755 TypeDeclaration(TypeDeclaration<'tree>),
7756 TypeElem(TypeElem<'tree>),
7757 TypeInstantiationExpression(TypeInstantiationExpression<'tree>),
7758 TypeParameterDeclaration(TypeParameterDeclaration<'tree>),
7759 TypeParameterList(TypeParameterList<'tree>),
7760 TypeSpec(TypeSpec<'tree>),
7761 TypeSwitchStatement(TypeSwitchStatement<'tree>),
7762 UnaryExpression(UnaryExpression<'tree>),
7763 VarDeclaration(VarDeclaration<'tree>),
7764 VarSpec(VarSpec<'tree>),
7765 VarSpecList(VarSpecList<'tree>),
7766 VariadicArgument(VariadicArgument<'tree>),
7767 VariadicParameterDeclaration(VariadicParameterDeclaration<'tree>),
7768 BlankIdentifier(BlankIdentifier<'tree>),
7769 Comment(Comment<'tree>),
7770 EscapeSequence(EscapeSequence<'tree>),
7771 False(False<'tree>),
7772 FieldIdentifier(FieldIdentifier<'tree>),
7773 FloatLiteral(FloatLiteral<'tree>),
7774 Identifier(Identifier<'tree>),
7775 ImaginaryLiteral(ImaginaryLiteral<'tree>),
7776 IntLiteral(IntLiteral<'tree>),
7777 InterpretedStringLiteralContent(InterpretedStringLiteralContent<'tree>),
7778 Iota(Iota<'tree>),
7779 LabelName(LabelName<'tree>),
7780 Nil(Nil<'tree>),
7781 PackageIdentifier(PackageIdentifier<'tree>),
7782 RawStringLiteralContent(RawStringLiteralContent<'tree>),
7783 RuneLiteral(RuneLiteral<'tree>),
7784 True(True<'tree>),
7785 TypeIdentifier(TypeIdentifier<'tree>),
7786 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
7787}
7788impl<'tree> AnyNode<'tree> {
7789 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
7790 match node.kind() {
7791 "_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7792 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7793 })
7794 .map(Self::Expression)
7795 .unwrap_or(Self::Unknown(node)),
7796 "_simple_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7797 <SimpleStatement as ::treesitter_types::FromNode>::from_node(node, src)
7798 })
7799 .map(Self::SimpleStatement)
7800 .unwrap_or(Self::Unknown(node)),
7801 "_simple_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7802 <SimpleType as ::treesitter_types::FromNode>::from_node(node, src)
7803 })
7804 .map(Self::SimpleType)
7805 .unwrap_or(Self::Unknown(node)),
7806 "_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7807 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7808 })
7809 .map(Self::Statement)
7810 .unwrap_or(Self::Unknown(node)),
7811 "_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7812 <Type as ::treesitter_types::FromNode>::from_node(node, src)
7813 })
7814 .map(Self::Type)
7815 .unwrap_or(Self::Unknown(node)),
7816 "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7817 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
7818 })
7819 .map(Self::ArgumentList)
7820 .unwrap_or(Self::Unknown(node)),
7821 "array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7822 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
7823 })
7824 .map(Self::ArrayType)
7825 .unwrap_or(Self::Unknown(node)),
7826 "assignment_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7827 <AssignmentStatement as ::treesitter_types::FromNode>::from_node(node, src)
7828 })
7829 .map(Self::AssignmentStatement)
7830 .unwrap_or(Self::Unknown(node)),
7831 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7832 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
7833 })
7834 .map(Self::BinaryExpression)
7835 .unwrap_or(Self::Unknown(node)),
7836 "block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7837 <Block as ::treesitter_types::FromNode>::from_node(node, src)
7838 })
7839 .map(Self::Block)
7840 .unwrap_or(Self::Unknown(node)),
7841 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7842 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
7843 })
7844 .map(Self::BreakStatement)
7845 .unwrap_or(Self::Unknown(node)),
7846 "call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7847 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
7848 })
7849 .map(Self::CallExpression)
7850 .unwrap_or(Self::Unknown(node)),
7851 "channel_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7852 <ChannelType as ::treesitter_types::FromNode>::from_node(node, src)
7853 })
7854 .map(Self::ChannelType)
7855 .unwrap_or(Self::Unknown(node)),
7856 "communication_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7857 <CommunicationCase as ::treesitter_types::FromNode>::from_node(node, src)
7858 })
7859 .map(Self::CommunicationCase)
7860 .unwrap_or(Self::Unknown(node)),
7861 "composite_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7862 <CompositeLiteral as ::treesitter_types::FromNode>::from_node(node, src)
7863 })
7864 .map(Self::CompositeLiteral)
7865 .unwrap_or(Self::Unknown(node)),
7866 "const_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7867 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7868 })
7869 .map(Self::ConstDeclaration)
7870 .unwrap_or(Self::Unknown(node)),
7871 "const_spec" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7872 <ConstSpec as ::treesitter_types::FromNode>::from_node(node, src)
7873 })
7874 .map(Self::ConstSpec)
7875 .unwrap_or(Self::Unknown(node)),
7876 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7877 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
7878 })
7879 .map(Self::ContinueStatement)
7880 .unwrap_or(Self::Unknown(node)),
7881 "dec_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7882 <DecStatement as ::treesitter_types::FromNode>::from_node(node, src)
7883 })
7884 .map(Self::DecStatement)
7885 .unwrap_or(Self::Unknown(node)),
7886 "default_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7887 <DefaultCase as ::treesitter_types::FromNode>::from_node(node, src)
7888 })
7889 .map(Self::DefaultCase)
7890 .unwrap_or(Self::Unknown(node)),
7891 "defer_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7892 <DeferStatement as ::treesitter_types::FromNode>::from_node(node, src)
7893 })
7894 .map(Self::DeferStatement)
7895 .unwrap_or(Self::Unknown(node)),
7896 "dot" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7897 <Dot as ::treesitter_types::FromNode>::from_node(node, src)
7898 })
7899 .map(Self::Dot)
7900 .unwrap_or(Self::Unknown(node)),
7901 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7902 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
7903 })
7904 .map(Self::EmptyStatement)
7905 .unwrap_or(Self::Unknown(node)),
7906 "expression_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7907 <ExpressionCase as ::treesitter_types::FromNode>::from_node(node, src)
7908 })
7909 .map(Self::ExpressionCase)
7910 .unwrap_or(Self::Unknown(node)),
7911 "expression_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7912 <ExpressionList as ::treesitter_types::FromNode>::from_node(node, src)
7913 })
7914 .map(Self::ExpressionList)
7915 .unwrap_or(Self::Unknown(node)),
7916 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7917 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
7918 })
7919 .map(Self::ExpressionStatement)
7920 .unwrap_or(Self::Unknown(node)),
7921 "expression_switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7922 <ExpressionSwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
7923 })
7924 .map(Self::ExpressionSwitchStatement)
7925 .unwrap_or(Self::Unknown(node)),
7926 "fallthrough_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7927 <FallthroughStatement as ::treesitter_types::FromNode>::from_node(node, src)
7928 })
7929 .map(Self::FallthroughStatement)
7930 .unwrap_or(Self::Unknown(node)),
7931 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7932 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7933 })
7934 .map(Self::FieldDeclaration)
7935 .unwrap_or(Self::Unknown(node)),
7936 "field_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7937 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
7938 })
7939 .map(Self::FieldDeclarationList)
7940 .unwrap_or(Self::Unknown(node)),
7941 "for_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7942 <ForClause as ::treesitter_types::FromNode>::from_node(node, src)
7943 })
7944 .map(Self::ForClause)
7945 .unwrap_or(Self::Unknown(node)),
7946 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7947 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
7948 })
7949 .map(Self::ForStatement)
7950 .unwrap_or(Self::Unknown(node)),
7951 "func_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7952 <FuncLiteral as ::treesitter_types::FromNode>::from_node(node, src)
7953 })
7954 .map(Self::FuncLiteral)
7955 .unwrap_or(Self::Unknown(node)),
7956 "function_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7957 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7958 })
7959 .map(Self::FunctionDeclaration)
7960 .unwrap_or(Self::Unknown(node)),
7961 "function_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7962 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
7963 })
7964 .map(Self::FunctionType)
7965 .unwrap_or(Self::Unknown(node)),
7966 "generic_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7967 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
7968 })
7969 .map(Self::GenericType)
7970 .unwrap_or(Self::Unknown(node)),
7971 "go_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7972 <GoStatement as ::treesitter_types::FromNode>::from_node(node, src)
7973 })
7974 .map(Self::GoStatement)
7975 .unwrap_or(Self::Unknown(node)),
7976 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7977 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
7978 })
7979 .map(Self::GotoStatement)
7980 .unwrap_or(Self::Unknown(node)),
7981 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7982 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
7983 })
7984 .map(Self::IfStatement)
7985 .unwrap_or(Self::Unknown(node)),
7986 "implicit_length_array_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7987 <ImplicitLengthArrayType as ::treesitter_types::FromNode>::from_node(node, src)
7988 })
7989 .map(Self::ImplicitLengthArrayType)
7990 .unwrap_or(Self::Unknown(node)),
7991 "import_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7992 <ImportDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7993 })
7994 .map(Self::ImportDeclaration)
7995 .unwrap_or(Self::Unknown(node)),
7996 "import_spec" => ::treesitter_types::runtime::maybe_grow_stack(|| {
7997 <ImportSpec as ::treesitter_types::FromNode>::from_node(node, src)
7998 })
7999 .map(Self::ImportSpec)
8000 .unwrap_or(Self::Unknown(node)),
8001 "import_spec_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8002 <ImportSpecList as ::treesitter_types::FromNode>::from_node(node, src)
8003 })
8004 .map(Self::ImportSpecList)
8005 .unwrap_or(Self::Unknown(node)),
8006 "inc_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8007 <IncStatement as ::treesitter_types::FromNode>::from_node(node, src)
8008 })
8009 .map(Self::IncStatement)
8010 .unwrap_or(Self::Unknown(node)),
8011 "index_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8012 <IndexExpression as ::treesitter_types::FromNode>::from_node(node, src)
8013 })
8014 .map(Self::IndexExpression)
8015 .unwrap_or(Self::Unknown(node)),
8016 "interface_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8017 <InterfaceType as ::treesitter_types::FromNode>::from_node(node, src)
8018 })
8019 .map(Self::InterfaceType)
8020 .unwrap_or(Self::Unknown(node)),
8021 "interpreted_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8022 <InterpretedStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8023 })
8024 .map(Self::InterpretedStringLiteral)
8025 .unwrap_or(Self::Unknown(node)),
8026 "keyed_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8027 <KeyedElement as ::treesitter_types::FromNode>::from_node(node, src)
8028 })
8029 .map(Self::KeyedElement)
8030 .unwrap_or(Self::Unknown(node)),
8031 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8032 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
8033 })
8034 .map(Self::LabeledStatement)
8035 .unwrap_or(Self::Unknown(node)),
8036 "literal_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8037 <LiteralElement as ::treesitter_types::FromNode>::from_node(node, src)
8038 })
8039 .map(Self::LiteralElement)
8040 .unwrap_or(Self::Unknown(node)),
8041 "literal_value" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8042 <LiteralValue as ::treesitter_types::FromNode>::from_node(node, src)
8043 })
8044 .map(Self::LiteralValue)
8045 .unwrap_or(Self::Unknown(node)),
8046 "map_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8047 <MapType as ::treesitter_types::FromNode>::from_node(node, src)
8048 })
8049 .map(Self::MapType)
8050 .unwrap_or(Self::Unknown(node)),
8051 "method_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8052 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8053 })
8054 .map(Self::MethodDeclaration)
8055 .unwrap_or(Self::Unknown(node)),
8056 "method_elem" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8057 <MethodElem as ::treesitter_types::FromNode>::from_node(node, src)
8058 })
8059 .map(Self::MethodElem)
8060 .unwrap_or(Self::Unknown(node)),
8061 "negated_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8062 <NegatedType as ::treesitter_types::FromNode>::from_node(node, src)
8063 })
8064 .map(Self::NegatedType)
8065 .unwrap_or(Self::Unknown(node)),
8066 "package_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8067 <PackageClause as ::treesitter_types::FromNode>::from_node(node, src)
8068 })
8069 .map(Self::PackageClause)
8070 .unwrap_or(Self::Unknown(node)),
8071 "parameter_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8072 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8073 })
8074 .map(Self::ParameterDeclaration)
8075 .unwrap_or(Self::Unknown(node)),
8076 "parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8077 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
8078 })
8079 .map(Self::ParameterList)
8080 .unwrap_or(Self::Unknown(node)),
8081 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8082 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
8083 })
8084 .map(Self::ParenthesizedExpression)
8085 .unwrap_or(Self::Unknown(node)),
8086 "parenthesized_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8087 <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)
8088 })
8089 .map(Self::ParenthesizedType)
8090 .unwrap_or(Self::Unknown(node)),
8091 "pointer_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8092 <PointerType as ::treesitter_types::FromNode>::from_node(node, src)
8093 })
8094 .map(Self::PointerType)
8095 .unwrap_or(Self::Unknown(node)),
8096 "qualified_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8097 <QualifiedType as ::treesitter_types::FromNode>::from_node(node, src)
8098 })
8099 .map(Self::QualifiedType)
8100 .unwrap_or(Self::Unknown(node)),
8101 "range_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8102 <RangeClause as ::treesitter_types::FromNode>::from_node(node, src)
8103 })
8104 .map(Self::RangeClause)
8105 .unwrap_or(Self::Unknown(node)),
8106 "raw_string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8107 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8108 })
8109 .map(Self::RawStringLiteral)
8110 .unwrap_or(Self::Unknown(node)),
8111 "receive_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8112 <ReceiveStatement as ::treesitter_types::FromNode>::from_node(node, src)
8113 })
8114 .map(Self::ReceiveStatement)
8115 .unwrap_or(Self::Unknown(node)),
8116 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8117 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
8118 })
8119 .map(Self::ReturnStatement)
8120 .unwrap_or(Self::Unknown(node)),
8121 "select_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8122 <SelectStatement as ::treesitter_types::FromNode>::from_node(node, src)
8123 })
8124 .map(Self::SelectStatement)
8125 .unwrap_or(Self::Unknown(node)),
8126 "selector_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8127 <SelectorExpression as ::treesitter_types::FromNode>::from_node(node, src)
8128 })
8129 .map(Self::SelectorExpression)
8130 .unwrap_or(Self::Unknown(node)),
8131 "send_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8132 <SendStatement as ::treesitter_types::FromNode>::from_node(node, src)
8133 })
8134 .map(Self::SendStatement)
8135 .unwrap_or(Self::Unknown(node)),
8136 "short_var_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8137 <ShortVarDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8138 })
8139 .map(Self::ShortVarDeclaration)
8140 .unwrap_or(Self::Unknown(node)),
8141 "slice_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8142 <SliceExpression as ::treesitter_types::FromNode>::from_node(node, src)
8143 })
8144 .map(Self::SliceExpression)
8145 .unwrap_or(Self::Unknown(node)),
8146 "slice_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8147 <SliceType as ::treesitter_types::FromNode>::from_node(node, src)
8148 })
8149 .map(Self::SliceType)
8150 .unwrap_or(Self::Unknown(node)),
8151 "source_file" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8152 <SourceFile as ::treesitter_types::FromNode>::from_node(node, src)
8153 })
8154 .map(Self::SourceFile)
8155 .unwrap_or(Self::Unknown(node)),
8156 "statement_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8157 <StatementList as ::treesitter_types::FromNode>::from_node(node, src)
8158 })
8159 .map(Self::StatementList)
8160 .unwrap_or(Self::Unknown(node)),
8161 "struct_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8162 <StructType as ::treesitter_types::FromNode>::from_node(node, src)
8163 })
8164 .map(Self::StructType)
8165 .unwrap_or(Self::Unknown(node)),
8166 "type_alias" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8167 <TypeAlias as ::treesitter_types::FromNode>::from_node(node, src)
8168 })
8169 .map(Self::TypeAlias)
8170 .unwrap_or(Self::Unknown(node)),
8171 "type_arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8172 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
8173 })
8174 .map(Self::TypeArguments)
8175 .unwrap_or(Self::Unknown(node)),
8176 "type_assertion_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8177 <TypeAssertionExpression as ::treesitter_types::FromNode>::from_node(node, src)
8178 })
8179 .map(Self::TypeAssertionExpression)
8180 .unwrap_or(Self::Unknown(node)),
8181 "type_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8182 <TypeCase as ::treesitter_types::FromNode>::from_node(node, src)
8183 })
8184 .map(Self::TypeCase)
8185 .unwrap_or(Self::Unknown(node)),
8186 "type_constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8187 <TypeConstraint as ::treesitter_types::FromNode>::from_node(node, src)
8188 })
8189 .map(Self::TypeConstraint)
8190 .unwrap_or(Self::Unknown(node)),
8191 "type_conversion_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8192 <TypeConversionExpression as ::treesitter_types::FromNode>::from_node(node, src)
8193 })
8194 .map(Self::TypeConversionExpression)
8195 .unwrap_or(Self::Unknown(node)),
8196 "type_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8197 <TypeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8198 })
8199 .map(Self::TypeDeclaration)
8200 .unwrap_or(Self::Unknown(node)),
8201 "type_elem" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8202 <TypeElem as ::treesitter_types::FromNode>::from_node(node, src)
8203 })
8204 .map(Self::TypeElem)
8205 .unwrap_or(Self::Unknown(node)),
8206 "type_instantiation_expression" => {
8207 ::treesitter_types::runtime::maybe_grow_stack(|| {
8208 <TypeInstantiationExpression as ::treesitter_types::FromNode>::from_node(
8209 node, src,
8210 )
8211 })
8212 .map(Self::TypeInstantiationExpression)
8213 .unwrap_or(Self::Unknown(node))
8214 }
8215 "type_parameter_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8216 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8217 })
8218 .map(Self::TypeParameterDeclaration)
8219 .unwrap_or(Self::Unknown(node)),
8220 "type_parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8221 <TypeParameterList as ::treesitter_types::FromNode>::from_node(node, src)
8222 })
8223 .map(Self::TypeParameterList)
8224 .unwrap_or(Self::Unknown(node)),
8225 "type_spec" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8226 <TypeSpec as ::treesitter_types::FromNode>::from_node(node, src)
8227 })
8228 .map(Self::TypeSpec)
8229 .unwrap_or(Self::Unknown(node)),
8230 "type_switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8231 <TypeSwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
8232 })
8233 .map(Self::TypeSwitchStatement)
8234 .unwrap_or(Self::Unknown(node)),
8235 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8236 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
8237 })
8238 .map(Self::UnaryExpression)
8239 .unwrap_or(Self::Unknown(node)),
8240 "var_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8241 <VarDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8242 })
8243 .map(Self::VarDeclaration)
8244 .unwrap_or(Self::Unknown(node)),
8245 "var_spec" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8246 <VarSpec as ::treesitter_types::FromNode>::from_node(node, src)
8247 })
8248 .map(Self::VarSpec)
8249 .unwrap_or(Self::Unknown(node)),
8250 "var_spec_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8251 <VarSpecList as ::treesitter_types::FromNode>::from_node(node, src)
8252 })
8253 .map(Self::VarSpecList)
8254 .unwrap_or(Self::Unknown(node)),
8255 "variadic_argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8256 <VariadicArgument as ::treesitter_types::FromNode>::from_node(node, src)
8257 })
8258 .map(Self::VariadicArgument)
8259 .unwrap_or(Self::Unknown(node)),
8260 "variadic_parameter_declaration" => {
8261 ::treesitter_types::runtime::maybe_grow_stack(|| {
8262 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
8263 node, src,
8264 )
8265 })
8266 .map(Self::VariadicParameterDeclaration)
8267 .unwrap_or(Self::Unknown(node))
8268 }
8269 "blank_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8270 <BlankIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8271 })
8272 .map(Self::BlankIdentifier)
8273 .unwrap_or(Self::Unknown(node)),
8274 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8275 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
8276 })
8277 .map(Self::Comment)
8278 .unwrap_or(Self::Unknown(node)),
8279 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8280 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8281 })
8282 .map(Self::EscapeSequence)
8283 .unwrap_or(Self::Unknown(node)),
8284 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8285 <False as ::treesitter_types::FromNode>::from_node(node, src)
8286 })
8287 .map(Self::False)
8288 .unwrap_or(Self::Unknown(node)),
8289 "field_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8290 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8291 })
8292 .map(Self::FieldIdentifier)
8293 .unwrap_or(Self::Unknown(node)),
8294 "float_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8295 <FloatLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8296 })
8297 .map(Self::FloatLiteral)
8298 .unwrap_or(Self::Unknown(node)),
8299 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8300 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8301 })
8302 .map(Self::Identifier)
8303 .unwrap_or(Self::Unknown(node)),
8304 "imaginary_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8305 <ImaginaryLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8306 })
8307 .map(Self::ImaginaryLiteral)
8308 .unwrap_or(Self::Unknown(node)),
8309 "int_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8310 <IntLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8311 })
8312 .map(Self::IntLiteral)
8313 .unwrap_or(Self::Unknown(node)),
8314 "interpreted_string_literal_content" => {
8315 ::treesitter_types::runtime::maybe_grow_stack(|| {
8316 <InterpretedStringLiteralContent as ::treesitter_types::FromNode>::from_node(
8317 node, src,
8318 )
8319 })
8320 .map(Self::InterpretedStringLiteralContent)
8321 .unwrap_or(Self::Unknown(node))
8322 }
8323 "iota" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8324 <Iota as ::treesitter_types::FromNode>::from_node(node, src)
8325 })
8326 .map(Self::Iota)
8327 .unwrap_or(Self::Unknown(node)),
8328 "label_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8329 <LabelName as ::treesitter_types::FromNode>::from_node(node, src)
8330 })
8331 .map(Self::LabelName)
8332 .unwrap_or(Self::Unknown(node)),
8333 "nil" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8334 <Nil as ::treesitter_types::FromNode>::from_node(node, src)
8335 })
8336 .map(Self::Nil)
8337 .unwrap_or(Self::Unknown(node)),
8338 "package_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8339 <PackageIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8340 })
8341 .map(Self::PackageIdentifier)
8342 .unwrap_or(Self::Unknown(node)),
8343 "raw_string_literal_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8344 <RawStringLiteralContent as ::treesitter_types::FromNode>::from_node(node, src)
8345 })
8346 .map(Self::RawStringLiteralContent)
8347 .unwrap_or(Self::Unknown(node)),
8348 "rune_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8349 <RuneLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8350 })
8351 .map(Self::RuneLiteral)
8352 .unwrap_or(Self::Unknown(node)),
8353 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8354 <True as ::treesitter_types::FromNode>::from_node(node, src)
8355 })
8356 .map(Self::True)
8357 .unwrap_or(Self::Unknown(node)),
8358 "type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
8359 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
8360 })
8361 .map(Self::TypeIdentifier)
8362 .unwrap_or(Self::Unknown(node)),
8363 _ => Self::Unknown(node),
8364 }
8365 }
8366}
8367impl ::treesitter_types::Spanned for AnyNode<'_> {
8368 fn span(&self) -> ::treesitter_types::Span {
8369 match self {
8370 Self::Expression(inner) => inner.span(),
8371 Self::SimpleStatement(inner) => inner.span(),
8372 Self::SimpleType(inner) => inner.span(),
8373 Self::Statement(inner) => inner.span(),
8374 Self::Type(inner) => inner.span(),
8375 Self::ArgumentList(inner) => inner.span(),
8376 Self::ArrayType(inner) => inner.span(),
8377 Self::AssignmentStatement(inner) => inner.span(),
8378 Self::BinaryExpression(inner) => inner.span(),
8379 Self::Block(inner) => inner.span(),
8380 Self::BreakStatement(inner) => inner.span(),
8381 Self::CallExpression(inner) => inner.span(),
8382 Self::ChannelType(inner) => inner.span(),
8383 Self::CommunicationCase(inner) => inner.span(),
8384 Self::CompositeLiteral(inner) => inner.span(),
8385 Self::ConstDeclaration(inner) => inner.span(),
8386 Self::ConstSpec(inner) => inner.span(),
8387 Self::ContinueStatement(inner) => inner.span(),
8388 Self::DecStatement(inner) => inner.span(),
8389 Self::DefaultCase(inner) => inner.span(),
8390 Self::DeferStatement(inner) => inner.span(),
8391 Self::Dot(inner) => inner.span(),
8392 Self::EmptyStatement(inner) => inner.span(),
8393 Self::ExpressionCase(inner) => inner.span(),
8394 Self::ExpressionList(inner) => inner.span(),
8395 Self::ExpressionStatement(inner) => inner.span(),
8396 Self::ExpressionSwitchStatement(inner) => inner.span(),
8397 Self::FallthroughStatement(inner) => inner.span(),
8398 Self::FieldDeclaration(inner) => inner.span(),
8399 Self::FieldDeclarationList(inner) => inner.span(),
8400 Self::ForClause(inner) => inner.span(),
8401 Self::ForStatement(inner) => inner.span(),
8402 Self::FuncLiteral(inner) => inner.span(),
8403 Self::FunctionDeclaration(inner) => inner.span(),
8404 Self::FunctionType(inner) => inner.span(),
8405 Self::GenericType(inner) => inner.span(),
8406 Self::GoStatement(inner) => inner.span(),
8407 Self::GotoStatement(inner) => inner.span(),
8408 Self::IfStatement(inner) => inner.span(),
8409 Self::ImplicitLengthArrayType(inner) => inner.span(),
8410 Self::ImportDeclaration(inner) => inner.span(),
8411 Self::ImportSpec(inner) => inner.span(),
8412 Self::ImportSpecList(inner) => inner.span(),
8413 Self::IncStatement(inner) => inner.span(),
8414 Self::IndexExpression(inner) => inner.span(),
8415 Self::InterfaceType(inner) => inner.span(),
8416 Self::InterpretedStringLiteral(inner) => inner.span(),
8417 Self::KeyedElement(inner) => inner.span(),
8418 Self::LabeledStatement(inner) => inner.span(),
8419 Self::LiteralElement(inner) => inner.span(),
8420 Self::LiteralValue(inner) => inner.span(),
8421 Self::MapType(inner) => inner.span(),
8422 Self::MethodDeclaration(inner) => inner.span(),
8423 Self::MethodElem(inner) => inner.span(),
8424 Self::NegatedType(inner) => inner.span(),
8425 Self::PackageClause(inner) => inner.span(),
8426 Self::ParameterDeclaration(inner) => inner.span(),
8427 Self::ParameterList(inner) => inner.span(),
8428 Self::ParenthesizedExpression(inner) => inner.span(),
8429 Self::ParenthesizedType(inner) => inner.span(),
8430 Self::PointerType(inner) => inner.span(),
8431 Self::QualifiedType(inner) => inner.span(),
8432 Self::RangeClause(inner) => inner.span(),
8433 Self::RawStringLiteral(inner) => inner.span(),
8434 Self::ReceiveStatement(inner) => inner.span(),
8435 Self::ReturnStatement(inner) => inner.span(),
8436 Self::SelectStatement(inner) => inner.span(),
8437 Self::SelectorExpression(inner) => inner.span(),
8438 Self::SendStatement(inner) => inner.span(),
8439 Self::ShortVarDeclaration(inner) => inner.span(),
8440 Self::SliceExpression(inner) => inner.span(),
8441 Self::SliceType(inner) => inner.span(),
8442 Self::SourceFile(inner) => inner.span(),
8443 Self::StatementList(inner) => inner.span(),
8444 Self::StructType(inner) => inner.span(),
8445 Self::TypeAlias(inner) => inner.span(),
8446 Self::TypeArguments(inner) => inner.span(),
8447 Self::TypeAssertionExpression(inner) => inner.span(),
8448 Self::TypeCase(inner) => inner.span(),
8449 Self::TypeConstraint(inner) => inner.span(),
8450 Self::TypeConversionExpression(inner) => inner.span(),
8451 Self::TypeDeclaration(inner) => inner.span(),
8452 Self::TypeElem(inner) => inner.span(),
8453 Self::TypeInstantiationExpression(inner) => inner.span(),
8454 Self::TypeParameterDeclaration(inner) => inner.span(),
8455 Self::TypeParameterList(inner) => inner.span(),
8456 Self::TypeSpec(inner) => inner.span(),
8457 Self::TypeSwitchStatement(inner) => inner.span(),
8458 Self::UnaryExpression(inner) => inner.span(),
8459 Self::VarDeclaration(inner) => inner.span(),
8460 Self::VarSpec(inner) => inner.span(),
8461 Self::VarSpecList(inner) => inner.span(),
8462 Self::VariadicArgument(inner) => inner.span(),
8463 Self::VariadicParameterDeclaration(inner) => inner.span(),
8464 Self::BlankIdentifier(inner) => inner.span(),
8465 Self::Comment(inner) => inner.span(),
8466 Self::EscapeSequence(inner) => inner.span(),
8467 Self::False(inner) => inner.span(),
8468 Self::FieldIdentifier(inner) => inner.span(),
8469 Self::FloatLiteral(inner) => inner.span(),
8470 Self::Identifier(inner) => inner.span(),
8471 Self::ImaginaryLiteral(inner) => inner.span(),
8472 Self::IntLiteral(inner) => inner.span(),
8473 Self::InterpretedStringLiteralContent(inner) => inner.span(),
8474 Self::Iota(inner) => inner.span(),
8475 Self::LabelName(inner) => inner.span(),
8476 Self::Nil(inner) => inner.span(),
8477 Self::PackageIdentifier(inner) => inner.span(),
8478 Self::RawStringLiteralContent(inner) => inner.span(),
8479 Self::RuneLiteral(inner) => inner.span(),
8480 Self::True(inner) => inner.span(),
8481 Self::TypeIdentifier(inner) => inner.span(),
8482 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
8483 }
8484 }
8485}