1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum AbstractDeclarator<'tree> {
3 AbstractArrayDeclarator(::std::boxed::Box<AbstractArrayDeclarator<'tree>>),
4 AbstractFunctionDeclarator(::std::boxed::Box<AbstractFunctionDeclarator<'tree>>),
5 AbstractParenthesizedDeclarator(::std::boxed::Box<AbstractParenthesizedDeclarator<'tree>>),
6 AbstractPointerDeclarator(::std::boxed::Box<AbstractPointerDeclarator<'tree>>),
7}
8impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractDeclarator<'tree> {
9 #[allow(clippy::collapsible_else_if)]
10 fn from_node(
11 node: ::treesitter_types::tree_sitter::Node<'tree>,
12 src: &'tree [u8],
13 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14 match node.kind() {
15 "abstract_array_declarator" => Ok(Self::AbstractArrayDeclarator(
16 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17 <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
18 })?),
19 )),
20 "abstract_function_declarator" => Ok(Self::AbstractFunctionDeclarator(
21 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
22 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
23 node, src,
24 )
25 })?),
26 )),
27 "abstract_parenthesized_declarator" => Ok(Self::AbstractParenthesizedDeclarator(
28 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
29 <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
30 node, src,
31 )
32 })?),
33 )),
34 "abstract_pointer_declarator" => Ok(Self::AbstractPointerDeclarator(
35 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
36 <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(
37 node, src,
38 )
39 })?),
40 )),
41 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
42 }
43 }
44}
45impl ::treesitter_types::Spanned for AbstractDeclarator<'_> {
46 fn span(&self) -> ::treesitter_types::Span {
47 match self {
48 Self::AbstractArrayDeclarator(inner) => inner.span(),
49 Self::AbstractFunctionDeclarator(inner) => inner.span(),
50 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
51 Self::AbstractPointerDeclarator(inner) => inner.span(),
52 }
53 }
54}
55#[derive(Debug, Clone, PartialEq, Eq)]
56pub enum Declarator<'tree> {
57 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
58 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
59 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
60 Identifier(::std::boxed::Box<Identifier<'tree>>),
61 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
62 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
63}
64impl<'tree> ::treesitter_types::FromNode<'tree> for Declarator<'tree> {
65 #[allow(clippy::collapsible_else_if)]
66 fn from_node(
67 node: ::treesitter_types::tree_sitter::Node<'tree>,
68 src: &'tree [u8],
69 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
70 match node.kind() {
71 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
72 ::treesitter_types::runtime::maybe_grow_stack(|| {
73 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
74 })?,
75 ))),
76 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
77 ::treesitter_types::runtime::maybe_grow_stack(|| {
78 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
79 })?,
80 ))),
81 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
82 ::treesitter_types::runtime::maybe_grow_stack(|| {
83 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
84 })?,
85 ))),
86 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
87 ::treesitter_types::runtime::maybe_grow_stack(|| {
88 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
89 })?,
90 ))),
91 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
92 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
93 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
94 })?),
95 )),
96 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
97 ::treesitter_types::runtime::maybe_grow_stack(|| {
98 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
99 })?,
100 ))),
101 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
102 }
103 }
104}
105impl ::treesitter_types::Spanned for Declarator<'_> {
106 fn span(&self) -> ::treesitter_types::Span {
107 match self {
108 Self::ArrayDeclarator(inner) => inner.span(),
109 Self::AttributedDeclarator(inner) => inner.span(),
110 Self::FunctionDeclarator(inner) => inner.span(),
111 Self::Identifier(inner) => inner.span(),
112 Self::ParenthesizedDeclarator(inner) => inner.span(),
113 Self::PointerDeclarator(inner) => inner.span(),
114 }
115 }
116}
117#[derive(Debug, Clone, PartialEq, Eq)]
118pub enum FieldDeclarator<'tree> {
119 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
120 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
121 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
122 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
123 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
124 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
125}
126impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarator<'tree> {
127 #[allow(clippy::collapsible_else_if)]
128 fn from_node(
129 node: ::treesitter_types::tree_sitter::Node<'tree>,
130 src: &'tree [u8],
131 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
132 match node.kind() {
133 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
134 ::treesitter_types::runtime::maybe_grow_stack(|| {
135 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
136 })?,
137 ))),
138 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
139 ::treesitter_types::runtime::maybe_grow_stack(|| {
140 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
141 })?,
142 ))),
143 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
144 ::treesitter_types::runtime::maybe_grow_stack(|| {
145 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
146 })?,
147 ))),
148 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
149 ::treesitter_types::runtime::maybe_grow_stack(|| {
150 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
151 })?,
152 ))),
153 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
154 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
155 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
156 })?),
157 )),
158 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
159 ::treesitter_types::runtime::maybe_grow_stack(|| {
160 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
161 })?,
162 ))),
163 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
164 }
165 }
166}
167impl ::treesitter_types::Spanned for FieldDeclarator<'_> {
168 fn span(&self) -> ::treesitter_types::Span {
169 match self {
170 Self::ArrayDeclarator(inner) => inner.span(),
171 Self::AttributedDeclarator(inner) => inner.span(),
172 Self::FieldIdentifier(inner) => inner.span(),
173 Self::FunctionDeclarator(inner) => inner.span(),
174 Self::ParenthesizedDeclarator(inner) => inner.span(),
175 Self::PointerDeclarator(inner) => inner.span(),
176 }
177 }
178}
179#[derive(Debug, Clone, PartialEq, Eq)]
180pub enum TypeDeclarator<'tree> {
181 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
182 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
183 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
184 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
185 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
186 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
187 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
188}
189impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclarator<'tree> {
190 #[allow(clippy::collapsible_else_if)]
191 fn from_node(
192 node: ::treesitter_types::tree_sitter::Node<'tree>,
193 src: &'tree [u8],
194 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
195 match node.kind() {
196 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
197 ::treesitter_types::runtime::maybe_grow_stack(|| {
198 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
199 })?,
200 ))),
201 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
202 ::treesitter_types::runtime::maybe_grow_stack(|| {
203 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
204 })?,
205 ))),
206 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
207 ::treesitter_types::runtime::maybe_grow_stack(|| {
208 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
209 })?,
210 ))),
211 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
212 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
213 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
214 })?),
215 )),
216 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
217 ::treesitter_types::runtime::maybe_grow_stack(|| {
218 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
219 })?,
220 ))),
221 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
222 ::treesitter_types::runtime::maybe_grow_stack(|| {
223 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
224 })?,
225 ))),
226 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
227 ::treesitter_types::runtime::maybe_grow_stack(|| {
228 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
229 })?,
230 ))),
231 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
232 }
233 }
234}
235impl ::treesitter_types::Spanned for TypeDeclarator<'_> {
236 fn span(&self) -> ::treesitter_types::Span {
237 match self {
238 Self::ArrayDeclarator(inner) => inner.span(),
239 Self::AttributedDeclarator(inner) => inner.span(),
240 Self::FunctionDeclarator(inner) => inner.span(),
241 Self::ParenthesizedDeclarator(inner) => inner.span(),
242 Self::PointerDeclarator(inner) => inner.span(),
243 Self::PrimitiveType(inner) => inner.span(),
244 Self::TypeIdentifier(inner) => inner.span(),
245 }
246 }
247}
248#[derive(Debug, Clone, PartialEq, Eq)]
249pub enum Expression<'tree> {
250 AlignofExpression(::std::boxed::Box<AlignofExpression<'tree>>),
251 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
252 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
253 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
254 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
255 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
256 CompoundLiteralExpression(::std::boxed::Box<CompoundLiteralExpression<'tree>>),
257 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
258 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
259 ExtensionExpression(::std::boxed::Box<ExtensionExpression<'tree>>),
260 False(::std::boxed::Box<False<'tree>>),
261 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
262 GenericExpression(::std::boxed::Box<GenericExpression<'tree>>),
263 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
264 Identifier(::std::boxed::Box<Identifier<'tree>>),
265 Null(::std::boxed::Box<Null<'tree>>),
266 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
267 OffsetofExpression(::std::boxed::Box<OffsetofExpression<'tree>>),
268 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
269 PointerExpression(::std::boxed::Box<PointerExpression<'tree>>),
270 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
271 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
272 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
273 True(::std::boxed::Box<True<'tree>>),
274 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
275 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
276}
277impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
278 #[allow(clippy::collapsible_else_if)]
279 fn from_node(
280 node: ::treesitter_types::tree_sitter::Node<'tree>,
281 src: &'tree [u8],
282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
283 match node.kind() {
284 "alignof_expression" => Ok(Self::AlignofExpression(::std::boxed::Box::new(
285 ::treesitter_types::runtime::maybe_grow_stack(|| {
286 <AlignofExpression as ::treesitter_types::FromNode>::from_node(node, src)
287 })?,
288 ))),
289 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
290 ::treesitter_types::runtime::maybe_grow_stack(|| {
291 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
292 })?,
293 ))),
294 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
295 ::treesitter_types::runtime::maybe_grow_stack(|| {
296 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
297 })?,
298 ))),
299 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
300 ::treesitter_types::runtime::maybe_grow_stack(|| {
301 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
302 })?,
303 ))),
304 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
305 ::treesitter_types::runtime::maybe_grow_stack(|| {
306 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
307 })?,
308 ))),
309 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
310 ::treesitter_types::runtime::maybe_grow_stack(|| {
311 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
312 })?,
313 ))),
314 "compound_literal_expression" => Ok(Self::CompoundLiteralExpression(
315 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
316 <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(
317 node, src,
318 )
319 })?),
320 )),
321 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
322 ::treesitter_types::runtime::maybe_grow_stack(|| {
323 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
324 })?,
325 ))),
326 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
327 ::treesitter_types::runtime::maybe_grow_stack(|| {
328 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
329 })?,
330 ))),
331 "extension_expression" => Ok(Self::ExtensionExpression(::std::boxed::Box::new(
332 ::treesitter_types::runtime::maybe_grow_stack(|| {
333 <ExtensionExpression as ::treesitter_types::FromNode>::from_node(node, src)
334 })?,
335 ))),
336 "false" => Ok(Self::False(::std::boxed::Box::new(
337 ::treesitter_types::runtime::maybe_grow_stack(|| {
338 <False as ::treesitter_types::FromNode>::from_node(node, src)
339 })?,
340 ))),
341 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
342 ::treesitter_types::runtime::maybe_grow_stack(|| {
343 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
344 })?,
345 ))),
346 "generic_expression" => Ok(Self::GenericExpression(::std::boxed::Box::new(
347 ::treesitter_types::runtime::maybe_grow_stack(|| {
348 <GenericExpression as ::treesitter_types::FromNode>::from_node(node, src)
349 })?,
350 ))),
351 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
352 ::treesitter_types::runtime::maybe_grow_stack(|| {
353 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
354 })?,
355 ))),
356 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
357 ::treesitter_types::runtime::maybe_grow_stack(|| {
358 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
359 })?,
360 ))),
361 "null" => Ok(Self::Null(::std::boxed::Box::new(
362 ::treesitter_types::runtime::maybe_grow_stack(|| {
363 <Null as ::treesitter_types::FromNode>::from_node(node, src)
364 })?,
365 ))),
366 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
367 ::treesitter_types::runtime::maybe_grow_stack(|| {
368 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
369 })?,
370 ))),
371 "offsetof_expression" => Ok(Self::OffsetofExpression(::std::boxed::Box::new(
372 ::treesitter_types::runtime::maybe_grow_stack(|| {
373 <OffsetofExpression as ::treesitter_types::FromNode>::from_node(node, src)
374 })?,
375 ))),
376 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
377 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
378 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
379 })?),
380 )),
381 "pointer_expression" => Ok(Self::PointerExpression(::std::boxed::Box::new(
382 ::treesitter_types::runtime::maybe_grow_stack(|| {
383 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)
384 })?,
385 ))),
386 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
387 ::treesitter_types::runtime::maybe_grow_stack(|| {
388 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
389 })?,
390 ))),
391 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
392 ::treesitter_types::runtime::maybe_grow_stack(|| {
393 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
394 })?,
395 ))),
396 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
397 ::treesitter_types::runtime::maybe_grow_stack(|| {
398 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
399 })?,
400 ))),
401 "true" => Ok(Self::True(::std::boxed::Box::new(
402 ::treesitter_types::runtime::maybe_grow_stack(|| {
403 <True as ::treesitter_types::FromNode>::from_node(node, src)
404 })?,
405 ))),
406 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
407 ::treesitter_types::runtime::maybe_grow_stack(|| {
408 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
409 })?,
410 ))),
411 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
412 ::treesitter_types::runtime::maybe_grow_stack(|| {
413 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
414 })?,
415 ))),
416 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
417 }
418 }
419}
420impl ::treesitter_types::Spanned for Expression<'_> {
421 fn span(&self) -> ::treesitter_types::Span {
422 match self {
423 Self::AlignofExpression(inner) => inner.span(),
424 Self::AssignmentExpression(inner) => inner.span(),
425 Self::BinaryExpression(inner) => inner.span(),
426 Self::CallExpression(inner) => inner.span(),
427 Self::CastExpression(inner) => inner.span(),
428 Self::CharLiteral(inner) => inner.span(),
429 Self::CompoundLiteralExpression(inner) => inner.span(),
430 Self::ConcatenatedString(inner) => inner.span(),
431 Self::ConditionalExpression(inner) => inner.span(),
432 Self::ExtensionExpression(inner) => inner.span(),
433 Self::False(inner) => inner.span(),
434 Self::FieldExpression(inner) => inner.span(),
435 Self::GenericExpression(inner) => inner.span(),
436 Self::GnuAsmExpression(inner) => inner.span(),
437 Self::Identifier(inner) => inner.span(),
438 Self::Null(inner) => inner.span(),
439 Self::NumberLiteral(inner) => inner.span(),
440 Self::OffsetofExpression(inner) => inner.span(),
441 Self::ParenthesizedExpression(inner) => inner.span(),
442 Self::PointerExpression(inner) => inner.span(),
443 Self::SizeofExpression(inner) => inner.span(),
444 Self::StringLiteral(inner) => inner.span(),
445 Self::SubscriptExpression(inner) => inner.span(),
446 Self::True(inner) => inner.span(),
447 Self::UnaryExpression(inner) => inner.span(),
448 Self::UpdateExpression(inner) => inner.span(),
449 }
450 }
451}
452#[derive(Debug, Clone, PartialEq, Eq)]
453pub enum Statement<'tree> {
454 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
455 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
456 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
457 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
458 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
459 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
460 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
461 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
462 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
463 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
464 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
465 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
466 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
467 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
468 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
469 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
470}
471impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
472 #[allow(clippy::collapsible_else_if)]
473 fn from_node(
474 node: ::treesitter_types::tree_sitter::Node<'tree>,
475 src: &'tree [u8],
476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
477 match node.kind() {
478 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
479 ::treesitter_types::runtime::maybe_grow_stack(|| {
480 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
481 })?,
482 ))),
483 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
484 ::treesitter_types::runtime::maybe_grow_stack(|| {
485 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
486 })?,
487 ))),
488 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
489 ::treesitter_types::runtime::maybe_grow_stack(|| {
490 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
491 })?,
492 ))),
493 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
494 ::treesitter_types::runtime::maybe_grow_stack(|| {
495 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
496 })?,
497 ))),
498 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
499 ::treesitter_types::runtime::maybe_grow_stack(|| {
500 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
501 })?,
502 ))),
503 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
504 ::treesitter_types::runtime::maybe_grow_stack(|| {
505 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
506 })?,
507 ))),
508 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
509 ::treesitter_types::runtime::maybe_grow_stack(|| {
510 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
511 })?,
512 ))),
513 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
514 ::treesitter_types::runtime::maybe_grow_stack(|| {
515 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
516 })?,
517 ))),
518 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
519 ::treesitter_types::runtime::maybe_grow_stack(|| {
520 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
521 })?,
522 ))),
523 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
524 ::treesitter_types::runtime::maybe_grow_stack(|| {
525 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
526 })?,
527 ))),
528 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
529 ::treesitter_types::runtime::maybe_grow_stack(|| {
530 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
531 })?,
532 ))),
533 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
534 ::treesitter_types::runtime::maybe_grow_stack(|| {
535 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
536 })?,
537 ))),
538 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
539 ::treesitter_types::runtime::maybe_grow_stack(|| {
540 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
541 })?,
542 ))),
543 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
544 ::treesitter_types::runtime::maybe_grow_stack(|| {
545 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
546 })?,
547 ))),
548 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
549 ::treesitter_types::runtime::maybe_grow_stack(|| {
550 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
551 })?,
552 ))),
553 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
554 ::treesitter_types::runtime::maybe_grow_stack(|| {
555 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
556 })?,
557 ))),
558 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
559 }
560 }
561}
562impl ::treesitter_types::Spanned for Statement<'_> {
563 fn span(&self) -> ::treesitter_types::Span {
564 match self {
565 Self::AttributedStatement(inner) => inner.span(),
566 Self::BreakStatement(inner) => inner.span(),
567 Self::CaseStatement(inner) => inner.span(),
568 Self::CompoundStatement(inner) => inner.span(),
569 Self::ContinueStatement(inner) => inner.span(),
570 Self::DoStatement(inner) => inner.span(),
571 Self::ExpressionStatement(inner) => inner.span(),
572 Self::ForStatement(inner) => inner.span(),
573 Self::GotoStatement(inner) => inner.span(),
574 Self::IfStatement(inner) => inner.span(),
575 Self::LabeledStatement(inner) => inner.span(),
576 Self::ReturnStatement(inner) => inner.span(),
577 Self::SehLeaveStatement(inner) => inner.span(),
578 Self::SehTryStatement(inner) => inner.span(),
579 Self::SwitchStatement(inner) => inner.span(),
580 Self::WhileStatement(inner) => inner.span(),
581 }
582 }
583}
584#[derive(Debug, Clone, PartialEq, Eq)]
585pub enum TypeSpecifier<'tree> {
586 EnumSpecifier(::std::boxed::Box<EnumSpecifier<'tree>>),
587 MacroTypeSpecifier(::std::boxed::Box<MacroTypeSpecifier<'tree>>),
588 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
589 SizedTypeSpecifier(::std::boxed::Box<SizedTypeSpecifier<'tree>>),
590 StructSpecifier(::std::boxed::Box<StructSpecifier<'tree>>),
591 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
592 UnionSpecifier(::std::boxed::Box<UnionSpecifier<'tree>>),
593}
594impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSpecifier<'tree> {
595 #[allow(clippy::collapsible_else_if)]
596 fn from_node(
597 node: ::treesitter_types::tree_sitter::Node<'tree>,
598 src: &'tree [u8],
599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
600 match node.kind() {
601 "enum_specifier" => Ok(Self::EnumSpecifier(::std::boxed::Box::new(
602 ::treesitter_types::runtime::maybe_grow_stack(|| {
603 <EnumSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
604 })?,
605 ))),
606 "macro_type_specifier" => Ok(Self::MacroTypeSpecifier(::std::boxed::Box::new(
607 ::treesitter_types::runtime::maybe_grow_stack(|| {
608 <MacroTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
609 })?,
610 ))),
611 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
612 ::treesitter_types::runtime::maybe_grow_stack(|| {
613 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
614 })?,
615 ))),
616 "sized_type_specifier" => Ok(Self::SizedTypeSpecifier(::std::boxed::Box::new(
617 ::treesitter_types::runtime::maybe_grow_stack(|| {
618 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
619 })?,
620 ))),
621 "struct_specifier" => Ok(Self::StructSpecifier(::std::boxed::Box::new(
622 ::treesitter_types::runtime::maybe_grow_stack(|| {
623 <StructSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
624 })?,
625 ))),
626 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
627 ::treesitter_types::runtime::maybe_grow_stack(|| {
628 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
629 })?,
630 ))),
631 "union_specifier" => Ok(Self::UnionSpecifier(::std::boxed::Box::new(
632 ::treesitter_types::runtime::maybe_grow_stack(|| {
633 <UnionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
634 })?,
635 ))),
636 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
637 }
638 }
639}
640impl ::treesitter_types::Spanned for TypeSpecifier<'_> {
641 fn span(&self) -> ::treesitter_types::Span {
642 match self {
643 Self::EnumSpecifier(inner) => inner.span(),
644 Self::MacroTypeSpecifier(inner) => inner.span(),
645 Self::PrimitiveType(inner) => inner.span(),
646 Self::SizedTypeSpecifier(inner) => inner.span(),
647 Self::StructSpecifier(inner) => inner.span(),
648 Self::TypeIdentifier(inner) => inner.span(),
649 Self::UnionSpecifier(inner) => inner.span(),
650 }
651 }
652}
653#[derive(Debug, Clone, PartialEq, Eq)]
654pub struct AbstractArrayDeclarator<'tree> {
655 pub span: ::treesitter_types::Span,
656 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
657 pub size: ::core::option::Option<AbstractArrayDeclaratorSize<'tree>>,
658 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
659}
660impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclarator<'tree> {
661 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
662 fn from_node(
663 node: ::treesitter_types::tree_sitter::Node<'tree>,
664 src: &'tree [u8],
665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
666 debug_assert_eq!(node.kind(), "abstract_array_declarator");
667 Ok(Self {
668 span: ::treesitter_types::Span::from(node),
669 declarator: match node.child_by_field_name("declarator") {
670 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
671 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
672 })?),
673 None => None,
674 },
675 size: match node.child_by_field_name("size") {
676 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
677 <AbstractArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(
678 child, src,
679 )
680 })?),
681 None => None,
682 },
683 children: {
684 #[allow(clippy::suspicious_else_formatting)]
685 let non_field_children = {
686 let mut cursor = node.walk();
687 let mut result = ::std::vec::Vec::new();
688 if cursor.goto_first_child() {
689 loop {
690 if cursor.field_name().is_none()
691 && cursor.node().is_named()
692 && !cursor.node().is_extra()
693 {
694 result.push(cursor.node());
695 }
696 if !cursor.goto_next_sibling() {
697 break;
698 }
699 }
700 }
701 result
702 };
703 let mut items = ::std::vec::Vec::new();
704 for child in non_field_children {
705 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
706 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
707 })?);
708 }
709 items
710 },
711 })
712 }
713}
714impl ::treesitter_types::Spanned for AbstractArrayDeclarator<'_> {
715 fn span(&self) -> ::treesitter_types::Span {
716 self.span
717 }
718}
719#[derive(Debug, Clone, PartialEq, Eq)]
720pub struct AbstractFunctionDeclarator<'tree> {
721 pub span: ::treesitter_types::Span,
722 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
723 pub parameters: ParameterList<'tree>,
724}
725impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFunctionDeclarator<'tree> {
726 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
727 fn from_node(
728 node: ::treesitter_types::tree_sitter::Node<'tree>,
729 src: &'tree [u8],
730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
731 debug_assert_eq!(node.kind(), "abstract_function_declarator");
732 Ok(Self {
733 span: ::treesitter_types::Span::from(node),
734 declarator: match node.child_by_field_name("declarator") {
735 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
736 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
737 })?),
738 None => None,
739 },
740 parameters: {
741 let child = node.child_by_field_name("parameters").ok_or_else(|| {
742 ::treesitter_types::ParseError::missing_field("parameters", node)
743 })?;
744 ::treesitter_types::runtime::maybe_grow_stack(|| {
745 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
746 })?
747 },
748 })
749 }
750}
751impl ::treesitter_types::Spanned for AbstractFunctionDeclarator<'_> {
752 fn span(&self) -> ::treesitter_types::Span {
753 self.span
754 }
755}
756#[derive(Debug, Clone, PartialEq, Eq)]
757pub struct AbstractParenthesizedDeclarator<'tree> {
758 pub span: ::treesitter_types::Span,
759 pub children: ::std::vec::Vec<AbstractParenthesizedDeclaratorChildren<'tree>>,
760}
761impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclarator<'tree> {
762 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
763 fn from_node(
764 node: ::treesitter_types::tree_sitter::Node<'tree>,
765 src: &'tree [u8],
766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
767 debug_assert_eq!(node.kind(), "abstract_parenthesized_declarator");
768 Ok(Self {
769 span: ::treesitter_types::Span::from(node),
770 children: {
771 #[allow(clippy::suspicious_else_formatting)]
772 let non_field_children = {
773 let mut cursor = node.walk();
774 let mut result = ::std::vec::Vec::new();
775 if cursor.goto_first_child() {
776 loop {
777 if cursor.field_name().is_none()
778 && cursor.node().is_named()
779 && !cursor.node().is_extra()
780 {
781 result.push(cursor.node());
782 }
783 if !cursor.goto_next_sibling() {
784 break;
785 }
786 }
787 }
788 result
789 };
790 let mut items = ::std::vec::Vec::new();
791 for child in non_field_children {
792 items
793 .push(
794 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
795 child,
796 src,
797 ))?,
798 );
799 }
800 items
801 },
802 })
803 }
804}
805impl ::treesitter_types::Spanned for AbstractParenthesizedDeclarator<'_> {
806 fn span(&self) -> ::treesitter_types::Span {
807 self.span
808 }
809}
810#[derive(Debug, Clone, PartialEq, Eq)]
811pub struct AbstractPointerDeclarator<'tree> {
812 pub span: ::treesitter_types::Span,
813 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
814 pub children: ::std::vec::Vec<AbstractPointerDeclaratorChildren<'tree>>,
815}
816impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclarator<'tree> {
817 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
818 fn from_node(
819 node: ::treesitter_types::tree_sitter::Node<'tree>,
820 src: &'tree [u8],
821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
822 debug_assert_eq!(node.kind(), "abstract_pointer_declarator");
823 Ok(Self {
824 span: ::treesitter_types::Span::from(node),
825 declarator: match node.child_by_field_name("declarator") {
826 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
827 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
828 })?),
829 None => None,
830 },
831 children: {
832 #[allow(clippy::suspicious_else_formatting)]
833 let non_field_children = {
834 let mut cursor = node.walk();
835 let mut result = ::std::vec::Vec::new();
836 if cursor.goto_first_child() {
837 loop {
838 if cursor.field_name().is_none()
839 && cursor.node().is_named()
840 && !cursor.node().is_extra()
841 {
842 result.push(cursor.node());
843 }
844 if !cursor.goto_next_sibling() {
845 break;
846 }
847 }
848 }
849 result
850 };
851 let mut items = ::std::vec::Vec::new();
852 for child in non_field_children {
853 items
854 .push(
855 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractPointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
856 child,
857 src,
858 ))?,
859 );
860 }
861 items
862 },
863 })
864 }
865}
866impl ::treesitter_types::Spanned for AbstractPointerDeclarator<'_> {
867 fn span(&self) -> ::treesitter_types::Span {
868 self.span
869 }
870}
871#[derive(Debug, Clone, PartialEq, Eq)]
872pub struct AlignasQualifier<'tree> {
873 pub span: ::treesitter_types::Span,
874 pub children: AlignasQualifierChildren<'tree>,
875}
876impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifier<'tree> {
877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
878 fn from_node(
879 node: ::treesitter_types::tree_sitter::Node<'tree>,
880 src: &'tree [u8],
881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
882 debug_assert_eq!(node.kind(), "alignas_qualifier");
883 Ok(Self {
884 span: ::treesitter_types::Span::from(node),
885 children: {
886 #[allow(clippy::suspicious_else_formatting)]
887 let non_field_children = {
888 let mut cursor = node.walk();
889 let mut result = ::std::vec::Vec::new();
890 if cursor.goto_first_child() {
891 loop {
892 if cursor.field_name().is_none()
893 && cursor.node().is_named()
894 && !cursor.node().is_extra()
895 {
896 result.push(cursor.node());
897 }
898 if !cursor.goto_next_sibling() {
899 break;
900 }
901 }
902 }
903 result
904 };
905 let child = if let Some(&c) = non_field_children.first() {
906 c
907 } else {
908 let mut fallback_cursor = node.walk();
909 let mut fallback_child = None;
910 if fallback_cursor.goto_first_child() {
911 loop {
912 if fallback_cursor.field_name().is_none()
913 && !fallback_cursor.node().is_extra()
914 {
915 let candidate = fallback_cursor.node();
916 #[allow(clippy::needless_question_mark)]
917 if (|| -> ::core::result::Result<
918 _,
919 ::treesitter_types::ParseError,
920 > {
921 let child = candidate;
922 Ok(
923 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
924 child,
925 src,
926 ))?,
927 )
928 })()
929 .is_ok()
930 {
931 fallback_child = Some(candidate);
932 break;
933 }
934 }
935 if !fallback_cursor.goto_next_sibling() {
936 break;
937 }
938 }
939 }
940 if fallback_child.is_none() {
941 let mut cursor2 = node.walk();
942 if cursor2.goto_first_child() {
943 loop {
944 if cursor2.node().is_named() && !cursor2.node().is_extra() {
945 let candidate = cursor2.node();
946 #[allow(clippy::needless_question_mark)]
947 if (|| -> ::core::result::Result<
948 _,
949 ::treesitter_types::ParseError,
950 > {
951 let child = candidate;
952 Ok(
953 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
954 child,
955 src,
956 ))?,
957 )
958 })()
959 .is_ok()
960 {
961 fallback_child = Some(candidate);
962 break;
963 }
964 }
965 if !cursor2.goto_next_sibling() {
966 break;
967 }
968 }
969 }
970 }
971 fallback_child.ok_or_else(|| {
972 ::treesitter_types::ParseError::missing_field("children", node)
973 })?
974 };
975 ::treesitter_types::runtime::maybe_grow_stack(|| {
976 <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
977 child, src,
978 )
979 })?
980 },
981 })
982 }
983}
984impl ::treesitter_types::Spanned for AlignasQualifier<'_> {
985 fn span(&self) -> ::treesitter_types::Span {
986 self.span
987 }
988}
989#[derive(Debug, Clone, PartialEq, Eq)]
990pub struct AlignofExpression<'tree> {
991 pub span: ::treesitter_types::Span,
992 pub r#type: TypeDescriptor<'tree>,
993}
994impl<'tree> ::treesitter_types::FromNode<'tree> for AlignofExpression<'tree> {
995 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
996 fn from_node(
997 node: ::treesitter_types::tree_sitter::Node<'tree>,
998 src: &'tree [u8],
999 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1000 debug_assert_eq!(node.kind(), "alignof_expression");
1001 Ok(Self {
1002 span: ::treesitter_types::Span::from(node),
1003 r#type: {
1004 let child = node
1005 .child_by_field_name("type")
1006 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1007 ::treesitter_types::runtime::maybe_grow_stack(|| {
1008 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
1009 })?
1010 },
1011 })
1012 }
1013}
1014impl ::treesitter_types::Spanned for AlignofExpression<'_> {
1015 fn span(&self) -> ::treesitter_types::Span {
1016 self.span
1017 }
1018}
1019#[derive(Debug, Clone, PartialEq, Eq)]
1020pub struct ArgumentList<'tree> {
1021 pub span: ::treesitter_types::Span,
1022 pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
1023}
1024impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1025 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1026 fn from_node(
1027 node: ::treesitter_types::tree_sitter::Node<'tree>,
1028 src: &'tree [u8],
1029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1030 debug_assert_eq!(node.kind(), "argument_list");
1031 Ok(Self {
1032 span: ::treesitter_types::Span::from(node),
1033 children: {
1034 #[allow(clippy::suspicious_else_formatting)]
1035 let non_field_children = {
1036 let mut cursor = node.walk();
1037 let mut result = ::std::vec::Vec::new();
1038 if cursor.goto_first_child() {
1039 loop {
1040 if cursor.field_name().is_none()
1041 && cursor.node().is_named()
1042 && !cursor.node().is_extra()
1043 {
1044 result.push(cursor.node());
1045 }
1046 if !cursor.goto_next_sibling() {
1047 break;
1048 }
1049 }
1050 }
1051 result
1052 };
1053 let mut items = ::std::vec::Vec::new();
1054 for child in non_field_children {
1055 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1056 <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
1057 child, src,
1058 )
1059 })?);
1060 }
1061 items
1062 },
1063 })
1064 }
1065}
1066impl ::treesitter_types::Spanned for ArgumentList<'_> {
1067 fn span(&self) -> ::treesitter_types::Span {
1068 self.span
1069 }
1070}
1071#[derive(Debug, Clone, PartialEq, Eq)]
1072pub struct ArrayDeclarator<'tree> {
1073 pub span: ::treesitter_types::Span,
1074 pub declarator: ArrayDeclaratorDeclarator<'tree>,
1075 pub size: ::core::option::Option<ArrayDeclaratorSize<'tree>>,
1076 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
1077}
1078impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclarator<'tree> {
1079 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1080 fn from_node(
1081 node: ::treesitter_types::tree_sitter::Node<'tree>,
1082 src: &'tree [u8],
1083 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1084 debug_assert_eq!(node.kind(), "array_declarator");
1085 Ok(Self {
1086 span: ::treesitter_types::Span::from(node),
1087 declarator: {
1088 let child = node.child_by_field_name("declarator").ok_or_else(|| {
1089 ::treesitter_types::ParseError::missing_field("declarator", node)
1090 })?;
1091 ::treesitter_types::runtime::maybe_grow_stack(|| {
1092 <ArrayDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
1093 child, src,
1094 )
1095 })?
1096 },
1097 size: match node.child_by_field_name("size") {
1098 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1099 <ArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(child, src)
1100 })?),
1101 None => None,
1102 },
1103 children: {
1104 #[allow(clippy::suspicious_else_formatting)]
1105 let non_field_children = {
1106 let mut cursor = node.walk();
1107 let mut result = ::std::vec::Vec::new();
1108 if cursor.goto_first_child() {
1109 loop {
1110 if cursor.field_name().is_none()
1111 && cursor.node().is_named()
1112 && !cursor.node().is_extra()
1113 {
1114 result.push(cursor.node());
1115 }
1116 if !cursor.goto_next_sibling() {
1117 break;
1118 }
1119 }
1120 }
1121 result
1122 };
1123 let mut items = ::std::vec::Vec::new();
1124 for child in non_field_children {
1125 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1126 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
1127 })?);
1128 }
1129 items
1130 },
1131 })
1132 }
1133}
1134impl ::treesitter_types::Spanned for ArrayDeclarator<'_> {
1135 fn span(&self) -> ::treesitter_types::Span {
1136 self.span
1137 }
1138}
1139#[derive(Debug, Clone, PartialEq, Eq)]
1140pub struct AssignmentExpression<'tree> {
1141 pub span: ::treesitter_types::Span,
1142 pub left: AssignmentExpressionLeft<'tree>,
1143 pub operator: AssignmentExpressionOperator,
1144 pub right: Expression<'tree>,
1145}
1146impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1147 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1148 fn from_node(
1149 node: ::treesitter_types::tree_sitter::Node<'tree>,
1150 src: &'tree [u8],
1151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1152 debug_assert_eq!(node.kind(), "assignment_expression");
1153 Ok(Self {
1154 span: ::treesitter_types::Span::from(node),
1155 left: {
1156 let child = node
1157 .child_by_field_name("left")
1158 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1159 ::treesitter_types::runtime::maybe_grow_stack(|| {
1160 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1161 child, src,
1162 )
1163 })?
1164 },
1165 operator: {
1166 let child = node.child_by_field_name("operator").ok_or_else(|| {
1167 ::treesitter_types::ParseError::missing_field("operator", node)
1168 })?;
1169 ::treesitter_types::runtime::maybe_grow_stack(|| {
1170 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1171 child, src,
1172 )
1173 })?
1174 },
1175 right: {
1176 let child = node
1177 .child_by_field_name("right")
1178 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1179 ::treesitter_types::runtime::maybe_grow_stack(|| {
1180 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1181 })?
1182 },
1183 })
1184 }
1185}
1186impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1187 fn span(&self) -> ::treesitter_types::Span {
1188 self.span
1189 }
1190}
1191#[derive(Debug, Clone, PartialEq, Eq)]
1192pub struct Attribute<'tree> {
1193 pub span: ::treesitter_types::Span,
1194 pub name: Identifier<'tree>,
1195 pub prefix: ::core::option::Option<Identifier<'tree>>,
1196 pub children: ::core::option::Option<ArgumentList<'tree>>,
1197}
1198impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1199 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1200 fn from_node(
1201 node: ::treesitter_types::tree_sitter::Node<'tree>,
1202 src: &'tree [u8],
1203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1204 debug_assert_eq!(node.kind(), "attribute");
1205 Ok(Self {
1206 span: ::treesitter_types::Span::from(node),
1207 name: {
1208 let child = node
1209 .child_by_field_name("name")
1210 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1211 ::treesitter_types::runtime::maybe_grow_stack(|| {
1212 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1213 })?
1214 },
1215 prefix: match node.child_by_field_name("prefix") {
1216 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1217 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1218 })?),
1219 None => None,
1220 },
1221 children: {
1222 #[allow(clippy::suspicious_else_formatting)]
1223 let non_field_children = {
1224 let mut cursor = node.walk();
1225 let mut result = ::std::vec::Vec::new();
1226 if cursor.goto_first_child() {
1227 loop {
1228 if cursor.field_name().is_none()
1229 && cursor.node().is_named()
1230 && !cursor.node().is_extra()
1231 {
1232 result.push(cursor.node());
1233 }
1234 if !cursor.goto_next_sibling() {
1235 break;
1236 }
1237 }
1238 }
1239 result
1240 };
1241 match non_field_children.first() {
1242 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1243 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
1244 })?),
1245 None => None,
1246 }
1247 },
1248 })
1249 }
1250}
1251impl ::treesitter_types::Spanned for Attribute<'_> {
1252 fn span(&self) -> ::treesitter_types::Span {
1253 self.span
1254 }
1255}
1256#[derive(Debug, Clone, PartialEq, Eq)]
1257pub struct AttributeDeclaration<'tree> {
1258 pub span: ::treesitter_types::Span,
1259 pub children: ::std::vec::Vec<Attribute<'tree>>,
1260}
1261impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeDeclaration<'tree> {
1262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1263 fn from_node(
1264 node: ::treesitter_types::tree_sitter::Node<'tree>,
1265 src: &'tree [u8],
1266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1267 debug_assert_eq!(node.kind(), "attribute_declaration");
1268 Ok(Self {
1269 span: ::treesitter_types::Span::from(node),
1270 children: {
1271 #[allow(clippy::suspicious_else_formatting)]
1272 let non_field_children = {
1273 let mut cursor = node.walk();
1274 let mut result = ::std::vec::Vec::new();
1275 if cursor.goto_first_child() {
1276 loop {
1277 if cursor.field_name().is_none()
1278 && cursor.node().is_named()
1279 && !cursor.node().is_extra()
1280 {
1281 result.push(cursor.node());
1282 }
1283 if !cursor.goto_next_sibling() {
1284 break;
1285 }
1286 }
1287 }
1288 result
1289 };
1290 let mut items = ::std::vec::Vec::new();
1291 for child in non_field_children {
1292 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1293 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
1294 })?);
1295 }
1296 items
1297 },
1298 })
1299 }
1300}
1301impl ::treesitter_types::Spanned for AttributeDeclaration<'_> {
1302 fn span(&self) -> ::treesitter_types::Span {
1303 self.span
1304 }
1305}
1306#[derive(Debug, Clone, PartialEq, Eq)]
1307pub struct AttributeSpecifier<'tree> {
1308 pub span: ::treesitter_types::Span,
1309 pub children: ArgumentList<'tree>,
1310}
1311impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeSpecifier<'tree> {
1312 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1313 fn from_node(
1314 node: ::treesitter_types::tree_sitter::Node<'tree>,
1315 src: &'tree [u8],
1316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1317 debug_assert_eq!(node.kind(), "attribute_specifier");
1318 Ok(Self {
1319 span: ::treesitter_types::Span::from(node),
1320 children: {
1321 #[allow(clippy::suspicious_else_formatting)]
1322 let non_field_children = {
1323 let mut cursor = node.walk();
1324 let mut result = ::std::vec::Vec::new();
1325 if cursor.goto_first_child() {
1326 loop {
1327 if cursor.field_name().is_none()
1328 && cursor.node().is_named()
1329 && !cursor.node().is_extra()
1330 {
1331 result.push(cursor.node());
1332 }
1333 if !cursor.goto_next_sibling() {
1334 break;
1335 }
1336 }
1337 }
1338 result
1339 };
1340 let child = if let Some(&c) = non_field_children.first() {
1341 c
1342 } else {
1343 let mut fallback_cursor = node.walk();
1344 let mut fallback_child = None;
1345 if fallback_cursor.goto_first_child() {
1346 loop {
1347 if fallback_cursor.field_name().is_none()
1348 && !fallback_cursor.node().is_extra()
1349 {
1350 let candidate = fallback_cursor.node();
1351 #[allow(clippy::needless_question_mark)]
1352 if (|| -> ::core::result::Result<
1353 _,
1354 ::treesitter_types::ParseError,
1355 > {
1356 let child = candidate;
1357 Ok(
1358 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
1359 child,
1360 src,
1361 ))?,
1362 )
1363 })()
1364 .is_ok()
1365 {
1366 fallback_child = Some(candidate);
1367 break;
1368 }
1369 }
1370 if !fallback_cursor.goto_next_sibling() {
1371 break;
1372 }
1373 }
1374 }
1375 if fallback_child.is_none() {
1376 let mut cursor2 = node.walk();
1377 if cursor2.goto_first_child() {
1378 loop {
1379 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1380 let candidate = cursor2.node();
1381 #[allow(clippy::needless_question_mark)]
1382 if (|| -> ::core::result::Result<
1383 _,
1384 ::treesitter_types::ParseError,
1385 > {
1386 let child = candidate;
1387 Ok(
1388 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
1389 child,
1390 src,
1391 ))?,
1392 )
1393 })()
1394 .is_ok()
1395 {
1396 fallback_child = Some(candidate);
1397 break;
1398 }
1399 }
1400 if !cursor2.goto_next_sibling() {
1401 break;
1402 }
1403 }
1404 }
1405 }
1406 fallback_child.ok_or_else(|| {
1407 ::treesitter_types::ParseError::missing_field("children", node)
1408 })?
1409 };
1410 ::treesitter_types::runtime::maybe_grow_stack(|| {
1411 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
1412 })?
1413 },
1414 })
1415 }
1416}
1417impl ::treesitter_types::Spanned for AttributeSpecifier<'_> {
1418 fn span(&self) -> ::treesitter_types::Span {
1419 self.span
1420 }
1421}
1422#[derive(Debug, Clone, PartialEq, Eq)]
1423pub struct AttributedDeclarator<'tree> {
1424 pub span: ::treesitter_types::Span,
1425 pub children: ::std::vec::Vec<AttributedDeclaratorChildren<'tree>>,
1426}
1427impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclarator<'tree> {
1428 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1429 fn from_node(
1430 node: ::treesitter_types::tree_sitter::Node<'tree>,
1431 src: &'tree [u8],
1432 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1433 debug_assert_eq!(node.kind(), "attributed_declarator");
1434 Ok(Self {
1435 span: ::treesitter_types::Span::from(node),
1436 children: {
1437 #[allow(clippy::suspicious_else_formatting)]
1438 let non_field_children = {
1439 let mut cursor = node.walk();
1440 let mut result = ::std::vec::Vec::new();
1441 if cursor.goto_first_child() {
1442 loop {
1443 if cursor.field_name().is_none()
1444 && cursor.node().is_named()
1445 && !cursor.node().is_extra()
1446 {
1447 result.push(cursor.node());
1448 }
1449 if !cursor.goto_next_sibling() {
1450 break;
1451 }
1452 }
1453 }
1454 result
1455 };
1456 let mut items = ::std::vec::Vec::new();
1457 for child in non_field_children {
1458 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1459 <AttributedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1460 child, src,
1461 )
1462 })?);
1463 }
1464 items
1465 },
1466 })
1467 }
1468}
1469impl ::treesitter_types::Spanned for AttributedDeclarator<'_> {
1470 fn span(&self) -> ::treesitter_types::Span {
1471 self.span
1472 }
1473}
1474#[derive(Debug, Clone, PartialEq, Eq)]
1475pub struct AttributedStatement<'tree> {
1476 pub span: ::treesitter_types::Span,
1477 pub children: ::std::vec::Vec<AttributedStatementChildren<'tree>>,
1478}
1479impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatement<'tree> {
1480 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1481 fn from_node(
1482 node: ::treesitter_types::tree_sitter::Node<'tree>,
1483 src: &'tree [u8],
1484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1485 debug_assert_eq!(node.kind(), "attributed_statement");
1486 Ok(Self {
1487 span: ::treesitter_types::Span::from(node),
1488 children: {
1489 #[allow(clippy::suspicious_else_formatting)]
1490 let non_field_children = {
1491 let mut cursor = node.walk();
1492 let mut result = ::std::vec::Vec::new();
1493 if cursor.goto_first_child() {
1494 loop {
1495 if cursor.field_name().is_none()
1496 && cursor.node().is_named()
1497 && !cursor.node().is_extra()
1498 {
1499 result.push(cursor.node());
1500 }
1501 if !cursor.goto_next_sibling() {
1502 break;
1503 }
1504 }
1505 }
1506 result
1507 };
1508 let mut items = ::std::vec::Vec::new();
1509 for child in non_field_children {
1510 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1511 <AttributedStatementChildren as ::treesitter_types::FromNode>::from_node(
1512 child, src,
1513 )
1514 })?);
1515 }
1516 items
1517 },
1518 })
1519 }
1520}
1521impl ::treesitter_types::Spanned for AttributedStatement<'_> {
1522 fn span(&self) -> ::treesitter_types::Span {
1523 self.span
1524 }
1525}
1526#[derive(Debug, Clone, PartialEq, Eq)]
1527pub struct BinaryExpression<'tree> {
1528 pub span: ::treesitter_types::Span,
1529 pub left: BinaryExpressionLeft<'tree>,
1530 pub operator: BinaryExpressionOperator,
1531 pub right: BinaryExpressionRight<'tree>,
1532}
1533impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1534 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1535 fn from_node(
1536 node: ::treesitter_types::tree_sitter::Node<'tree>,
1537 src: &'tree [u8],
1538 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1539 debug_assert_eq!(node.kind(), "binary_expression");
1540 Ok(Self {
1541 span: ::treesitter_types::Span::from(node),
1542 left: {
1543 let child = node
1544 .child_by_field_name("left")
1545 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1546 ::treesitter_types::runtime::maybe_grow_stack(|| {
1547 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
1548 })?
1549 },
1550 operator: {
1551 let child = node.child_by_field_name("operator").ok_or_else(|| {
1552 ::treesitter_types::ParseError::missing_field("operator", node)
1553 })?;
1554 ::treesitter_types::runtime::maybe_grow_stack(|| {
1555 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
1556 child, src,
1557 )
1558 })?
1559 },
1560 right: {
1561 let child = node
1562 .child_by_field_name("right")
1563 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1564 ::treesitter_types::runtime::maybe_grow_stack(|| {
1565 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
1566 })?
1567 },
1568 })
1569 }
1570}
1571impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1572 fn span(&self) -> ::treesitter_types::Span {
1573 self.span
1574 }
1575}
1576#[derive(Debug, Clone, PartialEq, Eq)]
1577pub struct BitfieldClause<'tree> {
1578 pub span: ::treesitter_types::Span,
1579 pub children: Expression<'tree>,
1580}
1581impl<'tree> ::treesitter_types::FromNode<'tree> for BitfieldClause<'tree> {
1582 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1583 fn from_node(
1584 node: ::treesitter_types::tree_sitter::Node<'tree>,
1585 src: &'tree [u8],
1586 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1587 debug_assert_eq!(node.kind(), "bitfield_clause");
1588 Ok(Self {
1589 span: ::treesitter_types::Span::from(node),
1590 children: {
1591 #[allow(clippy::suspicious_else_formatting)]
1592 let non_field_children = {
1593 let mut cursor = node.walk();
1594 let mut result = ::std::vec::Vec::new();
1595 if cursor.goto_first_child() {
1596 loop {
1597 if cursor.field_name().is_none()
1598 && cursor.node().is_named()
1599 && !cursor.node().is_extra()
1600 {
1601 result.push(cursor.node());
1602 }
1603 if !cursor.goto_next_sibling() {
1604 break;
1605 }
1606 }
1607 }
1608 result
1609 };
1610 let child = if let Some(&c) = non_field_children.first() {
1611 c
1612 } else {
1613 let mut fallback_cursor = node.walk();
1614 let mut fallback_child = None;
1615 if fallback_cursor.goto_first_child() {
1616 loop {
1617 if fallback_cursor.field_name().is_none()
1618 && !fallback_cursor.node().is_extra()
1619 {
1620 let candidate = fallback_cursor.node();
1621 #[allow(clippy::needless_question_mark)]
1622 if (|| -> ::core::result::Result<
1623 _,
1624 ::treesitter_types::ParseError,
1625 > {
1626 let child = candidate;
1627 Ok(
1628 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1629 child,
1630 src,
1631 ))?,
1632 )
1633 })()
1634 .is_ok()
1635 {
1636 fallback_child = Some(candidate);
1637 break;
1638 }
1639 }
1640 if !fallback_cursor.goto_next_sibling() {
1641 break;
1642 }
1643 }
1644 }
1645 if fallback_child.is_none() {
1646 let mut cursor2 = node.walk();
1647 if cursor2.goto_first_child() {
1648 loop {
1649 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1650 let candidate = cursor2.node();
1651 #[allow(clippy::needless_question_mark)]
1652 if (|| -> ::core::result::Result<
1653 _,
1654 ::treesitter_types::ParseError,
1655 > {
1656 let child = candidate;
1657 Ok(
1658 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
1659 child,
1660 src,
1661 ))?,
1662 )
1663 })()
1664 .is_ok()
1665 {
1666 fallback_child = Some(candidate);
1667 break;
1668 }
1669 }
1670 if !cursor2.goto_next_sibling() {
1671 break;
1672 }
1673 }
1674 }
1675 }
1676 fallback_child.ok_or_else(|| {
1677 ::treesitter_types::ParseError::missing_field("children", node)
1678 })?
1679 };
1680 ::treesitter_types::runtime::maybe_grow_stack(|| {
1681 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1682 })?
1683 },
1684 })
1685 }
1686}
1687impl ::treesitter_types::Spanned for BitfieldClause<'_> {
1688 fn span(&self) -> ::treesitter_types::Span {
1689 self.span
1690 }
1691}
1692#[derive(Debug, Clone, PartialEq, Eq)]
1693pub struct BreakStatement<'tree> {
1694 pub span: ::treesitter_types::Span,
1695 text: &'tree str,
1696}
1697impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1698 fn from_node(
1699 node: ::treesitter_types::tree_sitter::Node<'tree>,
1700 src: &'tree [u8],
1701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1702 debug_assert_eq!(node.kind(), "break_statement");
1703 Ok(Self {
1704 span: ::treesitter_types::Span::from(node),
1705 text: node.utf8_text(src)?,
1706 })
1707 }
1708}
1709impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
1710 fn text(&self) -> &'tree str {
1711 self.text
1712 }
1713}
1714impl ::treesitter_types::Spanned for BreakStatement<'_> {
1715 fn span(&self) -> ::treesitter_types::Span {
1716 self.span
1717 }
1718}
1719#[derive(Debug, Clone, PartialEq, Eq)]
1720pub struct CallExpression<'tree> {
1721 pub span: ::treesitter_types::Span,
1722 pub arguments: ArgumentList<'tree>,
1723 pub function: Expression<'tree>,
1724}
1725impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1726 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1727 fn from_node(
1728 node: ::treesitter_types::tree_sitter::Node<'tree>,
1729 src: &'tree [u8],
1730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1731 debug_assert_eq!(node.kind(), "call_expression");
1732 Ok(Self {
1733 span: ::treesitter_types::Span::from(node),
1734 arguments: {
1735 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1736 ::treesitter_types::ParseError::missing_field("arguments", node)
1737 })?;
1738 ::treesitter_types::runtime::maybe_grow_stack(|| {
1739 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
1740 })?
1741 },
1742 function: {
1743 let child = node.child_by_field_name("function").ok_or_else(|| {
1744 ::treesitter_types::ParseError::missing_field("function", node)
1745 })?;
1746 ::treesitter_types::runtime::maybe_grow_stack(|| {
1747 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1748 })?
1749 },
1750 })
1751 }
1752}
1753impl ::treesitter_types::Spanned for CallExpression<'_> {
1754 fn span(&self) -> ::treesitter_types::Span {
1755 self.span
1756 }
1757}
1758#[derive(Debug, Clone, PartialEq, Eq)]
1759pub struct CaseStatement<'tree> {
1760 pub span: ::treesitter_types::Span,
1761 pub value: ::core::option::Option<Expression<'tree>>,
1762 pub children: ::std::vec::Vec<CaseStatementChildren<'tree>>,
1763}
1764impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatement<'tree> {
1765 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1766 fn from_node(
1767 node: ::treesitter_types::tree_sitter::Node<'tree>,
1768 src: &'tree [u8],
1769 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1770 debug_assert_eq!(node.kind(), "case_statement");
1771 Ok(Self {
1772 span: ::treesitter_types::Span::from(node),
1773 value: match node.child_by_field_name("value") {
1774 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1775 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1776 })?),
1777 None => None,
1778 },
1779 children: {
1780 #[allow(clippy::suspicious_else_formatting)]
1781 let non_field_children = {
1782 let mut cursor = node.walk();
1783 let mut result = ::std::vec::Vec::new();
1784 if cursor.goto_first_child() {
1785 loop {
1786 if cursor.field_name().is_none()
1787 && cursor.node().is_named()
1788 && !cursor.node().is_extra()
1789 {
1790 result.push(cursor.node());
1791 }
1792 if !cursor.goto_next_sibling() {
1793 break;
1794 }
1795 }
1796 }
1797 result
1798 };
1799 let mut items = ::std::vec::Vec::new();
1800 for child in non_field_children {
1801 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1802 <CaseStatementChildren as ::treesitter_types::FromNode>::from_node(
1803 child, src,
1804 )
1805 })?);
1806 }
1807 items
1808 },
1809 })
1810 }
1811}
1812impl ::treesitter_types::Spanned for CaseStatement<'_> {
1813 fn span(&self) -> ::treesitter_types::Span {
1814 self.span
1815 }
1816}
1817#[derive(Debug, Clone, PartialEq, Eq)]
1818pub struct CastExpression<'tree> {
1819 pub span: ::treesitter_types::Span,
1820 pub r#type: TypeDescriptor<'tree>,
1821 pub value: Expression<'tree>,
1822}
1823impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
1824 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1825 fn from_node(
1826 node: ::treesitter_types::tree_sitter::Node<'tree>,
1827 src: &'tree [u8],
1828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1829 debug_assert_eq!(node.kind(), "cast_expression");
1830 Ok(Self {
1831 span: ::treesitter_types::Span::from(node),
1832 r#type: {
1833 let child = node
1834 .child_by_field_name("type")
1835 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1836 ::treesitter_types::runtime::maybe_grow_stack(|| {
1837 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
1838 })?
1839 },
1840 value: {
1841 let child = node
1842 .child_by_field_name("value")
1843 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1844 ::treesitter_types::runtime::maybe_grow_stack(|| {
1845 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1846 })?
1847 },
1848 })
1849 }
1850}
1851impl ::treesitter_types::Spanned for CastExpression<'_> {
1852 fn span(&self) -> ::treesitter_types::Span {
1853 self.span
1854 }
1855}
1856#[derive(Debug, Clone, PartialEq, Eq)]
1857pub struct CharLiteral<'tree> {
1858 pub span: ::treesitter_types::Span,
1859 pub children: ::std::vec::Vec<CharLiteralChildren<'tree>>,
1860}
1861impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
1862 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1863 fn from_node(
1864 node: ::treesitter_types::tree_sitter::Node<'tree>,
1865 src: &'tree [u8],
1866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1867 debug_assert_eq!(node.kind(), "char_literal");
1868 Ok(Self {
1869 span: ::treesitter_types::Span::from(node),
1870 children: {
1871 #[allow(clippy::suspicious_else_formatting)]
1872 let non_field_children = {
1873 let mut cursor = node.walk();
1874 let mut result = ::std::vec::Vec::new();
1875 if cursor.goto_first_child() {
1876 loop {
1877 if cursor.field_name().is_none()
1878 && cursor.node().is_named()
1879 && !cursor.node().is_extra()
1880 {
1881 result.push(cursor.node());
1882 }
1883 if !cursor.goto_next_sibling() {
1884 break;
1885 }
1886 }
1887 }
1888 result
1889 };
1890 let mut items = ::std::vec::Vec::new();
1891 for child in non_field_children {
1892 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1893 <CharLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)
1894 })?);
1895 }
1896 items
1897 },
1898 })
1899 }
1900}
1901impl ::treesitter_types::Spanned for CharLiteral<'_> {
1902 fn span(&self) -> ::treesitter_types::Span {
1903 self.span
1904 }
1905}
1906#[derive(Debug, Clone, PartialEq, Eq)]
1907pub struct CommaExpression<'tree> {
1908 pub span: ::treesitter_types::Span,
1909 pub left: Expression<'tree>,
1910 pub right: CommaExpressionRight<'tree>,
1911}
1912impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpression<'tree> {
1913 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1914 fn from_node(
1915 node: ::treesitter_types::tree_sitter::Node<'tree>,
1916 src: &'tree [u8],
1917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1918 debug_assert_eq!(node.kind(), "comma_expression");
1919 Ok(Self {
1920 span: ::treesitter_types::Span::from(node),
1921 left: {
1922 let child = node
1923 .child_by_field_name("left")
1924 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1925 ::treesitter_types::runtime::maybe_grow_stack(|| {
1926 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1927 })?
1928 },
1929 right: {
1930 let child = node
1931 .child_by_field_name("right")
1932 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1933 ::treesitter_types::runtime::maybe_grow_stack(|| {
1934 <CommaExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
1935 })?
1936 },
1937 })
1938 }
1939}
1940impl ::treesitter_types::Spanned for CommaExpression<'_> {
1941 fn span(&self) -> ::treesitter_types::Span {
1942 self.span
1943 }
1944}
1945#[derive(Debug, Clone, PartialEq, Eq)]
1946pub struct CompoundLiteralExpression<'tree> {
1947 pub span: ::treesitter_types::Span,
1948 pub r#type: TypeDescriptor<'tree>,
1949 pub value: InitializerList<'tree>,
1950}
1951impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundLiteralExpression<'tree> {
1952 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1953 fn from_node(
1954 node: ::treesitter_types::tree_sitter::Node<'tree>,
1955 src: &'tree [u8],
1956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1957 debug_assert_eq!(node.kind(), "compound_literal_expression");
1958 Ok(Self {
1959 span: ::treesitter_types::Span::from(node),
1960 r#type: {
1961 let child = node
1962 .child_by_field_name("type")
1963 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1964 ::treesitter_types::runtime::maybe_grow_stack(|| {
1965 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
1966 })?
1967 },
1968 value: {
1969 let child = node
1970 .child_by_field_name("value")
1971 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1972 ::treesitter_types::runtime::maybe_grow_stack(|| {
1973 <InitializerList as ::treesitter_types::FromNode>::from_node(child, src)
1974 })?
1975 },
1976 })
1977 }
1978}
1979impl ::treesitter_types::Spanned for CompoundLiteralExpression<'_> {
1980 fn span(&self) -> ::treesitter_types::Span {
1981 self.span
1982 }
1983}
1984#[derive(Debug, Clone, PartialEq, Eq)]
1985pub struct CompoundStatement<'tree> {
1986 pub span: ::treesitter_types::Span,
1987 pub children: ::std::vec::Vec<CompoundStatementChildren<'tree>>,
1988}
1989impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatement<'tree> {
1990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1991 fn from_node(
1992 node: ::treesitter_types::tree_sitter::Node<'tree>,
1993 src: &'tree [u8],
1994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1995 debug_assert_eq!(node.kind(), "compound_statement");
1996 Ok(Self {
1997 span: ::treesitter_types::Span::from(node),
1998 children: {
1999 #[allow(clippy::suspicious_else_formatting)]
2000 let non_field_children = {
2001 let mut cursor = node.walk();
2002 let mut result = ::std::vec::Vec::new();
2003 if cursor.goto_first_child() {
2004 loop {
2005 if cursor.field_name().is_none()
2006 && cursor.node().is_named()
2007 && !cursor.node().is_extra()
2008 {
2009 result.push(cursor.node());
2010 }
2011 if !cursor.goto_next_sibling() {
2012 break;
2013 }
2014 }
2015 }
2016 result
2017 };
2018 let mut items = ::std::vec::Vec::new();
2019 for child in non_field_children {
2020 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2021 <CompoundStatementChildren as ::treesitter_types::FromNode>::from_node(
2022 child, src,
2023 )
2024 })?);
2025 }
2026 items
2027 },
2028 })
2029 }
2030}
2031impl ::treesitter_types::Spanned for CompoundStatement<'_> {
2032 fn span(&self) -> ::treesitter_types::Span {
2033 self.span
2034 }
2035}
2036#[derive(Debug, Clone, PartialEq, Eq)]
2037pub struct ConcatenatedString<'tree> {
2038 pub span: ::treesitter_types::Span,
2039 pub children: ::std::vec::Vec<ConcatenatedStringChildren<'tree>>,
2040}
2041impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedString<'tree> {
2042 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2043 fn from_node(
2044 node: ::treesitter_types::tree_sitter::Node<'tree>,
2045 src: &'tree [u8],
2046 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2047 debug_assert_eq!(node.kind(), "concatenated_string");
2048 Ok(Self {
2049 span: ::treesitter_types::Span::from(node),
2050 children: {
2051 #[allow(clippy::suspicious_else_formatting)]
2052 let non_field_children = {
2053 let mut cursor = node.walk();
2054 let mut result = ::std::vec::Vec::new();
2055 if cursor.goto_first_child() {
2056 loop {
2057 if cursor.field_name().is_none()
2058 && cursor.node().is_named()
2059 && !cursor.node().is_extra()
2060 {
2061 result.push(cursor.node());
2062 }
2063 if !cursor.goto_next_sibling() {
2064 break;
2065 }
2066 }
2067 }
2068 result
2069 };
2070 let mut items = ::std::vec::Vec::new();
2071 for child in non_field_children {
2072 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2073 <ConcatenatedStringChildren as ::treesitter_types::FromNode>::from_node(
2074 child, src,
2075 )
2076 })?);
2077 }
2078 items
2079 },
2080 })
2081 }
2082}
2083impl ::treesitter_types::Spanned for ConcatenatedString<'_> {
2084 fn span(&self) -> ::treesitter_types::Span {
2085 self.span
2086 }
2087}
2088#[derive(Debug, Clone, PartialEq, Eq)]
2089pub struct ConditionalExpression<'tree> {
2090 pub span: ::treesitter_types::Span,
2091 pub alternative: Expression<'tree>,
2092 pub condition: Expression<'tree>,
2093 pub consequence: ::core::option::Option<ConditionalExpressionConsequence<'tree>>,
2094}
2095impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
2096 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2097 fn from_node(
2098 node: ::treesitter_types::tree_sitter::Node<'tree>,
2099 src: &'tree [u8],
2100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2101 debug_assert_eq!(node.kind(), "conditional_expression");
2102 Ok(Self {
2103 span: ::treesitter_types::Span::from(node),
2104 alternative: {
2105 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2106 ::treesitter_types::ParseError::missing_field("alternative", node)
2107 })?;
2108 ::treesitter_types::runtime::maybe_grow_stack(|| {
2109 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2110 })?
2111 },
2112 condition: {
2113 let child = node.child_by_field_name("condition").ok_or_else(|| {
2114 ::treesitter_types::ParseError::missing_field("condition", node)
2115 })?;
2116 ::treesitter_types::runtime::maybe_grow_stack(|| {
2117 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2118 })?
2119 },
2120 consequence: match node.child_by_field_name("consequence") {
2121 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2122 <ConditionalExpressionConsequence as ::treesitter_types::FromNode>::from_node(
2123 child, src,
2124 )
2125 })?),
2126 None => None,
2127 },
2128 })
2129 }
2130}
2131impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
2132 fn span(&self) -> ::treesitter_types::Span {
2133 self.span
2134 }
2135}
2136#[derive(Debug, Clone, PartialEq, Eq)]
2137pub struct ContinueStatement<'tree> {
2138 pub span: ::treesitter_types::Span,
2139 text: &'tree str,
2140}
2141impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2142 fn from_node(
2143 node: ::treesitter_types::tree_sitter::Node<'tree>,
2144 src: &'tree [u8],
2145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2146 debug_assert_eq!(node.kind(), "continue_statement");
2147 Ok(Self {
2148 span: ::treesitter_types::Span::from(node),
2149 text: node.utf8_text(src)?,
2150 })
2151 }
2152}
2153impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
2154 fn text(&self) -> &'tree str {
2155 self.text
2156 }
2157}
2158impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2159 fn span(&self) -> ::treesitter_types::Span {
2160 self.span
2161 }
2162}
2163#[derive(Debug, Clone, PartialEq, Eq)]
2164pub struct Declaration<'tree> {
2165 pub span: ::treesitter_types::Span,
2166 pub declarator: ::std::vec::Vec<DeclarationDeclarator<'tree>>,
2167 pub r#type: TypeSpecifier<'tree>,
2168 pub children: ::std::vec::Vec<DeclarationChildren<'tree>>,
2169}
2170impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
2171 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2172 fn from_node(
2173 node: ::treesitter_types::tree_sitter::Node<'tree>,
2174 src: &'tree [u8],
2175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2176 debug_assert_eq!(node.kind(), "declaration");
2177 Ok(Self {
2178 span: ::treesitter_types::Span::from(node),
2179 declarator: {
2180 let mut cursor = node.walk();
2181 let mut items = ::std::vec::Vec::new();
2182 for child in node.children_by_field_name("declarator", &mut cursor) {
2183 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2184 <DeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
2185 child, src,
2186 )
2187 })?);
2188 }
2189 items
2190 },
2191 r#type: {
2192 let child = node
2193 .child_by_field_name("type")
2194 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2195 ::treesitter_types::runtime::maybe_grow_stack(|| {
2196 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
2197 })?
2198 },
2199 children: {
2200 #[allow(clippy::suspicious_else_formatting)]
2201 let non_field_children = {
2202 let mut cursor = node.walk();
2203 let mut result = ::std::vec::Vec::new();
2204 if cursor.goto_first_child() {
2205 loop {
2206 if cursor.field_name().is_none()
2207 && cursor.node().is_named()
2208 && !cursor.node().is_extra()
2209 {
2210 result.push(cursor.node());
2211 }
2212 if !cursor.goto_next_sibling() {
2213 break;
2214 }
2215 }
2216 }
2217 result
2218 };
2219 let mut items = ::std::vec::Vec::new();
2220 for child in non_field_children {
2221 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2222 <DeclarationChildren as ::treesitter_types::FromNode>::from_node(child, src)
2223 })?);
2224 }
2225 items
2226 },
2227 })
2228 }
2229}
2230impl ::treesitter_types::Spanned for Declaration<'_> {
2231 fn span(&self) -> ::treesitter_types::Span {
2232 self.span
2233 }
2234}
2235#[derive(Debug, Clone, PartialEq, Eq)]
2236pub struct DeclarationList<'tree> {
2237 pub span: ::treesitter_types::Span,
2238 pub children: ::std::vec::Vec<DeclarationListChildren<'tree>>,
2239}
2240impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2241 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2242 fn from_node(
2243 node: ::treesitter_types::tree_sitter::Node<'tree>,
2244 src: &'tree [u8],
2245 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2246 debug_assert_eq!(node.kind(), "declaration_list");
2247 Ok(Self {
2248 span: ::treesitter_types::Span::from(node),
2249 children: {
2250 #[allow(clippy::suspicious_else_formatting)]
2251 let non_field_children = {
2252 let mut cursor = node.walk();
2253 let mut result = ::std::vec::Vec::new();
2254 if cursor.goto_first_child() {
2255 loop {
2256 if cursor.field_name().is_none()
2257 && cursor.node().is_named()
2258 && !cursor.node().is_extra()
2259 {
2260 result.push(cursor.node());
2261 }
2262 if !cursor.goto_next_sibling() {
2263 break;
2264 }
2265 }
2266 }
2267 result
2268 };
2269 let mut items = ::std::vec::Vec::new();
2270 for child in non_field_children {
2271 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2272 <DeclarationListChildren as ::treesitter_types::FromNode>::from_node(
2273 child, src,
2274 )
2275 })?);
2276 }
2277 items
2278 },
2279 })
2280 }
2281}
2282impl ::treesitter_types::Spanned for DeclarationList<'_> {
2283 fn span(&self) -> ::treesitter_types::Span {
2284 self.span
2285 }
2286}
2287#[derive(Debug, Clone, PartialEq, Eq)]
2288pub struct DoStatement<'tree> {
2289 pub span: ::treesitter_types::Span,
2290 pub body: Statement<'tree>,
2291 pub condition: ParenthesizedExpression<'tree>,
2292}
2293impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2294 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2295 fn from_node(
2296 node: ::treesitter_types::tree_sitter::Node<'tree>,
2297 src: &'tree [u8],
2298 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2299 debug_assert_eq!(node.kind(), "do_statement");
2300 Ok(Self {
2301 span: ::treesitter_types::Span::from(node),
2302 body: {
2303 let child = node
2304 .child_by_field_name("body")
2305 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2306 ::treesitter_types::runtime::maybe_grow_stack(|| {
2307 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2308 })?
2309 },
2310 condition: {
2311 let child = node.child_by_field_name("condition").ok_or_else(|| {
2312 ::treesitter_types::ParseError::missing_field("condition", node)
2313 })?;
2314 ::treesitter_types::runtime::maybe_grow_stack(|| {
2315 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
2316 })?
2317 },
2318 })
2319 }
2320}
2321impl ::treesitter_types::Spanned for DoStatement<'_> {
2322 fn span(&self) -> ::treesitter_types::Span {
2323 self.span
2324 }
2325}
2326#[derive(Debug, Clone, PartialEq, Eq)]
2327pub struct ElseClause<'tree> {
2328 pub span: ::treesitter_types::Span,
2329 pub children: Statement<'tree>,
2330}
2331impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
2332 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2333 fn from_node(
2334 node: ::treesitter_types::tree_sitter::Node<'tree>,
2335 src: &'tree [u8],
2336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2337 debug_assert_eq!(node.kind(), "else_clause");
2338 Ok(Self {
2339 span: ::treesitter_types::Span::from(node),
2340 children: {
2341 #[allow(clippy::suspicious_else_formatting)]
2342 let non_field_children = {
2343 let mut cursor = node.walk();
2344 let mut result = ::std::vec::Vec::new();
2345 if cursor.goto_first_child() {
2346 loop {
2347 if cursor.field_name().is_none()
2348 && cursor.node().is_named()
2349 && !cursor.node().is_extra()
2350 {
2351 result.push(cursor.node());
2352 }
2353 if !cursor.goto_next_sibling() {
2354 break;
2355 }
2356 }
2357 }
2358 result
2359 };
2360 let child = if let Some(&c) = non_field_children.first() {
2361 c
2362 } else {
2363 let mut fallback_cursor = node.walk();
2364 let mut fallback_child = None;
2365 if fallback_cursor.goto_first_child() {
2366 loop {
2367 if fallback_cursor.field_name().is_none()
2368 && !fallback_cursor.node().is_extra()
2369 {
2370 let candidate = fallback_cursor.node();
2371 #[allow(clippy::needless_question_mark)]
2372 if (|| -> ::core::result::Result<
2373 _,
2374 ::treesitter_types::ParseError,
2375 > {
2376 let child = candidate;
2377 Ok(
2378 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
2379 child,
2380 src,
2381 ))?,
2382 )
2383 })()
2384 .is_ok()
2385 {
2386 fallback_child = Some(candidate);
2387 break;
2388 }
2389 }
2390 if !fallback_cursor.goto_next_sibling() {
2391 break;
2392 }
2393 }
2394 }
2395 if fallback_child.is_none() {
2396 let mut cursor2 = node.walk();
2397 if cursor2.goto_first_child() {
2398 loop {
2399 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2400 let candidate = cursor2.node();
2401 #[allow(clippy::needless_question_mark)]
2402 if (|| -> ::core::result::Result<
2403 _,
2404 ::treesitter_types::ParseError,
2405 > {
2406 let child = candidate;
2407 Ok(
2408 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
2409 child,
2410 src,
2411 ))?,
2412 )
2413 })()
2414 .is_ok()
2415 {
2416 fallback_child = Some(candidate);
2417 break;
2418 }
2419 }
2420 if !cursor2.goto_next_sibling() {
2421 break;
2422 }
2423 }
2424 }
2425 }
2426 fallback_child.ok_or_else(|| {
2427 ::treesitter_types::ParseError::missing_field("children", node)
2428 })?
2429 };
2430 ::treesitter_types::runtime::maybe_grow_stack(|| {
2431 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2432 })?
2433 },
2434 })
2435 }
2436}
2437impl ::treesitter_types::Spanned for ElseClause<'_> {
2438 fn span(&self) -> ::treesitter_types::Span {
2439 self.span
2440 }
2441}
2442#[derive(Debug, Clone, PartialEq, Eq)]
2443pub struct EnumSpecifier<'tree> {
2444 pub span: ::treesitter_types::Span,
2445 pub body: ::core::option::Option<EnumeratorList<'tree>>,
2446 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
2447 pub underlying_type: ::core::option::Option<PrimitiveType<'tree>>,
2448 pub children: ::core::option::Option<AttributeSpecifier<'tree>>,
2449}
2450impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifier<'tree> {
2451 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2452 fn from_node(
2453 node: ::treesitter_types::tree_sitter::Node<'tree>,
2454 src: &'tree [u8],
2455 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2456 debug_assert_eq!(node.kind(), "enum_specifier");
2457 Ok(Self {
2458 span: ::treesitter_types::Span::from(node),
2459 body: match node.child_by_field_name("body") {
2460 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2461 <EnumeratorList as ::treesitter_types::FromNode>::from_node(child, src)
2462 })?),
2463 None => None,
2464 },
2465 name: match node.child_by_field_name("name") {
2466 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2467 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
2468 })?),
2469 None => None,
2470 },
2471 underlying_type: match node.child_by_field_name("underlying_type") {
2472 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2473 <PrimitiveType as ::treesitter_types::FromNode>::from_node(child, src)
2474 })?),
2475 None => None,
2476 },
2477 children: {
2478 #[allow(clippy::suspicious_else_formatting)]
2479 let non_field_children = {
2480 let mut cursor = node.walk();
2481 let mut result = ::std::vec::Vec::new();
2482 if cursor.goto_first_child() {
2483 loop {
2484 if cursor.field_name().is_none()
2485 && cursor.node().is_named()
2486 && !cursor.node().is_extra()
2487 {
2488 result.push(cursor.node());
2489 }
2490 if !cursor.goto_next_sibling() {
2491 break;
2492 }
2493 }
2494 }
2495 result
2496 };
2497 match non_field_children.first() {
2498 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2499 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
2500 })?),
2501 None => None,
2502 }
2503 },
2504 })
2505 }
2506}
2507impl ::treesitter_types::Spanned for EnumSpecifier<'_> {
2508 fn span(&self) -> ::treesitter_types::Span {
2509 self.span
2510 }
2511}
2512#[derive(Debug, Clone, PartialEq, Eq)]
2513pub struct Enumerator<'tree> {
2514 pub span: ::treesitter_types::Span,
2515 pub name: Identifier<'tree>,
2516 pub value: ::core::option::Option<Expression<'tree>>,
2517}
2518impl<'tree> ::treesitter_types::FromNode<'tree> for Enumerator<'tree> {
2519 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2520 fn from_node(
2521 node: ::treesitter_types::tree_sitter::Node<'tree>,
2522 src: &'tree [u8],
2523 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2524 debug_assert_eq!(node.kind(), "enumerator");
2525 Ok(Self {
2526 span: ::treesitter_types::Span::from(node),
2527 name: {
2528 let child = node
2529 .child_by_field_name("name")
2530 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2531 ::treesitter_types::runtime::maybe_grow_stack(|| {
2532 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2533 })?
2534 },
2535 value: match node.child_by_field_name("value") {
2536 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2537 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2538 })?),
2539 None => None,
2540 },
2541 })
2542 }
2543}
2544impl ::treesitter_types::Spanned for Enumerator<'_> {
2545 fn span(&self) -> ::treesitter_types::Span {
2546 self.span
2547 }
2548}
2549#[derive(Debug, Clone, PartialEq, Eq)]
2550pub struct EnumeratorList<'tree> {
2551 pub span: ::treesitter_types::Span,
2552 pub children: ::std::vec::Vec<EnumeratorListChildren<'tree>>,
2553}
2554impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorList<'tree> {
2555 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2556 fn from_node(
2557 node: ::treesitter_types::tree_sitter::Node<'tree>,
2558 src: &'tree [u8],
2559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2560 debug_assert_eq!(node.kind(), "enumerator_list");
2561 Ok(Self {
2562 span: ::treesitter_types::Span::from(node),
2563 children: {
2564 #[allow(clippy::suspicious_else_formatting)]
2565 let non_field_children = {
2566 let mut cursor = node.walk();
2567 let mut result = ::std::vec::Vec::new();
2568 if cursor.goto_first_child() {
2569 loop {
2570 if cursor.field_name().is_none()
2571 && cursor.node().is_named()
2572 && !cursor.node().is_extra()
2573 {
2574 result.push(cursor.node());
2575 }
2576 if !cursor.goto_next_sibling() {
2577 break;
2578 }
2579 }
2580 }
2581 result
2582 };
2583 let mut items = ::std::vec::Vec::new();
2584 for child in non_field_children {
2585 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2586 <EnumeratorListChildren as ::treesitter_types::FromNode>::from_node(
2587 child, src,
2588 )
2589 })?);
2590 }
2591 items
2592 },
2593 })
2594 }
2595}
2596impl ::treesitter_types::Spanned for EnumeratorList<'_> {
2597 fn span(&self) -> ::treesitter_types::Span {
2598 self.span
2599 }
2600}
2601#[derive(Debug, Clone, PartialEq, Eq)]
2602pub struct ExpressionStatement<'tree> {
2603 pub span: ::treesitter_types::Span,
2604 pub children: ::core::option::Option<ExpressionStatementChildren<'tree>>,
2605}
2606impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
2607 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2608 fn from_node(
2609 node: ::treesitter_types::tree_sitter::Node<'tree>,
2610 src: &'tree [u8],
2611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2612 debug_assert_eq!(node.kind(), "expression_statement");
2613 Ok(Self {
2614 span: ::treesitter_types::Span::from(node),
2615 children: {
2616 #[allow(clippy::suspicious_else_formatting)]
2617 let non_field_children = {
2618 let mut cursor = node.walk();
2619 let mut result = ::std::vec::Vec::new();
2620 if cursor.goto_first_child() {
2621 loop {
2622 if cursor.field_name().is_none()
2623 && cursor.node().is_named()
2624 && !cursor.node().is_extra()
2625 {
2626 result.push(cursor.node());
2627 }
2628 if !cursor.goto_next_sibling() {
2629 break;
2630 }
2631 }
2632 }
2633 result
2634 };
2635 match non_field_children.first() {
2636 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2637 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2638 child, src,
2639 )
2640 })?),
2641 None => None,
2642 }
2643 },
2644 })
2645 }
2646}
2647impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2648 fn span(&self) -> ::treesitter_types::Span {
2649 self.span
2650 }
2651}
2652#[derive(Debug, Clone, PartialEq, Eq)]
2653pub struct ExtensionExpression<'tree> {
2654 pub span: ::treesitter_types::Span,
2655 pub children: Expression<'tree>,
2656}
2657impl<'tree> ::treesitter_types::FromNode<'tree> for ExtensionExpression<'tree> {
2658 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2659 fn from_node(
2660 node: ::treesitter_types::tree_sitter::Node<'tree>,
2661 src: &'tree [u8],
2662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2663 debug_assert_eq!(node.kind(), "extension_expression");
2664 Ok(Self {
2665 span: ::treesitter_types::Span::from(node),
2666 children: {
2667 #[allow(clippy::suspicious_else_formatting)]
2668 let non_field_children = {
2669 let mut cursor = node.walk();
2670 let mut result = ::std::vec::Vec::new();
2671 if cursor.goto_first_child() {
2672 loop {
2673 if cursor.field_name().is_none()
2674 && cursor.node().is_named()
2675 && !cursor.node().is_extra()
2676 {
2677 result.push(cursor.node());
2678 }
2679 if !cursor.goto_next_sibling() {
2680 break;
2681 }
2682 }
2683 }
2684 result
2685 };
2686 let child = if let Some(&c) = non_field_children.first() {
2687 c
2688 } else {
2689 let mut fallback_cursor = node.walk();
2690 let mut fallback_child = None;
2691 if fallback_cursor.goto_first_child() {
2692 loop {
2693 if fallback_cursor.field_name().is_none()
2694 && !fallback_cursor.node().is_extra()
2695 {
2696 let candidate = fallback_cursor.node();
2697 #[allow(clippy::needless_question_mark)]
2698 if (|| -> ::core::result::Result<
2699 _,
2700 ::treesitter_types::ParseError,
2701 > {
2702 let child = candidate;
2703 Ok(
2704 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2705 child,
2706 src,
2707 ))?,
2708 )
2709 })()
2710 .is_ok()
2711 {
2712 fallback_child = Some(candidate);
2713 break;
2714 }
2715 }
2716 if !fallback_cursor.goto_next_sibling() {
2717 break;
2718 }
2719 }
2720 }
2721 if fallback_child.is_none() {
2722 let mut cursor2 = node.walk();
2723 if cursor2.goto_first_child() {
2724 loop {
2725 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2726 let candidate = cursor2.node();
2727 #[allow(clippy::needless_question_mark)]
2728 if (|| -> ::core::result::Result<
2729 _,
2730 ::treesitter_types::ParseError,
2731 > {
2732 let child = candidate;
2733 Ok(
2734 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2735 child,
2736 src,
2737 ))?,
2738 )
2739 })()
2740 .is_ok()
2741 {
2742 fallback_child = Some(candidate);
2743 break;
2744 }
2745 }
2746 if !cursor2.goto_next_sibling() {
2747 break;
2748 }
2749 }
2750 }
2751 }
2752 fallback_child.ok_or_else(|| {
2753 ::treesitter_types::ParseError::missing_field("children", node)
2754 })?
2755 };
2756 ::treesitter_types::runtime::maybe_grow_stack(|| {
2757 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2758 })?
2759 },
2760 })
2761 }
2762}
2763impl ::treesitter_types::Spanned for ExtensionExpression<'_> {
2764 fn span(&self) -> ::treesitter_types::Span {
2765 self.span
2766 }
2767}
2768#[derive(Debug, Clone, PartialEq, Eq)]
2769pub struct FieldDeclaration<'tree> {
2770 pub span: ::treesitter_types::Span,
2771 pub declarator: ::std::vec::Vec<FieldDeclarator<'tree>>,
2772 pub r#type: TypeSpecifier<'tree>,
2773 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
2774}
2775impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
2776 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2777 fn from_node(
2778 node: ::treesitter_types::tree_sitter::Node<'tree>,
2779 src: &'tree [u8],
2780 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2781 debug_assert_eq!(node.kind(), "field_declaration");
2782 Ok(Self {
2783 span: ::treesitter_types::Span::from(node),
2784 declarator: {
2785 let mut cursor = node.walk();
2786 let mut items = ::std::vec::Vec::new();
2787 for child in node.children_by_field_name("declarator", &mut cursor) {
2788 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2789 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
2790 })?);
2791 }
2792 items
2793 },
2794 r#type: {
2795 let child = node
2796 .child_by_field_name("type")
2797 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2798 ::treesitter_types::runtime::maybe_grow_stack(|| {
2799 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
2800 })?
2801 },
2802 children: {
2803 #[allow(clippy::suspicious_else_formatting)]
2804 let non_field_children = {
2805 let mut cursor = node.walk();
2806 let mut result = ::std::vec::Vec::new();
2807 if cursor.goto_first_child() {
2808 loop {
2809 if cursor.field_name().is_none()
2810 && cursor.node().is_named()
2811 && !cursor.node().is_extra()
2812 {
2813 result.push(cursor.node());
2814 }
2815 if !cursor.goto_next_sibling() {
2816 break;
2817 }
2818 }
2819 }
2820 result
2821 };
2822 let mut items = ::std::vec::Vec::new();
2823 for child in non_field_children {
2824 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2825 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2826 child, src,
2827 )
2828 })?);
2829 }
2830 items
2831 },
2832 })
2833 }
2834}
2835impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
2836 fn span(&self) -> ::treesitter_types::Span {
2837 self.span
2838 }
2839}
2840#[derive(Debug, Clone, PartialEq, Eq)]
2841pub struct FieldDeclarationList<'tree> {
2842 pub span: ::treesitter_types::Span,
2843 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
2844}
2845impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
2846 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2847 fn from_node(
2848 node: ::treesitter_types::tree_sitter::Node<'tree>,
2849 src: &'tree [u8],
2850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2851 debug_assert_eq!(node.kind(), "field_declaration_list");
2852 Ok(Self {
2853 span: ::treesitter_types::Span::from(node),
2854 children: {
2855 #[allow(clippy::suspicious_else_formatting)]
2856 let non_field_children = {
2857 let mut cursor = node.walk();
2858 let mut result = ::std::vec::Vec::new();
2859 if cursor.goto_first_child() {
2860 loop {
2861 if cursor.field_name().is_none()
2862 && cursor.node().is_named()
2863 && !cursor.node().is_extra()
2864 {
2865 result.push(cursor.node());
2866 }
2867 if !cursor.goto_next_sibling() {
2868 break;
2869 }
2870 }
2871 }
2872 result
2873 };
2874 let mut items = ::std::vec::Vec::new();
2875 for child in non_field_children {
2876 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2877 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
2878 child, src,
2879 )
2880 })?);
2881 }
2882 items
2883 },
2884 })
2885 }
2886}
2887impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
2888 fn span(&self) -> ::treesitter_types::Span {
2889 self.span
2890 }
2891}
2892#[derive(Debug, Clone, PartialEq, Eq)]
2893pub struct FieldDesignator<'tree> {
2894 pub span: ::treesitter_types::Span,
2895 pub children: FieldIdentifier<'tree>,
2896}
2897impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDesignator<'tree> {
2898 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2899 fn from_node(
2900 node: ::treesitter_types::tree_sitter::Node<'tree>,
2901 src: &'tree [u8],
2902 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2903 debug_assert_eq!(node.kind(), "field_designator");
2904 Ok(Self {
2905 span: ::treesitter_types::Span::from(node),
2906 children: {
2907 #[allow(clippy::suspicious_else_formatting)]
2908 let non_field_children = {
2909 let mut cursor = node.walk();
2910 let mut result = ::std::vec::Vec::new();
2911 if cursor.goto_first_child() {
2912 loop {
2913 if cursor.field_name().is_none()
2914 && cursor.node().is_named()
2915 && !cursor.node().is_extra()
2916 {
2917 result.push(cursor.node());
2918 }
2919 if !cursor.goto_next_sibling() {
2920 break;
2921 }
2922 }
2923 }
2924 result
2925 };
2926 let child = if let Some(&c) = non_field_children.first() {
2927 c
2928 } else {
2929 let mut fallback_cursor = node.walk();
2930 let mut fallback_child = None;
2931 if fallback_cursor.goto_first_child() {
2932 loop {
2933 if fallback_cursor.field_name().is_none()
2934 && !fallback_cursor.node().is_extra()
2935 {
2936 let candidate = fallback_cursor.node();
2937 #[allow(clippy::needless_question_mark)]
2938 if (|| -> ::core::result::Result<
2939 _,
2940 ::treesitter_types::ParseError,
2941 > {
2942 let child = candidate;
2943 Ok(
2944 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
2945 child,
2946 src,
2947 ))?,
2948 )
2949 })()
2950 .is_ok()
2951 {
2952 fallback_child = Some(candidate);
2953 break;
2954 }
2955 }
2956 if !fallback_cursor.goto_next_sibling() {
2957 break;
2958 }
2959 }
2960 }
2961 if fallback_child.is_none() {
2962 let mut cursor2 = node.walk();
2963 if cursor2.goto_first_child() {
2964 loop {
2965 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2966 let candidate = cursor2.node();
2967 #[allow(clippy::needless_question_mark)]
2968 if (|| -> ::core::result::Result<
2969 _,
2970 ::treesitter_types::ParseError,
2971 > {
2972 let child = candidate;
2973 Ok(
2974 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
2975 child,
2976 src,
2977 ))?,
2978 )
2979 })()
2980 .is_ok()
2981 {
2982 fallback_child = Some(candidate);
2983 break;
2984 }
2985 }
2986 if !cursor2.goto_next_sibling() {
2987 break;
2988 }
2989 }
2990 }
2991 }
2992 fallback_child.ok_or_else(|| {
2993 ::treesitter_types::ParseError::missing_field("children", node)
2994 })?
2995 };
2996 ::treesitter_types::runtime::maybe_grow_stack(|| {
2997 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
2998 })?
2999 },
3000 })
3001 }
3002}
3003impl ::treesitter_types::Spanned for FieldDesignator<'_> {
3004 fn span(&self) -> ::treesitter_types::Span {
3005 self.span
3006 }
3007}
3008#[derive(Debug, Clone, PartialEq, Eq)]
3009pub struct FieldExpression<'tree> {
3010 pub span: ::treesitter_types::Span,
3011 pub argument: Expression<'tree>,
3012 pub field: FieldIdentifier<'tree>,
3013 pub operator: FieldExpressionOperator,
3014}
3015impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
3016 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3017 fn from_node(
3018 node: ::treesitter_types::tree_sitter::Node<'tree>,
3019 src: &'tree [u8],
3020 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3021 debug_assert_eq!(node.kind(), "field_expression");
3022 Ok(Self {
3023 span: ::treesitter_types::Span::from(node),
3024 argument: {
3025 let child = node.child_by_field_name("argument").ok_or_else(|| {
3026 ::treesitter_types::ParseError::missing_field("argument", node)
3027 })?;
3028 ::treesitter_types::runtime::maybe_grow_stack(|| {
3029 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3030 })?
3031 },
3032 field: {
3033 let child = node
3034 .child_by_field_name("field")
3035 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3036 ::treesitter_types::runtime::maybe_grow_stack(|| {
3037 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3038 })?
3039 },
3040 operator: {
3041 let child = node.child_by_field_name("operator").ok_or_else(|| {
3042 ::treesitter_types::ParseError::missing_field("operator", node)
3043 })?;
3044 ::treesitter_types::runtime::maybe_grow_stack(|| {
3045 <FieldExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
3046 })?
3047 },
3048 })
3049 }
3050}
3051impl ::treesitter_types::Spanned for FieldExpression<'_> {
3052 fn span(&self) -> ::treesitter_types::Span {
3053 self.span
3054 }
3055}
3056#[derive(Debug, Clone, PartialEq, Eq)]
3057pub struct ForStatement<'tree> {
3058 pub span: ::treesitter_types::Span,
3059 pub body: Statement<'tree>,
3060 pub condition: ::core::option::Option<ForStatementCondition<'tree>>,
3061 pub initializer: ::core::option::Option<ForStatementInitializer<'tree>>,
3062 pub update: ::core::option::Option<ForStatementUpdate<'tree>>,
3063}
3064impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3065 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3066 fn from_node(
3067 node: ::treesitter_types::tree_sitter::Node<'tree>,
3068 src: &'tree [u8],
3069 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3070 debug_assert_eq!(node.kind(), "for_statement");
3071 Ok(Self {
3072 span: ::treesitter_types::Span::from(node),
3073 body: {
3074 let child = node
3075 .child_by_field_name("body")
3076 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3077 ::treesitter_types::runtime::maybe_grow_stack(|| {
3078 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3079 })?
3080 },
3081 condition: match node.child_by_field_name("condition") {
3082 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3083 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(child, src)
3084 })?),
3085 None => None,
3086 },
3087 initializer: match node.child_by_field_name("initializer") {
3088 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3089 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)
3090 })?),
3091 None => None,
3092 },
3093 update: match node.child_by_field_name("update") {
3094 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3095 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)
3096 })?),
3097 None => None,
3098 },
3099 })
3100 }
3101}
3102impl ::treesitter_types::Spanned for ForStatement<'_> {
3103 fn span(&self) -> ::treesitter_types::Span {
3104 self.span
3105 }
3106}
3107#[derive(Debug, Clone, PartialEq, Eq)]
3108pub struct FunctionDeclarator<'tree> {
3109 pub span: ::treesitter_types::Span,
3110 pub declarator: FunctionDeclaratorDeclarator<'tree>,
3111 pub parameters: ParameterList<'tree>,
3112 pub children: ::std::vec::Vec<FunctionDeclaratorChildren<'tree>>,
3113}
3114impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarator<'tree> {
3115 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3116 fn from_node(
3117 node: ::treesitter_types::tree_sitter::Node<'tree>,
3118 src: &'tree [u8],
3119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3120 debug_assert_eq!(node.kind(), "function_declarator");
3121 Ok(Self {
3122 span: ::treesitter_types::Span::from(node),
3123 declarator: {
3124 let child = node.child_by_field_name("declarator").ok_or_else(|| {
3125 ::treesitter_types::ParseError::missing_field("declarator", node)
3126 })?;
3127 ::treesitter_types::runtime::maybe_grow_stack(|| {
3128 <FunctionDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
3129 child, src,
3130 )
3131 })?
3132 },
3133 parameters: {
3134 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3135 ::treesitter_types::ParseError::missing_field("parameters", node)
3136 })?;
3137 ::treesitter_types::runtime::maybe_grow_stack(|| {
3138 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
3139 })?
3140 },
3141 children: {
3142 #[allow(clippy::suspicious_else_formatting)]
3143 let non_field_children = {
3144 let mut cursor = node.walk();
3145 let mut result = ::std::vec::Vec::new();
3146 if cursor.goto_first_child() {
3147 loop {
3148 if cursor.field_name().is_none()
3149 && cursor.node().is_named()
3150 && !cursor.node().is_extra()
3151 {
3152 result.push(cursor.node());
3153 }
3154 if !cursor.goto_next_sibling() {
3155 break;
3156 }
3157 }
3158 }
3159 result
3160 };
3161 let mut items = ::std::vec::Vec::new();
3162 for child in non_field_children {
3163 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3164 <FunctionDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
3165 child, src,
3166 )
3167 })?);
3168 }
3169 items
3170 },
3171 })
3172 }
3173}
3174impl ::treesitter_types::Spanned for FunctionDeclarator<'_> {
3175 fn span(&self) -> ::treesitter_types::Span {
3176 self.span
3177 }
3178}
3179#[derive(Debug, Clone, PartialEq, Eq)]
3180pub struct FunctionDefinition<'tree> {
3181 pub span: ::treesitter_types::Span,
3182 pub body: CompoundStatement<'tree>,
3183 pub declarator: Declarator<'tree>,
3184 pub r#type: TypeSpecifier<'tree>,
3185 pub children: ::std::vec::Vec<FunctionDefinitionChildren<'tree>>,
3186}
3187impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
3188 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3189 fn from_node(
3190 node: ::treesitter_types::tree_sitter::Node<'tree>,
3191 src: &'tree [u8],
3192 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3193 debug_assert_eq!(node.kind(), "function_definition");
3194 Ok(Self {
3195 span: ::treesitter_types::Span::from(node),
3196 body: {
3197 let child = node
3198 .child_by_field_name("body")
3199 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3200 ::treesitter_types::runtime::maybe_grow_stack(|| {
3201 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
3202 })?
3203 },
3204 declarator: {
3205 let child = node.child_by_field_name("declarator").ok_or_else(|| {
3206 ::treesitter_types::ParseError::missing_field("declarator", node)
3207 })?;
3208 ::treesitter_types::runtime::maybe_grow_stack(|| {
3209 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)
3210 })?
3211 },
3212 r#type: {
3213 let child = node
3214 .child_by_field_name("type")
3215 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3216 ::treesitter_types::runtime::maybe_grow_stack(|| {
3217 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
3218 })?
3219 },
3220 children: {
3221 #[allow(clippy::suspicious_else_formatting)]
3222 let non_field_children = {
3223 let mut cursor = node.walk();
3224 let mut result = ::std::vec::Vec::new();
3225 if cursor.goto_first_child() {
3226 loop {
3227 if cursor.field_name().is_none()
3228 && cursor.node().is_named()
3229 && !cursor.node().is_extra()
3230 {
3231 result.push(cursor.node());
3232 }
3233 if !cursor.goto_next_sibling() {
3234 break;
3235 }
3236 }
3237 }
3238 result
3239 };
3240 let mut items = ::std::vec::Vec::new();
3241 for child in non_field_children {
3242 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3243 <FunctionDefinitionChildren as ::treesitter_types::FromNode>::from_node(
3244 child, src,
3245 )
3246 })?);
3247 }
3248 items
3249 },
3250 })
3251 }
3252}
3253impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
3254 fn span(&self) -> ::treesitter_types::Span {
3255 self.span
3256 }
3257}
3258#[derive(Debug, Clone, PartialEq, Eq)]
3259pub struct GenericExpression<'tree> {
3260 pub span: ::treesitter_types::Span,
3261 pub children: ::std::vec::Vec<GenericExpressionChildren<'tree>>,
3262}
3263impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpression<'tree> {
3264 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3265 fn from_node(
3266 node: ::treesitter_types::tree_sitter::Node<'tree>,
3267 src: &'tree [u8],
3268 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3269 debug_assert_eq!(node.kind(), "generic_expression");
3270 Ok(Self {
3271 span: ::treesitter_types::Span::from(node),
3272 children: {
3273 #[allow(clippy::suspicious_else_formatting)]
3274 let non_field_children = {
3275 let mut cursor = node.walk();
3276 let mut result = ::std::vec::Vec::new();
3277 if cursor.goto_first_child() {
3278 loop {
3279 if cursor.field_name().is_none()
3280 && cursor.node().is_named()
3281 && !cursor.node().is_extra()
3282 {
3283 result.push(cursor.node());
3284 }
3285 if !cursor.goto_next_sibling() {
3286 break;
3287 }
3288 }
3289 }
3290 result
3291 };
3292 let mut items = ::std::vec::Vec::new();
3293 for child in non_field_children {
3294 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3295 <GenericExpressionChildren as ::treesitter_types::FromNode>::from_node(
3296 child, src,
3297 )
3298 })?);
3299 }
3300 items
3301 },
3302 })
3303 }
3304}
3305impl ::treesitter_types::Spanned for GenericExpression<'_> {
3306 fn span(&self) -> ::treesitter_types::Span {
3307 self.span
3308 }
3309}
3310#[derive(Debug, Clone, PartialEq, Eq)]
3311pub struct GnuAsmClobberList<'tree> {
3312 pub span: ::treesitter_types::Span,
3313 pub register: ::std::vec::Vec<GnuAsmClobberListRegister<'tree>>,
3314}
3315impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberList<'tree> {
3316 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3317 fn from_node(
3318 node: ::treesitter_types::tree_sitter::Node<'tree>,
3319 src: &'tree [u8],
3320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3321 debug_assert_eq!(node.kind(), "gnu_asm_clobber_list");
3322 Ok(Self {
3323 span: ::treesitter_types::Span::from(node),
3324 register: {
3325 let mut cursor = node.walk();
3326 let mut items = ::std::vec::Vec::new();
3327 for child in node.children_by_field_name("register", &mut cursor) {
3328 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3329 <GnuAsmClobberListRegister as ::treesitter_types::FromNode>::from_node(
3330 child, src,
3331 )
3332 })?);
3333 }
3334 items
3335 },
3336 })
3337 }
3338}
3339impl ::treesitter_types::Spanned for GnuAsmClobberList<'_> {
3340 fn span(&self) -> ::treesitter_types::Span {
3341 self.span
3342 }
3343}
3344#[derive(Debug, Clone, PartialEq, Eq)]
3345pub struct GnuAsmExpression<'tree> {
3346 pub span: ::treesitter_types::Span,
3347 pub assembly_code: GnuAsmExpressionAssemblyCode<'tree>,
3348 pub clobbers: ::core::option::Option<GnuAsmClobberList<'tree>>,
3349 pub goto_labels: ::core::option::Option<GnuAsmGotoList<'tree>>,
3350 pub input_operands: ::core::option::Option<GnuAsmInputOperandList<'tree>>,
3351 pub output_operands: ::core::option::Option<GnuAsmOutputOperandList<'tree>>,
3352 pub children: ::std::vec::Vec<GnuAsmQualifier<'tree>>,
3353}
3354impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpression<'tree> {
3355 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3356 fn from_node(
3357 node: ::treesitter_types::tree_sitter::Node<'tree>,
3358 src: &'tree [u8],
3359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3360 debug_assert_eq!(node.kind(), "gnu_asm_expression");
3361 Ok(Self {
3362 span: ::treesitter_types::Span::from(node),
3363 assembly_code: {
3364 let child = node.child_by_field_name("assembly_code").ok_or_else(|| {
3365 ::treesitter_types::ParseError::missing_field("assembly_code", node)
3366 })?;
3367 ::treesitter_types::runtime::maybe_grow_stack(|| {
3368 <GnuAsmExpressionAssemblyCode as ::treesitter_types::FromNode>::from_node(
3369 child, src,
3370 )
3371 })?
3372 },
3373 clobbers: match node.child_by_field_name("clobbers") {
3374 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3375 <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(child, src)
3376 })?),
3377 None => None,
3378 },
3379 goto_labels: match node.child_by_field_name("goto_labels") {
3380 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3381 <GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(child, src)
3382 })?),
3383 None => None,
3384 },
3385 input_operands: match node.child_by_field_name("input_operands") {
3386 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3387 <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(child, src)
3388 })?),
3389 None => None,
3390 },
3391 output_operands: match node.child_by_field_name("output_operands") {
3392 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3393 <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(child, src)
3394 })?),
3395 None => None,
3396 },
3397 children: {
3398 #[allow(clippy::suspicious_else_formatting)]
3399 let non_field_children = {
3400 let mut cursor = node.walk();
3401 let mut result = ::std::vec::Vec::new();
3402 if cursor.goto_first_child() {
3403 loop {
3404 if cursor.field_name().is_none()
3405 && cursor.node().is_named()
3406 && !cursor.node().is_extra()
3407 {
3408 result.push(cursor.node());
3409 }
3410 if !cursor.goto_next_sibling() {
3411 break;
3412 }
3413 }
3414 }
3415 result
3416 };
3417 let mut items = ::std::vec::Vec::new();
3418 for child in non_field_children {
3419 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3420 <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(child, src)
3421 })?);
3422 }
3423 items
3424 },
3425 })
3426 }
3427}
3428impl ::treesitter_types::Spanned for GnuAsmExpression<'_> {
3429 fn span(&self) -> ::treesitter_types::Span {
3430 self.span
3431 }
3432}
3433#[derive(Debug, Clone, PartialEq, Eq)]
3434pub struct GnuAsmGotoList<'tree> {
3435 pub span: ::treesitter_types::Span,
3436 pub label: ::std::vec::Vec<Identifier<'tree>>,
3437}
3438impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmGotoList<'tree> {
3439 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3440 fn from_node(
3441 node: ::treesitter_types::tree_sitter::Node<'tree>,
3442 src: &'tree [u8],
3443 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3444 debug_assert_eq!(node.kind(), "gnu_asm_goto_list");
3445 Ok(Self {
3446 span: ::treesitter_types::Span::from(node),
3447 label: {
3448 let mut cursor = node.walk();
3449 let mut items = ::std::vec::Vec::new();
3450 for child in node.children_by_field_name("label", &mut cursor) {
3451 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3452 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3453 })?);
3454 }
3455 items
3456 },
3457 })
3458 }
3459}
3460impl ::treesitter_types::Spanned for GnuAsmGotoList<'_> {
3461 fn span(&self) -> ::treesitter_types::Span {
3462 self.span
3463 }
3464}
3465#[derive(Debug, Clone, PartialEq, Eq)]
3466pub struct GnuAsmInputOperand<'tree> {
3467 pub span: ::treesitter_types::Span,
3468 pub constraint: StringLiteral<'tree>,
3469 pub symbol: ::core::option::Option<Identifier<'tree>>,
3470 pub value: Expression<'tree>,
3471}
3472impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperand<'tree> {
3473 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3474 fn from_node(
3475 node: ::treesitter_types::tree_sitter::Node<'tree>,
3476 src: &'tree [u8],
3477 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3478 debug_assert_eq!(node.kind(), "gnu_asm_input_operand");
3479 Ok(Self {
3480 span: ::treesitter_types::Span::from(node),
3481 constraint: {
3482 let child = node.child_by_field_name("constraint").ok_or_else(|| {
3483 ::treesitter_types::ParseError::missing_field("constraint", node)
3484 })?;
3485 ::treesitter_types::runtime::maybe_grow_stack(|| {
3486 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
3487 })?
3488 },
3489 symbol: match node.child_by_field_name("symbol") {
3490 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3491 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3492 })?),
3493 None => None,
3494 },
3495 value: {
3496 let child = node
3497 .child_by_field_name("value")
3498 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3499 ::treesitter_types::runtime::maybe_grow_stack(|| {
3500 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3501 })?
3502 },
3503 })
3504 }
3505}
3506impl ::treesitter_types::Spanned for GnuAsmInputOperand<'_> {
3507 fn span(&self) -> ::treesitter_types::Span {
3508 self.span
3509 }
3510}
3511#[derive(Debug, Clone, PartialEq, Eq)]
3512pub struct GnuAsmInputOperandList<'tree> {
3513 pub span: ::treesitter_types::Span,
3514 pub operand: ::std::vec::Vec<GnuAsmInputOperand<'tree>>,
3515}
3516impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperandList<'tree> {
3517 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3518 fn from_node(
3519 node: ::treesitter_types::tree_sitter::Node<'tree>,
3520 src: &'tree [u8],
3521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3522 debug_assert_eq!(node.kind(), "gnu_asm_input_operand_list");
3523 Ok(Self {
3524 span: ::treesitter_types::Span::from(node),
3525 operand: {
3526 let mut cursor = node.walk();
3527 let mut items = ::std::vec::Vec::new();
3528 for child in node.children_by_field_name("operand", &mut cursor) {
3529 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3530 <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(child, src)
3531 })?);
3532 }
3533 items
3534 },
3535 })
3536 }
3537}
3538impl ::treesitter_types::Spanned for GnuAsmInputOperandList<'_> {
3539 fn span(&self) -> ::treesitter_types::Span {
3540 self.span
3541 }
3542}
3543#[derive(Debug, Clone, PartialEq, Eq)]
3544pub struct GnuAsmOutputOperand<'tree> {
3545 pub span: ::treesitter_types::Span,
3546 pub constraint: StringLiteral<'tree>,
3547 pub symbol: ::core::option::Option<Identifier<'tree>>,
3548 pub value: Expression<'tree>,
3549}
3550impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperand<'tree> {
3551 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3552 fn from_node(
3553 node: ::treesitter_types::tree_sitter::Node<'tree>,
3554 src: &'tree [u8],
3555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3556 debug_assert_eq!(node.kind(), "gnu_asm_output_operand");
3557 Ok(Self {
3558 span: ::treesitter_types::Span::from(node),
3559 constraint: {
3560 let child = node.child_by_field_name("constraint").ok_or_else(|| {
3561 ::treesitter_types::ParseError::missing_field("constraint", node)
3562 })?;
3563 ::treesitter_types::runtime::maybe_grow_stack(|| {
3564 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
3565 })?
3566 },
3567 symbol: match node.child_by_field_name("symbol") {
3568 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3569 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
3570 })?),
3571 None => None,
3572 },
3573 value: {
3574 let child = node
3575 .child_by_field_name("value")
3576 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3577 ::treesitter_types::runtime::maybe_grow_stack(|| {
3578 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3579 })?
3580 },
3581 })
3582 }
3583}
3584impl ::treesitter_types::Spanned for GnuAsmOutputOperand<'_> {
3585 fn span(&self) -> ::treesitter_types::Span {
3586 self.span
3587 }
3588}
3589#[derive(Debug, Clone, PartialEq, Eq)]
3590pub struct GnuAsmOutputOperandList<'tree> {
3591 pub span: ::treesitter_types::Span,
3592 pub operand: ::std::vec::Vec<GnuAsmOutputOperand<'tree>>,
3593}
3594impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperandList<'tree> {
3595 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3596 fn from_node(
3597 node: ::treesitter_types::tree_sitter::Node<'tree>,
3598 src: &'tree [u8],
3599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3600 debug_assert_eq!(node.kind(), "gnu_asm_output_operand_list");
3601 Ok(Self {
3602 span: ::treesitter_types::Span::from(node),
3603 operand: {
3604 let mut cursor = node.walk();
3605 let mut items = ::std::vec::Vec::new();
3606 for child in node.children_by_field_name("operand", &mut cursor) {
3607 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3608 <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(child, src)
3609 })?);
3610 }
3611 items
3612 },
3613 })
3614 }
3615}
3616impl ::treesitter_types::Spanned for GnuAsmOutputOperandList<'_> {
3617 fn span(&self) -> ::treesitter_types::Span {
3618 self.span
3619 }
3620}
3621#[derive(Debug, Clone, PartialEq, Eq)]
3622pub struct GnuAsmQualifier<'tree> {
3623 pub span: ::treesitter_types::Span,
3624 text: &'tree str,
3625}
3626impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmQualifier<'tree> {
3627 fn from_node(
3628 node: ::treesitter_types::tree_sitter::Node<'tree>,
3629 src: &'tree [u8],
3630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3631 debug_assert_eq!(node.kind(), "gnu_asm_qualifier");
3632 Ok(Self {
3633 span: ::treesitter_types::Span::from(node),
3634 text: node.utf8_text(src)?,
3635 })
3636 }
3637}
3638impl<'tree> ::treesitter_types::LeafNode<'tree> for GnuAsmQualifier<'tree> {
3639 fn text(&self) -> &'tree str {
3640 self.text
3641 }
3642}
3643impl ::treesitter_types::Spanned for GnuAsmQualifier<'_> {
3644 fn span(&self) -> ::treesitter_types::Span {
3645 self.span
3646 }
3647}
3648#[derive(Debug, Clone, PartialEq, Eq)]
3649pub struct GotoStatement<'tree> {
3650 pub span: ::treesitter_types::Span,
3651 pub label: StatementIdentifier<'tree>,
3652}
3653impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
3654 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3655 fn from_node(
3656 node: ::treesitter_types::tree_sitter::Node<'tree>,
3657 src: &'tree [u8],
3658 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3659 debug_assert_eq!(node.kind(), "goto_statement");
3660 Ok(Self {
3661 span: ::treesitter_types::Span::from(node),
3662 label: {
3663 let child = node
3664 .child_by_field_name("label")
3665 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
3666 ::treesitter_types::runtime::maybe_grow_stack(|| {
3667 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3668 })?
3669 },
3670 })
3671 }
3672}
3673impl ::treesitter_types::Spanned for GotoStatement<'_> {
3674 fn span(&self) -> ::treesitter_types::Span {
3675 self.span
3676 }
3677}
3678#[derive(Debug, Clone, PartialEq, Eq)]
3679pub struct IfStatement<'tree> {
3680 pub span: ::treesitter_types::Span,
3681 pub alternative: ::core::option::Option<ElseClause<'tree>>,
3682 pub condition: ParenthesizedExpression<'tree>,
3683 pub consequence: Statement<'tree>,
3684}
3685impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
3686 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3687 fn from_node(
3688 node: ::treesitter_types::tree_sitter::Node<'tree>,
3689 src: &'tree [u8],
3690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3691 debug_assert_eq!(node.kind(), "if_statement");
3692 Ok(Self {
3693 span: ::treesitter_types::Span::from(node),
3694 alternative: match node.child_by_field_name("alternative") {
3695 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3696 <ElseClause as ::treesitter_types::FromNode>::from_node(child, src)
3697 })?),
3698 None => None,
3699 },
3700 condition: {
3701 let child = node.child_by_field_name("condition").ok_or_else(|| {
3702 ::treesitter_types::ParseError::missing_field("condition", node)
3703 })?;
3704 ::treesitter_types::runtime::maybe_grow_stack(|| {
3705 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
3706 })?
3707 },
3708 consequence: {
3709 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3710 ::treesitter_types::ParseError::missing_field("consequence", node)
3711 })?;
3712 ::treesitter_types::runtime::maybe_grow_stack(|| {
3713 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3714 })?
3715 },
3716 })
3717 }
3718}
3719impl ::treesitter_types::Spanned for IfStatement<'_> {
3720 fn span(&self) -> ::treesitter_types::Span {
3721 self.span
3722 }
3723}
3724#[derive(Debug, Clone, PartialEq, Eq)]
3725pub struct InitDeclarator<'tree> {
3726 pub span: ::treesitter_types::Span,
3727 pub declarator: Declarator<'tree>,
3728 pub value: InitDeclaratorValue<'tree>,
3729}
3730impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclarator<'tree> {
3731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3732 fn from_node(
3733 node: ::treesitter_types::tree_sitter::Node<'tree>,
3734 src: &'tree [u8],
3735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3736 debug_assert_eq!(node.kind(), "init_declarator");
3737 Ok(Self {
3738 span: ::treesitter_types::Span::from(node),
3739 declarator: {
3740 let child = node.child_by_field_name("declarator").ok_or_else(|| {
3741 ::treesitter_types::ParseError::missing_field("declarator", node)
3742 })?;
3743 ::treesitter_types::runtime::maybe_grow_stack(|| {
3744 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)
3745 })?
3746 },
3747 value: {
3748 let child = node
3749 .child_by_field_name("value")
3750 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3751 ::treesitter_types::runtime::maybe_grow_stack(|| {
3752 <InitDeclaratorValue as ::treesitter_types::FromNode>::from_node(child, src)
3753 })?
3754 },
3755 })
3756 }
3757}
3758impl ::treesitter_types::Spanned for InitDeclarator<'_> {
3759 fn span(&self) -> ::treesitter_types::Span {
3760 self.span
3761 }
3762}
3763#[derive(Debug, Clone, PartialEq, Eq)]
3764pub struct InitializerList<'tree> {
3765 pub span: ::treesitter_types::Span,
3766 pub children: ::std::vec::Vec<InitializerListChildren<'tree>>,
3767}
3768impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerList<'tree> {
3769 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3770 fn from_node(
3771 node: ::treesitter_types::tree_sitter::Node<'tree>,
3772 src: &'tree [u8],
3773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3774 debug_assert_eq!(node.kind(), "initializer_list");
3775 Ok(Self {
3776 span: ::treesitter_types::Span::from(node),
3777 children: {
3778 #[allow(clippy::suspicious_else_formatting)]
3779 let non_field_children = {
3780 let mut cursor = node.walk();
3781 let mut result = ::std::vec::Vec::new();
3782 if cursor.goto_first_child() {
3783 loop {
3784 if cursor.field_name().is_none()
3785 && cursor.node().is_named()
3786 && !cursor.node().is_extra()
3787 {
3788 result.push(cursor.node());
3789 }
3790 if !cursor.goto_next_sibling() {
3791 break;
3792 }
3793 }
3794 }
3795 result
3796 };
3797 let mut items = ::std::vec::Vec::new();
3798 for child in non_field_children {
3799 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3800 <InitializerListChildren as ::treesitter_types::FromNode>::from_node(
3801 child, src,
3802 )
3803 })?);
3804 }
3805 items
3806 },
3807 })
3808 }
3809}
3810impl ::treesitter_types::Spanned for InitializerList<'_> {
3811 fn span(&self) -> ::treesitter_types::Span {
3812 self.span
3813 }
3814}
3815#[derive(Debug, Clone, PartialEq, Eq)]
3816pub struct InitializerPair<'tree> {
3817 pub span: ::treesitter_types::Span,
3818 pub designator: ::std::vec::Vec<InitializerPairDesignator<'tree>>,
3819 pub value: InitializerPairValue<'tree>,
3820}
3821impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPair<'tree> {
3822 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3823 fn from_node(
3824 node: ::treesitter_types::tree_sitter::Node<'tree>,
3825 src: &'tree [u8],
3826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3827 debug_assert_eq!(node.kind(), "initializer_pair");
3828 Ok(Self {
3829 span: ::treesitter_types::Span::from(node),
3830 designator: {
3831 let mut cursor = node.walk();
3832 let mut items = ::std::vec::Vec::new();
3833 for child in node.children_by_field_name("designator", &mut cursor) {
3834 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3835 <InitializerPairDesignator as ::treesitter_types::FromNode>::from_node(
3836 child, src,
3837 )
3838 })?);
3839 }
3840 items
3841 },
3842 value: {
3843 let child = node
3844 .child_by_field_name("value")
3845 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3846 ::treesitter_types::runtime::maybe_grow_stack(|| {
3847 <InitializerPairValue as ::treesitter_types::FromNode>::from_node(child, src)
3848 })?
3849 },
3850 })
3851 }
3852}
3853impl ::treesitter_types::Spanned for InitializerPair<'_> {
3854 fn span(&self) -> ::treesitter_types::Span {
3855 self.span
3856 }
3857}
3858#[derive(Debug, Clone, PartialEq, Eq)]
3859pub struct LabeledStatement<'tree> {
3860 pub span: ::treesitter_types::Span,
3861 pub label: StatementIdentifier<'tree>,
3862 pub children: LabeledStatementChildren<'tree>,
3863}
3864impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
3865 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3866 fn from_node(
3867 node: ::treesitter_types::tree_sitter::Node<'tree>,
3868 src: &'tree [u8],
3869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3870 debug_assert_eq!(node.kind(), "labeled_statement");
3871 Ok(Self {
3872 span: ::treesitter_types::Span::from(node),
3873 label: {
3874 let child = node
3875 .child_by_field_name("label")
3876 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
3877 ::treesitter_types::runtime::maybe_grow_stack(|| {
3878 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
3879 })?
3880 },
3881 children: {
3882 #[allow(clippy::suspicious_else_formatting)]
3883 let non_field_children = {
3884 let mut cursor = node.walk();
3885 let mut result = ::std::vec::Vec::new();
3886 if cursor.goto_first_child() {
3887 loop {
3888 if cursor.field_name().is_none()
3889 && cursor.node().is_named()
3890 && !cursor.node().is_extra()
3891 {
3892 result.push(cursor.node());
3893 }
3894 if !cursor.goto_next_sibling() {
3895 break;
3896 }
3897 }
3898 }
3899 result
3900 };
3901 let child = if let Some(&c) = non_field_children.first() {
3902 c
3903 } else {
3904 let mut fallback_cursor = node.walk();
3905 let mut fallback_child = None;
3906 if fallback_cursor.goto_first_child() {
3907 loop {
3908 if fallback_cursor.field_name().is_none()
3909 && !fallback_cursor.node().is_extra()
3910 {
3911 let candidate = fallback_cursor.node();
3912 #[allow(clippy::needless_question_mark)]
3913 if (|| -> ::core::result::Result<
3914 _,
3915 ::treesitter_types::ParseError,
3916 > {
3917 let child = candidate;
3918 Ok(
3919 ::treesitter_types::runtime::maybe_grow_stack(|| <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
3920 child,
3921 src,
3922 ))?,
3923 )
3924 })()
3925 .is_ok()
3926 {
3927 fallback_child = Some(candidate);
3928 break;
3929 }
3930 }
3931 if !fallback_cursor.goto_next_sibling() {
3932 break;
3933 }
3934 }
3935 }
3936 if fallback_child.is_none() {
3937 let mut cursor2 = node.walk();
3938 if cursor2.goto_first_child() {
3939 loop {
3940 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3941 let candidate = cursor2.node();
3942 #[allow(clippy::needless_question_mark)]
3943 if (|| -> ::core::result::Result<
3944 _,
3945 ::treesitter_types::ParseError,
3946 > {
3947 let child = candidate;
3948 Ok(
3949 ::treesitter_types::runtime::maybe_grow_stack(|| <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
3950 child,
3951 src,
3952 ))?,
3953 )
3954 })()
3955 .is_ok()
3956 {
3957 fallback_child = Some(candidate);
3958 break;
3959 }
3960 }
3961 if !cursor2.goto_next_sibling() {
3962 break;
3963 }
3964 }
3965 }
3966 }
3967 fallback_child.ok_or_else(|| {
3968 ::treesitter_types::ParseError::missing_field("children", node)
3969 })?
3970 };
3971 ::treesitter_types::runtime::maybe_grow_stack(|| {
3972 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
3973 child, src,
3974 )
3975 })?
3976 },
3977 })
3978 }
3979}
3980impl ::treesitter_types::Spanned for LabeledStatement<'_> {
3981 fn span(&self) -> ::treesitter_types::Span {
3982 self.span
3983 }
3984}
3985#[derive(Debug, Clone, PartialEq, Eq)]
3986pub struct LinkageSpecification<'tree> {
3987 pub span: ::treesitter_types::Span,
3988 pub body: LinkageSpecificationBody<'tree>,
3989 pub value: StringLiteral<'tree>,
3990}
3991impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecification<'tree> {
3992 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3993 fn from_node(
3994 node: ::treesitter_types::tree_sitter::Node<'tree>,
3995 src: &'tree [u8],
3996 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3997 debug_assert_eq!(node.kind(), "linkage_specification");
3998 Ok(Self {
3999 span: ::treesitter_types::Span::from(node),
4000 body: {
4001 let child = node
4002 .child_by_field_name("body")
4003 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4004 ::treesitter_types::runtime::maybe_grow_stack(|| {
4005 <LinkageSpecificationBody as ::treesitter_types::FromNode>::from_node(
4006 child, src,
4007 )
4008 })?
4009 },
4010 value: {
4011 let child = node
4012 .child_by_field_name("value")
4013 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4014 ::treesitter_types::runtime::maybe_grow_stack(|| {
4015 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
4016 })?
4017 },
4018 })
4019 }
4020}
4021impl ::treesitter_types::Spanned for LinkageSpecification<'_> {
4022 fn span(&self) -> ::treesitter_types::Span {
4023 self.span
4024 }
4025}
4026#[derive(Debug, Clone, PartialEq, Eq)]
4027pub struct MacroTypeSpecifier<'tree> {
4028 pub span: ::treesitter_types::Span,
4029 pub name: Identifier<'tree>,
4030 pub r#type: TypeDescriptor<'tree>,
4031}
4032impl<'tree> ::treesitter_types::FromNode<'tree> for MacroTypeSpecifier<'tree> {
4033 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4034 fn from_node(
4035 node: ::treesitter_types::tree_sitter::Node<'tree>,
4036 src: &'tree [u8],
4037 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4038 debug_assert_eq!(node.kind(), "macro_type_specifier");
4039 Ok(Self {
4040 span: ::treesitter_types::Span::from(node),
4041 name: {
4042 let child = node
4043 .child_by_field_name("name")
4044 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4045 ::treesitter_types::runtime::maybe_grow_stack(|| {
4046 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4047 })?
4048 },
4049 r#type: {
4050 let child = node
4051 .child_by_field_name("type")
4052 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4053 ::treesitter_types::runtime::maybe_grow_stack(|| {
4054 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
4055 })?
4056 },
4057 })
4058 }
4059}
4060impl ::treesitter_types::Spanned for MacroTypeSpecifier<'_> {
4061 fn span(&self) -> ::treesitter_types::Span {
4062 self.span
4063 }
4064}
4065#[derive(Debug, Clone, PartialEq, Eq)]
4066pub struct MsBasedModifier<'tree> {
4067 pub span: ::treesitter_types::Span,
4068 pub children: ArgumentList<'tree>,
4069}
4070impl<'tree> ::treesitter_types::FromNode<'tree> for MsBasedModifier<'tree> {
4071 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4072 fn from_node(
4073 node: ::treesitter_types::tree_sitter::Node<'tree>,
4074 src: &'tree [u8],
4075 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4076 debug_assert_eq!(node.kind(), "ms_based_modifier");
4077 Ok(Self {
4078 span: ::treesitter_types::Span::from(node),
4079 children: {
4080 #[allow(clippy::suspicious_else_formatting)]
4081 let non_field_children = {
4082 let mut cursor = node.walk();
4083 let mut result = ::std::vec::Vec::new();
4084 if cursor.goto_first_child() {
4085 loop {
4086 if cursor.field_name().is_none()
4087 && cursor.node().is_named()
4088 && !cursor.node().is_extra()
4089 {
4090 result.push(cursor.node());
4091 }
4092 if !cursor.goto_next_sibling() {
4093 break;
4094 }
4095 }
4096 }
4097 result
4098 };
4099 let child = if let Some(&c) = non_field_children.first() {
4100 c
4101 } else {
4102 let mut fallback_cursor = node.walk();
4103 let mut fallback_child = None;
4104 if fallback_cursor.goto_first_child() {
4105 loop {
4106 if fallback_cursor.field_name().is_none()
4107 && !fallback_cursor.node().is_extra()
4108 {
4109 let candidate = fallback_cursor.node();
4110 #[allow(clippy::needless_question_mark)]
4111 if (|| -> ::core::result::Result<
4112 _,
4113 ::treesitter_types::ParseError,
4114 > {
4115 let child = candidate;
4116 Ok(
4117 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
4118 child,
4119 src,
4120 ))?,
4121 )
4122 })()
4123 .is_ok()
4124 {
4125 fallback_child = Some(candidate);
4126 break;
4127 }
4128 }
4129 if !fallback_cursor.goto_next_sibling() {
4130 break;
4131 }
4132 }
4133 }
4134 if fallback_child.is_none() {
4135 let mut cursor2 = node.walk();
4136 if cursor2.goto_first_child() {
4137 loop {
4138 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4139 let candidate = cursor2.node();
4140 #[allow(clippy::needless_question_mark)]
4141 if (|| -> ::core::result::Result<
4142 _,
4143 ::treesitter_types::ParseError,
4144 > {
4145 let child = candidate;
4146 Ok(
4147 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
4148 child,
4149 src,
4150 ))?,
4151 )
4152 })()
4153 .is_ok()
4154 {
4155 fallback_child = Some(candidate);
4156 break;
4157 }
4158 }
4159 if !cursor2.goto_next_sibling() {
4160 break;
4161 }
4162 }
4163 }
4164 }
4165 fallback_child.ok_or_else(|| {
4166 ::treesitter_types::ParseError::missing_field("children", node)
4167 })?
4168 };
4169 ::treesitter_types::runtime::maybe_grow_stack(|| {
4170 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
4171 })?
4172 },
4173 })
4174 }
4175}
4176impl ::treesitter_types::Spanned for MsBasedModifier<'_> {
4177 fn span(&self) -> ::treesitter_types::Span {
4178 self.span
4179 }
4180}
4181#[derive(Debug, Clone, PartialEq, Eq)]
4182pub struct MsCallModifier<'tree> {
4183 pub span: ::treesitter_types::Span,
4184 text: &'tree str,
4185}
4186impl<'tree> ::treesitter_types::FromNode<'tree> for MsCallModifier<'tree> {
4187 fn from_node(
4188 node: ::treesitter_types::tree_sitter::Node<'tree>,
4189 src: &'tree [u8],
4190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4191 debug_assert_eq!(node.kind(), "ms_call_modifier");
4192 Ok(Self {
4193 span: ::treesitter_types::Span::from(node),
4194 text: node.utf8_text(src)?,
4195 })
4196 }
4197}
4198impl<'tree> ::treesitter_types::LeafNode<'tree> for MsCallModifier<'tree> {
4199 fn text(&self) -> &'tree str {
4200 self.text
4201 }
4202}
4203impl ::treesitter_types::Spanned for MsCallModifier<'_> {
4204 fn span(&self) -> ::treesitter_types::Span {
4205 self.span
4206 }
4207}
4208#[derive(Debug, Clone, PartialEq, Eq)]
4209pub struct MsDeclspecModifier<'tree> {
4210 pub span: ::treesitter_types::Span,
4211 pub children: Identifier<'tree>,
4212}
4213impl<'tree> ::treesitter_types::FromNode<'tree> for MsDeclspecModifier<'tree> {
4214 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4215 fn from_node(
4216 node: ::treesitter_types::tree_sitter::Node<'tree>,
4217 src: &'tree [u8],
4218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4219 debug_assert_eq!(node.kind(), "ms_declspec_modifier");
4220 Ok(Self {
4221 span: ::treesitter_types::Span::from(node),
4222 children: {
4223 #[allow(clippy::suspicious_else_formatting)]
4224 let non_field_children = {
4225 let mut cursor = node.walk();
4226 let mut result = ::std::vec::Vec::new();
4227 if cursor.goto_first_child() {
4228 loop {
4229 if cursor.field_name().is_none()
4230 && cursor.node().is_named()
4231 && !cursor.node().is_extra()
4232 {
4233 result.push(cursor.node());
4234 }
4235 if !cursor.goto_next_sibling() {
4236 break;
4237 }
4238 }
4239 }
4240 result
4241 };
4242 let child = if let Some(&c) = non_field_children.first() {
4243 c
4244 } else {
4245 let mut fallback_cursor = node.walk();
4246 let mut fallback_child = None;
4247 if fallback_cursor.goto_first_child() {
4248 loop {
4249 if fallback_cursor.field_name().is_none()
4250 && !fallback_cursor.node().is_extra()
4251 {
4252 let candidate = fallback_cursor.node();
4253 #[allow(clippy::needless_question_mark)]
4254 if (|| -> ::core::result::Result<
4255 _,
4256 ::treesitter_types::ParseError,
4257 > {
4258 let child = candidate;
4259 Ok(
4260 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
4261 child,
4262 src,
4263 ))?,
4264 )
4265 })()
4266 .is_ok()
4267 {
4268 fallback_child = Some(candidate);
4269 break;
4270 }
4271 }
4272 if !fallback_cursor.goto_next_sibling() {
4273 break;
4274 }
4275 }
4276 }
4277 if fallback_child.is_none() {
4278 let mut cursor2 = node.walk();
4279 if cursor2.goto_first_child() {
4280 loop {
4281 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4282 let candidate = cursor2.node();
4283 #[allow(clippy::needless_question_mark)]
4284 if (|| -> ::core::result::Result<
4285 _,
4286 ::treesitter_types::ParseError,
4287 > {
4288 let child = candidate;
4289 Ok(
4290 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
4291 child,
4292 src,
4293 ))?,
4294 )
4295 })()
4296 .is_ok()
4297 {
4298 fallback_child = Some(candidate);
4299 break;
4300 }
4301 }
4302 if !cursor2.goto_next_sibling() {
4303 break;
4304 }
4305 }
4306 }
4307 }
4308 fallback_child.ok_or_else(|| {
4309 ::treesitter_types::ParseError::missing_field("children", node)
4310 })?
4311 };
4312 ::treesitter_types::runtime::maybe_grow_stack(|| {
4313 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4314 })?
4315 },
4316 })
4317 }
4318}
4319impl ::treesitter_types::Spanned for MsDeclspecModifier<'_> {
4320 fn span(&self) -> ::treesitter_types::Span {
4321 self.span
4322 }
4323}
4324#[derive(Debug, Clone, PartialEq, Eq)]
4325pub struct MsPointerModifier<'tree> {
4326 pub span: ::treesitter_types::Span,
4327 pub children: MsPointerModifierChildren<'tree>,
4328}
4329impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifier<'tree> {
4330 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4331 fn from_node(
4332 node: ::treesitter_types::tree_sitter::Node<'tree>,
4333 src: &'tree [u8],
4334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4335 debug_assert_eq!(node.kind(), "ms_pointer_modifier");
4336 Ok(Self {
4337 span: ::treesitter_types::Span::from(node),
4338 children: {
4339 #[allow(clippy::suspicious_else_formatting)]
4340 let non_field_children = {
4341 let mut cursor = node.walk();
4342 let mut result = ::std::vec::Vec::new();
4343 if cursor.goto_first_child() {
4344 loop {
4345 if cursor.field_name().is_none()
4346 && cursor.node().is_named()
4347 && !cursor.node().is_extra()
4348 {
4349 result.push(cursor.node());
4350 }
4351 if !cursor.goto_next_sibling() {
4352 break;
4353 }
4354 }
4355 }
4356 result
4357 };
4358 let child = if let Some(&c) = non_field_children.first() {
4359 c
4360 } else {
4361 let mut fallback_cursor = node.walk();
4362 let mut fallback_child = None;
4363 if fallback_cursor.goto_first_child() {
4364 loop {
4365 if fallback_cursor.field_name().is_none()
4366 && !fallback_cursor.node().is_extra()
4367 {
4368 let candidate = fallback_cursor.node();
4369 #[allow(clippy::needless_question_mark)]
4370 if (|| -> ::core::result::Result<
4371 _,
4372 ::treesitter_types::ParseError,
4373 > {
4374 let child = candidate;
4375 Ok(
4376 ::treesitter_types::runtime::maybe_grow_stack(|| <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
4377 child,
4378 src,
4379 ))?,
4380 )
4381 })()
4382 .is_ok()
4383 {
4384 fallback_child = Some(candidate);
4385 break;
4386 }
4387 }
4388 if !fallback_cursor.goto_next_sibling() {
4389 break;
4390 }
4391 }
4392 }
4393 if fallback_child.is_none() {
4394 let mut cursor2 = node.walk();
4395 if cursor2.goto_first_child() {
4396 loop {
4397 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4398 let candidate = cursor2.node();
4399 #[allow(clippy::needless_question_mark)]
4400 if (|| -> ::core::result::Result<
4401 _,
4402 ::treesitter_types::ParseError,
4403 > {
4404 let child = candidate;
4405 Ok(
4406 ::treesitter_types::runtime::maybe_grow_stack(|| <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
4407 child,
4408 src,
4409 ))?,
4410 )
4411 })()
4412 .is_ok()
4413 {
4414 fallback_child = Some(candidate);
4415 break;
4416 }
4417 }
4418 if !cursor2.goto_next_sibling() {
4419 break;
4420 }
4421 }
4422 }
4423 }
4424 fallback_child.ok_or_else(|| {
4425 ::treesitter_types::ParseError::missing_field("children", node)
4426 })?
4427 };
4428 ::treesitter_types::runtime::maybe_grow_stack(|| {
4429 <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
4430 child, src,
4431 )
4432 })?
4433 },
4434 })
4435 }
4436}
4437impl ::treesitter_types::Spanned for MsPointerModifier<'_> {
4438 fn span(&self) -> ::treesitter_types::Span {
4439 self.span
4440 }
4441}
4442#[derive(Debug, Clone, PartialEq, Eq)]
4443pub struct MsUnalignedPtrModifier<'tree> {
4444 pub span: ::treesitter_types::Span,
4445 text: &'tree str,
4446}
4447impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnalignedPtrModifier<'tree> {
4448 fn from_node(
4449 node: ::treesitter_types::tree_sitter::Node<'tree>,
4450 src: &'tree [u8],
4451 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4452 debug_assert_eq!(node.kind(), "ms_unaligned_ptr_modifier");
4453 Ok(Self {
4454 span: ::treesitter_types::Span::from(node),
4455 text: node.utf8_text(src)?,
4456 })
4457 }
4458}
4459impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnalignedPtrModifier<'tree> {
4460 fn text(&self) -> &'tree str {
4461 self.text
4462 }
4463}
4464impl ::treesitter_types::Spanned for MsUnalignedPtrModifier<'_> {
4465 fn span(&self) -> ::treesitter_types::Span {
4466 self.span
4467 }
4468}
4469#[derive(Debug, Clone, PartialEq, Eq)]
4470pub struct Null<'tree> {
4471 pub span: ::treesitter_types::Span,
4472 text: &'tree str,
4473}
4474impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
4475 fn from_node(
4476 node: ::treesitter_types::tree_sitter::Node<'tree>,
4477 src: &'tree [u8],
4478 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4479 debug_assert_eq!(node.kind(), "null");
4480 Ok(Self {
4481 span: ::treesitter_types::Span::from(node),
4482 text: node.utf8_text(src)?,
4483 })
4484 }
4485}
4486impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
4487 fn text(&self) -> &'tree str {
4488 self.text
4489 }
4490}
4491impl ::treesitter_types::Spanned for Null<'_> {
4492 fn span(&self) -> ::treesitter_types::Span {
4493 self.span
4494 }
4495}
4496#[derive(Debug, Clone, PartialEq, Eq)]
4497pub struct OffsetofExpression<'tree> {
4498 pub span: ::treesitter_types::Span,
4499 pub member: FieldIdentifier<'tree>,
4500 pub r#type: TypeDescriptor<'tree>,
4501}
4502impl<'tree> ::treesitter_types::FromNode<'tree> for OffsetofExpression<'tree> {
4503 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4504 fn from_node(
4505 node: ::treesitter_types::tree_sitter::Node<'tree>,
4506 src: &'tree [u8],
4507 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4508 debug_assert_eq!(node.kind(), "offsetof_expression");
4509 Ok(Self {
4510 span: ::treesitter_types::Span::from(node),
4511 member: {
4512 let child = node
4513 .child_by_field_name("member")
4514 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("member", node))?;
4515 ::treesitter_types::runtime::maybe_grow_stack(|| {
4516 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4517 })?
4518 },
4519 r#type: {
4520 let child = node
4521 .child_by_field_name("type")
4522 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4523 ::treesitter_types::runtime::maybe_grow_stack(|| {
4524 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
4525 })?
4526 },
4527 })
4528 }
4529}
4530impl ::treesitter_types::Spanned for OffsetofExpression<'_> {
4531 fn span(&self) -> ::treesitter_types::Span {
4532 self.span
4533 }
4534}
4535#[derive(Debug, Clone, PartialEq, Eq)]
4536pub struct ParameterDeclaration<'tree> {
4537 pub span: ::treesitter_types::Span,
4538 pub declarator: ::core::option::Option<ParameterDeclarationDeclarator<'tree>>,
4539 pub r#type: TypeSpecifier<'tree>,
4540 pub children: ::std::vec::Vec<ParameterDeclarationChildren<'tree>>,
4541}
4542impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclaration<'tree> {
4543 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4544 fn from_node(
4545 node: ::treesitter_types::tree_sitter::Node<'tree>,
4546 src: &'tree [u8],
4547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4548 debug_assert_eq!(node.kind(), "parameter_declaration");
4549 Ok(Self {
4550 span: ::treesitter_types::Span::from(node),
4551 declarator: match node.child_by_field_name("declarator") {
4552 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4553 <ParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
4554 child, src,
4555 )
4556 })?),
4557 None => None,
4558 },
4559 r#type: {
4560 let child = node
4561 .child_by_field_name("type")
4562 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4563 ::treesitter_types::runtime::maybe_grow_stack(|| {
4564 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
4565 })?
4566 },
4567 children: {
4568 #[allow(clippy::suspicious_else_formatting)]
4569 let non_field_children = {
4570 let mut cursor = node.walk();
4571 let mut result = ::std::vec::Vec::new();
4572 if cursor.goto_first_child() {
4573 loop {
4574 if cursor.field_name().is_none()
4575 && cursor.node().is_named()
4576 && !cursor.node().is_extra()
4577 {
4578 result.push(cursor.node());
4579 }
4580 if !cursor.goto_next_sibling() {
4581 break;
4582 }
4583 }
4584 }
4585 result
4586 };
4587 let mut items = ::std::vec::Vec::new();
4588 for child in non_field_children {
4589 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4590 <ParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4591 child, src,
4592 )
4593 })?);
4594 }
4595 items
4596 },
4597 })
4598 }
4599}
4600impl ::treesitter_types::Spanned for ParameterDeclaration<'_> {
4601 fn span(&self) -> ::treesitter_types::Span {
4602 self.span
4603 }
4604}
4605#[derive(Debug, Clone, PartialEq, Eq)]
4606pub struct ParameterList<'tree> {
4607 pub span: ::treesitter_types::Span,
4608 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
4609}
4610impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
4611 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4612 fn from_node(
4613 node: ::treesitter_types::tree_sitter::Node<'tree>,
4614 src: &'tree [u8],
4615 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4616 debug_assert_eq!(node.kind(), "parameter_list");
4617 Ok(Self {
4618 span: ::treesitter_types::Span::from(node),
4619 children: {
4620 #[allow(clippy::suspicious_else_formatting)]
4621 let non_field_children = {
4622 let mut cursor = node.walk();
4623 let mut result = ::std::vec::Vec::new();
4624 if cursor.goto_first_child() {
4625 loop {
4626 if cursor.field_name().is_none()
4627 && cursor.node().is_named()
4628 && !cursor.node().is_extra()
4629 {
4630 result.push(cursor.node());
4631 }
4632 if !cursor.goto_next_sibling() {
4633 break;
4634 }
4635 }
4636 }
4637 result
4638 };
4639 let mut items = ::std::vec::Vec::new();
4640 for child in non_field_children {
4641 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4642 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
4643 child, src,
4644 )
4645 })?);
4646 }
4647 items
4648 },
4649 })
4650 }
4651}
4652impl ::treesitter_types::Spanned for ParameterList<'_> {
4653 fn span(&self) -> ::treesitter_types::Span {
4654 self.span
4655 }
4656}
4657#[derive(Debug, Clone, PartialEq, Eq)]
4658pub struct ParenthesizedDeclarator<'tree> {
4659 pub span: ::treesitter_types::Span,
4660 pub children: ::std::vec::Vec<ParenthesizedDeclaratorChildren<'tree>>,
4661}
4662impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclarator<'tree> {
4663 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4664 fn from_node(
4665 node: ::treesitter_types::tree_sitter::Node<'tree>,
4666 src: &'tree [u8],
4667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4668 debug_assert_eq!(node.kind(), "parenthesized_declarator");
4669 Ok(Self {
4670 span: ::treesitter_types::Span::from(node),
4671 children: {
4672 #[allow(clippy::suspicious_else_formatting)]
4673 let non_field_children = {
4674 let mut cursor = node.walk();
4675 let mut result = ::std::vec::Vec::new();
4676 if cursor.goto_first_child() {
4677 loop {
4678 if cursor.field_name().is_none()
4679 && cursor.node().is_named()
4680 && !cursor.node().is_extra()
4681 {
4682 result.push(cursor.node());
4683 }
4684 if !cursor.goto_next_sibling() {
4685 break;
4686 }
4687 }
4688 }
4689 result
4690 };
4691 let mut items = ::std::vec::Vec::new();
4692 for child in non_field_children {
4693 items
4694 .push(
4695 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
4696 child,
4697 src,
4698 ))?,
4699 );
4700 }
4701 items
4702 },
4703 })
4704 }
4705}
4706impl ::treesitter_types::Spanned for ParenthesizedDeclarator<'_> {
4707 fn span(&self) -> ::treesitter_types::Span {
4708 self.span
4709 }
4710}
4711#[derive(Debug, Clone, PartialEq, Eq)]
4712pub struct ParenthesizedExpression<'tree> {
4713 pub span: ::treesitter_types::Span,
4714 pub children: ParenthesizedExpressionChildren<'tree>,
4715}
4716impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
4717 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4718 fn from_node(
4719 node: ::treesitter_types::tree_sitter::Node<'tree>,
4720 src: &'tree [u8],
4721 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4722 debug_assert_eq!(node.kind(), "parenthesized_expression");
4723 Ok(Self {
4724 span: ::treesitter_types::Span::from(node),
4725 children: {
4726 #[allow(clippy::suspicious_else_formatting)]
4727 let non_field_children = {
4728 let mut cursor = node.walk();
4729 let mut result = ::std::vec::Vec::new();
4730 if cursor.goto_first_child() {
4731 loop {
4732 if cursor.field_name().is_none()
4733 && cursor.node().is_named()
4734 && !cursor.node().is_extra()
4735 {
4736 result.push(cursor.node());
4737 }
4738 if !cursor.goto_next_sibling() {
4739 break;
4740 }
4741 }
4742 }
4743 result
4744 };
4745 let child = if let Some(&c) = non_field_children.first() {
4746 c
4747 } else {
4748 let mut fallback_cursor = node.walk();
4749 let mut fallback_child = None;
4750 if fallback_cursor.goto_first_child() {
4751 loop {
4752 if fallback_cursor.field_name().is_none()
4753 && !fallback_cursor.node().is_extra()
4754 {
4755 let candidate = fallback_cursor.node();
4756 #[allow(clippy::needless_question_mark)]
4757 if (|| -> ::core::result::Result<
4758 _,
4759 ::treesitter_types::ParseError,
4760 > {
4761 let child = candidate;
4762 Ok(
4763 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4764 child,
4765 src,
4766 ))?,
4767 )
4768 })()
4769 .is_ok()
4770 {
4771 fallback_child = Some(candidate);
4772 break;
4773 }
4774 }
4775 if !fallback_cursor.goto_next_sibling() {
4776 break;
4777 }
4778 }
4779 }
4780 if fallback_child.is_none() {
4781 let mut cursor2 = node.walk();
4782 if cursor2.goto_first_child() {
4783 loop {
4784 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4785 let candidate = cursor2.node();
4786 #[allow(clippy::needless_question_mark)]
4787 if (|| -> ::core::result::Result<
4788 _,
4789 ::treesitter_types::ParseError,
4790 > {
4791 let child = candidate;
4792 Ok(
4793 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4794 child,
4795 src,
4796 ))?,
4797 )
4798 })()
4799 .is_ok()
4800 {
4801 fallback_child = Some(candidate);
4802 break;
4803 }
4804 }
4805 if !cursor2.goto_next_sibling() {
4806 break;
4807 }
4808 }
4809 }
4810 }
4811 fallback_child.ok_or_else(|| {
4812 ::treesitter_types::ParseError::missing_field("children", node)
4813 })?
4814 };
4815 ::treesitter_types::runtime::maybe_grow_stack(|| {
4816 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
4817 child, src,
4818 )
4819 })?
4820 },
4821 })
4822 }
4823}
4824impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
4825 fn span(&self) -> ::treesitter_types::Span {
4826 self.span
4827 }
4828}
4829#[derive(Debug, Clone, PartialEq, Eq)]
4830pub struct PointerDeclarator<'tree> {
4831 pub span: ::treesitter_types::Span,
4832 pub declarator: PointerDeclaratorDeclarator<'tree>,
4833 pub children: ::std::vec::Vec<PointerDeclaratorChildren<'tree>>,
4834}
4835impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclarator<'tree> {
4836 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4837 fn from_node(
4838 node: ::treesitter_types::tree_sitter::Node<'tree>,
4839 src: &'tree [u8],
4840 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4841 debug_assert_eq!(node.kind(), "pointer_declarator");
4842 Ok(Self {
4843 span: ::treesitter_types::Span::from(node),
4844 declarator: {
4845 let child = node.child_by_field_name("declarator").ok_or_else(|| {
4846 ::treesitter_types::ParseError::missing_field("declarator", node)
4847 })?;
4848 ::treesitter_types::runtime::maybe_grow_stack(|| {
4849 <PointerDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
4850 child, src,
4851 )
4852 })?
4853 },
4854 children: {
4855 #[allow(clippy::suspicious_else_formatting)]
4856 let non_field_children = {
4857 let mut cursor = node.walk();
4858 let mut result = ::std::vec::Vec::new();
4859 if cursor.goto_first_child() {
4860 loop {
4861 if cursor.field_name().is_none()
4862 && cursor.node().is_named()
4863 && !cursor.node().is_extra()
4864 {
4865 result.push(cursor.node());
4866 }
4867 if !cursor.goto_next_sibling() {
4868 break;
4869 }
4870 }
4871 }
4872 result
4873 };
4874 let mut items = ::std::vec::Vec::new();
4875 for child in non_field_children {
4876 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4877 <PointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
4878 child, src,
4879 )
4880 })?);
4881 }
4882 items
4883 },
4884 })
4885 }
4886}
4887impl ::treesitter_types::Spanned for PointerDeclarator<'_> {
4888 fn span(&self) -> ::treesitter_types::Span {
4889 self.span
4890 }
4891}
4892#[derive(Debug, Clone, PartialEq, Eq)]
4893pub struct PointerExpression<'tree> {
4894 pub span: ::treesitter_types::Span,
4895 pub argument: Expression<'tree>,
4896 pub operator: PointerExpressionOperator,
4897}
4898impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpression<'tree> {
4899 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4900 fn from_node(
4901 node: ::treesitter_types::tree_sitter::Node<'tree>,
4902 src: &'tree [u8],
4903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4904 debug_assert_eq!(node.kind(), "pointer_expression");
4905 Ok(Self {
4906 span: ::treesitter_types::Span::from(node),
4907 argument: {
4908 let child = node.child_by_field_name("argument").ok_or_else(|| {
4909 ::treesitter_types::ParseError::missing_field("argument", node)
4910 })?;
4911 ::treesitter_types::runtime::maybe_grow_stack(|| {
4912 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4913 })?
4914 },
4915 operator: {
4916 let child = node.child_by_field_name("operator").ok_or_else(|| {
4917 ::treesitter_types::ParseError::missing_field("operator", node)
4918 })?;
4919 ::treesitter_types::runtime::maybe_grow_stack(|| {
4920 <PointerExpressionOperator as ::treesitter_types::FromNode>::from_node(
4921 child, src,
4922 )
4923 })?
4924 },
4925 })
4926 }
4927}
4928impl ::treesitter_types::Spanned for PointerExpression<'_> {
4929 fn span(&self) -> ::treesitter_types::Span {
4930 self.span
4931 }
4932}
4933#[derive(Debug, Clone, PartialEq, Eq)]
4934pub struct PreprocCall<'tree> {
4935 pub span: ::treesitter_types::Span,
4936 pub argument: ::core::option::Option<PreprocArg<'tree>>,
4937 pub directive: PreprocDirective<'tree>,
4938}
4939impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocCall<'tree> {
4940 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4941 fn from_node(
4942 node: ::treesitter_types::tree_sitter::Node<'tree>,
4943 src: &'tree [u8],
4944 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4945 debug_assert_eq!(node.kind(), "preproc_call");
4946 Ok(Self {
4947 span: ::treesitter_types::Span::from(node),
4948 argument: match node.child_by_field_name("argument") {
4949 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4950 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
4951 })?),
4952 None => None,
4953 },
4954 directive: {
4955 let child = node.child_by_field_name("directive").ok_or_else(|| {
4956 ::treesitter_types::ParseError::missing_field("directive", node)
4957 })?;
4958 ::treesitter_types::runtime::maybe_grow_stack(|| {
4959 <PreprocDirective as ::treesitter_types::FromNode>::from_node(child, src)
4960 })?
4961 },
4962 })
4963 }
4964}
4965impl ::treesitter_types::Spanned for PreprocCall<'_> {
4966 fn span(&self) -> ::treesitter_types::Span {
4967 self.span
4968 }
4969}
4970#[derive(Debug, Clone, PartialEq, Eq)]
4971pub struct PreprocDef<'tree> {
4972 pub span: ::treesitter_types::Span,
4973 pub name: Identifier<'tree>,
4974 pub value: ::core::option::Option<PreprocArg<'tree>>,
4975}
4976impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDef<'tree> {
4977 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4978 fn from_node(
4979 node: ::treesitter_types::tree_sitter::Node<'tree>,
4980 src: &'tree [u8],
4981 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4982 debug_assert_eq!(node.kind(), "preproc_def");
4983 Ok(Self {
4984 span: ::treesitter_types::Span::from(node),
4985 name: {
4986 let child = node
4987 .child_by_field_name("name")
4988 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4989 ::treesitter_types::runtime::maybe_grow_stack(|| {
4990 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4991 })?
4992 },
4993 value: match node.child_by_field_name("value") {
4994 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4995 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
4996 })?),
4997 None => None,
4998 },
4999 })
5000 }
5001}
5002impl ::treesitter_types::Spanned for PreprocDef<'_> {
5003 fn span(&self) -> ::treesitter_types::Span {
5004 self.span
5005 }
5006}
5007#[derive(Debug, Clone, PartialEq, Eq)]
5008pub struct PreprocDefined<'tree> {
5009 pub span: ::treesitter_types::Span,
5010 pub children: Identifier<'tree>,
5011}
5012impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefined<'tree> {
5013 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5014 fn from_node(
5015 node: ::treesitter_types::tree_sitter::Node<'tree>,
5016 src: &'tree [u8],
5017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5018 debug_assert_eq!(node.kind(), "preproc_defined");
5019 Ok(Self {
5020 span: ::treesitter_types::Span::from(node),
5021 children: {
5022 #[allow(clippy::suspicious_else_formatting)]
5023 let non_field_children = {
5024 let mut cursor = node.walk();
5025 let mut result = ::std::vec::Vec::new();
5026 if cursor.goto_first_child() {
5027 loop {
5028 if cursor.field_name().is_none()
5029 && cursor.node().is_named()
5030 && !cursor.node().is_extra()
5031 {
5032 result.push(cursor.node());
5033 }
5034 if !cursor.goto_next_sibling() {
5035 break;
5036 }
5037 }
5038 }
5039 result
5040 };
5041 let child = if let Some(&c) = non_field_children.first() {
5042 c
5043 } else {
5044 let mut fallback_cursor = node.walk();
5045 let mut fallback_child = None;
5046 if fallback_cursor.goto_first_child() {
5047 loop {
5048 if fallback_cursor.field_name().is_none()
5049 && !fallback_cursor.node().is_extra()
5050 {
5051 let candidate = fallback_cursor.node();
5052 #[allow(clippy::needless_question_mark)]
5053 if (|| -> ::core::result::Result<
5054 _,
5055 ::treesitter_types::ParseError,
5056 > {
5057 let child = candidate;
5058 Ok(
5059 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
5060 child,
5061 src,
5062 ))?,
5063 )
5064 })()
5065 .is_ok()
5066 {
5067 fallback_child = Some(candidate);
5068 break;
5069 }
5070 }
5071 if !fallback_cursor.goto_next_sibling() {
5072 break;
5073 }
5074 }
5075 }
5076 if fallback_child.is_none() {
5077 let mut cursor2 = node.walk();
5078 if cursor2.goto_first_child() {
5079 loop {
5080 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5081 let candidate = cursor2.node();
5082 #[allow(clippy::needless_question_mark)]
5083 if (|| -> ::core::result::Result<
5084 _,
5085 ::treesitter_types::ParseError,
5086 > {
5087 let child = candidate;
5088 Ok(
5089 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
5090 child,
5091 src,
5092 ))?,
5093 )
5094 })()
5095 .is_ok()
5096 {
5097 fallback_child = Some(candidate);
5098 break;
5099 }
5100 }
5101 if !cursor2.goto_next_sibling() {
5102 break;
5103 }
5104 }
5105 }
5106 }
5107 fallback_child.ok_or_else(|| {
5108 ::treesitter_types::ParseError::missing_field("children", node)
5109 })?
5110 };
5111 ::treesitter_types::runtime::maybe_grow_stack(|| {
5112 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5113 })?
5114 },
5115 })
5116 }
5117}
5118impl ::treesitter_types::Spanned for PreprocDefined<'_> {
5119 fn span(&self) -> ::treesitter_types::Span {
5120 self.span
5121 }
5122}
5123#[derive(Debug, Clone, PartialEq, Eq)]
5124pub struct PreprocElif<'tree> {
5125 pub span: ::treesitter_types::Span,
5126 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
5127 pub condition: PreprocElifCondition<'tree>,
5128 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
5129}
5130impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
5131 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5132 fn from_node(
5133 node: ::treesitter_types::tree_sitter::Node<'tree>,
5134 src: &'tree [u8],
5135 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5136 debug_assert_eq!(node.kind(), "preproc_elif");
5137 Ok(Self {
5138 span: ::treesitter_types::Span::from(node),
5139 alternative: match node.child_by_field_name("alternative") {
5140 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5141 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(child, src)
5142 })?),
5143 None => None,
5144 },
5145 condition: {
5146 let child = node.child_by_field_name("condition").ok_or_else(|| {
5147 ::treesitter_types::ParseError::missing_field("condition", node)
5148 })?;
5149 ::treesitter_types::runtime::maybe_grow_stack(|| {
5150 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)
5151 })?
5152 },
5153 children: {
5154 #[allow(clippy::suspicious_else_formatting)]
5155 let non_field_children = {
5156 let mut cursor = node.walk();
5157 let mut result = ::std::vec::Vec::new();
5158 if cursor.goto_first_child() {
5159 loop {
5160 if cursor.field_name().is_none()
5161 && cursor.node().is_named()
5162 && !cursor.node().is_extra()
5163 {
5164 result.push(cursor.node());
5165 }
5166 if !cursor.goto_next_sibling() {
5167 break;
5168 }
5169 }
5170 }
5171 result
5172 };
5173 let mut items = ::std::vec::Vec::new();
5174 for child in non_field_children {
5175 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5176 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(child, src)
5177 })?);
5178 }
5179 items
5180 },
5181 })
5182 }
5183}
5184impl ::treesitter_types::Spanned for PreprocElif<'_> {
5185 fn span(&self) -> ::treesitter_types::Span {
5186 self.span
5187 }
5188}
5189#[derive(Debug, Clone, PartialEq, Eq)]
5190pub struct PreprocElifdef<'tree> {
5191 pub span: ::treesitter_types::Span,
5192 pub alternative: ::core::option::Option<PreprocElifdefAlternative<'tree>>,
5193 pub name: Identifier<'tree>,
5194 pub children: ::std::vec::Vec<PreprocElifdefChildren<'tree>>,
5195}
5196impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdef<'tree> {
5197 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5198 fn from_node(
5199 node: ::treesitter_types::tree_sitter::Node<'tree>,
5200 src: &'tree [u8],
5201 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5202 debug_assert_eq!(node.kind(), "preproc_elifdef");
5203 Ok(Self {
5204 span: ::treesitter_types::Span::from(node),
5205 alternative: match node.child_by_field_name("alternative") {
5206 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5207 <PreprocElifdefAlternative as ::treesitter_types::FromNode>::from_node(
5208 child, src,
5209 )
5210 })?),
5211 None => None,
5212 },
5213 name: {
5214 let child = node
5215 .child_by_field_name("name")
5216 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5217 ::treesitter_types::runtime::maybe_grow_stack(|| {
5218 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5219 })?
5220 },
5221 children: {
5222 #[allow(clippy::suspicious_else_formatting)]
5223 let non_field_children = {
5224 let mut cursor = node.walk();
5225 let mut result = ::std::vec::Vec::new();
5226 if cursor.goto_first_child() {
5227 loop {
5228 if cursor.field_name().is_none()
5229 && cursor.node().is_named()
5230 && !cursor.node().is_extra()
5231 {
5232 result.push(cursor.node());
5233 }
5234 if !cursor.goto_next_sibling() {
5235 break;
5236 }
5237 }
5238 }
5239 result
5240 };
5241 let mut items = ::std::vec::Vec::new();
5242 for child in non_field_children {
5243 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5244 <PreprocElifdefChildren as ::treesitter_types::FromNode>::from_node(
5245 child, src,
5246 )
5247 })?);
5248 }
5249 items
5250 },
5251 })
5252 }
5253}
5254impl ::treesitter_types::Spanned for PreprocElifdef<'_> {
5255 fn span(&self) -> ::treesitter_types::Span {
5256 self.span
5257 }
5258}
5259#[derive(Debug, Clone, PartialEq, Eq)]
5260pub struct PreprocElse<'tree> {
5261 pub span: ::treesitter_types::Span,
5262 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
5263}
5264impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
5265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5266 fn from_node(
5267 node: ::treesitter_types::tree_sitter::Node<'tree>,
5268 src: &'tree [u8],
5269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5270 debug_assert_eq!(node.kind(), "preproc_else");
5271 Ok(Self {
5272 span: ::treesitter_types::Span::from(node),
5273 children: {
5274 #[allow(clippy::suspicious_else_formatting)]
5275 let non_field_children = {
5276 let mut cursor = node.walk();
5277 let mut result = ::std::vec::Vec::new();
5278 if cursor.goto_first_child() {
5279 loop {
5280 if cursor.field_name().is_none()
5281 && cursor.node().is_named()
5282 && !cursor.node().is_extra()
5283 {
5284 result.push(cursor.node());
5285 }
5286 if !cursor.goto_next_sibling() {
5287 break;
5288 }
5289 }
5290 }
5291 result
5292 };
5293 let mut items = ::std::vec::Vec::new();
5294 for child in non_field_children {
5295 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5296 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(child, src)
5297 })?);
5298 }
5299 items
5300 },
5301 })
5302 }
5303}
5304impl ::treesitter_types::Spanned for PreprocElse<'_> {
5305 fn span(&self) -> ::treesitter_types::Span {
5306 self.span
5307 }
5308}
5309#[derive(Debug, Clone, PartialEq, Eq)]
5310pub struct PreprocFunctionDef<'tree> {
5311 pub span: ::treesitter_types::Span,
5312 pub name: Identifier<'tree>,
5313 pub parameters: PreprocParams<'tree>,
5314 pub value: ::core::option::Option<PreprocArg<'tree>>,
5315}
5316impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocFunctionDef<'tree> {
5317 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5318 fn from_node(
5319 node: ::treesitter_types::tree_sitter::Node<'tree>,
5320 src: &'tree [u8],
5321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5322 debug_assert_eq!(node.kind(), "preproc_function_def");
5323 Ok(Self {
5324 span: ::treesitter_types::Span::from(node),
5325 name: {
5326 let child = node
5327 .child_by_field_name("name")
5328 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5329 ::treesitter_types::runtime::maybe_grow_stack(|| {
5330 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5331 })?
5332 },
5333 parameters: {
5334 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5335 ::treesitter_types::ParseError::missing_field("parameters", node)
5336 })?;
5337 ::treesitter_types::runtime::maybe_grow_stack(|| {
5338 <PreprocParams as ::treesitter_types::FromNode>::from_node(child, src)
5339 })?
5340 },
5341 value: match node.child_by_field_name("value") {
5342 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5343 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
5344 })?),
5345 None => None,
5346 },
5347 })
5348 }
5349}
5350impl ::treesitter_types::Spanned for PreprocFunctionDef<'_> {
5351 fn span(&self) -> ::treesitter_types::Span {
5352 self.span
5353 }
5354}
5355#[derive(Debug, Clone, PartialEq, Eq)]
5356pub struct PreprocIf<'tree> {
5357 pub span: ::treesitter_types::Span,
5358 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
5359 pub condition: PreprocIfCondition<'tree>,
5360 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
5361}
5362impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
5363 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5364 fn from_node(
5365 node: ::treesitter_types::tree_sitter::Node<'tree>,
5366 src: &'tree [u8],
5367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5368 debug_assert_eq!(node.kind(), "preproc_if");
5369 Ok(Self {
5370 span: ::treesitter_types::Span::from(node),
5371 alternative: match node.child_by_field_name("alternative") {
5372 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5373 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)
5374 })?),
5375 None => None,
5376 },
5377 condition: {
5378 let child = node.child_by_field_name("condition").ok_or_else(|| {
5379 ::treesitter_types::ParseError::missing_field("condition", node)
5380 })?;
5381 ::treesitter_types::runtime::maybe_grow_stack(|| {
5382 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)
5383 })?
5384 },
5385 children: {
5386 #[allow(clippy::suspicious_else_formatting)]
5387 let non_field_children = {
5388 let mut cursor = node.walk();
5389 let mut result = ::std::vec::Vec::new();
5390 if cursor.goto_first_child() {
5391 loop {
5392 if cursor.field_name().is_none()
5393 && cursor.node().is_named()
5394 && !cursor.node().is_extra()
5395 {
5396 result.push(cursor.node());
5397 }
5398 if !cursor.goto_next_sibling() {
5399 break;
5400 }
5401 }
5402 }
5403 result
5404 };
5405 let mut items = ::std::vec::Vec::new();
5406 for child in non_field_children {
5407 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5408 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)
5409 })?);
5410 }
5411 items
5412 },
5413 })
5414 }
5415}
5416impl ::treesitter_types::Spanned for PreprocIf<'_> {
5417 fn span(&self) -> ::treesitter_types::Span {
5418 self.span
5419 }
5420}
5421#[derive(Debug, Clone, PartialEq, Eq)]
5422pub struct PreprocIfdef<'tree> {
5423 pub span: ::treesitter_types::Span,
5424 pub alternative: ::core::option::Option<PreprocIfdefAlternative<'tree>>,
5425 pub name: Identifier<'tree>,
5426 pub children: ::std::vec::Vec<PreprocIfdefChildren<'tree>>,
5427}
5428impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdef<'tree> {
5429 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5430 fn from_node(
5431 node: ::treesitter_types::tree_sitter::Node<'tree>,
5432 src: &'tree [u8],
5433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5434 debug_assert_eq!(node.kind(), "preproc_ifdef");
5435 Ok(Self {
5436 span: ::treesitter_types::Span::from(node),
5437 alternative: match node.child_by_field_name("alternative") {
5438 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5439 <PreprocIfdefAlternative as ::treesitter_types::FromNode>::from_node(child, src)
5440 })?),
5441 None => None,
5442 },
5443 name: {
5444 let child = node
5445 .child_by_field_name("name")
5446 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5447 ::treesitter_types::runtime::maybe_grow_stack(|| {
5448 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5449 })?
5450 },
5451 children: {
5452 #[allow(clippy::suspicious_else_formatting)]
5453 let non_field_children = {
5454 let mut cursor = node.walk();
5455 let mut result = ::std::vec::Vec::new();
5456 if cursor.goto_first_child() {
5457 loop {
5458 if cursor.field_name().is_none()
5459 && cursor.node().is_named()
5460 && !cursor.node().is_extra()
5461 {
5462 result.push(cursor.node());
5463 }
5464 if !cursor.goto_next_sibling() {
5465 break;
5466 }
5467 }
5468 }
5469 result
5470 };
5471 let mut items = ::std::vec::Vec::new();
5472 for child in non_field_children {
5473 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5474 <PreprocIfdefChildren as ::treesitter_types::FromNode>::from_node(
5475 child, src,
5476 )
5477 })?);
5478 }
5479 items
5480 },
5481 })
5482 }
5483}
5484impl ::treesitter_types::Spanned for PreprocIfdef<'_> {
5485 fn span(&self) -> ::treesitter_types::Span {
5486 self.span
5487 }
5488}
5489#[derive(Debug, Clone, PartialEq, Eq)]
5490pub struct PreprocInclude<'tree> {
5491 pub span: ::treesitter_types::Span,
5492 pub path: PreprocIncludePath<'tree>,
5493}
5494impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocInclude<'tree> {
5495 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5496 fn from_node(
5497 node: ::treesitter_types::tree_sitter::Node<'tree>,
5498 src: &'tree [u8],
5499 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5500 debug_assert_eq!(node.kind(), "preproc_include");
5501 Ok(Self {
5502 span: ::treesitter_types::Span::from(node),
5503 path: {
5504 let child = node
5505 .child_by_field_name("path")
5506 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
5507 ::treesitter_types::runtime::maybe_grow_stack(|| {
5508 <PreprocIncludePath as ::treesitter_types::FromNode>::from_node(child, src)
5509 })?
5510 },
5511 })
5512 }
5513}
5514impl ::treesitter_types::Spanned for PreprocInclude<'_> {
5515 fn span(&self) -> ::treesitter_types::Span {
5516 self.span
5517 }
5518}
5519#[derive(Debug, Clone, PartialEq, Eq)]
5520pub struct PreprocParams<'tree> {
5521 pub span: ::treesitter_types::Span,
5522 pub children: ::std::vec::Vec<Identifier<'tree>>,
5523}
5524impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocParams<'tree> {
5525 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5526 fn from_node(
5527 node: ::treesitter_types::tree_sitter::Node<'tree>,
5528 src: &'tree [u8],
5529 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5530 debug_assert_eq!(node.kind(), "preproc_params");
5531 Ok(Self {
5532 span: ::treesitter_types::Span::from(node),
5533 children: {
5534 #[allow(clippy::suspicious_else_formatting)]
5535 let non_field_children = {
5536 let mut cursor = node.walk();
5537 let mut result = ::std::vec::Vec::new();
5538 if cursor.goto_first_child() {
5539 loop {
5540 if cursor.field_name().is_none()
5541 && cursor.node().is_named()
5542 && !cursor.node().is_extra()
5543 {
5544 result.push(cursor.node());
5545 }
5546 if !cursor.goto_next_sibling() {
5547 break;
5548 }
5549 }
5550 }
5551 result
5552 };
5553 let mut items = ::std::vec::Vec::new();
5554 for child in non_field_children {
5555 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5556 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5557 })?);
5558 }
5559 items
5560 },
5561 })
5562 }
5563}
5564impl ::treesitter_types::Spanned for PreprocParams<'_> {
5565 fn span(&self) -> ::treesitter_types::Span {
5566 self.span
5567 }
5568}
5569#[derive(Debug, Clone, PartialEq, Eq)]
5570pub struct ReturnStatement<'tree> {
5571 pub span: ::treesitter_types::Span,
5572 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
5573}
5574impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
5575 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5576 fn from_node(
5577 node: ::treesitter_types::tree_sitter::Node<'tree>,
5578 src: &'tree [u8],
5579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5580 debug_assert_eq!(node.kind(), "return_statement");
5581 Ok(Self {
5582 span: ::treesitter_types::Span::from(node),
5583 children: {
5584 #[allow(clippy::suspicious_else_formatting)]
5585 let non_field_children = {
5586 let mut cursor = node.walk();
5587 let mut result = ::std::vec::Vec::new();
5588 if cursor.goto_first_child() {
5589 loop {
5590 if cursor.field_name().is_none()
5591 && cursor.node().is_named()
5592 && !cursor.node().is_extra()
5593 {
5594 result.push(cursor.node());
5595 }
5596 if !cursor.goto_next_sibling() {
5597 break;
5598 }
5599 }
5600 }
5601 result
5602 };
5603 match non_field_children.first() {
5604 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5605 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
5606 child, src,
5607 )
5608 })?),
5609 None => None,
5610 }
5611 },
5612 })
5613 }
5614}
5615impl ::treesitter_types::Spanned for ReturnStatement<'_> {
5616 fn span(&self) -> ::treesitter_types::Span {
5617 self.span
5618 }
5619}
5620#[derive(Debug, Clone, PartialEq, Eq)]
5621pub struct SehExceptClause<'tree> {
5622 pub span: ::treesitter_types::Span,
5623 pub body: CompoundStatement<'tree>,
5624 pub filter: ParenthesizedExpression<'tree>,
5625}
5626impl<'tree> ::treesitter_types::FromNode<'tree> for SehExceptClause<'tree> {
5627 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5628 fn from_node(
5629 node: ::treesitter_types::tree_sitter::Node<'tree>,
5630 src: &'tree [u8],
5631 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5632 debug_assert_eq!(node.kind(), "seh_except_clause");
5633 Ok(Self {
5634 span: ::treesitter_types::Span::from(node),
5635 body: {
5636 let child = node
5637 .child_by_field_name("body")
5638 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5639 ::treesitter_types::runtime::maybe_grow_stack(|| {
5640 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
5641 })?
5642 },
5643 filter: {
5644 let child = node
5645 .child_by_field_name("filter")
5646 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("filter", node))?;
5647 ::treesitter_types::runtime::maybe_grow_stack(|| {
5648 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
5649 })?
5650 },
5651 })
5652 }
5653}
5654impl ::treesitter_types::Spanned for SehExceptClause<'_> {
5655 fn span(&self) -> ::treesitter_types::Span {
5656 self.span
5657 }
5658}
5659#[derive(Debug, Clone, PartialEq, Eq)]
5660pub struct SehFinallyClause<'tree> {
5661 pub span: ::treesitter_types::Span,
5662 pub body: CompoundStatement<'tree>,
5663}
5664impl<'tree> ::treesitter_types::FromNode<'tree> for SehFinallyClause<'tree> {
5665 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5666 fn from_node(
5667 node: ::treesitter_types::tree_sitter::Node<'tree>,
5668 src: &'tree [u8],
5669 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5670 debug_assert_eq!(node.kind(), "seh_finally_clause");
5671 Ok(Self {
5672 span: ::treesitter_types::Span::from(node),
5673 body: {
5674 let child = node
5675 .child_by_field_name("body")
5676 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5677 ::treesitter_types::runtime::maybe_grow_stack(|| {
5678 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
5679 })?
5680 },
5681 })
5682 }
5683}
5684impl ::treesitter_types::Spanned for SehFinallyClause<'_> {
5685 fn span(&self) -> ::treesitter_types::Span {
5686 self.span
5687 }
5688}
5689#[derive(Debug, Clone, PartialEq, Eq)]
5690pub struct SehLeaveStatement<'tree> {
5691 pub span: ::treesitter_types::Span,
5692 text: &'tree str,
5693}
5694impl<'tree> ::treesitter_types::FromNode<'tree> for SehLeaveStatement<'tree> {
5695 fn from_node(
5696 node: ::treesitter_types::tree_sitter::Node<'tree>,
5697 src: &'tree [u8],
5698 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5699 debug_assert_eq!(node.kind(), "seh_leave_statement");
5700 Ok(Self {
5701 span: ::treesitter_types::Span::from(node),
5702 text: node.utf8_text(src)?,
5703 })
5704 }
5705}
5706impl<'tree> ::treesitter_types::LeafNode<'tree> for SehLeaveStatement<'tree> {
5707 fn text(&self) -> &'tree str {
5708 self.text
5709 }
5710}
5711impl ::treesitter_types::Spanned for SehLeaveStatement<'_> {
5712 fn span(&self) -> ::treesitter_types::Span {
5713 self.span
5714 }
5715}
5716#[derive(Debug, Clone, PartialEq, Eq)]
5717pub struct SehTryStatement<'tree> {
5718 pub span: ::treesitter_types::Span,
5719 pub body: CompoundStatement<'tree>,
5720 pub children: SehTryStatementChildren<'tree>,
5721}
5722impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatement<'tree> {
5723 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5724 fn from_node(
5725 node: ::treesitter_types::tree_sitter::Node<'tree>,
5726 src: &'tree [u8],
5727 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5728 debug_assert_eq!(node.kind(), "seh_try_statement");
5729 Ok(Self {
5730 span: ::treesitter_types::Span::from(node),
5731 body: {
5732 let child = node
5733 .child_by_field_name("body")
5734 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5735 ::treesitter_types::runtime::maybe_grow_stack(|| {
5736 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
5737 })?
5738 },
5739 children: {
5740 #[allow(clippy::suspicious_else_formatting)]
5741 let non_field_children = {
5742 let mut cursor = node.walk();
5743 let mut result = ::std::vec::Vec::new();
5744 if cursor.goto_first_child() {
5745 loop {
5746 if cursor.field_name().is_none()
5747 && cursor.node().is_named()
5748 && !cursor.node().is_extra()
5749 {
5750 result.push(cursor.node());
5751 }
5752 if !cursor.goto_next_sibling() {
5753 break;
5754 }
5755 }
5756 }
5757 result
5758 };
5759 let child = if let Some(&c) = non_field_children.first() {
5760 c
5761 } else {
5762 let mut fallback_cursor = node.walk();
5763 let mut fallback_child = None;
5764 if fallback_cursor.goto_first_child() {
5765 loop {
5766 if fallback_cursor.field_name().is_none()
5767 && !fallback_cursor.node().is_extra()
5768 {
5769 let candidate = fallback_cursor.node();
5770 #[allow(clippy::needless_question_mark)]
5771 if (|| -> ::core::result::Result<
5772 _,
5773 ::treesitter_types::ParseError,
5774 > {
5775 let child = candidate;
5776 Ok(
5777 ::treesitter_types::runtime::maybe_grow_stack(|| <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
5778 child,
5779 src,
5780 ))?,
5781 )
5782 })()
5783 .is_ok()
5784 {
5785 fallback_child = Some(candidate);
5786 break;
5787 }
5788 }
5789 if !fallback_cursor.goto_next_sibling() {
5790 break;
5791 }
5792 }
5793 }
5794 if fallback_child.is_none() {
5795 let mut cursor2 = node.walk();
5796 if cursor2.goto_first_child() {
5797 loop {
5798 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5799 let candidate = cursor2.node();
5800 #[allow(clippy::needless_question_mark)]
5801 if (|| -> ::core::result::Result<
5802 _,
5803 ::treesitter_types::ParseError,
5804 > {
5805 let child = candidate;
5806 Ok(
5807 ::treesitter_types::runtime::maybe_grow_stack(|| <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
5808 child,
5809 src,
5810 ))?,
5811 )
5812 })()
5813 .is_ok()
5814 {
5815 fallback_child = Some(candidate);
5816 break;
5817 }
5818 }
5819 if !cursor2.goto_next_sibling() {
5820 break;
5821 }
5822 }
5823 }
5824 }
5825 fallback_child.ok_or_else(|| {
5826 ::treesitter_types::ParseError::missing_field("children", node)
5827 })?
5828 };
5829 ::treesitter_types::runtime::maybe_grow_stack(|| {
5830 <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
5831 })?
5832 },
5833 })
5834 }
5835}
5836impl ::treesitter_types::Spanned for SehTryStatement<'_> {
5837 fn span(&self) -> ::treesitter_types::Span {
5838 self.span
5839 }
5840}
5841#[derive(Debug, Clone, PartialEq, Eq)]
5842pub struct SizedTypeSpecifier<'tree> {
5843 pub span: ::treesitter_types::Span,
5844 pub r#type: ::core::option::Option<SizedTypeSpecifierType<'tree>>,
5845 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
5846}
5847impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifier<'tree> {
5848 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5849 fn from_node(
5850 node: ::treesitter_types::tree_sitter::Node<'tree>,
5851 src: &'tree [u8],
5852 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5853 debug_assert_eq!(node.kind(), "sized_type_specifier");
5854 Ok(Self {
5855 span: ::treesitter_types::Span::from(node),
5856 r#type: match node.child_by_field_name("type") {
5857 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5858 <SizedTypeSpecifierType as ::treesitter_types::FromNode>::from_node(child, src)
5859 })?),
5860 None => None,
5861 },
5862 children: {
5863 #[allow(clippy::suspicious_else_formatting)]
5864 let non_field_children = {
5865 let mut cursor = node.walk();
5866 let mut result = ::std::vec::Vec::new();
5867 if cursor.goto_first_child() {
5868 loop {
5869 if cursor.field_name().is_none()
5870 && cursor.node().is_named()
5871 && !cursor.node().is_extra()
5872 {
5873 result.push(cursor.node());
5874 }
5875 if !cursor.goto_next_sibling() {
5876 break;
5877 }
5878 }
5879 }
5880 result
5881 };
5882 let mut items = ::std::vec::Vec::new();
5883 for child in non_field_children {
5884 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5885 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
5886 })?);
5887 }
5888 items
5889 },
5890 })
5891 }
5892}
5893impl ::treesitter_types::Spanned for SizedTypeSpecifier<'_> {
5894 fn span(&self) -> ::treesitter_types::Span {
5895 self.span
5896 }
5897}
5898#[derive(Debug, Clone, PartialEq, Eq)]
5899pub struct SizeofExpression<'tree> {
5900 pub span: ::treesitter_types::Span,
5901 pub r#type: ::core::option::Option<TypeDescriptor<'tree>>,
5902 pub value: ::core::option::Option<Expression<'tree>>,
5903}
5904impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
5905 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5906 fn from_node(
5907 node: ::treesitter_types::tree_sitter::Node<'tree>,
5908 src: &'tree [u8],
5909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5910 debug_assert_eq!(node.kind(), "sizeof_expression");
5911 Ok(Self {
5912 span: ::treesitter_types::Span::from(node),
5913 r#type: match node.child_by_field_name("type") {
5914 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5915 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
5916 })?),
5917 None => None,
5918 },
5919 value: match node.child_by_field_name("value") {
5920 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5921 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5922 })?),
5923 None => None,
5924 },
5925 })
5926 }
5927}
5928impl ::treesitter_types::Spanned for SizeofExpression<'_> {
5929 fn span(&self) -> ::treesitter_types::Span {
5930 self.span
5931 }
5932}
5933#[derive(Debug, Clone, PartialEq, Eq)]
5934pub struct StorageClassSpecifier<'tree> {
5935 pub span: ::treesitter_types::Span,
5936 text: &'tree str,
5937}
5938impl<'tree> ::treesitter_types::FromNode<'tree> for StorageClassSpecifier<'tree> {
5939 fn from_node(
5940 node: ::treesitter_types::tree_sitter::Node<'tree>,
5941 src: &'tree [u8],
5942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5943 debug_assert_eq!(node.kind(), "storage_class_specifier");
5944 Ok(Self {
5945 span: ::treesitter_types::Span::from(node),
5946 text: node.utf8_text(src)?,
5947 })
5948 }
5949}
5950impl<'tree> ::treesitter_types::LeafNode<'tree> for StorageClassSpecifier<'tree> {
5951 fn text(&self) -> &'tree str {
5952 self.text
5953 }
5954}
5955impl ::treesitter_types::Spanned for StorageClassSpecifier<'_> {
5956 fn span(&self) -> ::treesitter_types::Span {
5957 self.span
5958 }
5959}
5960#[derive(Debug, Clone, PartialEq, Eq)]
5961pub struct StringLiteral<'tree> {
5962 pub span: ::treesitter_types::Span,
5963 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
5964}
5965impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
5966 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5967 fn from_node(
5968 node: ::treesitter_types::tree_sitter::Node<'tree>,
5969 src: &'tree [u8],
5970 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5971 debug_assert_eq!(node.kind(), "string_literal");
5972 Ok(Self {
5973 span: ::treesitter_types::Span::from(node),
5974 children: {
5975 #[allow(clippy::suspicious_else_formatting)]
5976 let non_field_children = {
5977 let mut cursor = node.walk();
5978 let mut result = ::std::vec::Vec::new();
5979 if cursor.goto_first_child() {
5980 loop {
5981 if cursor.field_name().is_none()
5982 && cursor.node().is_named()
5983 && !cursor.node().is_extra()
5984 {
5985 result.push(cursor.node());
5986 }
5987 if !cursor.goto_next_sibling() {
5988 break;
5989 }
5990 }
5991 }
5992 result
5993 };
5994 let mut items = ::std::vec::Vec::new();
5995 for child in non_field_children {
5996 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5997 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
5998 child, src,
5999 )
6000 })?);
6001 }
6002 items
6003 },
6004 })
6005 }
6006}
6007impl ::treesitter_types::Spanned for StringLiteral<'_> {
6008 fn span(&self) -> ::treesitter_types::Span {
6009 self.span
6010 }
6011}
6012#[derive(Debug, Clone, PartialEq, Eq)]
6013pub struct StructSpecifier<'tree> {
6014 pub span: ::treesitter_types::Span,
6015 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
6016 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
6017 pub children: ::std::vec::Vec<StructSpecifierChildren<'tree>>,
6018}
6019impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifier<'tree> {
6020 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6021 fn from_node(
6022 node: ::treesitter_types::tree_sitter::Node<'tree>,
6023 src: &'tree [u8],
6024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6025 debug_assert_eq!(node.kind(), "struct_specifier");
6026 Ok(Self {
6027 span: ::treesitter_types::Span::from(node),
6028 body: match node.child_by_field_name("body") {
6029 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6030 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
6031 })?),
6032 None => None,
6033 },
6034 name: match node.child_by_field_name("name") {
6035 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6036 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
6037 })?),
6038 None => None,
6039 },
6040 children: {
6041 #[allow(clippy::suspicious_else_formatting)]
6042 let non_field_children = {
6043 let mut cursor = node.walk();
6044 let mut result = ::std::vec::Vec::new();
6045 if cursor.goto_first_child() {
6046 loop {
6047 if cursor.field_name().is_none()
6048 && cursor.node().is_named()
6049 && !cursor.node().is_extra()
6050 {
6051 result.push(cursor.node());
6052 }
6053 if !cursor.goto_next_sibling() {
6054 break;
6055 }
6056 }
6057 }
6058 result
6059 };
6060 let mut items = ::std::vec::Vec::new();
6061 for child in non_field_children {
6062 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6063 <StructSpecifierChildren as ::treesitter_types::FromNode>::from_node(
6064 child, src,
6065 )
6066 })?);
6067 }
6068 items
6069 },
6070 })
6071 }
6072}
6073impl ::treesitter_types::Spanned for StructSpecifier<'_> {
6074 fn span(&self) -> ::treesitter_types::Span {
6075 self.span
6076 }
6077}
6078#[derive(Debug, Clone, PartialEq, Eq)]
6079pub struct SubscriptDesignator<'tree> {
6080 pub span: ::treesitter_types::Span,
6081 pub children: Expression<'tree>,
6082}
6083impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptDesignator<'tree> {
6084 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6085 fn from_node(
6086 node: ::treesitter_types::tree_sitter::Node<'tree>,
6087 src: &'tree [u8],
6088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6089 debug_assert_eq!(node.kind(), "subscript_designator");
6090 Ok(Self {
6091 span: ::treesitter_types::Span::from(node),
6092 children: {
6093 #[allow(clippy::suspicious_else_formatting)]
6094 let non_field_children = {
6095 let mut cursor = node.walk();
6096 let mut result = ::std::vec::Vec::new();
6097 if cursor.goto_first_child() {
6098 loop {
6099 if cursor.field_name().is_none()
6100 && cursor.node().is_named()
6101 && !cursor.node().is_extra()
6102 {
6103 result.push(cursor.node());
6104 }
6105 if !cursor.goto_next_sibling() {
6106 break;
6107 }
6108 }
6109 }
6110 result
6111 };
6112 let child = if let Some(&c) = non_field_children.first() {
6113 c
6114 } else {
6115 let mut fallback_cursor = node.walk();
6116 let mut fallback_child = None;
6117 if fallback_cursor.goto_first_child() {
6118 loop {
6119 if fallback_cursor.field_name().is_none()
6120 && !fallback_cursor.node().is_extra()
6121 {
6122 let candidate = fallback_cursor.node();
6123 #[allow(clippy::needless_question_mark)]
6124 if (|| -> ::core::result::Result<
6125 _,
6126 ::treesitter_types::ParseError,
6127 > {
6128 let child = candidate;
6129 Ok(
6130 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6131 child,
6132 src,
6133 ))?,
6134 )
6135 })()
6136 .is_ok()
6137 {
6138 fallback_child = Some(candidate);
6139 break;
6140 }
6141 }
6142 if !fallback_cursor.goto_next_sibling() {
6143 break;
6144 }
6145 }
6146 }
6147 if fallback_child.is_none() {
6148 let mut cursor2 = node.walk();
6149 if cursor2.goto_first_child() {
6150 loop {
6151 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6152 let candidate = cursor2.node();
6153 #[allow(clippy::needless_question_mark)]
6154 if (|| -> ::core::result::Result<
6155 _,
6156 ::treesitter_types::ParseError,
6157 > {
6158 let child = candidate;
6159 Ok(
6160 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6161 child,
6162 src,
6163 ))?,
6164 )
6165 })()
6166 .is_ok()
6167 {
6168 fallback_child = Some(candidate);
6169 break;
6170 }
6171 }
6172 if !cursor2.goto_next_sibling() {
6173 break;
6174 }
6175 }
6176 }
6177 }
6178 fallback_child.ok_or_else(|| {
6179 ::treesitter_types::ParseError::missing_field("children", node)
6180 })?
6181 };
6182 ::treesitter_types::runtime::maybe_grow_stack(|| {
6183 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6184 })?
6185 },
6186 })
6187 }
6188}
6189impl ::treesitter_types::Spanned for SubscriptDesignator<'_> {
6190 fn span(&self) -> ::treesitter_types::Span {
6191 self.span
6192 }
6193}
6194#[derive(Debug, Clone, PartialEq, Eq)]
6195pub struct SubscriptExpression<'tree> {
6196 pub span: ::treesitter_types::Span,
6197 pub argument: Expression<'tree>,
6198 pub index: Expression<'tree>,
6199}
6200impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
6201 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6202 fn from_node(
6203 node: ::treesitter_types::tree_sitter::Node<'tree>,
6204 src: &'tree [u8],
6205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6206 debug_assert_eq!(node.kind(), "subscript_expression");
6207 Ok(Self {
6208 span: ::treesitter_types::Span::from(node),
6209 argument: {
6210 let child = node.child_by_field_name("argument").ok_or_else(|| {
6211 ::treesitter_types::ParseError::missing_field("argument", node)
6212 })?;
6213 ::treesitter_types::runtime::maybe_grow_stack(|| {
6214 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6215 })?
6216 },
6217 index: {
6218 let child = node
6219 .child_by_field_name("index")
6220 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
6221 ::treesitter_types::runtime::maybe_grow_stack(|| {
6222 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6223 })?
6224 },
6225 })
6226 }
6227}
6228impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
6229 fn span(&self) -> ::treesitter_types::Span {
6230 self.span
6231 }
6232}
6233#[derive(Debug, Clone, PartialEq, Eq)]
6234pub struct SubscriptRangeDesignator<'tree> {
6235 pub span: ::treesitter_types::Span,
6236 pub end: Expression<'tree>,
6237 pub start: Expression<'tree>,
6238}
6239impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptRangeDesignator<'tree> {
6240 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6241 fn from_node(
6242 node: ::treesitter_types::tree_sitter::Node<'tree>,
6243 src: &'tree [u8],
6244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6245 debug_assert_eq!(node.kind(), "subscript_range_designator");
6246 Ok(Self {
6247 span: ::treesitter_types::Span::from(node),
6248 end: {
6249 let child = node
6250 .child_by_field_name("end")
6251 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("end", node))?;
6252 ::treesitter_types::runtime::maybe_grow_stack(|| {
6253 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6254 })?
6255 },
6256 start: {
6257 let child = node
6258 .child_by_field_name("start")
6259 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
6260 ::treesitter_types::runtime::maybe_grow_stack(|| {
6261 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6262 })?
6263 },
6264 })
6265 }
6266}
6267impl ::treesitter_types::Spanned for SubscriptRangeDesignator<'_> {
6268 fn span(&self) -> ::treesitter_types::Span {
6269 self.span
6270 }
6271}
6272#[derive(Debug, Clone, PartialEq, Eq)]
6273pub struct SwitchStatement<'tree> {
6274 pub span: ::treesitter_types::Span,
6275 pub body: CompoundStatement<'tree>,
6276 pub condition: ParenthesizedExpression<'tree>,
6277}
6278impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
6279 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
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(), "switch_statement");
6285 Ok(Self {
6286 span: ::treesitter_types::Span::from(node),
6287 body: {
6288 let child = node
6289 .child_by_field_name("body")
6290 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6291 ::treesitter_types::runtime::maybe_grow_stack(|| {
6292 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
6293 })?
6294 },
6295 condition: {
6296 let child = node.child_by_field_name("condition").ok_or_else(|| {
6297 ::treesitter_types::ParseError::missing_field("condition", node)
6298 })?;
6299 ::treesitter_types::runtime::maybe_grow_stack(|| {
6300 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
6301 })?
6302 },
6303 })
6304 }
6305}
6306impl ::treesitter_types::Spanned for SwitchStatement<'_> {
6307 fn span(&self) -> ::treesitter_types::Span {
6308 self.span
6309 }
6310}
6311#[derive(Debug, Clone, PartialEq, Eq)]
6312pub struct TranslationUnit<'tree> {
6313 pub span: ::treesitter_types::Span,
6314 pub children: ::std::vec::Vec<TranslationUnitChildren<'tree>>,
6315}
6316impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnit<'tree> {
6317 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6318 fn from_node(
6319 node: ::treesitter_types::tree_sitter::Node<'tree>,
6320 src: &'tree [u8],
6321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6322 debug_assert_eq!(node.kind(), "translation_unit");
6323 Ok(Self {
6324 span: ::treesitter_types::Span::from(node),
6325 children: {
6326 #[allow(clippy::suspicious_else_formatting)]
6327 let non_field_children = {
6328 let mut cursor = node.walk();
6329 let mut result = ::std::vec::Vec::new();
6330 if cursor.goto_first_child() {
6331 loop {
6332 if cursor.field_name().is_none()
6333 && cursor.node().is_named()
6334 && !cursor.node().is_extra()
6335 {
6336 result.push(cursor.node());
6337 }
6338 if !cursor.goto_next_sibling() {
6339 break;
6340 }
6341 }
6342 }
6343 result
6344 };
6345 let mut items = ::std::vec::Vec::new();
6346 for child in non_field_children {
6347 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6348 <TranslationUnitChildren as ::treesitter_types::FromNode>::from_node(
6349 child, src,
6350 )
6351 })?);
6352 }
6353 items
6354 },
6355 })
6356 }
6357}
6358impl ::treesitter_types::Spanned for TranslationUnit<'_> {
6359 fn span(&self) -> ::treesitter_types::Span {
6360 self.span
6361 }
6362}
6363#[derive(Debug, Clone, PartialEq, Eq)]
6364pub struct TypeDefinition<'tree> {
6365 pub span: ::treesitter_types::Span,
6366 pub declarator: ::std::vec::Vec<TypeDeclarator<'tree>>,
6367 pub r#type: TypeSpecifier<'tree>,
6368 pub children: ::std::vec::Vec<TypeDefinitionChildren<'tree>>,
6369}
6370impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinition<'tree> {
6371 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6372 fn from_node(
6373 node: ::treesitter_types::tree_sitter::Node<'tree>,
6374 src: &'tree [u8],
6375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6376 debug_assert_eq!(node.kind(), "type_definition");
6377 Ok(Self {
6378 span: ::treesitter_types::Span::from(node),
6379 declarator: {
6380 let mut cursor = node.walk();
6381 let mut items = ::std::vec::Vec::new();
6382 for child in node.children_by_field_name("declarator", &mut cursor) {
6383 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6384 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
6385 })?);
6386 }
6387 items
6388 },
6389 r#type: {
6390 let child = node
6391 .child_by_field_name("type")
6392 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6393 ::treesitter_types::runtime::maybe_grow_stack(|| {
6394 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
6395 })?
6396 },
6397 children: {
6398 #[allow(clippy::suspicious_else_formatting)]
6399 let non_field_children = {
6400 let mut cursor = node.walk();
6401 let mut result = ::std::vec::Vec::new();
6402 if cursor.goto_first_child() {
6403 loop {
6404 if cursor.field_name().is_none()
6405 && cursor.node().is_named()
6406 && !cursor.node().is_extra()
6407 {
6408 result.push(cursor.node());
6409 }
6410 if !cursor.goto_next_sibling() {
6411 break;
6412 }
6413 }
6414 }
6415 result
6416 };
6417 let mut items = ::std::vec::Vec::new();
6418 for child in non_field_children {
6419 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6420 <TypeDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6421 child, src,
6422 )
6423 })?);
6424 }
6425 items
6426 },
6427 })
6428 }
6429}
6430impl ::treesitter_types::Spanned for TypeDefinition<'_> {
6431 fn span(&self) -> ::treesitter_types::Span {
6432 self.span
6433 }
6434}
6435#[derive(Debug, Clone, PartialEq, Eq)]
6436pub struct TypeDescriptor<'tree> {
6437 pub span: ::treesitter_types::Span,
6438 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
6439 pub r#type: TypeSpecifier<'tree>,
6440 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
6441}
6442impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDescriptor<'tree> {
6443 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6444 fn from_node(
6445 node: ::treesitter_types::tree_sitter::Node<'tree>,
6446 src: &'tree [u8],
6447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6448 debug_assert_eq!(node.kind(), "type_descriptor");
6449 Ok(Self {
6450 span: ::treesitter_types::Span::from(node),
6451 declarator: match node.child_by_field_name("declarator") {
6452 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6453 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
6454 })?),
6455 None => None,
6456 },
6457 r#type: {
6458 let child = node
6459 .child_by_field_name("type")
6460 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6461 ::treesitter_types::runtime::maybe_grow_stack(|| {
6462 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
6463 })?
6464 },
6465 children: {
6466 #[allow(clippy::suspicious_else_formatting)]
6467 let non_field_children = {
6468 let mut cursor = node.walk();
6469 let mut result = ::std::vec::Vec::new();
6470 if cursor.goto_first_child() {
6471 loop {
6472 if cursor.field_name().is_none()
6473 && cursor.node().is_named()
6474 && !cursor.node().is_extra()
6475 {
6476 result.push(cursor.node());
6477 }
6478 if !cursor.goto_next_sibling() {
6479 break;
6480 }
6481 }
6482 }
6483 result
6484 };
6485 let mut items = ::std::vec::Vec::new();
6486 for child in non_field_children {
6487 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6488 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
6489 })?);
6490 }
6491 items
6492 },
6493 })
6494 }
6495}
6496impl ::treesitter_types::Spanned for TypeDescriptor<'_> {
6497 fn span(&self) -> ::treesitter_types::Span {
6498 self.span
6499 }
6500}
6501#[derive(Debug, Clone, PartialEq, Eq)]
6502pub struct TypeQualifier<'tree> {
6503 pub span: ::treesitter_types::Span,
6504 pub children: ::core::option::Option<AlignasQualifier<'tree>>,
6505}
6506impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQualifier<'tree> {
6507 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6508 fn from_node(
6509 node: ::treesitter_types::tree_sitter::Node<'tree>,
6510 src: &'tree [u8],
6511 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6512 debug_assert_eq!(node.kind(), "type_qualifier");
6513 Ok(Self {
6514 span: ::treesitter_types::Span::from(node),
6515 children: {
6516 #[allow(clippy::suspicious_else_formatting)]
6517 let non_field_children = {
6518 let mut cursor = node.walk();
6519 let mut result = ::std::vec::Vec::new();
6520 if cursor.goto_first_child() {
6521 loop {
6522 if cursor.field_name().is_none()
6523 && cursor.node().is_named()
6524 && !cursor.node().is_extra()
6525 {
6526 result.push(cursor.node());
6527 }
6528 if !cursor.goto_next_sibling() {
6529 break;
6530 }
6531 }
6532 }
6533 result
6534 };
6535 match non_field_children.first() {
6536 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6537 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(child, src)
6538 })?),
6539 None => None,
6540 }
6541 },
6542 })
6543 }
6544}
6545impl ::treesitter_types::Spanned for TypeQualifier<'_> {
6546 fn span(&self) -> ::treesitter_types::Span {
6547 self.span
6548 }
6549}
6550#[derive(Debug, Clone, PartialEq, Eq)]
6551pub struct UnaryExpression<'tree> {
6552 pub span: ::treesitter_types::Span,
6553 pub argument: UnaryExpressionArgument<'tree>,
6554 pub operator: UnaryExpressionOperator,
6555}
6556impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
6557 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6558 fn from_node(
6559 node: ::treesitter_types::tree_sitter::Node<'tree>,
6560 src: &'tree [u8],
6561 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6562 debug_assert_eq!(node.kind(), "unary_expression");
6563 Ok(Self {
6564 span: ::treesitter_types::Span::from(node),
6565 argument: {
6566 let child = node.child_by_field_name("argument").ok_or_else(|| {
6567 ::treesitter_types::ParseError::missing_field("argument", node)
6568 })?;
6569 ::treesitter_types::runtime::maybe_grow_stack(|| {
6570 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)
6571 })?
6572 },
6573 operator: {
6574 let child = node.child_by_field_name("operator").ok_or_else(|| {
6575 ::treesitter_types::ParseError::missing_field("operator", node)
6576 })?;
6577 ::treesitter_types::runtime::maybe_grow_stack(|| {
6578 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
6579 })?
6580 },
6581 })
6582 }
6583}
6584impl ::treesitter_types::Spanned for UnaryExpression<'_> {
6585 fn span(&self) -> ::treesitter_types::Span {
6586 self.span
6587 }
6588}
6589#[derive(Debug, Clone, PartialEq, Eq)]
6590pub struct UnionSpecifier<'tree> {
6591 pub span: ::treesitter_types::Span,
6592 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
6593 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
6594 pub children: ::std::vec::Vec<UnionSpecifierChildren<'tree>>,
6595}
6596impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifier<'tree> {
6597 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6598 fn from_node(
6599 node: ::treesitter_types::tree_sitter::Node<'tree>,
6600 src: &'tree [u8],
6601 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6602 debug_assert_eq!(node.kind(), "union_specifier");
6603 Ok(Self {
6604 span: ::treesitter_types::Span::from(node),
6605 body: match node.child_by_field_name("body") {
6606 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6607 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
6608 })?),
6609 None => None,
6610 },
6611 name: match node.child_by_field_name("name") {
6612 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6613 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
6614 })?),
6615 None => None,
6616 },
6617 children: {
6618 #[allow(clippy::suspicious_else_formatting)]
6619 let non_field_children = {
6620 let mut cursor = node.walk();
6621 let mut result = ::std::vec::Vec::new();
6622 if cursor.goto_first_child() {
6623 loop {
6624 if cursor.field_name().is_none()
6625 && cursor.node().is_named()
6626 && !cursor.node().is_extra()
6627 {
6628 result.push(cursor.node());
6629 }
6630 if !cursor.goto_next_sibling() {
6631 break;
6632 }
6633 }
6634 }
6635 result
6636 };
6637 let mut items = ::std::vec::Vec::new();
6638 for child in non_field_children {
6639 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6640 <UnionSpecifierChildren as ::treesitter_types::FromNode>::from_node(
6641 child, src,
6642 )
6643 })?);
6644 }
6645 items
6646 },
6647 })
6648 }
6649}
6650impl ::treesitter_types::Spanned for UnionSpecifier<'_> {
6651 fn span(&self) -> ::treesitter_types::Span {
6652 self.span
6653 }
6654}
6655#[derive(Debug, Clone, PartialEq, Eq)]
6656pub struct UpdateExpression<'tree> {
6657 pub span: ::treesitter_types::Span,
6658 pub argument: Expression<'tree>,
6659 pub operator: UpdateExpressionOperator,
6660}
6661impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
6662 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6663 fn from_node(
6664 node: ::treesitter_types::tree_sitter::Node<'tree>,
6665 src: &'tree [u8],
6666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6667 debug_assert_eq!(node.kind(), "update_expression");
6668 Ok(Self {
6669 span: ::treesitter_types::Span::from(node),
6670 argument: {
6671 let child = node.child_by_field_name("argument").ok_or_else(|| {
6672 ::treesitter_types::ParseError::missing_field("argument", node)
6673 })?;
6674 ::treesitter_types::runtime::maybe_grow_stack(|| {
6675 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6676 })?
6677 },
6678 operator: {
6679 let child = node.child_by_field_name("operator").ok_or_else(|| {
6680 ::treesitter_types::ParseError::missing_field("operator", node)
6681 })?;
6682 ::treesitter_types::runtime::maybe_grow_stack(|| {
6683 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(
6684 child, src,
6685 )
6686 })?
6687 },
6688 })
6689 }
6690}
6691impl ::treesitter_types::Spanned for UpdateExpression<'_> {
6692 fn span(&self) -> ::treesitter_types::Span {
6693 self.span
6694 }
6695}
6696#[derive(Debug, Clone, PartialEq, Eq)]
6697pub struct VariadicParameter<'tree> {
6698 pub span: ::treesitter_types::Span,
6699 text: &'tree str,
6700}
6701impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
6702 fn from_node(
6703 node: ::treesitter_types::tree_sitter::Node<'tree>,
6704 src: &'tree [u8],
6705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6706 debug_assert_eq!(node.kind(), "variadic_parameter");
6707 Ok(Self {
6708 span: ::treesitter_types::Span::from(node),
6709 text: node.utf8_text(src)?,
6710 })
6711 }
6712}
6713impl<'tree> ::treesitter_types::LeafNode<'tree> for VariadicParameter<'tree> {
6714 fn text(&self) -> &'tree str {
6715 self.text
6716 }
6717}
6718impl ::treesitter_types::Spanned for VariadicParameter<'_> {
6719 fn span(&self) -> ::treesitter_types::Span {
6720 self.span
6721 }
6722}
6723#[derive(Debug, Clone, PartialEq, Eq)]
6724pub struct WhileStatement<'tree> {
6725 pub span: ::treesitter_types::Span,
6726 pub body: Statement<'tree>,
6727 pub condition: ParenthesizedExpression<'tree>,
6728}
6729impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
6730 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6731 fn from_node(
6732 node: ::treesitter_types::tree_sitter::Node<'tree>,
6733 src: &'tree [u8],
6734 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6735 debug_assert_eq!(node.kind(), "while_statement");
6736 Ok(Self {
6737 span: ::treesitter_types::Span::from(node),
6738 body: {
6739 let child = node
6740 .child_by_field_name("body")
6741 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6742 ::treesitter_types::runtime::maybe_grow_stack(|| {
6743 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
6744 })?
6745 },
6746 condition: {
6747 let child = node.child_by_field_name("condition").ok_or_else(|| {
6748 ::treesitter_types::ParseError::missing_field("condition", node)
6749 })?;
6750 ::treesitter_types::runtime::maybe_grow_stack(|| {
6751 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
6752 })?
6753 },
6754 })
6755 }
6756}
6757impl ::treesitter_types::Spanned for WhileStatement<'_> {
6758 fn span(&self) -> ::treesitter_types::Span {
6759 self.span
6760 }
6761}
6762#[derive(Debug, Clone, PartialEq, Eq)]
6763pub struct Character<'tree> {
6764 pub span: ::treesitter_types::Span,
6765 text: &'tree str,
6766}
6767impl<'tree> ::treesitter_types::FromNode<'tree> for Character<'tree> {
6768 fn from_node(
6769 node: ::treesitter_types::tree_sitter::Node<'tree>,
6770 src: &'tree [u8],
6771 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6772 debug_assert_eq!(node.kind(), "character");
6773 Ok(Self {
6774 span: ::treesitter_types::Span::from(node),
6775 text: node.utf8_text(src)?,
6776 })
6777 }
6778}
6779impl<'tree> ::treesitter_types::LeafNode<'tree> for Character<'tree> {
6780 fn text(&self) -> &'tree str {
6781 self.text
6782 }
6783}
6784impl ::treesitter_types::Spanned for Character<'_> {
6785 fn span(&self) -> ::treesitter_types::Span {
6786 self.span
6787 }
6788}
6789#[derive(Debug, Clone, PartialEq, Eq)]
6790pub struct Comment<'tree> {
6791 pub span: ::treesitter_types::Span,
6792 text: &'tree str,
6793}
6794impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
6795 fn from_node(
6796 node: ::treesitter_types::tree_sitter::Node<'tree>,
6797 src: &'tree [u8],
6798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6799 debug_assert_eq!(node.kind(), "comment");
6800 Ok(Self {
6801 span: ::treesitter_types::Span::from(node),
6802 text: node.utf8_text(src)?,
6803 })
6804 }
6805}
6806impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
6807 fn text(&self) -> &'tree str {
6808 self.text
6809 }
6810}
6811impl ::treesitter_types::Spanned for Comment<'_> {
6812 fn span(&self) -> ::treesitter_types::Span {
6813 self.span
6814 }
6815}
6816#[derive(Debug, Clone, PartialEq, Eq)]
6817pub struct EscapeSequence<'tree> {
6818 pub span: ::treesitter_types::Span,
6819 text: &'tree str,
6820}
6821impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
6822 fn from_node(
6823 node: ::treesitter_types::tree_sitter::Node<'tree>,
6824 src: &'tree [u8],
6825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6826 debug_assert_eq!(node.kind(), "escape_sequence");
6827 Ok(Self {
6828 span: ::treesitter_types::Span::from(node),
6829 text: node.utf8_text(src)?,
6830 })
6831 }
6832}
6833impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
6834 fn text(&self) -> &'tree str {
6835 self.text
6836 }
6837}
6838impl ::treesitter_types::Spanned for EscapeSequence<'_> {
6839 fn span(&self) -> ::treesitter_types::Span {
6840 self.span
6841 }
6842}
6843#[derive(Debug, Clone, PartialEq, Eq)]
6844pub struct False<'tree> {
6845 pub span: ::treesitter_types::Span,
6846 text: &'tree str,
6847}
6848impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
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 debug_assert_eq!(node.kind(), "false");
6854 Ok(Self {
6855 span: ::treesitter_types::Span::from(node),
6856 text: node.utf8_text(src)?,
6857 })
6858 }
6859}
6860impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
6861 fn text(&self) -> &'tree str {
6862 self.text
6863 }
6864}
6865impl ::treesitter_types::Spanned for False<'_> {
6866 fn span(&self) -> ::treesitter_types::Span {
6867 self.span
6868 }
6869}
6870#[derive(Debug, Clone, PartialEq, Eq)]
6871pub struct FieldIdentifier<'tree> {
6872 pub span: ::treesitter_types::Span,
6873 text: &'tree str,
6874}
6875impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
6876 fn from_node(
6877 node: ::treesitter_types::tree_sitter::Node<'tree>,
6878 src: &'tree [u8],
6879 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6880 debug_assert_eq!(node.kind(), "field_identifier");
6881 Ok(Self {
6882 span: ::treesitter_types::Span::from(node),
6883 text: node.utf8_text(src)?,
6884 })
6885 }
6886}
6887impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
6888 fn text(&self) -> &'tree str {
6889 self.text
6890 }
6891}
6892impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
6893 fn span(&self) -> ::treesitter_types::Span {
6894 self.span
6895 }
6896}
6897#[derive(Debug, Clone, PartialEq, Eq)]
6898pub struct Identifier<'tree> {
6899 pub span: ::treesitter_types::Span,
6900 text: &'tree str,
6901}
6902impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
6903 fn from_node(
6904 node: ::treesitter_types::tree_sitter::Node<'tree>,
6905 src: &'tree [u8],
6906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6907 debug_assert_eq!(node.kind(), "identifier");
6908 Ok(Self {
6909 span: ::treesitter_types::Span::from(node),
6910 text: node.utf8_text(src)?,
6911 })
6912 }
6913}
6914impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
6915 fn text(&self) -> &'tree str {
6916 self.text
6917 }
6918}
6919impl ::treesitter_types::Spanned for Identifier<'_> {
6920 fn span(&self) -> ::treesitter_types::Span {
6921 self.span
6922 }
6923}
6924#[derive(Debug, Clone, PartialEq, Eq)]
6925pub struct MsRestrictModifier<'tree> {
6926 pub span: ::treesitter_types::Span,
6927 text: &'tree str,
6928}
6929impl<'tree> ::treesitter_types::FromNode<'tree> for MsRestrictModifier<'tree> {
6930 fn from_node(
6931 node: ::treesitter_types::tree_sitter::Node<'tree>,
6932 src: &'tree [u8],
6933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6934 debug_assert_eq!(node.kind(), "ms_restrict_modifier");
6935 Ok(Self {
6936 span: ::treesitter_types::Span::from(node),
6937 text: node.utf8_text(src)?,
6938 })
6939 }
6940}
6941impl<'tree> ::treesitter_types::LeafNode<'tree> for MsRestrictModifier<'tree> {
6942 fn text(&self) -> &'tree str {
6943 self.text
6944 }
6945}
6946impl ::treesitter_types::Spanned for MsRestrictModifier<'_> {
6947 fn span(&self) -> ::treesitter_types::Span {
6948 self.span
6949 }
6950}
6951#[derive(Debug, Clone, PartialEq, Eq)]
6952pub struct MsSignedPtrModifier<'tree> {
6953 pub span: ::treesitter_types::Span,
6954 text: &'tree str,
6955}
6956impl<'tree> ::treesitter_types::FromNode<'tree> for MsSignedPtrModifier<'tree> {
6957 fn from_node(
6958 node: ::treesitter_types::tree_sitter::Node<'tree>,
6959 src: &'tree [u8],
6960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6961 debug_assert_eq!(node.kind(), "ms_signed_ptr_modifier");
6962 Ok(Self {
6963 span: ::treesitter_types::Span::from(node),
6964 text: node.utf8_text(src)?,
6965 })
6966 }
6967}
6968impl<'tree> ::treesitter_types::LeafNode<'tree> for MsSignedPtrModifier<'tree> {
6969 fn text(&self) -> &'tree str {
6970 self.text
6971 }
6972}
6973impl ::treesitter_types::Spanned for MsSignedPtrModifier<'_> {
6974 fn span(&self) -> ::treesitter_types::Span {
6975 self.span
6976 }
6977}
6978#[derive(Debug, Clone, PartialEq, Eq)]
6979pub struct MsUnsignedPtrModifier<'tree> {
6980 pub span: ::treesitter_types::Span,
6981 text: &'tree str,
6982}
6983impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnsignedPtrModifier<'tree> {
6984 fn from_node(
6985 node: ::treesitter_types::tree_sitter::Node<'tree>,
6986 src: &'tree [u8],
6987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6988 debug_assert_eq!(node.kind(), "ms_unsigned_ptr_modifier");
6989 Ok(Self {
6990 span: ::treesitter_types::Span::from(node),
6991 text: node.utf8_text(src)?,
6992 })
6993 }
6994}
6995impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnsignedPtrModifier<'tree> {
6996 fn text(&self) -> &'tree str {
6997 self.text
6998 }
6999}
7000impl ::treesitter_types::Spanned for MsUnsignedPtrModifier<'_> {
7001 fn span(&self) -> ::treesitter_types::Span {
7002 self.span
7003 }
7004}
7005#[derive(Debug, Clone, PartialEq, Eq)]
7006pub struct NumberLiteral<'tree> {
7007 pub span: ::treesitter_types::Span,
7008 text: &'tree str,
7009}
7010impl<'tree> ::treesitter_types::FromNode<'tree> for NumberLiteral<'tree> {
7011 fn from_node(
7012 node: ::treesitter_types::tree_sitter::Node<'tree>,
7013 src: &'tree [u8],
7014 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7015 debug_assert_eq!(node.kind(), "number_literal");
7016 Ok(Self {
7017 span: ::treesitter_types::Span::from(node),
7018 text: node.utf8_text(src)?,
7019 })
7020 }
7021}
7022impl<'tree> ::treesitter_types::LeafNode<'tree> for NumberLiteral<'tree> {
7023 fn text(&self) -> &'tree str {
7024 self.text
7025 }
7026}
7027impl ::treesitter_types::Spanned for NumberLiteral<'_> {
7028 fn span(&self) -> ::treesitter_types::Span {
7029 self.span
7030 }
7031}
7032#[derive(Debug, Clone, PartialEq, Eq)]
7033pub struct PreprocArg<'tree> {
7034 pub span: ::treesitter_types::Span,
7035 text: &'tree str,
7036}
7037impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
7038 fn from_node(
7039 node: ::treesitter_types::tree_sitter::Node<'tree>,
7040 src: &'tree [u8],
7041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7042 debug_assert_eq!(node.kind(), "preproc_arg");
7043 Ok(Self {
7044 span: ::treesitter_types::Span::from(node),
7045 text: node.utf8_text(src)?,
7046 })
7047 }
7048}
7049impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
7050 fn text(&self) -> &'tree str {
7051 self.text
7052 }
7053}
7054impl ::treesitter_types::Spanned for PreprocArg<'_> {
7055 fn span(&self) -> ::treesitter_types::Span {
7056 self.span
7057 }
7058}
7059#[derive(Debug, Clone, PartialEq, Eq)]
7060pub struct PreprocDirective<'tree> {
7061 pub span: ::treesitter_types::Span,
7062 text: &'tree str,
7063}
7064impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDirective<'tree> {
7065 fn from_node(
7066 node: ::treesitter_types::tree_sitter::Node<'tree>,
7067 src: &'tree [u8],
7068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7069 debug_assert_eq!(node.kind(), "preproc_directive");
7070 Ok(Self {
7071 span: ::treesitter_types::Span::from(node),
7072 text: node.utf8_text(src)?,
7073 })
7074 }
7075}
7076impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocDirective<'tree> {
7077 fn text(&self) -> &'tree str {
7078 self.text
7079 }
7080}
7081impl ::treesitter_types::Spanned for PreprocDirective<'_> {
7082 fn span(&self) -> ::treesitter_types::Span {
7083 self.span
7084 }
7085}
7086#[derive(Debug, Clone, PartialEq, Eq)]
7087pub struct PrimitiveType<'tree> {
7088 pub span: ::treesitter_types::Span,
7089 text: &'tree str,
7090}
7091impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
7092 fn from_node(
7093 node: ::treesitter_types::tree_sitter::Node<'tree>,
7094 src: &'tree [u8],
7095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7096 debug_assert_eq!(node.kind(), "primitive_type");
7097 Ok(Self {
7098 span: ::treesitter_types::Span::from(node),
7099 text: node.utf8_text(src)?,
7100 })
7101 }
7102}
7103impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
7104 fn text(&self) -> &'tree str {
7105 self.text
7106 }
7107}
7108impl ::treesitter_types::Spanned for PrimitiveType<'_> {
7109 fn span(&self) -> ::treesitter_types::Span {
7110 self.span
7111 }
7112}
7113#[derive(Debug, Clone, PartialEq, Eq)]
7114pub struct StatementIdentifier<'tree> {
7115 pub span: ::treesitter_types::Span,
7116 text: &'tree str,
7117}
7118impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
7119 fn from_node(
7120 node: ::treesitter_types::tree_sitter::Node<'tree>,
7121 src: &'tree [u8],
7122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7123 debug_assert_eq!(node.kind(), "statement_identifier");
7124 Ok(Self {
7125 span: ::treesitter_types::Span::from(node),
7126 text: node.utf8_text(src)?,
7127 })
7128 }
7129}
7130impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
7131 fn text(&self) -> &'tree str {
7132 self.text
7133 }
7134}
7135impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
7136 fn span(&self) -> ::treesitter_types::Span {
7137 self.span
7138 }
7139}
7140#[derive(Debug, Clone, PartialEq, Eq)]
7141pub struct StringContent<'tree> {
7142 pub span: ::treesitter_types::Span,
7143 text: &'tree str,
7144}
7145impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
7146 fn from_node(
7147 node: ::treesitter_types::tree_sitter::Node<'tree>,
7148 src: &'tree [u8],
7149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7150 debug_assert_eq!(node.kind(), "string_content");
7151 Ok(Self {
7152 span: ::treesitter_types::Span::from(node),
7153 text: node.utf8_text(src)?,
7154 })
7155 }
7156}
7157impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
7158 fn text(&self) -> &'tree str {
7159 self.text
7160 }
7161}
7162impl ::treesitter_types::Spanned for StringContent<'_> {
7163 fn span(&self) -> ::treesitter_types::Span {
7164 self.span
7165 }
7166}
7167#[derive(Debug, Clone, PartialEq, Eq)]
7168pub struct SystemLibString<'tree> {
7169 pub span: ::treesitter_types::Span,
7170 text: &'tree str,
7171}
7172impl<'tree> ::treesitter_types::FromNode<'tree> for SystemLibString<'tree> {
7173 fn from_node(
7174 node: ::treesitter_types::tree_sitter::Node<'tree>,
7175 src: &'tree [u8],
7176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7177 debug_assert_eq!(node.kind(), "system_lib_string");
7178 Ok(Self {
7179 span: ::treesitter_types::Span::from(node),
7180 text: node.utf8_text(src)?,
7181 })
7182 }
7183}
7184impl<'tree> ::treesitter_types::LeafNode<'tree> for SystemLibString<'tree> {
7185 fn text(&self) -> &'tree str {
7186 self.text
7187 }
7188}
7189impl ::treesitter_types::Spanned for SystemLibString<'_> {
7190 fn span(&self) -> ::treesitter_types::Span {
7191 self.span
7192 }
7193}
7194#[derive(Debug, Clone, PartialEq, Eq)]
7195pub struct True<'tree> {
7196 pub span: ::treesitter_types::Span,
7197 text: &'tree str,
7198}
7199impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
7200 fn from_node(
7201 node: ::treesitter_types::tree_sitter::Node<'tree>,
7202 src: &'tree [u8],
7203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7204 debug_assert_eq!(node.kind(), "true");
7205 Ok(Self {
7206 span: ::treesitter_types::Span::from(node),
7207 text: node.utf8_text(src)?,
7208 })
7209 }
7210}
7211impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
7212 fn text(&self) -> &'tree str {
7213 self.text
7214 }
7215}
7216impl ::treesitter_types::Spanned for True<'_> {
7217 fn span(&self) -> ::treesitter_types::Span {
7218 self.span
7219 }
7220}
7221#[derive(Debug, Clone, PartialEq, Eq)]
7222pub struct TypeIdentifier<'tree> {
7223 pub span: ::treesitter_types::Span,
7224 text: &'tree str,
7225}
7226impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
7227 fn from_node(
7228 node: ::treesitter_types::tree_sitter::Node<'tree>,
7229 src: &'tree [u8],
7230 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7231 debug_assert_eq!(node.kind(), "type_identifier");
7232 Ok(Self {
7233 span: ::treesitter_types::Span::from(node),
7234 text: node.utf8_text(src)?,
7235 })
7236 }
7237}
7238impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
7239 fn text(&self) -> &'tree str {
7240 self.text
7241 }
7242}
7243impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
7244 fn span(&self) -> ::treesitter_types::Span {
7245 self.span
7246 }
7247}
7248#[derive(Debug, Clone, PartialEq, Eq)]
7249pub enum AbstractArrayDeclaratorSize<'tree> {
7250 Star(::treesitter_types::Span),
7251 Expression(::std::boxed::Box<Expression<'tree>>),
7252}
7253impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclaratorSize<'tree> {
7254 #[allow(clippy::collapsible_else_if)]
7255 fn from_node(
7256 node: ::treesitter_types::tree_sitter::Node<'tree>,
7257 src: &'tree [u8],
7258 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7259 match node.kind() {
7260 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7261 _other => {
7262 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7263 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7264 }) {
7265 Ok(Self::Expression(::std::boxed::Box::new(v)))
7266 } else {
7267 Err(::treesitter_types::ParseError::unexpected_kind(
7268 _other, node,
7269 ))
7270 }
7271 }
7272 }
7273 }
7274}
7275impl ::treesitter_types::Spanned for AbstractArrayDeclaratorSize<'_> {
7276 fn span(&self) -> ::treesitter_types::Span {
7277 match self {
7278 Self::Star(span) => *span,
7279 Self::Expression(inner) => inner.span(),
7280 }
7281 }
7282}
7283#[derive(Debug, Clone, PartialEq, Eq)]
7284pub enum AbstractParenthesizedDeclaratorChildren<'tree> {
7285 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
7286 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
7287}
7288impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclaratorChildren<'tree> {
7289 #[allow(clippy::collapsible_else_if)]
7290 fn from_node(
7291 node: ::treesitter_types::tree_sitter::Node<'tree>,
7292 src: &'tree [u8],
7293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7294 match node.kind() {
7295 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
7296 ::treesitter_types::runtime::maybe_grow_stack(|| {
7297 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
7298 })?,
7299 ))),
7300 _other => {
7301 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7302 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
7303 }) {
7304 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
7305 } else {
7306 Err(::treesitter_types::ParseError::unexpected_kind(
7307 _other, node,
7308 ))
7309 }
7310 }
7311 }
7312 }
7313}
7314impl ::treesitter_types::Spanned for AbstractParenthesizedDeclaratorChildren<'_> {
7315 fn span(&self) -> ::treesitter_types::Span {
7316 match self {
7317 Self::AbstractDeclarator(inner) => inner.span(),
7318 Self::MsCallModifier(inner) => inner.span(),
7319 }
7320 }
7321}
7322#[derive(Debug, Clone, PartialEq, Eq)]
7323pub enum AbstractPointerDeclaratorChildren<'tree> {
7324 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
7325 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
7326}
7327impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclaratorChildren<'tree> {
7328 #[allow(clippy::collapsible_else_if)]
7329 fn from_node(
7330 node: ::treesitter_types::tree_sitter::Node<'tree>,
7331 src: &'tree [u8],
7332 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7333 match node.kind() {
7334 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
7335 ::treesitter_types::runtime::maybe_grow_stack(|| {
7336 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
7337 })?,
7338 ))),
7339 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
7340 ::treesitter_types::runtime::maybe_grow_stack(|| {
7341 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
7342 })?,
7343 ))),
7344 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7345 }
7346 }
7347}
7348impl ::treesitter_types::Spanned for AbstractPointerDeclaratorChildren<'_> {
7349 fn span(&self) -> ::treesitter_types::Span {
7350 match self {
7351 Self::MsPointerModifier(inner) => inner.span(),
7352 Self::TypeQualifier(inner) => inner.span(),
7353 }
7354 }
7355}
7356#[derive(Debug, Clone, PartialEq, Eq)]
7357pub enum AlignasQualifierChildren<'tree> {
7358 Expression(::std::boxed::Box<Expression<'tree>>),
7359 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
7360}
7361impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifierChildren<'tree> {
7362 #[allow(clippy::collapsible_else_if)]
7363 fn from_node(
7364 node: ::treesitter_types::tree_sitter::Node<'tree>,
7365 src: &'tree [u8],
7366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7367 match node.kind() {
7368 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
7369 ::treesitter_types::runtime::maybe_grow_stack(|| {
7370 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
7371 })?,
7372 ))),
7373 _other => {
7374 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7375 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7376 }) {
7377 Ok(Self::Expression(::std::boxed::Box::new(v)))
7378 } else {
7379 Err(::treesitter_types::ParseError::unexpected_kind(
7380 _other, node,
7381 ))
7382 }
7383 }
7384 }
7385 }
7386}
7387impl ::treesitter_types::Spanned for AlignasQualifierChildren<'_> {
7388 fn span(&self) -> ::treesitter_types::Span {
7389 match self {
7390 Self::Expression(inner) => inner.span(),
7391 Self::TypeDescriptor(inner) => inner.span(),
7392 }
7393 }
7394}
7395#[derive(Debug, Clone, PartialEq, Eq)]
7396pub enum ArgumentListChildren<'tree> {
7397 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
7398 Expression(::std::boxed::Box<Expression<'tree>>),
7399 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
7400}
7401impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
7402 #[allow(clippy::collapsible_else_if)]
7403 fn from_node(
7404 node: ::treesitter_types::tree_sitter::Node<'tree>,
7405 src: &'tree [u8],
7406 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7407 match node.kind() {
7408 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
7409 ::treesitter_types::runtime::maybe_grow_stack(|| {
7410 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
7411 })?,
7412 ))),
7413 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
7414 ::treesitter_types::runtime::maybe_grow_stack(|| {
7415 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
7416 })?,
7417 ))),
7418 _other => {
7419 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7420 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7421 }) {
7422 Ok(Self::Expression(::std::boxed::Box::new(v)))
7423 } else {
7424 Err(::treesitter_types::ParseError::unexpected_kind(
7425 _other, node,
7426 ))
7427 }
7428 }
7429 }
7430 }
7431}
7432impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
7433 fn span(&self) -> ::treesitter_types::Span {
7434 match self {
7435 Self::CompoundStatement(inner) => inner.span(),
7436 Self::Expression(inner) => inner.span(),
7437 Self::PreprocDefined(inner) => inner.span(),
7438 }
7439 }
7440}
7441#[derive(Debug, Clone, PartialEq, Eq)]
7442pub enum ArrayDeclaratorDeclarator<'tree> {
7443 Declarator(::std::boxed::Box<Declarator<'tree>>),
7444 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
7445 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
7446}
7447impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorDeclarator<'tree> {
7448 #[allow(clippy::collapsible_else_if)]
7449 fn from_node(
7450 node: ::treesitter_types::tree_sitter::Node<'tree>,
7451 src: &'tree [u8],
7452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7453 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7454 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
7455 }) {
7456 Ok(Self::Declarator(::std::boxed::Box::new(v)))
7457 } else {
7458 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7459 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
7460 }) {
7461 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
7462 } else {
7463 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7464 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
7465 }) {
7466 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
7467 } else {
7468 Err(::treesitter_types::ParseError::unexpected_kind(
7469 node.kind(),
7470 node,
7471 ))
7472 }
7473 }
7474 }
7475 }
7476}
7477impl ::treesitter_types::Spanned for ArrayDeclaratorDeclarator<'_> {
7478 fn span(&self) -> ::treesitter_types::Span {
7479 match self {
7480 Self::Declarator(inner) => inner.span(),
7481 Self::FieldDeclarator(inner) => inner.span(),
7482 Self::TypeDeclarator(inner) => inner.span(),
7483 }
7484 }
7485}
7486#[derive(Debug, Clone, PartialEq, Eq)]
7487pub enum ArrayDeclaratorSize<'tree> {
7488 Star(::treesitter_types::Span),
7489 Expression(::std::boxed::Box<Expression<'tree>>),
7490}
7491impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorSize<'tree> {
7492 #[allow(clippy::collapsible_else_if)]
7493 fn from_node(
7494 node: ::treesitter_types::tree_sitter::Node<'tree>,
7495 src: &'tree [u8],
7496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7497 match node.kind() {
7498 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7499 _other => {
7500 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7501 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7502 }) {
7503 Ok(Self::Expression(::std::boxed::Box::new(v)))
7504 } else {
7505 Err(::treesitter_types::ParseError::unexpected_kind(
7506 _other, node,
7507 ))
7508 }
7509 }
7510 }
7511 }
7512}
7513impl ::treesitter_types::Spanned for ArrayDeclaratorSize<'_> {
7514 fn span(&self) -> ::treesitter_types::Span {
7515 match self {
7516 Self::Star(span) => *span,
7517 Self::Expression(inner) => inner.span(),
7518 }
7519 }
7520}
7521#[derive(Debug, Clone, PartialEq, Eq)]
7522pub enum AssignmentExpressionLeft<'tree> {
7523 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
7524 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
7525 Identifier(::std::boxed::Box<Identifier<'tree>>),
7526 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
7527 PointerExpression(::std::boxed::Box<PointerExpression<'tree>>),
7528 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
7529}
7530impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
7531 #[allow(clippy::collapsible_else_if)]
7532 fn from_node(
7533 node: ::treesitter_types::tree_sitter::Node<'tree>,
7534 src: &'tree [u8],
7535 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7536 match node.kind() {
7537 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
7538 ::treesitter_types::runtime::maybe_grow_stack(|| {
7539 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
7540 })?,
7541 ))),
7542 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
7543 ::treesitter_types::runtime::maybe_grow_stack(|| {
7544 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
7545 })?,
7546 ))),
7547 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7548 ::treesitter_types::runtime::maybe_grow_stack(|| {
7549 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
7550 })?,
7551 ))),
7552 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
7553 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
7554 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
7555 })?),
7556 )),
7557 "pointer_expression" => Ok(Self::PointerExpression(::std::boxed::Box::new(
7558 ::treesitter_types::runtime::maybe_grow_stack(|| {
7559 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)
7560 })?,
7561 ))),
7562 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
7563 ::treesitter_types::runtime::maybe_grow_stack(|| {
7564 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
7565 })?,
7566 ))),
7567 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7568 }
7569 }
7570}
7571impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
7572 fn span(&self) -> ::treesitter_types::Span {
7573 match self {
7574 Self::CallExpression(inner) => inner.span(),
7575 Self::FieldExpression(inner) => inner.span(),
7576 Self::Identifier(inner) => inner.span(),
7577 Self::ParenthesizedExpression(inner) => inner.span(),
7578 Self::PointerExpression(inner) => inner.span(),
7579 Self::SubscriptExpression(inner) => inner.span(),
7580 }
7581 }
7582}
7583#[derive(Debug, Clone, PartialEq, Eq)]
7584pub enum AssignmentExpressionOperator {
7585 PercentEq(::treesitter_types::Span),
7586 AmpEq(::treesitter_types::Span),
7587 StarEq(::treesitter_types::Span),
7588 PlusEq(::treesitter_types::Span),
7589 MinusEq(::treesitter_types::Span),
7590 SlashEq(::treesitter_types::Span),
7591 ShlEq(::treesitter_types::Span),
7592 Eq(::treesitter_types::Span),
7593 ShrEq(::treesitter_types::Span),
7594 CaretEq(::treesitter_types::Span),
7595 PipeEq(::treesitter_types::Span),
7596}
7597impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
7598 #[allow(clippy::collapsible_else_if)]
7599 fn from_node(
7600 node: ::treesitter_types::tree_sitter::Node<'tree>,
7601 _src: &'tree [u8],
7602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7603 match node.kind() {
7604 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
7605 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
7606 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
7607 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
7608 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
7609 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
7610 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
7611 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
7612 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
7613 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
7614 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
7615 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7616 }
7617 }
7618}
7619impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
7620 fn span(&self) -> ::treesitter_types::Span {
7621 match self {
7622 Self::PercentEq(span) => *span,
7623 Self::AmpEq(span) => *span,
7624 Self::StarEq(span) => *span,
7625 Self::PlusEq(span) => *span,
7626 Self::MinusEq(span) => *span,
7627 Self::SlashEq(span) => *span,
7628 Self::ShlEq(span) => *span,
7629 Self::Eq(span) => *span,
7630 Self::ShrEq(span) => *span,
7631 Self::CaretEq(span) => *span,
7632 Self::PipeEq(span) => *span,
7633 }
7634 }
7635}
7636#[derive(Debug, Clone, PartialEq, Eq)]
7637pub enum AttributedDeclaratorChildren<'tree> {
7638 Declarator(::std::boxed::Box<Declarator<'tree>>),
7639 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
7640 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
7641 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
7642}
7643impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclaratorChildren<'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 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
7651 ::treesitter_types::runtime::maybe_grow_stack(|| {
7652 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7653 })?,
7654 ))),
7655 _other => {
7656 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7657 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
7658 }) {
7659 Ok(Self::Declarator(::std::boxed::Box::new(v)))
7660 } else {
7661 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7662 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
7663 }) {
7664 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
7665 } else {
7666 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7667 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
7668 }) {
7669 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
7670 } else {
7671 Err(::treesitter_types::ParseError::unexpected_kind(
7672 _other, node,
7673 ))
7674 }
7675 }
7676 }
7677 }
7678 }
7679 }
7680}
7681impl ::treesitter_types::Spanned for AttributedDeclaratorChildren<'_> {
7682 fn span(&self) -> ::treesitter_types::Span {
7683 match self {
7684 Self::Declarator(inner) => inner.span(),
7685 Self::FieldDeclarator(inner) => inner.span(),
7686 Self::TypeDeclarator(inner) => inner.span(),
7687 Self::AttributeDeclaration(inner) => inner.span(),
7688 }
7689 }
7690}
7691#[derive(Debug, Clone, PartialEq, Eq)]
7692pub enum AttributedStatementChildren<'tree> {
7693 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
7694 Statement(::std::boxed::Box<Statement<'tree>>),
7695}
7696impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatementChildren<'tree> {
7697 #[allow(clippy::collapsible_else_if)]
7698 fn from_node(
7699 node: ::treesitter_types::tree_sitter::Node<'tree>,
7700 src: &'tree [u8],
7701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7702 match node.kind() {
7703 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
7704 ::treesitter_types::runtime::maybe_grow_stack(|| {
7705 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
7706 })?,
7707 ))),
7708 _other => {
7709 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7710 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
7711 }) {
7712 Ok(Self::Statement(::std::boxed::Box::new(v)))
7713 } else {
7714 Err(::treesitter_types::ParseError::unexpected_kind(
7715 _other, node,
7716 ))
7717 }
7718 }
7719 }
7720 }
7721}
7722impl ::treesitter_types::Spanned for AttributedStatementChildren<'_> {
7723 fn span(&self) -> ::treesitter_types::Span {
7724 match self {
7725 Self::AttributeDeclaration(inner) => inner.span(),
7726 Self::Statement(inner) => inner.span(),
7727 }
7728 }
7729}
7730#[derive(Debug, Clone, PartialEq, Eq)]
7731pub enum BinaryExpressionLeft<'tree> {
7732 Expression(::std::boxed::Box<Expression<'tree>>),
7733 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
7734}
7735impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
7736 #[allow(clippy::collapsible_else_if)]
7737 fn from_node(
7738 node: ::treesitter_types::tree_sitter::Node<'tree>,
7739 src: &'tree [u8],
7740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7741 match node.kind() {
7742 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
7743 ::treesitter_types::runtime::maybe_grow_stack(|| {
7744 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
7745 })?,
7746 ))),
7747 _other => {
7748 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7749 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7750 }) {
7751 Ok(Self::Expression(::std::boxed::Box::new(v)))
7752 } else {
7753 Err(::treesitter_types::ParseError::unexpected_kind(
7754 _other, node,
7755 ))
7756 }
7757 }
7758 }
7759 }
7760}
7761impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
7762 fn span(&self) -> ::treesitter_types::Span {
7763 match self {
7764 Self::Expression(inner) => inner.span(),
7765 Self::PreprocDefined(inner) => inner.span(),
7766 }
7767 }
7768}
7769#[derive(Debug, Clone, PartialEq, Eq)]
7770pub enum BinaryExpressionOperator {
7771 NotEq(::treesitter_types::Span),
7772 Percent(::treesitter_types::Span),
7773 Amp(::treesitter_types::Span),
7774 AmpAmp(::treesitter_types::Span),
7775 Star(::treesitter_types::Span),
7776 Plus(::treesitter_types::Span),
7777 Minus(::treesitter_types::Span),
7778 Slash(::treesitter_types::Span),
7779 Lt(::treesitter_types::Span),
7780 Shl(::treesitter_types::Span),
7781 LtEq(::treesitter_types::Span),
7782 EqEq(::treesitter_types::Span),
7783 Gt(::treesitter_types::Span),
7784 GtEq(::treesitter_types::Span),
7785 Shr(::treesitter_types::Span),
7786 Caret(::treesitter_types::Span),
7787 Pipe(::treesitter_types::Span),
7788 PipePipe(::treesitter_types::Span),
7789}
7790impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
7791 #[allow(clippy::collapsible_else_if)]
7792 fn from_node(
7793 node: ::treesitter_types::tree_sitter::Node<'tree>,
7794 _src: &'tree [u8],
7795 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7796 match node.kind() {
7797 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
7798 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
7799 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
7800 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
7801 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
7802 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
7803 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
7804 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
7805 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
7806 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
7807 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
7808 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
7809 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
7810 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
7811 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
7812 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
7813 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
7814 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
7815 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7816 }
7817 }
7818}
7819impl ::treesitter_types::Spanned for BinaryExpressionOperator {
7820 fn span(&self) -> ::treesitter_types::Span {
7821 match self {
7822 Self::NotEq(span) => *span,
7823 Self::Percent(span) => *span,
7824 Self::Amp(span) => *span,
7825 Self::AmpAmp(span) => *span,
7826 Self::Star(span) => *span,
7827 Self::Plus(span) => *span,
7828 Self::Minus(span) => *span,
7829 Self::Slash(span) => *span,
7830 Self::Lt(span) => *span,
7831 Self::Shl(span) => *span,
7832 Self::LtEq(span) => *span,
7833 Self::EqEq(span) => *span,
7834 Self::Gt(span) => *span,
7835 Self::GtEq(span) => *span,
7836 Self::Shr(span) => *span,
7837 Self::Caret(span) => *span,
7838 Self::Pipe(span) => *span,
7839 Self::PipePipe(span) => *span,
7840 }
7841 }
7842}
7843#[derive(Debug, Clone, PartialEq, Eq)]
7844pub enum BinaryExpressionRight<'tree> {
7845 Expression(::std::boxed::Box<Expression<'tree>>),
7846 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
7847}
7848impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
7849 #[allow(clippy::collapsible_else_if)]
7850 fn from_node(
7851 node: ::treesitter_types::tree_sitter::Node<'tree>,
7852 src: &'tree [u8],
7853 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7854 match node.kind() {
7855 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
7856 ::treesitter_types::runtime::maybe_grow_stack(|| {
7857 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
7858 })?,
7859 ))),
7860 _other => {
7861 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
7862 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
7863 }) {
7864 Ok(Self::Expression(::std::boxed::Box::new(v)))
7865 } else {
7866 Err(::treesitter_types::ParseError::unexpected_kind(
7867 _other, node,
7868 ))
7869 }
7870 }
7871 }
7872 }
7873}
7874impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
7875 fn span(&self) -> ::treesitter_types::Span {
7876 match self {
7877 Self::Expression(inner) => inner.span(),
7878 Self::PreprocDefined(inner) => inner.span(),
7879 }
7880 }
7881}
7882#[derive(Debug, Clone, PartialEq, Eq)]
7883pub enum CaseStatementChildren<'tree> {
7884 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
7885 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
7886 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
7887 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
7888 Declaration(::std::boxed::Box<Declaration<'tree>>),
7889 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
7890 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
7891 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
7892 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
7893 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
7894 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
7895 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
7896 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
7897 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
7898 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
7899 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
7900 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
7901}
7902impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatementChildren<'tree> {
7903 #[allow(clippy::collapsible_else_if)]
7904 fn from_node(
7905 node: ::treesitter_types::tree_sitter::Node<'tree>,
7906 src: &'tree [u8],
7907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7908 match node.kind() {
7909 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
7910 ::treesitter_types::runtime::maybe_grow_stack(|| {
7911 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
7912 })?,
7913 ))),
7914 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
7915 ::treesitter_types::runtime::maybe_grow_stack(|| {
7916 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
7917 })?,
7918 ))),
7919 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
7920 ::treesitter_types::runtime::maybe_grow_stack(|| {
7921 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
7922 })?,
7923 ))),
7924 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
7925 ::treesitter_types::runtime::maybe_grow_stack(|| {
7926 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
7927 })?,
7928 ))),
7929 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
7930 ::treesitter_types::runtime::maybe_grow_stack(|| {
7931 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
7932 })?,
7933 ))),
7934 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
7935 ::treesitter_types::runtime::maybe_grow_stack(|| {
7936 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
7937 })?,
7938 ))),
7939 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
7940 ::treesitter_types::runtime::maybe_grow_stack(|| {
7941 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
7942 })?,
7943 ))),
7944 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
7945 ::treesitter_types::runtime::maybe_grow_stack(|| {
7946 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
7947 })?,
7948 ))),
7949 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
7950 ::treesitter_types::runtime::maybe_grow_stack(|| {
7951 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
7952 })?,
7953 ))),
7954 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
7955 ::treesitter_types::runtime::maybe_grow_stack(|| {
7956 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
7957 })?,
7958 ))),
7959 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
7960 ::treesitter_types::runtime::maybe_grow_stack(|| {
7961 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
7962 })?,
7963 ))),
7964 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
7965 ::treesitter_types::runtime::maybe_grow_stack(|| {
7966 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
7967 })?,
7968 ))),
7969 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
7970 ::treesitter_types::runtime::maybe_grow_stack(|| {
7971 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
7972 })?,
7973 ))),
7974 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
7975 ::treesitter_types::runtime::maybe_grow_stack(|| {
7976 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
7977 })?,
7978 ))),
7979 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
7980 ::treesitter_types::runtime::maybe_grow_stack(|| {
7981 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
7982 })?,
7983 ))),
7984 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
7985 ::treesitter_types::runtime::maybe_grow_stack(|| {
7986 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
7987 })?,
7988 ))),
7989 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
7990 ::treesitter_types::runtime::maybe_grow_stack(|| {
7991 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
7992 })?,
7993 ))),
7994 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7995 }
7996 }
7997}
7998impl ::treesitter_types::Spanned for CaseStatementChildren<'_> {
7999 fn span(&self) -> ::treesitter_types::Span {
8000 match self {
8001 Self::AttributedStatement(inner) => inner.span(),
8002 Self::BreakStatement(inner) => inner.span(),
8003 Self::CompoundStatement(inner) => inner.span(),
8004 Self::ContinueStatement(inner) => inner.span(),
8005 Self::Declaration(inner) => inner.span(),
8006 Self::DoStatement(inner) => inner.span(),
8007 Self::ExpressionStatement(inner) => inner.span(),
8008 Self::ForStatement(inner) => inner.span(),
8009 Self::GotoStatement(inner) => inner.span(),
8010 Self::IfStatement(inner) => inner.span(),
8011 Self::LabeledStatement(inner) => inner.span(),
8012 Self::ReturnStatement(inner) => inner.span(),
8013 Self::SehLeaveStatement(inner) => inner.span(),
8014 Self::SehTryStatement(inner) => inner.span(),
8015 Self::SwitchStatement(inner) => inner.span(),
8016 Self::TypeDefinition(inner) => inner.span(),
8017 Self::WhileStatement(inner) => inner.span(),
8018 }
8019 }
8020}
8021#[derive(Debug, Clone, PartialEq, Eq)]
8022pub enum CharLiteralChildren<'tree> {
8023 Character(::std::boxed::Box<Character<'tree>>),
8024 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8025}
8026impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteralChildren<'tree> {
8027 #[allow(clippy::collapsible_else_if)]
8028 fn from_node(
8029 node: ::treesitter_types::tree_sitter::Node<'tree>,
8030 src: &'tree [u8],
8031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8032 match node.kind() {
8033 "character" => Ok(Self::Character(::std::boxed::Box::new(
8034 ::treesitter_types::runtime::maybe_grow_stack(|| {
8035 <Character as ::treesitter_types::FromNode>::from_node(node, src)
8036 })?,
8037 ))),
8038 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8039 ::treesitter_types::runtime::maybe_grow_stack(|| {
8040 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
8041 })?,
8042 ))),
8043 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8044 }
8045 }
8046}
8047impl ::treesitter_types::Spanned for CharLiteralChildren<'_> {
8048 fn span(&self) -> ::treesitter_types::Span {
8049 match self {
8050 Self::Character(inner) => inner.span(),
8051 Self::EscapeSequence(inner) => inner.span(),
8052 }
8053 }
8054}
8055#[derive(Debug, Clone, PartialEq, Eq)]
8056pub enum CommaExpressionRight<'tree> {
8057 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8058 Expression(::std::boxed::Box<Expression<'tree>>),
8059}
8060impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpressionRight<'tree> {
8061 #[allow(clippy::collapsible_else_if)]
8062 fn from_node(
8063 node: ::treesitter_types::tree_sitter::Node<'tree>,
8064 src: &'tree [u8],
8065 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8066 match node.kind() {
8067 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8068 ::treesitter_types::runtime::maybe_grow_stack(|| {
8069 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8070 })?,
8071 ))),
8072 _other => {
8073 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8074 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8075 }) {
8076 Ok(Self::Expression(::std::boxed::Box::new(v)))
8077 } else {
8078 Err(::treesitter_types::ParseError::unexpected_kind(
8079 _other, node,
8080 ))
8081 }
8082 }
8083 }
8084 }
8085}
8086impl ::treesitter_types::Spanned for CommaExpressionRight<'_> {
8087 fn span(&self) -> ::treesitter_types::Span {
8088 match self {
8089 Self::CommaExpression(inner) => inner.span(),
8090 Self::Expression(inner) => inner.span(),
8091 }
8092 }
8093}
8094#[derive(Debug, Clone, PartialEq, Eq)]
8095pub enum CompoundStatementChildren<'tree> {
8096 Declaration(::std::boxed::Box<Declaration<'tree>>),
8097 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
8098 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
8099 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
8100 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
8101 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
8102 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
8103 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
8104 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
8105 Statement(::std::boxed::Box<Statement<'tree>>),
8106 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
8107 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
8108}
8109impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatementChildren<'tree> {
8110 #[allow(clippy::collapsible_else_if)]
8111 fn from_node(
8112 node: ::treesitter_types::tree_sitter::Node<'tree>,
8113 src: &'tree [u8],
8114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8115 match node.kind() {
8116 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
8117 ::treesitter_types::runtime::maybe_grow_stack(|| {
8118 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
8119 })?,
8120 ))),
8121 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
8122 ::treesitter_types::runtime::maybe_grow_stack(|| {
8123 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8124 })?,
8125 ))),
8126 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
8127 ::treesitter_types::runtime::maybe_grow_stack(|| {
8128 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
8129 })?,
8130 ))),
8131 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
8132 ::treesitter_types::runtime::maybe_grow_stack(|| {
8133 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
8134 })?,
8135 ))),
8136 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
8137 ::treesitter_types::runtime::maybe_grow_stack(|| {
8138 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
8139 })?,
8140 ))),
8141 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
8142 ::treesitter_types::runtime::maybe_grow_stack(|| {
8143 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
8144 })?,
8145 ))),
8146 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
8147 ::treesitter_types::runtime::maybe_grow_stack(|| {
8148 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
8149 })?,
8150 ))),
8151 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
8152 ::treesitter_types::runtime::maybe_grow_stack(|| {
8153 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
8154 })?,
8155 ))),
8156 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
8157 ::treesitter_types::runtime::maybe_grow_stack(|| {
8158 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
8159 })?,
8160 ))),
8161 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
8162 ::treesitter_types::runtime::maybe_grow_stack(|| {
8163 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8164 })?,
8165 ))),
8166 _other => {
8167 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8168 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8169 }) {
8170 Ok(Self::Statement(::std::boxed::Box::new(v)))
8171 } else {
8172 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8173 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8174 }) {
8175 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
8176 } else {
8177 Err(::treesitter_types::ParseError::unexpected_kind(
8178 _other, node,
8179 ))
8180 }
8181 }
8182 }
8183 }
8184 }
8185}
8186impl ::treesitter_types::Spanned for CompoundStatementChildren<'_> {
8187 fn span(&self) -> ::treesitter_types::Span {
8188 match self {
8189 Self::Declaration(inner) => inner.span(),
8190 Self::FunctionDefinition(inner) => inner.span(),
8191 Self::LinkageSpecification(inner) => inner.span(),
8192 Self::PreprocCall(inner) => inner.span(),
8193 Self::PreprocDef(inner) => inner.span(),
8194 Self::PreprocFunctionDef(inner) => inner.span(),
8195 Self::PreprocIf(inner) => inner.span(),
8196 Self::PreprocIfdef(inner) => inner.span(),
8197 Self::PreprocInclude(inner) => inner.span(),
8198 Self::Statement(inner) => inner.span(),
8199 Self::TypeDefinition(inner) => inner.span(),
8200 Self::TypeSpecifier(inner) => inner.span(),
8201 }
8202 }
8203}
8204#[derive(Debug, Clone, PartialEq, Eq)]
8205pub enum ConcatenatedStringChildren<'tree> {
8206 Identifier(::std::boxed::Box<Identifier<'tree>>),
8207 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
8208}
8209impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedStringChildren<'tree> {
8210 #[allow(clippy::collapsible_else_if)]
8211 fn from_node(
8212 node: ::treesitter_types::tree_sitter::Node<'tree>,
8213 src: &'tree [u8],
8214 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8215 match node.kind() {
8216 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8217 ::treesitter_types::runtime::maybe_grow_stack(|| {
8218 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8219 })?,
8220 ))),
8221 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
8222 ::treesitter_types::runtime::maybe_grow_stack(|| {
8223 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
8224 })?,
8225 ))),
8226 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8227 }
8228 }
8229}
8230impl ::treesitter_types::Spanned for ConcatenatedStringChildren<'_> {
8231 fn span(&self) -> ::treesitter_types::Span {
8232 match self {
8233 Self::Identifier(inner) => inner.span(),
8234 Self::StringLiteral(inner) => inner.span(),
8235 }
8236 }
8237}
8238#[derive(Debug, Clone, PartialEq, Eq)]
8239pub enum ConditionalExpressionConsequence<'tree> {
8240 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8241 Expression(::std::boxed::Box<Expression<'tree>>),
8242}
8243impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpressionConsequence<'tree> {
8244 #[allow(clippy::collapsible_else_if)]
8245 fn from_node(
8246 node: ::treesitter_types::tree_sitter::Node<'tree>,
8247 src: &'tree [u8],
8248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8249 match node.kind() {
8250 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8251 ::treesitter_types::runtime::maybe_grow_stack(|| {
8252 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8253 })?,
8254 ))),
8255 _other => {
8256 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8257 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8258 }) {
8259 Ok(Self::Expression(::std::boxed::Box::new(v)))
8260 } else {
8261 Err(::treesitter_types::ParseError::unexpected_kind(
8262 _other, node,
8263 ))
8264 }
8265 }
8266 }
8267 }
8268}
8269impl ::treesitter_types::Spanned for ConditionalExpressionConsequence<'_> {
8270 fn span(&self) -> ::treesitter_types::Span {
8271 match self {
8272 Self::CommaExpression(inner) => inner.span(),
8273 Self::Expression(inner) => inner.span(),
8274 }
8275 }
8276}
8277#[derive(Debug, Clone, PartialEq, Eq)]
8278pub enum DeclarationDeclarator<'tree> {
8279 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
8280 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
8281 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
8282 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
8283 Identifier(::std::boxed::Box<Identifier<'tree>>),
8284 InitDeclarator(::std::boxed::Box<InitDeclarator<'tree>>),
8285 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
8286 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
8287 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
8288}
8289impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationDeclarator<'tree> {
8290 #[allow(clippy::collapsible_else_if)]
8291 fn from_node(
8292 node: ::treesitter_types::tree_sitter::Node<'tree>,
8293 src: &'tree [u8],
8294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8295 match node.kind() {
8296 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
8297 ::treesitter_types::runtime::maybe_grow_stack(|| {
8298 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8299 })?,
8300 ))),
8301 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
8302 ::treesitter_types::runtime::maybe_grow_stack(|| {
8303 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8304 })?,
8305 ))),
8306 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
8307 ::treesitter_types::runtime::maybe_grow_stack(|| {
8308 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8309 })?,
8310 ))),
8311 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
8312 ::treesitter_types::runtime::maybe_grow_stack(|| {
8313 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
8314 })?,
8315 ))),
8316 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8317 ::treesitter_types::runtime::maybe_grow_stack(|| {
8318 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8319 })?,
8320 ))),
8321 "init_declarator" => Ok(Self::InitDeclarator(::std::boxed::Box::new(
8322 ::treesitter_types::runtime::maybe_grow_stack(|| {
8323 <InitDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8324 })?,
8325 ))),
8326 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
8327 ::treesitter_types::runtime::maybe_grow_stack(|| {
8328 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
8329 })?,
8330 ))),
8331 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
8332 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
8333 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8334 })?),
8335 )),
8336 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
8337 ::treesitter_types::runtime::maybe_grow_stack(|| {
8338 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8339 })?,
8340 ))),
8341 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8342 }
8343 }
8344}
8345impl ::treesitter_types::Spanned for DeclarationDeclarator<'_> {
8346 fn span(&self) -> ::treesitter_types::Span {
8347 match self {
8348 Self::ArrayDeclarator(inner) => inner.span(),
8349 Self::AttributedDeclarator(inner) => inner.span(),
8350 Self::FunctionDeclarator(inner) => inner.span(),
8351 Self::GnuAsmExpression(inner) => inner.span(),
8352 Self::Identifier(inner) => inner.span(),
8353 Self::InitDeclarator(inner) => inner.span(),
8354 Self::MsCallModifier(inner) => inner.span(),
8355 Self::ParenthesizedDeclarator(inner) => inner.span(),
8356 Self::PointerDeclarator(inner) => inner.span(),
8357 }
8358 }
8359}
8360#[derive(Debug, Clone, PartialEq, Eq)]
8361pub enum DeclarationChildren<'tree> {
8362 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
8363 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
8364 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
8365 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
8366 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
8367}
8368impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationChildren<'tree> {
8369 #[allow(clippy::collapsible_else_if)]
8370 fn from_node(
8371 node: ::treesitter_types::tree_sitter::Node<'tree>,
8372 src: &'tree [u8],
8373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8374 match node.kind() {
8375 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
8376 ::treesitter_types::runtime::maybe_grow_stack(|| {
8377 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8378 })?,
8379 ))),
8380 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
8381 ::treesitter_types::runtime::maybe_grow_stack(|| {
8382 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8383 })?,
8384 ))),
8385 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
8386 ::treesitter_types::runtime::maybe_grow_stack(|| {
8387 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
8388 })?,
8389 ))),
8390 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
8391 ::treesitter_types::runtime::maybe_grow_stack(|| {
8392 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8393 })?,
8394 ))),
8395 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
8396 ::treesitter_types::runtime::maybe_grow_stack(|| {
8397 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
8398 })?,
8399 ))),
8400 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8401 }
8402 }
8403}
8404impl ::treesitter_types::Spanned for DeclarationChildren<'_> {
8405 fn span(&self) -> ::treesitter_types::Span {
8406 match self {
8407 Self::AttributeDeclaration(inner) => inner.span(),
8408 Self::AttributeSpecifier(inner) => inner.span(),
8409 Self::MsDeclspecModifier(inner) => inner.span(),
8410 Self::StorageClassSpecifier(inner) => inner.span(),
8411 Self::TypeQualifier(inner) => inner.span(),
8412 }
8413 }
8414}
8415#[derive(Debug, Clone, PartialEq, Eq)]
8416pub enum DeclarationListChildren<'tree> {
8417 Declaration(::std::boxed::Box<Declaration<'tree>>),
8418 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
8419 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
8420 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
8421 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
8422 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
8423 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
8424 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
8425 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
8426 Statement(::std::boxed::Box<Statement<'tree>>),
8427 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
8428 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
8429}
8430impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationListChildren<'tree> {
8431 #[allow(clippy::collapsible_else_if)]
8432 fn from_node(
8433 node: ::treesitter_types::tree_sitter::Node<'tree>,
8434 src: &'tree [u8],
8435 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8436 match node.kind() {
8437 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
8438 ::treesitter_types::runtime::maybe_grow_stack(|| {
8439 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
8440 })?,
8441 ))),
8442 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
8443 ::treesitter_types::runtime::maybe_grow_stack(|| {
8444 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8445 })?,
8446 ))),
8447 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
8448 ::treesitter_types::runtime::maybe_grow_stack(|| {
8449 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
8450 })?,
8451 ))),
8452 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
8453 ::treesitter_types::runtime::maybe_grow_stack(|| {
8454 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
8455 })?,
8456 ))),
8457 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
8458 ::treesitter_types::runtime::maybe_grow_stack(|| {
8459 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
8460 })?,
8461 ))),
8462 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
8463 ::treesitter_types::runtime::maybe_grow_stack(|| {
8464 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
8465 })?,
8466 ))),
8467 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
8468 ::treesitter_types::runtime::maybe_grow_stack(|| {
8469 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
8470 })?,
8471 ))),
8472 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
8473 ::treesitter_types::runtime::maybe_grow_stack(|| {
8474 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
8475 })?,
8476 ))),
8477 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
8478 ::treesitter_types::runtime::maybe_grow_stack(|| {
8479 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
8480 })?,
8481 ))),
8482 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
8483 ::treesitter_types::runtime::maybe_grow_stack(|| {
8484 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8485 })?,
8486 ))),
8487 _other => {
8488 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8489 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8490 }) {
8491 Ok(Self::Statement(::std::boxed::Box::new(v)))
8492 } else {
8493 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8494 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8495 }) {
8496 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
8497 } else {
8498 Err(::treesitter_types::ParseError::unexpected_kind(
8499 _other, node,
8500 ))
8501 }
8502 }
8503 }
8504 }
8505 }
8506}
8507impl ::treesitter_types::Spanned for DeclarationListChildren<'_> {
8508 fn span(&self) -> ::treesitter_types::Span {
8509 match self {
8510 Self::Declaration(inner) => inner.span(),
8511 Self::FunctionDefinition(inner) => inner.span(),
8512 Self::LinkageSpecification(inner) => inner.span(),
8513 Self::PreprocCall(inner) => inner.span(),
8514 Self::PreprocDef(inner) => inner.span(),
8515 Self::PreprocFunctionDef(inner) => inner.span(),
8516 Self::PreprocIf(inner) => inner.span(),
8517 Self::PreprocIfdef(inner) => inner.span(),
8518 Self::PreprocInclude(inner) => inner.span(),
8519 Self::Statement(inner) => inner.span(),
8520 Self::TypeDefinition(inner) => inner.span(),
8521 Self::TypeSpecifier(inner) => inner.span(),
8522 }
8523 }
8524}
8525#[derive(Debug, Clone, PartialEq, Eq)]
8526pub enum EnumeratorListChildren<'tree> {
8527 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
8528 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
8529 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
8530 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
8531}
8532impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorListChildren<'tree> {
8533 #[allow(clippy::collapsible_else_if)]
8534 fn from_node(
8535 node: ::treesitter_types::tree_sitter::Node<'tree>,
8536 src: &'tree [u8],
8537 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8538 match node.kind() {
8539 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
8540 ::treesitter_types::runtime::maybe_grow_stack(|| {
8541 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
8542 })?,
8543 ))),
8544 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
8545 ::treesitter_types::runtime::maybe_grow_stack(|| {
8546 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
8547 })?,
8548 ))),
8549 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
8550 ::treesitter_types::runtime::maybe_grow_stack(|| {
8551 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
8552 })?,
8553 ))),
8554 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
8555 ::treesitter_types::runtime::maybe_grow_stack(|| {
8556 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
8557 })?,
8558 ))),
8559 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8560 }
8561 }
8562}
8563impl ::treesitter_types::Spanned for EnumeratorListChildren<'_> {
8564 fn span(&self) -> ::treesitter_types::Span {
8565 match self {
8566 Self::Enumerator(inner) => inner.span(),
8567 Self::PreprocCall(inner) => inner.span(),
8568 Self::PreprocIf(inner) => inner.span(),
8569 Self::PreprocIfdef(inner) => inner.span(),
8570 }
8571 }
8572}
8573#[derive(Debug, Clone, PartialEq, Eq)]
8574pub enum ExpressionStatementChildren<'tree> {
8575 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8576 Expression(::std::boxed::Box<Expression<'tree>>),
8577}
8578impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
8579 #[allow(clippy::collapsible_else_if)]
8580 fn from_node(
8581 node: ::treesitter_types::tree_sitter::Node<'tree>,
8582 src: &'tree [u8],
8583 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8584 match node.kind() {
8585 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8586 ::treesitter_types::runtime::maybe_grow_stack(|| {
8587 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8588 })?,
8589 ))),
8590 _other => {
8591 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8592 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8593 }) {
8594 Ok(Self::Expression(::std::boxed::Box::new(v)))
8595 } else {
8596 Err(::treesitter_types::ParseError::unexpected_kind(
8597 _other, node,
8598 ))
8599 }
8600 }
8601 }
8602 }
8603}
8604impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
8605 fn span(&self) -> ::treesitter_types::Span {
8606 match self {
8607 Self::CommaExpression(inner) => inner.span(),
8608 Self::Expression(inner) => inner.span(),
8609 }
8610 }
8611}
8612#[derive(Debug, Clone, PartialEq, Eq)]
8613pub enum FieldDeclarationChildren<'tree> {
8614 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
8615 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
8616 BitfieldClause(::std::boxed::Box<BitfieldClause<'tree>>),
8617 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
8618 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
8619 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
8620}
8621impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
8622 #[allow(clippy::collapsible_else_if)]
8623 fn from_node(
8624 node: ::treesitter_types::tree_sitter::Node<'tree>,
8625 src: &'tree [u8],
8626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8627 match node.kind() {
8628 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
8629 ::treesitter_types::runtime::maybe_grow_stack(|| {
8630 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8631 })?,
8632 ))),
8633 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
8634 ::treesitter_types::runtime::maybe_grow_stack(|| {
8635 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8636 })?,
8637 ))),
8638 "bitfield_clause" => Ok(Self::BitfieldClause(::std::boxed::Box::new(
8639 ::treesitter_types::runtime::maybe_grow_stack(|| {
8640 <BitfieldClause as ::treesitter_types::FromNode>::from_node(node, src)
8641 })?,
8642 ))),
8643 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
8644 ::treesitter_types::runtime::maybe_grow_stack(|| {
8645 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
8646 })?,
8647 ))),
8648 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
8649 ::treesitter_types::runtime::maybe_grow_stack(|| {
8650 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8651 })?,
8652 ))),
8653 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
8654 ::treesitter_types::runtime::maybe_grow_stack(|| {
8655 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
8656 })?,
8657 ))),
8658 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8659 }
8660 }
8661}
8662impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
8663 fn span(&self) -> ::treesitter_types::Span {
8664 match self {
8665 Self::AttributeDeclaration(inner) => inner.span(),
8666 Self::AttributeSpecifier(inner) => inner.span(),
8667 Self::BitfieldClause(inner) => inner.span(),
8668 Self::MsDeclspecModifier(inner) => inner.span(),
8669 Self::StorageClassSpecifier(inner) => inner.span(),
8670 Self::TypeQualifier(inner) => inner.span(),
8671 }
8672 }
8673}
8674#[derive(Debug, Clone, PartialEq, Eq)]
8675pub enum FieldDeclarationListChildren<'tree> {
8676 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
8677 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
8678 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
8679 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
8680 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
8681 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
8682}
8683impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
8684 #[allow(clippy::collapsible_else_if)]
8685 fn from_node(
8686 node: ::treesitter_types::tree_sitter::Node<'tree>,
8687 src: &'tree [u8],
8688 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8689 match node.kind() {
8690 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
8691 ::treesitter_types::runtime::maybe_grow_stack(|| {
8692 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8693 })?,
8694 ))),
8695 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
8696 ::treesitter_types::runtime::maybe_grow_stack(|| {
8697 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
8698 })?,
8699 ))),
8700 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
8701 ::treesitter_types::runtime::maybe_grow_stack(|| {
8702 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
8703 })?,
8704 ))),
8705 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
8706 ::treesitter_types::runtime::maybe_grow_stack(|| {
8707 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
8708 })?,
8709 ))),
8710 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
8711 ::treesitter_types::runtime::maybe_grow_stack(|| {
8712 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
8713 })?,
8714 ))),
8715 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
8716 ::treesitter_types::runtime::maybe_grow_stack(|| {
8717 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
8718 })?,
8719 ))),
8720 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8721 }
8722 }
8723}
8724impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
8725 fn span(&self) -> ::treesitter_types::Span {
8726 match self {
8727 Self::FieldDeclaration(inner) => inner.span(),
8728 Self::PreprocCall(inner) => inner.span(),
8729 Self::PreprocDef(inner) => inner.span(),
8730 Self::PreprocFunctionDef(inner) => inner.span(),
8731 Self::PreprocIf(inner) => inner.span(),
8732 Self::PreprocIfdef(inner) => inner.span(),
8733 }
8734 }
8735}
8736#[derive(Debug, Clone, PartialEq, Eq)]
8737pub enum FieldExpressionOperator {
8738 Arrow(::treesitter_types::Span),
8739 Dot(::treesitter_types::Span),
8740}
8741impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionOperator {
8742 #[allow(clippy::collapsible_else_if)]
8743 fn from_node(
8744 node: ::treesitter_types::tree_sitter::Node<'tree>,
8745 _src: &'tree [u8],
8746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8747 match node.kind() {
8748 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
8749 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
8750 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8751 }
8752 }
8753}
8754impl ::treesitter_types::Spanned for FieldExpressionOperator {
8755 fn span(&self) -> ::treesitter_types::Span {
8756 match self {
8757 Self::Arrow(span) => *span,
8758 Self::Dot(span) => *span,
8759 }
8760 }
8761}
8762#[derive(Debug, Clone, PartialEq, Eq)]
8763pub enum ForStatementCondition<'tree> {
8764 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8765 Expression(::std::boxed::Box<Expression<'tree>>),
8766}
8767impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
8768 #[allow(clippy::collapsible_else_if)]
8769 fn from_node(
8770 node: ::treesitter_types::tree_sitter::Node<'tree>,
8771 src: &'tree [u8],
8772 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8773 match node.kind() {
8774 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8775 ::treesitter_types::runtime::maybe_grow_stack(|| {
8776 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8777 })?,
8778 ))),
8779 _other => {
8780 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8781 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8782 }) {
8783 Ok(Self::Expression(::std::boxed::Box::new(v)))
8784 } else {
8785 Err(::treesitter_types::ParseError::unexpected_kind(
8786 _other, node,
8787 ))
8788 }
8789 }
8790 }
8791 }
8792}
8793impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
8794 fn span(&self) -> ::treesitter_types::Span {
8795 match self {
8796 Self::CommaExpression(inner) => inner.span(),
8797 Self::Expression(inner) => inner.span(),
8798 }
8799 }
8800}
8801#[derive(Debug, Clone, PartialEq, Eq)]
8802pub enum ForStatementInitializer<'tree> {
8803 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8804 Declaration(::std::boxed::Box<Declaration<'tree>>),
8805 Expression(::std::boxed::Box<Expression<'tree>>),
8806}
8807impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
8808 #[allow(clippy::collapsible_else_if)]
8809 fn from_node(
8810 node: ::treesitter_types::tree_sitter::Node<'tree>,
8811 src: &'tree [u8],
8812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8813 match node.kind() {
8814 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8815 ::treesitter_types::runtime::maybe_grow_stack(|| {
8816 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8817 })?,
8818 ))),
8819 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
8820 ::treesitter_types::runtime::maybe_grow_stack(|| {
8821 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
8822 })?,
8823 ))),
8824 _other => {
8825 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8826 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8827 }) {
8828 Ok(Self::Expression(::std::boxed::Box::new(v)))
8829 } else {
8830 Err(::treesitter_types::ParseError::unexpected_kind(
8831 _other, node,
8832 ))
8833 }
8834 }
8835 }
8836 }
8837}
8838impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
8839 fn span(&self) -> ::treesitter_types::Span {
8840 match self {
8841 Self::CommaExpression(inner) => inner.span(),
8842 Self::Declaration(inner) => inner.span(),
8843 Self::Expression(inner) => inner.span(),
8844 }
8845 }
8846}
8847#[derive(Debug, Clone, PartialEq, Eq)]
8848pub enum ForStatementUpdate<'tree> {
8849 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
8850 Expression(::std::boxed::Box<Expression<'tree>>),
8851}
8852impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
8853 #[allow(clippy::collapsible_else_if)]
8854 fn from_node(
8855 node: ::treesitter_types::tree_sitter::Node<'tree>,
8856 src: &'tree [u8],
8857 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8858 match node.kind() {
8859 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
8860 ::treesitter_types::runtime::maybe_grow_stack(|| {
8861 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
8862 })?,
8863 ))),
8864 _other => {
8865 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8866 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8867 }) {
8868 Ok(Self::Expression(::std::boxed::Box::new(v)))
8869 } else {
8870 Err(::treesitter_types::ParseError::unexpected_kind(
8871 _other, node,
8872 ))
8873 }
8874 }
8875 }
8876 }
8877}
8878impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
8879 fn span(&self) -> ::treesitter_types::Span {
8880 match self {
8881 Self::CommaExpression(inner) => inner.span(),
8882 Self::Expression(inner) => inner.span(),
8883 }
8884 }
8885}
8886#[derive(Debug, Clone, PartialEq, Eq)]
8887pub enum FunctionDeclaratorDeclarator<'tree> {
8888 Declarator(::std::boxed::Box<Declarator<'tree>>),
8889 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
8890 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
8891}
8892impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorDeclarator<'tree> {
8893 #[allow(clippy::collapsible_else_if)]
8894 fn from_node(
8895 node: ::treesitter_types::tree_sitter::Node<'tree>,
8896 src: &'tree [u8],
8897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8898 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8899 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
8900 }) {
8901 Ok(Self::Declarator(::std::boxed::Box::new(v)))
8902 } else {
8903 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8904 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8905 }) {
8906 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
8907 } else {
8908 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
8909 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
8910 }) {
8911 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
8912 } else {
8913 Err(::treesitter_types::ParseError::unexpected_kind(
8914 node.kind(),
8915 node,
8916 ))
8917 }
8918 }
8919 }
8920 }
8921}
8922impl ::treesitter_types::Spanned for FunctionDeclaratorDeclarator<'_> {
8923 fn span(&self) -> ::treesitter_types::Span {
8924 match self {
8925 Self::Declarator(inner) => inner.span(),
8926 Self::FieldDeclarator(inner) => inner.span(),
8927 Self::TypeDeclarator(inner) => inner.span(),
8928 }
8929 }
8930}
8931#[derive(Debug, Clone, PartialEq, Eq)]
8932pub enum FunctionDeclaratorChildren<'tree> {
8933 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
8934 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
8935 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
8936 Identifier(::std::boxed::Box<Identifier<'tree>>),
8937}
8938impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorChildren<'tree> {
8939 #[allow(clippy::collapsible_else_if)]
8940 fn from_node(
8941 node: ::treesitter_types::tree_sitter::Node<'tree>,
8942 src: &'tree [u8],
8943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8944 match node.kind() {
8945 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
8946 ::treesitter_types::runtime::maybe_grow_stack(|| {
8947 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8948 })?,
8949 ))),
8950 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
8951 ::treesitter_types::runtime::maybe_grow_stack(|| {
8952 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
8953 })?,
8954 ))),
8955 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
8956 ::treesitter_types::runtime::maybe_grow_stack(|| {
8957 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
8958 })?,
8959 ))),
8960 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8961 ::treesitter_types::runtime::maybe_grow_stack(|| {
8962 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
8963 })?,
8964 ))),
8965 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8966 }
8967 }
8968}
8969impl ::treesitter_types::Spanned for FunctionDeclaratorChildren<'_> {
8970 fn span(&self) -> ::treesitter_types::Span {
8971 match self {
8972 Self::AttributeSpecifier(inner) => inner.span(),
8973 Self::CallExpression(inner) => inner.span(),
8974 Self::GnuAsmExpression(inner) => inner.span(),
8975 Self::Identifier(inner) => inner.span(),
8976 }
8977 }
8978}
8979#[derive(Debug, Clone, PartialEq, Eq)]
8980pub enum FunctionDefinitionChildren<'tree> {
8981 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
8982 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
8983 Declaration(::std::boxed::Box<Declaration<'tree>>),
8984 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
8985 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
8986 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
8987 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
8988}
8989impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionChildren<'tree> {
8990 #[allow(clippy::collapsible_else_if)]
8991 fn from_node(
8992 node: ::treesitter_types::tree_sitter::Node<'tree>,
8993 src: &'tree [u8],
8994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8995 match node.kind() {
8996 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
8997 ::treesitter_types::runtime::maybe_grow_stack(|| {
8998 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8999 })?,
9000 ))),
9001 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
9002 ::treesitter_types::runtime::maybe_grow_stack(|| {
9003 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9004 })?,
9005 ))),
9006 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
9007 ::treesitter_types::runtime::maybe_grow_stack(|| {
9008 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
9009 })?,
9010 ))),
9011 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
9012 ::treesitter_types::runtime::maybe_grow_stack(|| {
9013 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
9014 })?,
9015 ))),
9016 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
9017 ::treesitter_types::runtime::maybe_grow_stack(|| {
9018 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
9019 })?,
9020 ))),
9021 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
9022 ::treesitter_types::runtime::maybe_grow_stack(|| {
9023 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9024 })?,
9025 ))),
9026 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
9027 ::treesitter_types::runtime::maybe_grow_stack(|| {
9028 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
9029 })?,
9030 ))),
9031 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9032 }
9033 }
9034}
9035impl ::treesitter_types::Spanned for FunctionDefinitionChildren<'_> {
9036 fn span(&self) -> ::treesitter_types::Span {
9037 match self {
9038 Self::AttributeDeclaration(inner) => inner.span(),
9039 Self::AttributeSpecifier(inner) => inner.span(),
9040 Self::Declaration(inner) => inner.span(),
9041 Self::MsCallModifier(inner) => inner.span(),
9042 Self::MsDeclspecModifier(inner) => inner.span(),
9043 Self::StorageClassSpecifier(inner) => inner.span(),
9044 Self::TypeQualifier(inner) => inner.span(),
9045 }
9046 }
9047}
9048#[derive(Debug, Clone, PartialEq, Eq)]
9049pub enum GenericExpressionChildren<'tree> {
9050 Expression(::std::boxed::Box<Expression<'tree>>),
9051 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
9052}
9053impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpressionChildren<'tree> {
9054 #[allow(clippy::collapsible_else_if)]
9055 fn from_node(
9056 node: ::treesitter_types::tree_sitter::Node<'tree>,
9057 src: &'tree [u8],
9058 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9059 match node.kind() {
9060 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
9061 ::treesitter_types::runtime::maybe_grow_stack(|| {
9062 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
9063 })?,
9064 ))),
9065 _other => {
9066 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9067 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9068 }) {
9069 Ok(Self::Expression(::std::boxed::Box::new(v)))
9070 } else {
9071 Err(::treesitter_types::ParseError::unexpected_kind(
9072 _other, node,
9073 ))
9074 }
9075 }
9076 }
9077 }
9078}
9079impl ::treesitter_types::Spanned for GenericExpressionChildren<'_> {
9080 fn span(&self) -> ::treesitter_types::Span {
9081 match self {
9082 Self::Expression(inner) => inner.span(),
9083 Self::TypeDescriptor(inner) => inner.span(),
9084 }
9085 }
9086}
9087#[derive(Debug, Clone, PartialEq, Eq)]
9088pub enum GnuAsmClobberListRegister<'tree> {
9089 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
9090 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
9091}
9092impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberListRegister<'tree> {
9093 #[allow(clippy::collapsible_else_if)]
9094 fn from_node(
9095 node: ::treesitter_types::tree_sitter::Node<'tree>,
9096 src: &'tree [u8],
9097 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9098 match node.kind() {
9099 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
9100 ::treesitter_types::runtime::maybe_grow_stack(|| {
9101 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
9102 })?,
9103 ))),
9104 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
9105 ::treesitter_types::runtime::maybe_grow_stack(|| {
9106 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
9107 })?,
9108 ))),
9109 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9110 }
9111 }
9112}
9113impl ::treesitter_types::Spanned for GnuAsmClobberListRegister<'_> {
9114 fn span(&self) -> ::treesitter_types::Span {
9115 match self {
9116 Self::ConcatenatedString(inner) => inner.span(),
9117 Self::StringLiteral(inner) => inner.span(),
9118 }
9119 }
9120}
9121#[derive(Debug, Clone, PartialEq, Eq)]
9122pub enum GnuAsmExpressionAssemblyCode<'tree> {
9123 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
9124 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
9125}
9126impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpressionAssemblyCode<'tree> {
9127 #[allow(clippy::collapsible_else_if)]
9128 fn from_node(
9129 node: ::treesitter_types::tree_sitter::Node<'tree>,
9130 src: &'tree [u8],
9131 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9132 match node.kind() {
9133 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
9134 ::treesitter_types::runtime::maybe_grow_stack(|| {
9135 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
9136 })?,
9137 ))),
9138 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
9139 ::treesitter_types::runtime::maybe_grow_stack(|| {
9140 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
9141 })?,
9142 ))),
9143 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9144 }
9145 }
9146}
9147impl ::treesitter_types::Spanned for GnuAsmExpressionAssemblyCode<'_> {
9148 fn span(&self) -> ::treesitter_types::Span {
9149 match self {
9150 Self::ConcatenatedString(inner) => inner.span(),
9151 Self::StringLiteral(inner) => inner.span(),
9152 }
9153 }
9154}
9155#[derive(Debug, Clone, PartialEq, Eq)]
9156pub enum InitDeclaratorValue<'tree> {
9157 Expression(::std::boxed::Box<Expression<'tree>>),
9158 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
9159}
9160impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclaratorValue<'tree> {
9161 #[allow(clippy::collapsible_else_if)]
9162 fn from_node(
9163 node: ::treesitter_types::tree_sitter::Node<'tree>,
9164 src: &'tree [u8],
9165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9166 match node.kind() {
9167 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
9168 ::treesitter_types::runtime::maybe_grow_stack(|| {
9169 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
9170 })?,
9171 ))),
9172 _other => {
9173 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9174 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9175 }) {
9176 Ok(Self::Expression(::std::boxed::Box::new(v)))
9177 } else {
9178 Err(::treesitter_types::ParseError::unexpected_kind(
9179 _other, node,
9180 ))
9181 }
9182 }
9183 }
9184 }
9185}
9186impl ::treesitter_types::Spanned for InitDeclaratorValue<'_> {
9187 fn span(&self) -> ::treesitter_types::Span {
9188 match self {
9189 Self::Expression(inner) => inner.span(),
9190 Self::InitializerList(inner) => inner.span(),
9191 }
9192 }
9193}
9194#[derive(Debug, Clone, PartialEq, Eq)]
9195pub enum InitializerListChildren<'tree> {
9196 Expression(::std::boxed::Box<Expression<'tree>>),
9197 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
9198 InitializerPair(::std::boxed::Box<InitializerPair<'tree>>),
9199}
9200impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerListChildren<'tree> {
9201 #[allow(clippy::collapsible_else_if)]
9202 fn from_node(
9203 node: ::treesitter_types::tree_sitter::Node<'tree>,
9204 src: &'tree [u8],
9205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9206 match node.kind() {
9207 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
9208 ::treesitter_types::runtime::maybe_grow_stack(|| {
9209 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
9210 })?,
9211 ))),
9212 "initializer_pair" => Ok(Self::InitializerPair(::std::boxed::Box::new(
9213 ::treesitter_types::runtime::maybe_grow_stack(|| {
9214 <InitializerPair as ::treesitter_types::FromNode>::from_node(node, src)
9215 })?,
9216 ))),
9217 _other => {
9218 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9219 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9220 }) {
9221 Ok(Self::Expression(::std::boxed::Box::new(v)))
9222 } else {
9223 Err(::treesitter_types::ParseError::unexpected_kind(
9224 _other, node,
9225 ))
9226 }
9227 }
9228 }
9229 }
9230}
9231impl ::treesitter_types::Spanned for InitializerListChildren<'_> {
9232 fn span(&self) -> ::treesitter_types::Span {
9233 match self {
9234 Self::Expression(inner) => inner.span(),
9235 Self::InitializerList(inner) => inner.span(),
9236 Self::InitializerPair(inner) => inner.span(),
9237 }
9238 }
9239}
9240#[derive(Debug, Clone, PartialEq, Eq)]
9241pub enum InitializerPairDesignator<'tree> {
9242 FieldDesignator(::std::boxed::Box<FieldDesignator<'tree>>),
9243 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
9244 SubscriptDesignator(::std::boxed::Box<SubscriptDesignator<'tree>>),
9245 SubscriptRangeDesignator(::std::boxed::Box<SubscriptRangeDesignator<'tree>>),
9246}
9247impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairDesignator<'tree> {
9248 #[allow(clippy::collapsible_else_if)]
9249 fn from_node(
9250 node: ::treesitter_types::tree_sitter::Node<'tree>,
9251 src: &'tree [u8],
9252 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9253 match node.kind() {
9254 "field_designator" => Ok(Self::FieldDesignator(::std::boxed::Box::new(
9255 ::treesitter_types::runtime::maybe_grow_stack(|| {
9256 <FieldDesignator as ::treesitter_types::FromNode>::from_node(node, src)
9257 })?,
9258 ))),
9259 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
9260 ::treesitter_types::runtime::maybe_grow_stack(|| {
9261 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9262 })?,
9263 ))),
9264 "subscript_designator" => Ok(Self::SubscriptDesignator(::std::boxed::Box::new(
9265 ::treesitter_types::runtime::maybe_grow_stack(|| {
9266 <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(node, src)
9267 })?,
9268 ))),
9269 "subscript_range_designator" => Ok(Self::SubscriptRangeDesignator(
9270 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9271 <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(node, src)
9272 })?),
9273 )),
9274 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9275 }
9276 }
9277}
9278impl ::treesitter_types::Spanned for InitializerPairDesignator<'_> {
9279 fn span(&self) -> ::treesitter_types::Span {
9280 match self {
9281 Self::FieldDesignator(inner) => inner.span(),
9282 Self::FieldIdentifier(inner) => inner.span(),
9283 Self::SubscriptDesignator(inner) => inner.span(),
9284 Self::SubscriptRangeDesignator(inner) => inner.span(),
9285 }
9286 }
9287}
9288#[derive(Debug, Clone, PartialEq, Eq)]
9289pub enum InitializerPairValue<'tree> {
9290 Expression(::std::boxed::Box<Expression<'tree>>),
9291 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
9292}
9293impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairValue<'tree> {
9294 #[allow(clippy::collapsible_else_if)]
9295 fn from_node(
9296 node: ::treesitter_types::tree_sitter::Node<'tree>,
9297 src: &'tree [u8],
9298 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9299 match node.kind() {
9300 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
9301 ::treesitter_types::runtime::maybe_grow_stack(|| {
9302 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
9303 })?,
9304 ))),
9305 _other => {
9306 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9307 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9308 }) {
9309 Ok(Self::Expression(::std::boxed::Box::new(v)))
9310 } else {
9311 Err(::treesitter_types::ParseError::unexpected_kind(
9312 _other, node,
9313 ))
9314 }
9315 }
9316 }
9317 }
9318}
9319impl ::treesitter_types::Spanned for InitializerPairValue<'_> {
9320 fn span(&self) -> ::treesitter_types::Span {
9321 match self {
9322 Self::Expression(inner) => inner.span(),
9323 Self::InitializerList(inner) => inner.span(),
9324 }
9325 }
9326}
9327#[derive(Debug, Clone, PartialEq, Eq)]
9328pub enum LabeledStatementChildren<'tree> {
9329 Declaration(::std::boxed::Box<Declaration<'tree>>),
9330 Statement(::std::boxed::Box<Statement<'tree>>),
9331}
9332impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
9333 #[allow(clippy::collapsible_else_if)]
9334 fn from_node(
9335 node: ::treesitter_types::tree_sitter::Node<'tree>,
9336 src: &'tree [u8],
9337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9338 match node.kind() {
9339 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
9340 ::treesitter_types::runtime::maybe_grow_stack(|| {
9341 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
9342 })?,
9343 ))),
9344 _other => {
9345 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9346 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
9347 }) {
9348 Ok(Self::Statement(::std::boxed::Box::new(v)))
9349 } else {
9350 Err(::treesitter_types::ParseError::unexpected_kind(
9351 _other, node,
9352 ))
9353 }
9354 }
9355 }
9356 }
9357}
9358impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
9359 fn span(&self) -> ::treesitter_types::Span {
9360 match self {
9361 Self::Declaration(inner) => inner.span(),
9362 Self::Statement(inner) => inner.span(),
9363 }
9364 }
9365}
9366#[derive(Debug, Clone, PartialEq, Eq)]
9367pub enum LinkageSpecificationBody<'tree> {
9368 Declaration(::std::boxed::Box<Declaration<'tree>>),
9369 DeclarationList(::std::boxed::Box<DeclarationList<'tree>>),
9370 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
9371}
9372impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecificationBody<'tree> {
9373 #[allow(clippy::collapsible_else_if)]
9374 fn from_node(
9375 node: ::treesitter_types::tree_sitter::Node<'tree>,
9376 src: &'tree [u8],
9377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9378 match node.kind() {
9379 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
9380 ::treesitter_types::runtime::maybe_grow_stack(|| {
9381 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
9382 })?,
9383 ))),
9384 "declaration_list" => Ok(Self::DeclarationList(::std::boxed::Box::new(
9385 ::treesitter_types::runtime::maybe_grow_stack(|| {
9386 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
9387 })?,
9388 ))),
9389 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
9390 ::treesitter_types::runtime::maybe_grow_stack(|| {
9391 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
9392 })?,
9393 ))),
9394 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9395 }
9396 }
9397}
9398impl ::treesitter_types::Spanned for LinkageSpecificationBody<'_> {
9399 fn span(&self) -> ::treesitter_types::Span {
9400 match self {
9401 Self::Declaration(inner) => inner.span(),
9402 Self::DeclarationList(inner) => inner.span(),
9403 Self::FunctionDefinition(inner) => inner.span(),
9404 }
9405 }
9406}
9407#[derive(Debug, Clone, PartialEq, Eq)]
9408pub enum MsPointerModifierChildren<'tree> {
9409 MsRestrictModifier(::std::boxed::Box<MsRestrictModifier<'tree>>),
9410 MsSignedPtrModifier(::std::boxed::Box<MsSignedPtrModifier<'tree>>),
9411 MsUnalignedPtrModifier(::std::boxed::Box<MsUnalignedPtrModifier<'tree>>),
9412 MsUnsignedPtrModifier(::std::boxed::Box<MsUnsignedPtrModifier<'tree>>),
9413}
9414impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifierChildren<'tree> {
9415 #[allow(clippy::collapsible_else_if)]
9416 fn from_node(
9417 node: ::treesitter_types::tree_sitter::Node<'tree>,
9418 src: &'tree [u8],
9419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9420 match node.kind() {
9421 "ms_restrict_modifier" => Ok(Self::MsRestrictModifier(::std::boxed::Box::new(
9422 ::treesitter_types::runtime::maybe_grow_stack(|| {
9423 <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(node, src)
9424 })?,
9425 ))),
9426 "ms_signed_ptr_modifier" => Ok(Self::MsSignedPtrModifier(::std::boxed::Box::new(
9427 ::treesitter_types::runtime::maybe_grow_stack(|| {
9428 <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
9429 })?,
9430 ))),
9431 "ms_unaligned_ptr_modifier" => Ok(Self::MsUnalignedPtrModifier(
9432 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9433 <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
9434 })?),
9435 )),
9436 "ms_unsigned_ptr_modifier" => Ok(Self::MsUnsignedPtrModifier(::std::boxed::Box::new(
9437 ::treesitter_types::runtime::maybe_grow_stack(|| {
9438 <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
9439 })?,
9440 ))),
9441 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9442 }
9443 }
9444}
9445impl ::treesitter_types::Spanned for MsPointerModifierChildren<'_> {
9446 fn span(&self) -> ::treesitter_types::Span {
9447 match self {
9448 Self::MsRestrictModifier(inner) => inner.span(),
9449 Self::MsSignedPtrModifier(inner) => inner.span(),
9450 Self::MsUnalignedPtrModifier(inner) => inner.span(),
9451 Self::MsUnsignedPtrModifier(inner) => inner.span(),
9452 }
9453 }
9454}
9455#[derive(Debug, Clone, PartialEq, Eq)]
9456pub enum ParameterDeclarationDeclarator<'tree> {
9457 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
9458 Declarator(::std::boxed::Box<Declarator<'tree>>),
9459}
9460impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationDeclarator<'tree> {
9461 #[allow(clippy::collapsible_else_if)]
9462 fn from_node(
9463 node: ::treesitter_types::tree_sitter::Node<'tree>,
9464 src: &'tree [u8],
9465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9466 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9467 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9468 }) {
9469 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
9470 } else {
9471 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9472 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
9473 }) {
9474 Ok(Self::Declarator(::std::boxed::Box::new(v)))
9475 } else {
9476 Err(::treesitter_types::ParseError::unexpected_kind(
9477 node.kind(),
9478 node,
9479 ))
9480 }
9481 }
9482 }
9483}
9484impl ::treesitter_types::Spanned for ParameterDeclarationDeclarator<'_> {
9485 fn span(&self) -> ::treesitter_types::Span {
9486 match self {
9487 Self::AbstractDeclarator(inner) => inner.span(),
9488 Self::Declarator(inner) => inner.span(),
9489 }
9490 }
9491}
9492#[derive(Debug, Clone, PartialEq, Eq)]
9493pub enum ParameterDeclarationChildren<'tree> {
9494 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
9495 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
9496 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
9497 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
9498 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
9499}
9500impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationChildren<'tree> {
9501 #[allow(clippy::collapsible_else_if)]
9502 fn from_node(
9503 node: ::treesitter_types::tree_sitter::Node<'tree>,
9504 src: &'tree [u8],
9505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9506 match node.kind() {
9507 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
9508 ::treesitter_types::runtime::maybe_grow_stack(|| {
9509 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9510 })?,
9511 ))),
9512 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
9513 ::treesitter_types::runtime::maybe_grow_stack(|| {
9514 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9515 })?,
9516 ))),
9517 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
9518 ::treesitter_types::runtime::maybe_grow_stack(|| {
9519 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
9520 })?,
9521 ))),
9522 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
9523 ::treesitter_types::runtime::maybe_grow_stack(|| {
9524 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
9525 })?,
9526 ))),
9527 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
9528 ::treesitter_types::runtime::maybe_grow_stack(|| {
9529 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
9530 })?,
9531 ))),
9532 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9533 }
9534 }
9535}
9536impl ::treesitter_types::Spanned for ParameterDeclarationChildren<'_> {
9537 fn span(&self) -> ::treesitter_types::Span {
9538 match self {
9539 Self::AttributeDeclaration(inner) => inner.span(),
9540 Self::AttributeSpecifier(inner) => inner.span(),
9541 Self::MsDeclspecModifier(inner) => inner.span(),
9542 Self::StorageClassSpecifier(inner) => inner.span(),
9543 Self::TypeQualifier(inner) => inner.span(),
9544 }
9545 }
9546}
9547#[derive(Debug, Clone, PartialEq, Eq)]
9548pub enum ParameterListChildren<'tree> {
9549 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
9550 Identifier(::std::boxed::Box<Identifier<'tree>>),
9551 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
9552 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
9553}
9554impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
9555 #[allow(clippy::collapsible_else_if)]
9556 fn from_node(
9557 node: ::treesitter_types::tree_sitter::Node<'tree>,
9558 src: &'tree [u8],
9559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9560 match node.kind() {
9561 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
9562 ::treesitter_types::runtime::maybe_grow_stack(|| {
9563 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
9564 })?,
9565 ))),
9566 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9567 ::treesitter_types::runtime::maybe_grow_stack(|| {
9568 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9569 })?,
9570 ))),
9571 "parameter_declaration" => Ok(Self::ParameterDeclaration(::std::boxed::Box::new(
9572 ::treesitter_types::runtime::maybe_grow_stack(|| {
9573 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9574 })?,
9575 ))),
9576 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
9577 ::treesitter_types::runtime::maybe_grow_stack(|| {
9578 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
9579 })?,
9580 ))),
9581 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9582 }
9583 }
9584}
9585impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
9586 fn span(&self) -> ::treesitter_types::Span {
9587 match self {
9588 Self::CompoundStatement(inner) => inner.span(),
9589 Self::Identifier(inner) => inner.span(),
9590 Self::ParameterDeclaration(inner) => inner.span(),
9591 Self::VariadicParameter(inner) => inner.span(),
9592 }
9593 }
9594}
9595#[derive(Debug, Clone, PartialEq, Eq)]
9596pub enum ParenthesizedDeclaratorChildren<'tree> {
9597 Declarator(::std::boxed::Box<Declarator<'tree>>),
9598 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
9599 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
9600 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
9601}
9602impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclaratorChildren<'tree> {
9603 #[allow(clippy::collapsible_else_if)]
9604 fn from_node(
9605 node: ::treesitter_types::tree_sitter::Node<'tree>,
9606 src: &'tree [u8],
9607 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9608 match node.kind() {
9609 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
9610 ::treesitter_types::runtime::maybe_grow_stack(|| {
9611 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
9612 })?,
9613 ))),
9614 _other => {
9615 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9616 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
9617 }) {
9618 Ok(Self::Declarator(::std::boxed::Box::new(v)))
9619 } else {
9620 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9621 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9622 }) {
9623 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
9624 } else {
9625 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9626 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9627 }) {
9628 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
9629 } else {
9630 Err(::treesitter_types::ParseError::unexpected_kind(
9631 _other, node,
9632 ))
9633 }
9634 }
9635 }
9636 }
9637 }
9638 }
9639}
9640impl ::treesitter_types::Spanned for ParenthesizedDeclaratorChildren<'_> {
9641 fn span(&self) -> ::treesitter_types::Span {
9642 match self {
9643 Self::Declarator(inner) => inner.span(),
9644 Self::FieldDeclarator(inner) => inner.span(),
9645 Self::TypeDeclarator(inner) => inner.span(),
9646 Self::MsCallModifier(inner) => inner.span(),
9647 }
9648 }
9649}
9650#[derive(Debug, Clone, PartialEq, Eq)]
9651pub enum ParenthesizedExpressionChildren<'tree> {
9652 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
9653 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
9654 Expression(::std::boxed::Box<Expression<'tree>>),
9655 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
9656}
9657impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
9658 #[allow(clippy::collapsible_else_if)]
9659 fn from_node(
9660 node: ::treesitter_types::tree_sitter::Node<'tree>,
9661 src: &'tree [u8],
9662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9663 match node.kind() {
9664 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
9665 ::treesitter_types::runtime::maybe_grow_stack(|| {
9666 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
9667 })?,
9668 ))),
9669 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
9670 ::treesitter_types::runtime::maybe_grow_stack(|| {
9671 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
9672 })?,
9673 ))),
9674 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
9675 ::treesitter_types::runtime::maybe_grow_stack(|| {
9676 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
9677 })?,
9678 ))),
9679 _other => {
9680 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9681 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
9682 }) {
9683 Ok(Self::Expression(::std::boxed::Box::new(v)))
9684 } else {
9685 Err(::treesitter_types::ParseError::unexpected_kind(
9686 _other, node,
9687 ))
9688 }
9689 }
9690 }
9691 }
9692}
9693impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
9694 fn span(&self) -> ::treesitter_types::Span {
9695 match self {
9696 Self::CommaExpression(inner) => inner.span(),
9697 Self::CompoundStatement(inner) => inner.span(),
9698 Self::Expression(inner) => inner.span(),
9699 Self::PreprocDefined(inner) => inner.span(),
9700 }
9701 }
9702}
9703#[derive(Debug, Clone, PartialEq, Eq)]
9704pub enum PointerDeclaratorDeclarator<'tree> {
9705 Declarator(::std::boxed::Box<Declarator<'tree>>),
9706 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
9707 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
9708}
9709impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorDeclarator<'tree> {
9710 #[allow(clippy::collapsible_else_if)]
9711 fn from_node(
9712 node: ::treesitter_types::tree_sitter::Node<'tree>,
9713 src: &'tree [u8],
9714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9715 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9716 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
9717 }) {
9718 Ok(Self::Declarator(::std::boxed::Box::new(v)))
9719 } else {
9720 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9721 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9722 }) {
9723 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
9724 } else {
9725 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
9726 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9727 }) {
9728 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
9729 } else {
9730 Err(::treesitter_types::ParseError::unexpected_kind(
9731 node.kind(),
9732 node,
9733 ))
9734 }
9735 }
9736 }
9737 }
9738}
9739impl ::treesitter_types::Spanned for PointerDeclaratorDeclarator<'_> {
9740 fn span(&self) -> ::treesitter_types::Span {
9741 match self {
9742 Self::Declarator(inner) => inner.span(),
9743 Self::FieldDeclarator(inner) => inner.span(),
9744 Self::TypeDeclarator(inner) => inner.span(),
9745 }
9746 }
9747}
9748#[derive(Debug, Clone, PartialEq, Eq)]
9749pub enum PointerDeclaratorChildren<'tree> {
9750 MsBasedModifier(::std::boxed::Box<MsBasedModifier<'tree>>),
9751 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
9752 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
9753}
9754impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorChildren<'tree> {
9755 #[allow(clippy::collapsible_else_if)]
9756 fn from_node(
9757 node: ::treesitter_types::tree_sitter::Node<'tree>,
9758 src: &'tree [u8],
9759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9760 match node.kind() {
9761 "ms_based_modifier" => Ok(Self::MsBasedModifier(::std::boxed::Box::new(
9762 ::treesitter_types::runtime::maybe_grow_stack(|| {
9763 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)
9764 })?,
9765 ))),
9766 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
9767 ::treesitter_types::runtime::maybe_grow_stack(|| {
9768 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
9769 })?,
9770 ))),
9771 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
9772 ::treesitter_types::runtime::maybe_grow_stack(|| {
9773 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
9774 })?,
9775 ))),
9776 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9777 }
9778 }
9779}
9780impl ::treesitter_types::Spanned for PointerDeclaratorChildren<'_> {
9781 fn span(&self) -> ::treesitter_types::Span {
9782 match self {
9783 Self::MsBasedModifier(inner) => inner.span(),
9784 Self::MsPointerModifier(inner) => inner.span(),
9785 Self::TypeQualifier(inner) => inner.span(),
9786 }
9787 }
9788}
9789#[derive(Debug, Clone, PartialEq, Eq)]
9790pub enum PointerExpressionOperator {
9791 Amp(::treesitter_types::Span),
9792 Star(::treesitter_types::Span),
9793}
9794impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpressionOperator {
9795 #[allow(clippy::collapsible_else_if)]
9796 fn from_node(
9797 node: ::treesitter_types::tree_sitter::Node<'tree>,
9798 _src: &'tree [u8],
9799 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9800 match node.kind() {
9801 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
9802 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
9803 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9804 }
9805 }
9806}
9807impl ::treesitter_types::Spanned for PointerExpressionOperator {
9808 fn span(&self) -> ::treesitter_types::Span {
9809 match self {
9810 Self::Amp(span) => *span,
9811 Self::Star(span) => *span,
9812 }
9813 }
9814}
9815#[derive(Debug, Clone, PartialEq, Eq)]
9816pub enum PreprocElifAlternative<'tree> {
9817 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
9818 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
9819 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
9820}
9821impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
9822 #[allow(clippy::collapsible_else_if)]
9823 fn from_node(
9824 node: ::treesitter_types::tree_sitter::Node<'tree>,
9825 src: &'tree [u8],
9826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9827 match node.kind() {
9828 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
9829 ::treesitter_types::runtime::maybe_grow_stack(|| {
9830 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
9831 })?,
9832 ))),
9833 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
9834 ::treesitter_types::runtime::maybe_grow_stack(|| {
9835 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
9836 })?,
9837 ))),
9838 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
9839 ::treesitter_types::runtime::maybe_grow_stack(|| {
9840 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
9841 })?,
9842 ))),
9843 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9844 }
9845 }
9846}
9847impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
9848 fn span(&self) -> ::treesitter_types::Span {
9849 match self {
9850 Self::PreprocElif(inner) => inner.span(),
9851 Self::PreprocElifdef(inner) => inner.span(),
9852 Self::PreprocElse(inner) => inner.span(),
9853 }
9854 }
9855}
9856#[derive(Debug, Clone, PartialEq, Eq)]
9857pub enum PreprocElifCondition<'tree> {
9858 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
9859 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
9860 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
9861 Identifier(::std::boxed::Box<Identifier<'tree>>),
9862 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
9863 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
9864 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
9865 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
9866}
9867impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
9868 #[allow(clippy::collapsible_else_if)]
9869 fn from_node(
9870 node: ::treesitter_types::tree_sitter::Node<'tree>,
9871 src: &'tree [u8],
9872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9873 match node.kind() {
9874 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
9875 ::treesitter_types::runtime::maybe_grow_stack(|| {
9876 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9877 })?,
9878 ))),
9879 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
9880 ::treesitter_types::runtime::maybe_grow_stack(|| {
9881 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
9882 })?,
9883 ))),
9884 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
9885 ::treesitter_types::runtime::maybe_grow_stack(|| {
9886 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
9887 })?,
9888 ))),
9889 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9890 ::treesitter_types::runtime::maybe_grow_stack(|| {
9891 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9892 })?,
9893 ))),
9894 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
9895 ::treesitter_types::runtime::maybe_grow_stack(|| {
9896 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
9897 })?,
9898 ))),
9899 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
9900 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
9901 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
9902 })?),
9903 )),
9904 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
9905 ::treesitter_types::runtime::maybe_grow_stack(|| {
9906 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
9907 })?,
9908 ))),
9909 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
9910 ::treesitter_types::runtime::maybe_grow_stack(|| {
9911 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9912 })?,
9913 ))),
9914 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9915 }
9916 }
9917}
9918impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
9919 fn span(&self) -> ::treesitter_types::Span {
9920 match self {
9921 Self::BinaryExpression(inner) => inner.span(),
9922 Self::CallExpression(inner) => inner.span(),
9923 Self::CharLiteral(inner) => inner.span(),
9924 Self::Identifier(inner) => inner.span(),
9925 Self::NumberLiteral(inner) => inner.span(),
9926 Self::ParenthesizedExpression(inner) => inner.span(),
9927 Self::PreprocDefined(inner) => inner.span(),
9928 Self::UnaryExpression(inner) => inner.span(),
9929 }
9930 }
9931}
9932#[derive(Debug, Clone, PartialEq, Eq)]
9933pub enum PreprocElifChildren<'tree> {
9934 Declaration(::std::boxed::Box<Declaration<'tree>>),
9935 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
9936 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
9937 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
9938 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
9939 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
9940 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
9941 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
9942 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
9943 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
9944 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
9945 Statement(::std::boxed::Box<Statement<'tree>>),
9946 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
9947 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
9948}
9949impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
9950 #[allow(clippy::collapsible_else_if)]
9951 fn from_node(
9952 node: ::treesitter_types::tree_sitter::Node<'tree>,
9953 src: &'tree [u8],
9954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9955 match node.kind() {
9956 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
9957 ::treesitter_types::runtime::maybe_grow_stack(|| {
9958 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
9959 })?,
9960 ))),
9961 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
9962 ::treesitter_types::runtime::maybe_grow_stack(|| {
9963 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
9964 })?,
9965 ))),
9966 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
9967 ::treesitter_types::runtime::maybe_grow_stack(|| {
9968 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9969 })?,
9970 ))),
9971 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
9972 ::treesitter_types::runtime::maybe_grow_stack(|| {
9973 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
9974 })?,
9975 ))),
9976 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
9977 ::treesitter_types::runtime::maybe_grow_stack(|| {
9978 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
9979 })?,
9980 ))),
9981 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
9982 ::treesitter_types::runtime::maybe_grow_stack(|| {
9983 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
9984 })?,
9985 ))),
9986 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
9987 ::treesitter_types::runtime::maybe_grow_stack(|| {
9988 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
9989 })?,
9990 ))),
9991 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
9992 ::treesitter_types::runtime::maybe_grow_stack(|| {
9993 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
9994 })?,
9995 ))),
9996 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
9997 ::treesitter_types::runtime::maybe_grow_stack(|| {
9998 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
9999 })?,
10000 ))),
10001 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
10002 ::treesitter_types::runtime::maybe_grow_stack(|| {
10003 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
10004 })?,
10005 ))),
10006 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
10007 ::treesitter_types::runtime::maybe_grow_stack(|| {
10008 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
10009 })?,
10010 ))),
10011 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
10012 ::treesitter_types::runtime::maybe_grow_stack(|| {
10013 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10014 })?,
10015 ))),
10016 _other => {
10017 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10018 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10019 }) {
10020 Ok(Self::Statement(::std::boxed::Box::new(v)))
10021 } else {
10022 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10023 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10024 }) {
10025 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
10026 } else {
10027 Err(::treesitter_types::ParseError::unexpected_kind(
10028 _other, node,
10029 ))
10030 }
10031 }
10032 }
10033 }
10034 }
10035}
10036impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
10037 fn span(&self) -> ::treesitter_types::Span {
10038 match self {
10039 Self::Declaration(inner) => inner.span(),
10040 Self::Enumerator(inner) => inner.span(),
10041 Self::FieldDeclaration(inner) => inner.span(),
10042 Self::FunctionDefinition(inner) => inner.span(),
10043 Self::LinkageSpecification(inner) => inner.span(),
10044 Self::PreprocCall(inner) => inner.span(),
10045 Self::PreprocDef(inner) => inner.span(),
10046 Self::PreprocFunctionDef(inner) => inner.span(),
10047 Self::PreprocIf(inner) => inner.span(),
10048 Self::PreprocIfdef(inner) => inner.span(),
10049 Self::PreprocInclude(inner) => inner.span(),
10050 Self::Statement(inner) => inner.span(),
10051 Self::TypeDefinition(inner) => inner.span(),
10052 Self::TypeSpecifier(inner) => inner.span(),
10053 }
10054 }
10055}
10056#[derive(Debug, Clone, PartialEq, Eq)]
10057pub enum PreprocElifdefAlternative<'tree> {
10058 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
10059 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
10060 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
10061}
10062impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefAlternative<'tree> {
10063 #[allow(clippy::collapsible_else_if)]
10064 fn from_node(
10065 node: ::treesitter_types::tree_sitter::Node<'tree>,
10066 src: &'tree [u8],
10067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10068 match node.kind() {
10069 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
10070 ::treesitter_types::runtime::maybe_grow_stack(|| {
10071 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
10072 })?,
10073 ))),
10074 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
10075 ::treesitter_types::runtime::maybe_grow_stack(|| {
10076 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
10077 })?,
10078 ))),
10079 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
10080 ::treesitter_types::runtime::maybe_grow_stack(|| {
10081 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
10082 })?,
10083 ))),
10084 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10085 }
10086 }
10087}
10088impl ::treesitter_types::Spanned for PreprocElifdefAlternative<'_> {
10089 fn span(&self) -> ::treesitter_types::Span {
10090 match self {
10091 Self::PreprocElif(inner) => inner.span(),
10092 Self::PreprocElifdef(inner) => inner.span(),
10093 Self::PreprocElse(inner) => inner.span(),
10094 }
10095 }
10096}
10097#[derive(Debug, Clone, PartialEq, Eq)]
10098pub enum PreprocElifdefChildren<'tree> {
10099 Declaration(::std::boxed::Box<Declaration<'tree>>),
10100 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
10101 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
10102 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
10103 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
10104 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
10105 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
10106 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
10107 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
10108 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
10109 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
10110 Statement(::std::boxed::Box<Statement<'tree>>),
10111 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
10112 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
10113}
10114impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefChildren<'tree> {
10115 #[allow(clippy::collapsible_else_if)]
10116 fn from_node(
10117 node: ::treesitter_types::tree_sitter::Node<'tree>,
10118 src: &'tree [u8],
10119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10120 match node.kind() {
10121 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
10122 ::treesitter_types::runtime::maybe_grow_stack(|| {
10123 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
10124 })?,
10125 ))),
10126 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
10127 ::treesitter_types::runtime::maybe_grow_stack(|| {
10128 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
10129 })?,
10130 ))),
10131 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
10132 ::treesitter_types::runtime::maybe_grow_stack(|| {
10133 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10134 })?,
10135 ))),
10136 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
10137 ::treesitter_types::runtime::maybe_grow_stack(|| {
10138 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10139 })?,
10140 ))),
10141 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
10142 ::treesitter_types::runtime::maybe_grow_stack(|| {
10143 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
10144 })?,
10145 ))),
10146 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
10147 ::treesitter_types::runtime::maybe_grow_stack(|| {
10148 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
10149 })?,
10150 ))),
10151 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
10152 ::treesitter_types::runtime::maybe_grow_stack(|| {
10153 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
10154 })?,
10155 ))),
10156 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
10157 ::treesitter_types::runtime::maybe_grow_stack(|| {
10158 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
10159 })?,
10160 ))),
10161 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
10162 ::treesitter_types::runtime::maybe_grow_stack(|| {
10163 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
10164 })?,
10165 ))),
10166 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
10167 ::treesitter_types::runtime::maybe_grow_stack(|| {
10168 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
10169 })?,
10170 ))),
10171 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
10172 ::treesitter_types::runtime::maybe_grow_stack(|| {
10173 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
10174 })?,
10175 ))),
10176 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
10177 ::treesitter_types::runtime::maybe_grow_stack(|| {
10178 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10179 })?,
10180 ))),
10181 _other => {
10182 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10183 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10184 }) {
10185 Ok(Self::Statement(::std::boxed::Box::new(v)))
10186 } else {
10187 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10188 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10189 }) {
10190 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
10191 } else {
10192 Err(::treesitter_types::ParseError::unexpected_kind(
10193 _other, node,
10194 ))
10195 }
10196 }
10197 }
10198 }
10199 }
10200}
10201impl ::treesitter_types::Spanned for PreprocElifdefChildren<'_> {
10202 fn span(&self) -> ::treesitter_types::Span {
10203 match self {
10204 Self::Declaration(inner) => inner.span(),
10205 Self::Enumerator(inner) => inner.span(),
10206 Self::FieldDeclaration(inner) => inner.span(),
10207 Self::FunctionDefinition(inner) => inner.span(),
10208 Self::LinkageSpecification(inner) => inner.span(),
10209 Self::PreprocCall(inner) => inner.span(),
10210 Self::PreprocDef(inner) => inner.span(),
10211 Self::PreprocFunctionDef(inner) => inner.span(),
10212 Self::PreprocIf(inner) => inner.span(),
10213 Self::PreprocIfdef(inner) => inner.span(),
10214 Self::PreprocInclude(inner) => inner.span(),
10215 Self::Statement(inner) => inner.span(),
10216 Self::TypeDefinition(inner) => inner.span(),
10217 Self::TypeSpecifier(inner) => inner.span(),
10218 }
10219 }
10220}
10221#[derive(Debug, Clone, PartialEq, Eq)]
10222pub enum PreprocElseChildren<'tree> {
10223 Declaration(::std::boxed::Box<Declaration<'tree>>),
10224 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
10225 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
10226 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
10227 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
10228 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
10229 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
10230 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
10231 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
10232 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
10233 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
10234 Statement(::std::boxed::Box<Statement<'tree>>),
10235 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
10236 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
10237}
10238impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
10239 #[allow(clippy::collapsible_else_if)]
10240 fn from_node(
10241 node: ::treesitter_types::tree_sitter::Node<'tree>,
10242 src: &'tree [u8],
10243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10244 match node.kind() {
10245 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
10246 ::treesitter_types::runtime::maybe_grow_stack(|| {
10247 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
10248 })?,
10249 ))),
10250 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
10251 ::treesitter_types::runtime::maybe_grow_stack(|| {
10252 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
10253 })?,
10254 ))),
10255 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
10256 ::treesitter_types::runtime::maybe_grow_stack(|| {
10257 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10258 })?,
10259 ))),
10260 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
10261 ::treesitter_types::runtime::maybe_grow_stack(|| {
10262 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10263 })?,
10264 ))),
10265 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
10266 ::treesitter_types::runtime::maybe_grow_stack(|| {
10267 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
10268 })?,
10269 ))),
10270 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
10271 ::treesitter_types::runtime::maybe_grow_stack(|| {
10272 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
10273 })?,
10274 ))),
10275 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
10276 ::treesitter_types::runtime::maybe_grow_stack(|| {
10277 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
10278 })?,
10279 ))),
10280 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
10281 ::treesitter_types::runtime::maybe_grow_stack(|| {
10282 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
10283 })?,
10284 ))),
10285 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
10286 ::treesitter_types::runtime::maybe_grow_stack(|| {
10287 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
10288 })?,
10289 ))),
10290 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
10291 ::treesitter_types::runtime::maybe_grow_stack(|| {
10292 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
10293 })?,
10294 ))),
10295 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
10296 ::treesitter_types::runtime::maybe_grow_stack(|| {
10297 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
10298 })?,
10299 ))),
10300 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
10301 ::treesitter_types::runtime::maybe_grow_stack(|| {
10302 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10303 })?,
10304 ))),
10305 _other => {
10306 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10307 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10308 }) {
10309 Ok(Self::Statement(::std::boxed::Box::new(v)))
10310 } else {
10311 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10312 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10313 }) {
10314 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
10315 } else {
10316 Err(::treesitter_types::ParseError::unexpected_kind(
10317 _other, node,
10318 ))
10319 }
10320 }
10321 }
10322 }
10323 }
10324}
10325impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
10326 fn span(&self) -> ::treesitter_types::Span {
10327 match self {
10328 Self::Declaration(inner) => inner.span(),
10329 Self::Enumerator(inner) => inner.span(),
10330 Self::FieldDeclaration(inner) => inner.span(),
10331 Self::FunctionDefinition(inner) => inner.span(),
10332 Self::LinkageSpecification(inner) => inner.span(),
10333 Self::PreprocCall(inner) => inner.span(),
10334 Self::PreprocDef(inner) => inner.span(),
10335 Self::PreprocFunctionDef(inner) => inner.span(),
10336 Self::PreprocIf(inner) => inner.span(),
10337 Self::PreprocIfdef(inner) => inner.span(),
10338 Self::PreprocInclude(inner) => inner.span(),
10339 Self::Statement(inner) => inner.span(),
10340 Self::TypeDefinition(inner) => inner.span(),
10341 Self::TypeSpecifier(inner) => inner.span(),
10342 }
10343 }
10344}
10345#[derive(Debug, Clone, PartialEq, Eq)]
10346pub enum PreprocIfAlternative<'tree> {
10347 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
10348 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
10349 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
10350}
10351impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
10352 #[allow(clippy::collapsible_else_if)]
10353 fn from_node(
10354 node: ::treesitter_types::tree_sitter::Node<'tree>,
10355 src: &'tree [u8],
10356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10357 match node.kind() {
10358 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
10359 ::treesitter_types::runtime::maybe_grow_stack(|| {
10360 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
10361 })?,
10362 ))),
10363 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
10364 ::treesitter_types::runtime::maybe_grow_stack(|| {
10365 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
10366 })?,
10367 ))),
10368 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
10369 ::treesitter_types::runtime::maybe_grow_stack(|| {
10370 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
10371 })?,
10372 ))),
10373 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10374 }
10375 }
10376}
10377impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
10378 fn span(&self) -> ::treesitter_types::Span {
10379 match self {
10380 Self::PreprocElif(inner) => inner.span(),
10381 Self::PreprocElifdef(inner) => inner.span(),
10382 Self::PreprocElse(inner) => inner.span(),
10383 }
10384 }
10385}
10386#[derive(Debug, Clone, PartialEq, Eq)]
10387pub enum PreprocIfCondition<'tree> {
10388 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
10389 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
10390 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
10391 Identifier(::std::boxed::Box<Identifier<'tree>>),
10392 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
10393 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10394 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
10395 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
10396}
10397impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
10398 #[allow(clippy::collapsible_else_if)]
10399 fn from_node(
10400 node: ::treesitter_types::tree_sitter::Node<'tree>,
10401 src: &'tree [u8],
10402 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10403 match node.kind() {
10404 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
10405 ::treesitter_types::runtime::maybe_grow_stack(|| {
10406 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10407 })?,
10408 ))),
10409 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
10410 ::treesitter_types::runtime::maybe_grow_stack(|| {
10411 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10412 })?,
10413 ))),
10414 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
10415 ::treesitter_types::runtime::maybe_grow_stack(|| {
10416 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
10417 })?,
10418 ))),
10419 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10420 ::treesitter_types::runtime::maybe_grow_stack(|| {
10421 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10422 })?,
10423 ))),
10424 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
10425 ::treesitter_types::runtime::maybe_grow_stack(|| {
10426 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
10427 })?,
10428 ))),
10429 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
10430 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10431 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
10432 })?),
10433 )),
10434 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
10435 ::treesitter_types::runtime::maybe_grow_stack(|| {
10436 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
10437 })?,
10438 ))),
10439 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
10440 ::treesitter_types::runtime::maybe_grow_stack(|| {
10441 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10442 })?,
10443 ))),
10444 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10445 }
10446 }
10447}
10448impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
10449 fn span(&self) -> ::treesitter_types::Span {
10450 match self {
10451 Self::BinaryExpression(inner) => inner.span(),
10452 Self::CallExpression(inner) => inner.span(),
10453 Self::CharLiteral(inner) => inner.span(),
10454 Self::Identifier(inner) => inner.span(),
10455 Self::NumberLiteral(inner) => inner.span(),
10456 Self::ParenthesizedExpression(inner) => inner.span(),
10457 Self::PreprocDefined(inner) => inner.span(),
10458 Self::UnaryExpression(inner) => inner.span(),
10459 }
10460 }
10461}
10462#[derive(Debug, Clone, PartialEq, Eq)]
10463pub enum PreprocIfChildren<'tree> {
10464 Declaration(::std::boxed::Box<Declaration<'tree>>),
10465 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
10466 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
10467 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
10468 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
10469 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
10470 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
10471 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
10472 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
10473 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
10474 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
10475 Statement(::std::boxed::Box<Statement<'tree>>),
10476 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
10477 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
10478}
10479impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
10480 #[allow(clippy::collapsible_else_if)]
10481 fn from_node(
10482 node: ::treesitter_types::tree_sitter::Node<'tree>,
10483 src: &'tree [u8],
10484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10485 match node.kind() {
10486 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
10487 ::treesitter_types::runtime::maybe_grow_stack(|| {
10488 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
10489 })?,
10490 ))),
10491 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
10492 ::treesitter_types::runtime::maybe_grow_stack(|| {
10493 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
10494 })?,
10495 ))),
10496 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
10497 ::treesitter_types::runtime::maybe_grow_stack(|| {
10498 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10499 })?,
10500 ))),
10501 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
10502 ::treesitter_types::runtime::maybe_grow_stack(|| {
10503 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10504 })?,
10505 ))),
10506 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
10507 ::treesitter_types::runtime::maybe_grow_stack(|| {
10508 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
10509 })?,
10510 ))),
10511 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
10512 ::treesitter_types::runtime::maybe_grow_stack(|| {
10513 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
10514 })?,
10515 ))),
10516 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
10517 ::treesitter_types::runtime::maybe_grow_stack(|| {
10518 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
10519 })?,
10520 ))),
10521 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
10522 ::treesitter_types::runtime::maybe_grow_stack(|| {
10523 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
10524 })?,
10525 ))),
10526 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
10527 ::treesitter_types::runtime::maybe_grow_stack(|| {
10528 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
10529 })?,
10530 ))),
10531 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
10532 ::treesitter_types::runtime::maybe_grow_stack(|| {
10533 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
10534 })?,
10535 ))),
10536 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
10537 ::treesitter_types::runtime::maybe_grow_stack(|| {
10538 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
10539 })?,
10540 ))),
10541 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
10542 ::treesitter_types::runtime::maybe_grow_stack(|| {
10543 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10544 })?,
10545 ))),
10546 _other => {
10547 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10548 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10549 }) {
10550 Ok(Self::Statement(::std::boxed::Box::new(v)))
10551 } else {
10552 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10553 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10554 }) {
10555 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
10556 } else {
10557 Err(::treesitter_types::ParseError::unexpected_kind(
10558 _other, node,
10559 ))
10560 }
10561 }
10562 }
10563 }
10564 }
10565}
10566impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
10567 fn span(&self) -> ::treesitter_types::Span {
10568 match self {
10569 Self::Declaration(inner) => inner.span(),
10570 Self::Enumerator(inner) => inner.span(),
10571 Self::FieldDeclaration(inner) => inner.span(),
10572 Self::FunctionDefinition(inner) => inner.span(),
10573 Self::LinkageSpecification(inner) => inner.span(),
10574 Self::PreprocCall(inner) => inner.span(),
10575 Self::PreprocDef(inner) => inner.span(),
10576 Self::PreprocFunctionDef(inner) => inner.span(),
10577 Self::PreprocIf(inner) => inner.span(),
10578 Self::PreprocIfdef(inner) => inner.span(),
10579 Self::PreprocInclude(inner) => inner.span(),
10580 Self::Statement(inner) => inner.span(),
10581 Self::TypeDefinition(inner) => inner.span(),
10582 Self::TypeSpecifier(inner) => inner.span(),
10583 }
10584 }
10585}
10586#[derive(Debug, Clone, PartialEq, Eq)]
10587pub enum PreprocIfdefAlternative<'tree> {
10588 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
10589 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
10590 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
10591}
10592impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefAlternative<'tree> {
10593 #[allow(clippy::collapsible_else_if)]
10594 fn from_node(
10595 node: ::treesitter_types::tree_sitter::Node<'tree>,
10596 src: &'tree [u8],
10597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10598 match node.kind() {
10599 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
10600 ::treesitter_types::runtime::maybe_grow_stack(|| {
10601 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
10602 })?,
10603 ))),
10604 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
10605 ::treesitter_types::runtime::maybe_grow_stack(|| {
10606 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
10607 })?,
10608 ))),
10609 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
10610 ::treesitter_types::runtime::maybe_grow_stack(|| {
10611 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
10612 })?,
10613 ))),
10614 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10615 }
10616 }
10617}
10618impl ::treesitter_types::Spanned for PreprocIfdefAlternative<'_> {
10619 fn span(&self) -> ::treesitter_types::Span {
10620 match self {
10621 Self::PreprocElif(inner) => inner.span(),
10622 Self::PreprocElifdef(inner) => inner.span(),
10623 Self::PreprocElse(inner) => inner.span(),
10624 }
10625 }
10626}
10627#[derive(Debug, Clone, PartialEq, Eq)]
10628pub enum PreprocIfdefChildren<'tree> {
10629 Declaration(::std::boxed::Box<Declaration<'tree>>),
10630 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
10631 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
10632 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
10633 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
10634 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
10635 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
10636 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
10637 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
10638 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
10639 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
10640 Statement(::std::boxed::Box<Statement<'tree>>),
10641 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
10642 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
10643}
10644impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefChildren<'tree> {
10645 #[allow(clippy::collapsible_else_if)]
10646 fn from_node(
10647 node: ::treesitter_types::tree_sitter::Node<'tree>,
10648 src: &'tree [u8],
10649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10650 match node.kind() {
10651 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
10652 ::treesitter_types::runtime::maybe_grow_stack(|| {
10653 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
10654 })?,
10655 ))),
10656 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
10657 ::treesitter_types::runtime::maybe_grow_stack(|| {
10658 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
10659 })?,
10660 ))),
10661 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
10662 ::treesitter_types::runtime::maybe_grow_stack(|| {
10663 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
10664 })?,
10665 ))),
10666 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
10667 ::treesitter_types::runtime::maybe_grow_stack(|| {
10668 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10669 })?,
10670 ))),
10671 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
10672 ::treesitter_types::runtime::maybe_grow_stack(|| {
10673 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
10674 })?,
10675 ))),
10676 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
10677 ::treesitter_types::runtime::maybe_grow_stack(|| {
10678 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
10679 })?,
10680 ))),
10681 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
10682 ::treesitter_types::runtime::maybe_grow_stack(|| {
10683 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
10684 })?,
10685 ))),
10686 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
10687 ::treesitter_types::runtime::maybe_grow_stack(|| {
10688 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
10689 })?,
10690 ))),
10691 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
10692 ::treesitter_types::runtime::maybe_grow_stack(|| {
10693 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
10694 })?,
10695 ))),
10696 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
10697 ::treesitter_types::runtime::maybe_grow_stack(|| {
10698 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
10699 })?,
10700 ))),
10701 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
10702 ::treesitter_types::runtime::maybe_grow_stack(|| {
10703 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
10704 })?,
10705 ))),
10706 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
10707 ::treesitter_types::runtime::maybe_grow_stack(|| {
10708 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
10709 })?,
10710 ))),
10711 _other => {
10712 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10713 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
10714 }) {
10715 Ok(Self::Statement(::std::boxed::Box::new(v)))
10716 } else {
10717 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10718 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10719 }) {
10720 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
10721 } else {
10722 Err(::treesitter_types::ParseError::unexpected_kind(
10723 _other, node,
10724 ))
10725 }
10726 }
10727 }
10728 }
10729 }
10730}
10731impl ::treesitter_types::Spanned for PreprocIfdefChildren<'_> {
10732 fn span(&self) -> ::treesitter_types::Span {
10733 match self {
10734 Self::Declaration(inner) => inner.span(),
10735 Self::Enumerator(inner) => inner.span(),
10736 Self::FieldDeclaration(inner) => inner.span(),
10737 Self::FunctionDefinition(inner) => inner.span(),
10738 Self::LinkageSpecification(inner) => inner.span(),
10739 Self::PreprocCall(inner) => inner.span(),
10740 Self::PreprocDef(inner) => inner.span(),
10741 Self::PreprocFunctionDef(inner) => inner.span(),
10742 Self::PreprocIf(inner) => inner.span(),
10743 Self::PreprocIfdef(inner) => inner.span(),
10744 Self::PreprocInclude(inner) => inner.span(),
10745 Self::Statement(inner) => inner.span(),
10746 Self::TypeDefinition(inner) => inner.span(),
10747 Self::TypeSpecifier(inner) => inner.span(),
10748 }
10749 }
10750}
10751#[derive(Debug, Clone, PartialEq, Eq)]
10752pub enum PreprocIncludePath<'tree> {
10753 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
10754 Identifier(::std::boxed::Box<Identifier<'tree>>),
10755 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
10756 SystemLibString(::std::boxed::Box<SystemLibString<'tree>>),
10757}
10758impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIncludePath<'tree> {
10759 #[allow(clippy::collapsible_else_if)]
10760 fn from_node(
10761 node: ::treesitter_types::tree_sitter::Node<'tree>,
10762 src: &'tree [u8],
10763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10764 match node.kind() {
10765 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
10766 ::treesitter_types::runtime::maybe_grow_stack(|| {
10767 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10768 })?,
10769 ))),
10770 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10771 ::treesitter_types::runtime::maybe_grow_stack(|| {
10772 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
10773 })?,
10774 ))),
10775 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
10776 ::treesitter_types::runtime::maybe_grow_stack(|| {
10777 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
10778 })?,
10779 ))),
10780 "system_lib_string" => Ok(Self::SystemLibString(::std::boxed::Box::new(
10781 ::treesitter_types::runtime::maybe_grow_stack(|| {
10782 <SystemLibString as ::treesitter_types::FromNode>::from_node(node, src)
10783 })?,
10784 ))),
10785 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10786 }
10787 }
10788}
10789impl ::treesitter_types::Spanned for PreprocIncludePath<'_> {
10790 fn span(&self) -> ::treesitter_types::Span {
10791 match self {
10792 Self::CallExpression(inner) => inner.span(),
10793 Self::Identifier(inner) => inner.span(),
10794 Self::StringLiteral(inner) => inner.span(),
10795 Self::SystemLibString(inner) => inner.span(),
10796 }
10797 }
10798}
10799#[derive(Debug, Clone, PartialEq, Eq)]
10800pub enum ReturnStatementChildren<'tree> {
10801 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
10802 Expression(::std::boxed::Box<Expression<'tree>>),
10803}
10804impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
10805 #[allow(clippy::collapsible_else_if)]
10806 fn from_node(
10807 node: ::treesitter_types::tree_sitter::Node<'tree>,
10808 src: &'tree [u8],
10809 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10810 match node.kind() {
10811 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
10812 ::treesitter_types::runtime::maybe_grow_stack(|| {
10813 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
10814 })?,
10815 ))),
10816 _other => {
10817 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10818 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10819 }) {
10820 Ok(Self::Expression(::std::boxed::Box::new(v)))
10821 } else {
10822 Err(::treesitter_types::ParseError::unexpected_kind(
10823 _other, node,
10824 ))
10825 }
10826 }
10827 }
10828 }
10829}
10830impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
10831 fn span(&self) -> ::treesitter_types::Span {
10832 match self {
10833 Self::CommaExpression(inner) => inner.span(),
10834 Self::Expression(inner) => inner.span(),
10835 }
10836 }
10837}
10838#[derive(Debug, Clone, PartialEq, Eq)]
10839pub enum SehTryStatementChildren<'tree> {
10840 SehExceptClause(::std::boxed::Box<SehExceptClause<'tree>>),
10841 SehFinallyClause(::std::boxed::Box<SehFinallyClause<'tree>>),
10842}
10843impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatementChildren<'tree> {
10844 #[allow(clippy::collapsible_else_if)]
10845 fn from_node(
10846 node: ::treesitter_types::tree_sitter::Node<'tree>,
10847 src: &'tree [u8],
10848 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10849 match node.kind() {
10850 "seh_except_clause" => Ok(Self::SehExceptClause(::std::boxed::Box::new(
10851 ::treesitter_types::runtime::maybe_grow_stack(|| {
10852 <SehExceptClause as ::treesitter_types::FromNode>::from_node(node, src)
10853 })?,
10854 ))),
10855 "seh_finally_clause" => Ok(Self::SehFinallyClause(::std::boxed::Box::new(
10856 ::treesitter_types::runtime::maybe_grow_stack(|| {
10857 <SehFinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
10858 })?,
10859 ))),
10860 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10861 }
10862 }
10863}
10864impl ::treesitter_types::Spanned for SehTryStatementChildren<'_> {
10865 fn span(&self) -> ::treesitter_types::Span {
10866 match self {
10867 Self::SehExceptClause(inner) => inner.span(),
10868 Self::SehFinallyClause(inner) => inner.span(),
10869 }
10870 }
10871}
10872#[derive(Debug, Clone, PartialEq, Eq)]
10873pub enum SizedTypeSpecifierType<'tree> {
10874 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
10875 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10876}
10877impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifierType<'tree> {
10878 #[allow(clippy::collapsible_else_if)]
10879 fn from_node(
10880 node: ::treesitter_types::tree_sitter::Node<'tree>,
10881 src: &'tree [u8],
10882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10883 match node.kind() {
10884 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
10885 ::treesitter_types::runtime::maybe_grow_stack(|| {
10886 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
10887 })?,
10888 ))),
10889 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10890 ::treesitter_types::runtime::maybe_grow_stack(|| {
10891 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
10892 })?,
10893 ))),
10894 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10895 }
10896 }
10897}
10898impl ::treesitter_types::Spanned for SizedTypeSpecifierType<'_> {
10899 fn span(&self) -> ::treesitter_types::Span {
10900 match self {
10901 Self::PrimitiveType(inner) => inner.span(),
10902 Self::TypeIdentifier(inner) => inner.span(),
10903 }
10904 }
10905}
10906#[derive(Debug, Clone, PartialEq, Eq)]
10907pub enum StringLiteralChildren<'tree> {
10908 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
10909 StringContent(::std::boxed::Box<StringContent<'tree>>),
10910}
10911impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
10912 #[allow(clippy::collapsible_else_if)]
10913 fn from_node(
10914 node: ::treesitter_types::tree_sitter::Node<'tree>,
10915 src: &'tree [u8],
10916 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10917 match node.kind() {
10918 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
10919 ::treesitter_types::runtime::maybe_grow_stack(|| {
10920 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
10921 })?,
10922 ))),
10923 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
10924 ::treesitter_types::runtime::maybe_grow_stack(|| {
10925 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
10926 })?,
10927 ))),
10928 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10929 }
10930 }
10931}
10932impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
10933 fn span(&self) -> ::treesitter_types::Span {
10934 match self {
10935 Self::EscapeSequence(inner) => inner.span(),
10936 Self::StringContent(inner) => inner.span(),
10937 }
10938 }
10939}
10940#[derive(Debug, Clone, PartialEq, Eq)]
10941pub enum StructSpecifierChildren<'tree> {
10942 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
10943 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
10944}
10945impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifierChildren<'tree> {
10946 #[allow(clippy::collapsible_else_if)]
10947 fn from_node(
10948 node: ::treesitter_types::tree_sitter::Node<'tree>,
10949 src: &'tree [u8],
10950 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10951 match node.kind() {
10952 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
10953 ::treesitter_types::runtime::maybe_grow_stack(|| {
10954 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
10955 })?,
10956 ))),
10957 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
10958 ::treesitter_types::runtime::maybe_grow_stack(|| {
10959 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
10960 })?,
10961 ))),
10962 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10963 }
10964 }
10965}
10966impl ::treesitter_types::Spanned for StructSpecifierChildren<'_> {
10967 fn span(&self) -> ::treesitter_types::Span {
10968 match self {
10969 Self::AttributeSpecifier(inner) => inner.span(),
10970 Self::MsDeclspecModifier(inner) => inner.span(),
10971 }
10972 }
10973}
10974#[derive(Debug, Clone, PartialEq, Eq)]
10975pub enum TranslationUnitChildren<'tree> {
10976 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
10977 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
10978 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
10979 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
10980 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
10981 Declaration(::std::boxed::Box<Declaration<'tree>>),
10982 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
10983 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
10984 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
10985 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
10986 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
10987 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
10988 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
10989 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
10990 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
10991 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
10992 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
10993 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
10994 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
10995 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
10996 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
10997 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
10998 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
10999 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
11000 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
11001}
11002impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnitChildren<'tree> {
11003 #[allow(clippy::collapsible_else_if)]
11004 fn from_node(
11005 node: ::treesitter_types::tree_sitter::Node<'tree>,
11006 src: &'tree [u8],
11007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11008 match node.kind() {
11009 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
11010 ::treesitter_types::runtime::maybe_grow_stack(|| {
11011 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
11012 })?,
11013 ))),
11014 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
11015 ::treesitter_types::runtime::maybe_grow_stack(|| {
11016 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
11017 })?,
11018 ))),
11019 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
11020 ::treesitter_types::runtime::maybe_grow_stack(|| {
11021 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
11022 })?,
11023 ))),
11024 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
11025 ::treesitter_types::runtime::maybe_grow_stack(|| {
11026 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
11027 })?,
11028 ))),
11029 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
11030 ::treesitter_types::runtime::maybe_grow_stack(|| {
11031 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
11032 })?,
11033 ))),
11034 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
11035 ::treesitter_types::runtime::maybe_grow_stack(|| {
11036 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
11037 })?,
11038 ))),
11039 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
11040 ::treesitter_types::runtime::maybe_grow_stack(|| {
11041 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
11042 })?,
11043 ))),
11044 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
11045 ::treesitter_types::runtime::maybe_grow_stack(|| {
11046 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
11047 })?,
11048 ))),
11049 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
11050 ::treesitter_types::runtime::maybe_grow_stack(|| {
11051 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
11052 })?,
11053 ))),
11054 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
11055 ::treesitter_types::runtime::maybe_grow_stack(|| {
11056 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
11057 })?,
11058 ))),
11059 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
11060 ::treesitter_types::runtime::maybe_grow_stack(|| {
11061 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
11062 })?,
11063 ))),
11064 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
11065 ::treesitter_types::runtime::maybe_grow_stack(|| {
11066 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
11067 })?,
11068 ))),
11069 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
11070 ::treesitter_types::runtime::maybe_grow_stack(|| {
11071 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
11072 })?,
11073 ))),
11074 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
11075 ::treesitter_types::runtime::maybe_grow_stack(|| {
11076 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
11077 })?,
11078 ))),
11079 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
11080 ::treesitter_types::runtime::maybe_grow_stack(|| {
11081 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
11082 })?,
11083 ))),
11084 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
11085 ::treesitter_types::runtime::maybe_grow_stack(|| {
11086 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
11087 })?,
11088 ))),
11089 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
11090 ::treesitter_types::runtime::maybe_grow_stack(|| {
11091 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
11092 })?,
11093 ))),
11094 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
11095 ::treesitter_types::runtime::maybe_grow_stack(|| {
11096 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
11097 })?,
11098 ))),
11099 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
11100 ::treesitter_types::runtime::maybe_grow_stack(|| {
11101 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
11102 })?,
11103 ))),
11104 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
11105 ::treesitter_types::runtime::maybe_grow_stack(|| {
11106 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
11107 })?,
11108 ))),
11109 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
11110 ::treesitter_types::runtime::maybe_grow_stack(|| {
11111 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
11112 })?,
11113 ))),
11114 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
11115 ::treesitter_types::runtime::maybe_grow_stack(|| {
11116 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
11117 })?,
11118 ))),
11119 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
11120 ::treesitter_types::runtime::maybe_grow_stack(|| {
11121 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
11122 })?,
11123 ))),
11124 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
11125 ::treesitter_types::runtime::maybe_grow_stack(|| {
11126 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
11127 })?,
11128 ))),
11129 _other => {
11130 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11131 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11132 }) {
11133 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
11134 } else {
11135 Err(::treesitter_types::ParseError::unexpected_kind(
11136 _other, node,
11137 ))
11138 }
11139 }
11140 }
11141 }
11142}
11143impl ::treesitter_types::Spanned for TranslationUnitChildren<'_> {
11144 fn span(&self) -> ::treesitter_types::Span {
11145 match self {
11146 Self::AttributedStatement(inner) => inner.span(),
11147 Self::BreakStatement(inner) => inner.span(),
11148 Self::CaseStatement(inner) => inner.span(),
11149 Self::CompoundStatement(inner) => inner.span(),
11150 Self::ContinueStatement(inner) => inner.span(),
11151 Self::Declaration(inner) => inner.span(),
11152 Self::DoStatement(inner) => inner.span(),
11153 Self::ExpressionStatement(inner) => inner.span(),
11154 Self::ForStatement(inner) => inner.span(),
11155 Self::FunctionDefinition(inner) => inner.span(),
11156 Self::GotoStatement(inner) => inner.span(),
11157 Self::IfStatement(inner) => inner.span(),
11158 Self::LabeledStatement(inner) => inner.span(),
11159 Self::LinkageSpecification(inner) => inner.span(),
11160 Self::PreprocCall(inner) => inner.span(),
11161 Self::PreprocDef(inner) => inner.span(),
11162 Self::PreprocFunctionDef(inner) => inner.span(),
11163 Self::PreprocIf(inner) => inner.span(),
11164 Self::PreprocIfdef(inner) => inner.span(),
11165 Self::PreprocInclude(inner) => inner.span(),
11166 Self::ReturnStatement(inner) => inner.span(),
11167 Self::SwitchStatement(inner) => inner.span(),
11168 Self::TypeDefinition(inner) => inner.span(),
11169 Self::TypeSpecifier(inner) => inner.span(),
11170 Self::WhileStatement(inner) => inner.span(),
11171 }
11172 }
11173}
11174#[derive(Debug, Clone, PartialEq, Eq)]
11175pub enum TypeDefinitionChildren<'tree> {
11176 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
11177 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
11178}
11179impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinitionChildren<'tree> {
11180 #[allow(clippy::collapsible_else_if)]
11181 fn from_node(
11182 node: ::treesitter_types::tree_sitter::Node<'tree>,
11183 src: &'tree [u8],
11184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11185 match node.kind() {
11186 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
11187 ::treesitter_types::runtime::maybe_grow_stack(|| {
11188 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11189 })?,
11190 ))),
11191 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
11192 ::treesitter_types::runtime::maybe_grow_stack(|| {
11193 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
11194 })?,
11195 ))),
11196 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11197 }
11198 }
11199}
11200impl ::treesitter_types::Spanned for TypeDefinitionChildren<'_> {
11201 fn span(&self) -> ::treesitter_types::Span {
11202 match self {
11203 Self::AttributeSpecifier(inner) => inner.span(),
11204 Self::TypeQualifier(inner) => inner.span(),
11205 }
11206 }
11207}
11208#[derive(Debug, Clone, PartialEq, Eq)]
11209pub enum UnaryExpressionArgument<'tree> {
11210 Expression(::std::boxed::Box<Expression<'tree>>),
11211 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
11212}
11213impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
11214 #[allow(clippy::collapsible_else_if)]
11215 fn from_node(
11216 node: ::treesitter_types::tree_sitter::Node<'tree>,
11217 src: &'tree [u8],
11218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11219 match node.kind() {
11220 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
11221 ::treesitter_types::runtime::maybe_grow_stack(|| {
11222 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
11223 })?,
11224 ))),
11225 _other => {
11226 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11227 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11228 }) {
11229 Ok(Self::Expression(::std::boxed::Box::new(v)))
11230 } else {
11231 Err(::treesitter_types::ParseError::unexpected_kind(
11232 _other, node,
11233 ))
11234 }
11235 }
11236 }
11237 }
11238}
11239impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
11240 fn span(&self) -> ::treesitter_types::Span {
11241 match self {
11242 Self::Expression(inner) => inner.span(),
11243 Self::PreprocDefined(inner) => inner.span(),
11244 }
11245 }
11246}
11247#[derive(Debug, Clone, PartialEq, Eq)]
11248pub enum UnaryExpressionOperator {
11249 Bang(::treesitter_types::Span),
11250 Plus(::treesitter_types::Span),
11251 Minus(::treesitter_types::Span),
11252 Tilde(::treesitter_types::Span),
11253}
11254impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
11255 #[allow(clippy::collapsible_else_if)]
11256 fn from_node(
11257 node: ::treesitter_types::tree_sitter::Node<'tree>,
11258 _src: &'tree [u8],
11259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11260 match node.kind() {
11261 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
11262 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
11263 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
11264 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
11265 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11266 }
11267 }
11268}
11269impl ::treesitter_types::Spanned for UnaryExpressionOperator {
11270 fn span(&self) -> ::treesitter_types::Span {
11271 match self {
11272 Self::Bang(span) => *span,
11273 Self::Plus(span) => *span,
11274 Self::Minus(span) => *span,
11275 Self::Tilde(span) => *span,
11276 }
11277 }
11278}
11279#[derive(Debug, Clone, PartialEq, Eq)]
11280pub enum UnionSpecifierChildren<'tree> {
11281 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
11282 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
11283}
11284impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifierChildren<'tree> {
11285 #[allow(clippy::collapsible_else_if)]
11286 fn from_node(
11287 node: ::treesitter_types::tree_sitter::Node<'tree>,
11288 src: &'tree [u8],
11289 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11290 match node.kind() {
11291 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
11292 ::treesitter_types::runtime::maybe_grow_stack(|| {
11293 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11294 })?,
11295 ))),
11296 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
11297 ::treesitter_types::runtime::maybe_grow_stack(|| {
11298 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
11299 })?,
11300 ))),
11301 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11302 }
11303 }
11304}
11305impl ::treesitter_types::Spanned for UnionSpecifierChildren<'_> {
11306 fn span(&self) -> ::treesitter_types::Span {
11307 match self {
11308 Self::AttributeSpecifier(inner) => inner.span(),
11309 Self::MsDeclspecModifier(inner) => inner.span(),
11310 }
11311 }
11312}
11313#[derive(Debug, Clone, PartialEq, Eq)]
11314pub enum UpdateExpressionOperator {
11315 PlusPlus(::treesitter_types::Span),
11316 MinusMinus(::treesitter_types::Span),
11317}
11318impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
11319 #[allow(clippy::collapsible_else_if)]
11320 fn from_node(
11321 node: ::treesitter_types::tree_sitter::Node<'tree>,
11322 _src: &'tree [u8],
11323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11324 match node.kind() {
11325 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
11326 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
11327 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11328 }
11329 }
11330}
11331impl ::treesitter_types::Spanned for UpdateExpressionOperator {
11332 fn span(&self) -> ::treesitter_types::Span {
11333 match self {
11334 Self::PlusPlus(span) => *span,
11335 Self::MinusMinus(span) => *span,
11336 }
11337 }
11338}
11339#[derive(Debug, Clone, PartialEq, Eq)]
11340pub enum AnyNode<'tree> {
11341 AbstractDeclarator(AbstractDeclarator<'tree>),
11342 Declarator(Declarator<'tree>),
11343 FieldDeclarator(FieldDeclarator<'tree>),
11344 TypeDeclarator(TypeDeclarator<'tree>),
11345 Expression(Expression<'tree>),
11346 Statement(Statement<'tree>),
11347 TypeSpecifier(TypeSpecifier<'tree>),
11348 AbstractArrayDeclarator(AbstractArrayDeclarator<'tree>),
11349 AbstractFunctionDeclarator(AbstractFunctionDeclarator<'tree>),
11350 AbstractParenthesizedDeclarator(AbstractParenthesizedDeclarator<'tree>),
11351 AbstractPointerDeclarator(AbstractPointerDeclarator<'tree>),
11352 AlignasQualifier(AlignasQualifier<'tree>),
11353 AlignofExpression(AlignofExpression<'tree>),
11354 ArgumentList(ArgumentList<'tree>),
11355 ArrayDeclarator(ArrayDeclarator<'tree>),
11356 AssignmentExpression(AssignmentExpression<'tree>),
11357 Attribute(Attribute<'tree>),
11358 AttributeDeclaration(AttributeDeclaration<'tree>),
11359 AttributeSpecifier(AttributeSpecifier<'tree>),
11360 AttributedDeclarator(AttributedDeclarator<'tree>),
11361 AttributedStatement(AttributedStatement<'tree>),
11362 BinaryExpression(BinaryExpression<'tree>),
11363 BitfieldClause(BitfieldClause<'tree>),
11364 BreakStatement(BreakStatement<'tree>),
11365 CallExpression(CallExpression<'tree>),
11366 CaseStatement(CaseStatement<'tree>),
11367 CastExpression(CastExpression<'tree>),
11368 CharLiteral(CharLiteral<'tree>),
11369 CommaExpression(CommaExpression<'tree>),
11370 CompoundLiteralExpression(CompoundLiteralExpression<'tree>),
11371 CompoundStatement(CompoundStatement<'tree>),
11372 ConcatenatedString(ConcatenatedString<'tree>),
11373 ConditionalExpression(ConditionalExpression<'tree>),
11374 ContinueStatement(ContinueStatement<'tree>),
11375 Declaration(Declaration<'tree>),
11376 DeclarationList(DeclarationList<'tree>),
11377 DoStatement(DoStatement<'tree>),
11378 ElseClause(ElseClause<'tree>),
11379 EnumSpecifier(EnumSpecifier<'tree>),
11380 Enumerator(Enumerator<'tree>),
11381 EnumeratorList(EnumeratorList<'tree>),
11382 ExpressionStatement(ExpressionStatement<'tree>),
11383 ExtensionExpression(ExtensionExpression<'tree>),
11384 FieldDeclaration(FieldDeclaration<'tree>),
11385 FieldDeclarationList(FieldDeclarationList<'tree>),
11386 FieldDesignator(FieldDesignator<'tree>),
11387 FieldExpression(FieldExpression<'tree>),
11388 ForStatement(ForStatement<'tree>),
11389 FunctionDeclarator(FunctionDeclarator<'tree>),
11390 FunctionDefinition(FunctionDefinition<'tree>),
11391 GenericExpression(GenericExpression<'tree>),
11392 GnuAsmClobberList(GnuAsmClobberList<'tree>),
11393 GnuAsmExpression(GnuAsmExpression<'tree>),
11394 GnuAsmGotoList(GnuAsmGotoList<'tree>),
11395 GnuAsmInputOperand(GnuAsmInputOperand<'tree>),
11396 GnuAsmInputOperandList(GnuAsmInputOperandList<'tree>),
11397 GnuAsmOutputOperand(GnuAsmOutputOperand<'tree>),
11398 GnuAsmOutputOperandList(GnuAsmOutputOperandList<'tree>),
11399 GnuAsmQualifier(GnuAsmQualifier<'tree>),
11400 GotoStatement(GotoStatement<'tree>),
11401 IfStatement(IfStatement<'tree>),
11402 InitDeclarator(InitDeclarator<'tree>),
11403 InitializerList(InitializerList<'tree>),
11404 InitializerPair(InitializerPair<'tree>),
11405 LabeledStatement(LabeledStatement<'tree>),
11406 LinkageSpecification(LinkageSpecification<'tree>),
11407 MacroTypeSpecifier(MacroTypeSpecifier<'tree>),
11408 MsBasedModifier(MsBasedModifier<'tree>),
11409 MsCallModifier(MsCallModifier<'tree>),
11410 MsDeclspecModifier(MsDeclspecModifier<'tree>),
11411 MsPointerModifier(MsPointerModifier<'tree>),
11412 MsUnalignedPtrModifier(MsUnalignedPtrModifier<'tree>),
11413 Null(Null<'tree>),
11414 OffsetofExpression(OffsetofExpression<'tree>),
11415 ParameterDeclaration(ParameterDeclaration<'tree>),
11416 ParameterList(ParameterList<'tree>),
11417 ParenthesizedDeclarator(ParenthesizedDeclarator<'tree>),
11418 ParenthesizedExpression(ParenthesizedExpression<'tree>),
11419 PointerDeclarator(PointerDeclarator<'tree>),
11420 PointerExpression(PointerExpression<'tree>),
11421 PreprocCall(PreprocCall<'tree>),
11422 PreprocDef(PreprocDef<'tree>),
11423 PreprocDefined(PreprocDefined<'tree>),
11424 PreprocElif(PreprocElif<'tree>),
11425 PreprocElifdef(PreprocElifdef<'tree>),
11426 PreprocElse(PreprocElse<'tree>),
11427 PreprocFunctionDef(PreprocFunctionDef<'tree>),
11428 PreprocIf(PreprocIf<'tree>),
11429 PreprocIfdef(PreprocIfdef<'tree>),
11430 PreprocInclude(PreprocInclude<'tree>),
11431 PreprocParams(PreprocParams<'tree>),
11432 ReturnStatement(ReturnStatement<'tree>),
11433 SehExceptClause(SehExceptClause<'tree>),
11434 SehFinallyClause(SehFinallyClause<'tree>),
11435 SehLeaveStatement(SehLeaveStatement<'tree>),
11436 SehTryStatement(SehTryStatement<'tree>),
11437 SizedTypeSpecifier(SizedTypeSpecifier<'tree>),
11438 SizeofExpression(SizeofExpression<'tree>),
11439 StorageClassSpecifier(StorageClassSpecifier<'tree>),
11440 StringLiteral(StringLiteral<'tree>),
11441 StructSpecifier(StructSpecifier<'tree>),
11442 SubscriptDesignator(SubscriptDesignator<'tree>),
11443 SubscriptExpression(SubscriptExpression<'tree>),
11444 SubscriptRangeDesignator(SubscriptRangeDesignator<'tree>),
11445 SwitchStatement(SwitchStatement<'tree>),
11446 TranslationUnit(TranslationUnit<'tree>),
11447 TypeDefinition(TypeDefinition<'tree>),
11448 TypeDescriptor(TypeDescriptor<'tree>),
11449 TypeQualifier(TypeQualifier<'tree>),
11450 UnaryExpression(UnaryExpression<'tree>),
11451 UnionSpecifier(UnionSpecifier<'tree>),
11452 UpdateExpression(UpdateExpression<'tree>),
11453 VariadicParameter(VariadicParameter<'tree>),
11454 WhileStatement(WhileStatement<'tree>),
11455 Character(Character<'tree>),
11456 Comment(Comment<'tree>),
11457 EscapeSequence(EscapeSequence<'tree>),
11458 False(False<'tree>),
11459 FieldIdentifier(FieldIdentifier<'tree>),
11460 Identifier(Identifier<'tree>),
11461 MsRestrictModifier(MsRestrictModifier<'tree>),
11462 MsSignedPtrModifier(MsSignedPtrModifier<'tree>),
11463 MsUnsignedPtrModifier(MsUnsignedPtrModifier<'tree>),
11464 NumberLiteral(NumberLiteral<'tree>),
11465 PreprocArg(PreprocArg<'tree>),
11466 PreprocDirective(PreprocDirective<'tree>),
11467 PrimitiveType(PrimitiveType<'tree>),
11468 StatementIdentifier(StatementIdentifier<'tree>),
11469 StringContent(StringContent<'tree>),
11470 SystemLibString(SystemLibString<'tree>),
11471 True(True<'tree>),
11472 TypeIdentifier(TypeIdentifier<'tree>),
11473 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
11474}
11475impl<'tree> AnyNode<'tree> {
11476 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
11477 match node.kind() {
11478 "_abstract_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11479 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11480 })
11481 .map(Self::AbstractDeclarator)
11482 .unwrap_or(Self::Unknown(node)),
11483 "_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11484 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
11485 })
11486 .map(Self::Declarator)
11487 .unwrap_or(Self::Unknown(node)),
11488 "_field_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11489 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11490 })
11491 .map(Self::FieldDeclarator)
11492 .unwrap_or(Self::Unknown(node)),
11493 "_type_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11494 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11495 })
11496 .map(Self::TypeDeclarator)
11497 .unwrap_or(Self::Unknown(node)),
11498 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11499 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11500 })
11501 .map(Self::Expression)
11502 .unwrap_or(Self::Unknown(node)),
11503 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11504 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11505 })
11506 .map(Self::Statement)
11507 .unwrap_or(Self::Unknown(node)),
11508 "type_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11509 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11510 })
11511 .map(Self::TypeSpecifier)
11512 .unwrap_or(Self::Unknown(node)),
11513 "abstract_array_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11514 <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11515 })
11516 .map(Self::AbstractArrayDeclarator)
11517 .unwrap_or(Self::Unknown(node)),
11518 "abstract_function_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11519 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11520 })
11521 .map(Self::AbstractFunctionDeclarator)
11522 .unwrap_or(Self::Unknown(node)),
11523 "abstract_parenthesized_declarator" => {
11524 ::treesitter_types::runtime::maybe_grow_stack(|| {
11525 <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
11526 node, src,
11527 )
11528 })
11529 .map(Self::AbstractParenthesizedDeclarator)
11530 .unwrap_or(Self::Unknown(node))
11531 }
11532 "abstract_pointer_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11533 <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11534 })
11535 .map(Self::AbstractPointerDeclarator)
11536 .unwrap_or(Self::Unknown(node)),
11537 "alignas_qualifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11538 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)
11539 })
11540 .map(Self::AlignasQualifier)
11541 .unwrap_or(Self::Unknown(node)),
11542 "alignof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11543 <AlignofExpression as ::treesitter_types::FromNode>::from_node(node, src)
11544 })
11545 .map(Self::AlignofExpression)
11546 .unwrap_or(Self::Unknown(node)),
11547 "argument_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11548 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
11549 })
11550 .map(Self::ArgumentList)
11551 .unwrap_or(Self::Unknown(node)),
11552 "array_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11553 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11554 })
11555 .map(Self::ArrayDeclarator)
11556 .unwrap_or(Self::Unknown(node)),
11557 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11558 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
11559 })
11560 .map(Self::AssignmentExpression)
11561 .unwrap_or(Self::Unknown(node)),
11562 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11563 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
11564 })
11565 .map(Self::Attribute)
11566 .unwrap_or(Self::Unknown(node)),
11567 "attribute_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11568 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11569 })
11570 .map(Self::AttributeDeclaration)
11571 .unwrap_or(Self::Unknown(node)),
11572 "attribute_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11573 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11574 })
11575 .map(Self::AttributeSpecifier)
11576 .unwrap_or(Self::Unknown(node)),
11577 "attributed_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11578 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11579 })
11580 .map(Self::AttributedDeclarator)
11581 .unwrap_or(Self::Unknown(node)),
11582 "attributed_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11583 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
11584 })
11585 .map(Self::AttributedStatement)
11586 .unwrap_or(Self::Unknown(node)),
11587 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11588 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
11589 })
11590 .map(Self::BinaryExpression)
11591 .unwrap_or(Self::Unknown(node)),
11592 "bitfield_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11593 <BitfieldClause as ::treesitter_types::FromNode>::from_node(node, src)
11594 })
11595 .map(Self::BitfieldClause)
11596 .unwrap_or(Self::Unknown(node)),
11597 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11598 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
11599 })
11600 .map(Self::BreakStatement)
11601 .unwrap_or(Self::Unknown(node)),
11602 "call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11603 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
11604 })
11605 .map(Self::CallExpression)
11606 .unwrap_or(Self::Unknown(node)),
11607 "case_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11608 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
11609 })
11610 .map(Self::CaseStatement)
11611 .unwrap_or(Self::Unknown(node)),
11612 "cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11613 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
11614 })
11615 .map(Self::CastExpression)
11616 .unwrap_or(Self::Unknown(node)),
11617 "char_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11618 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11619 })
11620 .map(Self::CharLiteral)
11621 .unwrap_or(Self::Unknown(node)),
11622 "comma_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11623 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
11624 })
11625 .map(Self::CommaExpression)
11626 .unwrap_or(Self::Unknown(node)),
11627 "compound_literal_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11628 <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(node, src)
11629 })
11630 .map(Self::CompoundLiteralExpression)
11631 .unwrap_or(Self::Unknown(node)),
11632 "compound_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11633 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
11634 })
11635 .map(Self::CompoundStatement)
11636 .unwrap_or(Self::Unknown(node)),
11637 "concatenated_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11638 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
11639 })
11640 .map(Self::ConcatenatedString)
11641 .unwrap_or(Self::Unknown(node)),
11642 "conditional_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11643 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
11644 })
11645 .map(Self::ConditionalExpression)
11646 .unwrap_or(Self::Unknown(node)),
11647 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11648 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
11649 })
11650 .map(Self::ContinueStatement)
11651 .unwrap_or(Self::Unknown(node)),
11652 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11653 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
11654 })
11655 .map(Self::Declaration)
11656 .unwrap_or(Self::Unknown(node)),
11657 "declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11658 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
11659 })
11660 .map(Self::DeclarationList)
11661 .unwrap_or(Self::Unknown(node)),
11662 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11663 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
11664 })
11665 .map(Self::DoStatement)
11666 .unwrap_or(Self::Unknown(node)),
11667 "else_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11668 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
11669 })
11670 .map(Self::ElseClause)
11671 .unwrap_or(Self::Unknown(node)),
11672 "enum_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11673 <EnumSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11674 })
11675 .map(Self::EnumSpecifier)
11676 .unwrap_or(Self::Unknown(node)),
11677 "enumerator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11678 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
11679 })
11680 .map(Self::Enumerator)
11681 .unwrap_or(Self::Unknown(node)),
11682 "enumerator_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11683 <EnumeratorList as ::treesitter_types::FromNode>::from_node(node, src)
11684 })
11685 .map(Self::EnumeratorList)
11686 .unwrap_or(Self::Unknown(node)),
11687 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11688 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
11689 })
11690 .map(Self::ExpressionStatement)
11691 .unwrap_or(Self::Unknown(node)),
11692 "extension_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11693 <ExtensionExpression as ::treesitter_types::FromNode>::from_node(node, src)
11694 })
11695 .map(Self::ExtensionExpression)
11696 .unwrap_or(Self::Unknown(node)),
11697 "field_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11698 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11699 })
11700 .map(Self::FieldDeclaration)
11701 .unwrap_or(Self::Unknown(node)),
11702 "field_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11703 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
11704 })
11705 .map(Self::FieldDeclarationList)
11706 .unwrap_or(Self::Unknown(node)),
11707 "field_designator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11708 <FieldDesignator as ::treesitter_types::FromNode>::from_node(node, src)
11709 })
11710 .map(Self::FieldDesignator)
11711 .unwrap_or(Self::Unknown(node)),
11712 "field_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11713 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
11714 })
11715 .map(Self::FieldExpression)
11716 .unwrap_or(Self::Unknown(node)),
11717 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11718 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
11719 })
11720 .map(Self::ForStatement)
11721 .unwrap_or(Self::Unknown(node)),
11722 "function_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11723 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11724 })
11725 .map(Self::FunctionDeclarator)
11726 .unwrap_or(Self::Unknown(node)),
11727 "function_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11728 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
11729 })
11730 .map(Self::FunctionDefinition)
11731 .unwrap_or(Self::Unknown(node)),
11732 "generic_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11733 <GenericExpression as ::treesitter_types::FromNode>::from_node(node, src)
11734 })
11735 .map(Self::GenericExpression)
11736 .unwrap_or(Self::Unknown(node)),
11737 "gnu_asm_clobber_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11738 <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(node, src)
11739 })
11740 .map(Self::GnuAsmClobberList)
11741 .unwrap_or(Self::Unknown(node)),
11742 "gnu_asm_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11743 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
11744 })
11745 .map(Self::GnuAsmExpression)
11746 .unwrap_or(Self::Unknown(node)),
11747 "gnu_asm_goto_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11748 <GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(node, src)
11749 })
11750 .map(Self::GnuAsmGotoList)
11751 .unwrap_or(Self::Unknown(node)),
11752 "gnu_asm_input_operand" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11753 <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(node, src)
11754 })
11755 .map(Self::GnuAsmInputOperand)
11756 .unwrap_or(Self::Unknown(node)),
11757 "gnu_asm_input_operand_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11758 <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(node, src)
11759 })
11760 .map(Self::GnuAsmInputOperandList)
11761 .unwrap_or(Self::Unknown(node)),
11762 "gnu_asm_output_operand" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11763 <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(node, src)
11764 })
11765 .map(Self::GnuAsmOutputOperand)
11766 .unwrap_or(Self::Unknown(node)),
11767 "gnu_asm_output_operand_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11768 <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(node, src)
11769 })
11770 .map(Self::GnuAsmOutputOperandList)
11771 .unwrap_or(Self::Unknown(node)),
11772 "gnu_asm_qualifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11773 <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(node, src)
11774 })
11775 .map(Self::GnuAsmQualifier)
11776 .unwrap_or(Self::Unknown(node)),
11777 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11778 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
11779 })
11780 .map(Self::GotoStatement)
11781 .unwrap_or(Self::Unknown(node)),
11782 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11783 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
11784 })
11785 .map(Self::IfStatement)
11786 .unwrap_or(Self::Unknown(node)),
11787 "init_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11788 <InitDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11789 })
11790 .map(Self::InitDeclarator)
11791 .unwrap_or(Self::Unknown(node)),
11792 "initializer_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11793 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
11794 })
11795 .map(Self::InitializerList)
11796 .unwrap_or(Self::Unknown(node)),
11797 "initializer_pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11798 <InitializerPair as ::treesitter_types::FromNode>::from_node(node, src)
11799 })
11800 .map(Self::InitializerPair)
11801 .unwrap_or(Self::Unknown(node)),
11802 "labeled_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11803 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
11804 })
11805 .map(Self::LabeledStatement)
11806 .unwrap_or(Self::Unknown(node)),
11807 "linkage_specification" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11808 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
11809 })
11810 .map(Self::LinkageSpecification)
11811 .unwrap_or(Self::Unknown(node)),
11812 "macro_type_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11813 <MacroTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11814 })
11815 .map(Self::MacroTypeSpecifier)
11816 .unwrap_or(Self::Unknown(node)),
11817 "ms_based_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11818 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)
11819 })
11820 .map(Self::MsBasedModifier)
11821 .unwrap_or(Self::Unknown(node)),
11822 "ms_call_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11823 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
11824 })
11825 .map(Self::MsCallModifier)
11826 .unwrap_or(Self::Unknown(node)),
11827 "ms_declspec_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11828 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
11829 })
11830 .map(Self::MsDeclspecModifier)
11831 .unwrap_or(Self::Unknown(node)),
11832 "ms_pointer_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11833 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
11834 })
11835 .map(Self::MsPointerModifier)
11836 .unwrap_or(Self::Unknown(node)),
11837 "ms_unaligned_ptr_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11838 <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
11839 })
11840 .map(Self::MsUnalignedPtrModifier)
11841 .unwrap_or(Self::Unknown(node)),
11842 "null" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11843 <Null as ::treesitter_types::FromNode>::from_node(node, src)
11844 })
11845 .map(Self::Null)
11846 .unwrap_or(Self::Unknown(node)),
11847 "offsetof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11848 <OffsetofExpression as ::treesitter_types::FromNode>::from_node(node, src)
11849 })
11850 .map(Self::OffsetofExpression)
11851 .unwrap_or(Self::Unknown(node)),
11852 "parameter_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11853 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11854 })
11855 .map(Self::ParameterDeclaration)
11856 .unwrap_or(Self::Unknown(node)),
11857 "parameter_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11858 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
11859 })
11860 .map(Self::ParameterList)
11861 .unwrap_or(Self::Unknown(node)),
11862 "parenthesized_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11863 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11864 })
11865 .map(Self::ParenthesizedDeclarator)
11866 .unwrap_or(Self::Unknown(node)),
11867 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11868 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
11869 })
11870 .map(Self::ParenthesizedExpression)
11871 .unwrap_or(Self::Unknown(node)),
11872 "pointer_declarator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11873 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
11874 })
11875 .map(Self::PointerDeclarator)
11876 .unwrap_or(Self::Unknown(node)),
11877 "pointer_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11878 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)
11879 })
11880 .map(Self::PointerExpression)
11881 .unwrap_or(Self::Unknown(node)),
11882 "preproc_call" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11883 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
11884 })
11885 .map(Self::PreprocCall)
11886 .unwrap_or(Self::Unknown(node)),
11887 "preproc_def" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11888 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
11889 })
11890 .map(Self::PreprocDef)
11891 .unwrap_or(Self::Unknown(node)),
11892 "preproc_defined" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11893 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
11894 })
11895 .map(Self::PreprocDefined)
11896 .unwrap_or(Self::Unknown(node)),
11897 "preproc_elif" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11898 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
11899 })
11900 .map(Self::PreprocElif)
11901 .unwrap_or(Self::Unknown(node)),
11902 "preproc_elifdef" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11903 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
11904 })
11905 .map(Self::PreprocElifdef)
11906 .unwrap_or(Self::Unknown(node)),
11907 "preproc_else" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11908 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
11909 })
11910 .map(Self::PreprocElse)
11911 .unwrap_or(Self::Unknown(node)),
11912 "preproc_function_def" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11913 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
11914 })
11915 .map(Self::PreprocFunctionDef)
11916 .unwrap_or(Self::Unknown(node)),
11917 "preproc_if" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11918 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
11919 })
11920 .map(Self::PreprocIf)
11921 .unwrap_or(Self::Unknown(node)),
11922 "preproc_ifdef" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11923 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
11924 })
11925 .map(Self::PreprocIfdef)
11926 .unwrap_or(Self::Unknown(node)),
11927 "preproc_include" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11928 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
11929 })
11930 .map(Self::PreprocInclude)
11931 .unwrap_or(Self::Unknown(node)),
11932 "preproc_params" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11933 <PreprocParams as ::treesitter_types::FromNode>::from_node(node, src)
11934 })
11935 .map(Self::PreprocParams)
11936 .unwrap_or(Self::Unknown(node)),
11937 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11938 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
11939 })
11940 .map(Self::ReturnStatement)
11941 .unwrap_or(Self::Unknown(node)),
11942 "seh_except_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11943 <SehExceptClause as ::treesitter_types::FromNode>::from_node(node, src)
11944 })
11945 .map(Self::SehExceptClause)
11946 .unwrap_or(Self::Unknown(node)),
11947 "seh_finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11948 <SehFinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
11949 })
11950 .map(Self::SehFinallyClause)
11951 .unwrap_or(Self::Unknown(node)),
11952 "seh_leave_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11953 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
11954 })
11955 .map(Self::SehLeaveStatement)
11956 .unwrap_or(Self::Unknown(node)),
11957 "seh_try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11958 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
11959 })
11960 .map(Self::SehTryStatement)
11961 .unwrap_or(Self::Unknown(node)),
11962 "sized_type_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11963 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11964 })
11965 .map(Self::SizedTypeSpecifier)
11966 .unwrap_or(Self::Unknown(node)),
11967 "sizeof_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11968 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
11969 })
11970 .map(Self::SizeofExpression)
11971 .unwrap_or(Self::Unknown(node)),
11972 "storage_class_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11973 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11974 })
11975 .map(Self::StorageClassSpecifier)
11976 .unwrap_or(Self::Unknown(node)),
11977 "string_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11978 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
11979 })
11980 .map(Self::StringLiteral)
11981 .unwrap_or(Self::Unknown(node)),
11982 "struct_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11983 <StructSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
11984 })
11985 .map(Self::StructSpecifier)
11986 .unwrap_or(Self::Unknown(node)),
11987 "subscript_designator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11988 <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(node, src)
11989 })
11990 .map(Self::SubscriptDesignator)
11991 .unwrap_or(Self::Unknown(node)),
11992 "subscript_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11993 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
11994 })
11995 .map(Self::SubscriptExpression)
11996 .unwrap_or(Self::Unknown(node)),
11997 "subscript_range_designator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
11998 <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(node, src)
11999 })
12000 .map(Self::SubscriptRangeDesignator)
12001 .unwrap_or(Self::Unknown(node)),
12002 "switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12003 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
12004 })
12005 .map(Self::SwitchStatement)
12006 .unwrap_or(Self::Unknown(node)),
12007 "translation_unit" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12008 <TranslationUnit as ::treesitter_types::FromNode>::from_node(node, src)
12009 })
12010 .map(Self::TranslationUnit)
12011 .unwrap_or(Self::Unknown(node)),
12012 "type_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12013 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
12014 })
12015 .map(Self::TypeDefinition)
12016 .unwrap_or(Self::Unknown(node)),
12017 "type_descriptor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12018 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
12019 })
12020 .map(Self::TypeDescriptor)
12021 .unwrap_or(Self::Unknown(node)),
12022 "type_qualifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12023 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
12024 })
12025 .map(Self::TypeQualifier)
12026 .unwrap_or(Self::Unknown(node)),
12027 "unary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12028 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
12029 })
12030 .map(Self::UnaryExpression)
12031 .unwrap_or(Self::Unknown(node)),
12032 "union_specifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12033 <UnionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12034 })
12035 .map(Self::UnionSpecifier)
12036 .unwrap_or(Self::Unknown(node)),
12037 "update_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12038 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
12039 })
12040 .map(Self::UpdateExpression)
12041 .unwrap_or(Self::Unknown(node)),
12042 "variadic_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12043 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
12044 })
12045 .map(Self::VariadicParameter)
12046 .unwrap_or(Self::Unknown(node)),
12047 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12048 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
12049 })
12050 .map(Self::WhileStatement)
12051 .unwrap_or(Self::Unknown(node)),
12052 "character" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12053 <Character as ::treesitter_types::FromNode>::from_node(node, src)
12054 })
12055 .map(Self::Character)
12056 .unwrap_or(Self::Unknown(node)),
12057 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12058 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
12059 })
12060 .map(Self::Comment)
12061 .unwrap_or(Self::Unknown(node)),
12062 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12063 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
12064 })
12065 .map(Self::EscapeSequence)
12066 .unwrap_or(Self::Unknown(node)),
12067 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12068 <False as ::treesitter_types::FromNode>::from_node(node, src)
12069 })
12070 .map(Self::False)
12071 .unwrap_or(Self::Unknown(node)),
12072 "field_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12073 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12074 })
12075 .map(Self::FieldIdentifier)
12076 .unwrap_or(Self::Unknown(node)),
12077 "identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12078 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
12079 })
12080 .map(Self::Identifier)
12081 .unwrap_or(Self::Unknown(node)),
12082 "ms_restrict_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12083 <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(node, src)
12084 })
12085 .map(Self::MsRestrictModifier)
12086 .unwrap_or(Self::Unknown(node)),
12087 "ms_signed_ptr_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12088 <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
12089 })
12090 .map(Self::MsSignedPtrModifier)
12091 .unwrap_or(Self::Unknown(node)),
12092 "ms_unsigned_ptr_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12093 <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
12094 })
12095 .map(Self::MsUnsignedPtrModifier)
12096 .unwrap_or(Self::Unknown(node)),
12097 "number_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12098 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12099 })
12100 .map(Self::NumberLiteral)
12101 .unwrap_or(Self::Unknown(node)),
12102 "preproc_arg" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12103 <PreprocArg as ::treesitter_types::FromNode>::from_node(node, src)
12104 })
12105 .map(Self::PreprocArg)
12106 .unwrap_or(Self::Unknown(node)),
12107 "preproc_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12108 <PreprocDirective as ::treesitter_types::FromNode>::from_node(node, src)
12109 })
12110 .map(Self::PreprocDirective)
12111 .unwrap_or(Self::Unknown(node)),
12112 "primitive_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12113 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
12114 })
12115 .map(Self::PrimitiveType)
12116 .unwrap_or(Self::Unknown(node)),
12117 "statement_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12118 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12119 })
12120 .map(Self::StatementIdentifier)
12121 .unwrap_or(Self::Unknown(node)),
12122 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12123 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
12124 })
12125 .map(Self::StringContent)
12126 .unwrap_or(Self::Unknown(node)),
12127 "system_lib_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12128 <SystemLibString as ::treesitter_types::FromNode>::from_node(node, src)
12129 })
12130 .map(Self::SystemLibString)
12131 .unwrap_or(Self::Unknown(node)),
12132 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12133 <True as ::treesitter_types::FromNode>::from_node(node, src)
12134 })
12135 .map(Self::True)
12136 .unwrap_or(Self::Unknown(node)),
12137 "type_identifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
12138 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
12139 })
12140 .map(Self::TypeIdentifier)
12141 .unwrap_or(Self::Unknown(node)),
12142 _ => Self::Unknown(node),
12143 }
12144 }
12145}
12146impl ::treesitter_types::Spanned for AnyNode<'_> {
12147 fn span(&self) -> ::treesitter_types::Span {
12148 match self {
12149 Self::AbstractDeclarator(inner) => inner.span(),
12150 Self::Declarator(inner) => inner.span(),
12151 Self::FieldDeclarator(inner) => inner.span(),
12152 Self::TypeDeclarator(inner) => inner.span(),
12153 Self::Expression(inner) => inner.span(),
12154 Self::Statement(inner) => inner.span(),
12155 Self::TypeSpecifier(inner) => inner.span(),
12156 Self::AbstractArrayDeclarator(inner) => inner.span(),
12157 Self::AbstractFunctionDeclarator(inner) => inner.span(),
12158 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
12159 Self::AbstractPointerDeclarator(inner) => inner.span(),
12160 Self::AlignasQualifier(inner) => inner.span(),
12161 Self::AlignofExpression(inner) => inner.span(),
12162 Self::ArgumentList(inner) => inner.span(),
12163 Self::ArrayDeclarator(inner) => inner.span(),
12164 Self::AssignmentExpression(inner) => inner.span(),
12165 Self::Attribute(inner) => inner.span(),
12166 Self::AttributeDeclaration(inner) => inner.span(),
12167 Self::AttributeSpecifier(inner) => inner.span(),
12168 Self::AttributedDeclarator(inner) => inner.span(),
12169 Self::AttributedStatement(inner) => inner.span(),
12170 Self::BinaryExpression(inner) => inner.span(),
12171 Self::BitfieldClause(inner) => inner.span(),
12172 Self::BreakStatement(inner) => inner.span(),
12173 Self::CallExpression(inner) => inner.span(),
12174 Self::CaseStatement(inner) => inner.span(),
12175 Self::CastExpression(inner) => inner.span(),
12176 Self::CharLiteral(inner) => inner.span(),
12177 Self::CommaExpression(inner) => inner.span(),
12178 Self::CompoundLiteralExpression(inner) => inner.span(),
12179 Self::CompoundStatement(inner) => inner.span(),
12180 Self::ConcatenatedString(inner) => inner.span(),
12181 Self::ConditionalExpression(inner) => inner.span(),
12182 Self::ContinueStatement(inner) => inner.span(),
12183 Self::Declaration(inner) => inner.span(),
12184 Self::DeclarationList(inner) => inner.span(),
12185 Self::DoStatement(inner) => inner.span(),
12186 Self::ElseClause(inner) => inner.span(),
12187 Self::EnumSpecifier(inner) => inner.span(),
12188 Self::Enumerator(inner) => inner.span(),
12189 Self::EnumeratorList(inner) => inner.span(),
12190 Self::ExpressionStatement(inner) => inner.span(),
12191 Self::ExtensionExpression(inner) => inner.span(),
12192 Self::FieldDeclaration(inner) => inner.span(),
12193 Self::FieldDeclarationList(inner) => inner.span(),
12194 Self::FieldDesignator(inner) => inner.span(),
12195 Self::FieldExpression(inner) => inner.span(),
12196 Self::ForStatement(inner) => inner.span(),
12197 Self::FunctionDeclarator(inner) => inner.span(),
12198 Self::FunctionDefinition(inner) => inner.span(),
12199 Self::GenericExpression(inner) => inner.span(),
12200 Self::GnuAsmClobberList(inner) => inner.span(),
12201 Self::GnuAsmExpression(inner) => inner.span(),
12202 Self::GnuAsmGotoList(inner) => inner.span(),
12203 Self::GnuAsmInputOperand(inner) => inner.span(),
12204 Self::GnuAsmInputOperandList(inner) => inner.span(),
12205 Self::GnuAsmOutputOperand(inner) => inner.span(),
12206 Self::GnuAsmOutputOperandList(inner) => inner.span(),
12207 Self::GnuAsmQualifier(inner) => inner.span(),
12208 Self::GotoStatement(inner) => inner.span(),
12209 Self::IfStatement(inner) => inner.span(),
12210 Self::InitDeclarator(inner) => inner.span(),
12211 Self::InitializerList(inner) => inner.span(),
12212 Self::InitializerPair(inner) => inner.span(),
12213 Self::LabeledStatement(inner) => inner.span(),
12214 Self::LinkageSpecification(inner) => inner.span(),
12215 Self::MacroTypeSpecifier(inner) => inner.span(),
12216 Self::MsBasedModifier(inner) => inner.span(),
12217 Self::MsCallModifier(inner) => inner.span(),
12218 Self::MsDeclspecModifier(inner) => inner.span(),
12219 Self::MsPointerModifier(inner) => inner.span(),
12220 Self::MsUnalignedPtrModifier(inner) => inner.span(),
12221 Self::Null(inner) => inner.span(),
12222 Self::OffsetofExpression(inner) => inner.span(),
12223 Self::ParameterDeclaration(inner) => inner.span(),
12224 Self::ParameterList(inner) => inner.span(),
12225 Self::ParenthesizedDeclarator(inner) => inner.span(),
12226 Self::ParenthesizedExpression(inner) => inner.span(),
12227 Self::PointerDeclarator(inner) => inner.span(),
12228 Self::PointerExpression(inner) => inner.span(),
12229 Self::PreprocCall(inner) => inner.span(),
12230 Self::PreprocDef(inner) => inner.span(),
12231 Self::PreprocDefined(inner) => inner.span(),
12232 Self::PreprocElif(inner) => inner.span(),
12233 Self::PreprocElifdef(inner) => inner.span(),
12234 Self::PreprocElse(inner) => inner.span(),
12235 Self::PreprocFunctionDef(inner) => inner.span(),
12236 Self::PreprocIf(inner) => inner.span(),
12237 Self::PreprocIfdef(inner) => inner.span(),
12238 Self::PreprocInclude(inner) => inner.span(),
12239 Self::PreprocParams(inner) => inner.span(),
12240 Self::ReturnStatement(inner) => inner.span(),
12241 Self::SehExceptClause(inner) => inner.span(),
12242 Self::SehFinallyClause(inner) => inner.span(),
12243 Self::SehLeaveStatement(inner) => inner.span(),
12244 Self::SehTryStatement(inner) => inner.span(),
12245 Self::SizedTypeSpecifier(inner) => inner.span(),
12246 Self::SizeofExpression(inner) => inner.span(),
12247 Self::StorageClassSpecifier(inner) => inner.span(),
12248 Self::StringLiteral(inner) => inner.span(),
12249 Self::StructSpecifier(inner) => inner.span(),
12250 Self::SubscriptDesignator(inner) => inner.span(),
12251 Self::SubscriptExpression(inner) => inner.span(),
12252 Self::SubscriptRangeDesignator(inner) => inner.span(),
12253 Self::SwitchStatement(inner) => inner.span(),
12254 Self::TranslationUnit(inner) => inner.span(),
12255 Self::TypeDefinition(inner) => inner.span(),
12256 Self::TypeDescriptor(inner) => inner.span(),
12257 Self::TypeQualifier(inner) => inner.span(),
12258 Self::UnaryExpression(inner) => inner.span(),
12259 Self::UnionSpecifier(inner) => inner.span(),
12260 Self::UpdateExpression(inner) => inner.span(),
12261 Self::VariadicParameter(inner) => inner.span(),
12262 Self::WhileStatement(inner) => inner.span(),
12263 Self::Character(inner) => inner.span(),
12264 Self::Comment(inner) => inner.span(),
12265 Self::EscapeSequence(inner) => inner.span(),
12266 Self::False(inner) => inner.span(),
12267 Self::FieldIdentifier(inner) => inner.span(),
12268 Self::Identifier(inner) => inner.span(),
12269 Self::MsRestrictModifier(inner) => inner.span(),
12270 Self::MsSignedPtrModifier(inner) => inner.span(),
12271 Self::MsUnsignedPtrModifier(inner) => inner.span(),
12272 Self::NumberLiteral(inner) => inner.span(),
12273 Self::PreprocArg(inner) => inner.span(),
12274 Self::PreprocDirective(inner) => inner.span(),
12275 Self::PrimitiveType(inner) => inner.span(),
12276 Self::StatementIdentifier(inner) => inner.span(),
12277 Self::StringContent(inner) => inner.span(),
12278 Self::SystemLibString(inner) => inner.span(),
12279 Self::True(inner) => inner.span(),
12280 Self::TypeIdentifier(inner) => inner.span(),
12281 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
12282 }
12283 }
12284}