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 AbstractReferenceDeclarator(::std::boxed::Box<AbstractReferenceDeclarator<'tree>>),
8}
9impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractDeclarator<'tree> {
10 #[allow(clippy::collapsible_else_if)]
11 fn from_node(
12 node: ::treesitter_types::tree_sitter::Node<'tree>,
13 src: &'tree [u8],
14 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15 match node.kind() {
16 "abstract_array_declarator" => Ok(Self::AbstractArrayDeclarator(
17 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18 <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19 })?),
20 )),
21 "abstract_function_declarator" => Ok(Self::AbstractFunctionDeclarator(
22 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
23 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
24 node, src,
25 )
26 })?),
27 )),
28 "abstract_parenthesized_declarator" => Ok(Self::AbstractParenthesizedDeclarator(
29 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
30 <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
31 node, src,
32 )
33 })?),
34 )),
35 "abstract_pointer_declarator" => Ok(Self::AbstractPointerDeclarator(
36 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
37 <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(
38 node, src,
39 )
40 })?),
41 )),
42 "abstract_reference_declarator" => Ok(Self::AbstractReferenceDeclarator(
43 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
44 <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
45 node, src,
46 )
47 })?),
48 )),
49 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
50 }
51 }
52}
53impl ::treesitter_types::Spanned for AbstractDeclarator<'_> {
54 fn span(&self) -> ::treesitter_types::Span {
55 match self {
56 Self::AbstractArrayDeclarator(inner) => inner.span(),
57 Self::AbstractFunctionDeclarator(inner) => inner.span(),
58 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
59 Self::AbstractPointerDeclarator(inner) => inner.span(),
60 Self::AbstractReferenceDeclarator(inner) => inner.span(),
61 }
62 }
63}
64#[derive(Debug, Clone, PartialEq, Eq)]
65pub enum Declarator<'tree> {
66 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
67 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
68 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
69 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
70 Identifier(::std::boxed::Box<Identifier<'tree>>),
71 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
72 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
73 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
74 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
75 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
76 StructuredBindingDeclarator(::std::boxed::Box<StructuredBindingDeclarator<'tree>>),
77 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
78}
79impl<'tree> ::treesitter_types::FromNode<'tree> for Declarator<'tree> {
80 #[allow(clippy::collapsible_else_if)]
81 fn from_node(
82 node: ::treesitter_types::tree_sitter::Node<'tree>,
83 src: &'tree [u8],
84 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
85 match node.kind() {
86 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
87 ::treesitter_types::runtime::maybe_grow_stack(|| {
88 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
89 })?,
90 ))),
91 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
92 ::treesitter_types::runtime::maybe_grow_stack(|| {
93 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
94 })?,
95 ))),
96 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
97 ::treesitter_types::runtime::maybe_grow_stack(|| {
98 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)
99 })?,
100 ))),
101 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
102 ::treesitter_types::runtime::maybe_grow_stack(|| {
103 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
104 })?,
105 ))),
106 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
107 ::treesitter_types::runtime::maybe_grow_stack(|| {
108 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
109 })?,
110 ))),
111 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
112 ::treesitter_types::runtime::maybe_grow_stack(|| {
113 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)
114 })?,
115 ))),
116 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
117 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
118 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
119 })?),
120 )),
121 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
122 ::treesitter_types::runtime::maybe_grow_stack(|| {
123 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
124 })?,
125 ))),
126 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
127 ::treesitter_types::runtime::maybe_grow_stack(|| {
128 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
129 })?,
130 ))),
131 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
132 ::treesitter_types::runtime::maybe_grow_stack(|| {
133 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
134 })?,
135 ))),
136 "structured_binding_declarator" => Ok(Self::StructuredBindingDeclarator(
137 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
138 <StructuredBindingDeclarator as ::treesitter_types::FromNode>::from_node(
139 node, src,
140 )
141 })?),
142 )),
143 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
144 ::treesitter_types::runtime::maybe_grow_stack(|| {
145 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)
146 })?,
147 ))),
148 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
149 }
150 }
151}
152impl ::treesitter_types::Spanned for Declarator<'_> {
153 fn span(&self) -> ::treesitter_types::Span {
154 match self {
155 Self::ArrayDeclarator(inner) => inner.span(),
156 Self::AttributedDeclarator(inner) => inner.span(),
157 Self::DestructorName(inner) => inner.span(),
158 Self::FunctionDeclarator(inner) => inner.span(),
159 Self::Identifier(inner) => inner.span(),
160 Self::OperatorName(inner) => inner.span(),
161 Self::ParenthesizedDeclarator(inner) => inner.span(),
162 Self::PointerDeclarator(inner) => inner.span(),
163 Self::QualifiedIdentifier(inner) => inner.span(),
164 Self::ReferenceDeclarator(inner) => inner.span(),
165 Self::StructuredBindingDeclarator(inner) => inner.span(),
166 Self::TemplateFunction(inner) => inner.span(),
167 }
168 }
169}
170#[derive(Debug, Clone, PartialEq, Eq)]
171pub enum FieldDeclarator<'tree> {
172 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
173 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
174 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
175 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
176 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
177 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
178 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
179 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
180 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
181}
182impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarator<'tree> {
183 #[allow(clippy::collapsible_else_if)]
184 fn from_node(
185 node: ::treesitter_types::tree_sitter::Node<'tree>,
186 src: &'tree [u8],
187 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
188 match node.kind() {
189 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
190 ::treesitter_types::runtime::maybe_grow_stack(|| {
191 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
192 })?,
193 ))),
194 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
195 ::treesitter_types::runtime::maybe_grow_stack(|| {
196 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
197 })?,
198 ))),
199 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
200 ::treesitter_types::runtime::maybe_grow_stack(|| {
201 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
202 })?,
203 ))),
204 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
205 ::treesitter_types::runtime::maybe_grow_stack(|| {
206 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
207 })?,
208 ))),
209 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
210 ::treesitter_types::runtime::maybe_grow_stack(|| {
211 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)
212 })?,
213 ))),
214 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
215 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
216 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
217 })?),
218 )),
219 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
220 ::treesitter_types::runtime::maybe_grow_stack(|| {
221 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
222 })?,
223 ))),
224 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
225 ::treesitter_types::runtime::maybe_grow_stack(|| {
226 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
227 })?,
228 ))),
229 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
230 ::treesitter_types::runtime::maybe_grow_stack(|| {
231 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
232 })?,
233 ))),
234 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
235 }
236 }
237}
238impl ::treesitter_types::Spanned for FieldDeclarator<'_> {
239 fn span(&self) -> ::treesitter_types::Span {
240 match self {
241 Self::ArrayDeclarator(inner) => inner.span(),
242 Self::AttributedDeclarator(inner) => inner.span(),
243 Self::FieldIdentifier(inner) => inner.span(),
244 Self::FunctionDeclarator(inner) => inner.span(),
245 Self::OperatorName(inner) => inner.span(),
246 Self::ParenthesizedDeclarator(inner) => inner.span(),
247 Self::PointerDeclarator(inner) => inner.span(),
248 Self::ReferenceDeclarator(inner) => inner.span(),
249 Self::TemplateMethod(inner) => inner.span(),
250 }
251 }
252}
253#[derive(Debug, Clone, PartialEq, Eq)]
254pub enum TypeDeclarator<'tree> {
255 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
256 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
257 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
258 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
259 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
260 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
261 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
262 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
263}
264impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclarator<'tree> {
265 #[allow(clippy::collapsible_else_if)]
266 fn from_node(
267 node: ::treesitter_types::tree_sitter::Node<'tree>,
268 src: &'tree [u8],
269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
270 match node.kind() {
271 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
272 ::treesitter_types::runtime::maybe_grow_stack(|| {
273 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
274 })?,
275 ))),
276 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
277 ::treesitter_types::runtime::maybe_grow_stack(|| {
278 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
279 })?,
280 ))),
281 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
282 ::treesitter_types::runtime::maybe_grow_stack(|| {
283 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
284 })?,
285 ))),
286 "parenthesized_declarator" => Ok(Self::ParenthesizedDeclarator(
287 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
288 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
289 })?),
290 )),
291 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
292 ::treesitter_types::runtime::maybe_grow_stack(|| {
293 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
294 })?,
295 ))),
296 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
297 ::treesitter_types::runtime::maybe_grow_stack(|| {
298 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
299 })?,
300 ))),
301 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
302 ::treesitter_types::runtime::maybe_grow_stack(|| {
303 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
304 })?,
305 ))),
306 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
307 ::treesitter_types::runtime::maybe_grow_stack(|| {
308 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
309 })?,
310 ))),
311 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
312 }
313 }
314}
315impl ::treesitter_types::Spanned for TypeDeclarator<'_> {
316 fn span(&self) -> ::treesitter_types::Span {
317 match self {
318 Self::ArrayDeclarator(inner) => inner.span(),
319 Self::AttributedDeclarator(inner) => inner.span(),
320 Self::FunctionDeclarator(inner) => inner.span(),
321 Self::ParenthesizedDeclarator(inner) => inner.span(),
322 Self::PointerDeclarator(inner) => inner.span(),
323 Self::PrimitiveType(inner) => inner.span(),
324 Self::ReferenceDeclarator(inner) => inner.span(),
325 Self::TypeIdentifier(inner) => inner.span(),
326 }
327 }
328}
329#[derive(Debug, Clone, PartialEq, Eq)]
330pub enum Expression<'tree> {
331 AlignofExpression(::std::boxed::Box<AlignofExpression<'tree>>),
332 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
333 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
334 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
335 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
336 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
337 CoAwaitExpression(::std::boxed::Box<CoAwaitExpression<'tree>>),
338 CompoundLiteralExpression(::std::boxed::Box<CompoundLiteralExpression<'tree>>),
339 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
340 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
341 DeleteExpression(::std::boxed::Box<DeleteExpression<'tree>>),
342 ExtensionExpression(::std::boxed::Box<ExtensionExpression<'tree>>),
343 False(::std::boxed::Box<False<'tree>>),
344 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
345 FoldExpression(::std::boxed::Box<FoldExpression<'tree>>),
346 GenericExpression(::std::boxed::Box<GenericExpression<'tree>>),
347 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
348 Identifier(::std::boxed::Box<Identifier<'tree>>),
349 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
350 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
351 Null(::std::boxed::Box<Null<'tree>>),
352 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
353 OffsetofExpression(::std::boxed::Box<OffsetofExpression<'tree>>),
354 ParameterPackExpansion(::std::boxed::Box<ParameterPackExpansion<'tree>>),
355 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
356 PointerExpression(::std::boxed::Box<PointerExpression<'tree>>),
357 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
358 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
359 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
360 RequiresExpression(::std::boxed::Box<RequiresExpression<'tree>>),
361 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
362 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
363 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
364 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
365 This(::std::boxed::Box<This<'tree>>),
366 True(::std::boxed::Box<True<'tree>>),
367 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
368 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
369 UserDefinedLiteral(::std::boxed::Box<UserDefinedLiteral<'tree>>),
370}
371impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
372 #[allow(clippy::collapsible_else_if)]
373 fn from_node(
374 node: ::treesitter_types::tree_sitter::Node<'tree>,
375 src: &'tree [u8],
376 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
377 match node.kind() {
378 "alignof_expression" => Ok(Self::AlignofExpression(::std::boxed::Box::new(
379 ::treesitter_types::runtime::maybe_grow_stack(|| {
380 <AlignofExpression as ::treesitter_types::FromNode>::from_node(node, src)
381 })?,
382 ))),
383 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
384 ::treesitter_types::runtime::maybe_grow_stack(|| {
385 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
386 })?,
387 ))),
388 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
389 ::treesitter_types::runtime::maybe_grow_stack(|| {
390 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
391 })?,
392 ))),
393 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
394 ::treesitter_types::runtime::maybe_grow_stack(|| {
395 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
396 })?,
397 ))),
398 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
399 ::treesitter_types::runtime::maybe_grow_stack(|| {
400 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
401 })?,
402 ))),
403 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
404 ::treesitter_types::runtime::maybe_grow_stack(|| {
405 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
406 })?,
407 ))),
408 "co_await_expression" => Ok(Self::CoAwaitExpression(::std::boxed::Box::new(
409 ::treesitter_types::runtime::maybe_grow_stack(|| {
410 <CoAwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
411 })?,
412 ))),
413 "compound_literal_expression" => Ok(Self::CompoundLiteralExpression(
414 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
415 <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(
416 node, src,
417 )
418 })?),
419 )),
420 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
421 ::treesitter_types::runtime::maybe_grow_stack(|| {
422 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
423 })?,
424 ))),
425 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
426 ::treesitter_types::runtime::maybe_grow_stack(|| {
427 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
428 })?,
429 ))),
430 "delete_expression" => Ok(Self::DeleteExpression(::std::boxed::Box::new(
431 ::treesitter_types::runtime::maybe_grow_stack(|| {
432 <DeleteExpression as ::treesitter_types::FromNode>::from_node(node, src)
433 })?,
434 ))),
435 "extension_expression" => Ok(Self::ExtensionExpression(::std::boxed::Box::new(
436 ::treesitter_types::runtime::maybe_grow_stack(|| {
437 <ExtensionExpression as ::treesitter_types::FromNode>::from_node(node, src)
438 })?,
439 ))),
440 "false" => Ok(Self::False(::std::boxed::Box::new(
441 ::treesitter_types::runtime::maybe_grow_stack(|| {
442 <False as ::treesitter_types::FromNode>::from_node(node, src)
443 })?,
444 ))),
445 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
446 ::treesitter_types::runtime::maybe_grow_stack(|| {
447 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
448 })?,
449 ))),
450 "fold_expression" => Ok(Self::FoldExpression(::std::boxed::Box::new(
451 ::treesitter_types::runtime::maybe_grow_stack(|| {
452 <FoldExpression as ::treesitter_types::FromNode>::from_node(node, src)
453 })?,
454 ))),
455 "generic_expression" => Ok(Self::GenericExpression(::std::boxed::Box::new(
456 ::treesitter_types::runtime::maybe_grow_stack(|| {
457 <GenericExpression as ::treesitter_types::FromNode>::from_node(node, src)
458 })?,
459 ))),
460 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
461 ::treesitter_types::runtime::maybe_grow_stack(|| {
462 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
463 })?,
464 ))),
465 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
466 ::treesitter_types::runtime::maybe_grow_stack(|| {
467 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
468 })?,
469 ))),
470 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
471 ::treesitter_types::runtime::maybe_grow_stack(|| {
472 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
473 })?,
474 ))),
475 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
476 ::treesitter_types::runtime::maybe_grow_stack(|| {
477 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
478 })?,
479 ))),
480 "null" => Ok(Self::Null(::std::boxed::Box::new(
481 ::treesitter_types::runtime::maybe_grow_stack(|| {
482 <Null as ::treesitter_types::FromNode>::from_node(node, src)
483 })?,
484 ))),
485 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
486 ::treesitter_types::runtime::maybe_grow_stack(|| {
487 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
488 })?,
489 ))),
490 "offsetof_expression" => Ok(Self::OffsetofExpression(::std::boxed::Box::new(
491 ::treesitter_types::runtime::maybe_grow_stack(|| {
492 <OffsetofExpression as ::treesitter_types::FromNode>::from_node(node, src)
493 })?,
494 ))),
495 "parameter_pack_expansion" => Ok(Self::ParameterPackExpansion(::std::boxed::Box::new(
496 ::treesitter_types::runtime::maybe_grow_stack(|| {
497 <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(node, src)
498 })?,
499 ))),
500 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
501 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
502 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
503 })?),
504 )),
505 "pointer_expression" => Ok(Self::PointerExpression(::std::boxed::Box::new(
506 ::treesitter_types::runtime::maybe_grow_stack(|| {
507 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)
508 })?,
509 ))),
510 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
511 ::treesitter_types::runtime::maybe_grow_stack(|| {
512 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
513 })?,
514 ))),
515 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
516 ::treesitter_types::runtime::maybe_grow_stack(|| {
517 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
518 })?,
519 ))),
520 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
521 ::treesitter_types::runtime::maybe_grow_stack(|| {
522 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)
523 })?,
524 ))),
525 "requires_expression" => Ok(Self::RequiresExpression(::std::boxed::Box::new(
526 ::treesitter_types::runtime::maybe_grow_stack(|| {
527 <RequiresExpression as ::treesitter_types::FromNode>::from_node(node, src)
528 })?,
529 ))),
530 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
531 ::treesitter_types::runtime::maybe_grow_stack(|| {
532 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
533 })?,
534 ))),
535 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
536 ::treesitter_types::runtime::maybe_grow_stack(|| {
537 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
538 })?,
539 ))),
540 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
541 ::treesitter_types::runtime::maybe_grow_stack(|| {
542 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
543 })?,
544 ))),
545 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
546 ::treesitter_types::runtime::maybe_grow_stack(|| {
547 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)
548 })?,
549 ))),
550 "this" => Ok(Self::This(::std::boxed::Box::new(
551 ::treesitter_types::runtime::maybe_grow_stack(|| {
552 <This as ::treesitter_types::FromNode>::from_node(node, src)
553 })?,
554 ))),
555 "true" => Ok(Self::True(::std::boxed::Box::new(
556 ::treesitter_types::runtime::maybe_grow_stack(|| {
557 <True as ::treesitter_types::FromNode>::from_node(node, src)
558 })?,
559 ))),
560 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
561 ::treesitter_types::runtime::maybe_grow_stack(|| {
562 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
563 })?,
564 ))),
565 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
566 ::treesitter_types::runtime::maybe_grow_stack(|| {
567 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
568 })?,
569 ))),
570 "user_defined_literal" => Ok(Self::UserDefinedLiteral(::std::boxed::Box::new(
571 ::treesitter_types::runtime::maybe_grow_stack(|| {
572 <UserDefinedLiteral as ::treesitter_types::FromNode>::from_node(node, src)
573 })?,
574 ))),
575 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
576 }
577 }
578}
579impl ::treesitter_types::Spanned for Expression<'_> {
580 fn span(&self) -> ::treesitter_types::Span {
581 match self {
582 Self::AlignofExpression(inner) => inner.span(),
583 Self::AssignmentExpression(inner) => inner.span(),
584 Self::BinaryExpression(inner) => inner.span(),
585 Self::CallExpression(inner) => inner.span(),
586 Self::CastExpression(inner) => inner.span(),
587 Self::CharLiteral(inner) => inner.span(),
588 Self::CoAwaitExpression(inner) => inner.span(),
589 Self::CompoundLiteralExpression(inner) => inner.span(),
590 Self::ConcatenatedString(inner) => inner.span(),
591 Self::ConditionalExpression(inner) => inner.span(),
592 Self::DeleteExpression(inner) => inner.span(),
593 Self::ExtensionExpression(inner) => inner.span(),
594 Self::False(inner) => inner.span(),
595 Self::FieldExpression(inner) => inner.span(),
596 Self::FoldExpression(inner) => inner.span(),
597 Self::GenericExpression(inner) => inner.span(),
598 Self::GnuAsmExpression(inner) => inner.span(),
599 Self::Identifier(inner) => inner.span(),
600 Self::LambdaExpression(inner) => inner.span(),
601 Self::NewExpression(inner) => inner.span(),
602 Self::Null(inner) => inner.span(),
603 Self::NumberLiteral(inner) => inner.span(),
604 Self::OffsetofExpression(inner) => inner.span(),
605 Self::ParameterPackExpansion(inner) => inner.span(),
606 Self::ParenthesizedExpression(inner) => inner.span(),
607 Self::PointerExpression(inner) => inner.span(),
608 Self::QualifiedIdentifier(inner) => inner.span(),
609 Self::RawStringLiteral(inner) => inner.span(),
610 Self::RequiresClause(inner) => inner.span(),
611 Self::RequiresExpression(inner) => inner.span(),
612 Self::SizeofExpression(inner) => inner.span(),
613 Self::StringLiteral(inner) => inner.span(),
614 Self::SubscriptExpression(inner) => inner.span(),
615 Self::TemplateFunction(inner) => inner.span(),
616 Self::This(inner) => inner.span(),
617 Self::True(inner) => inner.span(),
618 Self::UnaryExpression(inner) => inner.span(),
619 Self::UpdateExpression(inner) => inner.span(),
620 Self::UserDefinedLiteral(inner) => inner.span(),
621 }
622 }
623}
624#[derive(Debug, Clone, PartialEq, Eq)]
625pub enum Statement<'tree> {
626 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
627 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
628 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
629 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
630 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
631 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
632 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
633 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
634 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
635 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
636 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
637 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
638 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
639 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
640 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
641 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
642 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
643 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
644 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
645 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
646 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
647}
648impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
649 #[allow(clippy::collapsible_else_if)]
650 fn from_node(
651 node: ::treesitter_types::tree_sitter::Node<'tree>,
652 src: &'tree [u8],
653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
654 match node.kind() {
655 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
656 ::treesitter_types::runtime::maybe_grow_stack(|| {
657 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
658 })?,
659 ))),
660 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
661 ::treesitter_types::runtime::maybe_grow_stack(|| {
662 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
663 })?,
664 ))),
665 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
666 ::treesitter_types::runtime::maybe_grow_stack(|| {
667 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
668 })?,
669 ))),
670 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
671 ::treesitter_types::runtime::maybe_grow_stack(|| {
672 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
673 })?,
674 ))),
675 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
676 ::treesitter_types::runtime::maybe_grow_stack(|| {
677 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
678 })?,
679 ))),
680 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
681 ::treesitter_types::runtime::maybe_grow_stack(|| {
682 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
683 })?,
684 ))),
685 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
686 ::treesitter_types::runtime::maybe_grow_stack(|| {
687 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
688 })?,
689 ))),
690 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
691 ::treesitter_types::runtime::maybe_grow_stack(|| {
692 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
693 })?,
694 ))),
695 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
696 ::treesitter_types::runtime::maybe_grow_stack(|| {
697 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
698 })?,
699 ))),
700 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
701 ::treesitter_types::runtime::maybe_grow_stack(|| {
702 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)
703 })?,
704 ))),
705 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
706 ::treesitter_types::runtime::maybe_grow_stack(|| {
707 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
708 })?,
709 ))),
710 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
711 ::treesitter_types::runtime::maybe_grow_stack(|| {
712 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
713 })?,
714 ))),
715 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
716 ::treesitter_types::runtime::maybe_grow_stack(|| {
717 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
718 })?,
719 ))),
720 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
721 ::treesitter_types::runtime::maybe_grow_stack(|| {
722 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
723 })?,
724 ))),
725 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
726 ::treesitter_types::runtime::maybe_grow_stack(|| {
727 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
728 })?,
729 ))),
730 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
731 ::treesitter_types::runtime::maybe_grow_stack(|| {
732 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
733 })?,
734 ))),
735 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
736 ::treesitter_types::runtime::maybe_grow_stack(|| {
737 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
738 })?,
739 ))),
740 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
741 ::treesitter_types::runtime::maybe_grow_stack(|| {
742 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
743 })?,
744 ))),
745 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
746 ::treesitter_types::runtime::maybe_grow_stack(|| {
747 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
748 })?,
749 ))),
750 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
751 ::treesitter_types::runtime::maybe_grow_stack(|| {
752 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
753 })?,
754 ))),
755 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
756 ::treesitter_types::runtime::maybe_grow_stack(|| {
757 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
758 })?,
759 ))),
760 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
761 }
762 }
763}
764impl ::treesitter_types::Spanned for Statement<'_> {
765 fn span(&self) -> ::treesitter_types::Span {
766 match self {
767 Self::AttributedStatement(inner) => inner.span(),
768 Self::BreakStatement(inner) => inner.span(),
769 Self::CaseStatement(inner) => inner.span(),
770 Self::CoReturnStatement(inner) => inner.span(),
771 Self::CoYieldStatement(inner) => inner.span(),
772 Self::CompoundStatement(inner) => inner.span(),
773 Self::ContinueStatement(inner) => inner.span(),
774 Self::DoStatement(inner) => inner.span(),
775 Self::ExpressionStatement(inner) => inner.span(),
776 Self::ForRangeLoop(inner) => inner.span(),
777 Self::ForStatement(inner) => inner.span(),
778 Self::GotoStatement(inner) => inner.span(),
779 Self::IfStatement(inner) => inner.span(),
780 Self::LabeledStatement(inner) => inner.span(),
781 Self::ReturnStatement(inner) => inner.span(),
782 Self::SehLeaveStatement(inner) => inner.span(),
783 Self::SehTryStatement(inner) => inner.span(),
784 Self::SwitchStatement(inner) => inner.span(),
785 Self::ThrowStatement(inner) => inner.span(),
786 Self::TryStatement(inner) => inner.span(),
787 Self::WhileStatement(inner) => inner.span(),
788 }
789 }
790}
791#[derive(Debug, Clone, PartialEq, Eq)]
792pub enum TypeSpecifier<'tree> {
793 ClassSpecifier(::std::boxed::Box<ClassSpecifier<'tree>>),
794 Decltype(::std::boxed::Box<Decltype<'tree>>),
795 DependentType(::std::boxed::Box<DependentType<'tree>>),
796 EnumSpecifier(::std::boxed::Box<EnumSpecifier<'tree>>),
797 PlaceholderTypeSpecifier(::std::boxed::Box<PlaceholderTypeSpecifier<'tree>>),
798 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
799 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
800 SizedTypeSpecifier(::std::boxed::Box<SizedTypeSpecifier<'tree>>),
801 StructSpecifier(::std::boxed::Box<StructSpecifier<'tree>>),
802 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
803 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
804 UnionSpecifier(::std::boxed::Box<UnionSpecifier<'tree>>),
805}
806impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSpecifier<'tree> {
807 #[allow(clippy::collapsible_else_if)]
808 fn from_node(
809 node: ::treesitter_types::tree_sitter::Node<'tree>,
810 src: &'tree [u8],
811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
812 match node.kind() {
813 "class_specifier" => Ok(Self::ClassSpecifier(::std::boxed::Box::new(
814 ::treesitter_types::runtime::maybe_grow_stack(|| {
815 <ClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
816 })?,
817 ))),
818 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
819 ::treesitter_types::runtime::maybe_grow_stack(|| {
820 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)
821 })?,
822 ))),
823 "dependent_type" => Ok(Self::DependentType(::std::boxed::Box::new(
824 ::treesitter_types::runtime::maybe_grow_stack(|| {
825 <DependentType as ::treesitter_types::FromNode>::from_node(node, src)
826 })?,
827 ))),
828 "enum_specifier" => Ok(Self::EnumSpecifier(::std::boxed::Box::new(
829 ::treesitter_types::runtime::maybe_grow_stack(|| {
830 <EnumSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
831 })?,
832 ))),
833 "placeholder_type_specifier" => Ok(Self::PlaceholderTypeSpecifier(
834 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
835 <PlaceholderTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
836 })?),
837 )),
838 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
839 ::treesitter_types::runtime::maybe_grow_stack(|| {
840 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
841 })?,
842 ))),
843 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
844 ::treesitter_types::runtime::maybe_grow_stack(|| {
845 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
846 })?,
847 ))),
848 "sized_type_specifier" => Ok(Self::SizedTypeSpecifier(::std::boxed::Box::new(
849 ::treesitter_types::runtime::maybe_grow_stack(|| {
850 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
851 })?,
852 ))),
853 "struct_specifier" => Ok(Self::StructSpecifier(::std::boxed::Box::new(
854 ::treesitter_types::runtime::maybe_grow_stack(|| {
855 <StructSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
856 })?,
857 ))),
858 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
859 ::treesitter_types::runtime::maybe_grow_stack(|| {
860 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
861 })?,
862 ))),
863 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
864 ::treesitter_types::runtime::maybe_grow_stack(|| {
865 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
866 })?,
867 ))),
868 "union_specifier" => Ok(Self::UnionSpecifier(::std::boxed::Box::new(
869 ::treesitter_types::runtime::maybe_grow_stack(|| {
870 <UnionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
871 })?,
872 ))),
873 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
874 }
875 }
876}
877impl ::treesitter_types::Spanned for TypeSpecifier<'_> {
878 fn span(&self) -> ::treesitter_types::Span {
879 match self {
880 Self::ClassSpecifier(inner) => inner.span(),
881 Self::Decltype(inner) => inner.span(),
882 Self::DependentType(inner) => inner.span(),
883 Self::EnumSpecifier(inner) => inner.span(),
884 Self::PlaceholderTypeSpecifier(inner) => inner.span(),
885 Self::PrimitiveType(inner) => inner.span(),
886 Self::QualifiedIdentifier(inner) => inner.span(),
887 Self::SizedTypeSpecifier(inner) => inner.span(),
888 Self::StructSpecifier(inner) => inner.span(),
889 Self::TemplateType(inner) => inner.span(),
890 Self::TypeIdentifier(inner) => inner.span(),
891 Self::UnionSpecifier(inner) => inner.span(),
892 }
893 }
894}
895#[derive(Debug, Clone, PartialEq, Eq)]
896pub struct AbstractArrayDeclarator<'tree> {
897 pub span: ::treesitter_types::Span,
898 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
899 pub size: ::core::option::Option<AbstractArrayDeclaratorSize<'tree>>,
900 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
901}
902impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclarator<'tree> {
903 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
904 fn from_node(
905 node: ::treesitter_types::tree_sitter::Node<'tree>,
906 src: &'tree [u8],
907 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
908 debug_assert_eq!(node.kind(), "abstract_array_declarator");
909 Ok(Self {
910 span: ::treesitter_types::Span::from(node),
911 declarator: match node.child_by_field_name("declarator") {
912 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
913 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
914 })?),
915 None => None,
916 },
917 size: match node.child_by_field_name("size") {
918 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
919 <AbstractArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(
920 child, src,
921 )
922 })?),
923 None => None,
924 },
925 children: {
926 #[allow(clippy::suspicious_else_formatting)]
927 let non_field_children = {
928 let mut cursor = node.walk();
929 let mut result = ::std::vec::Vec::new();
930 if cursor.goto_first_child() {
931 loop {
932 if cursor.field_name().is_none()
933 && cursor.node().is_named()
934 && !cursor.node().is_extra()
935 {
936 result.push(cursor.node());
937 }
938 if !cursor.goto_next_sibling() {
939 break;
940 }
941 }
942 }
943 result
944 };
945 let mut items = ::std::vec::Vec::new();
946 for child in non_field_children {
947 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
948 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
949 })?);
950 }
951 items
952 },
953 })
954 }
955}
956impl ::treesitter_types::Spanned for AbstractArrayDeclarator<'_> {
957 fn span(&self) -> ::treesitter_types::Span {
958 self.span
959 }
960}
961#[derive(Debug, Clone, PartialEq, Eq)]
962pub struct AbstractFunctionDeclarator<'tree> {
963 pub span: ::treesitter_types::Span,
964 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
965 pub parameters: ParameterList<'tree>,
966 pub children: ::std::vec::Vec<AbstractFunctionDeclaratorChildren<'tree>>,
967}
968impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFunctionDeclarator<'tree> {
969 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
970 fn from_node(
971 node: ::treesitter_types::tree_sitter::Node<'tree>,
972 src: &'tree [u8],
973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
974 debug_assert_eq!(node.kind(), "abstract_function_declarator");
975 Ok(Self {
976 span: ::treesitter_types::Span::from(node),
977 declarator: match node.child_by_field_name("declarator") {
978 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
979 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
980 })?),
981 None => None,
982 },
983 parameters: {
984 let child = node.child_by_field_name("parameters").ok_or_else(|| {
985 ::treesitter_types::ParseError::missing_field("parameters", node)
986 })?;
987 ::treesitter_types::runtime::maybe_grow_stack(|| {
988 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
989 })?
990 },
991 children: {
992 #[allow(clippy::suspicious_else_formatting)]
993 let non_field_children = {
994 let mut cursor = node.walk();
995 let mut result = ::std::vec::Vec::new();
996 if cursor.goto_first_child() {
997 loop {
998 if cursor.field_name().is_none()
999 && cursor.node().is_named()
1000 && !cursor.node().is_extra()
1001 {
1002 result.push(cursor.node());
1003 }
1004 if !cursor.goto_next_sibling() {
1005 break;
1006 }
1007 }
1008 }
1009 result
1010 };
1011 let mut items = ::std::vec::Vec::new();
1012 for child in non_field_children {
1013 items
1014 .push(
1015 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractFunctionDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1016 child,
1017 src,
1018 ))?,
1019 );
1020 }
1021 items
1022 },
1023 })
1024 }
1025}
1026impl ::treesitter_types::Spanned for AbstractFunctionDeclarator<'_> {
1027 fn span(&self) -> ::treesitter_types::Span {
1028 self.span
1029 }
1030}
1031#[derive(Debug, Clone, PartialEq, Eq)]
1032pub struct AbstractParenthesizedDeclarator<'tree> {
1033 pub span: ::treesitter_types::Span,
1034 pub children: ::std::vec::Vec<AbstractParenthesizedDeclaratorChildren<'tree>>,
1035}
1036impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclarator<'tree> {
1037 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1038 fn from_node(
1039 node: ::treesitter_types::tree_sitter::Node<'tree>,
1040 src: &'tree [u8],
1041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1042 debug_assert_eq!(node.kind(), "abstract_parenthesized_declarator");
1043 Ok(Self {
1044 span: ::treesitter_types::Span::from(node),
1045 children: {
1046 #[allow(clippy::suspicious_else_formatting)]
1047 let non_field_children = {
1048 let mut cursor = node.walk();
1049 let mut result = ::std::vec::Vec::new();
1050 if cursor.goto_first_child() {
1051 loop {
1052 if cursor.field_name().is_none()
1053 && cursor.node().is_named()
1054 && !cursor.node().is_extra()
1055 {
1056 result.push(cursor.node());
1057 }
1058 if !cursor.goto_next_sibling() {
1059 break;
1060 }
1061 }
1062 }
1063 result
1064 };
1065 let mut items = ::std::vec::Vec::new();
1066 for child in non_field_children {
1067 items
1068 .push(
1069 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1070 child,
1071 src,
1072 ))?,
1073 );
1074 }
1075 items
1076 },
1077 })
1078 }
1079}
1080impl ::treesitter_types::Spanned for AbstractParenthesizedDeclarator<'_> {
1081 fn span(&self) -> ::treesitter_types::Span {
1082 self.span
1083 }
1084}
1085#[derive(Debug, Clone, PartialEq, Eq)]
1086pub struct AbstractPointerDeclarator<'tree> {
1087 pub span: ::treesitter_types::Span,
1088 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
1089 pub children: ::std::vec::Vec<AbstractPointerDeclaratorChildren<'tree>>,
1090}
1091impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclarator<'tree> {
1092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1093 fn from_node(
1094 node: ::treesitter_types::tree_sitter::Node<'tree>,
1095 src: &'tree [u8],
1096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1097 debug_assert_eq!(node.kind(), "abstract_pointer_declarator");
1098 Ok(Self {
1099 span: ::treesitter_types::Span::from(node),
1100 declarator: match node.child_by_field_name("declarator") {
1101 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1102 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
1103 })?),
1104 None => None,
1105 },
1106 children: {
1107 #[allow(clippy::suspicious_else_formatting)]
1108 let non_field_children = {
1109 let mut cursor = node.walk();
1110 let mut result = ::std::vec::Vec::new();
1111 if cursor.goto_first_child() {
1112 loop {
1113 if cursor.field_name().is_none()
1114 && cursor.node().is_named()
1115 && !cursor.node().is_extra()
1116 {
1117 result.push(cursor.node());
1118 }
1119 if !cursor.goto_next_sibling() {
1120 break;
1121 }
1122 }
1123 }
1124 result
1125 };
1126 let mut items = ::std::vec::Vec::new();
1127 for child in non_field_children {
1128 items
1129 .push(
1130 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractPointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1131 child,
1132 src,
1133 ))?,
1134 );
1135 }
1136 items
1137 },
1138 })
1139 }
1140}
1141impl ::treesitter_types::Spanned for AbstractPointerDeclarator<'_> {
1142 fn span(&self) -> ::treesitter_types::Span {
1143 self.span
1144 }
1145}
1146#[derive(Debug, Clone, PartialEq, Eq)]
1147pub struct AbstractReferenceDeclarator<'tree> {
1148 pub span: ::treesitter_types::Span,
1149 pub children: ::core::option::Option<AbstractDeclarator<'tree>>,
1150}
1151impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractReferenceDeclarator<'tree> {
1152 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1153 fn from_node(
1154 node: ::treesitter_types::tree_sitter::Node<'tree>,
1155 src: &'tree [u8],
1156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1157 debug_assert_eq!(node.kind(), "abstract_reference_declarator");
1158 Ok(Self {
1159 span: ::treesitter_types::Span::from(node),
1160 children: {
1161 #[allow(clippy::suspicious_else_formatting)]
1162 let non_field_children = {
1163 let mut cursor = node.walk();
1164 let mut result = ::std::vec::Vec::new();
1165 if cursor.goto_first_child() {
1166 loop {
1167 if cursor.field_name().is_none()
1168 && cursor.node().is_named()
1169 && !cursor.node().is_extra()
1170 {
1171 result.push(cursor.node());
1172 }
1173 if !cursor.goto_next_sibling() {
1174 break;
1175 }
1176 }
1177 }
1178 result
1179 };
1180 match non_field_children.first() {
1181 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1182 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
1183 })?),
1184 None => None,
1185 }
1186 },
1187 })
1188 }
1189}
1190impl ::treesitter_types::Spanned for AbstractReferenceDeclarator<'_> {
1191 fn span(&self) -> ::treesitter_types::Span {
1192 self.span
1193 }
1194}
1195#[derive(Debug, Clone, PartialEq, Eq)]
1196pub struct AccessSpecifier<'tree> {
1197 pub span: ::treesitter_types::Span,
1198 text: &'tree str,
1199}
1200impl<'tree> ::treesitter_types::FromNode<'tree> for AccessSpecifier<'tree> {
1201 fn from_node(
1202 node: ::treesitter_types::tree_sitter::Node<'tree>,
1203 src: &'tree [u8],
1204 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1205 debug_assert_eq!(node.kind(), "access_specifier");
1206 Ok(Self {
1207 span: ::treesitter_types::Span::from(node),
1208 text: node.utf8_text(src)?,
1209 })
1210 }
1211}
1212impl<'tree> ::treesitter_types::LeafNode<'tree> for AccessSpecifier<'tree> {
1213 fn text(&self) -> &'tree str {
1214 self.text
1215 }
1216}
1217impl ::treesitter_types::Spanned for AccessSpecifier<'_> {
1218 fn span(&self) -> ::treesitter_types::Span {
1219 self.span
1220 }
1221}
1222#[derive(Debug, Clone, PartialEq, Eq)]
1223pub struct AliasDeclaration<'tree> {
1224 pub span: ::treesitter_types::Span,
1225 pub name: TypeIdentifier<'tree>,
1226 pub r#type: TypeDescriptor<'tree>,
1227 pub children: ::std::vec::Vec<AttributeDeclaration<'tree>>,
1228}
1229impl<'tree> ::treesitter_types::FromNode<'tree> for AliasDeclaration<'tree> {
1230 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1231 fn from_node(
1232 node: ::treesitter_types::tree_sitter::Node<'tree>,
1233 src: &'tree [u8],
1234 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1235 debug_assert_eq!(node.kind(), "alias_declaration");
1236 Ok(Self {
1237 span: ::treesitter_types::Span::from(node),
1238 name: {
1239 let child = node
1240 .child_by_field_name("name")
1241 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1242 ::treesitter_types::runtime::maybe_grow_stack(|| {
1243 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
1244 })?
1245 },
1246 r#type: {
1247 let child = node
1248 .child_by_field_name("type")
1249 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1250 ::treesitter_types::runtime::maybe_grow_stack(|| {
1251 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
1252 })?
1253 },
1254 children: {
1255 #[allow(clippy::suspicious_else_formatting)]
1256 let non_field_children = {
1257 let mut cursor = node.walk();
1258 let mut result = ::std::vec::Vec::new();
1259 if cursor.goto_first_child() {
1260 loop {
1261 if cursor.field_name().is_none()
1262 && cursor.node().is_named()
1263 && !cursor.node().is_extra()
1264 {
1265 result.push(cursor.node());
1266 }
1267 if !cursor.goto_next_sibling() {
1268 break;
1269 }
1270 }
1271 }
1272 result
1273 };
1274 let mut items = ::std::vec::Vec::new();
1275 for child in non_field_children {
1276 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1277 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(
1278 child, src,
1279 )
1280 })?);
1281 }
1282 items
1283 },
1284 })
1285 }
1286}
1287impl ::treesitter_types::Spanned for AliasDeclaration<'_> {
1288 fn span(&self) -> ::treesitter_types::Span {
1289 self.span
1290 }
1291}
1292#[derive(Debug, Clone, PartialEq, Eq)]
1293pub struct AlignasQualifier<'tree> {
1294 pub span: ::treesitter_types::Span,
1295 pub children: AlignasQualifierChildren<'tree>,
1296}
1297impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifier<'tree> {
1298 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1299 fn from_node(
1300 node: ::treesitter_types::tree_sitter::Node<'tree>,
1301 src: &'tree [u8],
1302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1303 debug_assert_eq!(node.kind(), "alignas_qualifier");
1304 Ok(Self {
1305 span: ::treesitter_types::Span::from(node),
1306 children: {
1307 #[allow(clippy::suspicious_else_formatting)]
1308 let non_field_children = {
1309 let mut cursor = node.walk();
1310 let mut result = ::std::vec::Vec::new();
1311 if cursor.goto_first_child() {
1312 loop {
1313 if cursor.field_name().is_none()
1314 && cursor.node().is_named()
1315 && !cursor.node().is_extra()
1316 {
1317 result.push(cursor.node());
1318 }
1319 if !cursor.goto_next_sibling() {
1320 break;
1321 }
1322 }
1323 }
1324 result
1325 };
1326 let child = if let Some(&c) = non_field_children.first() {
1327 c
1328 } else {
1329 let mut fallback_cursor = node.walk();
1330 let mut fallback_child = None;
1331 if fallback_cursor.goto_first_child() {
1332 loop {
1333 if fallback_cursor.field_name().is_none()
1334 && !fallback_cursor.node().is_extra()
1335 {
1336 let candidate = fallback_cursor.node();
1337 #[allow(clippy::needless_question_mark)]
1338 if (|| -> ::core::result::Result<
1339 _,
1340 ::treesitter_types::ParseError,
1341 > {
1342 let child = candidate;
1343 Ok(
1344 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
1345 child,
1346 src,
1347 ))?,
1348 )
1349 })()
1350 .is_ok()
1351 {
1352 fallback_child = Some(candidate);
1353 break;
1354 }
1355 }
1356 if !fallback_cursor.goto_next_sibling() {
1357 break;
1358 }
1359 }
1360 }
1361 if fallback_child.is_none() {
1362 let mut cursor2 = node.walk();
1363 if cursor2.goto_first_child() {
1364 loop {
1365 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1366 let candidate = cursor2.node();
1367 #[allow(clippy::needless_question_mark)]
1368 if (|| -> ::core::result::Result<
1369 _,
1370 ::treesitter_types::ParseError,
1371 > {
1372 let child = candidate;
1373 Ok(
1374 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
1375 child,
1376 src,
1377 ))?,
1378 )
1379 })()
1380 .is_ok()
1381 {
1382 fallback_child = Some(candidate);
1383 break;
1384 }
1385 }
1386 if !cursor2.goto_next_sibling() {
1387 break;
1388 }
1389 }
1390 }
1391 }
1392 fallback_child.ok_or_else(|| {
1393 ::treesitter_types::ParseError::missing_field("children", node)
1394 })?
1395 };
1396 ::treesitter_types::runtime::maybe_grow_stack(|| {
1397 <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
1398 child, src,
1399 )
1400 })?
1401 },
1402 })
1403 }
1404}
1405impl ::treesitter_types::Spanned for AlignasQualifier<'_> {
1406 fn span(&self) -> ::treesitter_types::Span {
1407 self.span
1408 }
1409}
1410#[derive(Debug, Clone, PartialEq, Eq)]
1411pub struct AlignofExpression<'tree> {
1412 pub span: ::treesitter_types::Span,
1413 pub r#type: TypeDescriptor<'tree>,
1414}
1415impl<'tree> ::treesitter_types::FromNode<'tree> for AlignofExpression<'tree> {
1416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1417 fn from_node(
1418 node: ::treesitter_types::tree_sitter::Node<'tree>,
1419 src: &'tree [u8],
1420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1421 debug_assert_eq!(node.kind(), "alignof_expression");
1422 Ok(Self {
1423 span: ::treesitter_types::Span::from(node),
1424 r#type: {
1425 let child = node
1426 .child_by_field_name("type")
1427 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1428 ::treesitter_types::runtime::maybe_grow_stack(|| {
1429 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
1430 })?
1431 },
1432 })
1433 }
1434}
1435impl ::treesitter_types::Spanned for AlignofExpression<'_> {
1436 fn span(&self) -> ::treesitter_types::Span {
1437 self.span
1438 }
1439}
1440#[derive(Debug, Clone, PartialEq, Eq)]
1441pub struct ArgumentList<'tree> {
1442 pub span: ::treesitter_types::Span,
1443 pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
1444}
1445impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1446 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1447 fn from_node(
1448 node: ::treesitter_types::tree_sitter::Node<'tree>,
1449 src: &'tree [u8],
1450 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1451 debug_assert_eq!(node.kind(), "argument_list");
1452 Ok(Self {
1453 span: ::treesitter_types::Span::from(node),
1454 children: {
1455 #[allow(clippy::suspicious_else_formatting)]
1456 let non_field_children = {
1457 let mut cursor = node.walk();
1458 let mut result = ::std::vec::Vec::new();
1459 if cursor.goto_first_child() {
1460 loop {
1461 if cursor.field_name().is_none()
1462 && cursor.node().is_named()
1463 && !cursor.node().is_extra()
1464 {
1465 result.push(cursor.node());
1466 }
1467 if !cursor.goto_next_sibling() {
1468 break;
1469 }
1470 }
1471 }
1472 result
1473 };
1474 let mut items = ::std::vec::Vec::new();
1475 for child in non_field_children {
1476 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1477 <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
1478 child, src,
1479 )
1480 })?);
1481 }
1482 items
1483 },
1484 })
1485 }
1486}
1487impl ::treesitter_types::Spanned for ArgumentList<'_> {
1488 fn span(&self) -> ::treesitter_types::Span {
1489 self.span
1490 }
1491}
1492#[derive(Debug, Clone, PartialEq, Eq)]
1493pub struct ArrayDeclarator<'tree> {
1494 pub span: ::treesitter_types::Span,
1495 pub declarator: ArrayDeclaratorDeclarator<'tree>,
1496 pub size: ::core::option::Option<ArrayDeclaratorSize<'tree>>,
1497 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
1498}
1499impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclarator<'tree> {
1500 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1501 fn from_node(
1502 node: ::treesitter_types::tree_sitter::Node<'tree>,
1503 src: &'tree [u8],
1504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1505 debug_assert_eq!(node.kind(), "array_declarator");
1506 Ok(Self {
1507 span: ::treesitter_types::Span::from(node),
1508 declarator: {
1509 let child = node.child_by_field_name("declarator").ok_or_else(|| {
1510 ::treesitter_types::ParseError::missing_field("declarator", node)
1511 })?;
1512 ::treesitter_types::runtime::maybe_grow_stack(|| {
1513 <ArrayDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
1514 child, src,
1515 )
1516 })?
1517 },
1518 size: match node.child_by_field_name("size") {
1519 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1520 <ArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(child, src)
1521 })?),
1522 None => None,
1523 },
1524 children: {
1525 #[allow(clippy::suspicious_else_formatting)]
1526 let non_field_children = {
1527 let mut cursor = node.walk();
1528 let mut result = ::std::vec::Vec::new();
1529 if cursor.goto_first_child() {
1530 loop {
1531 if cursor.field_name().is_none()
1532 && cursor.node().is_named()
1533 && !cursor.node().is_extra()
1534 {
1535 result.push(cursor.node());
1536 }
1537 if !cursor.goto_next_sibling() {
1538 break;
1539 }
1540 }
1541 }
1542 result
1543 };
1544 let mut items = ::std::vec::Vec::new();
1545 for child in non_field_children {
1546 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1547 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
1548 })?);
1549 }
1550 items
1551 },
1552 })
1553 }
1554}
1555impl ::treesitter_types::Spanned for ArrayDeclarator<'_> {
1556 fn span(&self) -> ::treesitter_types::Span {
1557 self.span
1558 }
1559}
1560#[derive(Debug, Clone, PartialEq, Eq)]
1561pub struct AssignmentExpression<'tree> {
1562 pub span: ::treesitter_types::Span,
1563 pub left: Expression<'tree>,
1564 pub operator: AssignmentExpressionOperator,
1565 pub right: AssignmentExpressionRight<'tree>,
1566}
1567impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1568 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1569 fn from_node(
1570 node: ::treesitter_types::tree_sitter::Node<'tree>,
1571 src: &'tree [u8],
1572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1573 debug_assert_eq!(node.kind(), "assignment_expression");
1574 Ok(Self {
1575 span: ::treesitter_types::Span::from(node),
1576 left: {
1577 let child = node
1578 .child_by_field_name("left")
1579 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1580 ::treesitter_types::runtime::maybe_grow_stack(|| {
1581 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1582 })?
1583 },
1584 operator: {
1585 let child = node.child_by_field_name("operator").ok_or_else(|| {
1586 ::treesitter_types::ParseError::missing_field("operator", node)
1587 })?;
1588 ::treesitter_types::runtime::maybe_grow_stack(|| {
1589 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1590 child, src,
1591 )
1592 })?
1593 },
1594 right: {
1595 let child = node
1596 .child_by_field_name("right")
1597 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1598 ::treesitter_types::runtime::maybe_grow_stack(|| {
1599 <AssignmentExpressionRight as ::treesitter_types::FromNode>::from_node(
1600 child, src,
1601 )
1602 })?
1603 },
1604 })
1605 }
1606}
1607impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1608 fn span(&self) -> ::treesitter_types::Span {
1609 self.span
1610 }
1611}
1612#[derive(Debug, Clone, PartialEq, Eq)]
1613pub struct Attribute<'tree> {
1614 pub span: ::treesitter_types::Span,
1615 pub name: Identifier<'tree>,
1616 pub prefix: ::core::option::Option<Identifier<'tree>>,
1617 pub children: ::core::option::Option<ArgumentList<'tree>>,
1618}
1619impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1620 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1621 fn from_node(
1622 node: ::treesitter_types::tree_sitter::Node<'tree>,
1623 src: &'tree [u8],
1624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1625 debug_assert_eq!(node.kind(), "attribute");
1626 Ok(Self {
1627 span: ::treesitter_types::Span::from(node),
1628 name: {
1629 let child = node
1630 .child_by_field_name("name")
1631 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1632 ::treesitter_types::runtime::maybe_grow_stack(|| {
1633 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1634 })?
1635 },
1636 prefix: match node.child_by_field_name("prefix") {
1637 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1638 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
1639 })?),
1640 None => None,
1641 },
1642 children: {
1643 #[allow(clippy::suspicious_else_formatting)]
1644 let non_field_children = {
1645 let mut cursor = node.walk();
1646 let mut result = ::std::vec::Vec::new();
1647 if cursor.goto_first_child() {
1648 loop {
1649 if cursor.field_name().is_none()
1650 && cursor.node().is_named()
1651 && !cursor.node().is_extra()
1652 {
1653 result.push(cursor.node());
1654 }
1655 if !cursor.goto_next_sibling() {
1656 break;
1657 }
1658 }
1659 }
1660 result
1661 };
1662 match non_field_children.first() {
1663 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1664 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
1665 })?),
1666 None => None,
1667 }
1668 },
1669 })
1670 }
1671}
1672impl ::treesitter_types::Spanned for Attribute<'_> {
1673 fn span(&self) -> ::treesitter_types::Span {
1674 self.span
1675 }
1676}
1677#[derive(Debug, Clone, PartialEq, Eq)]
1678pub struct AttributeDeclaration<'tree> {
1679 pub span: ::treesitter_types::Span,
1680 pub children: ::std::vec::Vec<Attribute<'tree>>,
1681}
1682impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeDeclaration<'tree> {
1683 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1684 fn from_node(
1685 node: ::treesitter_types::tree_sitter::Node<'tree>,
1686 src: &'tree [u8],
1687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1688 debug_assert_eq!(node.kind(), "attribute_declaration");
1689 Ok(Self {
1690 span: ::treesitter_types::Span::from(node),
1691 children: {
1692 #[allow(clippy::suspicious_else_formatting)]
1693 let non_field_children = {
1694 let mut cursor = node.walk();
1695 let mut result = ::std::vec::Vec::new();
1696 if cursor.goto_first_child() {
1697 loop {
1698 if cursor.field_name().is_none()
1699 && cursor.node().is_named()
1700 && !cursor.node().is_extra()
1701 {
1702 result.push(cursor.node());
1703 }
1704 if !cursor.goto_next_sibling() {
1705 break;
1706 }
1707 }
1708 }
1709 result
1710 };
1711 let mut items = ::std::vec::Vec::new();
1712 for child in non_field_children {
1713 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1714 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
1715 })?);
1716 }
1717 items
1718 },
1719 })
1720 }
1721}
1722impl ::treesitter_types::Spanned for AttributeDeclaration<'_> {
1723 fn span(&self) -> ::treesitter_types::Span {
1724 self.span
1725 }
1726}
1727#[derive(Debug, Clone, PartialEq, Eq)]
1728pub struct AttributeSpecifier<'tree> {
1729 pub span: ::treesitter_types::Span,
1730 pub children: ArgumentList<'tree>,
1731}
1732impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeSpecifier<'tree> {
1733 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1734 fn from_node(
1735 node: ::treesitter_types::tree_sitter::Node<'tree>,
1736 src: &'tree [u8],
1737 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1738 debug_assert_eq!(node.kind(), "attribute_specifier");
1739 Ok(Self {
1740 span: ::treesitter_types::Span::from(node),
1741 children: {
1742 #[allow(clippy::suspicious_else_formatting)]
1743 let non_field_children = {
1744 let mut cursor = node.walk();
1745 let mut result = ::std::vec::Vec::new();
1746 if cursor.goto_first_child() {
1747 loop {
1748 if cursor.field_name().is_none()
1749 && cursor.node().is_named()
1750 && !cursor.node().is_extra()
1751 {
1752 result.push(cursor.node());
1753 }
1754 if !cursor.goto_next_sibling() {
1755 break;
1756 }
1757 }
1758 }
1759 result
1760 };
1761 let child = if let Some(&c) = non_field_children.first() {
1762 c
1763 } else {
1764 let mut fallback_cursor = node.walk();
1765 let mut fallback_child = None;
1766 if fallback_cursor.goto_first_child() {
1767 loop {
1768 if fallback_cursor.field_name().is_none()
1769 && !fallback_cursor.node().is_extra()
1770 {
1771 let candidate = fallback_cursor.node();
1772 #[allow(clippy::needless_question_mark)]
1773 if (|| -> ::core::result::Result<
1774 _,
1775 ::treesitter_types::ParseError,
1776 > {
1777 let child = candidate;
1778 Ok(
1779 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
1780 child,
1781 src,
1782 ))?,
1783 )
1784 })()
1785 .is_ok()
1786 {
1787 fallback_child = Some(candidate);
1788 break;
1789 }
1790 }
1791 if !fallback_cursor.goto_next_sibling() {
1792 break;
1793 }
1794 }
1795 }
1796 if fallback_child.is_none() {
1797 let mut cursor2 = node.walk();
1798 if cursor2.goto_first_child() {
1799 loop {
1800 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1801 let candidate = cursor2.node();
1802 #[allow(clippy::needless_question_mark)]
1803 if (|| -> ::core::result::Result<
1804 _,
1805 ::treesitter_types::ParseError,
1806 > {
1807 let child = candidate;
1808 Ok(
1809 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
1810 child,
1811 src,
1812 ))?,
1813 )
1814 })()
1815 .is_ok()
1816 {
1817 fallback_child = Some(candidate);
1818 break;
1819 }
1820 }
1821 if !cursor2.goto_next_sibling() {
1822 break;
1823 }
1824 }
1825 }
1826 }
1827 fallback_child.ok_or_else(|| {
1828 ::treesitter_types::ParseError::missing_field("children", node)
1829 })?
1830 };
1831 ::treesitter_types::runtime::maybe_grow_stack(|| {
1832 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
1833 })?
1834 },
1835 })
1836 }
1837}
1838impl ::treesitter_types::Spanned for AttributeSpecifier<'_> {
1839 fn span(&self) -> ::treesitter_types::Span {
1840 self.span
1841 }
1842}
1843#[derive(Debug, Clone, PartialEq, Eq)]
1844pub struct AttributedDeclarator<'tree> {
1845 pub span: ::treesitter_types::Span,
1846 pub children: ::std::vec::Vec<AttributedDeclaratorChildren<'tree>>,
1847}
1848impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclarator<'tree> {
1849 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1850 fn from_node(
1851 node: ::treesitter_types::tree_sitter::Node<'tree>,
1852 src: &'tree [u8],
1853 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1854 debug_assert_eq!(node.kind(), "attributed_declarator");
1855 Ok(Self {
1856 span: ::treesitter_types::Span::from(node),
1857 children: {
1858 #[allow(clippy::suspicious_else_formatting)]
1859 let non_field_children = {
1860 let mut cursor = node.walk();
1861 let mut result = ::std::vec::Vec::new();
1862 if cursor.goto_first_child() {
1863 loop {
1864 if cursor.field_name().is_none()
1865 && cursor.node().is_named()
1866 && !cursor.node().is_extra()
1867 {
1868 result.push(cursor.node());
1869 }
1870 if !cursor.goto_next_sibling() {
1871 break;
1872 }
1873 }
1874 }
1875 result
1876 };
1877 let mut items = ::std::vec::Vec::new();
1878 for child in non_field_children {
1879 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1880 <AttributedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1881 child, src,
1882 )
1883 })?);
1884 }
1885 items
1886 },
1887 })
1888 }
1889}
1890impl ::treesitter_types::Spanned for AttributedDeclarator<'_> {
1891 fn span(&self) -> ::treesitter_types::Span {
1892 self.span
1893 }
1894}
1895#[derive(Debug, Clone, PartialEq, Eq)]
1896pub struct AttributedStatement<'tree> {
1897 pub span: ::treesitter_types::Span,
1898 pub children: ::std::vec::Vec<AttributedStatementChildren<'tree>>,
1899}
1900impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatement<'tree> {
1901 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1902 fn from_node(
1903 node: ::treesitter_types::tree_sitter::Node<'tree>,
1904 src: &'tree [u8],
1905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1906 debug_assert_eq!(node.kind(), "attributed_statement");
1907 Ok(Self {
1908 span: ::treesitter_types::Span::from(node),
1909 children: {
1910 #[allow(clippy::suspicious_else_formatting)]
1911 let non_field_children = {
1912 let mut cursor = node.walk();
1913 let mut result = ::std::vec::Vec::new();
1914 if cursor.goto_first_child() {
1915 loop {
1916 if cursor.field_name().is_none()
1917 && cursor.node().is_named()
1918 && !cursor.node().is_extra()
1919 {
1920 result.push(cursor.node());
1921 }
1922 if !cursor.goto_next_sibling() {
1923 break;
1924 }
1925 }
1926 }
1927 result
1928 };
1929 let mut items = ::std::vec::Vec::new();
1930 for child in non_field_children {
1931 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1932 <AttributedStatementChildren as ::treesitter_types::FromNode>::from_node(
1933 child, src,
1934 )
1935 })?);
1936 }
1937 items
1938 },
1939 })
1940 }
1941}
1942impl ::treesitter_types::Spanned for AttributedStatement<'_> {
1943 fn span(&self) -> ::treesitter_types::Span {
1944 self.span
1945 }
1946}
1947#[derive(Debug, Clone, PartialEq, Eq)]
1948pub struct BaseClassClause<'tree> {
1949 pub span: ::treesitter_types::Span,
1950 pub children: ::std::vec::Vec<BaseClassClauseChildren<'tree>>,
1951}
1952impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClassClause<'tree> {
1953 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1954 fn from_node(
1955 node: ::treesitter_types::tree_sitter::Node<'tree>,
1956 src: &'tree [u8],
1957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1958 debug_assert_eq!(node.kind(), "base_class_clause");
1959 Ok(Self {
1960 span: ::treesitter_types::Span::from(node),
1961 children: {
1962 #[allow(clippy::suspicious_else_formatting)]
1963 let non_field_children = {
1964 let mut cursor = node.walk();
1965 let mut result = ::std::vec::Vec::new();
1966 if cursor.goto_first_child() {
1967 loop {
1968 if cursor.field_name().is_none()
1969 && cursor.node().is_named()
1970 && !cursor.node().is_extra()
1971 {
1972 result.push(cursor.node());
1973 }
1974 if !cursor.goto_next_sibling() {
1975 break;
1976 }
1977 }
1978 }
1979 result
1980 };
1981 let mut items = ::std::vec::Vec::new();
1982 for child in non_field_children {
1983 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1984 <BaseClassClauseChildren as ::treesitter_types::FromNode>::from_node(
1985 child, src,
1986 )
1987 })?);
1988 }
1989 items
1990 },
1991 })
1992 }
1993}
1994impl ::treesitter_types::Spanned for BaseClassClause<'_> {
1995 fn span(&self) -> ::treesitter_types::Span {
1996 self.span
1997 }
1998}
1999#[derive(Debug, Clone, PartialEq, Eq)]
2000pub struct BinaryExpression<'tree> {
2001 pub span: ::treesitter_types::Span,
2002 pub left: BinaryExpressionLeft<'tree>,
2003 pub operator: BinaryExpressionOperator,
2004 pub right: BinaryExpressionRight<'tree>,
2005}
2006impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
2007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2008 fn from_node(
2009 node: ::treesitter_types::tree_sitter::Node<'tree>,
2010 src: &'tree [u8],
2011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2012 debug_assert_eq!(node.kind(), "binary_expression");
2013 Ok(Self {
2014 span: ::treesitter_types::Span::from(node),
2015 left: {
2016 let child = node
2017 .child_by_field_name("left")
2018 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2019 ::treesitter_types::runtime::maybe_grow_stack(|| {
2020 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
2021 })?
2022 },
2023 operator: {
2024 let child = node.child_by_field_name("operator").ok_or_else(|| {
2025 ::treesitter_types::ParseError::missing_field("operator", node)
2026 })?;
2027 ::treesitter_types::runtime::maybe_grow_stack(|| {
2028 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
2029 child, src,
2030 )
2031 })?
2032 },
2033 right: {
2034 let child = node
2035 .child_by_field_name("right")
2036 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2037 ::treesitter_types::runtime::maybe_grow_stack(|| {
2038 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
2039 })?
2040 },
2041 })
2042 }
2043}
2044impl ::treesitter_types::Spanned for BinaryExpression<'_> {
2045 fn span(&self) -> ::treesitter_types::Span {
2046 self.span
2047 }
2048}
2049#[derive(Debug, Clone, PartialEq, Eq)]
2050pub struct BitfieldClause<'tree> {
2051 pub span: ::treesitter_types::Span,
2052 pub children: Expression<'tree>,
2053}
2054impl<'tree> ::treesitter_types::FromNode<'tree> for BitfieldClause<'tree> {
2055 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2056 fn from_node(
2057 node: ::treesitter_types::tree_sitter::Node<'tree>,
2058 src: &'tree [u8],
2059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2060 debug_assert_eq!(node.kind(), "bitfield_clause");
2061 Ok(Self {
2062 span: ::treesitter_types::Span::from(node),
2063 children: {
2064 #[allow(clippy::suspicious_else_formatting)]
2065 let non_field_children = {
2066 let mut cursor = node.walk();
2067 let mut result = ::std::vec::Vec::new();
2068 if cursor.goto_first_child() {
2069 loop {
2070 if cursor.field_name().is_none()
2071 && cursor.node().is_named()
2072 && !cursor.node().is_extra()
2073 {
2074 result.push(cursor.node());
2075 }
2076 if !cursor.goto_next_sibling() {
2077 break;
2078 }
2079 }
2080 }
2081 result
2082 };
2083 let child = if let Some(&c) = non_field_children.first() {
2084 c
2085 } else {
2086 let mut fallback_cursor = node.walk();
2087 let mut fallback_child = None;
2088 if fallback_cursor.goto_first_child() {
2089 loop {
2090 if fallback_cursor.field_name().is_none()
2091 && !fallback_cursor.node().is_extra()
2092 {
2093 let candidate = fallback_cursor.node();
2094 #[allow(clippy::needless_question_mark)]
2095 if (|| -> ::core::result::Result<
2096 _,
2097 ::treesitter_types::ParseError,
2098 > {
2099 let child = candidate;
2100 Ok(
2101 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2102 child,
2103 src,
2104 ))?,
2105 )
2106 })()
2107 .is_ok()
2108 {
2109 fallback_child = Some(candidate);
2110 break;
2111 }
2112 }
2113 if !fallback_cursor.goto_next_sibling() {
2114 break;
2115 }
2116 }
2117 }
2118 if fallback_child.is_none() {
2119 let mut cursor2 = node.walk();
2120 if cursor2.goto_first_child() {
2121 loop {
2122 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2123 let candidate = cursor2.node();
2124 #[allow(clippy::needless_question_mark)]
2125 if (|| -> ::core::result::Result<
2126 _,
2127 ::treesitter_types::ParseError,
2128 > {
2129 let child = candidate;
2130 Ok(
2131 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2132 child,
2133 src,
2134 ))?,
2135 )
2136 })()
2137 .is_ok()
2138 {
2139 fallback_child = Some(candidate);
2140 break;
2141 }
2142 }
2143 if !cursor2.goto_next_sibling() {
2144 break;
2145 }
2146 }
2147 }
2148 }
2149 fallback_child.ok_or_else(|| {
2150 ::treesitter_types::ParseError::missing_field("children", node)
2151 })?
2152 };
2153 ::treesitter_types::runtime::maybe_grow_stack(|| {
2154 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2155 })?
2156 },
2157 })
2158 }
2159}
2160impl ::treesitter_types::Spanned for BitfieldClause<'_> {
2161 fn span(&self) -> ::treesitter_types::Span {
2162 self.span
2163 }
2164}
2165#[derive(Debug, Clone, PartialEq, Eq)]
2166pub struct BreakStatement<'tree> {
2167 pub span: ::treesitter_types::Span,
2168 text: &'tree str,
2169}
2170impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
2171 fn from_node(
2172 node: ::treesitter_types::tree_sitter::Node<'tree>,
2173 src: &'tree [u8],
2174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2175 debug_assert_eq!(node.kind(), "break_statement");
2176 Ok(Self {
2177 span: ::treesitter_types::Span::from(node),
2178 text: node.utf8_text(src)?,
2179 })
2180 }
2181}
2182impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
2183 fn text(&self) -> &'tree str {
2184 self.text
2185 }
2186}
2187impl ::treesitter_types::Spanned for BreakStatement<'_> {
2188 fn span(&self) -> ::treesitter_types::Span {
2189 self.span
2190 }
2191}
2192#[derive(Debug, Clone, PartialEq, Eq)]
2193pub struct CallExpression<'tree> {
2194 pub span: ::treesitter_types::Span,
2195 pub arguments: ArgumentList<'tree>,
2196 pub function: CallExpressionFunction<'tree>,
2197}
2198impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
2199 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2200 fn from_node(
2201 node: ::treesitter_types::tree_sitter::Node<'tree>,
2202 src: &'tree [u8],
2203 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2204 debug_assert_eq!(node.kind(), "call_expression");
2205 Ok(Self {
2206 span: ::treesitter_types::Span::from(node),
2207 arguments: {
2208 let child = node.child_by_field_name("arguments").ok_or_else(|| {
2209 ::treesitter_types::ParseError::missing_field("arguments", node)
2210 })?;
2211 ::treesitter_types::runtime::maybe_grow_stack(|| {
2212 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
2213 })?
2214 },
2215 function: {
2216 let child = node.child_by_field_name("function").ok_or_else(|| {
2217 ::treesitter_types::ParseError::missing_field("function", node)
2218 })?;
2219 ::treesitter_types::runtime::maybe_grow_stack(|| {
2220 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)
2221 })?
2222 },
2223 })
2224 }
2225}
2226impl ::treesitter_types::Spanned for CallExpression<'_> {
2227 fn span(&self) -> ::treesitter_types::Span {
2228 self.span
2229 }
2230}
2231#[derive(Debug, Clone, PartialEq, Eq)]
2232pub struct CaseStatement<'tree> {
2233 pub span: ::treesitter_types::Span,
2234 pub value: ::core::option::Option<Expression<'tree>>,
2235 pub children: ::std::vec::Vec<CaseStatementChildren<'tree>>,
2236}
2237impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatement<'tree> {
2238 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2239 fn from_node(
2240 node: ::treesitter_types::tree_sitter::Node<'tree>,
2241 src: &'tree [u8],
2242 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2243 debug_assert_eq!(node.kind(), "case_statement");
2244 Ok(Self {
2245 span: ::treesitter_types::Span::from(node),
2246 value: match node.child_by_field_name("value") {
2247 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2248 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2249 })?),
2250 None => None,
2251 },
2252 children: {
2253 #[allow(clippy::suspicious_else_formatting)]
2254 let non_field_children = {
2255 let mut cursor = node.walk();
2256 let mut result = ::std::vec::Vec::new();
2257 if cursor.goto_first_child() {
2258 loop {
2259 if cursor.field_name().is_none()
2260 && cursor.node().is_named()
2261 && !cursor.node().is_extra()
2262 {
2263 result.push(cursor.node());
2264 }
2265 if !cursor.goto_next_sibling() {
2266 break;
2267 }
2268 }
2269 }
2270 result
2271 };
2272 let mut items = ::std::vec::Vec::new();
2273 for child in non_field_children {
2274 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2275 <CaseStatementChildren as ::treesitter_types::FromNode>::from_node(
2276 child, src,
2277 )
2278 })?);
2279 }
2280 items
2281 },
2282 })
2283 }
2284}
2285impl ::treesitter_types::Spanned for CaseStatement<'_> {
2286 fn span(&self) -> ::treesitter_types::Span {
2287 self.span
2288 }
2289}
2290#[derive(Debug, Clone, PartialEq, Eq)]
2291pub struct CastExpression<'tree> {
2292 pub span: ::treesitter_types::Span,
2293 pub r#type: TypeDescriptor<'tree>,
2294 pub value: Expression<'tree>,
2295}
2296impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
2297 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2298 fn from_node(
2299 node: ::treesitter_types::tree_sitter::Node<'tree>,
2300 src: &'tree [u8],
2301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2302 debug_assert_eq!(node.kind(), "cast_expression");
2303 Ok(Self {
2304 span: ::treesitter_types::Span::from(node),
2305 r#type: {
2306 let child = node
2307 .child_by_field_name("type")
2308 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2309 ::treesitter_types::runtime::maybe_grow_stack(|| {
2310 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
2311 })?
2312 },
2313 value: {
2314 let child = node
2315 .child_by_field_name("value")
2316 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2317 ::treesitter_types::runtime::maybe_grow_stack(|| {
2318 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2319 })?
2320 },
2321 })
2322 }
2323}
2324impl ::treesitter_types::Spanned for CastExpression<'_> {
2325 fn span(&self) -> ::treesitter_types::Span {
2326 self.span
2327 }
2328}
2329#[derive(Debug, Clone, PartialEq, Eq)]
2330pub struct CatchClause<'tree> {
2331 pub span: ::treesitter_types::Span,
2332 pub body: CompoundStatement<'tree>,
2333 pub parameters: ParameterList<'tree>,
2334}
2335impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2336 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2337 fn from_node(
2338 node: ::treesitter_types::tree_sitter::Node<'tree>,
2339 src: &'tree [u8],
2340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2341 debug_assert_eq!(node.kind(), "catch_clause");
2342 Ok(Self {
2343 span: ::treesitter_types::Span::from(node),
2344 body: {
2345 let child = node
2346 .child_by_field_name("body")
2347 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2348 ::treesitter_types::runtime::maybe_grow_stack(|| {
2349 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
2350 })?
2351 },
2352 parameters: {
2353 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2354 ::treesitter_types::ParseError::missing_field("parameters", node)
2355 })?;
2356 ::treesitter_types::runtime::maybe_grow_stack(|| {
2357 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
2358 })?
2359 },
2360 })
2361 }
2362}
2363impl ::treesitter_types::Spanned for CatchClause<'_> {
2364 fn span(&self) -> ::treesitter_types::Span {
2365 self.span
2366 }
2367}
2368#[derive(Debug, Clone, PartialEq, Eq)]
2369pub struct CharLiteral<'tree> {
2370 pub span: ::treesitter_types::Span,
2371 pub children: ::std::vec::Vec<CharLiteralChildren<'tree>>,
2372}
2373impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
2374 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2375 fn from_node(
2376 node: ::treesitter_types::tree_sitter::Node<'tree>,
2377 src: &'tree [u8],
2378 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2379 debug_assert_eq!(node.kind(), "char_literal");
2380 Ok(Self {
2381 span: ::treesitter_types::Span::from(node),
2382 children: {
2383 #[allow(clippy::suspicious_else_formatting)]
2384 let non_field_children = {
2385 let mut cursor = node.walk();
2386 let mut result = ::std::vec::Vec::new();
2387 if cursor.goto_first_child() {
2388 loop {
2389 if cursor.field_name().is_none()
2390 && cursor.node().is_named()
2391 && !cursor.node().is_extra()
2392 {
2393 result.push(cursor.node());
2394 }
2395 if !cursor.goto_next_sibling() {
2396 break;
2397 }
2398 }
2399 }
2400 result
2401 };
2402 let mut items = ::std::vec::Vec::new();
2403 for child in non_field_children {
2404 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2405 <CharLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)
2406 })?);
2407 }
2408 items
2409 },
2410 })
2411 }
2412}
2413impl ::treesitter_types::Spanned for CharLiteral<'_> {
2414 fn span(&self) -> ::treesitter_types::Span {
2415 self.span
2416 }
2417}
2418#[derive(Debug, Clone, PartialEq, Eq)]
2419pub struct ClassSpecifier<'tree> {
2420 pub span: ::treesitter_types::Span,
2421 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
2422 pub name: ::core::option::Option<ClassSpecifierName<'tree>>,
2423 pub children: ::std::vec::Vec<ClassSpecifierChildren<'tree>>,
2424}
2425impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifier<'tree> {
2426 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2427 fn from_node(
2428 node: ::treesitter_types::tree_sitter::Node<'tree>,
2429 src: &'tree [u8],
2430 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2431 debug_assert_eq!(node.kind(), "class_specifier");
2432 Ok(Self {
2433 span: ::treesitter_types::Span::from(node),
2434 body: match node.child_by_field_name("body") {
2435 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2436 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
2437 })?),
2438 None => None,
2439 },
2440 name: match node.child_by_field_name("name") {
2441 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2442 <ClassSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
2443 })?),
2444 None => None,
2445 },
2446 children: {
2447 #[allow(clippy::suspicious_else_formatting)]
2448 let non_field_children = {
2449 let mut cursor = node.walk();
2450 let mut result = ::std::vec::Vec::new();
2451 if cursor.goto_first_child() {
2452 loop {
2453 if cursor.field_name().is_none()
2454 && cursor.node().is_named()
2455 && !cursor.node().is_extra()
2456 {
2457 result.push(cursor.node());
2458 }
2459 if !cursor.goto_next_sibling() {
2460 break;
2461 }
2462 }
2463 }
2464 result
2465 };
2466 let mut items = ::std::vec::Vec::new();
2467 for child in non_field_children {
2468 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2469 <ClassSpecifierChildren as ::treesitter_types::FromNode>::from_node(
2470 child, src,
2471 )
2472 })?);
2473 }
2474 items
2475 },
2476 })
2477 }
2478}
2479impl ::treesitter_types::Spanned for ClassSpecifier<'_> {
2480 fn span(&self) -> ::treesitter_types::Span {
2481 self.span
2482 }
2483}
2484#[derive(Debug, Clone, PartialEq, Eq)]
2485pub struct CoAwaitExpression<'tree> {
2486 pub span: ::treesitter_types::Span,
2487 pub argument: Expression<'tree>,
2488 pub operator: CoAwaitExpressionOperator,
2489}
2490impl<'tree> ::treesitter_types::FromNode<'tree> for CoAwaitExpression<'tree> {
2491 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2492 fn from_node(
2493 node: ::treesitter_types::tree_sitter::Node<'tree>,
2494 src: &'tree [u8],
2495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2496 debug_assert_eq!(node.kind(), "co_await_expression");
2497 Ok(Self {
2498 span: ::treesitter_types::Span::from(node),
2499 argument: {
2500 let child = node.child_by_field_name("argument").ok_or_else(|| {
2501 ::treesitter_types::ParseError::missing_field("argument", node)
2502 })?;
2503 ::treesitter_types::runtime::maybe_grow_stack(|| {
2504 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2505 })?
2506 },
2507 operator: {
2508 let child = node.child_by_field_name("operator").ok_or_else(|| {
2509 ::treesitter_types::ParseError::missing_field("operator", node)
2510 })?;
2511 ::treesitter_types::runtime::maybe_grow_stack(|| {
2512 <CoAwaitExpressionOperator as ::treesitter_types::FromNode>::from_node(
2513 child, src,
2514 )
2515 })?
2516 },
2517 })
2518 }
2519}
2520impl ::treesitter_types::Spanned for CoAwaitExpression<'_> {
2521 fn span(&self) -> ::treesitter_types::Span {
2522 self.span
2523 }
2524}
2525#[derive(Debug, Clone, PartialEq, Eq)]
2526pub struct CoReturnStatement<'tree> {
2527 pub span: ::treesitter_types::Span,
2528 pub children: ::core::option::Option<Expression<'tree>>,
2529}
2530impl<'tree> ::treesitter_types::FromNode<'tree> for CoReturnStatement<'tree> {
2531 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2532 fn from_node(
2533 node: ::treesitter_types::tree_sitter::Node<'tree>,
2534 src: &'tree [u8],
2535 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2536 debug_assert_eq!(node.kind(), "co_return_statement");
2537 Ok(Self {
2538 span: ::treesitter_types::Span::from(node),
2539 children: {
2540 #[allow(clippy::suspicious_else_formatting)]
2541 let non_field_children = {
2542 let mut cursor = node.walk();
2543 let mut result = ::std::vec::Vec::new();
2544 if cursor.goto_first_child() {
2545 loop {
2546 if cursor.field_name().is_none()
2547 && cursor.node().is_named()
2548 && !cursor.node().is_extra()
2549 {
2550 result.push(cursor.node());
2551 }
2552 if !cursor.goto_next_sibling() {
2553 break;
2554 }
2555 }
2556 }
2557 result
2558 };
2559 match non_field_children.first() {
2560 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2561 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2562 })?),
2563 None => None,
2564 }
2565 },
2566 })
2567 }
2568}
2569impl ::treesitter_types::Spanned for CoReturnStatement<'_> {
2570 fn span(&self) -> ::treesitter_types::Span {
2571 self.span
2572 }
2573}
2574#[derive(Debug, Clone, PartialEq, Eq)]
2575pub struct CoYieldStatement<'tree> {
2576 pub span: ::treesitter_types::Span,
2577 pub children: Expression<'tree>,
2578}
2579impl<'tree> ::treesitter_types::FromNode<'tree> for CoYieldStatement<'tree> {
2580 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2581 fn from_node(
2582 node: ::treesitter_types::tree_sitter::Node<'tree>,
2583 src: &'tree [u8],
2584 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2585 debug_assert_eq!(node.kind(), "co_yield_statement");
2586 Ok(Self {
2587 span: ::treesitter_types::Span::from(node),
2588 children: {
2589 #[allow(clippy::suspicious_else_formatting)]
2590 let non_field_children = {
2591 let mut cursor = node.walk();
2592 let mut result = ::std::vec::Vec::new();
2593 if cursor.goto_first_child() {
2594 loop {
2595 if cursor.field_name().is_none()
2596 && cursor.node().is_named()
2597 && !cursor.node().is_extra()
2598 {
2599 result.push(cursor.node());
2600 }
2601 if !cursor.goto_next_sibling() {
2602 break;
2603 }
2604 }
2605 }
2606 result
2607 };
2608 let child = if let Some(&c) = non_field_children.first() {
2609 c
2610 } else {
2611 let mut fallback_cursor = node.walk();
2612 let mut fallback_child = None;
2613 if fallback_cursor.goto_first_child() {
2614 loop {
2615 if fallback_cursor.field_name().is_none()
2616 && !fallback_cursor.node().is_extra()
2617 {
2618 let candidate = fallback_cursor.node();
2619 #[allow(clippy::needless_question_mark)]
2620 if (|| -> ::core::result::Result<
2621 _,
2622 ::treesitter_types::ParseError,
2623 > {
2624 let child = candidate;
2625 Ok(
2626 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2627 child,
2628 src,
2629 ))?,
2630 )
2631 })()
2632 .is_ok()
2633 {
2634 fallback_child = Some(candidate);
2635 break;
2636 }
2637 }
2638 if !fallback_cursor.goto_next_sibling() {
2639 break;
2640 }
2641 }
2642 }
2643 if fallback_child.is_none() {
2644 let mut cursor2 = node.walk();
2645 if cursor2.goto_first_child() {
2646 loop {
2647 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2648 let candidate = cursor2.node();
2649 #[allow(clippy::needless_question_mark)]
2650 if (|| -> ::core::result::Result<
2651 _,
2652 ::treesitter_types::ParseError,
2653 > {
2654 let child = candidate;
2655 Ok(
2656 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2657 child,
2658 src,
2659 ))?,
2660 )
2661 })()
2662 .is_ok()
2663 {
2664 fallback_child = Some(candidate);
2665 break;
2666 }
2667 }
2668 if !cursor2.goto_next_sibling() {
2669 break;
2670 }
2671 }
2672 }
2673 }
2674 fallback_child.ok_or_else(|| {
2675 ::treesitter_types::ParseError::missing_field("children", node)
2676 })?
2677 };
2678 ::treesitter_types::runtime::maybe_grow_stack(|| {
2679 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2680 })?
2681 },
2682 })
2683 }
2684}
2685impl ::treesitter_types::Spanned for CoYieldStatement<'_> {
2686 fn span(&self) -> ::treesitter_types::Span {
2687 self.span
2688 }
2689}
2690#[derive(Debug, Clone, PartialEq, Eq)]
2691pub struct CommaExpression<'tree> {
2692 pub span: ::treesitter_types::Span,
2693 pub left: Expression<'tree>,
2694 pub right: CommaExpressionRight<'tree>,
2695}
2696impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpression<'tree> {
2697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2698 fn from_node(
2699 node: ::treesitter_types::tree_sitter::Node<'tree>,
2700 src: &'tree [u8],
2701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2702 debug_assert_eq!(node.kind(), "comma_expression");
2703 Ok(Self {
2704 span: ::treesitter_types::Span::from(node),
2705 left: {
2706 let child = node
2707 .child_by_field_name("left")
2708 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2709 ::treesitter_types::runtime::maybe_grow_stack(|| {
2710 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2711 })?
2712 },
2713 right: {
2714 let child = node
2715 .child_by_field_name("right")
2716 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2717 ::treesitter_types::runtime::maybe_grow_stack(|| {
2718 <CommaExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
2719 })?
2720 },
2721 })
2722 }
2723}
2724impl ::treesitter_types::Spanned for CommaExpression<'_> {
2725 fn span(&self) -> ::treesitter_types::Span {
2726 self.span
2727 }
2728}
2729#[derive(Debug, Clone, PartialEq, Eq)]
2730pub struct CompoundLiteralExpression<'tree> {
2731 pub span: ::treesitter_types::Span,
2732 pub r#type: CompoundLiteralExpressionType<'tree>,
2733 pub value: InitializerList<'tree>,
2734}
2735impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundLiteralExpression<'tree> {
2736 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2737 fn from_node(
2738 node: ::treesitter_types::tree_sitter::Node<'tree>,
2739 src: &'tree [u8],
2740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2741 debug_assert_eq!(node.kind(), "compound_literal_expression");
2742 Ok(Self {
2743 span: ::treesitter_types::Span::from(node),
2744 r#type: {
2745 let child = node
2746 .child_by_field_name("type")
2747 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2748 ::treesitter_types::runtime::maybe_grow_stack(|| {
2749 <CompoundLiteralExpressionType as ::treesitter_types::FromNode>::from_node(
2750 child, src,
2751 )
2752 })?
2753 },
2754 value: {
2755 let child = node
2756 .child_by_field_name("value")
2757 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2758 ::treesitter_types::runtime::maybe_grow_stack(|| {
2759 <InitializerList as ::treesitter_types::FromNode>::from_node(child, src)
2760 })?
2761 },
2762 })
2763 }
2764}
2765impl ::treesitter_types::Spanned for CompoundLiteralExpression<'_> {
2766 fn span(&self) -> ::treesitter_types::Span {
2767 self.span
2768 }
2769}
2770#[derive(Debug, Clone, PartialEq, Eq)]
2771pub struct CompoundRequirement<'tree> {
2772 pub span: ::treesitter_types::Span,
2773 pub children: ::std::vec::Vec<CompoundRequirementChildren<'tree>>,
2774}
2775impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundRequirement<'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(), "compound_requirement");
2782 Ok(Self {
2783 span: ::treesitter_types::Span::from(node),
2784 children: {
2785 #[allow(clippy::suspicious_else_formatting)]
2786 let non_field_children = {
2787 let mut cursor = node.walk();
2788 let mut result = ::std::vec::Vec::new();
2789 if cursor.goto_first_child() {
2790 loop {
2791 if cursor.field_name().is_none()
2792 && cursor.node().is_named()
2793 && !cursor.node().is_extra()
2794 {
2795 result.push(cursor.node());
2796 }
2797 if !cursor.goto_next_sibling() {
2798 break;
2799 }
2800 }
2801 }
2802 result
2803 };
2804 let mut items = ::std::vec::Vec::new();
2805 for child in non_field_children {
2806 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2807 <CompoundRequirementChildren as ::treesitter_types::FromNode>::from_node(
2808 child, src,
2809 )
2810 })?);
2811 }
2812 items
2813 },
2814 })
2815 }
2816}
2817impl ::treesitter_types::Spanned for CompoundRequirement<'_> {
2818 fn span(&self) -> ::treesitter_types::Span {
2819 self.span
2820 }
2821}
2822#[derive(Debug, Clone, PartialEq, Eq)]
2823pub struct CompoundStatement<'tree> {
2824 pub span: ::treesitter_types::Span,
2825 pub children: ::std::vec::Vec<CompoundStatementChildren<'tree>>,
2826}
2827impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatement<'tree> {
2828 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2829 fn from_node(
2830 node: ::treesitter_types::tree_sitter::Node<'tree>,
2831 src: &'tree [u8],
2832 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2833 debug_assert_eq!(node.kind(), "compound_statement");
2834 Ok(Self {
2835 span: ::treesitter_types::Span::from(node),
2836 children: {
2837 #[allow(clippy::suspicious_else_formatting)]
2838 let non_field_children = {
2839 let mut cursor = node.walk();
2840 let mut result = ::std::vec::Vec::new();
2841 if cursor.goto_first_child() {
2842 loop {
2843 if cursor.field_name().is_none()
2844 && cursor.node().is_named()
2845 && !cursor.node().is_extra()
2846 {
2847 result.push(cursor.node());
2848 }
2849 if !cursor.goto_next_sibling() {
2850 break;
2851 }
2852 }
2853 }
2854 result
2855 };
2856 let mut items = ::std::vec::Vec::new();
2857 for child in non_field_children {
2858 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2859 <CompoundStatementChildren as ::treesitter_types::FromNode>::from_node(
2860 child, src,
2861 )
2862 })?);
2863 }
2864 items
2865 },
2866 })
2867 }
2868}
2869impl ::treesitter_types::Spanned for CompoundStatement<'_> {
2870 fn span(&self) -> ::treesitter_types::Span {
2871 self.span
2872 }
2873}
2874#[derive(Debug, Clone, PartialEq, Eq)]
2875pub struct ConcatenatedString<'tree> {
2876 pub span: ::treesitter_types::Span,
2877 pub children: ::std::vec::Vec<ConcatenatedStringChildren<'tree>>,
2878}
2879impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedString<'tree> {
2880 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2881 fn from_node(
2882 node: ::treesitter_types::tree_sitter::Node<'tree>,
2883 src: &'tree [u8],
2884 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2885 debug_assert_eq!(node.kind(), "concatenated_string");
2886 Ok(Self {
2887 span: ::treesitter_types::Span::from(node),
2888 children: {
2889 #[allow(clippy::suspicious_else_formatting)]
2890 let non_field_children = {
2891 let mut cursor = node.walk();
2892 let mut result = ::std::vec::Vec::new();
2893 if cursor.goto_first_child() {
2894 loop {
2895 if cursor.field_name().is_none()
2896 && cursor.node().is_named()
2897 && !cursor.node().is_extra()
2898 {
2899 result.push(cursor.node());
2900 }
2901 if !cursor.goto_next_sibling() {
2902 break;
2903 }
2904 }
2905 }
2906 result
2907 };
2908 let mut items = ::std::vec::Vec::new();
2909 for child in non_field_children {
2910 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2911 <ConcatenatedStringChildren as ::treesitter_types::FromNode>::from_node(
2912 child, src,
2913 )
2914 })?);
2915 }
2916 items
2917 },
2918 })
2919 }
2920}
2921impl ::treesitter_types::Spanned for ConcatenatedString<'_> {
2922 fn span(&self) -> ::treesitter_types::Span {
2923 self.span
2924 }
2925}
2926#[derive(Debug, Clone, PartialEq, Eq)]
2927pub struct ConceptDefinition<'tree> {
2928 pub span: ::treesitter_types::Span,
2929 pub name: Identifier<'tree>,
2930 pub children: Expression<'tree>,
2931}
2932impl<'tree> ::treesitter_types::FromNode<'tree> for ConceptDefinition<'tree> {
2933 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2934 fn from_node(
2935 node: ::treesitter_types::tree_sitter::Node<'tree>,
2936 src: &'tree [u8],
2937 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2938 debug_assert_eq!(node.kind(), "concept_definition");
2939 Ok(Self {
2940 span: ::treesitter_types::Span::from(node),
2941 name: {
2942 let child = node
2943 .child_by_field_name("name")
2944 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2945 ::treesitter_types::runtime::maybe_grow_stack(|| {
2946 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
2947 })?
2948 },
2949 children: {
2950 #[allow(clippy::suspicious_else_formatting)]
2951 let non_field_children = {
2952 let mut cursor = node.walk();
2953 let mut result = ::std::vec::Vec::new();
2954 if cursor.goto_first_child() {
2955 loop {
2956 if cursor.field_name().is_none()
2957 && cursor.node().is_named()
2958 && !cursor.node().is_extra()
2959 {
2960 result.push(cursor.node());
2961 }
2962 if !cursor.goto_next_sibling() {
2963 break;
2964 }
2965 }
2966 }
2967 result
2968 };
2969 let child = if let Some(&c) = non_field_children.first() {
2970 c
2971 } else {
2972 let mut fallback_cursor = node.walk();
2973 let mut fallback_child = None;
2974 if fallback_cursor.goto_first_child() {
2975 loop {
2976 if fallback_cursor.field_name().is_none()
2977 && !fallback_cursor.node().is_extra()
2978 {
2979 let candidate = fallback_cursor.node();
2980 #[allow(clippy::needless_question_mark)]
2981 if (|| -> ::core::result::Result<
2982 _,
2983 ::treesitter_types::ParseError,
2984 > {
2985 let child = candidate;
2986 Ok(
2987 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
2988 child,
2989 src,
2990 ))?,
2991 )
2992 })()
2993 .is_ok()
2994 {
2995 fallback_child = Some(candidate);
2996 break;
2997 }
2998 }
2999 if !fallback_cursor.goto_next_sibling() {
3000 break;
3001 }
3002 }
3003 }
3004 if fallback_child.is_none() {
3005 let mut cursor2 = node.walk();
3006 if cursor2.goto_first_child() {
3007 loop {
3008 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3009 let candidate = cursor2.node();
3010 #[allow(clippy::needless_question_mark)]
3011 if (|| -> ::core::result::Result<
3012 _,
3013 ::treesitter_types::ParseError,
3014 > {
3015 let child = candidate;
3016 Ok(
3017 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3018 child,
3019 src,
3020 ))?,
3021 )
3022 })()
3023 .is_ok()
3024 {
3025 fallback_child = Some(candidate);
3026 break;
3027 }
3028 }
3029 if !cursor2.goto_next_sibling() {
3030 break;
3031 }
3032 }
3033 }
3034 }
3035 fallback_child.ok_or_else(|| {
3036 ::treesitter_types::ParseError::missing_field("children", node)
3037 })?
3038 };
3039 ::treesitter_types::runtime::maybe_grow_stack(|| {
3040 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3041 })?
3042 },
3043 })
3044 }
3045}
3046impl ::treesitter_types::Spanned for ConceptDefinition<'_> {
3047 fn span(&self) -> ::treesitter_types::Span {
3048 self.span
3049 }
3050}
3051#[derive(Debug, Clone, PartialEq, Eq)]
3052pub struct ConditionClause<'tree> {
3053 pub span: ::treesitter_types::Span,
3054 pub initializer: ::core::option::Option<InitStatement<'tree>>,
3055 pub value: ConditionClauseValue<'tree>,
3056}
3057impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionClause<'tree> {
3058 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3059 fn from_node(
3060 node: ::treesitter_types::tree_sitter::Node<'tree>,
3061 src: &'tree [u8],
3062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3063 debug_assert_eq!(node.kind(), "condition_clause");
3064 Ok(Self {
3065 span: ::treesitter_types::Span::from(node),
3066 initializer: match node.child_by_field_name("initializer") {
3067 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3068 <InitStatement as ::treesitter_types::FromNode>::from_node(child, src)
3069 })?),
3070 None => None,
3071 },
3072 value: {
3073 let child = node
3074 .child_by_field_name("value")
3075 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3076 ::treesitter_types::runtime::maybe_grow_stack(|| {
3077 <ConditionClauseValue as ::treesitter_types::FromNode>::from_node(child, src)
3078 })?
3079 },
3080 })
3081 }
3082}
3083impl ::treesitter_types::Spanned for ConditionClause<'_> {
3084 fn span(&self) -> ::treesitter_types::Span {
3085 self.span
3086 }
3087}
3088#[derive(Debug, Clone, PartialEq, Eq)]
3089pub struct ConditionalExpression<'tree> {
3090 pub span: ::treesitter_types::Span,
3091 pub alternative: Expression<'tree>,
3092 pub condition: Expression<'tree>,
3093 pub consequence: ::core::option::Option<ConditionalExpressionConsequence<'tree>>,
3094}
3095impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
3096 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3097 fn from_node(
3098 node: ::treesitter_types::tree_sitter::Node<'tree>,
3099 src: &'tree [u8],
3100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3101 debug_assert_eq!(node.kind(), "conditional_expression");
3102 Ok(Self {
3103 span: ::treesitter_types::Span::from(node),
3104 alternative: {
3105 let child = node.child_by_field_name("alternative").ok_or_else(|| {
3106 ::treesitter_types::ParseError::missing_field("alternative", node)
3107 })?;
3108 ::treesitter_types::runtime::maybe_grow_stack(|| {
3109 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3110 })?
3111 },
3112 condition: {
3113 let child = node.child_by_field_name("condition").ok_or_else(|| {
3114 ::treesitter_types::ParseError::missing_field("condition", node)
3115 })?;
3116 ::treesitter_types::runtime::maybe_grow_stack(|| {
3117 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3118 })?
3119 },
3120 consequence: match node.child_by_field_name("consequence") {
3121 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3122 <ConditionalExpressionConsequence as ::treesitter_types::FromNode>::from_node(
3123 child, src,
3124 )
3125 })?),
3126 None => None,
3127 },
3128 })
3129 }
3130}
3131impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
3132 fn span(&self) -> ::treesitter_types::Span {
3133 self.span
3134 }
3135}
3136#[derive(Debug, Clone, PartialEq, Eq)]
3137pub struct ConstraintConjunction<'tree> {
3138 pub span: ::treesitter_types::Span,
3139 pub left: ::std::vec::Vec<ConstraintConjunctionLeft<'tree>>,
3140 pub operator: ConstraintConjunctionOperator,
3141 pub right: ::std::vec::Vec<ConstraintConjunctionRight<'tree>>,
3142}
3143impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunction<'tree> {
3144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3145 fn from_node(
3146 node: ::treesitter_types::tree_sitter::Node<'tree>,
3147 src: &'tree [u8],
3148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3149 debug_assert_eq!(node.kind(), "constraint_conjunction");
3150 Ok(Self {
3151 span: ::treesitter_types::Span::from(node),
3152 left: {
3153 let mut cursor = node.walk();
3154 let mut items = ::std::vec::Vec::new();
3155 for child in node.children_by_field_name("left", &mut cursor) {
3156 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3157 <ConstraintConjunctionLeft as ::treesitter_types::FromNode>::from_node(
3158 child, src,
3159 )
3160 })?);
3161 }
3162 items
3163 },
3164 operator: {
3165 let child = node.child_by_field_name("operator").ok_or_else(|| {
3166 ::treesitter_types::ParseError::missing_field("operator", node)
3167 })?;
3168 ::treesitter_types::runtime::maybe_grow_stack(|| {
3169 <ConstraintConjunctionOperator as ::treesitter_types::FromNode>::from_node(
3170 child, src,
3171 )
3172 })?
3173 },
3174 right: {
3175 let mut cursor = node.walk();
3176 let mut items = ::std::vec::Vec::new();
3177 for child in node.children_by_field_name("right", &mut cursor) {
3178 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3179 <ConstraintConjunctionRight as ::treesitter_types::FromNode>::from_node(
3180 child, src,
3181 )
3182 })?);
3183 }
3184 items
3185 },
3186 })
3187 }
3188}
3189impl ::treesitter_types::Spanned for ConstraintConjunction<'_> {
3190 fn span(&self) -> ::treesitter_types::Span {
3191 self.span
3192 }
3193}
3194#[derive(Debug, Clone, PartialEq, Eq)]
3195pub struct ConstraintDisjunction<'tree> {
3196 pub span: ::treesitter_types::Span,
3197 pub left: ::std::vec::Vec<ConstraintDisjunctionLeft<'tree>>,
3198 pub operator: ConstraintDisjunctionOperator,
3199 pub right: ::std::vec::Vec<ConstraintDisjunctionRight<'tree>>,
3200}
3201impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunction<'tree> {
3202 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3203 fn from_node(
3204 node: ::treesitter_types::tree_sitter::Node<'tree>,
3205 src: &'tree [u8],
3206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3207 debug_assert_eq!(node.kind(), "constraint_disjunction");
3208 Ok(Self {
3209 span: ::treesitter_types::Span::from(node),
3210 left: {
3211 let mut cursor = node.walk();
3212 let mut items = ::std::vec::Vec::new();
3213 for child in node.children_by_field_name("left", &mut cursor) {
3214 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3215 <ConstraintDisjunctionLeft as ::treesitter_types::FromNode>::from_node(
3216 child, src,
3217 )
3218 })?);
3219 }
3220 items
3221 },
3222 operator: {
3223 let child = node.child_by_field_name("operator").ok_or_else(|| {
3224 ::treesitter_types::ParseError::missing_field("operator", node)
3225 })?;
3226 ::treesitter_types::runtime::maybe_grow_stack(|| {
3227 <ConstraintDisjunctionOperator as ::treesitter_types::FromNode>::from_node(
3228 child, src,
3229 )
3230 })?
3231 },
3232 right: {
3233 let mut cursor = node.walk();
3234 let mut items = ::std::vec::Vec::new();
3235 for child in node.children_by_field_name("right", &mut cursor) {
3236 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3237 <ConstraintDisjunctionRight as ::treesitter_types::FromNode>::from_node(
3238 child, src,
3239 )
3240 })?);
3241 }
3242 items
3243 },
3244 })
3245 }
3246}
3247impl ::treesitter_types::Spanned for ConstraintDisjunction<'_> {
3248 fn span(&self) -> ::treesitter_types::Span {
3249 self.span
3250 }
3251}
3252#[derive(Debug, Clone, PartialEq, Eq)]
3253pub struct ContinueStatement<'tree> {
3254 pub span: ::treesitter_types::Span,
3255 text: &'tree str,
3256}
3257impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
3258 fn from_node(
3259 node: ::treesitter_types::tree_sitter::Node<'tree>,
3260 src: &'tree [u8],
3261 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3262 debug_assert_eq!(node.kind(), "continue_statement");
3263 Ok(Self {
3264 span: ::treesitter_types::Span::from(node),
3265 text: node.utf8_text(src)?,
3266 })
3267 }
3268}
3269impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
3270 fn text(&self) -> &'tree str {
3271 self.text
3272 }
3273}
3274impl ::treesitter_types::Spanned for ContinueStatement<'_> {
3275 fn span(&self) -> ::treesitter_types::Span {
3276 self.span
3277 }
3278}
3279#[derive(Debug, Clone, PartialEq, Eq)]
3280pub struct Declaration<'tree> {
3281 pub span: ::treesitter_types::Span,
3282 pub declarator: ::std::vec::Vec<DeclarationDeclarator<'tree>>,
3283 pub default_value: ::core::option::Option<Expression<'tree>>,
3284 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
3285 pub value: ::core::option::Option<DeclarationValue<'tree>>,
3286 pub children: ::std::vec::Vec<DeclarationChildren<'tree>>,
3287}
3288impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
3289 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3290 fn from_node(
3291 node: ::treesitter_types::tree_sitter::Node<'tree>,
3292 src: &'tree [u8],
3293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3294 debug_assert_eq!(node.kind(), "declaration");
3295 Ok(Self {
3296 span: ::treesitter_types::Span::from(node),
3297 declarator: {
3298 let mut cursor = node.walk();
3299 let mut items = ::std::vec::Vec::new();
3300 for child in node.children_by_field_name("declarator", &mut cursor) {
3301 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3302 <DeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
3303 child, src,
3304 )
3305 })?);
3306 }
3307 items
3308 },
3309 default_value: match node.child_by_field_name("default_value") {
3310 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3311 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3312 })?),
3313 None => None,
3314 },
3315 r#type: match node.child_by_field_name("type") {
3316 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3317 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
3318 })?),
3319 None => None,
3320 },
3321 value: match node.child_by_field_name("value") {
3322 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3323 <DeclarationValue as ::treesitter_types::FromNode>::from_node(child, src)
3324 })?),
3325 None => None,
3326 },
3327 children: {
3328 #[allow(clippy::suspicious_else_formatting)]
3329 let non_field_children = {
3330 let mut cursor = node.walk();
3331 let mut result = ::std::vec::Vec::new();
3332 if cursor.goto_first_child() {
3333 loop {
3334 if cursor.field_name().is_none()
3335 && cursor.node().is_named()
3336 && !cursor.node().is_extra()
3337 {
3338 result.push(cursor.node());
3339 }
3340 if !cursor.goto_next_sibling() {
3341 break;
3342 }
3343 }
3344 }
3345 result
3346 };
3347 let mut items = ::std::vec::Vec::new();
3348 for child in non_field_children {
3349 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3350 <DeclarationChildren as ::treesitter_types::FromNode>::from_node(child, src)
3351 })?);
3352 }
3353 items
3354 },
3355 })
3356 }
3357}
3358impl ::treesitter_types::Spanned for Declaration<'_> {
3359 fn span(&self) -> ::treesitter_types::Span {
3360 self.span
3361 }
3362}
3363#[derive(Debug, Clone, PartialEq, Eq)]
3364pub struct DeclarationList<'tree> {
3365 pub span: ::treesitter_types::Span,
3366 pub children: ::std::vec::Vec<DeclarationListChildren<'tree>>,
3367}
3368impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
3369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3370 fn from_node(
3371 node: ::treesitter_types::tree_sitter::Node<'tree>,
3372 src: &'tree [u8],
3373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3374 debug_assert_eq!(node.kind(), "declaration_list");
3375 Ok(Self {
3376 span: ::treesitter_types::Span::from(node),
3377 children: {
3378 #[allow(clippy::suspicious_else_formatting)]
3379 let non_field_children = {
3380 let mut cursor = node.walk();
3381 let mut result = ::std::vec::Vec::new();
3382 if cursor.goto_first_child() {
3383 loop {
3384 if cursor.field_name().is_none()
3385 && cursor.node().is_named()
3386 && !cursor.node().is_extra()
3387 {
3388 result.push(cursor.node());
3389 }
3390 if !cursor.goto_next_sibling() {
3391 break;
3392 }
3393 }
3394 }
3395 result
3396 };
3397 let mut items = ::std::vec::Vec::new();
3398 for child in non_field_children {
3399 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3400 <DeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3401 child, src,
3402 )
3403 })?);
3404 }
3405 items
3406 },
3407 })
3408 }
3409}
3410impl ::treesitter_types::Spanned for DeclarationList<'_> {
3411 fn span(&self) -> ::treesitter_types::Span {
3412 self.span
3413 }
3414}
3415#[derive(Debug, Clone, PartialEq, Eq)]
3416pub struct Decltype<'tree> {
3417 pub span: ::treesitter_types::Span,
3418 pub children: DecltypeChildren<'tree>,
3419}
3420impl<'tree> ::treesitter_types::FromNode<'tree> for Decltype<'tree> {
3421 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3422 fn from_node(
3423 node: ::treesitter_types::tree_sitter::Node<'tree>,
3424 src: &'tree [u8],
3425 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3426 debug_assert_eq!(node.kind(), "decltype");
3427 Ok(Self {
3428 span: ::treesitter_types::Span::from(node),
3429 children: {
3430 #[allow(clippy::suspicious_else_formatting)]
3431 let non_field_children = {
3432 let mut cursor = node.walk();
3433 let mut result = ::std::vec::Vec::new();
3434 if cursor.goto_first_child() {
3435 loop {
3436 if cursor.field_name().is_none()
3437 && cursor.node().is_named()
3438 && !cursor.node().is_extra()
3439 {
3440 result.push(cursor.node());
3441 }
3442 if !cursor.goto_next_sibling() {
3443 break;
3444 }
3445 }
3446 }
3447 result
3448 };
3449 let child = if let Some(&c) = non_field_children.first() {
3450 c
3451 } else {
3452 let mut fallback_cursor = node.walk();
3453 let mut fallback_child = None;
3454 if fallback_cursor.goto_first_child() {
3455 loop {
3456 if fallback_cursor.field_name().is_none()
3457 && !fallback_cursor.node().is_extra()
3458 {
3459 let candidate = fallback_cursor.node();
3460 #[allow(clippy::needless_question_mark)]
3461 if (|| -> ::core::result::Result<
3462 _,
3463 ::treesitter_types::ParseError,
3464 > {
3465 let child = candidate;
3466 Ok(
3467 ::treesitter_types::runtime::maybe_grow_stack(|| <DecltypeChildren as ::treesitter_types::FromNode>::from_node(
3468 child,
3469 src,
3470 ))?,
3471 )
3472 })()
3473 .is_ok()
3474 {
3475 fallback_child = Some(candidate);
3476 break;
3477 }
3478 }
3479 if !fallback_cursor.goto_next_sibling() {
3480 break;
3481 }
3482 }
3483 }
3484 if fallback_child.is_none() {
3485 let mut cursor2 = node.walk();
3486 if cursor2.goto_first_child() {
3487 loop {
3488 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3489 let candidate = cursor2.node();
3490 #[allow(clippy::needless_question_mark)]
3491 if (|| -> ::core::result::Result<
3492 _,
3493 ::treesitter_types::ParseError,
3494 > {
3495 let child = candidate;
3496 Ok(
3497 ::treesitter_types::runtime::maybe_grow_stack(|| <DecltypeChildren as ::treesitter_types::FromNode>::from_node(
3498 child,
3499 src,
3500 ))?,
3501 )
3502 })()
3503 .is_ok()
3504 {
3505 fallback_child = Some(candidate);
3506 break;
3507 }
3508 }
3509 if !cursor2.goto_next_sibling() {
3510 break;
3511 }
3512 }
3513 }
3514 }
3515 fallback_child.ok_or_else(|| {
3516 ::treesitter_types::ParseError::missing_field("children", node)
3517 })?
3518 };
3519 ::treesitter_types::runtime::maybe_grow_stack(|| {
3520 <DecltypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
3521 })?
3522 },
3523 })
3524 }
3525}
3526impl ::treesitter_types::Spanned for Decltype<'_> {
3527 fn span(&self) -> ::treesitter_types::Span {
3528 self.span
3529 }
3530}
3531#[derive(Debug, Clone, PartialEq, Eq)]
3532pub struct DefaultMethodClause<'tree> {
3533 pub span: ::treesitter_types::Span,
3534 text: &'tree str,
3535}
3536impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultMethodClause<'tree> {
3537 fn from_node(
3538 node: ::treesitter_types::tree_sitter::Node<'tree>,
3539 src: &'tree [u8],
3540 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3541 debug_assert_eq!(node.kind(), "default_method_clause");
3542 Ok(Self {
3543 span: ::treesitter_types::Span::from(node),
3544 text: node.utf8_text(src)?,
3545 })
3546 }
3547}
3548impl<'tree> ::treesitter_types::LeafNode<'tree> for DefaultMethodClause<'tree> {
3549 fn text(&self) -> &'tree str {
3550 self.text
3551 }
3552}
3553impl ::treesitter_types::Spanned for DefaultMethodClause<'_> {
3554 fn span(&self) -> ::treesitter_types::Span {
3555 self.span
3556 }
3557}
3558#[derive(Debug, Clone, PartialEq, Eq)]
3559pub struct DeleteExpression<'tree> {
3560 pub span: ::treesitter_types::Span,
3561 pub children: Expression<'tree>,
3562}
3563impl<'tree> ::treesitter_types::FromNode<'tree> for DeleteExpression<'tree> {
3564 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3565 fn from_node(
3566 node: ::treesitter_types::tree_sitter::Node<'tree>,
3567 src: &'tree [u8],
3568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3569 debug_assert_eq!(node.kind(), "delete_expression");
3570 Ok(Self {
3571 span: ::treesitter_types::Span::from(node),
3572 children: {
3573 #[allow(clippy::suspicious_else_formatting)]
3574 let non_field_children = {
3575 let mut cursor = node.walk();
3576 let mut result = ::std::vec::Vec::new();
3577 if cursor.goto_first_child() {
3578 loop {
3579 if cursor.field_name().is_none()
3580 && cursor.node().is_named()
3581 && !cursor.node().is_extra()
3582 {
3583 result.push(cursor.node());
3584 }
3585 if !cursor.goto_next_sibling() {
3586 break;
3587 }
3588 }
3589 }
3590 result
3591 };
3592 let child = if let Some(&c) = non_field_children.first() {
3593 c
3594 } else {
3595 let mut fallback_cursor = node.walk();
3596 let mut fallback_child = None;
3597 if fallback_cursor.goto_first_child() {
3598 loop {
3599 if fallback_cursor.field_name().is_none()
3600 && !fallback_cursor.node().is_extra()
3601 {
3602 let candidate = fallback_cursor.node();
3603 #[allow(clippy::needless_question_mark)]
3604 if (|| -> ::core::result::Result<
3605 _,
3606 ::treesitter_types::ParseError,
3607 > {
3608 let child = candidate;
3609 Ok(
3610 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3611 child,
3612 src,
3613 ))?,
3614 )
3615 })()
3616 .is_ok()
3617 {
3618 fallback_child = Some(candidate);
3619 break;
3620 }
3621 }
3622 if !fallback_cursor.goto_next_sibling() {
3623 break;
3624 }
3625 }
3626 }
3627 if fallback_child.is_none() {
3628 let mut cursor2 = node.walk();
3629 if cursor2.goto_first_child() {
3630 loop {
3631 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3632 let candidate = cursor2.node();
3633 #[allow(clippy::needless_question_mark)]
3634 if (|| -> ::core::result::Result<
3635 _,
3636 ::treesitter_types::ParseError,
3637 > {
3638 let child = candidate;
3639 Ok(
3640 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3641 child,
3642 src,
3643 ))?,
3644 )
3645 })()
3646 .is_ok()
3647 {
3648 fallback_child = Some(candidate);
3649 break;
3650 }
3651 }
3652 if !cursor2.goto_next_sibling() {
3653 break;
3654 }
3655 }
3656 }
3657 }
3658 fallback_child.ok_or_else(|| {
3659 ::treesitter_types::ParseError::missing_field("children", node)
3660 })?
3661 };
3662 ::treesitter_types::runtime::maybe_grow_stack(|| {
3663 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3664 })?
3665 },
3666 })
3667 }
3668}
3669impl ::treesitter_types::Spanned for DeleteExpression<'_> {
3670 fn span(&self) -> ::treesitter_types::Span {
3671 self.span
3672 }
3673}
3674#[derive(Debug, Clone, PartialEq, Eq)]
3675pub struct DeleteMethodClause<'tree> {
3676 pub span: ::treesitter_types::Span,
3677 text: &'tree str,
3678}
3679impl<'tree> ::treesitter_types::FromNode<'tree> for DeleteMethodClause<'tree> {
3680 fn from_node(
3681 node: ::treesitter_types::tree_sitter::Node<'tree>,
3682 src: &'tree [u8],
3683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3684 debug_assert_eq!(node.kind(), "delete_method_clause");
3685 Ok(Self {
3686 span: ::treesitter_types::Span::from(node),
3687 text: node.utf8_text(src)?,
3688 })
3689 }
3690}
3691impl<'tree> ::treesitter_types::LeafNode<'tree> for DeleteMethodClause<'tree> {
3692 fn text(&self) -> &'tree str {
3693 self.text
3694 }
3695}
3696impl ::treesitter_types::Spanned for DeleteMethodClause<'_> {
3697 fn span(&self) -> ::treesitter_types::Span {
3698 self.span
3699 }
3700}
3701#[derive(Debug, Clone, PartialEq, Eq)]
3702pub struct DependentName<'tree> {
3703 pub span: ::treesitter_types::Span,
3704 pub children: DependentNameChildren<'tree>,
3705}
3706impl<'tree> ::treesitter_types::FromNode<'tree> for DependentName<'tree> {
3707 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3708 fn from_node(
3709 node: ::treesitter_types::tree_sitter::Node<'tree>,
3710 src: &'tree [u8],
3711 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3712 debug_assert_eq!(node.kind(), "dependent_name");
3713 Ok(Self {
3714 span: ::treesitter_types::Span::from(node),
3715 children: {
3716 #[allow(clippy::suspicious_else_formatting)]
3717 let non_field_children = {
3718 let mut cursor = node.walk();
3719 let mut result = ::std::vec::Vec::new();
3720 if cursor.goto_first_child() {
3721 loop {
3722 if cursor.field_name().is_none()
3723 && cursor.node().is_named()
3724 && !cursor.node().is_extra()
3725 {
3726 result.push(cursor.node());
3727 }
3728 if !cursor.goto_next_sibling() {
3729 break;
3730 }
3731 }
3732 }
3733 result
3734 };
3735 let child = if let Some(&c) = non_field_children.first() {
3736 c
3737 } else {
3738 let mut fallback_cursor = node.walk();
3739 let mut fallback_child = None;
3740 if fallback_cursor.goto_first_child() {
3741 loop {
3742 if fallback_cursor.field_name().is_none()
3743 && !fallback_cursor.node().is_extra()
3744 {
3745 let candidate = fallback_cursor.node();
3746 #[allow(clippy::needless_question_mark)]
3747 if (|| -> ::core::result::Result<
3748 _,
3749 ::treesitter_types::ParseError,
3750 > {
3751 let child = candidate;
3752 Ok(
3753 ::treesitter_types::runtime::maybe_grow_stack(|| <DependentNameChildren as ::treesitter_types::FromNode>::from_node(
3754 child,
3755 src,
3756 ))?,
3757 )
3758 })()
3759 .is_ok()
3760 {
3761 fallback_child = Some(candidate);
3762 break;
3763 }
3764 }
3765 if !fallback_cursor.goto_next_sibling() {
3766 break;
3767 }
3768 }
3769 }
3770 if fallback_child.is_none() {
3771 let mut cursor2 = node.walk();
3772 if cursor2.goto_first_child() {
3773 loop {
3774 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3775 let candidate = cursor2.node();
3776 #[allow(clippy::needless_question_mark)]
3777 if (|| -> ::core::result::Result<
3778 _,
3779 ::treesitter_types::ParseError,
3780 > {
3781 let child = candidate;
3782 Ok(
3783 ::treesitter_types::runtime::maybe_grow_stack(|| <DependentNameChildren as ::treesitter_types::FromNode>::from_node(
3784 child,
3785 src,
3786 ))?,
3787 )
3788 })()
3789 .is_ok()
3790 {
3791 fallback_child = Some(candidate);
3792 break;
3793 }
3794 }
3795 if !cursor2.goto_next_sibling() {
3796 break;
3797 }
3798 }
3799 }
3800 }
3801 fallback_child.ok_or_else(|| {
3802 ::treesitter_types::ParseError::missing_field("children", node)
3803 })?
3804 };
3805 ::treesitter_types::runtime::maybe_grow_stack(|| {
3806 <DependentNameChildren as ::treesitter_types::FromNode>::from_node(child, src)
3807 })?
3808 },
3809 })
3810 }
3811}
3812impl ::treesitter_types::Spanned for DependentName<'_> {
3813 fn span(&self) -> ::treesitter_types::Span {
3814 self.span
3815 }
3816}
3817#[derive(Debug, Clone, PartialEq, Eq)]
3818pub struct DependentType<'tree> {
3819 pub span: ::treesitter_types::Span,
3820 pub children: TypeSpecifier<'tree>,
3821}
3822impl<'tree> ::treesitter_types::FromNode<'tree> for DependentType<'tree> {
3823 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3824 fn from_node(
3825 node: ::treesitter_types::tree_sitter::Node<'tree>,
3826 src: &'tree [u8],
3827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3828 debug_assert_eq!(node.kind(), "dependent_type");
3829 Ok(Self {
3830 span: ::treesitter_types::Span::from(node),
3831 children: {
3832 #[allow(clippy::suspicious_else_formatting)]
3833 let non_field_children = {
3834 let mut cursor = node.walk();
3835 let mut result = ::std::vec::Vec::new();
3836 if cursor.goto_first_child() {
3837 loop {
3838 if cursor.field_name().is_none()
3839 && cursor.node().is_named()
3840 && !cursor.node().is_extra()
3841 {
3842 result.push(cursor.node());
3843 }
3844 if !cursor.goto_next_sibling() {
3845 break;
3846 }
3847 }
3848 }
3849 result
3850 };
3851 let child = if let Some(&c) = non_field_children.first() {
3852 c
3853 } else {
3854 let mut fallback_cursor = node.walk();
3855 let mut fallback_child = None;
3856 if fallback_cursor.goto_first_child() {
3857 loop {
3858 if fallback_cursor.field_name().is_none()
3859 && !fallback_cursor.node().is_extra()
3860 {
3861 let candidate = fallback_cursor.node();
3862 #[allow(clippy::needless_question_mark)]
3863 if (|| -> ::core::result::Result<
3864 _,
3865 ::treesitter_types::ParseError,
3866 > {
3867 let child = candidate;
3868 Ok(
3869 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeSpecifier as ::treesitter_types::FromNode>::from_node(
3870 child,
3871 src,
3872 ))?,
3873 )
3874 })()
3875 .is_ok()
3876 {
3877 fallback_child = Some(candidate);
3878 break;
3879 }
3880 }
3881 if !fallback_cursor.goto_next_sibling() {
3882 break;
3883 }
3884 }
3885 }
3886 if fallback_child.is_none() {
3887 let mut cursor2 = node.walk();
3888 if cursor2.goto_first_child() {
3889 loop {
3890 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3891 let candidate = cursor2.node();
3892 #[allow(clippy::needless_question_mark)]
3893 if (|| -> ::core::result::Result<
3894 _,
3895 ::treesitter_types::ParseError,
3896 > {
3897 let child = candidate;
3898 Ok(
3899 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeSpecifier as ::treesitter_types::FromNode>::from_node(
3900 child,
3901 src,
3902 ))?,
3903 )
3904 })()
3905 .is_ok()
3906 {
3907 fallback_child = Some(candidate);
3908 break;
3909 }
3910 }
3911 if !cursor2.goto_next_sibling() {
3912 break;
3913 }
3914 }
3915 }
3916 }
3917 fallback_child.ok_or_else(|| {
3918 ::treesitter_types::ParseError::missing_field("children", node)
3919 })?
3920 };
3921 ::treesitter_types::runtime::maybe_grow_stack(|| {
3922 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
3923 })?
3924 },
3925 })
3926 }
3927}
3928impl ::treesitter_types::Spanned for DependentType<'_> {
3929 fn span(&self) -> ::treesitter_types::Span {
3930 self.span
3931 }
3932}
3933#[derive(Debug, Clone, PartialEq, Eq)]
3934pub struct DestructorName<'tree> {
3935 pub span: ::treesitter_types::Span,
3936 pub children: Identifier<'tree>,
3937}
3938impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorName<'tree> {
3939 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3940 fn from_node(
3941 node: ::treesitter_types::tree_sitter::Node<'tree>,
3942 src: &'tree [u8],
3943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3944 debug_assert_eq!(node.kind(), "destructor_name");
3945 Ok(Self {
3946 span: ::treesitter_types::Span::from(node),
3947 children: {
3948 #[allow(clippy::suspicious_else_formatting)]
3949 let non_field_children = {
3950 let mut cursor = node.walk();
3951 let mut result = ::std::vec::Vec::new();
3952 if cursor.goto_first_child() {
3953 loop {
3954 if cursor.field_name().is_none()
3955 && cursor.node().is_named()
3956 && !cursor.node().is_extra()
3957 {
3958 result.push(cursor.node());
3959 }
3960 if !cursor.goto_next_sibling() {
3961 break;
3962 }
3963 }
3964 }
3965 result
3966 };
3967 let child = if let Some(&c) = non_field_children.first() {
3968 c
3969 } else {
3970 let mut fallback_cursor = node.walk();
3971 let mut fallback_child = None;
3972 if fallback_cursor.goto_first_child() {
3973 loop {
3974 if fallback_cursor.field_name().is_none()
3975 && !fallback_cursor.node().is_extra()
3976 {
3977 let candidate = fallback_cursor.node();
3978 #[allow(clippy::needless_question_mark)]
3979 if (|| -> ::core::result::Result<
3980 _,
3981 ::treesitter_types::ParseError,
3982 > {
3983 let child = candidate;
3984 Ok(
3985 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
3986 child,
3987 src,
3988 ))?,
3989 )
3990 })()
3991 .is_ok()
3992 {
3993 fallback_child = Some(candidate);
3994 break;
3995 }
3996 }
3997 if !fallback_cursor.goto_next_sibling() {
3998 break;
3999 }
4000 }
4001 }
4002 if fallback_child.is_none() {
4003 let mut cursor2 = node.walk();
4004 if cursor2.goto_first_child() {
4005 loop {
4006 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4007 let candidate = cursor2.node();
4008 #[allow(clippy::needless_question_mark)]
4009 if (|| -> ::core::result::Result<
4010 _,
4011 ::treesitter_types::ParseError,
4012 > {
4013 let child = candidate;
4014 Ok(
4015 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
4016 child,
4017 src,
4018 ))?,
4019 )
4020 })()
4021 .is_ok()
4022 {
4023 fallback_child = Some(candidate);
4024 break;
4025 }
4026 }
4027 if !cursor2.goto_next_sibling() {
4028 break;
4029 }
4030 }
4031 }
4032 }
4033 fallback_child.ok_or_else(|| {
4034 ::treesitter_types::ParseError::missing_field("children", node)
4035 })?
4036 };
4037 ::treesitter_types::runtime::maybe_grow_stack(|| {
4038 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4039 })?
4040 },
4041 })
4042 }
4043}
4044impl ::treesitter_types::Spanned for DestructorName<'_> {
4045 fn span(&self) -> ::treesitter_types::Span {
4046 self.span
4047 }
4048}
4049#[derive(Debug, Clone, PartialEq, Eq)]
4050pub struct DoStatement<'tree> {
4051 pub span: ::treesitter_types::Span,
4052 pub body: Statement<'tree>,
4053 pub condition: ParenthesizedExpression<'tree>,
4054}
4055impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
4056 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4057 fn from_node(
4058 node: ::treesitter_types::tree_sitter::Node<'tree>,
4059 src: &'tree [u8],
4060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4061 debug_assert_eq!(node.kind(), "do_statement");
4062 Ok(Self {
4063 span: ::treesitter_types::Span::from(node),
4064 body: {
4065 let child = node
4066 .child_by_field_name("body")
4067 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4068 ::treesitter_types::runtime::maybe_grow_stack(|| {
4069 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4070 })?
4071 },
4072 condition: {
4073 let child = node.child_by_field_name("condition").ok_or_else(|| {
4074 ::treesitter_types::ParseError::missing_field("condition", node)
4075 })?;
4076 ::treesitter_types::runtime::maybe_grow_stack(|| {
4077 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
4078 })?
4079 },
4080 })
4081 }
4082}
4083impl ::treesitter_types::Spanned for DoStatement<'_> {
4084 fn span(&self) -> ::treesitter_types::Span {
4085 self.span
4086 }
4087}
4088#[derive(Debug, Clone, PartialEq, Eq)]
4089pub struct ElseClause<'tree> {
4090 pub span: ::treesitter_types::Span,
4091 pub children: Statement<'tree>,
4092}
4093impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
4094 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4095 fn from_node(
4096 node: ::treesitter_types::tree_sitter::Node<'tree>,
4097 src: &'tree [u8],
4098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4099 debug_assert_eq!(node.kind(), "else_clause");
4100 Ok(Self {
4101 span: ::treesitter_types::Span::from(node),
4102 children: {
4103 #[allow(clippy::suspicious_else_formatting)]
4104 let non_field_children = {
4105 let mut cursor = node.walk();
4106 let mut result = ::std::vec::Vec::new();
4107 if cursor.goto_first_child() {
4108 loop {
4109 if cursor.field_name().is_none()
4110 && cursor.node().is_named()
4111 && !cursor.node().is_extra()
4112 {
4113 result.push(cursor.node());
4114 }
4115 if !cursor.goto_next_sibling() {
4116 break;
4117 }
4118 }
4119 }
4120 result
4121 };
4122 let child = if let Some(&c) = non_field_children.first() {
4123 c
4124 } else {
4125 let mut fallback_cursor = node.walk();
4126 let mut fallback_child = None;
4127 if fallback_cursor.goto_first_child() {
4128 loop {
4129 if fallback_cursor.field_name().is_none()
4130 && !fallback_cursor.node().is_extra()
4131 {
4132 let candidate = fallback_cursor.node();
4133 #[allow(clippy::needless_question_mark)]
4134 if (|| -> ::core::result::Result<
4135 _,
4136 ::treesitter_types::ParseError,
4137 > {
4138 let child = candidate;
4139 Ok(
4140 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
4141 child,
4142 src,
4143 ))?,
4144 )
4145 })()
4146 .is_ok()
4147 {
4148 fallback_child = Some(candidate);
4149 break;
4150 }
4151 }
4152 if !fallback_cursor.goto_next_sibling() {
4153 break;
4154 }
4155 }
4156 }
4157 if fallback_child.is_none() {
4158 let mut cursor2 = node.walk();
4159 if cursor2.goto_first_child() {
4160 loop {
4161 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4162 let candidate = cursor2.node();
4163 #[allow(clippy::needless_question_mark)]
4164 if (|| -> ::core::result::Result<
4165 _,
4166 ::treesitter_types::ParseError,
4167 > {
4168 let child = candidate;
4169 Ok(
4170 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
4171 child,
4172 src,
4173 ))?,
4174 )
4175 })()
4176 .is_ok()
4177 {
4178 fallback_child = Some(candidate);
4179 break;
4180 }
4181 }
4182 if !cursor2.goto_next_sibling() {
4183 break;
4184 }
4185 }
4186 }
4187 }
4188 fallback_child.ok_or_else(|| {
4189 ::treesitter_types::ParseError::missing_field("children", node)
4190 })?
4191 };
4192 ::treesitter_types::runtime::maybe_grow_stack(|| {
4193 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
4194 })?
4195 },
4196 })
4197 }
4198}
4199impl ::treesitter_types::Spanned for ElseClause<'_> {
4200 fn span(&self) -> ::treesitter_types::Span {
4201 self.span
4202 }
4203}
4204#[derive(Debug, Clone, PartialEq, Eq)]
4205pub struct EnumSpecifier<'tree> {
4206 pub span: ::treesitter_types::Span,
4207 pub base: ::core::option::Option<EnumSpecifierBase<'tree>>,
4208 pub body: ::core::option::Option<EnumeratorList<'tree>>,
4209 pub name: ::core::option::Option<EnumSpecifierName<'tree>>,
4210 pub children: ::core::option::Option<AttributeSpecifier<'tree>>,
4211}
4212impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifier<'tree> {
4213 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4214 fn from_node(
4215 node: ::treesitter_types::tree_sitter::Node<'tree>,
4216 src: &'tree [u8],
4217 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4218 debug_assert_eq!(node.kind(), "enum_specifier");
4219 Ok(Self {
4220 span: ::treesitter_types::Span::from(node),
4221 base: match node.child_by_field_name("base") {
4222 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4223 <EnumSpecifierBase as ::treesitter_types::FromNode>::from_node(child, src)
4224 })?),
4225 None => None,
4226 },
4227 body: match node.child_by_field_name("body") {
4228 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4229 <EnumeratorList as ::treesitter_types::FromNode>::from_node(child, src)
4230 })?),
4231 None => None,
4232 },
4233 name: match node.child_by_field_name("name") {
4234 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4235 <EnumSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
4236 })?),
4237 None => None,
4238 },
4239 children: {
4240 #[allow(clippy::suspicious_else_formatting)]
4241 let non_field_children = {
4242 let mut cursor = node.walk();
4243 let mut result = ::std::vec::Vec::new();
4244 if cursor.goto_first_child() {
4245 loop {
4246 if cursor.field_name().is_none()
4247 && cursor.node().is_named()
4248 && !cursor.node().is_extra()
4249 {
4250 result.push(cursor.node());
4251 }
4252 if !cursor.goto_next_sibling() {
4253 break;
4254 }
4255 }
4256 }
4257 result
4258 };
4259 match non_field_children.first() {
4260 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4261 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
4262 })?),
4263 None => None,
4264 }
4265 },
4266 })
4267 }
4268}
4269impl ::treesitter_types::Spanned for EnumSpecifier<'_> {
4270 fn span(&self) -> ::treesitter_types::Span {
4271 self.span
4272 }
4273}
4274#[derive(Debug, Clone, PartialEq, Eq)]
4275pub struct Enumerator<'tree> {
4276 pub span: ::treesitter_types::Span,
4277 pub name: Identifier<'tree>,
4278 pub value: ::core::option::Option<Expression<'tree>>,
4279}
4280impl<'tree> ::treesitter_types::FromNode<'tree> for Enumerator<'tree> {
4281 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4282 fn from_node(
4283 node: ::treesitter_types::tree_sitter::Node<'tree>,
4284 src: &'tree [u8],
4285 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4286 debug_assert_eq!(node.kind(), "enumerator");
4287 Ok(Self {
4288 span: ::treesitter_types::Span::from(node),
4289 name: {
4290 let child = node
4291 .child_by_field_name("name")
4292 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4293 ::treesitter_types::runtime::maybe_grow_stack(|| {
4294 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
4295 })?
4296 },
4297 value: match node.child_by_field_name("value") {
4298 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4299 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4300 })?),
4301 None => None,
4302 },
4303 })
4304 }
4305}
4306impl ::treesitter_types::Spanned for Enumerator<'_> {
4307 fn span(&self) -> ::treesitter_types::Span {
4308 self.span
4309 }
4310}
4311#[derive(Debug, Clone, PartialEq, Eq)]
4312pub struct EnumeratorList<'tree> {
4313 pub span: ::treesitter_types::Span,
4314 pub children: ::std::vec::Vec<EnumeratorListChildren<'tree>>,
4315}
4316impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorList<'tree> {
4317 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4318 fn from_node(
4319 node: ::treesitter_types::tree_sitter::Node<'tree>,
4320 src: &'tree [u8],
4321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4322 debug_assert_eq!(node.kind(), "enumerator_list");
4323 Ok(Self {
4324 span: ::treesitter_types::Span::from(node),
4325 children: {
4326 #[allow(clippy::suspicious_else_formatting)]
4327 let non_field_children = {
4328 let mut cursor = node.walk();
4329 let mut result = ::std::vec::Vec::new();
4330 if cursor.goto_first_child() {
4331 loop {
4332 if cursor.field_name().is_none()
4333 && cursor.node().is_named()
4334 && !cursor.node().is_extra()
4335 {
4336 result.push(cursor.node());
4337 }
4338 if !cursor.goto_next_sibling() {
4339 break;
4340 }
4341 }
4342 }
4343 result
4344 };
4345 let mut items = ::std::vec::Vec::new();
4346 for child in non_field_children {
4347 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4348 <EnumeratorListChildren as ::treesitter_types::FromNode>::from_node(
4349 child, src,
4350 )
4351 })?);
4352 }
4353 items
4354 },
4355 })
4356 }
4357}
4358impl ::treesitter_types::Spanned for EnumeratorList<'_> {
4359 fn span(&self) -> ::treesitter_types::Span {
4360 self.span
4361 }
4362}
4363#[derive(Debug, Clone, PartialEq, Eq)]
4364pub struct ExplicitFunctionSpecifier<'tree> {
4365 pub span: ::treesitter_types::Span,
4366 pub children: ::core::option::Option<Expression<'tree>>,
4367}
4368impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitFunctionSpecifier<'tree> {
4369 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4370 fn from_node(
4371 node: ::treesitter_types::tree_sitter::Node<'tree>,
4372 src: &'tree [u8],
4373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4374 debug_assert_eq!(node.kind(), "explicit_function_specifier");
4375 Ok(Self {
4376 span: ::treesitter_types::Span::from(node),
4377 children: {
4378 #[allow(clippy::suspicious_else_formatting)]
4379 let non_field_children = {
4380 let mut cursor = node.walk();
4381 let mut result = ::std::vec::Vec::new();
4382 if cursor.goto_first_child() {
4383 loop {
4384 if cursor.field_name().is_none()
4385 && cursor.node().is_named()
4386 && !cursor.node().is_extra()
4387 {
4388 result.push(cursor.node());
4389 }
4390 if !cursor.goto_next_sibling() {
4391 break;
4392 }
4393 }
4394 }
4395 result
4396 };
4397 match non_field_children.first() {
4398 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4399 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4400 })?),
4401 None => None,
4402 }
4403 },
4404 })
4405 }
4406}
4407impl ::treesitter_types::Spanned for ExplicitFunctionSpecifier<'_> {
4408 fn span(&self) -> ::treesitter_types::Span {
4409 self.span
4410 }
4411}
4412#[derive(Debug, Clone, PartialEq, Eq)]
4413pub struct ExpressionStatement<'tree> {
4414 pub span: ::treesitter_types::Span,
4415 pub children: ::core::option::Option<ExpressionStatementChildren<'tree>>,
4416}
4417impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
4418 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4419 fn from_node(
4420 node: ::treesitter_types::tree_sitter::Node<'tree>,
4421 src: &'tree [u8],
4422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4423 debug_assert_eq!(node.kind(), "expression_statement");
4424 Ok(Self {
4425 span: ::treesitter_types::Span::from(node),
4426 children: {
4427 #[allow(clippy::suspicious_else_formatting)]
4428 let non_field_children = {
4429 let mut cursor = node.walk();
4430 let mut result = ::std::vec::Vec::new();
4431 if cursor.goto_first_child() {
4432 loop {
4433 if cursor.field_name().is_none()
4434 && cursor.node().is_named()
4435 && !cursor.node().is_extra()
4436 {
4437 result.push(cursor.node());
4438 }
4439 if !cursor.goto_next_sibling() {
4440 break;
4441 }
4442 }
4443 }
4444 result
4445 };
4446 match non_field_children.first() {
4447 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4448 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
4449 child, src,
4450 )
4451 })?),
4452 None => None,
4453 }
4454 },
4455 })
4456 }
4457}
4458impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
4459 fn span(&self) -> ::treesitter_types::Span {
4460 self.span
4461 }
4462}
4463#[derive(Debug, Clone, PartialEq, Eq)]
4464pub struct ExtensionExpression<'tree> {
4465 pub span: ::treesitter_types::Span,
4466 pub children: Expression<'tree>,
4467}
4468impl<'tree> ::treesitter_types::FromNode<'tree> for ExtensionExpression<'tree> {
4469 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4470 fn from_node(
4471 node: ::treesitter_types::tree_sitter::Node<'tree>,
4472 src: &'tree [u8],
4473 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4474 debug_assert_eq!(node.kind(), "extension_expression");
4475 Ok(Self {
4476 span: ::treesitter_types::Span::from(node),
4477 children: {
4478 #[allow(clippy::suspicious_else_formatting)]
4479 let non_field_children = {
4480 let mut cursor = node.walk();
4481 let mut result = ::std::vec::Vec::new();
4482 if cursor.goto_first_child() {
4483 loop {
4484 if cursor.field_name().is_none()
4485 && cursor.node().is_named()
4486 && !cursor.node().is_extra()
4487 {
4488 result.push(cursor.node());
4489 }
4490 if !cursor.goto_next_sibling() {
4491 break;
4492 }
4493 }
4494 }
4495 result
4496 };
4497 let child = if let Some(&c) = non_field_children.first() {
4498 c
4499 } else {
4500 let mut fallback_cursor = node.walk();
4501 let mut fallback_child = None;
4502 if fallback_cursor.goto_first_child() {
4503 loop {
4504 if fallback_cursor.field_name().is_none()
4505 && !fallback_cursor.node().is_extra()
4506 {
4507 let candidate = fallback_cursor.node();
4508 #[allow(clippy::needless_question_mark)]
4509 if (|| -> ::core::result::Result<
4510 _,
4511 ::treesitter_types::ParseError,
4512 > {
4513 let child = candidate;
4514 Ok(
4515 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4516 child,
4517 src,
4518 ))?,
4519 )
4520 })()
4521 .is_ok()
4522 {
4523 fallback_child = Some(candidate);
4524 break;
4525 }
4526 }
4527 if !fallback_cursor.goto_next_sibling() {
4528 break;
4529 }
4530 }
4531 }
4532 if fallback_child.is_none() {
4533 let mut cursor2 = node.walk();
4534 if cursor2.goto_first_child() {
4535 loop {
4536 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4537 let candidate = cursor2.node();
4538 #[allow(clippy::needless_question_mark)]
4539 if (|| -> ::core::result::Result<
4540 _,
4541 ::treesitter_types::ParseError,
4542 > {
4543 let child = candidate;
4544 Ok(
4545 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4546 child,
4547 src,
4548 ))?,
4549 )
4550 })()
4551 .is_ok()
4552 {
4553 fallback_child = Some(candidate);
4554 break;
4555 }
4556 }
4557 if !cursor2.goto_next_sibling() {
4558 break;
4559 }
4560 }
4561 }
4562 }
4563 fallback_child.ok_or_else(|| {
4564 ::treesitter_types::ParseError::missing_field("children", node)
4565 })?
4566 };
4567 ::treesitter_types::runtime::maybe_grow_stack(|| {
4568 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4569 })?
4570 },
4571 })
4572 }
4573}
4574impl ::treesitter_types::Spanned for ExtensionExpression<'_> {
4575 fn span(&self) -> ::treesitter_types::Span {
4576 self.span
4577 }
4578}
4579#[derive(Debug, Clone, PartialEq, Eq)]
4580pub struct FieldDeclaration<'tree> {
4581 pub span: ::treesitter_types::Span,
4582 pub declarator: ::std::vec::Vec<FieldDeclarator<'tree>>,
4583 pub default_value: ::std::vec::Vec<FieldDeclarationDefaultValue<'tree>>,
4584 pub r#type: TypeSpecifier<'tree>,
4585 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
4586}
4587impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
4588 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4589 fn from_node(
4590 node: ::treesitter_types::tree_sitter::Node<'tree>,
4591 src: &'tree [u8],
4592 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4593 debug_assert_eq!(node.kind(), "field_declaration");
4594 Ok(Self {
4595 span: ::treesitter_types::Span::from(node),
4596 declarator: {
4597 let mut cursor = node.walk();
4598 let mut items = ::std::vec::Vec::new();
4599 for child in node.children_by_field_name("declarator", &mut cursor) {
4600 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4601 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
4602 })?);
4603 }
4604 items
4605 },
4606 default_value: {
4607 let mut cursor = node.walk();
4608 let mut items = ::std::vec::Vec::new();
4609 for child in node.children_by_field_name("default_value", &mut cursor) {
4610 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4611 <FieldDeclarationDefaultValue as ::treesitter_types::FromNode>::from_node(
4612 child, src,
4613 )
4614 })?);
4615 }
4616 items
4617 },
4618 r#type: {
4619 let child = node
4620 .child_by_field_name("type")
4621 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4622 ::treesitter_types::runtime::maybe_grow_stack(|| {
4623 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
4624 })?
4625 },
4626 children: {
4627 #[allow(clippy::suspicious_else_formatting)]
4628 let non_field_children = {
4629 let mut cursor = node.walk();
4630 let mut result = ::std::vec::Vec::new();
4631 if cursor.goto_first_child() {
4632 loop {
4633 if cursor.field_name().is_none()
4634 && cursor.node().is_named()
4635 && !cursor.node().is_extra()
4636 {
4637 result.push(cursor.node());
4638 }
4639 if !cursor.goto_next_sibling() {
4640 break;
4641 }
4642 }
4643 }
4644 result
4645 };
4646 let mut items = ::std::vec::Vec::new();
4647 for child in non_field_children {
4648 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4649 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4650 child, src,
4651 )
4652 })?);
4653 }
4654 items
4655 },
4656 })
4657 }
4658}
4659impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
4660 fn span(&self) -> ::treesitter_types::Span {
4661 self.span
4662 }
4663}
4664#[derive(Debug, Clone, PartialEq, Eq)]
4665pub struct FieldDeclarationList<'tree> {
4666 pub span: ::treesitter_types::Span,
4667 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
4668}
4669impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
4670 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4671 fn from_node(
4672 node: ::treesitter_types::tree_sitter::Node<'tree>,
4673 src: &'tree [u8],
4674 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4675 debug_assert_eq!(node.kind(), "field_declaration_list");
4676 Ok(Self {
4677 span: ::treesitter_types::Span::from(node),
4678 children: {
4679 #[allow(clippy::suspicious_else_formatting)]
4680 let non_field_children = {
4681 let mut cursor = node.walk();
4682 let mut result = ::std::vec::Vec::new();
4683 if cursor.goto_first_child() {
4684 loop {
4685 if cursor.field_name().is_none()
4686 && cursor.node().is_named()
4687 && !cursor.node().is_extra()
4688 {
4689 result.push(cursor.node());
4690 }
4691 if !cursor.goto_next_sibling() {
4692 break;
4693 }
4694 }
4695 }
4696 result
4697 };
4698 let mut items = ::std::vec::Vec::new();
4699 for child in non_field_children {
4700 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4701 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
4702 child, src,
4703 )
4704 })?);
4705 }
4706 items
4707 },
4708 })
4709 }
4710}
4711impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
4712 fn span(&self) -> ::treesitter_types::Span {
4713 self.span
4714 }
4715}
4716#[derive(Debug, Clone, PartialEq, Eq)]
4717pub struct FieldDesignator<'tree> {
4718 pub span: ::treesitter_types::Span,
4719 pub children: FieldIdentifier<'tree>,
4720}
4721impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDesignator<'tree> {
4722 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4723 fn from_node(
4724 node: ::treesitter_types::tree_sitter::Node<'tree>,
4725 src: &'tree [u8],
4726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4727 debug_assert_eq!(node.kind(), "field_designator");
4728 Ok(Self {
4729 span: ::treesitter_types::Span::from(node),
4730 children: {
4731 #[allow(clippy::suspicious_else_formatting)]
4732 let non_field_children = {
4733 let mut cursor = node.walk();
4734 let mut result = ::std::vec::Vec::new();
4735 if cursor.goto_first_child() {
4736 loop {
4737 if cursor.field_name().is_none()
4738 && cursor.node().is_named()
4739 && !cursor.node().is_extra()
4740 {
4741 result.push(cursor.node());
4742 }
4743 if !cursor.goto_next_sibling() {
4744 break;
4745 }
4746 }
4747 }
4748 result
4749 };
4750 let child = if let Some(&c) = non_field_children.first() {
4751 c
4752 } else {
4753 let mut fallback_cursor = node.walk();
4754 let mut fallback_child = None;
4755 if fallback_cursor.goto_first_child() {
4756 loop {
4757 if fallback_cursor.field_name().is_none()
4758 && !fallback_cursor.node().is_extra()
4759 {
4760 let candidate = fallback_cursor.node();
4761 #[allow(clippy::needless_question_mark)]
4762 if (|| -> ::core::result::Result<
4763 _,
4764 ::treesitter_types::ParseError,
4765 > {
4766 let child = candidate;
4767 Ok(
4768 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
4769 child,
4770 src,
4771 ))?,
4772 )
4773 })()
4774 .is_ok()
4775 {
4776 fallback_child = Some(candidate);
4777 break;
4778 }
4779 }
4780 if !fallback_cursor.goto_next_sibling() {
4781 break;
4782 }
4783 }
4784 }
4785 if fallback_child.is_none() {
4786 let mut cursor2 = node.walk();
4787 if cursor2.goto_first_child() {
4788 loop {
4789 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4790 let candidate = cursor2.node();
4791 #[allow(clippy::needless_question_mark)]
4792 if (|| -> ::core::result::Result<
4793 _,
4794 ::treesitter_types::ParseError,
4795 > {
4796 let child = candidate;
4797 Ok(
4798 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
4799 child,
4800 src,
4801 ))?,
4802 )
4803 })()
4804 .is_ok()
4805 {
4806 fallback_child = Some(candidate);
4807 break;
4808 }
4809 }
4810 if !cursor2.goto_next_sibling() {
4811 break;
4812 }
4813 }
4814 }
4815 }
4816 fallback_child.ok_or_else(|| {
4817 ::treesitter_types::ParseError::missing_field("children", node)
4818 })?
4819 };
4820 ::treesitter_types::runtime::maybe_grow_stack(|| {
4821 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
4822 })?
4823 },
4824 })
4825 }
4826}
4827impl ::treesitter_types::Spanned for FieldDesignator<'_> {
4828 fn span(&self) -> ::treesitter_types::Span {
4829 self.span
4830 }
4831}
4832#[derive(Debug, Clone, PartialEq, Eq)]
4833pub struct FieldExpression<'tree> {
4834 pub span: ::treesitter_types::Span,
4835 pub argument: Expression<'tree>,
4836 pub field: FieldExpressionField<'tree>,
4837 pub operator: FieldExpressionOperator,
4838}
4839impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
4840 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4841 fn from_node(
4842 node: ::treesitter_types::tree_sitter::Node<'tree>,
4843 src: &'tree [u8],
4844 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4845 debug_assert_eq!(node.kind(), "field_expression");
4846 Ok(Self {
4847 span: ::treesitter_types::Span::from(node),
4848 argument: {
4849 let child = node.child_by_field_name("argument").ok_or_else(|| {
4850 ::treesitter_types::ParseError::missing_field("argument", node)
4851 })?;
4852 ::treesitter_types::runtime::maybe_grow_stack(|| {
4853 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4854 })?
4855 },
4856 field: {
4857 let child = node
4858 .child_by_field_name("field")
4859 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
4860 ::treesitter_types::runtime::maybe_grow_stack(|| {
4861 <FieldExpressionField as ::treesitter_types::FromNode>::from_node(child, src)
4862 })?
4863 },
4864 operator: {
4865 let child = node.child_by_field_name("operator").ok_or_else(|| {
4866 ::treesitter_types::ParseError::missing_field("operator", node)
4867 })?;
4868 ::treesitter_types::runtime::maybe_grow_stack(|| {
4869 <FieldExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
4870 })?
4871 },
4872 })
4873 }
4874}
4875impl ::treesitter_types::Spanned for FieldExpression<'_> {
4876 fn span(&self) -> ::treesitter_types::Span {
4877 self.span
4878 }
4879}
4880#[derive(Debug, Clone, PartialEq, Eq)]
4881pub struct FieldInitializer<'tree> {
4882 pub span: ::treesitter_types::Span,
4883 pub children: ::std::vec::Vec<FieldInitializerChildren<'tree>>,
4884}
4885impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializer<'tree> {
4886 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4887 fn from_node(
4888 node: ::treesitter_types::tree_sitter::Node<'tree>,
4889 src: &'tree [u8],
4890 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4891 debug_assert_eq!(node.kind(), "field_initializer");
4892 Ok(Self {
4893 span: ::treesitter_types::Span::from(node),
4894 children: {
4895 #[allow(clippy::suspicious_else_formatting)]
4896 let non_field_children = {
4897 let mut cursor = node.walk();
4898 let mut result = ::std::vec::Vec::new();
4899 if cursor.goto_first_child() {
4900 loop {
4901 if cursor.field_name().is_none()
4902 && cursor.node().is_named()
4903 && !cursor.node().is_extra()
4904 {
4905 result.push(cursor.node());
4906 }
4907 if !cursor.goto_next_sibling() {
4908 break;
4909 }
4910 }
4911 }
4912 result
4913 };
4914 let mut items = ::std::vec::Vec::new();
4915 for child in non_field_children {
4916 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4917 <FieldInitializerChildren as ::treesitter_types::FromNode>::from_node(
4918 child, src,
4919 )
4920 })?);
4921 }
4922 items
4923 },
4924 })
4925 }
4926}
4927impl ::treesitter_types::Spanned for FieldInitializer<'_> {
4928 fn span(&self) -> ::treesitter_types::Span {
4929 self.span
4930 }
4931}
4932#[derive(Debug, Clone, PartialEq, Eq)]
4933pub struct FieldInitializerList<'tree> {
4934 pub span: ::treesitter_types::Span,
4935 pub children: ::std::vec::Vec<FieldInitializer<'tree>>,
4936}
4937impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerList<'tree> {
4938 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4939 fn from_node(
4940 node: ::treesitter_types::tree_sitter::Node<'tree>,
4941 src: &'tree [u8],
4942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4943 debug_assert_eq!(node.kind(), "field_initializer_list");
4944 Ok(Self {
4945 span: ::treesitter_types::Span::from(node),
4946 children: {
4947 #[allow(clippy::suspicious_else_formatting)]
4948 let non_field_children = {
4949 let mut cursor = node.walk();
4950 let mut result = ::std::vec::Vec::new();
4951 if cursor.goto_first_child() {
4952 loop {
4953 if cursor.field_name().is_none()
4954 && cursor.node().is_named()
4955 && !cursor.node().is_extra()
4956 {
4957 result.push(cursor.node());
4958 }
4959 if !cursor.goto_next_sibling() {
4960 break;
4961 }
4962 }
4963 }
4964 result
4965 };
4966 let mut items = ::std::vec::Vec::new();
4967 for child in non_field_children {
4968 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4969 <FieldInitializer as ::treesitter_types::FromNode>::from_node(child, src)
4970 })?);
4971 }
4972 items
4973 },
4974 })
4975 }
4976}
4977impl ::treesitter_types::Spanned for FieldInitializerList<'_> {
4978 fn span(&self) -> ::treesitter_types::Span {
4979 self.span
4980 }
4981}
4982#[derive(Debug, Clone, PartialEq, Eq)]
4983pub struct FoldExpression<'tree> {
4984 pub span: ::treesitter_types::Span,
4985 pub left: FoldExpressionLeft<'tree>,
4986 pub operator: FoldExpressionOperator,
4987 pub right: FoldExpressionRight<'tree>,
4988}
4989impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpression<'tree> {
4990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4991 fn from_node(
4992 node: ::treesitter_types::tree_sitter::Node<'tree>,
4993 src: &'tree [u8],
4994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4995 debug_assert_eq!(node.kind(), "fold_expression");
4996 Ok(Self {
4997 span: ::treesitter_types::Span::from(node),
4998 left: {
4999 let child = node
5000 .child_by_field_name("left")
5001 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5002 ::treesitter_types::runtime::maybe_grow_stack(|| {
5003 <FoldExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)
5004 })?
5005 },
5006 operator: {
5007 let child = node.child_by_field_name("operator").ok_or_else(|| {
5008 ::treesitter_types::ParseError::missing_field("operator", node)
5009 })?;
5010 ::treesitter_types::runtime::maybe_grow_stack(|| {
5011 <FoldExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
5012 })?
5013 },
5014 right: {
5015 let child = node
5016 .child_by_field_name("right")
5017 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5018 ::treesitter_types::runtime::maybe_grow_stack(|| {
5019 <FoldExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
5020 })?
5021 },
5022 })
5023 }
5024}
5025impl ::treesitter_types::Spanned for FoldExpression<'_> {
5026 fn span(&self) -> ::treesitter_types::Span {
5027 self.span
5028 }
5029}
5030#[derive(Debug, Clone, PartialEq, Eq)]
5031pub struct ForRangeLoop<'tree> {
5032 pub span: ::treesitter_types::Span,
5033 pub body: Statement<'tree>,
5034 pub declarator: Declarator<'tree>,
5035 pub initializer: ::core::option::Option<InitStatement<'tree>>,
5036 pub right: ForRangeLoopRight<'tree>,
5037 pub r#type: TypeSpecifier<'tree>,
5038 pub children: ::std::vec::Vec<ForRangeLoopChildren<'tree>>,
5039}
5040impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoop<'tree> {
5041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5042 fn from_node(
5043 node: ::treesitter_types::tree_sitter::Node<'tree>,
5044 src: &'tree [u8],
5045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5046 debug_assert_eq!(node.kind(), "for_range_loop");
5047 Ok(Self {
5048 span: ::treesitter_types::Span::from(node),
5049 body: {
5050 let child = node
5051 .child_by_field_name("body")
5052 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5053 ::treesitter_types::runtime::maybe_grow_stack(|| {
5054 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5055 })?
5056 },
5057 declarator: {
5058 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5059 ::treesitter_types::ParseError::missing_field("declarator", node)
5060 })?;
5061 ::treesitter_types::runtime::maybe_grow_stack(|| {
5062 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)
5063 })?
5064 },
5065 initializer: match node.child_by_field_name("initializer") {
5066 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5067 <InitStatement as ::treesitter_types::FromNode>::from_node(child, src)
5068 })?),
5069 None => None,
5070 },
5071 right: {
5072 let child = node
5073 .child_by_field_name("right")
5074 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5075 ::treesitter_types::runtime::maybe_grow_stack(|| {
5076 <ForRangeLoopRight as ::treesitter_types::FromNode>::from_node(child, src)
5077 })?
5078 },
5079 r#type: {
5080 let child = node
5081 .child_by_field_name("type")
5082 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5083 ::treesitter_types::runtime::maybe_grow_stack(|| {
5084 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
5085 })?
5086 },
5087 children: {
5088 #[allow(clippy::suspicious_else_formatting)]
5089 let non_field_children = {
5090 let mut cursor = node.walk();
5091 let mut result = ::std::vec::Vec::new();
5092 if cursor.goto_first_child() {
5093 loop {
5094 if cursor.field_name().is_none()
5095 && cursor.node().is_named()
5096 && !cursor.node().is_extra()
5097 {
5098 result.push(cursor.node());
5099 }
5100 if !cursor.goto_next_sibling() {
5101 break;
5102 }
5103 }
5104 }
5105 result
5106 };
5107 let mut items = ::std::vec::Vec::new();
5108 for child in non_field_children {
5109 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5110 <ForRangeLoopChildren as ::treesitter_types::FromNode>::from_node(
5111 child, src,
5112 )
5113 })?);
5114 }
5115 items
5116 },
5117 })
5118 }
5119}
5120impl ::treesitter_types::Spanned for ForRangeLoop<'_> {
5121 fn span(&self) -> ::treesitter_types::Span {
5122 self.span
5123 }
5124}
5125#[derive(Debug, Clone, PartialEq, Eq)]
5126pub struct ForStatement<'tree> {
5127 pub span: ::treesitter_types::Span,
5128 pub body: Statement<'tree>,
5129 pub condition: ::core::option::Option<ForStatementCondition<'tree>>,
5130 pub initializer: ::core::option::Option<ForStatementInitializer<'tree>>,
5131 pub update: ::core::option::Option<ForStatementUpdate<'tree>>,
5132}
5133impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
5134 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5135 fn from_node(
5136 node: ::treesitter_types::tree_sitter::Node<'tree>,
5137 src: &'tree [u8],
5138 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5139 debug_assert_eq!(node.kind(), "for_statement");
5140 Ok(Self {
5141 span: ::treesitter_types::Span::from(node),
5142 body: {
5143 let child = node
5144 .child_by_field_name("body")
5145 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5146 ::treesitter_types::runtime::maybe_grow_stack(|| {
5147 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5148 })?
5149 },
5150 condition: match node.child_by_field_name("condition") {
5151 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5152 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(child, src)
5153 })?),
5154 None => None,
5155 },
5156 initializer: match node.child_by_field_name("initializer") {
5157 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5158 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)
5159 })?),
5160 None => None,
5161 },
5162 update: match node.child_by_field_name("update") {
5163 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5164 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)
5165 })?),
5166 None => None,
5167 },
5168 })
5169 }
5170}
5171impl ::treesitter_types::Spanned for ForStatement<'_> {
5172 fn span(&self) -> ::treesitter_types::Span {
5173 self.span
5174 }
5175}
5176#[derive(Debug, Clone, PartialEq, Eq)]
5177pub struct FriendDeclaration<'tree> {
5178 pub span: ::treesitter_types::Span,
5179 pub children: FriendDeclarationChildren<'tree>,
5180}
5181impl<'tree> ::treesitter_types::FromNode<'tree> for FriendDeclaration<'tree> {
5182 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5183 fn from_node(
5184 node: ::treesitter_types::tree_sitter::Node<'tree>,
5185 src: &'tree [u8],
5186 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5187 debug_assert_eq!(node.kind(), "friend_declaration");
5188 Ok(Self {
5189 span: ::treesitter_types::Span::from(node),
5190 children: {
5191 #[allow(clippy::suspicious_else_formatting)]
5192 let non_field_children = {
5193 let mut cursor = node.walk();
5194 let mut result = ::std::vec::Vec::new();
5195 if cursor.goto_first_child() {
5196 loop {
5197 if cursor.field_name().is_none()
5198 && cursor.node().is_named()
5199 && !cursor.node().is_extra()
5200 {
5201 result.push(cursor.node());
5202 }
5203 if !cursor.goto_next_sibling() {
5204 break;
5205 }
5206 }
5207 }
5208 result
5209 };
5210 let child = if let Some(&c) = non_field_children.first() {
5211 c
5212 } else {
5213 let mut fallback_cursor = node.walk();
5214 let mut fallback_child = None;
5215 if fallback_cursor.goto_first_child() {
5216 loop {
5217 if fallback_cursor.field_name().is_none()
5218 && !fallback_cursor.node().is_extra()
5219 {
5220 let candidate = fallback_cursor.node();
5221 #[allow(clippy::needless_question_mark)]
5222 if (|| -> ::core::result::Result<
5223 _,
5224 ::treesitter_types::ParseError,
5225 > {
5226 let child = candidate;
5227 Ok(
5228 ::treesitter_types::runtime::maybe_grow_stack(|| <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5229 child,
5230 src,
5231 ))?,
5232 )
5233 })()
5234 .is_ok()
5235 {
5236 fallback_child = Some(candidate);
5237 break;
5238 }
5239 }
5240 if !fallback_cursor.goto_next_sibling() {
5241 break;
5242 }
5243 }
5244 }
5245 if fallback_child.is_none() {
5246 let mut cursor2 = node.walk();
5247 if cursor2.goto_first_child() {
5248 loop {
5249 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5250 let candidate = cursor2.node();
5251 #[allow(clippy::needless_question_mark)]
5252 if (|| -> ::core::result::Result<
5253 _,
5254 ::treesitter_types::ParseError,
5255 > {
5256 let child = candidate;
5257 Ok(
5258 ::treesitter_types::runtime::maybe_grow_stack(|| <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5259 child,
5260 src,
5261 ))?,
5262 )
5263 })()
5264 .is_ok()
5265 {
5266 fallback_child = Some(candidate);
5267 break;
5268 }
5269 }
5270 if !cursor2.goto_next_sibling() {
5271 break;
5272 }
5273 }
5274 }
5275 }
5276 fallback_child.ok_or_else(|| {
5277 ::treesitter_types::ParseError::missing_field("children", node)
5278 })?
5279 };
5280 ::treesitter_types::runtime::maybe_grow_stack(|| {
5281 <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5282 child, src,
5283 )
5284 })?
5285 },
5286 })
5287 }
5288}
5289impl ::treesitter_types::Spanned for FriendDeclaration<'_> {
5290 fn span(&self) -> ::treesitter_types::Span {
5291 self.span
5292 }
5293}
5294#[derive(Debug, Clone, PartialEq, Eq)]
5295pub struct FunctionDeclarator<'tree> {
5296 pub span: ::treesitter_types::Span,
5297 pub declarator: FunctionDeclaratorDeclarator<'tree>,
5298 pub parameters: ParameterList<'tree>,
5299 pub children: ::std::vec::Vec<FunctionDeclaratorChildren<'tree>>,
5300}
5301impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarator<'tree> {
5302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5303 fn from_node(
5304 node: ::treesitter_types::tree_sitter::Node<'tree>,
5305 src: &'tree [u8],
5306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5307 debug_assert_eq!(node.kind(), "function_declarator");
5308 Ok(Self {
5309 span: ::treesitter_types::Span::from(node),
5310 declarator: {
5311 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5312 ::treesitter_types::ParseError::missing_field("declarator", node)
5313 })?;
5314 ::treesitter_types::runtime::maybe_grow_stack(|| {
5315 <FunctionDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
5316 child, src,
5317 )
5318 })?
5319 },
5320 parameters: {
5321 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5322 ::treesitter_types::ParseError::missing_field("parameters", node)
5323 })?;
5324 ::treesitter_types::runtime::maybe_grow_stack(|| {
5325 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
5326 })?
5327 },
5328 children: {
5329 #[allow(clippy::suspicious_else_formatting)]
5330 let non_field_children = {
5331 let mut cursor = node.walk();
5332 let mut result = ::std::vec::Vec::new();
5333 if cursor.goto_first_child() {
5334 loop {
5335 if cursor.field_name().is_none()
5336 && cursor.node().is_named()
5337 && !cursor.node().is_extra()
5338 {
5339 result.push(cursor.node());
5340 }
5341 if !cursor.goto_next_sibling() {
5342 break;
5343 }
5344 }
5345 }
5346 result
5347 };
5348 let mut items = ::std::vec::Vec::new();
5349 for child in non_field_children {
5350 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5351 <FunctionDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
5352 child, src,
5353 )
5354 })?);
5355 }
5356 items
5357 },
5358 })
5359 }
5360}
5361impl ::treesitter_types::Spanned for FunctionDeclarator<'_> {
5362 fn span(&self) -> ::treesitter_types::Span {
5363 self.span
5364 }
5365}
5366#[derive(Debug, Clone, PartialEq, Eq)]
5367pub struct FunctionDefinition<'tree> {
5368 pub span: ::treesitter_types::Span,
5369 pub body: ::core::option::Option<FunctionDefinitionBody<'tree>>,
5370 pub declarator: FunctionDefinitionDeclarator<'tree>,
5371 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
5372 pub children: ::std::vec::Vec<FunctionDefinitionChildren<'tree>>,
5373}
5374impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
5375 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5376 fn from_node(
5377 node: ::treesitter_types::tree_sitter::Node<'tree>,
5378 src: &'tree [u8],
5379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5380 debug_assert_eq!(node.kind(), "function_definition");
5381 Ok(Self {
5382 span: ::treesitter_types::Span::from(node),
5383 body: match node.child_by_field_name("body") {
5384 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5385 <FunctionDefinitionBody as ::treesitter_types::FromNode>::from_node(child, src)
5386 })?),
5387 None => None,
5388 },
5389 declarator: {
5390 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5391 ::treesitter_types::ParseError::missing_field("declarator", node)
5392 })?;
5393 ::treesitter_types::runtime::maybe_grow_stack(|| {
5394 <FunctionDefinitionDeclarator as ::treesitter_types::FromNode>::from_node(
5395 child, src,
5396 )
5397 })?
5398 },
5399 r#type: match node.child_by_field_name("type") {
5400 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5401 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
5402 })?),
5403 None => None,
5404 },
5405 children: {
5406 #[allow(clippy::suspicious_else_formatting)]
5407 let non_field_children = {
5408 let mut cursor = node.walk();
5409 let mut result = ::std::vec::Vec::new();
5410 if cursor.goto_first_child() {
5411 loop {
5412 if cursor.field_name().is_none()
5413 && cursor.node().is_named()
5414 && !cursor.node().is_extra()
5415 {
5416 result.push(cursor.node());
5417 }
5418 if !cursor.goto_next_sibling() {
5419 break;
5420 }
5421 }
5422 }
5423 result
5424 };
5425 let mut items = ::std::vec::Vec::new();
5426 for child in non_field_children {
5427 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5428 <FunctionDefinitionChildren as ::treesitter_types::FromNode>::from_node(
5429 child, src,
5430 )
5431 })?);
5432 }
5433 items
5434 },
5435 })
5436 }
5437}
5438impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
5439 fn span(&self) -> ::treesitter_types::Span {
5440 self.span
5441 }
5442}
5443#[derive(Debug, Clone, PartialEq, Eq)]
5444pub struct GenericExpression<'tree> {
5445 pub span: ::treesitter_types::Span,
5446 pub children: ::std::vec::Vec<GenericExpressionChildren<'tree>>,
5447}
5448impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpression<'tree> {
5449 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5450 fn from_node(
5451 node: ::treesitter_types::tree_sitter::Node<'tree>,
5452 src: &'tree [u8],
5453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5454 debug_assert_eq!(node.kind(), "generic_expression");
5455 Ok(Self {
5456 span: ::treesitter_types::Span::from(node),
5457 children: {
5458 #[allow(clippy::suspicious_else_formatting)]
5459 let non_field_children = {
5460 let mut cursor = node.walk();
5461 let mut result = ::std::vec::Vec::new();
5462 if cursor.goto_first_child() {
5463 loop {
5464 if cursor.field_name().is_none()
5465 && cursor.node().is_named()
5466 && !cursor.node().is_extra()
5467 {
5468 result.push(cursor.node());
5469 }
5470 if !cursor.goto_next_sibling() {
5471 break;
5472 }
5473 }
5474 }
5475 result
5476 };
5477 let mut items = ::std::vec::Vec::new();
5478 for child in non_field_children {
5479 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5480 <GenericExpressionChildren as ::treesitter_types::FromNode>::from_node(
5481 child, src,
5482 )
5483 })?);
5484 }
5485 items
5486 },
5487 })
5488 }
5489}
5490impl ::treesitter_types::Spanned for GenericExpression<'_> {
5491 fn span(&self) -> ::treesitter_types::Span {
5492 self.span
5493 }
5494}
5495#[derive(Debug, Clone, PartialEq, Eq)]
5496pub struct GnuAsmClobberList<'tree> {
5497 pub span: ::treesitter_types::Span,
5498 pub register: ::std::vec::Vec<GnuAsmClobberListRegister<'tree>>,
5499}
5500impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberList<'tree> {
5501 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5502 fn from_node(
5503 node: ::treesitter_types::tree_sitter::Node<'tree>,
5504 src: &'tree [u8],
5505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5506 debug_assert_eq!(node.kind(), "gnu_asm_clobber_list");
5507 Ok(Self {
5508 span: ::treesitter_types::Span::from(node),
5509 register: {
5510 let mut cursor = node.walk();
5511 let mut items = ::std::vec::Vec::new();
5512 for child in node.children_by_field_name("register", &mut cursor) {
5513 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5514 <GnuAsmClobberListRegister as ::treesitter_types::FromNode>::from_node(
5515 child, src,
5516 )
5517 })?);
5518 }
5519 items
5520 },
5521 })
5522 }
5523}
5524impl ::treesitter_types::Spanned for GnuAsmClobberList<'_> {
5525 fn span(&self) -> ::treesitter_types::Span {
5526 self.span
5527 }
5528}
5529#[derive(Debug, Clone, PartialEq, Eq)]
5530pub struct GnuAsmExpression<'tree> {
5531 pub span: ::treesitter_types::Span,
5532 pub assembly_code: GnuAsmExpressionAssemblyCode<'tree>,
5533 pub clobbers: ::core::option::Option<GnuAsmClobberList<'tree>>,
5534 pub goto_labels: ::core::option::Option<GnuAsmGotoList<'tree>>,
5535 pub input_operands: ::core::option::Option<GnuAsmInputOperandList<'tree>>,
5536 pub output_operands: ::core::option::Option<GnuAsmOutputOperandList<'tree>>,
5537 pub children: ::std::vec::Vec<GnuAsmQualifier<'tree>>,
5538}
5539impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpression<'tree> {
5540 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5541 fn from_node(
5542 node: ::treesitter_types::tree_sitter::Node<'tree>,
5543 src: &'tree [u8],
5544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5545 debug_assert_eq!(node.kind(), "gnu_asm_expression");
5546 Ok(Self {
5547 span: ::treesitter_types::Span::from(node),
5548 assembly_code: {
5549 let child = node.child_by_field_name("assembly_code").ok_or_else(|| {
5550 ::treesitter_types::ParseError::missing_field("assembly_code", node)
5551 })?;
5552 ::treesitter_types::runtime::maybe_grow_stack(|| {
5553 <GnuAsmExpressionAssemblyCode as ::treesitter_types::FromNode>::from_node(
5554 child, src,
5555 )
5556 })?
5557 },
5558 clobbers: match node.child_by_field_name("clobbers") {
5559 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5560 <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(child, src)
5561 })?),
5562 None => None,
5563 },
5564 goto_labels: match node.child_by_field_name("goto_labels") {
5565 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5566 <GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(child, src)
5567 })?),
5568 None => None,
5569 },
5570 input_operands: match node.child_by_field_name("input_operands") {
5571 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5572 <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(child, src)
5573 })?),
5574 None => None,
5575 },
5576 output_operands: match node.child_by_field_name("output_operands") {
5577 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5578 <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(child, src)
5579 })?),
5580 None => None,
5581 },
5582 children: {
5583 #[allow(clippy::suspicious_else_formatting)]
5584 let non_field_children = {
5585 let mut cursor = node.walk();
5586 let mut result = ::std::vec::Vec::new();
5587 if cursor.goto_first_child() {
5588 loop {
5589 if cursor.field_name().is_none()
5590 && cursor.node().is_named()
5591 && !cursor.node().is_extra()
5592 {
5593 result.push(cursor.node());
5594 }
5595 if !cursor.goto_next_sibling() {
5596 break;
5597 }
5598 }
5599 }
5600 result
5601 };
5602 let mut items = ::std::vec::Vec::new();
5603 for child in non_field_children {
5604 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5605 <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(child, src)
5606 })?);
5607 }
5608 items
5609 },
5610 })
5611 }
5612}
5613impl ::treesitter_types::Spanned for GnuAsmExpression<'_> {
5614 fn span(&self) -> ::treesitter_types::Span {
5615 self.span
5616 }
5617}
5618#[derive(Debug, Clone, PartialEq, Eq)]
5619pub struct GnuAsmGotoList<'tree> {
5620 pub span: ::treesitter_types::Span,
5621 pub label: ::std::vec::Vec<Identifier<'tree>>,
5622}
5623impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmGotoList<'tree> {
5624 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5625 fn from_node(
5626 node: ::treesitter_types::tree_sitter::Node<'tree>,
5627 src: &'tree [u8],
5628 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5629 debug_assert_eq!(node.kind(), "gnu_asm_goto_list");
5630 Ok(Self {
5631 span: ::treesitter_types::Span::from(node),
5632 label: {
5633 let mut cursor = node.walk();
5634 let mut items = ::std::vec::Vec::new();
5635 for child in node.children_by_field_name("label", &mut cursor) {
5636 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5637 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5638 })?);
5639 }
5640 items
5641 },
5642 })
5643 }
5644}
5645impl ::treesitter_types::Spanned for GnuAsmGotoList<'_> {
5646 fn span(&self) -> ::treesitter_types::Span {
5647 self.span
5648 }
5649}
5650#[derive(Debug, Clone, PartialEq, Eq)]
5651pub struct GnuAsmInputOperand<'tree> {
5652 pub span: ::treesitter_types::Span,
5653 pub constraint: StringLiteral<'tree>,
5654 pub symbol: ::core::option::Option<Identifier<'tree>>,
5655 pub value: Expression<'tree>,
5656}
5657impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperand<'tree> {
5658 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5659 fn from_node(
5660 node: ::treesitter_types::tree_sitter::Node<'tree>,
5661 src: &'tree [u8],
5662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5663 debug_assert_eq!(node.kind(), "gnu_asm_input_operand");
5664 Ok(Self {
5665 span: ::treesitter_types::Span::from(node),
5666 constraint: {
5667 let child = node.child_by_field_name("constraint").ok_or_else(|| {
5668 ::treesitter_types::ParseError::missing_field("constraint", node)
5669 })?;
5670 ::treesitter_types::runtime::maybe_grow_stack(|| {
5671 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
5672 })?
5673 },
5674 symbol: match node.child_by_field_name("symbol") {
5675 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5676 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5677 })?),
5678 None => None,
5679 },
5680 value: {
5681 let child = node
5682 .child_by_field_name("value")
5683 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5684 ::treesitter_types::runtime::maybe_grow_stack(|| {
5685 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5686 })?
5687 },
5688 })
5689 }
5690}
5691impl ::treesitter_types::Spanned for GnuAsmInputOperand<'_> {
5692 fn span(&self) -> ::treesitter_types::Span {
5693 self.span
5694 }
5695}
5696#[derive(Debug, Clone, PartialEq, Eq)]
5697pub struct GnuAsmInputOperandList<'tree> {
5698 pub span: ::treesitter_types::Span,
5699 pub operand: ::std::vec::Vec<GnuAsmInputOperand<'tree>>,
5700}
5701impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperandList<'tree> {
5702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5703 fn from_node(
5704 node: ::treesitter_types::tree_sitter::Node<'tree>,
5705 src: &'tree [u8],
5706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5707 debug_assert_eq!(node.kind(), "gnu_asm_input_operand_list");
5708 Ok(Self {
5709 span: ::treesitter_types::Span::from(node),
5710 operand: {
5711 let mut cursor = node.walk();
5712 let mut items = ::std::vec::Vec::new();
5713 for child in node.children_by_field_name("operand", &mut cursor) {
5714 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5715 <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(child, src)
5716 })?);
5717 }
5718 items
5719 },
5720 })
5721 }
5722}
5723impl ::treesitter_types::Spanned for GnuAsmInputOperandList<'_> {
5724 fn span(&self) -> ::treesitter_types::Span {
5725 self.span
5726 }
5727}
5728#[derive(Debug, Clone, PartialEq, Eq)]
5729pub struct GnuAsmOutputOperand<'tree> {
5730 pub span: ::treesitter_types::Span,
5731 pub constraint: StringLiteral<'tree>,
5732 pub symbol: ::core::option::Option<Identifier<'tree>>,
5733 pub value: Expression<'tree>,
5734}
5735impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperand<'tree> {
5736 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5737 fn from_node(
5738 node: ::treesitter_types::tree_sitter::Node<'tree>,
5739 src: &'tree [u8],
5740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5741 debug_assert_eq!(node.kind(), "gnu_asm_output_operand");
5742 Ok(Self {
5743 span: ::treesitter_types::Span::from(node),
5744 constraint: {
5745 let child = node.child_by_field_name("constraint").ok_or_else(|| {
5746 ::treesitter_types::ParseError::missing_field("constraint", node)
5747 })?;
5748 ::treesitter_types::runtime::maybe_grow_stack(|| {
5749 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
5750 })?
5751 },
5752 symbol: match node.child_by_field_name("symbol") {
5753 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5754 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
5755 })?),
5756 None => None,
5757 },
5758 value: {
5759 let child = node
5760 .child_by_field_name("value")
5761 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5762 ::treesitter_types::runtime::maybe_grow_stack(|| {
5763 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5764 })?
5765 },
5766 })
5767 }
5768}
5769impl ::treesitter_types::Spanned for GnuAsmOutputOperand<'_> {
5770 fn span(&self) -> ::treesitter_types::Span {
5771 self.span
5772 }
5773}
5774#[derive(Debug, Clone, PartialEq, Eq)]
5775pub struct GnuAsmOutputOperandList<'tree> {
5776 pub span: ::treesitter_types::Span,
5777 pub operand: ::std::vec::Vec<GnuAsmOutputOperand<'tree>>,
5778}
5779impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperandList<'tree> {
5780 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5781 fn from_node(
5782 node: ::treesitter_types::tree_sitter::Node<'tree>,
5783 src: &'tree [u8],
5784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5785 debug_assert_eq!(node.kind(), "gnu_asm_output_operand_list");
5786 Ok(Self {
5787 span: ::treesitter_types::Span::from(node),
5788 operand: {
5789 let mut cursor = node.walk();
5790 let mut items = ::std::vec::Vec::new();
5791 for child in node.children_by_field_name("operand", &mut cursor) {
5792 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5793 <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(child, src)
5794 })?);
5795 }
5796 items
5797 },
5798 })
5799 }
5800}
5801impl ::treesitter_types::Spanned for GnuAsmOutputOperandList<'_> {
5802 fn span(&self) -> ::treesitter_types::Span {
5803 self.span
5804 }
5805}
5806#[derive(Debug, Clone, PartialEq, Eq)]
5807pub struct GnuAsmQualifier<'tree> {
5808 pub span: ::treesitter_types::Span,
5809 text: &'tree str,
5810}
5811impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmQualifier<'tree> {
5812 fn from_node(
5813 node: ::treesitter_types::tree_sitter::Node<'tree>,
5814 src: &'tree [u8],
5815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5816 debug_assert_eq!(node.kind(), "gnu_asm_qualifier");
5817 Ok(Self {
5818 span: ::treesitter_types::Span::from(node),
5819 text: node.utf8_text(src)?,
5820 })
5821 }
5822}
5823impl<'tree> ::treesitter_types::LeafNode<'tree> for GnuAsmQualifier<'tree> {
5824 fn text(&self) -> &'tree str {
5825 self.text
5826 }
5827}
5828impl ::treesitter_types::Spanned for GnuAsmQualifier<'_> {
5829 fn span(&self) -> ::treesitter_types::Span {
5830 self.span
5831 }
5832}
5833#[derive(Debug, Clone, PartialEq, Eq)]
5834pub struct GotoStatement<'tree> {
5835 pub span: ::treesitter_types::Span,
5836 pub label: StatementIdentifier<'tree>,
5837}
5838impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
5839 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5840 fn from_node(
5841 node: ::treesitter_types::tree_sitter::Node<'tree>,
5842 src: &'tree [u8],
5843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5844 debug_assert_eq!(node.kind(), "goto_statement");
5845 Ok(Self {
5846 span: ::treesitter_types::Span::from(node),
5847 label: {
5848 let child = node
5849 .child_by_field_name("label")
5850 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
5851 ::treesitter_types::runtime::maybe_grow_stack(|| {
5852 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
5853 })?
5854 },
5855 })
5856 }
5857}
5858impl ::treesitter_types::Spanned for GotoStatement<'_> {
5859 fn span(&self) -> ::treesitter_types::Span {
5860 self.span
5861 }
5862}
5863#[derive(Debug, Clone, PartialEq, Eq)]
5864pub struct IfStatement<'tree> {
5865 pub span: ::treesitter_types::Span,
5866 pub alternative: ::core::option::Option<ElseClause<'tree>>,
5867 pub condition: ConditionClause<'tree>,
5868 pub consequence: Statement<'tree>,
5869}
5870impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
5871 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5872 fn from_node(
5873 node: ::treesitter_types::tree_sitter::Node<'tree>,
5874 src: &'tree [u8],
5875 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5876 debug_assert_eq!(node.kind(), "if_statement");
5877 Ok(Self {
5878 span: ::treesitter_types::Span::from(node),
5879 alternative: match node.child_by_field_name("alternative") {
5880 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5881 <ElseClause as ::treesitter_types::FromNode>::from_node(child, src)
5882 })?),
5883 None => None,
5884 },
5885 condition: {
5886 let child = node.child_by_field_name("condition").ok_or_else(|| {
5887 ::treesitter_types::ParseError::missing_field("condition", node)
5888 })?;
5889 ::treesitter_types::runtime::maybe_grow_stack(|| {
5890 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)
5891 })?
5892 },
5893 consequence: {
5894 let child = node.child_by_field_name("consequence").ok_or_else(|| {
5895 ::treesitter_types::ParseError::missing_field("consequence", node)
5896 })?;
5897 ::treesitter_types::runtime::maybe_grow_stack(|| {
5898 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
5899 })?
5900 },
5901 })
5902 }
5903}
5904impl ::treesitter_types::Spanned for IfStatement<'_> {
5905 fn span(&self) -> ::treesitter_types::Span {
5906 self.span
5907 }
5908}
5909#[derive(Debug, Clone, PartialEq, Eq)]
5910pub struct InitDeclarator<'tree> {
5911 pub span: ::treesitter_types::Span,
5912 pub declarator: Declarator<'tree>,
5913 pub value: InitDeclaratorValue<'tree>,
5914}
5915impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclarator<'tree> {
5916 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5917 fn from_node(
5918 node: ::treesitter_types::tree_sitter::Node<'tree>,
5919 src: &'tree [u8],
5920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5921 debug_assert_eq!(node.kind(), "init_declarator");
5922 Ok(Self {
5923 span: ::treesitter_types::Span::from(node),
5924 declarator: {
5925 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5926 ::treesitter_types::ParseError::missing_field("declarator", node)
5927 })?;
5928 ::treesitter_types::runtime::maybe_grow_stack(|| {
5929 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)
5930 })?
5931 },
5932 value: {
5933 let child = node
5934 .child_by_field_name("value")
5935 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5936 ::treesitter_types::runtime::maybe_grow_stack(|| {
5937 <InitDeclaratorValue as ::treesitter_types::FromNode>::from_node(child, src)
5938 })?
5939 },
5940 })
5941 }
5942}
5943impl ::treesitter_types::Spanned for InitDeclarator<'_> {
5944 fn span(&self) -> ::treesitter_types::Span {
5945 self.span
5946 }
5947}
5948#[derive(Debug, Clone, PartialEq, Eq)]
5949pub struct InitStatement<'tree> {
5950 pub span: ::treesitter_types::Span,
5951 pub children: InitStatementChildren<'tree>,
5952}
5953impl<'tree> ::treesitter_types::FromNode<'tree> for InitStatement<'tree> {
5954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5955 fn from_node(
5956 node: ::treesitter_types::tree_sitter::Node<'tree>,
5957 src: &'tree [u8],
5958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5959 debug_assert_eq!(node.kind(), "init_statement");
5960 Ok(Self {
5961 span: ::treesitter_types::Span::from(node),
5962 children: {
5963 #[allow(clippy::suspicious_else_formatting)]
5964 let non_field_children = {
5965 let mut cursor = node.walk();
5966 let mut result = ::std::vec::Vec::new();
5967 if cursor.goto_first_child() {
5968 loop {
5969 if cursor.field_name().is_none()
5970 && cursor.node().is_named()
5971 && !cursor.node().is_extra()
5972 {
5973 result.push(cursor.node());
5974 }
5975 if !cursor.goto_next_sibling() {
5976 break;
5977 }
5978 }
5979 }
5980 result
5981 };
5982 let child = if let Some(&c) = non_field_children.first() {
5983 c
5984 } else {
5985 let mut fallback_cursor = node.walk();
5986 let mut fallback_child = None;
5987 if fallback_cursor.goto_first_child() {
5988 loop {
5989 if fallback_cursor.field_name().is_none()
5990 && !fallback_cursor.node().is_extra()
5991 {
5992 let candidate = fallback_cursor.node();
5993 #[allow(clippy::needless_question_mark)]
5994 if (|| -> ::core::result::Result<
5995 _,
5996 ::treesitter_types::ParseError,
5997 > {
5998 let child = candidate;
5999 Ok(
6000 ::treesitter_types::runtime::maybe_grow_stack(|| <InitStatementChildren as ::treesitter_types::FromNode>::from_node(
6001 child,
6002 src,
6003 ))?,
6004 )
6005 })()
6006 .is_ok()
6007 {
6008 fallback_child = Some(candidate);
6009 break;
6010 }
6011 }
6012 if !fallback_cursor.goto_next_sibling() {
6013 break;
6014 }
6015 }
6016 }
6017 if fallback_child.is_none() {
6018 let mut cursor2 = node.walk();
6019 if cursor2.goto_first_child() {
6020 loop {
6021 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6022 let candidate = cursor2.node();
6023 #[allow(clippy::needless_question_mark)]
6024 if (|| -> ::core::result::Result<
6025 _,
6026 ::treesitter_types::ParseError,
6027 > {
6028 let child = candidate;
6029 Ok(
6030 ::treesitter_types::runtime::maybe_grow_stack(|| <InitStatementChildren as ::treesitter_types::FromNode>::from_node(
6031 child,
6032 src,
6033 ))?,
6034 )
6035 })()
6036 .is_ok()
6037 {
6038 fallback_child = Some(candidate);
6039 break;
6040 }
6041 }
6042 if !cursor2.goto_next_sibling() {
6043 break;
6044 }
6045 }
6046 }
6047 }
6048 fallback_child.ok_or_else(|| {
6049 ::treesitter_types::ParseError::missing_field("children", node)
6050 })?
6051 };
6052 ::treesitter_types::runtime::maybe_grow_stack(|| {
6053 <InitStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
6054 })?
6055 },
6056 })
6057 }
6058}
6059impl ::treesitter_types::Spanned for InitStatement<'_> {
6060 fn span(&self) -> ::treesitter_types::Span {
6061 self.span
6062 }
6063}
6064#[derive(Debug, Clone, PartialEq, Eq)]
6065pub struct InitializerList<'tree> {
6066 pub span: ::treesitter_types::Span,
6067 pub children: ::std::vec::Vec<InitializerListChildren<'tree>>,
6068}
6069impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerList<'tree> {
6070 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6071 fn from_node(
6072 node: ::treesitter_types::tree_sitter::Node<'tree>,
6073 src: &'tree [u8],
6074 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6075 debug_assert_eq!(node.kind(), "initializer_list");
6076 Ok(Self {
6077 span: ::treesitter_types::Span::from(node),
6078 children: {
6079 #[allow(clippy::suspicious_else_formatting)]
6080 let non_field_children = {
6081 let mut cursor = node.walk();
6082 let mut result = ::std::vec::Vec::new();
6083 if cursor.goto_first_child() {
6084 loop {
6085 if cursor.field_name().is_none()
6086 && cursor.node().is_named()
6087 && !cursor.node().is_extra()
6088 {
6089 result.push(cursor.node());
6090 }
6091 if !cursor.goto_next_sibling() {
6092 break;
6093 }
6094 }
6095 }
6096 result
6097 };
6098 let mut items = ::std::vec::Vec::new();
6099 for child in non_field_children {
6100 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6101 <InitializerListChildren as ::treesitter_types::FromNode>::from_node(
6102 child, src,
6103 )
6104 })?);
6105 }
6106 items
6107 },
6108 })
6109 }
6110}
6111impl ::treesitter_types::Spanned for InitializerList<'_> {
6112 fn span(&self) -> ::treesitter_types::Span {
6113 self.span
6114 }
6115}
6116#[derive(Debug, Clone, PartialEq, Eq)]
6117pub struct InitializerPair<'tree> {
6118 pub span: ::treesitter_types::Span,
6119 pub designator: ::std::vec::Vec<InitializerPairDesignator<'tree>>,
6120 pub value: InitializerPairValue<'tree>,
6121}
6122impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPair<'tree> {
6123 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6124 fn from_node(
6125 node: ::treesitter_types::tree_sitter::Node<'tree>,
6126 src: &'tree [u8],
6127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6128 debug_assert_eq!(node.kind(), "initializer_pair");
6129 Ok(Self {
6130 span: ::treesitter_types::Span::from(node),
6131 designator: {
6132 let mut cursor = node.walk();
6133 let mut items = ::std::vec::Vec::new();
6134 for child in node.children_by_field_name("designator", &mut cursor) {
6135 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6136 <InitializerPairDesignator as ::treesitter_types::FromNode>::from_node(
6137 child, src,
6138 )
6139 })?);
6140 }
6141 items
6142 },
6143 value: {
6144 let child = node
6145 .child_by_field_name("value")
6146 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6147 ::treesitter_types::runtime::maybe_grow_stack(|| {
6148 <InitializerPairValue as ::treesitter_types::FromNode>::from_node(child, src)
6149 })?
6150 },
6151 })
6152 }
6153}
6154impl ::treesitter_types::Spanned for InitializerPair<'_> {
6155 fn span(&self) -> ::treesitter_types::Span {
6156 self.span
6157 }
6158}
6159#[derive(Debug, Clone, PartialEq, Eq)]
6160pub struct LabeledStatement<'tree> {
6161 pub span: ::treesitter_types::Span,
6162 pub label: StatementIdentifier<'tree>,
6163 pub children: LabeledStatementChildren<'tree>,
6164}
6165impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
6166 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6167 fn from_node(
6168 node: ::treesitter_types::tree_sitter::Node<'tree>,
6169 src: &'tree [u8],
6170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6171 debug_assert_eq!(node.kind(), "labeled_statement");
6172 Ok(Self {
6173 span: ::treesitter_types::Span::from(node),
6174 label: {
6175 let child = node
6176 .child_by_field_name("label")
6177 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
6178 ::treesitter_types::runtime::maybe_grow_stack(|| {
6179 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
6180 })?
6181 },
6182 children: {
6183 #[allow(clippy::suspicious_else_formatting)]
6184 let non_field_children = {
6185 let mut cursor = node.walk();
6186 let mut result = ::std::vec::Vec::new();
6187 if cursor.goto_first_child() {
6188 loop {
6189 if cursor.field_name().is_none()
6190 && cursor.node().is_named()
6191 && !cursor.node().is_extra()
6192 {
6193 result.push(cursor.node());
6194 }
6195 if !cursor.goto_next_sibling() {
6196 break;
6197 }
6198 }
6199 }
6200 result
6201 };
6202 let child = if let Some(&c) = non_field_children.first() {
6203 c
6204 } else {
6205 let mut fallback_cursor = node.walk();
6206 let mut fallback_child = None;
6207 if fallback_cursor.goto_first_child() {
6208 loop {
6209 if fallback_cursor.field_name().is_none()
6210 && !fallback_cursor.node().is_extra()
6211 {
6212 let candidate = fallback_cursor.node();
6213 #[allow(clippy::needless_question_mark)]
6214 if (|| -> ::core::result::Result<
6215 _,
6216 ::treesitter_types::ParseError,
6217 > {
6218 let child = candidate;
6219 Ok(
6220 ::treesitter_types::runtime::maybe_grow_stack(|| <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
6221 child,
6222 src,
6223 ))?,
6224 )
6225 })()
6226 .is_ok()
6227 {
6228 fallback_child = Some(candidate);
6229 break;
6230 }
6231 }
6232 if !fallback_cursor.goto_next_sibling() {
6233 break;
6234 }
6235 }
6236 }
6237 if fallback_child.is_none() {
6238 let mut cursor2 = node.walk();
6239 if cursor2.goto_first_child() {
6240 loop {
6241 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6242 let candidate = cursor2.node();
6243 #[allow(clippy::needless_question_mark)]
6244 if (|| -> ::core::result::Result<
6245 _,
6246 ::treesitter_types::ParseError,
6247 > {
6248 let child = candidate;
6249 Ok(
6250 ::treesitter_types::runtime::maybe_grow_stack(|| <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
6251 child,
6252 src,
6253 ))?,
6254 )
6255 })()
6256 .is_ok()
6257 {
6258 fallback_child = Some(candidate);
6259 break;
6260 }
6261 }
6262 if !cursor2.goto_next_sibling() {
6263 break;
6264 }
6265 }
6266 }
6267 }
6268 fallback_child.ok_or_else(|| {
6269 ::treesitter_types::ParseError::missing_field("children", node)
6270 })?
6271 };
6272 ::treesitter_types::runtime::maybe_grow_stack(|| {
6273 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
6274 child, src,
6275 )
6276 })?
6277 },
6278 })
6279 }
6280}
6281impl ::treesitter_types::Spanned for LabeledStatement<'_> {
6282 fn span(&self) -> ::treesitter_types::Span {
6283 self.span
6284 }
6285}
6286#[derive(Debug, Clone, PartialEq, Eq)]
6287pub struct LambdaCaptureInitializer<'tree> {
6288 pub span: ::treesitter_types::Span,
6289 pub left: Identifier<'tree>,
6290 pub right: Expression<'tree>,
6291}
6292impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureInitializer<'tree> {
6293 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6294 fn from_node(
6295 node: ::treesitter_types::tree_sitter::Node<'tree>,
6296 src: &'tree [u8],
6297 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6298 debug_assert_eq!(node.kind(), "lambda_capture_initializer");
6299 Ok(Self {
6300 span: ::treesitter_types::Span::from(node),
6301 left: {
6302 let child = node
6303 .child_by_field_name("left")
6304 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
6305 ::treesitter_types::runtime::maybe_grow_stack(|| {
6306 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
6307 })?
6308 },
6309 right: {
6310 let child = node
6311 .child_by_field_name("right")
6312 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
6313 ::treesitter_types::runtime::maybe_grow_stack(|| {
6314 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6315 })?
6316 },
6317 })
6318 }
6319}
6320impl ::treesitter_types::Spanned for LambdaCaptureInitializer<'_> {
6321 fn span(&self) -> ::treesitter_types::Span {
6322 self.span
6323 }
6324}
6325#[derive(Debug, Clone, PartialEq, Eq)]
6326pub struct LambdaCaptureSpecifier<'tree> {
6327 pub span: ::treesitter_types::Span,
6328 pub children: ::std::vec::Vec<LambdaCaptureSpecifierChildren<'tree>>,
6329}
6330impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureSpecifier<'tree> {
6331 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6332 fn from_node(
6333 node: ::treesitter_types::tree_sitter::Node<'tree>,
6334 src: &'tree [u8],
6335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6336 debug_assert_eq!(node.kind(), "lambda_capture_specifier");
6337 Ok(Self {
6338 span: ::treesitter_types::Span::from(node),
6339 children: {
6340 #[allow(clippy::suspicious_else_formatting)]
6341 let non_field_children = {
6342 let mut cursor = node.walk();
6343 let mut result = ::std::vec::Vec::new();
6344 if cursor.goto_first_child() {
6345 loop {
6346 if cursor.field_name().is_none()
6347 && cursor.node().is_named()
6348 && !cursor.node().is_extra()
6349 {
6350 result.push(cursor.node());
6351 }
6352 if !cursor.goto_next_sibling() {
6353 break;
6354 }
6355 }
6356 }
6357 result
6358 };
6359 let mut items = ::std::vec::Vec::new();
6360 for child in non_field_children {
6361 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6362 <LambdaCaptureSpecifierChildren as ::treesitter_types::FromNode>::from_node(
6363 child, src,
6364 )
6365 })?);
6366 }
6367 items
6368 },
6369 })
6370 }
6371}
6372impl ::treesitter_types::Spanned for LambdaCaptureSpecifier<'_> {
6373 fn span(&self) -> ::treesitter_types::Span {
6374 self.span
6375 }
6376}
6377#[derive(Debug, Clone, PartialEq, Eq)]
6378pub struct LambdaDefaultCapture<'tree> {
6379 pub span: ::treesitter_types::Span,
6380 text: &'tree str,
6381}
6382impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaDefaultCapture<'tree> {
6383 fn from_node(
6384 node: ::treesitter_types::tree_sitter::Node<'tree>,
6385 src: &'tree [u8],
6386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6387 debug_assert_eq!(node.kind(), "lambda_default_capture");
6388 Ok(Self {
6389 span: ::treesitter_types::Span::from(node),
6390 text: node.utf8_text(src)?,
6391 })
6392 }
6393}
6394impl<'tree> ::treesitter_types::LeafNode<'tree> for LambdaDefaultCapture<'tree> {
6395 fn text(&self) -> &'tree str {
6396 self.text
6397 }
6398}
6399impl ::treesitter_types::Spanned for LambdaDefaultCapture<'_> {
6400 fn span(&self) -> ::treesitter_types::Span {
6401 self.span
6402 }
6403}
6404#[derive(Debug, Clone, PartialEq, Eq)]
6405pub struct LambdaExpression<'tree> {
6406 pub span: ::treesitter_types::Span,
6407 pub body: CompoundStatement<'tree>,
6408 pub captures: LambdaCaptureSpecifier<'tree>,
6409 pub constraint: ::core::option::Option<RequiresClause<'tree>>,
6410 pub declarator: ::core::option::Option<AbstractFunctionDeclarator<'tree>>,
6411 pub template_parameters: ::core::option::Option<TemplateParameterList<'tree>>,
6412}
6413impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
6414 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6415 fn from_node(
6416 node: ::treesitter_types::tree_sitter::Node<'tree>,
6417 src: &'tree [u8],
6418 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6419 debug_assert_eq!(node.kind(), "lambda_expression");
6420 Ok(Self {
6421 span: ::treesitter_types::Span::from(node),
6422 body: {
6423 let child = node
6424 .child_by_field_name("body")
6425 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6426 ::treesitter_types::runtime::maybe_grow_stack(|| {
6427 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
6428 })?
6429 },
6430 captures: {
6431 let child = node.child_by_field_name("captures").ok_or_else(|| {
6432 ::treesitter_types::ParseError::missing_field("captures", node)
6433 })?;
6434 ::treesitter_types::runtime::maybe_grow_stack(|| {
6435 <LambdaCaptureSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
6436 })?
6437 },
6438 constraint: match node.child_by_field_name("constraint") {
6439 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6440 <RequiresClause as ::treesitter_types::FromNode>::from_node(child, src)
6441 })?),
6442 None => None,
6443 },
6444 declarator: match node.child_by_field_name("declarator") {
6445 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6446 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
6447 child, src,
6448 )
6449 })?),
6450 None => None,
6451 },
6452 template_parameters: match node.child_by_field_name("template_parameters") {
6453 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6454 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)
6455 })?),
6456 None => None,
6457 },
6458 })
6459 }
6460}
6461impl ::treesitter_types::Spanned for LambdaExpression<'_> {
6462 fn span(&self) -> ::treesitter_types::Span {
6463 self.span
6464 }
6465}
6466#[derive(Debug, Clone, PartialEq, Eq)]
6467pub struct LinkageSpecification<'tree> {
6468 pub span: ::treesitter_types::Span,
6469 pub body: LinkageSpecificationBody<'tree>,
6470 pub value: StringLiteral<'tree>,
6471}
6472impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecification<'tree> {
6473 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6474 fn from_node(
6475 node: ::treesitter_types::tree_sitter::Node<'tree>,
6476 src: &'tree [u8],
6477 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6478 debug_assert_eq!(node.kind(), "linkage_specification");
6479 Ok(Self {
6480 span: ::treesitter_types::Span::from(node),
6481 body: {
6482 let child = node
6483 .child_by_field_name("body")
6484 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6485 ::treesitter_types::runtime::maybe_grow_stack(|| {
6486 <LinkageSpecificationBody as ::treesitter_types::FromNode>::from_node(
6487 child, src,
6488 )
6489 })?
6490 },
6491 value: {
6492 let child = node
6493 .child_by_field_name("value")
6494 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6495 ::treesitter_types::runtime::maybe_grow_stack(|| {
6496 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)
6497 })?
6498 },
6499 })
6500 }
6501}
6502impl ::treesitter_types::Spanned for LinkageSpecification<'_> {
6503 fn span(&self) -> ::treesitter_types::Span {
6504 self.span
6505 }
6506}
6507#[derive(Debug, Clone, PartialEq, Eq)]
6508pub struct MsBasedModifier<'tree> {
6509 pub span: ::treesitter_types::Span,
6510 pub children: ArgumentList<'tree>,
6511}
6512impl<'tree> ::treesitter_types::FromNode<'tree> for MsBasedModifier<'tree> {
6513 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6514 fn from_node(
6515 node: ::treesitter_types::tree_sitter::Node<'tree>,
6516 src: &'tree [u8],
6517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6518 debug_assert_eq!(node.kind(), "ms_based_modifier");
6519 Ok(Self {
6520 span: ::treesitter_types::Span::from(node),
6521 children: {
6522 #[allow(clippy::suspicious_else_formatting)]
6523 let non_field_children = {
6524 let mut cursor = node.walk();
6525 let mut result = ::std::vec::Vec::new();
6526 if cursor.goto_first_child() {
6527 loop {
6528 if cursor.field_name().is_none()
6529 && cursor.node().is_named()
6530 && !cursor.node().is_extra()
6531 {
6532 result.push(cursor.node());
6533 }
6534 if !cursor.goto_next_sibling() {
6535 break;
6536 }
6537 }
6538 }
6539 result
6540 };
6541 let child = if let Some(&c) = non_field_children.first() {
6542 c
6543 } else {
6544 let mut fallback_cursor = node.walk();
6545 let mut fallback_child = None;
6546 if fallback_cursor.goto_first_child() {
6547 loop {
6548 if fallback_cursor.field_name().is_none()
6549 && !fallback_cursor.node().is_extra()
6550 {
6551 let candidate = fallback_cursor.node();
6552 #[allow(clippy::needless_question_mark)]
6553 if (|| -> ::core::result::Result<
6554 _,
6555 ::treesitter_types::ParseError,
6556 > {
6557 let child = candidate;
6558 Ok(
6559 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
6560 child,
6561 src,
6562 ))?,
6563 )
6564 })()
6565 .is_ok()
6566 {
6567 fallback_child = Some(candidate);
6568 break;
6569 }
6570 }
6571 if !fallback_cursor.goto_next_sibling() {
6572 break;
6573 }
6574 }
6575 }
6576 if fallback_child.is_none() {
6577 let mut cursor2 = node.walk();
6578 if cursor2.goto_first_child() {
6579 loop {
6580 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6581 let candidate = cursor2.node();
6582 #[allow(clippy::needless_question_mark)]
6583 if (|| -> ::core::result::Result<
6584 _,
6585 ::treesitter_types::ParseError,
6586 > {
6587 let child = candidate;
6588 Ok(
6589 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
6590 child,
6591 src,
6592 ))?,
6593 )
6594 })()
6595 .is_ok()
6596 {
6597 fallback_child = Some(candidate);
6598 break;
6599 }
6600 }
6601 if !cursor2.goto_next_sibling() {
6602 break;
6603 }
6604 }
6605 }
6606 }
6607 fallback_child.ok_or_else(|| {
6608 ::treesitter_types::ParseError::missing_field("children", node)
6609 })?
6610 };
6611 ::treesitter_types::runtime::maybe_grow_stack(|| {
6612 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
6613 })?
6614 },
6615 })
6616 }
6617}
6618impl ::treesitter_types::Spanned for MsBasedModifier<'_> {
6619 fn span(&self) -> ::treesitter_types::Span {
6620 self.span
6621 }
6622}
6623#[derive(Debug, Clone, PartialEq, Eq)]
6624pub struct MsCallModifier<'tree> {
6625 pub span: ::treesitter_types::Span,
6626 text: &'tree str,
6627}
6628impl<'tree> ::treesitter_types::FromNode<'tree> for MsCallModifier<'tree> {
6629 fn from_node(
6630 node: ::treesitter_types::tree_sitter::Node<'tree>,
6631 src: &'tree [u8],
6632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6633 debug_assert_eq!(node.kind(), "ms_call_modifier");
6634 Ok(Self {
6635 span: ::treesitter_types::Span::from(node),
6636 text: node.utf8_text(src)?,
6637 })
6638 }
6639}
6640impl<'tree> ::treesitter_types::LeafNode<'tree> for MsCallModifier<'tree> {
6641 fn text(&self) -> &'tree str {
6642 self.text
6643 }
6644}
6645impl ::treesitter_types::Spanned for MsCallModifier<'_> {
6646 fn span(&self) -> ::treesitter_types::Span {
6647 self.span
6648 }
6649}
6650#[derive(Debug, Clone, PartialEq, Eq)]
6651pub struct MsDeclspecModifier<'tree> {
6652 pub span: ::treesitter_types::Span,
6653 pub children: Identifier<'tree>,
6654}
6655impl<'tree> ::treesitter_types::FromNode<'tree> for MsDeclspecModifier<'tree> {
6656 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6657 fn from_node(
6658 node: ::treesitter_types::tree_sitter::Node<'tree>,
6659 src: &'tree [u8],
6660 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6661 debug_assert_eq!(node.kind(), "ms_declspec_modifier");
6662 Ok(Self {
6663 span: ::treesitter_types::Span::from(node),
6664 children: {
6665 #[allow(clippy::suspicious_else_formatting)]
6666 let non_field_children = {
6667 let mut cursor = node.walk();
6668 let mut result = ::std::vec::Vec::new();
6669 if cursor.goto_first_child() {
6670 loop {
6671 if cursor.field_name().is_none()
6672 && cursor.node().is_named()
6673 && !cursor.node().is_extra()
6674 {
6675 result.push(cursor.node());
6676 }
6677 if !cursor.goto_next_sibling() {
6678 break;
6679 }
6680 }
6681 }
6682 result
6683 };
6684 let child = if let Some(&c) = non_field_children.first() {
6685 c
6686 } else {
6687 let mut fallback_cursor = node.walk();
6688 let mut fallback_child = None;
6689 if fallback_cursor.goto_first_child() {
6690 loop {
6691 if fallback_cursor.field_name().is_none()
6692 && !fallback_cursor.node().is_extra()
6693 {
6694 let candidate = fallback_cursor.node();
6695 #[allow(clippy::needless_question_mark)]
6696 if (|| -> ::core::result::Result<
6697 _,
6698 ::treesitter_types::ParseError,
6699 > {
6700 let child = candidate;
6701 Ok(
6702 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
6703 child,
6704 src,
6705 ))?,
6706 )
6707 })()
6708 .is_ok()
6709 {
6710 fallback_child = Some(candidate);
6711 break;
6712 }
6713 }
6714 if !fallback_cursor.goto_next_sibling() {
6715 break;
6716 }
6717 }
6718 }
6719 if fallback_child.is_none() {
6720 let mut cursor2 = node.walk();
6721 if cursor2.goto_first_child() {
6722 loop {
6723 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6724 let candidate = cursor2.node();
6725 #[allow(clippy::needless_question_mark)]
6726 if (|| -> ::core::result::Result<
6727 _,
6728 ::treesitter_types::ParseError,
6729 > {
6730 let child = candidate;
6731 Ok(
6732 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
6733 child,
6734 src,
6735 ))?,
6736 )
6737 })()
6738 .is_ok()
6739 {
6740 fallback_child = Some(candidate);
6741 break;
6742 }
6743 }
6744 if !cursor2.goto_next_sibling() {
6745 break;
6746 }
6747 }
6748 }
6749 }
6750 fallback_child.ok_or_else(|| {
6751 ::treesitter_types::ParseError::missing_field("children", node)
6752 })?
6753 };
6754 ::treesitter_types::runtime::maybe_grow_stack(|| {
6755 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
6756 })?
6757 },
6758 })
6759 }
6760}
6761impl ::treesitter_types::Spanned for MsDeclspecModifier<'_> {
6762 fn span(&self) -> ::treesitter_types::Span {
6763 self.span
6764 }
6765}
6766#[derive(Debug, Clone, PartialEq, Eq)]
6767pub struct MsPointerModifier<'tree> {
6768 pub span: ::treesitter_types::Span,
6769 pub children: MsPointerModifierChildren<'tree>,
6770}
6771impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifier<'tree> {
6772 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6773 fn from_node(
6774 node: ::treesitter_types::tree_sitter::Node<'tree>,
6775 src: &'tree [u8],
6776 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6777 debug_assert_eq!(node.kind(), "ms_pointer_modifier");
6778 Ok(Self {
6779 span: ::treesitter_types::Span::from(node),
6780 children: {
6781 #[allow(clippy::suspicious_else_formatting)]
6782 let non_field_children = {
6783 let mut cursor = node.walk();
6784 let mut result = ::std::vec::Vec::new();
6785 if cursor.goto_first_child() {
6786 loop {
6787 if cursor.field_name().is_none()
6788 && cursor.node().is_named()
6789 && !cursor.node().is_extra()
6790 {
6791 result.push(cursor.node());
6792 }
6793 if !cursor.goto_next_sibling() {
6794 break;
6795 }
6796 }
6797 }
6798 result
6799 };
6800 let child = if let Some(&c) = non_field_children.first() {
6801 c
6802 } else {
6803 let mut fallback_cursor = node.walk();
6804 let mut fallback_child = None;
6805 if fallback_cursor.goto_first_child() {
6806 loop {
6807 if fallback_cursor.field_name().is_none()
6808 && !fallback_cursor.node().is_extra()
6809 {
6810 let candidate = fallback_cursor.node();
6811 #[allow(clippy::needless_question_mark)]
6812 if (|| -> ::core::result::Result<
6813 _,
6814 ::treesitter_types::ParseError,
6815 > {
6816 let child = candidate;
6817 Ok(
6818 ::treesitter_types::runtime::maybe_grow_stack(|| <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
6819 child,
6820 src,
6821 ))?,
6822 )
6823 })()
6824 .is_ok()
6825 {
6826 fallback_child = Some(candidate);
6827 break;
6828 }
6829 }
6830 if !fallback_cursor.goto_next_sibling() {
6831 break;
6832 }
6833 }
6834 }
6835 if fallback_child.is_none() {
6836 let mut cursor2 = node.walk();
6837 if cursor2.goto_first_child() {
6838 loop {
6839 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6840 let candidate = cursor2.node();
6841 #[allow(clippy::needless_question_mark)]
6842 if (|| -> ::core::result::Result<
6843 _,
6844 ::treesitter_types::ParseError,
6845 > {
6846 let child = candidate;
6847 Ok(
6848 ::treesitter_types::runtime::maybe_grow_stack(|| <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
6849 child,
6850 src,
6851 ))?,
6852 )
6853 })()
6854 .is_ok()
6855 {
6856 fallback_child = Some(candidate);
6857 break;
6858 }
6859 }
6860 if !cursor2.goto_next_sibling() {
6861 break;
6862 }
6863 }
6864 }
6865 }
6866 fallback_child.ok_or_else(|| {
6867 ::treesitter_types::ParseError::missing_field("children", node)
6868 })?
6869 };
6870 ::treesitter_types::runtime::maybe_grow_stack(|| {
6871 <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
6872 child, src,
6873 )
6874 })?
6875 },
6876 })
6877 }
6878}
6879impl ::treesitter_types::Spanned for MsPointerModifier<'_> {
6880 fn span(&self) -> ::treesitter_types::Span {
6881 self.span
6882 }
6883}
6884#[derive(Debug, Clone, PartialEq, Eq)]
6885pub struct MsUnalignedPtrModifier<'tree> {
6886 pub span: ::treesitter_types::Span,
6887 text: &'tree str,
6888}
6889impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnalignedPtrModifier<'tree> {
6890 fn from_node(
6891 node: ::treesitter_types::tree_sitter::Node<'tree>,
6892 src: &'tree [u8],
6893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6894 debug_assert_eq!(node.kind(), "ms_unaligned_ptr_modifier");
6895 Ok(Self {
6896 span: ::treesitter_types::Span::from(node),
6897 text: node.utf8_text(src)?,
6898 })
6899 }
6900}
6901impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnalignedPtrModifier<'tree> {
6902 fn text(&self) -> &'tree str {
6903 self.text
6904 }
6905}
6906impl ::treesitter_types::Spanned for MsUnalignedPtrModifier<'_> {
6907 fn span(&self) -> ::treesitter_types::Span {
6908 self.span
6909 }
6910}
6911#[derive(Debug, Clone, PartialEq, Eq)]
6912pub struct NamespaceAliasDefinition<'tree> {
6913 pub span: ::treesitter_types::Span,
6914 pub name: NamespaceIdentifier<'tree>,
6915 pub children: NamespaceAliasDefinitionChildren<'tree>,
6916}
6917impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceAliasDefinition<'tree> {
6918 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6919 fn from_node(
6920 node: ::treesitter_types::tree_sitter::Node<'tree>,
6921 src: &'tree [u8],
6922 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6923 debug_assert_eq!(node.kind(), "namespace_alias_definition");
6924 Ok(Self {
6925 span: ::treesitter_types::Span::from(node),
6926 name: {
6927 let child = node
6928 .child_by_field_name("name")
6929 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6930 ::treesitter_types::runtime::maybe_grow_stack(|| {
6931 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
6932 })?
6933 },
6934 children: {
6935 #[allow(clippy::suspicious_else_formatting)]
6936 let non_field_children = {
6937 let mut cursor = node.walk();
6938 let mut result = ::std::vec::Vec::new();
6939 if cursor.goto_first_child() {
6940 loop {
6941 if cursor.field_name().is_none()
6942 && cursor.node().is_named()
6943 && !cursor.node().is_extra()
6944 {
6945 result.push(cursor.node());
6946 }
6947 if !cursor.goto_next_sibling() {
6948 break;
6949 }
6950 }
6951 }
6952 result
6953 };
6954 let child = if let Some(&c) = non_field_children.first() {
6955 c
6956 } else {
6957 let mut fallback_cursor = node.walk();
6958 let mut fallback_child = None;
6959 if fallback_cursor.goto_first_child() {
6960 loop {
6961 if fallback_cursor.field_name().is_none()
6962 && !fallback_cursor.node().is_extra()
6963 {
6964 let candidate = fallback_cursor.node();
6965 #[allow(clippy::needless_question_mark)]
6966 if (|| -> ::core::result::Result<
6967 _,
6968 ::treesitter_types::ParseError,
6969 > {
6970 let child = candidate;
6971 Ok(
6972 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6973 child,
6974 src,
6975 ))?,
6976 )
6977 })()
6978 .is_ok()
6979 {
6980 fallback_child = Some(candidate);
6981 break;
6982 }
6983 }
6984 if !fallback_cursor.goto_next_sibling() {
6985 break;
6986 }
6987 }
6988 }
6989 if fallback_child.is_none() {
6990 let mut cursor2 = node.walk();
6991 if cursor2.goto_first_child() {
6992 loop {
6993 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6994 let candidate = cursor2.node();
6995 #[allow(clippy::needless_question_mark)]
6996 if (|| -> ::core::result::Result<
6997 _,
6998 ::treesitter_types::ParseError,
6999 > {
7000 let child = candidate;
7001 Ok(
7002 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
7003 child,
7004 src,
7005 ))?,
7006 )
7007 })()
7008 .is_ok()
7009 {
7010 fallback_child = Some(candidate);
7011 break;
7012 }
7013 }
7014 if !cursor2.goto_next_sibling() {
7015 break;
7016 }
7017 }
7018 }
7019 }
7020 fallback_child.ok_or_else(|| {
7021 ::treesitter_types::ParseError::missing_field("children", node)
7022 })?
7023 };
7024 ::treesitter_types::runtime::maybe_grow_stack(|| {
7025 <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
7026 child, src,
7027 )
7028 })?
7029 },
7030 })
7031 }
7032}
7033impl ::treesitter_types::Spanned for NamespaceAliasDefinition<'_> {
7034 fn span(&self) -> ::treesitter_types::Span {
7035 self.span
7036 }
7037}
7038#[derive(Debug, Clone, PartialEq, Eq)]
7039pub struct NamespaceDefinition<'tree> {
7040 pub span: ::treesitter_types::Span,
7041 pub body: DeclarationList<'tree>,
7042 pub name: ::core::option::Option<NamespaceDefinitionName<'tree>>,
7043 pub children: ::core::option::Option<AttributeDeclaration<'tree>>,
7044}
7045impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinition<'tree> {
7046 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7047 fn from_node(
7048 node: ::treesitter_types::tree_sitter::Node<'tree>,
7049 src: &'tree [u8],
7050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7051 debug_assert_eq!(node.kind(), "namespace_definition");
7052 Ok(Self {
7053 span: ::treesitter_types::Span::from(node),
7054 body: {
7055 let child = node
7056 .child_by_field_name("body")
7057 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7058 ::treesitter_types::runtime::maybe_grow_stack(|| {
7059 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
7060 })?
7061 },
7062 name: match node.child_by_field_name("name") {
7063 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7064 <NamespaceDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)
7065 })?),
7066 None => None,
7067 },
7068 children: {
7069 #[allow(clippy::suspicious_else_formatting)]
7070 let non_field_children = {
7071 let mut cursor = node.walk();
7072 let mut result = ::std::vec::Vec::new();
7073 if cursor.goto_first_child() {
7074 loop {
7075 if cursor.field_name().is_none()
7076 && cursor.node().is_named()
7077 && !cursor.node().is_extra()
7078 {
7079 result.push(cursor.node());
7080 }
7081 if !cursor.goto_next_sibling() {
7082 break;
7083 }
7084 }
7085 }
7086 result
7087 };
7088 match non_field_children.first() {
7089 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7090 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(
7091 child, src,
7092 )
7093 })?),
7094 None => None,
7095 }
7096 },
7097 })
7098 }
7099}
7100impl ::treesitter_types::Spanned for NamespaceDefinition<'_> {
7101 fn span(&self) -> ::treesitter_types::Span {
7102 self.span
7103 }
7104}
7105#[derive(Debug, Clone, PartialEq, Eq)]
7106pub struct NestedNamespaceSpecifier<'tree> {
7107 pub span: ::treesitter_types::Span,
7108 pub children: ::std::vec::Vec<NestedNamespaceSpecifierChildren<'tree>>,
7109}
7110impl<'tree> ::treesitter_types::FromNode<'tree> for NestedNamespaceSpecifier<'tree> {
7111 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7112 fn from_node(
7113 node: ::treesitter_types::tree_sitter::Node<'tree>,
7114 src: &'tree [u8],
7115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7116 debug_assert_eq!(node.kind(), "nested_namespace_specifier");
7117 Ok(Self {
7118 span: ::treesitter_types::Span::from(node),
7119 children: {
7120 #[allow(clippy::suspicious_else_formatting)]
7121 let non_field_children = {
7122 let mut cursor = node.walk();
7123 let mut result = ::std::vec::Vec::new();
7124 if cursor.goto_first_child() {
7125 loop {
7126 if cursor.field_name().is_none()
7127 && cursor.node().is_named()
7128 && !cursor.node().is_extra()
7129 {
7130 result.push(cursor.node());
7131 }
7132 if !cursor.goto_next_sibling() {
7133 break;
7134 }
7135 }
7136 }
7137 result
7138 };
7139 let mut items = ::std::vec::Vec::new();
7140 for child in non_field_children {
7141 items
7142 .push(
7143 ::treesitter_types::runtime::maybe_grow_stack(|| <NestedNamespaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
7144 child,
7145 src,
7146 ))?,
7147 );
7148 }
7149 items
7150 },
7151 })
7152 }
7153}
7154impl ::treesitter_types::Spanned for NestedNamespaceSpecifier<'_> {
7155 fn span(&self) -> ::treesitter_types::Span {
7156 self.span
7157 }
7158}
7159#[derive(Debug, Clone, PartialEq, Eq)]
7160pub struct NewDeclarator<'tree> {
7161 pub span: ::treesitter_types::Span,
7162 pub length: Expression<'tree>,
7163 pub children: ::core::option::Option<::std::boxed::Box<NewDeclarator<'tree>>>,
7164}
7165impl<'tree> ::treesitter_types::FromNode<'tree> for NewDeclarator<'tree> {
7166 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7167 fn from_node(
7168 node: ::treesitter_types::tree_sitter::Node<'tree>,
7169 src: &'tree [u8],
7170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7171 debug_assert_eq!(node.kind(), "new_declarator");
7172 Ok(Self {
7173 span: ::treesitter_types::Span::from(node),
7174 length: {
7175 let child = node
7176 .child_by_field_name("length")
7177 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("length", node))?;
7178 ::treesitter_types::runtime::maybe_grow_stack(|| {
7179 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7180 })?
7181 },
7182 children: {
7183 #[allow(clippy::suspicious_else_formatting)]
7184 let non_field_children = {
7185 let mut cursor = node.walk();
7186 let mut result = ::std::vec::Vec::new();
7187 if cursor.goto_first_child() {
7188 loop {
7189 if cursor.field_name().is_none()
7190 && cursor.node().is_named()
7191 && !cursor.node().is_extra()
7192 {
7193 result.push(cursor.node());
7194 }
7195 if !cursor.goto_next_sibling() {
7196 break;
7197 }
7198 }
7199 }
7200 result
7201 };
7202 match non_field_children.first() {
7203 Some(&child) => Some(::std::boxed::Box::new(
7204 ::treesitter_types::runtime::maybe_grow_stack(|| {
7205 <NewDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
7206 })?,
7207 )),
7208 None => None,
7209 }
7210 },
7211 })
7212 }
7213}
7214impl ::treesitter_types::Spanned for NewDeclarator<'_> {
7215 fn span(&self) -> ::treesitter_types::Span {
7216 self.span
7217 }
7218}
7219#[derive(Debug, Clone, PartialEq, Eq)]
7220pub struct NewExpression<'tree> {
7221 pub span: ::treesitter_types::Span,
7222 pub arguments: ::core::option::Option<NewExpressionArguments<'tree>>,
7223 pub declarator: ::core::option::Option<NewDeclarator<'tree>>,
7224 pub placement: ::core::option::Option<ArgumentList<'tree>>,
7225 pub r#type: TypeSpecifier<'tree>,
7226}
7227impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
7228 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7229 fn from_node(
7230 node: ::treesitter_types::tree_sitter::Node<'tree>,
7231 src: &'tree [u8],
7232 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7233 debug_assert_eq!(node.kind(), "new_expression");
7234 Ok(Self {
7235 span: ::treesitter_types::Span::from(node),
7236 arguments: match node.child_by_field_name("arguments") {
7237 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7238 <NewExpressionArguments as ::treesitter_types::FromNode>::from_node(child, src)
7239 })?),
7240 None => None,
7241 },
7242 declarator: match node.child_by_field_name("declarator") {
7243 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7244 <NewDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
7245 })?),
7246 None => None,
7247 },
7248 placement: match node.child_by_field_name("placement") {
7249 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7250 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
7251 })?),
7252 None => None,
7253 },
7254 r#type: {
7255 let child = node
7256 .child_by_field_name("type")
7257 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7258 ::treesitter_types::runtime::maybe_grow_stack(|| {
7259 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7260 })?
7261 },
7262 })
7263 }
7264}
7265impl ::treesitter_types::Spanned for NewExpression<'_> {
7266 fn span(&self) -> ::treesitter_types::Span {
7267 self.span
7268 }
7269}
7270#[derive(Debug, Clone, PartialEq, Eq)]
7271pub struct Noexcept<'tree> {
7272 pub span: ::treesitter_types::Span,
7273 pub children: ::core::option::Option<Expression<'tree>>,
7274}
7275impl<'tree> ::treesitter_types::FromNode<'tree> for Noexcept<'tree> {
7276 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7277 fn from_node(
7278 node: ::treesitter_types::tree_sitter::Node<'tree>,
7279 src: &'tree [u8],
7280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7281 debug_assert_eq!(node.kind(), "noexcept");
7282 Ok(Self {
7283 span: ::treesitter_types::Span::from(node),
7284 children: {
7285 #[allow(clippy::suspicious_else_formatting)]
7286 let non_field_children = {
7287 let mut cursor = node.walk();
7288 let mut result = ::std::vec::Vec::new();
7289 if cursor.goto_first_child() {
7290 loop {
7291 if cursor.field_name().is_none()
7292 && cursor.node().is_named()
7293 && !cursor.node().is_extra()
7294 {
7295 result.push(cursor.node());
7296 }
7297 if !cursor.goto_next_sibling() {
7298 break;
7299 }
7300 }
7301 }
7302 result
7303 };
7304 match non_field_children.first() {
7305 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7306 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7307 })?),
7308 None => None,
7309 }
7310 },
7311 })
7312 }
7313}
7314impl ::treesitter_types::Spanned for Noexcept<'_> {
7315 fn span(&self) -> ::treesitter_types::Span {
7316 self.span
7317 }
7318}
7319#[derive(Debug, Clone, PartialEq, Eq)]
7320pub struct Null<'tree> {
7321 pub span: ::treesitter_types::Span,
7322 text: &'tree str,
7323}
7324impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
7325 fn from_node(
7326 node: ::treesitter_types::tree_sitter::Node<'tree>,
7327 src: &'tree [u8],
7328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7329 debug_assert_eq!(node.kind(), "null");
7330 Ok(Self {
7331 span: ::treesitter_types::Span::from(node),
7332 text: node.utf8_text(src)?,
7333 })
7334 }
7335}
7336impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
7337 fn text(&self) -> &'tree str {
7338 self.text
7339 }
7340}
7341impl ::treesitter_types::Spanned for Null<'_> {
7342 fn span(&self) -> ::treesitter_types::Span {
7343 self.span
7344 }
7345}
7346#[derive(Debug, Clone, PartialEq, Eq)]
7347pub struct OffsetofExpression<'tree> {
7348 pub span: ::treesitter_types::Span,
7349 pub member: FieldIdentifier<'tree>,
7350 pub r#type: TypeDescriptor<'tree>,
7351}
7352impl<'tree> ::treesitter_types::FromNode<'tree> for OffsetofExpression<'tree> {
7353 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7354 fn from_node(
7355 node: ::treesitter_types::tree_sitter::Node<'tree>,
7356 src: &'tree [u8],
7357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7358 debug_assert_eq!(node.kind(), "offsetof_expression");
7359 Ok(Self {
7360 span: ::treesitter_types::Span::from(node),
7361 member: {
7362 let child = node
7363 .child_by_field_name("member")
7364 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("member", node))?;
7365 ::treesitter_types::runtime::maybe_grow_stack(|| {
7366 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
7367 })?
7368 },
7369 r#type: {
7370 let child = node
7371 .child_by_field_name("type")
7372 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7373 ::treesitter_types::runtime::maybe_grow_stack(|| {
7374 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
7375 })?
7376 },
7377 })
7378 }
7379}
7380impl ::treesitter_types::Spanned for OffsetofExpression<'_> {
7381 fn span(&self) -> ::treesitter_types::Span {
7382 self.span
7383 }
7384}
7385#[derive(Debug, Clone, PartialEq, Eq)]
7386pub struct OperatorCast<'tree> {
7387 pub span: ::treesitter_types::Span,
7388 pub declarator: AbstractDeclarator<'tree>,
7389 pub r#type: TypeSpecifier<'tree>,
7390 pub children: ::std::vec::Vec<OperatorCastChildren<'tree>>,
7391}
7392impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorCast<'tree> {
7393 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7394 fn from_node(
7395 node: ::treesitter_types::tree_sitter::Node<'tree>,
7396 src: &'tree [u8],
7397 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7398 debug_assert_eq!(node.kind(), "operator_cast");
7399 Ok(Self {
7400 span: ::treesitter_types::Span::from(node),
7401 declarator: {
7402 let child = node.child_by_field_name("declarator").ok_or_else(|| {
7403 ::treesitter_types::ParseError::missing_field("declarator", node)
7404 })?;
7405 ::treesitter_types::runtime::maybe_grow_stack(|| {
7406 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
7407 })?
7408 },
7409 r#type: {
7410 let child = node
7411 .child_by_field_name("type")
7412 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7413 ::treesitter_types::runtime::maybe_grow_stack(|| {
7414 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7415 })?
7416 },
7417 children: {
7418 #[allow(clippy::suspicious_else_formatting)]
7419 let non_field_children = {
7420 let mut cursor = node.walk();
7421 let mut result = ::std::vec::Vec::new();
7422 if cursor.goto_first_child() {
7423 loop {
7424 if cursor.field_name().is_none()
7425 && cursor.node().is_named()
7426 && !cursor.node().is_extra()
7427 {
7428 result.push(cursor.node());
7429 }
7430 if !cursor.goto_next_sibling() {
7431 break;
7432 }
7433 }
7434 }
7435 result
7436 };
7437 let mut items = ::std::vec::Vec::new();
7438 for child in non_field_children {
7439 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7440 <OperatorCastChildren as ::treesitter_types::FromNode>::from_node(
7441 child, src,
7442 )
7443 })?);
7444 }
7445 items
7446 },
7447 })
7448 }
7449}
7450impl ::treesitter_types::Spanned for OperatorCast<'_> {
7451 fn span(&self) -> ::treesitter_types::Span {
7452 self.span
7453 }
7454}
7455#[derive(Debug, Clone, PartialEq, Eq)]
7456pub struct OperatorName<'tree> {
7457 pub span: ::treesitter_types::Span,
7458 pub children: ::core::option::Option<Identifier<'tree>>,
7459}
7460impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorName<'tree> {
7461 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7462 fn from_node(
7463 node: ::treesitter_types::tree_sitter::Node<'tree>,
7464 src: &'tree [u8],
7465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7466 debug_assert_eq!(node.kind(), "operator_name");
7467 Ok(Self {
7468 span: ::treesitter_types::Span::from(node),
7469 children: {
7470 #[allow(clippy::suspicious_else_formatting)]
7471 let non_field_children = {
7472 let mut cursor = node.walk();
7473 let mut result = ::std::vec::Vec::new();
7474 if cursor.goto_first_child() {
7475 loop {
7476 if cursor.field_name().is_none()
7477 && cursor.node().is_named()
7478 && !cursor.node().is_extra()
7479 {
7480 result.push(cursor.node());
7481 }
7482 if !cursor.goto_next_sibling() {
7483 break;
7484 }
7485 }
7486 }
7487 result
7488 };
7489 match non_field_children.first() {
7490 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7491 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
7492 })?),
7493 None => None,
7494 }
7495 },
7496 })
7497 }
7498}
7499impl ::treesitter_types::Spanned for OperatorName<'_> {
7500 fn span(&self) -> ::treesitter_types::Span {
7501 self.span
7502 }
7503}
7504#[derive(Debug, Clone, PartialEq, Eq)]
7505pub struct OptionalParameterDeclaration<'tree> {
7506 pub span: ::treesitter_types::Span,
7507 pub declarator: ::core::option::Option<OptionalParameterDeclarationDeclarator<'tree>>,
7508 pub default_value: Expression<'tree>,
7509 pub r#type: TypeSpecifier<'tree>,
7510 pub children: ::std::vec::Vec<OptionalParameterDeclarationChildren<'tree>>,
7511}
7512impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclaration<'tree> {
7513 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7514 fn from_node(
7515 node: ::treesitter_types::tree_sitter::Node<'tree>,
7516 src: &'tree [u8],
7517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7518 debug_assert_eq!(node.kind(), "optional_parameter_declaration");
7519 Ok(Self {
7520 span: ::treesitter_types::Span::from(node),
7521 declarator: match node.child_by_field_name("declarator") {
7522 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7523 <OptionalParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
7524 child,
7525 src,
7526 )
7527 })?),
7528 None => None,
7529 },
7530 default_value: {
7531 let child = node.child_by_field_name("default_value").ok_or_else(|| {
7532 ::treesitter_types::ParseError::missing_field("default_value", node)
7533 })?;
7534 ::treesitter_types::runtime::maybe_grow_stack(|| {
7535 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7536 })?
7537 },
7538 r#type: {
7539 let child = node
7540 .child_by_field_name("type")
7541 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7542 ::treesitter_types::runtime::maybe_grow_stack(|| {
7543 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7544 })?
7545 },
7546 children: {
7547 #[allow(clippy::suspicious_else_formatting)]
7548 let non_field_children = {
7549 let mut cursor = node.walk();
7550 let mut result = ::std::vec::Vec::new();
7551 if cursor.goto_first_child() {
7552 loop {
7553 if cursor.field_name().is_none()
7554 && cursor.node().is_named()
7555 && !cursor.node().is_extra()
7556 {
7557 result.push(cursor.node());
7558 }
7559 if !cursor.goto_next_sibling() {
7560 break;
7561 }
7562 }
7563 }
7564 result
7565 };
7566 let mut items = ::std::vec::Vec::new();
7567 for child in non_field_children {
7568 items
7569 .push(
7570 ::treesitter_types::runtime::maybe_grow_stack(|| <OptionalParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7571 child,
7572 src,
7573 ))?,
7574 );
7575 }
7576 items
7577 },
7578 })
7579 }
7580}
7581impl ::treesitter_types::Spanned for OptionalParameterDeclaration<'_> {
7582 fn span(&self) -> ::treesitter_types::Span {
7583 self.span
7584 }
7585}
7586#[derive(Debug, Clone, PartialEq, Eq)]
7587pub struct OptionalTypeParameterDeclaration<'tree> {
7588 pub span: ::treesitter_types::Span,
7589 pub default_type: TypeSpecifier<'tree>,
7590 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
7591}
7592impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalTypeParameterDeclaration<'tree> {
7593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7594 fn from_node(
7595 node: ::treesitter_types::tree_sitter::Node<'tree>,
7596 src: &'tree [u8],
7597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7598 debug_assert_eq!(node.kind(), "optional_type_parameter_declaration");
7599 Ok(Self {
7600 span: ::treesitter_types::Span::from(node),
7601 default_type: {
7602 let child = node.child_by_field_name("default_type").ok_or_else(|| {
7603 ::treesitter_types::ParseError::missing_field("default_type", node)
7604 })?;
7605 ::treesitter_types::runtime::maybe_grow_stack(|| {
7606 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7607 })?
7608 },
7609 name: match node.child_by_field_name("name") {
7610 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7611 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
7612 })?),
7613 None => None,
7614 },
7615 })
7616 }
7617}
7618impl ::treesitter_types::Spanned for OptionalTypeParameterDeclaration<'_> {
7619 fn span(&self) -> ::treesitter_types::Span {
7620 self.span
7621 }
7622}
7623#[derive(Debug, Clone, PartialEq, Eq)]
7624pub struct ParameterDeclaration<'tree> {
7625 pub span: ::treesitter_types::Span,
7626 pub declarator: ::core::option::Option<ParameterDeclarationDeclarator<'tree>>,
7627 pub r#type: TypeSpecifier<'tree>,
7628 pub children: ::std::vec::Vec<ParameterDeclarationChildren<'tree>>,
7629}
7630impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclaration<'tree> {
7631 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7632 fn from_node(
7633 node: ::treesitter_types::tree_sitter::Node<'tree>,
7634 src: &'tree [u8],
7635 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7636 debug_assert_eq!(node.kind(), "parameter_declaration");
7637 Ok(Self {
7638 span: ::treesitter_types::Span::from(node),
7639 declarator: match node.child_by_field_name("declarator") {
7640 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7641 <ParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
7642 child, src,
7643 )
7644 })?),
7645 None => None,
7646 },
7647 r#type: {
7648 let child = node
7649 .child_by_field_name("type")
7650 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7651 ::treesitter_types::runtime::maybe_grow_stack(|| {
7652 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7653 })?
7654 },
7655 children: {
7656 #[allow(clippy::suspicious_else_formatting)]
7657 let non_field_children = {
7658 let mut cursor = node.walk();
7659 let mut result = ::std::vec::Vec::new();
7660 if cursor.goto_first_child() {
7661 loop {
7662 if cursor.field_name().is_none()
7663 && cursor.node().is_named()
7664 && !cursor.node().is_extra()
7665 {
7666 result.push(cursor.node());
7667 }
7668 if !cursor.goto_next_sibling() {
7669 break;
7670 }
7671 }
7672 }
7673 result
7674 };
7675 let mut items = ::std::vec::Vec::new();
7676 for child in non_field_children {
7677 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7678 <ParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7679 child, src,
7680 )
7681 })?);
7682 }
7683 items
7684 },
7685 })
7686 }
7687}
7688impl ::treesitter_types::Spanned for ParameterDeclaration<'_> {
7689 fn span(&self) -> ::treesitter_types::Span {
7690 self.span
7691 }
7692}
7693#[derive(Debug, Clone, PartialEq, Eq)]
7694pub struct ParameterList<'tree> {
7695 pub span: ::treesitter_types::Span,
7696 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
7697}
7698impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
7699 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7700 fn from_node(
7701 node: ::treesitter_types::tree_sitter::Node<'tree>,
7702 src: &'tree [u8],
7703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7704 debug_assert_eq!(node.kind(), "parameter_list");
7705 Ok(Self {
7706 span: ::treesitter_types::Span::from(node),
7707 children: {
7708 #[allow(clippy::suspicious_else_formatting)]
7709 let non_field_children = {
7710 let mut cursor = node.walk();
7711 let mut result = ::std::vec::Vec::new();
7712 if cursor.goto_first_child() {
7713 loop {
7714 if cursor.field_name().is_none()
7715 && cursor.node().is_named()
7716 && !cursor.node().is_extra()
7717 {
7718 result.push(cursor.node());
7719 }
7720 if !cursor.goto_next_sibling() {
7721 break;
7722 }
7723 }
7724 }
7725 result
7726 };
7727 let mut items = ::std::vec::Vec::new();
7728 for child in non_field_children {
7729 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7730 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
7731 child, src,
7732 )
7733 })?);
7734 }
7735 items
7736 },
7737 })
7738 }
7739}
7740impl ::treesitter_types::Spanned for ParameterList<'_> {
7741 fn span(&self) -> ::treesitter_types::Span {
7742 self.span
7743 }
7744}
7745#[derive(Debug, Clone, PartialEq, Eq)]
7746pub struct ParameterPackExpansion<'tree> {
7747 pub span: ::treesitter_types::Span,
7748 pub pattern: ParameterPackExpansionPattern<'tree>,
7749}
7750impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPackExpansion<'tree> {
7751 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7752 fn from_node(
7753 node: ::treesitter_types::tree_sitter::Node<'tree>,
7754 src: &'tree [u8],
7755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7756 debug_assert_eq!(node.kind(), "parameter_pack_expansion");
7757 Ok(Self {
7758 span: ::treesitter_types::Span::from(node),
7759 pattern: {
7760 let child = node.child_by_field_name("pattern").ok_or_else(|| {
7761 ::treesitter_types::ParseError::missing_field("pattern", node)
7762 })?;
7763 ::treesitter_types::runtime::maybe_grow_stack(|| {
7764 <ParameterPackExpansionPattern as ::treesitter_types::FromNode>::from_node(
7765 child, src,
7766 )
7767 })?
7768 },
7769 })
7770 }
7771}
7772impl ::treesitter_types::Spanned for ParameterPackExpansion<'_> {
7773 fn span(&self) -> ::treesitter_types::Span {
7774 self.span
7775 }
7776}
7777#[derive(Debug, Clone, PartialEq, Eq)]
7778pub struct ParenthesizedDeclarator<'tree> {
7779 pub span: ::treesitter_types::Span,
7780 pub children: ::std::vec::Vec<ParenthesizedDeclaratorChildren<'tree>>,
7781}
7782impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclarator<'tree> {
7783 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7784 fn from_node(
7785 node: ::treesitter_types::tree_sitter::Node<'tree>,
7786 src: &'tree [u8],
7787 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7788 debug_assert_eq!(node.kind(), "parenthesized_declarator");
7789 Ok(Self {
7790 span: ::treesitter_types::Span::from(node),
7791 children: {
7792 #[allow(clippy::suspicious_else_formatting)]
7793 let non_field_children = {
7794 let mut cursor = node.walk();
7795 let mut result = ::std::vec::Vec::new();
7796 if cursor.goto_first_child() {
7797 loop {
7798 if cursor.field_name().is_none()
7799 && cursor.node().is_named()
7800 && !cursor.node().is_extra()
7801 {
7802 result.push(cursor.node());
7803 }
7804 if !cursor.goto_next_sibling() {
7805 break;
7806 }
7807 }
7808 }
7809 result
7810 };
7811 let mut items = ::std::vec::Vec::new();
7812 for child in non_field_children {
7813 items
7814 .push(
7815 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
7816 child,
7817 src,
7818 ))?,
7819 );
7820 }
7821 items
7822 },
7823 })
7824 }
7825}
7826impl ::treesitter_types::Spanned for ParenthesizedDeclarator<'_> {
7827 fn span(&self) -> ::treesitter_types::Span {
7828 self.span
7829 }
7830}
7831#[derive(Debug, Clone, PartialEq, Eq)]
7832pub struct ParenthesizedExpression<'tree> {
7833 pub span: ::treesitter_types::Span,
7834 pub children: ParenthesizedExpressionChildren<'tree>,
7835}
7836impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
7837 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7838 fn from_node(
7839 node: ::treesitter_types::tree_sitter::Node<'tree>,
7840 src: &'tree [u8],
7841 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7842 debug_assert_eq!(node.kind(), "parenthesized_expression");
7843 Ok(Self {
7844 span: ::treesitter_types::Span::from(node),
7845 children: {
7846 #[allow(clippy::suspicious_else_formatting)]
7847 let non_field_children = {
7848 let mut cursor = node.walk();
7849 let mut result = ::std::vec::Vec::new();
7850 if cursor.goto_first_child() {
7851 loop {
7852 if cursor.field_name().is_none()
7853 && cursor.node().is_named()
7854 && !cursor.node().is_extra()
7855 {
7856 result.push(cursor.node());
7857 }
7858 if !cursor.goto_next_sibling() {
7859 break;
7860 }
7861 }
7862 }
7863 result
7864 };
7865 let child = if let Some(&c) = non_field_children.first() {
7866 c
7867 } else {
7868 let mut fallback_cursor = node.walk();
7869 let mut fallback_child = None;
7870 if fallback_cursor.goto_first_child() {
7871 loop {
7872 if fallback_cursor.field_name().is_none()
7873 && !fallback_cursor.node().is_extra()
7874 {
7875 let candidate = fallback_cursor.node();
7876 #[allow(clippy::needless_question_mark)]
7877 if (|| -> ::core::result::Result<
7878 _,
7879 ::treesitter_types::ParseError,
7880 > {
7881 let child = candidate;
7882 Ok(
7883 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7884 child,
7885 src,
7886 ))?,
7887 )
7888 })()
7889 .is_ok()
7890 {
7891 fallback_child = Some(candidate);
7892 break;
7893 }
7894 }
7895 if !fallback_cursor.goto_next_sibling() {
7896 break;
7897 }
7898 }
7899 }
7900 if fallback_child.is_none() {
7901 let mut cursor2 = node.walk();
7902 if cursor2.goto_first_child() {
7903 loop {
7904 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7905 let candidate = cursor2.node();
7906 #[allow(clippy::needless_question_mark)]
7907 if (|| -> ::core::result::Result<
7908 _,
7909 ::treesitter_types::ParseError,
7910 > {
7911 let child = candidate;
7912 Ok(
7913 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7914 child,
7915 src,
7916 ))?,
7917 )
7918 })()
7919 .is_ok()
7920 {
7921 fallback_child = Some(candidate);
7922 break;
7923 }
7924 }
7925 if !cursor2.goto_next_sibling() {
7926 break;
7927 }
7928 }
7929 }
7930 }
7931 fallback_child.ok_or_else(|| {
7932 ::treesitter_types::ParseError::missing_field("children", node)
7933 })?
7934 };
7935 ::treesitter_types::runtime::maybe_grow_stack(|| {
7936 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7937 child, src,
7938 )
7939 })?
7940 },
7941 })
7942 }
7943}
7944impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
7945 fn span(&self) -> ::treesitter_types::Span {
7946 self.span
7947 }
7948}
7949#[derive(Debug, Clone, PartialEq, Eq)]
7950pub struct PlaceholderTypeSpecifier<'tree> {
7951 pub span: ::treesitter_types::Span,
7952 pub constraint: ::core::option::Option<TypeSpecifier<'tree>>,
7953 pub children: PlaceholderTypeSpecifierChildren<'tree>,
7954}
7955impl<'tree> ::treesitter_types::FromNode<'tree> for PlaceholderTypeSpecifier<'tree> {
7956 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7957 fn from_node(
7958 node: ::treesitter_types::tree_sitter::Node<'tree>,
7959 src: &'tree [u8],
7960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7961 debug_assert_eq!(node.kind(), "placeholder_type_specifier");
7962 Ok(Self {
7963 span: ::treesitter_types::Span::from(node),
7964 constraint: match node.child_by_field_name("constraint") {
7965 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7966 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
7967 })?),
7968 None => None,
7969 },
7970 children: {
7971 #[allow(clippy::suspicious_else_formatting)]
7972 let non_field_children = {
7973 let mut cursor = node.walk();
7974 let mut result = ::std::vec::Vec::new();
7975 if cursor.goto_first_child() {
7976 loop {
7977 if cursor.field_name().is_none()
7978 && cursor.node().is_named()
7979 && !cursor.node().is_extra()
7980 {
7981 result.push(cursor.node());
7982 }
7983 if !cursor.goto_next_sibling() {
7984 break;
7985 }
7986 }
7987 }
7988 result
7989 };
7990 let child = if let Some(&c) = non_field_children.first() {
7991 c
7992 } else {
7993 let mut fallback_cursor = node.walk();
7994 let mut fallback_child = None;
7995 if fallback_cursor.goto_first_child() {
7996 loop {
7997 if fallback_cursor.field_name().is_none()
7998 && !fallback_cursor.node().is_extra()
7999 {
8000 let candidate = fallback_cursor.node();
8001 #[allow(clippy::needless_question_mark)]
8002 if (|| -> ::core::result::Result<
8003 _,
8004 ::treesitter_types::ParseError,
8005 > {
8006 let child = candidate;
8007 Ok(
8008 ::treesitter_types::runtime::maybe_grow_stack(|| <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
8009 child,
8010 src,
8011 ))?,
8012 )
8013 })()
8014 .is_ok()
8015 {
8016 fallback_child = Some(candidate);
8017 break;
8018 }
8019 }
8020 if !fallback_cursor.goto_next_sibling() {
8021 break;
8022 }
8023 }
8024 }
8025 if fallback_child.is_none() {
8026 let mut cursor2 = node.walk();
8027 if cursor2.goto_first_child() {
8028 loop {
8029 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8030 let candidate = cursor2.node();
8031 #[allow(clippy::needless_question_mark)]
8032 if (|| -> ::core::result::Result<
8033 _,
8034 ::treesitter_types::ParseError,
8035 > {
8036 let child = candidate;
8037 Ok(
8038 ::treesitter_types::runtime::maybe_grow_stack(|| <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
8039 child,
8040 src,
8041 ))?,
8042 )
8043 })()
8044 .is_ok()
8045 {
8046 fallback_child = Some(candidate);
8047 break;
8048 }
8049 }
8050 if !cursor2.goto_next_sibling() {
8051 break;
8052 }
8053 }
8054 }
8055 }
8056 fallback_child.ok_or_else(|| {
8057 ::treesitter_types::ParseError::missing_field("children", node)
8058 })?
8059 };
8060 ::treesitter_types::runtime::maybe_grow_stack(|| {
8061 <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
8062 child, src,
8063 )
8064 })?
8065 },
8066 })
8067 }
8068}
8069impl ::treesitter_types::Spanned for PlaceholderTypeSpecifier<'_> {
8070 fn span(&self) -> ::treesitter_types::Span {
8071 self.span
8072 }
8073}
8074#[derive(Debug, Clone, PartialEq, Eq)]
8075pub struct PointerDeclarator<'tree> {
8076 pub span: ::treesitter_types::Span,
8077 pub declarator: PointerDeclaratorDeclarator<'tree>,
8078 pub children: ::std::vec::Vec<PointerDeclaratorChildren<'tree>>,
8079}
8080impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclarator<'tree> {
8081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8082 fn from_node(
8083 node: ::treesitter_types::tree_sitter::Node<'tree>,
8084 src: &'tree [u8],
8085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8086 debug_assert_eq!(node.kind(), "pointer_declarator");
8087 Ok(Self {
8088 span: ::treesitter_types::Span::from(node),
8089 declarator: {
8090 let child = node.child_by_field_name("declarator").ok_or_else(|| {
8091 ::treesitter_types::ParseError::missing_field("declarator", node)
8092 })?;
8093 ::treesitter_types::runtime::maybe_grow_stack(|| {
8094 <PointerDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
8095 child, src,
8096 )
8097 })?
8098 },
8099 children: {
8100 #[allow(clippy::suspicious_else_formatting)]
8101 let non_field_children = {
8102 let mut cursor = node.walk();
8103 let mut result = ::std::vec::Vec::new();
8104 if cursor.goto_first_child() {
8105 loop {
8106 if cursor.field_name().is_none()
8107 && cursor.node().is_named()
8108 && !cursor.node().is_extra()
8109 {
8110 result.push(cursor.node());
8111 }
8112 if !cursor.goto_next_sibling() {
8113 break;
8114 }
8115 }
8116 }
8117 result
8118 };
8119 let mut items = ::std::vec::Vec::new();
8120 for child in non_field_children {
8121 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8122 <PointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
8123 child, src,
8124 )
8125 })?);
8126 }
8127 items
8128 },
8129 })
8130 }
8131}
8132impl ::treesitter_types::Spanned for PointerDeclarator<'_> {
8133 fn span(&self) -> ::treesitter_types::Span {
8134 self.span
8135 }
8136}
8137#[derive(Debug, Clone, PartialEq, Eq)]
8138pub struct PointerExpression<'tree> {
8139 pub span: ::treesitter_types::Span,
8140 pub argument: Expression<'tree>,
8141 pub operator: PointerExpressionOperator,
8142}
8143impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpression<'tree> {
8144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8145 fn from_node(
8146 node: ::treesitter_types::tree_sitter::Node<'tree>,
8147 src: &'tree [u8],
8148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8149 debug_assert_eq!(node.kind(), "pointer_expression");
8150 Ok(Self {
8151 span: ::treesitter_types::Span::from(node),
8152 argument: {
8153 let child = node.child_by_field_name("argument").ok_or_else(|| {
8154 ::treesitter_types::ParseError::missing_field("argument", node)
8155 })?;
8156 ::treesitter_types::runtime::maybe_grow_stack(|| {
8157 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8158 })?
8159 },
8160 operator: {
8161 let child = node.child_by_field_name("operator").ok_or_else(|| {
8162 ::treesitter_types::ParseError::missing_field("operator", node)
8163 })?;
8164 ::treesitter_types::runtime::maybe_grow_stack(|| {
8165 <PointerExpressionOperator as ::treesitter_types::FromNode>::from_node(
8166 child, src,
8167 )
8168 })?
8169 },
8170 })
8171 }
8172}
8173impl ::treesitter_types::Spanned for PointerExpression<'_> {
8174 fn span(&self) -> ::treesitter_types::Span {
8175 self.span
8176 }
8177}
8178#[derive(Debug, Clone, PartialEq, Eq)]
8179pub struct PointerTypeDeclarator<'tree> {
8180 pub span: ::treesitter_types::Span,
8181 pub declarator: TypeDeclarator<'tree>,
8182 pub children: ::std::vec::Vec<PointerTypeDeclaratorChildren<'tree>>,
8183}
8184impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeDeclarator<'tree> {
8185 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8186 fn from_node(
8187 node: ::treesitter_types::tree_sitter::Node<'tree>,
8188 src: &'tree [u8],
8189 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8190 debug_assert_eq!(node.kind(), "pointer_type_declarator");
8191 Ok(Self {
8192 span: ::treesitter_types::Span::from(node),
8193 declarator: {
8194 let child = node.child_by_field_name("declarator").ok_or_else(|| {
8195 ::treesitter_types::ParseError::missing_field("declarator", node)
8196 })?;
8197 ::treesitter_types::runtime::maybe_grow_stack(|| {
8198 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
8199 })?
8200 },
8201 children: {
8202 #[allow(clippy::suspicious_else_formatting)]
8203 let non_field_children = {
8204 let mut cursor = node.walk();
8205 let mut result = ::std::vec::Vec::new();
8206 if cursor.goto_first_child() {
8207 loop {
8208 if cursor.field_name().is_none()
8209 && cursor.node().is_named()
8210 && !cursor.node().is_extra()
8211 {
8212 result.push(cursor.node());
8213 }
8214 if !cursor.goto_next_sibling() {
8215 break;
8216 }
8217 }
8218 }
8219 result
8220 };
8221 let mut items = ::std::vec::Vec::new();
8222 for child in non_field_children {
8223 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8224 <PointerTypeDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
8225 child, src,
8226 )
8227 })?);
8228 }
8229 items
8230 },
8231 })
8232 }
8233}
8234impl ::treesitter_types::Spanned for PointerTypeDeclarator<'_> {
8235 fn span(&self) -> ::treesitter_types::Span {
8236 self.span
8237 }
8238}
8239#[derive(Debug, Clone, PartialEq, Eq)]
8240pub struct PreprocCall<'tree> {
8241 pub span: ::treesitter_types::Span,
8242 pub argument: ::core::option::Option<PreprocArg<'tree>>,
8243 pub directive: PreprocDirective<'tree>,
8244}
8245impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocCall<'tree> {
8246 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8247 fn from_node(
8248 node: ::treesitter_types::tree_sitter::Node<'tree>,
8249 src: &'tree [u8],
8250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8251 debug_assert_eq!(node.kind(), "preproc_call");
8252 Ok(Self {
8253 span: ::treesitter_types::Span::from(node),
8254 argument: match node.child_by_field_name("argument") {
8255 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8256 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
8257 })?),
8258 None => None,
8259 },
8260 directive: {
8261 let child = node.child_by_field_name("directive").ok_or_else(|| {
8262 ::treesitter_types::ParseError::missing_field("directive", node)
8263 })?;
8264 ::treesitter_types::runtime::maybe_grow_stack(|| {
8265 <PreprocDirective as ::treesitter_types::FromNode>::from_node(child, src)
8266 })?
8267 },
8268 })
8269 }
8270}
8271impl ::treesitter_types::Spanned for PreprocCall<'_> {
8272 fn span(&self) -> ::treesitter_types::Span {
8273 self.span
8274 }
8275}
8276#[derive(Debug, Clone, PartialEq, Eq)]
8277pub struct PreprocDef<'tree> {
8278 pub span: ::treesitter_types::Span,
8279 pub name: Identifier<'tree>,
8280 pub value: ::core::option::Option<PreprocArg<'tree>>,
8281}
8282impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDef<'tree> {
8283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8284 fn from_node(
8285 node: ::treesitter_types::tree_sitter::Node<'tree>,
8286 src: &'tree [u8],
8287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8288 debug_assert_eq!(node.kind(), "preproc_def");
8289 Ok(Self {
8290 span: ::treesitter_types::Span::from(node),
8291 name: {
8292 let child = node
8293 .child_by_field_name("name")
8294 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8295 ::treesitter_types::runtime::maybe_grow_stack(|| {
8296 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8297 })?
8298 },
8299 value: match node.child_by_field_name("value") {
8300 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8301 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
8302 })?),
8303 None => None,
8304 },
8305 })
8306 }
8307}
8308impl ::treesitter_types::Spanned for PreprocDef<'_> {
8309 fn span(&self) -> ::treesitter_types::Span {
8310 self.span
8311 }
8312}
8313#[derive(Debug, Clone, PartialEq, Eq)]
8314pub struct PreprocDefined<'tree> {
8315 pub span: ::treesitter_types::Span,
8316 pub children: Identifier<'tree>,
8317}
8318impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefined<'tree> {
8319 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8320 fn from_node(
8321 node: ::treesitter_types::tree_sitter::Node<'tree>,
8322 src: &'tree [u8],
8323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8324 debug_assert_eq!(node.kind(), "preproc_defined");
8325 Ok(Self {
8326 span: ::treesitter_types::Span::from(node),
8327 children: {
8328 #[allow(clippy::suspicious_else_formatting)]
8329 let non_field_children = {
8330 let mut cursor = node.walk();
8331 let mut result = ::std::vec::Vec::new();
8332 if cursor.goto_first_child() {
8333 loop {
8334 if cursor.field_name().is_none()
8335 && cursor.node().is_named()
8336 && !cursor.node().is_extra()
8337 {
8338 result.push(cursor.node());
8339 }
8340 if !cursor.goto_next_sibling() {
8341 break;
8342 }
8343 }
8344 }
8345 result
8346 };
8347 let child = if let Some(&c) = non_field_children.first() {
8348 c
8349 } else {
8350 let mut fallback_cursor = node.walk();
8351 let mut fallback_child = None;
8352 if fallback_cursor.goto_first_child() {
8353 loop {
8354 if fallback_cursor.field_name().is_none()
8355 && !fallback_cursor.node().is_extra()
8356 {
8357 let candidate = fallback_cursor.node();
8358 #[allow(clippy::needless_question_mark)]
8359 if (|| -> ::core::result::Result<
8360 _,
8361 ::treesitter_types::ParseError,
8362 > {
8363 let child = candidate;
8364 Ok(
8365 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
8366 child,
8367 src,
8368 ))?,
8369 )
8370 })()
8371 .is_ok()
8372 {
8373 fallback_child = Some(candidate);
8374 break;
8375 }
8376 }
8377 if !fallback_cursor.goto_next_sibling() {
8378 break;
8379 }
8380 }
8381 }
8382 if fallback_child.is_none() {
8383 let mut cursor2 = node.walk();
8384 if cursor2.goto_first_child() {
8385 loop {
8386 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8387 let candidate = cursor2.node();
8388 #[allow(clippy::needless_question_mark)]
8389 if (|| -> ::core::result::Result<
8390 _,
8391 ::treesitter_types::ParseError,
8392 > {
8393 let child = candidate;
8394 Ok(
8395 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
8396 child,
8397 src,
8398 ))?,
8399 )
8400 })()
8401 .is_ok()
8402 {
8403 fallback_child = Some(candidate);
8404 break;
8405 }
8406 }
8407 if !cursor2.goto_next_sibling() {
8408 break;
8409 }
8410 }
8411 }
8412 }
8413 fallback_child.ok_or_else(|| {
8414 ::treesitter_types::ParseError::missing_field("children", node)
8415 })?
8416 };
8417 ::treesitter_types::runtime::maybe_grow_stack(|| {
8418 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8419 })?
8420 },
8421 })
8422 }
8423}
8424impl ::treesitter_types::Spanned for PreprocDefined<'_> {
8425 fn span(&self) -> ::treesitter_types::Span {
8426 self.span
8427 }
8428}
8429#[derive(Debug, Clone, PartialEq, Eq)]
8430pub struct PreprocElif<'tree> {
8431 pub span: ::treesitter_types::Span,
8432 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
8433 pub condition: PreprocElifCondition<'tree>,
8434 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
8435}
8436impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
8437 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8438 fn from_node(
8439 node: ::treesitter_types::tree_sitter::Node<'tree>,
8440 src: &'tree [u8],
8441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8442 debug_assert_eq!(node.kind(), "preproc_elif");
8443 Ok(Self {
8444 span: ::treesitter_types::Span::from(node),
8445 alternative: match node.child_by_field_name("alternative") {
8446 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8447 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(child, src)
8448 })?),
8449 None => None,
8450 },
8451 condition: {
8452 let child = node.child_by_field_name("condition").ok_or_else(|| {
8453 ::treesitter_types::ParseError::missing_field("condition", node)
8454 })?;
8455 ::treesitter_types::runtime::maybe_grow_stack(|| {
8456 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)
8457 })?
8458 },
8459 children: {
8460 #[allow(clippy::suspicious_else_formatting)]
8461 let non_field_children = {
8462 let mut cursor = node.walk();
8463 let mut result = ::std::vec::Vec::new();
8464 if cursor.goto_first_child() {
8465 loop {
8466 if cursor.field_name().is_none()
8467 && cursor.node().is_named()
8468 && !cursor.node().is_extra()
8469 {
8470 result.push(cursor.node());
8471 }
8472 if !cursor.goto_next_sibling() {
8473 break;
8474 }
8475 }
8476 }
8477 result
8478 };
8479 let mut items = ::std::vec::Vec::new();
8480 for child in non_field_children {
8481 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8482 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(child, src)
8483 })?);
8484 }
8485 items
8486 },
8487 })
8488 }
8489}
8490impl ::treesitter_types::Spanned for PreprocElif<'_> {
8491 fn span(&self) -> ::treesitter_types::Span {
8492 self.span
8493 }
8494}
8495#[derive(Debug, Clone, PartialEq, Eq)]
8496pub struct PreprocElifdef<'tree> {
8497 pub span: ::treesitter_types::Span,
8498 pub alternative: ::core::option::Option<PreprocElifdefAlternative<'tree>>,
8499 pub name: Identifier<'tree>,
8500 pub children: ::std::vec::Vec<PreprocElifdefChildren<'tree>>,
8501}
8502impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdef<'tree> {
8503 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8504 fn from_node(
8505 node: ::treesitter_types::tree_sitter::Node<'tree>,
8506 src: &'tree [u8],
8507 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8508 debug_assert_eq!(node.kind(), "preproc_elifdef");
8509 Ok(Self {
8510 span: ::treesitter_types::Span::from(node),
8511 alternative: match node.child_by_field_name("alternative") {
8512 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8513 <PreprocElifdefAlternative as ::treesitter_types::FromNode>::from_node(
8514 child, src,
8515 )
8516 })?),
8517 None => None,
8518 },
8519 name: {
8520 let child = node
8521 .child_by_field_name("name")
8522 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8523 ::treesitter_types::runtime::maybe_grow_stack(|| {
8524 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8525 })?
8526 },
8527 children: {
8528 #[allow(clippy::suspicious_else_formatting)]
8529 let non_field_children = {
8530 let mut cursor = node.walk();
8531 let mut result = ::std::vec::Vec::new();
8532 if cursor.goto_first_child() {
8533 loop {
8534 if cursor.field_name().is_none()
8535 && cursor.node().is_named()
8536 && !cursor.node().is_extra()
8537 {
8538 result.push(cursor.node());
8539 }
8540 if !cursor.goto_next_sibling() {
8541 break;
8542 }
8543 }
8544 }
8545 result
8546 };
8547 let mut items = ::std::vec::Vec::new();
8548 for child in non_field_children {
8549 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8550 <PreprocElifdefChildren as ::treesitter_types::FromNode>::from_node(
8551 child, src,
8552 )
8553 })?);
8554 }
8555 items
8556 },
8557 })
8558 }
8559}
8560impl ::treesitter_types::Spanned for PreprocElifdef<'_> {
8561 fn span(&self) -> ::treesitter_types::Span {
8562 self.span
8563 }
8564}
8565#[derive(Debug, Clone, PartialEq, Eq)]
8566pub struct PreprocElse<'tree> {
8567 pub span: ::treesitter_types::Span,
8568 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
8569}
8570impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
8571 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8572 fn from_node(
8573 node: ::treesitter_types::tree_sitter::Node<'tree>,
8574 src: &'tree [u8],
8575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8576 debug_assert_eq!(node.kind(), "preproc_else");
8577 Ok(Self {
8578 span: ::treesitter_types::Span::from(node),
8579 children: {
8580 #[allow(clippy::suspicious_else_formatting)]
8581 let non_field_children = {
8582 let mut cursor = node.walk();
8583 let mut result = ::std::vec::Vec::new();
8584 if cursor.goto_first_child() {
8585 loop {
8586 if cursor.field_name().is_none()
8587 && cursor.node().is_named()
8588 && !cursor.node().is_extra()
8589 {
8590 result.push(cursor.node());
8591 }
8592 if !cursor.goto_next_sibling() {
8593 break;
8594 }
8595 }
8596 }
8597 result
8598 };
8599 let mut items = ::std::vec::Vec::new();
8600 for child in non_field_children {
8601 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8602 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(child, src)
8603 })?);
8604 }
8605 items
8606 },
8607 })
8608 }
8609}
8610impl ::treesitter_types::Spanned for PreprocElse<'_> {
8611 fn span(&self) -> ::treesitter_types::Span {
8612 self.span
8613 }
8614}
8615#[derive(Debug, Clone, PartialEq, Eq)]
8616pub struct PreprocFunctionDef<'tree> {
8617 pub span: ::treesitter_types::Span,
8618 pub name: Identifier<'tree>,
8619 pub parameters: PreprocParams<'tree>,
8620 pub value: ::core::option::Option<PreprocArg<'tree>>,
8621}
8622impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocFunctionDef<'tree> {
8623 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8624 fn from_node(
8625 node: ::treesitter_types::tree_sitter::Node<'tree>,
8626 src: &'tree [u8],
8627 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8628 debug_assert_eq!(node.kind(), "preproc_function_def");
8629 Ok(Self {
8630 span: ::treesitter_types::Span::from(node),
8631 name: {
8632 let child = node
8633 .child_by_field_name("name")
8634 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8635 ::treesitter_types::runtime::maybe_grow_stack(|| {
8636 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8637 })?
8638 },
8639 parameters: {
8640 let child = node.child_by_field_name("parameters").ok_or_else(|| {
8641 ::treesitter_types::ParseError::missing_field("parameters", node)
8642 })?;
8643 ::treesitter_types::runtime::maybe_grow_stack(|| {
8644 <PreprocParams as ::treesitter_types::FromNode>::from_node(child, src)
8645 })?
8646 },
8647 value: match node.child_by_field_name("value") {
8648 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8649 <PreprocArg as ::treesitter_types::FromNode>::from_node(child, src)
8650 })?),
8651 None => None,
8652 },
8653 })
8654 }
8655}
8656impl ::treesitter_types::Spanned for PreprocFunctionDef<'_> {
8657 fn span(&self) -> ::treesitter_types::Span {
8658 self.span
8659 }
8660}
8661#[derive(Debug, Clone, PartialEq, Eq)]
8662pub struct PreprocIf<'tree> {
8663 pub span: ::treesitter_types::Span,
8664 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
8665 pub condition: PreprocIfCondition<'tree>,
8666 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
8667}
8668impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
8669 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8670 fn from_node(
8671 node: ::treesitter_types::tree_sitter::Node<'tree>,
8672 src: &'tree [u8],
8673 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8674 debug_assert_eq!(node.kind(), "preproc_if");
8675 Ok(Self {
8676 span: ::treesitter_types::Span::from(node),
8677 alternative: match node.child_by_field_name("alternative") {
8678 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8679 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)
8680 })?),
8681 None => None,
8682 },
8683 condition: {
8684 let child = node.child_by_field_name("condition").ok_or_else(|| {
8685 ::treesitter_types::ParseError::missing_field("condition", node)
8686 })?;
8687 ::treesitter_types::runtime::maybe_grow_stack(|| {
8688 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)
8689 })?
8690 },
8691 children: {
8692 #[allow(clippy::suspicious_else_formatting)]
8693 let non_field_children = {
8694 let mut cursor = node.walk();
8695 let mut result = ::std::vec::Vec::new();
8696 if cursor.goto_first_child() {
8697 loop {
8698 if cursor.field_name().is_none()
8699 && cursor.node().is_named()
8700 && !cursor.node().is_extra()
8701 {
8702 result.push(cursor.node());
8703 }
8704 if !cursor.goto_next_sibling() {
8705 break;
8706 }
8707 }
8708 }
8709 result
8710 };
8711 let mut items = ::std::vec::Vec::new();
8712 for child in non_field_children {
8713 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8714 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)
8715 })?);
8716 }
8717 items
8718 },
8719 })
8720 }
8721}
8722impl ::treesitter_types::Spanned for PreprocIf<'_> {
8723 fn span(&self) -> ::treesitter_types::Span {
8724 self.span
8725 }
8726}
8727#[derive(Debug, Clone, PartialEq, Eq)]
8728pub struct PreprocIfdef<'tree> {
8729 pub span: ::treesitter_types::Span,
8730 pub alternative: ::core::option::Option<PreprocIfdefAlternative<'tree>>,
8731 pub name: Identifier<'tree>,
8732 pub children: ::std::vec::Vec<PreprocIfdefChildren<'tree>>,
8733}
8734impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdef<'tree> {
8735 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8736 fn from_node(
8737 node: ::treesitter_types::tree_sitter::Node<'tree>,
8738 src: &'tree [u8],
8739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8740 debug_assert_eq!(node.kind(), "preproc_ifdef");
8741 Ok(Self {
8742 span: ::treesitter_types::Span::from(node),
8743 alternative: match node.child_by_field_name("alternative") {
8744 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8745 <PreprocIfdefAlternative as ::treesitter_types::FromNode>::from_node(child, src)
8746 })?),
8747 None => None,
8748 },
8749 name: {
8750 let child = node
8751 .child_by_field_name("name")
8752 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8753 ::treesitter_types::runtime::maybe_grow_stack(|| {
8754 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8755 })?
8756 },
8757 children: {
8758 #[allow(clippy::suspicious_else_formatting)]
8759 let non_field_children = {
8760 let mut cursor = node.walk();
8761 let mut result = ::std::vec::Vec::new();
8762 if cursor.goto_first_child() {
8763 loop {
8764 if cursor.field_name().is_none()
8765 && cursor.node().is_named()
8766 && !cursor.node().is_extra()
8767 {
8768 result.push(cursor.node());
8769 }
8770 if !cursor.goto_next_sibling() {
8771 break;
8772 }
8773 }
8774 }
8775 result
8776 };
8777 let mut items = ::std::vec::Vec::new();
8778 for child in non_field_children {
8779 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8780 <PreprocIfdefChildren as ::treesitter_types::FromNode>::from_node(
8781 child, src,
8782 )
8783 })?);
8784 }
8785 items
8786 },
8787 })
8788 }
8789}
8790impl ::treesitter_types::Spanned for PreprocIfdef<'_> {
8791 fn span(&self) -> ::treesitter_types::Span {
8792 self.span
8793 }
8794}
8795#[derive(Debug, Clone, PartialEq, Eq)]
8796pub struct PreprocInclude<'tree> {
8797 pub span: ::treesitter_types::Span,
8798 pub path: PreprocIncludePath<'tree>,
8799}
8800impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocInclude<'tree> {
8801 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8802 fn from_node(
8803 node: ::treesitter_types::tree_sitter::Node<'tree>,
8804 src: &'tree [u8],
8805 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8806 debug_assert_eq!(node.kind(), "preproc_include");
8807 Ok(Self {
8808 span: ::treesitter_types::Span::from(node),
8809 path: {
8810 let child = node
8811 .child_by_field_name("path")
8812 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
8813 ::treesitter_types::runtime::maybe_grow_stack(|| {
8814 <PreprocIncludePath as ::treesitter_types::FromNode>::from_node(child, src)
8815 })?
8816 },
8817 })
8818 }
8819}
8820impl ::treesitter_types::Spanned for PreprocInclude<'_> {
8821 fn span(&self) -> ::treesitter_types::Span {
8822 self.span
8823 }
8824}
8825#[derive(Debug, Clone, PartialEq, Eq)]
8826pub struct PreprocParams<'tree> {
8827 pub span: ::treesitter_types::Span,
8828 pub children: ::std::vec::Vec<Identifier<'tree>>,
8829}
8830impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocParams<'tree> {
8831 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8832 fn from_node(
8833 node: ::treesitter_types::tree_sitter::Node<'tree>,
8834 src: &'tree [u8],
8835 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8836 debug_assert_eq!(node.kind(), "preproc_params");
8837 Ok(Self {
8838 span: ::treesitter_types::Span::from(node),
8839 children: {
8840 #[allow(clippy::suspicious_else_formatting)]
8841 let non_field_children = {
8842 let mut cursor = node.walk();
8843 let mut result = ::std::vec::Vec::new();
8844 if cursor.goto_first_child() {
8845 loop {
8846 if cursor.field_name().is_none()
8847 && cursor.node().is_named()
8848 && !cursor.node().is_extra()
8849 {
8850 result.push(cursor.node());
8851 }
8852 if !cursor.goto_next_sibling() {
8853 break;
8854 }
8855 }
8856 }
8857 result
8858 };
8859 let mut items = ::std::vec::Vec::new();
8860 for child in non_field_children {
8861 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8862 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
8863 })?);
8864 }
8865 items
8866 },
8867 })
8868 }
8869}
8870impl ::treesitter_types::Spanned for PreprocParams<'_> {
8871 fn span(&self) -> ::treesitter_types::Span {
8872 self.span
8873 }
8874}
8875#[derive(Debug, Clone, PartialEq, Eq)]
8876pub struct PureVirtualClause<'tree> {
8877 pub span: ::treesitter_types::Span,
8878 text: &'tree str,
8879}
8880impl<'tree> ::treesitter_types::FromNode<'tree> for PureVirtualClause<'tree> {
8881 fn from_node(
8882 node: ::treesitter_types::tree_sitter::Node<'tree>,
8883 src: &'tree [u8],
8884 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8885 debug_assert_eq!(node.kind(), "pure_virtual_clause");
8886 Ok(Self {
8887 span: ::treesitter_types::Span::from(node),
8888 text: node.utf8_text(src)?,
8889 })
8890 }
8891}
8892impl<'tree> ::treesitter_types::LeafNode<'tree> for PureVirtualClause<'tree> {
8893 fn text(&self) -> &'tree str {
8894 self.text
8895 }
8896}
8897impl ::treesitter_types::Spanned for PureVirtualClause<'_> {
8898 fn span(&self) -> ::treesitter_types::Span {
8899 self.span
8900 }
8901}
8902#[derive(Debug, Clone, PartialEq, Eq)]
8903pub struct QualifiedIdentifier<'tree> {
8904 pub span: ::treesitter_types::Span,
8905 pub name: ::std::vec::Vec<QualifiedIdentifierName<'tree>>,
8906 pub scope: ::core::option::Option<QualifiedIdentifierScope<'tree>>,
8907}
8908impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifier<'tree> {
8909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8910 fn from_node(
8911 node: ::treesitter_types::tree_sitter::Node<'tree>,
8912 src: &'tree [u8],
8913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8914 debug_assert_eq!(node.kind(), "qualified_identifier");
8915 Ok(Self {
8916 span: ::treesitter_types::Span::from(node),
8917 name: {
8918 let mut cursor = node.walk();
8919 let mut items = ::std::vec::Vec::new();
8920 for child in node.children_by_field_name("name", &mut cursor) {
8921 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8922 <QualifiedIdentifierName as ::treesitter_types::FromNode>::from_node(
8923 child, src,
8924 )
8925 })?);
8926 }
8927 items
8928 },
8929 scope: match node.child_by_field_name("scope") {
8930 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8931 <QualifiedIdentifierScope as ::treesitter_types::FromNode>::from_node(
8932 child, src,
8933 )
8934 })?),
8935 None => None,
8936 },
8937 })
8938 }
8939}
8940impl ::treesitter_types::Spanned for QualifiedIdentifier<'_> {
8941 fn span(&self) -> ::treesitter_types::Span {
8942 self.span
8943 }
8944}
8945#[derive(Debug, Clone, PartialEq, Eq)]
8946pub struct RawStringLiteral<'tree> {
8947 pub span: ::treesitter_types::Span,
8948 pub delimiter: ::core::option::Option<RawStringDelimiter<'tree>>,
8949 pub children: ::std::vec::Vec<RawStringLiteralChildren<'tree>>,
8950}
8951impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
8952 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8953 fn from_node(
8954 node: ::treesitter_types::tree_sitter::Node<'tree>,
8955 src: &'tree [u8],
8956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8957 debug_assert_eq!(node.kind(), "raw_string_literal");
8958 Ok(Self {
8959 span: ::treesitter_types::Span::from(node),
8960 delimiter: match node.child_by_field_name("delimiter") {
8961 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8962 <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(child, src)
8963 })?),
8964 None => None,
8965 },
8966 children: {
8967 #[allow(clippy::suspicious_else_formatting)]
8968 let non_field_children = {
8969 let mut cursor = node.walk();
8970 let mut result = ::std::vec::Vec::new();
8971 if cursor.goto_first_child() {
8972 loop {
8973 if cursor.field_name().is_none()
8974 && cursor.node().is_named()
8975 && !cursor.node().is_extra()
8976 {
8977 result.push(cursor.node());
8978 }
8979 if !cursor.goto_next_sibling() {
8980 break;
8981 }
8982 }
8983 }
8984 result
8985 };
8986 let mut items = ::std::vec::Vec::new();
8987 for child in non_field_children {
8988 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8989 <RawStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
8990 child, src,
8991 )
8992 })?);
8993 }
8994 items
8995 },
8996 })
8997 }
8998}
8999impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
9000 fn span(&self) -> ::treesitter_types::Span {
9001 self.span
9002 }
9003}
9004#[derive(Debug, Clone, PartialEq, Eq)]
9005pub struct RefQualifier<'tree> {
9006 pub span: ::treesitter_types::Span,
9007 text: &'tree str,
9008}
9009impl<'tree> ::treesitter_types::FromNode<'tree> for RefQualifier<'tree> {
9010 fn from_node(
9011 node: ::treesitter_types::tree_sitter::Node<'tree>,
9012 src: &'tree [u8],
9013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9014 debug_assert_eq!(node.kind(), "ref_qualifier");
9015 Ok(Self {
9016 span: ::treesitter_types::Span::from(node),
9017 text: node.utf8_text(src)?,
9018 })
9019 }
9020}
9021impl<'tree> ::treesitter_types::LeafNode<'tree> for RefQualifier<'tree> {
9022 fn text(&self) -> &'tree str {
9023 self.text
9024 }
9025}
9026impl ::treesitter_types::Spanned for RefQualifier<'_> {
9027 fn span(&self) -> ::treesitter_types::Span {
9028 self.span
9029 }
9030}
9031#[derive(Debug, Clone, PartialEq, Eq)]
9032pub struct ReferenceDeclarator<'tree> {
9033 pub span: ::treesitter_types::Span,
9034 pub children: ReferenceDeclaratorChildren<'tree>,
9035}
9036impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceDeclarator<'tree> {
9037 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9038 fn from_node(
9039 node: ::treesitter_types::tree_sitter::Node<'tree>,
9040 src: &'tree [u8],
9041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9042 debug_assert_eq!(node.kind(), "reference_declarator");
9043 Ok(Self {
9044 span: ::treesitter_types::Span::from(node),
9045 children: {
9046 #[allow(clippy::suspicious_else_formatting)]
9047 let non_field_children = {
9048 let mut cursor = node.walk();
9049 let mut result = ::std::vec::Vec::new();
9050 if cursor.goto_first_child() {
9051 loop {
9052 if cursor.field_name().is_none()
9053 && cursor.node().is_named()
9054 && !cursor.node().is_extra()
9055 {
9056 result.push(cursor.node());
9057 }
9058 if !cursor.goto_next_sibling() {
9059 break;
9060 }
9061 }
9062 }
9063 result
9064 };
9065 let child = if let Some(&c) = non_field_children.first() {
9066 c
9067 } else {
9068 let mut fallback_cursor = node.walk();
9069 let mut fallback_child = None;
9070 if fallback_cursor.goto_first_child() {
9071 loop {
9072 if fallback_cursor.field_name().is_none()
9073 && !fallback_cursor.node().is_extra()
9074 {
9075 let candidate = fallback_cursor.node();
9076 #[allow(clippy::needless_question_mark)]
9077 if (|| -> ::core::result::Result<
9078 _,
9079 ::treesitter_types::ParseError,
9080 > {
9081 let child = candidate;
9082 Ok(
9083 ::treesitter_types::runtime::maybe_grow_stack(|| <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
9084 child,
9085 src,
9086 ))?,
9087 )
9088 })()
9089 .is_ok()
9090 {
9091 fallback_child = Some(candidate);
9092 break;
9093 }
9094 }
9095 if !fallback_cursor.goto_next_sibling() {
9096 break;
9097 }
9098 }
9099 }
9100 if fallback_child.is_none() {
9101 let mut cursor2 = node.walk();
9102 if cursor2.goto_first_child() {
9103 loop {
9104 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9105 let candidate = cursor2.node();
9106 #[allow(clippy::needless_question_mark)]
9107 if (|| -> ::core::result::Result<
9108 _,
9109 ::treesitter_types::ParseError,
9110 > {
9111 let child = candidate;
9112 Ok(
9113 ::treesitter_types::runtime::maybe_grow_stack(|| <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
9114 child,
9115 src,
9116 ))?,
9117 )
9118 })()
9119 .is_ok()
9120 {
9121 fallback_child = Some(candidate);
9122 break;
9123 }
9124 }
9125 if !cursor2.goto_next_sibling() {
9126 break;
9127 }
9128 }
9129 }
9130 }
9131 fallback_child.ok_or_else(|| {
9132 ::treesitter_types::ParseError::missing_field("children", node)
9133 })?
9134 };
9135 ::treesitter_types::runtime::maybe_grow_stack(|| {
9136 <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
9137 child, src,
9138 )
9139 })?
9140 },
9141 })
9142 }
9143}
9144impl ::treesitter_types::Spanned for ReferenceDeclarator<'_> {
9145 fn span(&self) -> ::treesitter_types::Span {
9146 self.span
9147 }
9148}
9149#[derive(Debug, Clone, PartialEq, Eq)]
9150pub struct RequirementSeq<'tree> {
9151 pub span: ::treesitter_types::Span,
9152 pub children: ::std::vec::Vec<RequirementSeqChildren<'tree>>,
9153}
9154impl<'tree> ::treesitter_types::FromNode<'tree> for RequirementSeq<'tree> {
9155 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9156 fn from_node(
9157 node: ::treesitter_types::tree_sitter::Node<'tree>,
9158 src: &'tree [u8],
9159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9160 debug_assert_eq!(node.kind(), "requirement_seq");
9161 Ok(Self {
9162 span: ::treesitter_types::Span::from(node),
9163 children: {
9164 #[allow(clippy::suspicious_else_formatting)]
9165 let non_field_children = {
9166 let mut cursor = node.walk();
9167 let mut result = ::std::vec::Vec::new();
9168 if cursor.goto_first_child() {
9169 loop {
9170 if cursor.field_name().is_none()
9171 && cursor.node().is_named()
9172 && !cursor.node().is_extra()
9173 {
9174 result.push(cursor.node());
9175 }
9176 if !cursor.goto_next_sibling() {
9177 break;
9178 }
9179 }
9180 }
9181 result
9182 };
9183 let mut items = ::std::vec::Vec::new();
9184 for child in non_field_children {
9185 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9186 <RequirementSeqChildren as ::treesitter_types::FromNode>::from_node(
9187 child, src,
9188 )
9189 })?);
9190 }
9191 items
9192 },
9193 })
9194 }
9195}
9196impl ::treesitter_types::Spanned for RequirementSeq<'_> {
9197 fn span(&self) -> ::treesitter_types::Span {
9198 self.span
9199 }
9200}
9201#[derive(Debug, Clone, PartialEq, Eq)]
9202pub struct RequiresClause<'tree> {
9203 pub span: ::treesitter_types::Span,
9204 pub constraint: ::std::vec::Vec<RequiresClauseConstraint<'tree>>,
9205}
9206impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresClause<'tree> {
9207 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9208 fn from_node(
9209 node: ::treesitter_types::tree_sitter::Node<'tree>,
9210 src: &'tree [u8],
9211 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9212 debug_assert_eq!(node.kind(), "requires_clause");
9213 Ok(Self {
9214 span: ::treesitter_types::Span::from(node),
9215 constraint: {
9216 let mut cursor = node.walk();
9217 let mut items = ::std::vec::Vec::new();
9218 for child in node.children_by_field_name("constraint", &mut cursor) {
9219 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9220 <RequiresClauseConstraint as ::treesitter_types::FromNode>::from_node(
9221 child, src,
9222 )
9223 })?);
9224 }
9225 items
9226 },
9227 })
9228 }
9229}
9230impl ::treesitter_types::Spanned for RequiresClause<'_> {
9231 fn span(&self) -> ::treesitter_types::Span {
9232 self.span
9233 }
9234}
9235#[derive(Debug, Clone, PartialEq, Eq)]
9236pub struct RequiresExpression<'tree> {
9237 pub span: ::treesitter_types::Span,
9238 pub parameters: ::core::option::Option<ParameterList<'tree>>,
9239 pub requirements: RequirementSeq<'tree>,
9240}
9241impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresExpression<'tree> {
9242 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9243 fn from_node(
9244 node: ::treesitter_types::tree_sitter::Node<'tree>,
9245 src: &'tree [u8],
9246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9247 debug_assert_eq!(node.kind(), "requires_expression");
9248 Ok(Self {
9249 span: ::treesitter_types::Span::from(node),
9250 parameters: match node.child_by_field_name("parameters") {
9251 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9252 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)
9253 })?),
9254 None => None,
9255 },
9256 requirements: {
9257 let child = node.child_by_field_name("requirements").ok_or_else(|| {
9258 ::treesitter_types::ParseError::missing_field("requirements", node)
9259 })?;
9260 ::treesitter_types::runtime::maybe_grow_stack(|| {
9261 <RequirementSeq as ::treesitter_types::FromNode>::from_node(child, src)
9262 })?
9263 },
9264 })
9265 }
9266}
9267impl ::treesitter_types::Spanned for RequiresExpression<'_> {
9268 fn span(&self) -> ::treesitter_types::Span {
9269 self.span
9270 }
9271}
9272#[derive(Debug, Clone, PartialEq, Eq)]
9273pub struct ReturnStatement<'tree> {
9274 pub span: ::treesitter_types::Span,
9275 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
9276}
9277impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
9278 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9279 fn from_node(
9280 node: ::treesitter_types::tree_sitter::Node<'tree>,
9281 src: &'tree [u8],
9282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9283 debug_assert_eq!(node.kind(), "return_statement");
9284 Ok(Self {
9285 span: ::treesitter_types::Span::from(node),
9286 children: {
9287 #[allow(clippy::suspicious_else_formatting)]
9288 let non_field_children = {
9289 let mut cursor = node.walk();
9290 let mut result = ::std::vec::Vec::new();
9291 if cursor.goto_first_child() {
9292 loop {
9293 if cursor.field_name().is_none()
9294 && cursor.node().is_named()
9295 && !cursor.node().is_extra()
9296 {
9297 result.push(cursor.node());
9298 }
9299 if !cursor.goto_next_sibling() {
9300 break;
9301 }
9302 }
9303 }
9304 result
9305 };
9306 match non_field_children.first() {
9307 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9308 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
9309 child, src,
9310 )
9311 })?),
9312 None => None,
9313 }
9314 },
9315 })
9316 }
9317}
9318impl ::treesitter_types::Spanned for ReturnStatement<'_> {
9319 fn span(&self) -> ::treesitter_types::Span {
9320 self.span
9321 }
9322}
9323#[derive(Debug, Clone, PartialEq, Eq)]
9324pub struct SehExceptClause<'tree> {
9325 pub span: ::treesitter_types::Span,
9326 pub body: CompoundStatement<'tree>,
9327 pub filter: ParenthesizedExpression<'tree>,
9328}
9329impl<'tree> ::treesitter_types::FromNode<'tree> for SehExceptClause<'tree> {
9330 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9331 fn from_node(
9332 node: ::treesitter_types::tree_sitter::Node<'tree>,
9333 src: &'tree [u8],
9334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9335 debug_assert_eq!(node.kind(), "seh_except_clause");
9336 Ok(Self {
9337 span: ::treesitter_types::Span::from(node),
9338 body: {
9339 let child = node
9340 .child_by_field_name("body")
9341 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9342 ::treesitter_types::runtime::maybe_grow_stack(|| {
9343 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
9344 })?
9345 },
9346 filter: {
9347 let child = node
9348 .child_by_field_name("filter")
9349 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("filter", node))?;
9350 ::treesitter_types::runtime::maybe_grow_stack(|| {
9351 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
9352 })?
9353 },
9354 })
9355 }
9356}
9357impl ::treesitter_types::Spanned for SehExceptClause<'_> {
9358 fn span(&self) -> ::treesitter_types::Span {
9359 self.span
9360 }
9361}
9362#[derive(Debug, Clone, PartialEq, Eq)]
9363pub struct SehFinallyClause<'tree> {
9364 pub span: ::treesitter_types::Span,
9365 pub body: CompoundStatement<'tree>,
9366}
9367impl<'tree> ::treesitter_types::FromNode<'tree> for SehFinallyClause<'tree> {
9368 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9369 fn from_node(
9370 node: ::treesitter_types::tree_sitter::Node<'tree>,
9371 src: &'tree [u8],
9372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9373 debug_assert_eq!(node.kind(), "seh_finally_clause");
9374 Ok(Self {
9375 span: ::treesitter_types::Span::from(node),
9376 body: {
9377 let child = node
9378 .child_by_field_name("body")
9379 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9380 ::treesitter_types::runtime::maybe_grow_stack(|| {
9381 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
9382 })?
9383 },
9384 })
9385 }
9386}
9387impl ::treesitter_types::Spanned for SehFinallyClause<'_> {
9388 fn span(&self) -> ::treesitter_types::Span {
9389 self.span
9390 }
9391}
9392#[derive(Debug, Clone, PartialEq, Eq)]
9393pub struct SehLeaveStatement<'tree> {
9394 pub span: ::treesitter_types::Span,
9395 text: &'tree str,
9396}
9397impl<'tree> ::treesitter_types::FromNode<'tree> for SehLeaveStatement<'tree> {
9398 fn from_node(
9399 node: ::treesitter_types::tree_sitter::Node<'tree>,
9400 src: &'tree [u8],
9401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9402 debug_assert_eq!(node.kind(), "seh_leave_statement");
9403 Ok(Self {
9404 span: ::treesitter_types::Span::from(node),
9405 text: node.utf8_text(src)?,
9406 })
9407 }
9408}
9409impl<'tree> ::treesitter_types::LeafNode<'tree> for SehLeaveStatement<'tree> {
9410 fn text(&self) -> &'tree str {
9411 self.text
9412 }
9413}
9414impl ::treesitter_types::Spanned for SehLeaveStatement<'_> {
9415 fn span(&self) -> ::treesitter_types::Span {
9416 self.span
9417 }
9418}
9419#[derive(Debug, Clone, PartialEq, Eq)]
9420pub struct SehTryStatement<'tree> {
9421 pub span: ::treesitter_types::Span,
9422 pub body: CompoundStatement<'tree>,
9423 pub children: SehTryStatementChildren<'tree>,
9424}
9425impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatement<'tree> {
9426 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9427 fn from_node(
9428 node: ::treesitter_types::tree_sitter::Node<'tree>,
9429 src: &'tree [u8],
9430 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9431 debug_assert_eq!(node.kind(), "seh_try_statement");
9432 Ok(Self {
9433 span: ::treesitter_types::Span::from(node),
9434 body: {
9435 let child = node
9436 .child_by_field_name("body")
9437 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9438 ::treesitter_types::runtime::maybe_grow_stack(|| {
9439 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
9440 })?
9441 },
9442 children: {
9443 #[allow(clippy::suspicious_else_formatting)]
9444 let non_field_children = {
9445 let mut cursor = node.walk();
9446 let mut result = ::std::vec::Vec::new();
9447 if cursor.goto_first_child() {
9448 loop {
9449 if cursor.field_name().is_none()
9450 && cursor.node().is_named()
9451 && !cursor.node().is_extra()
9452 {
9453 result.push(cursor.node());
9454 }
9455 if !cursor.goto_next_sibling() {
9456 break;
9457 }
9458 }
9459 }
9460 result
9461 };
9462 let child = if let Some(&c) = non_field_children.first() {
9463 c
9464 } else {
9465 let mut fallback_cursor = node.walk();
9466 let mut fallback_child = None;
9467 if fallback_cursor.goto_first_child() {
9468 loop {
9469 if fallback_cursor.field_name().is_none()
9470 && !fallback_cursor.node().is_extra()
9471 {
9472 let candidate = fallback_cursor.node();
9473 #[allow(clippy::needless_question_mark)]
9474 if (|| -> ::core::result::Result<
9475 _,
9476 ::treesitter_types::ParseError,
9477 > {
9478 let child = candidate;
9479 Ok(
9480 ::treesitter_types::runtime::maybe_grow_stack(|| <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
9481 child,
9482 src,
9483 ))?,
9484 )
9485 })()
9486 .is_ok()
9487 {
9488 fallback_child = Some(candidate);
9489 break;
9490 }
9491 }
9492 if !fallback_cursor.goto_next_sibling() {
9493 break;
9494 }
9495 }
9496 }
9497 if fallback_child.is_none() {
9498 let mut cursor2 = node.walk();
9499 if cursor2.goto_first_child() {
9500 loop {
9501 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9502 let candidate = cursor2.node();
9503 #[allow(clippy::needless_question_mark)]
9504 if (|| -> ::core::result::Result<
9505 _,
9506 ::treesitter_types::ParseError,
9507 > {
9508 let child = candidate;
9509 Ok(
9510 ::treesitter_types::runtime::maybe_grow_stack(|| <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
9511 child,
9512 src,
9513 ))?,
9514 )
9515 })()
9516 .is_ok()
9517 {
9518 fallback_child = Some(candidate);
9519 break;
9520 }
9521 }
9522 if !cursor2.goto_next_sibling() {
9523 break;
9524 }
9525 }
9526 }
9527 }
9528 fallback_child.ok_or_else(|| {
9529 ::treesitter_types::ParseError::missing_field("children", node)
9530 })?
9531 };
9532 ::treesitter_types::runtime::maybe_grow_stack(|| {
9533 <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
9534 })?
9535 },
9536 })
9537 }
9538}
9539impl ::treesitter_types::Spanned for SehTryStatement<'_> {
9540 fn span(&self) -> ::treesitter_types::Span {
9541 self.span
9542 }
9543}
9544#[derive(Debug, Clone, PartialEq, Eq)]
9545pub struct SimpleRequirement<'tree> {
9546 pub span: ::treesitter_types::Span,
9547 pub children: ::core::option::Option<SimpleRequirementChildren<'tree>>,
9548}
9549impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleRequirement<'tree> {
9550 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9551 fn from_node(
9552 node: ::treesitter_types::tree_sitter::Node<'tree>,
9553 src: &'tree [u8],
9554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9555 debug_assert_eq!(node.kind(), "simple_requirement");
9556 Ok(Self {
9557 span: ::treesitter_types::Span::from(node),
9558 children: {
9559 #[allow(clippy::suspicious_else_formatting)]
9560 let non_field_children = {
9561 let mut cursor = node.walk();
9562 let mut result = ::std::vec::Vec::new();
9563 if cursor.goto_first_child() {
9564 loop {
9565 if cursor.field_name().is_none()
9566 && cursor.node().is_named()
9567 && !cursor.node().is_extra()
9568 {
9569 result.push(cursor.node());
9570 }
9571 if !cursor.goto_next_sibling() {
9572 break;
9573 }
9574 }
9575 }
9576 result
9577 };
9578 match non_field_children.first() {
9579 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9580 <SimpleRequirementChildren as ::treesitter_types::FromNode>::from_node(
9581 child, src,
9582 )
9583 })?),
9584 None => None,
9585 }
9586 },
9587 })
9588 }
9589}
9590impl ::treesitter_types::Spanned for SimpleRequirement<'_> {
9591 fn span(&self) -> ::treesitter_types::Span {
9592 self.span
9593 }
9594}
9595#[derive(Debug, Clone, PartialEq, Eq)]
9596pub struct SizedTypeSpecifier<'tree> {
9597 pub span: ::treesitter_types::Span,
9598 pub r#type: ::core::option::Option<SizedTypeSpecifierType<'tree>>,
9599 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
9600}
9601impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifier<'tree> {
9602 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9603 fn from_node(
9604 node: ::treesitter_types::tree_sitter::Node<'tree>,
9605 src: &'tree [u8],
9606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9607 debug_assert_eq!(node.kind(), "sized_type_specifier");
9608 Ok(Self {
9609 span: ::treesitter_types::Span::from(node),
9610 r#type: match node.child_by_field_name("type") {
9611 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9612 <SizedTypeSpecifierType as ::treesitter_types::FromNode>::from_node(child, src)
9613 })?),
9614 None => None,
9615 },
9616 children: {
9617 #[allow(clippy::suspicious_else_formatting)]
9618 let non_field_children = {
9619 let mut cursor = node.walk();
9620 let mut result = ::std::vec::Vec::new();
9621 if cursor.goto_first_child() {
9622 loop {
9623 if cursor.field_name().is_none()
9624 && cursor.node().is_named()
9625 && !cursor.node().is_extra()
9626 {
9627 result.push(cursor.node());
9628 }
9629 if !cursor.goto_next_sibling() {
9630 break;
9631 }
9632 }
9633 }
9634 result
9635 };
9636 let mut items = ::std::vec::Vec::new();
9637 for child in non_field_children {
9638 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9639 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
9640 })?);
9641 }
9642 items
9643 },
9644 })
9645 }
9646}
9647impl ::treesitter_types::Spanned for SizedTypeSpecifier<'_> {
9648 fn span(&self) -> ::treesitter_types::Span {
9649 self.span
9650 }
9651}
9652#[derive(Debug, Clone, PartialEq, Eq)]
9653pub struct SizeofExpression<'tree> {
9654 pub span: ::treesitter_types::Span,
9655 pub r#type: ::core::option::Option<TypeDescriptor<'tree>>,
9656 pub value: ::core::option::Option<Expression<'tree>>,
9657}
9658impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
9659 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9660 fn from_node(
9661 node: ::treesitter_types::tree_sitter::Node<'tree>,
9662 src: &'tree [u8],
9663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9664 debug_assert_eq!(node.kind(), "sizeof_expression");
9665 Ok(Self {
9666 span: ::treesitter_types::Span::from(node),
9667 r#type: match node.child_by_field_name("type") {
9668 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9669 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
9670 })?),
9671 None => None,
9672 },
9673 value: match node.child_by_field_name("value") {
9674 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9675 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9676 })?),
9677 None => None,
9678 },
9679 })
9680 }
9681}
9682impl ::treesitter_types::Spanned for SizeofExpression<'_> {
9683 fn span(&self) -> ::treesitter_types::Span {
9684 self.span
9685 }
9686}
9687#[derive(Debug, Clone, PartialEq, Eq)]
9688pub struct StaticAssertDeclaration<'tree> {
9689 pub span: ::treesitter_types::Span,
9690 pub condition: Expression<'tree>,
9691 pub message: ::core::option::Option<StaticAssertDeclarationMessage<'tree>>,
9692}
9693impl<'tree> ::treesitter_types::FromNode<'tree> for StaticAssertDeclaration<'tree> {
9694 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9695 fn from_node(
9696 node: ::treesitter_types::tree_sitter::Node<'tree>,
9697 src: &'tree [u8],
9698 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9699 debug_assert_eq!(node.kind(), "static_assert_declaration");
9700 Ok(Self {
9701 span: ::treesitter_types::Span::from(node),
9702 condition: {
9703 let child = node.child_by_field_name("condition").ok_or_else(|| {
9704 ::treesitter_types::ParseError::missing_field("condition", node)
9705 })?;
9706 ::treesitter_types::runtime::maybe_grow_stack(|| {
9707 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9708 })?
9709 },
9710 message: match node.child_by_field_name("message") {
9711 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9712 <StaticAssertDeclarationMessage as ::treesitter_types::FromNode>::from_node(
9713 child, src,
9714 )
9715 })?),
9716 None => None,
9717 },
9718 })
9719 }
9720}
9721impl ::treesitter_types::Spanned for StaticAssertDeclaration<'_> {
9722 fn span(&self) -> ::treesitter_types::Span {
9723 self.span
9724 }
9725}
9726#[derive(Debug, Clone, PartialEq, Eq)]
9727pub struct StorageClassSpecifier<'tree> {
9728 pub span: ::treesitter_types::Span,
9729 text: &'tree str,
9730}
9731impl<'tree> ::treesitter_types::FromNode<'tree> for StorageClassSpecifier<'tree> {
9732 fn from_node(
9733 node: ::treesitter_types::tree_sitter::Node<'tree>,
9734 src: &'tree [u8],
9735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9736 debug_assert_eq!(node.kind(), "storage_class_specifier");
9737 Ok(Self {
9738 span: ::treesitter_types::Span::from(node),
9739 text: node.utf8_text(src)?,
9740 })
9741 }
9742}
9743impl<'tree> ::treesitter_types::LeafNode<'tree> for StorageClassSpecifier<'tree> {
9744 fn text(&self) -> &'tree str {
9745 self.text
9746 }
9747}
9748impl ::treesitter_types::Spanned for StorageClassSpecifier<'_> {
9749 fn span(&self) -> ::treesitter_types::Span {
9750 self.span
9751 }
9752}
9753#[derive(Debug, Clone, PartialEq, Eq)]
9754pub struct StringLiteral<'tree> {
9755 pub span: ::treesitter_types::Span,
9756 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
9757}
9758impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
9759 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9760 fn from_node(
9761 node: ::treesitter_types::tree_sitter::Node<'tree>,
9762 src: &'tree [u8],
9763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9764 debug_assert_eq!(node.kind(), "string_literal");
9765 Ok(Self {
9766 span: ::treesitter_types::Span::from(node),
9767 children: {
9768 #[allow(clippy::suspicious_else_formatting)]
9769 let non_field_children = {
9770 let mut cursor = node.walk();
9771 let mut result = ::std::vec::Vec::new();
9772 if cursor.goto_first_child() {
9773 loop {
9774 if cursor.field_name().is_none()
9775 && cursor.node().is_named()
9776 && !cursor.node().is_extra()
9777 {
9778 result.push(cursor.node());
9779 }
9780 if !cursor.goto_next_sibling() {
9781 break;
9782 }
9783 }
9784 }
9785 result
9786 };
9787 let mut items = ::std::vec::Vec::new();
9788 for child in non_field_children {
9789 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9790 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
9791 child, src,
9792 )
9793 })?);
9794 }
9795 items
9796 },
9797 })
9798 }
9799}
9800impl ::treesitter_types::Spanned for StringLiteral<'_> {
9801 fn span(&self) -> ::treesitter_types::Span {
9802 self.span
9803 }
9804}
9805#[derive(Debug, Clone, PartialEq, Eq)]
9806pub struct StructSpecifier<'tree> {
9807 pub span: ::treesitter_types::Span,
9808 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
9809 pub name: ::core::option::Option<StructSpecifierName<'tree>>,
9810 pub children: ::std::vec::Vec<StructSpecifierChildren<'tree>>,
9811}
9812impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifier<'tree> {
9813 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9814 fn from_node(
9815 node: ::treesitter_types::tree_sitter::Node<'tree>,
9816 src: &'tree [u8],
9817 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9818 debug_assert_eq!(node.kind(), "struct_specifier");
9819 Ok(Self {
9820 span: ::treesitter_types::Span::from(node),
9821 body: match node.child_by_field_name("body") {
9822 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9823 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
9824 })?),
9825 None => None,
9826 },
9827 name: match node.child_by_field_name("name") {
9828 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9829 <StructSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
9830 })?),
9831 None => None,
9832 },
9833 children: {
9834 #[allow(clippy::suspicious_else_formatting)]
9835 let non_field_children = {
9836 let mut cursor = node.walk();
9837 let mut result = ::std::vec::Vec::new();
9838 if cursor.goto_first_child() {
9839 loop {
9840 if cursor.field_name().is_none()
9841 && cursor.node().is_named()
9842 && !cursor.node().is_extra()
9843 {
9844 result.push(cursor.node());
9845 }
9846 if !cursor.goto_next_sibling() {
9847 break;
9848 }
9849 }
9850 }
9851 result
9852 };
9853 let mut items = ::std::vec::Vec::new();
9854 for child in non_field_children {
9855 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9856 <StructSpecifierChildren as ::treesitter_types::FromNode>::from_node(
9857 child, src,
9858 )
9859 })?);
9860 }
9861 items
9862 },
9863 })
9864 }
9865}
9866impl ::treesitter_types::Spanned for StructSpecifier<'_> {
9867 fn span(&self) -> ::treesitter_types::Span {
9868 self.span
9869 }
9870}
9871#[derive(Debug, Clone, PartialEq, Eq)]
9872pub struct StructuredBindingDeclarator<'tree> {
9873 pub span: ::treesitter_types::Span,
9874 pub children: ::std::vec::Vec<Identifier<'tree>>,
9875}
9876impl<'tree> ::treesitter_types::FromNode<'tree> for StructuredBindingDeclarator<'tree> {
9877 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9878 fn from_node(
9879 node: ::treesitter_types::tree_sitter::Node<'tree>,
9880 src: &'tree [u8],
9881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9882 debug_assert_eq!(node.kind(), "structured_binding_declarator");
9883 Ok(Self {
9884 span: ::treesitter_types::Span::from(node),
9885 children: {
9886 #[allow(clippy::suspicious_else_formatting)]
9887 let non_field_children = {
9888 let mut cursor = node.walk();
9889 let mut result = ::std::vec::Vec::new();
9890 if cursor.goto_first_child() {
9891 loop {
9892 if cursor.field_name().is_none()
9893 && cursor.node().is_named()
9894 && !cursor.node().is_extra()
9895 {
9896 result.push(cursor.node());
9897 }
9898 if !cursor.goto_next_sibling() {
9899 break;
9900 }
9901 }
9902 }
9903 result
9904 };
9905 let mut items = ::std::vec::Vec::new();
9906 for child in non_field_children {
9907 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9908 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
9909 })?);
9910 }
9911 items
9912 },
9913 })
9914 }
9915}
9916impl ::treesitter_types::Spanned for StructuredBindingDeclarator<'_> {
9917 fn span(&self) -> ::treesitter_types::Span {
9918 self.span
9919 }
9920}
9921#[derive(Debug, Clone, PartialEq, Eq)]
9922pub struct SubscriptArgumentList<'tree> {
9923 pub span: ::treesitter_types::Span,
9924 pub children: ::std::vec::Vec<SubscriptArgumentListChildren<'tree>>,
9925}
9926impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptArgumentList<'tree> {
9927 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9928 fn from_node(
9929 node: ::treesitter_types::tree_sitter::Node<'tree>,
9930 src: &'tree [u8],
9931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9932 debug_assert_eq!(node.kind(), "subscript_argument_list");
9933 Ok(Self {
9934 span: ::treesitter_types::Span::from(node),
9935 children: {
9936 #[allow(clippy::suspicious_else_formatting)]
9937 let non_field_children = {
9938 let mut cursor = node.walk();
9939 let mut result = ::std::vec::Vec::new();
9940 if cursor.goto_first_child() {
9941 loop {
9942 if cursor.field_name().is_none()
9943 && cursor.node().is_named()
9944 && !cursor.node().is_extra()
9945 {
9946 result.push(cursor.node());
9947 }
9948 if !cursor.goto_next_sibling() {
9949 break;
9950 }
9951 }
9952 }
9953 result
9954 };
9955 let mut items = ::std::vec::Vec::new();
9956 for child in non_field_children {
9957 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9958 <SubscriptArgumentListChildren as ::treesitter_types::FromNode>::from_node(
9959 child, src,
9960 )
9961 })?);
9962 }
9963 items
9964 },
9965 })
9966 }
9967}
9968impl ::treesitter_types::Spanned for SubscriptArgumentList<'_> {
9969 fn span(&self) -> ::treesitter_types::Span {
9970 self.span
9971 }
9972}
9973#[derive(Debug, Clone, PartialEq, Eq)]
9974pub struct SubscriptDesignator<'tree> {
9975 pub span: ::treesitter_types::Span,
9976 pub children: Expression<'tree>,
9977}
9978impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptDesignator<'tree> {
9979 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9980 fn from_node(
9981 node: ::treesitter_types::tree_sitter::Node<'tree>,
9982 src: &'tree [u8],
9983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9984 debug_assert_eq!(node.kind(), "subscript_designator");
9985 Ok(Self {
9986 span: ::treesitter_types::Span::from(node),
9987 children: {
9988 #[allow(clippy::suspicious_else_formatting)]
9989 let non_field_children = {
9990 let mut cursor = node.walk();
9991 let mut result = ::std::vec::Vec::new();
9992 if cursor.goto_first_child() {
9993 loop {
9994 if cursor.field_name().is_none()
9995 && cursor.node().is_named()
9996 && !cursor.node().is_extra()
9997 {
9998 result.push(cursor.node());
9999 }
10000 if !cursor.goto_next_sibling() {
10001 break;
10002 }
10003 }
10004 }
10005 result
10006 };
10007 let child = if let Some(&c) = non_field_children.first() {
10008 c
10009 } else {
10010 let mut fallback_cursor = node.walk();
10011 let mut fallback_child = None;
10012 if fallback_cursor.goto_first_child() {
10013 loop {
10014 if fallback_cursor.field_name().is_none()
10015 && !fallback_cursor.node().is_extra()
10016 {
10017 let candidate = fallback_cursor.node();
10018 #[allow(clippy::needless_question_mark)]
10019 if (|| -> ::core::result::Result<
10020 _,
10021 ::treesitter_types::ParseError,
10022 > {
10023 let child = candidate;
10024 Ok(
10025 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10026 child,
10027 src,
10028 ))?,
10029 )
10030 })()
10031 .is_ok()
10032 {
10033 fallback_child = Some(candidate);
10034 break;
10035 }
10036 }
10037 if !fallback_cursor.goto_next_sibling() {
10038 break;
10039 }
10040 }
10041 }
10042 if fallback_child.is_none() {
10043 let mut cursor2 = node.walk();
10044 if cursor2.goto_first_child() {
10045 loop {
10046 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10047 let candidate = cursor2.node();
10048 #[allow(clippy::needless_question_mark)]
10049 if (|| -> ::core::result::Result<
10050 _,
10051 ::treesitter_types::ParseError,
10052 > {
10053 let child = candidate;
10054 Ok(
10055 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
10056 child,
10057 src,
10058 ))?,
10059 )
10060 })()
10061 .is_ok()
10062 {
10063 fallback_child = Some(candidate);
10064 break;
10065 }
10066 }
10067 if !cursor2.goto_next_sibling() {
10068 break;
10069 }
10070 }
10071 }
10072 }
10073 fallback_child.ok_or_else(|| {
10074 ::treesitter_types::ParseError::missing_field("children", node)
10075 })?
10076 };
10077 ::treesitter_types::runtime::maybe_grow_stack(|| {
10078 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10079 })?
10080 },
10081 })
10082 }
10083}
10084impl ::treesitter_types::Spanned for SubscriptDesignator<'_> {
10085 fn span(&self) -> ::treesitter_types::Span {
10086 self.span
10087 }
10088}
10089#[derive(Debug, Clone, PartialEq, Eq)]
10090pub struct SubscriptExpression<'tree> {
10091 pub span: ::treesitter_types::Span,
10092 pub argument: Expression<'tree>,
10093 pub indices: SubscriptArgumentList<'tree>,
10094}
10095impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
10096 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10097 fn from_node(
10098 node: ::treesitter_types::tree_sitter::Node<'tree>,
10099 src: &'tree [u8],
10100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10101 debug_assert_eq!(node.kind(), "subscript_expression");
10102 Ok(Self {
10103 span: ::treesitter_types::Span::from(node),
10104 argument: {
10105 let child = node.child_by_field_name("argument").ok_or_else(|| {
10106 ::treesitter_types::ParseError::missing_field("argument", node)
10107 })?;
10108 ::treesitter_types::runtime::maybe_grow_stack(|| {
10109 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10110 })?
10111 },
10112 indices: {
10113 let child = node.child_by_field_name("indices").ok_or_else(|| {
10114 ::treesitter_types::ParseError::missing_field("indices", node)
10115 })?;
10116 ::treesitter_types::runtime::maybe_grow_stack(|| {
10117 <SubscriptArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10118 })?
10119 },
10120 })
10121 }
10122}
10123impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
10124 fn span(&self) -> ::treesitter_types::Span {
10125 self.span
10126 }
10127}
10128#[derive(Debug, Clone, PartialEq, Eq)]
10129pub struct SubscriptRangeDesignator<'tree> {
10130 pub span: ::treesitter_types::Span,
10131 pub end: Expression<'tree>,
10132 pub start: Expression<'tree>,
10133}
10134impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptRangeDesignator<'tree> {
10135 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10136 fn from_node(
10137 node: ::treesitter_types::tree_sitter::Node<'tree>,
10138 src: &'tree [u8],
10139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10140 debug_assert_eq!(node.kind(), "subscript_range_designator");
10141 Ok(Self {
10142 span: ::treesitter_types::Span::from(node),
10143 end: {
10144 let child = node
10145 .child_by_field_name("end")
10146 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("end", node))?;
10147 ::treesitter_types::runtime::maybe_grow_stack(|| {
10148 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10149 })?
10150 },
10151 start: {
10152 let child = node
10153 .child_by_field_name("start")
10154 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
10155 ::treesitter_types::runtime::maybe_grow_stack(|| {
10156 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10157 })?
10158 },
10159 })
10160 }
10161}
10162impl ::treesitter_types::Spanned for SubscriptRangeDesignator<'_> {
10163 fn span(&self) -> ::treesitter_types::Span {
10164 self.span
10165 }
10166}
10167#[derive(Debug, Clone, PartialEq, Eq)]
10168pub struct SwitchStatement<'tree> {
10169 pub span: ::treesitter_types::Span,
10170 pub body: CompoundStatement<'tree>,
10171 pub condition: ConditionClause<'tree>,
10172}
10173impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
10174 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10175 fn from_node(
10176 node: ::treesitter_types::tree_sitter::Node<'tree>,
10177 src: &'tree [u8],
10178 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10179 debug_assert_eq!(node.kind(), "switch_statement");
10180 Ok(Self {
10181 span: ::treesitter_types::Span::from(node),
10182 body: {
10183 let child = node
10184 .child_by_field_name("body")
10185 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
10186 ::treesitter_types::runtime::maybe_grow_stack(|| {
10187 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
10188 })?
10189 },
10190 condition: {
10191 let child = node.child_by_field_name("condition").ok_or_else(|| {
10192 ::treesitter_types::ParseError::missing_field("condition", node)
10193 })?;
10194 ::treesitter_types::runtime::maybe_grow_stack(|| {
10195 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)
10196 })?
10197 },
10198 })
10199 }
10200}
10201impl ::treesitter_types::Spanned for SwitchStatement<'_> {
10202 fn span(&self) -> ::treesitter_types::Span {
10203 self.span
10204 }
10205}
10206#[derive(Debug, Clone, PartialEq, Eq)]
10207pub struct TemplateArgumentList<'tree> {
10208 pub span: ::treesitter_types::Span,
10209 pub children: ::std::vec::Vec<TemplateArgumentListChildren<'tree>>,
10210}
10211impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateArgumentList<'tree> {
10212 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10213 fn from_node(
10214 node: ::treesitter_types::tree_sitter::Node<'tree>,
10215 src: &'tree [u8],
10216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10217 debug_assert_eq!(node.kind(), "template_argument_list");
10218 Ok(Self {
10219 span: ::treesitter_types::Span::from(node),
10220 children: {
10221 #[allow(clippy::suspicious_else_formatting)]
10222 let non_field_children = {
10223 let mut cursor = node.walk();
10224 let mut result = ::std::vec::Vec::new();
10225 if cursor.goto_first_child() {
10226 loop {
10227 if cursor.field_name().is_none()
10228 && cursor.node().is_named()
10229 && !cursor.node().is_extra()
10230 {
10231 result.push(cursor.node());
10232 }
10233 if !cursor.goto_next_sibling() {
10234 break;
10235 }
10236 }
10237 }
10238 result
10239 };
10240 let mut items = ::std::vec::Vec::new();
10241 for child in non_field_children {
10242 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10243 <TemplateArgumentListChildren as ::treesitter_types::FromNode>::from_node(
10244 child, src,
10245 )
10246 })?);
10247 }
10248 items
10249 },
10250 })
10251 }
10252}
10253impl ::treesitter_types::Spanned for TemplateArgumentList<'_> {
10254 fn span(&self) -> ::treesitter_types::Span {
10255 self.span
10256 }
10257}
10258#[derive(Debug, Clone, PartialEq, Eq)]
10259pub struct TemplateDeclaration<'tree> {
10260 pub span: ::treesitter_types::Span,
10261 pub parameters: TemplateParameterList<'tree>,
10262 pub children: ::std::vec::Vec<TemplateDeclarationChildren<'tree>>,
10263}
10264impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateDeclaration<'tree> {
10265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10266 fn from_node(
10267 node: ::treesitter_types::tree_sitter::Node<'tree>,
10268 src: &'tree [u8],
10269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10270 debug_assert_eq!(node.kind(), "template_declaration");
10271 Ok(Self {
10272 span: ::treesitter_types::Span::from(node),
10273 parameters: {
10274 let child = node.child_by_field_name("parameters").ok_or_else(|| {
10275 ::treesitter_types::ParseError::missing_field("parameters", node)
10276 })?;
10277 ::treesitter_types::runtime::maybe_grow_stack(|| {
10278 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)
10279 })?
10280 },
10281 children: {
10282 #[allow(clippy::suspicious_else_formatting)]
10283 let non_field_children = {
10284 let mut cursor = node.walk();
10285 let mut result = ::std::vec::Vec::new();
10286 if cursor.goto_first_child() {
10287 loop {
10288 if cursor.field_name().is_none()
10289 && cursor.node().is_named()
10290 && !cursor.node().is_extra()
10291 {
10292 result.push(cursor.node());
10293 }
10294 if !cursor.goto_next_sibling() {
10295 break;
10296 }
10297 }
10298 }
10299 result
10300 };
10301 let mut items = ::std::vec::Vec::new();
10302 for child in non_field_children {
10303 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10304 <TemplateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10305 child, src,
10306 )
10307 })?);
10308 }
10309 items
10310 },
10311 })
10312 }
10313}
10314impl ::treesitter_types::Spanned for TemplateDeclaration<'_> {
10315 fn span(&self) -> ::treesitter_types::Span {
10316 self.span
10317 }
10318}
10319#[derive(Debug, Clone, PartialEq, Eq)]
10320pub struct TemplateFunction<'tree> {
10321 pub span: ::treesitter_types::Span,
10322 pub arguments: TemplateArgumentList<'tree>,
10323 pub name: Identifier<'tree>,
10324}
10325impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateFunction<'tree> {
10326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10327 fn from_node(
10328 node: ::treesitter_types::tree_sitter::Node<'tree>,
10329 src: &'tree [u8],
10330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10331 debug_assert_eq!(node.kind(), "template_function");
10332 Ok(Self {
10333 span: ::treesitter_types::Span::from(node),
10334 arguments: {
10335 let child = node.child_by_field_name("arguments").ok_or_else(|| {
10336 ::treesitter_types::ParseError::missing_field("arguments", node)
10337 })?;
10338 ::treesitter_types::runtime::maybe_grow_stack(|| {
10339 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10340 })?
10341 },
10342 name: {
10343 let child = node
10344 .child_by_field_name("name")
10345 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10346 ::treesitter_types::runtime::maybe_grow_stack(|| {
10347 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
10348 })?
10349 },
10350 })
10351 }
10352}
10353impl ::treesitter_types::Spanned for TemplateFunction<'_> {
10354 fn span(&self) -> ::treesitter_types::Span {
10355 self.span
10356 }
10357}
10358#[derive(Debug, Clone, PartialEq, Eq)]
10359pub struct TemplateInstantiation<'tree> {
10360 pub span: ::treesitter_types::Span,
10361 pub declarator: Declarator<'tree>,
10362 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
10363 pub children: ::std::vec::Vec<TemplateInstantiationChildren<'tree>>,
10364}
10365impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateInstantiation<'tree> {
10366 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10367 fn from_node(
10368 node: ::treesitter_types::tree_sitter::Node<'tree>,
10369 src: &'tree [u8],
10370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10371 debug_assert_eq!(node.kind(), "template_instantiation");
10372 Ok(Self {
10373 span: ::treesitter_types::Span::from(node),
10374 declarator: {
10375 let child = node.child_by_field_name("declarator").ok_or_else(|| {
10376 ::treesitter_types::ParseError::missing_field("declarator", node)
10377 })?;
10378 ::treesitter_types::runtime::maybe_grow_stack(|| {
10379 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)
10380 })?
10381 },
10382 r#type: match node.child_by_field_name("type") {
10383 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10384 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
10385 })?),
10386 None => None,
10387 },
10388 children: {
10389 #[allow(clippy::suspicious_else_formatting)]
10390 let non_field_children = {
10391 let mut cursor = node.walk();
10392 let mut result = ::std::vec::Vec::new();
10393 if cursor.goto_first_child() {
10394 loop {
10395 if cursor.field_name().is_none()
10396 && cursor.node().is_named()
10397 && !cursor.node().is_extra()
10398 {
10399 result.push(cursor.node());
10400 }
10401 if !cursor.goto_next_sibling() {
10402 break;
10403 }
10404 }
10405 }
10406 result
10407 };
10408 let mut items = ::std::vec::Vec::new();
10409 for child in non_field_children {
10410 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10411 <TemplateInstantiationChildren as ::treesitter_types::FromNode>::from_node(
10412 child, src,
10413 )
10414 })?);
10415 }
10416 items
10417 },
10418 })
10419 }
10420}
10421impl ::treesitter_types::Spanned for TemplateInstantiation<'_> {
10422 fn span(&self) -> ::treesitter_types::Span {
10423 self.span
10424 }
10425}
10426#[derive(Debug, Clone, PartialEq, Eq)]
10427pub struct TemplateMethod<'tree> {
10428 pub span: ::treesitter_types::Span,
10429 pub arguments: TemplateArgumentList<'tree>,
10430 pub name: TemplateMethodName<'tree>,
10431}
10432impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateMethod<'tree> {
10433 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10434 fn from_node(
10435 node: ::treesitter_types::tree_sitter::Node<'tree>,
10436 src: &'tree [u8],
10437 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10438 debug_assert_eq!(node.kind(), "template_method");
10439 Ok(Self {
10440 span: ::treesitter_types::Span::from(node),
10441 arguments: {
10442 let child = node.child_by_field_name("arguments").ok_or_else(|| {
10443 ::treesitter_types::ParseError::missing_field("arguments", node)
10444 })?;
10445 ::treesitter_types::runtime::maybe_grow_stack(|| {
10446 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10447 })?
10448 },
10449 name: {
10450 let child = node
10451 .child_by_field_name("name")
10452 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10453 ::treesitter_types::runtime::maybe_grow_stack(|| {
10454 <TemplateMethodName as ::treesitter_types::FromNode>::from_node(child, src)
10455 })?
10456 },
10457 })
10458 }
10459}
10460impl ::treesitter_types::Spanned for TemplateMethod<'_> {
10461 fn span(&self) -> ::treesitter_types::Span {
10462 self.span
10463 }
10464}
10465#[derive(Debug, Clone, PartialEq, Eq)]
10466pub struct TemplateParameterList<'tree> {
10467 pub span: ::treesitter_types::Span,
10468 pub children: ::std::vec::Vec<TemplateParameterListChildren<'tree>>,
10469}
10470impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateParameterList<'tree> {
10471 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10472 fn from_node(
10473 node: ::treesitter_types::tree_sitter::Node<'tree>,
10474 src: &'tree [u8],
10475 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10476 debug_assert_eq!(node.kind(), "template_parameter_list");
10477 Ok(Self {
10478 span: ::treesitter_types::Span::from(node),
10479 children: {
10480 #[allow(clippy::suspicious_else_formatting)]
10481 let non_field_children = {
10482 let mut cursor = node.walk();
10483 let mut result = ::std::vec::Vec::new();
10484 if cursor.goto_first_child() {
10485 loop {
10486 if cursor.field_name().is_none()
10487 && cursor.node().is_named()
10488 && !cursor.node().is_extra()
10489 {
10490 result.push(cursor.node());
10491 }
10492 if !cursor.goto_next_sibling() {
10493 break;
10494 }
10495 }
10496 }
10497 result
10498 };
10499 let mut items = ::std::vec::Vec::new();
10500 for child in non_field_children {
10501 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10502 <TemplateParameterListChildren as ::treesitter_types::FromNode>::from_node(
10503 child, src,
10504 )
10505 })?);
10506 }
10507 items
10508 },
10509 })
10510 }
10511}
10512impl ::treesitter_types::Spanned for TemplateParameterList<'_> {
10513 fn span(&self) -> ::treesitter_types::Span {
10514 self.span
10515 }
10516}
10517#[derive(Debug, Clone, PartialEq, Eq)]
10518pub struct TemplateTemplateParameterDeclaration<'tree> {
10519 pub span: ::treesitter_types::Span,
10520 pub parameters: TemplateParameterList<'tree>,
10521 pub children: TemplateTemplateParameterDeclarationChildren<'tree>,
10522}
10523impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateTemplateParameterDeclaration<'tree> {
10524 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10525 fn from_node(
10526 node: ::treesitter_types::tree_sitter::Node<'tree>,
10527 src: &'tree [u8],
10528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10529 debug_assert_eq!(node.kind(), "template_template_parameter_declaration");
10530 Ok(Self {
10531 span: ::treesitter_types::Span::from(node),
10532 parameters: {
10533 let child = node.child_by_field_name("parameters").ok_or_else(|| {
10534 ::treesitter_types::ParseError::missing_field("parameters", node)
10535 })?;
10536 ::treesitter_types::runtime::maybe_grow_stack(|| {
10537 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)
10538 })?
10539 },
10540 children: {
10541 #[allow(clippy::suspicious_else_formatting)]
10542 let non_field_children = {
10543 let mut cursor = node.walk();
10544 let mut result = ::std::vec::Vec::new();
10545 if cursor.goto_first_child() {
10546 loop {
10547 if cursor.field_name().is_none()
10548 && cursor.node().is_named()
10549 && !cursor.node().is_extra()
10550 {
10551 result.push(cursor.node());
10552 }
10553 if !cursor.goto_next_sibling() {
10554 break;
10555 }
10556 }
10557 }
10558 result
10559 };
10560 let child = if let Some(&c) = non_field_children.first() {
10561 c
10562 } else {
10563 let mut fallback_cursor = node.walk();
10564 let mut fallback_child = None;
10565 if fallback_cursor.goto_first_child() {
10566 loop {
10567 if fallback_cursor.field_name().is_none()
10568 && !fallback_cursor.node().is_extra()
10569 {
10570 let candidate = fallback_cursor.node();
10571 #[allow(clippy::needless_question_mark)]
10572 if (|| -> ::core::result::Result<
10573 _,
10574 ::treesitter_types::ParseError,
10575 > {
10576 let child = candidate;
10577 Ok(
10578 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10579 child,
10580 src,
10581 ))?,
10582 )
10583 })()
10584 .is_ok()
10585 {
10586 fallback_child = Some(candidate);
10587 break;
10588 }
10589 }
10590 if !fallback_cursor.goto_next_sibling() {
10591 break;
10592 }
10593 }
10594 }
10595 if fallback_child.is_none() {
10596 let mut cursor2 = node.walk();
10597 if cursor2.goto_first_child() {
10598 loop {
10599 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10600 let candidate = cursor2.node();
10601 #[allow(clippy::needless_question_mark)]
10602 if (|| -> ::core::result::Result<
10603 _,
10604 ::treesitter_types::ParseError,
10605 > {
10606 let child = candidate;
10607 Ok(
10608 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10609 child,
10610 src,
10611 ))?,
10612 )
10613 })()
10614 .is_ok()
10615 {
10616 fallback_child = Some(candidate);
10617 break;
10618 }
10619 }
10620 if !cursor2.goto_next_sibling() {
10621 break;
10622 }
10623 }
10624 }
10625 }
10626 fallback_child.ok_or_else(|| {
10627 ::treesitter_types::ParseError::missing_field("children", node)
10628 })?
10629 };
10630 ::treesitter_types::runtime::maybe_grow_stack(|| {
10631 <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10632 child,
10633 src,
10634 )
10635 })?
10636 },
10637 })
10638 }
10639}
10640impl ::treesitter_types::Spanned for TemplateTemplateParameterDeclaration<'_> {
10641 fn span(&self) -> ::treesitter_types::Span {
10642 self.span
10643 }
10644}
10645#[derive(Debug, Clone, PartialEq, Eq)]
10646pub struct TemplateType<'tree> {
10647 pub span: ::treesitter_types::Span,
10648 pub arguments: TemplateArgumentList<'tree>,
10649 pub name: TypeIdentifier<'tree>,
10650}
10651impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateType<'tree> {
10652 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10653 fn from_node(
10654 node: ::treesitter_types::tree_sitter::Node<'tree>,
10655 src: &'tree [u8],
10656 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10657 debug_assert_eq!(node.kind(), "template_type");
10658 Ok(Self {
10659 span: ::treesitter_types::Span::from(node),
10660 arguments: {
10661 let child = node.child_by_field_name("arguments").ok_or_else(|| {
10662 ::treesitter_types::ParseError::missing_field("arguments", node)
10663 })?;
10664 ::treesitter_types::runtime::maybe_grow_stack(|| {
10665 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)
10666 })?
10667 },
10668 name: {
10669 let child = node
10670 .child_by_field_name("name")
10671 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10672 ::treesitter_types::runtime::maybe_grow_stack(|| {
10673 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
10674 })?
10675 },
10676 })
10677 }
10678}
10679impl ::treesitter_types::Spanned for TemplateType<'_> {
10680 fn span(&self) -> ::treesitter_types::Span {
10681 self.span
10682 }
10683}
10684#[derive(Debug, Clone, PartialEq, Eq)]
10685pub struct ThrowSpecifier<'tree> {
10686 pub span: ::treesitter_types::Span,
10687 pub children: ::std::vec::Vec<TypeDescriptor<'tree>>,
10688}
10689impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowSpecifier<'tree> {
10690 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10691 fn from_node(
10692 node: ::treesitter_types::tree_sitter::Node<'tree>,
10693 src: &'tree [u8],
10694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10695 debug_assert_eq!(node.kind(), "throw_specifier");
10696 Ok(Self {
10697 span: ::treesitter_types::Span::from(node),
10698 children: {
10699 #[allow(clippy::suspicious_else_formatting)]
10700 let non_field_children = {
10701 let mut cursor = node.walk();
10702 let mut result = ::std::vec::Vec::new();
10703 if cursor.goto_first_child() {
10704 loop {
10705 if cursor.field_name().is_none()
10706 && cursor.node().is_named()
10707 && !cursor.node().is_extra()
10708 {
10709 result.push(cursor.node());
10710 }
10711 if !cursor.goto_next_sibling() {
10712 break;
10713 }
10714 }
10715 }
10716 result
10717 };
10718 let mut items = ::std::vec::Vec::new();
10719 for child in non_field_children {
10720 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10721 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
10722 })?);
10723 }
10724 items
10725 },
10726 })
10727 }
10728}
10729impl ::treesitter_types::Spanned for ThrowSpecifier<'_> {
10730 fn span(&self) -> ::treesitter_types::Span {
10731 self.span
10732 }
10733}
10734#[derive(Debug, Clone, PartialEq, Eq)]
10735pub struct ThrowStatement<'tree> {
10736 pub span: ::treesitter_types::Span,
10737 pub children: ::core::option::Option<Expression<'tree>>,
10738}
10739impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
10740 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10741 fn from_node(
10742 node: ::treesitter_types::tree_sitter::Node<'tree>,
10743 src: &'tree [u8],
10744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10745 debug_assert_eq!(node.kind(), "throw_statement");
10746 Ok(Self {
10747 span: ::treesitter_types::Span::from(node),
10748 children: {
10749 #[allow(clippy::suspicious_else_formatting)]
10750 let non_field_children = {
10751 let mut cursor = node.walk();
10752 let mut result = ::std::vec::Vec::new();
10753 if cursor.goto_first_child() {
10754 loop {
10755 if cursor.field_name().is_none()
10756 && cursor.node().is_named()
10757 && !cursor.node().is_extra()
10758 {
10759 result.push(cursor.node());
10760 }
10761 if !cursor.goto_next_sibling() {
10762 break;
10763 }
10764 }
10765 }
10766 result
10767 };
10768 match non_field_children.first() {
10769 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
10770 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
10771 })?),
10772 None => None,
10773 }
10774 },
10775 })
10776 }
10777}
10778impl ::treesitter_types::Spanned for ThrowStatement<'_> {
10779 fn span(&self) -> ::treesitter_types::Span {
10780 self.span
10781 }
10782}
10783#[derive(Debug, Clone, PartialEq, Eq)]
10784pub struct TrailingReturnType<'tree> {
10785 pub span: ::treesitter_types::Span,
10786 pub children: TypeDescriptor<'tree>,
10787}
10788impl<'tree> ::treesitter_types::FromNode<'tree> for TrailingReturnType<'tree> {
10789 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10790 fn from_node(
10791 node: ::treesitter_types::tree_sitter::Node<'tree>,
10792 src: &'tree [u8],
10793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10794 debug_assert_eq!(node.kind(), "trailing_return_type");
10795 Ok(Self {
10796 span: ::treesitter_types::Span::from(node),
10797 children: {
10798 #[allow(clippy::suspicious_else_formatting)]
10799 let non_field_children = {
10800 let mut cursor = node.walk();
10801 let mut result = ::std::vec::Vec::new();
10802 if cursor.goto_first_child() {
10803 loop {
10804 if cursor.field_name().is_none()
10805 && cursor.node().is_named()
10806 && !cursor.node().is_extra()
10807 {
10808 result.push(cursor.node());
10809 }
10810 if !cursor.goto_next_sibling() {
10811 break;
10812 }
10813 }
10814 }
10815 result
10816 };
10817 let child = if let Some(&c) = non_field_children.first() {
10818 c
10819 } else {
10820 let mut fallback_cursor = node.walk();
10821 let mut fallback_child = None;
10822 if fallback_cursor.goto_first_child() {
10823 loop {
10824 if fallback_cursor.field_name().is_none()
10825 && !fallback_cursor.node().is_extra()
10826 {
10827 let candidate = fallback_cursor.node();
10828 #[allow(clippy::needless_question_mark)]
10829 if (|| -> ::core::result::Result<
10830 _,
10831 ::treesitter_types::ParseError,
10832 > {
10833 let child = candidate;
10834 Ok(
10835 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeDescriptor as ::treesitter_types::FromNode>::from_node(
10836 child,
10837 src,
10838 ))?,
10839 )
10840 })()
10841 .is_ok()
10842 {
10843 fallback_child = Some(candidate);
10844 break;
10845 }
10846 }
10847 if !fallback_cursor.goto_next_sibling() {
10848 break;
10849 }
10850 }
10851 }
10852 if fallback_child.is_none() {
10853 let mut cursor2 = node.walk();
10854 if cursor2.goto_first_child() {
10855 loop {
10856 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10857 let candidate = cursor2.node();
10858 #[allow(clippy::needless_question_mark)]
10859 if (|| -> ::core::result::Result<
10860 _,
10861 ::treesitter_types::ParseError,
10862 > {
10863 let child = candidate;
10864 Ok(
10865 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeDescriptor as ::treesitter_types::FromNode>::from_node(
10866 child,
10867 src,
10868 ))?,
10869 )
10870 })()
10871 .is_ok()
10872 {
10873 fallback_child = Some(candidate);
10874 break;
10875 }
10876 }
10877 if !cursor2.goto_next_sibling() {
10878 break;
10879 }
10880 }
10881 }
10882 }
10883 fallback_child.ok_or_else(|| {
10884 ::treesitter_types::ParseError::missing_field("children", node)
10885 })?
10886 };
10887 ::treesitter_types::runtime::maybe_grow_stack(|| {
10888 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)
10889 })?
10890 },
10891 })
10892 }
10893}
10894impl ::treesitter_types::Spanned for TrailingReturnType<'_> {
10895 fn span(&self) -> ::treesitter_types::Span {
10896 self.span
10897 }
10898}
10899#[derive(Debug, Clone, PartialEq, Eq)]
10900pub struct TranslationUnit<'tree> {
10901 pub span: ::treesitter_types::Span,
10902 pub children: ::std::vec::Vec<TranslationUnitChildren<'tree>>,
10903}
10904impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnit<'tree> {
10905 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10906 fn from_node(
10907 node: ::treesitter_types::tree_sitter::Node<'tree>,
10908 src: &'tree [u8],
10909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10910 debug_assert_eq!(node.kind(), "translation_unit");
10911 Ok(Self {
10912 span: ::treesitter_types::Span::from(node),
10913 children: {
10914 #[allow(clippy::suspicious_else_formatting)]
10915 let non_field_children = {
10916 let mut cursor = node.walk();
10917 let mut result = ::std::vec::Vec::new();
10918 if cursor.goto_first_child() {
10919 loop {
10920 if cursor.field_name().is_none()
10921 && cursor.node().is_named()
10922 && !cursor.node().is_extra()
10923 {
10924 result.push(cursor.node());
10925 }
10926 if !cursor.goto_next_sibling() {
10927 break;
10928 }
10929 }
10930 }
10931 result
10932 };
10933 let mut items = ::std::vec::Vec::new();
10934 for child in non_field_children {
10935 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10936 <TranslationUnitChildren as ::treesitter_types::FromNode>::from_node(
10937 child, src,
10938 )
10939 })?);
10940 }
10941 items
10942 },
10943 })
10944 }
10945}
10946impl ::treesitter_types::Spanned for TranslationUnit<'_> {
10947 fn span(&self) -> ::treesitter_types::Span {
10948 self.span
10949 }
10950}
10951#[derive(Debug, Clone, PartialEq, Eq)]
10952pub struct TryStatement<'tree> {
10953 pub span: ::treesitter_types::Span,
10954 pub body: CompoundStatement<'tree>,
10955 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
10956}
10957impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
10958 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10959 fn from_node(
10960 node: ::treesitter_types::tree_sitter::Node<'tree>,
10961 src: &'tree [u8],
10962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10963 debug_assert_eq!(node.kind(), "try_statement");
10964 Ok(Self {
10965 span: ::treesitter_types::Span::from(node),
10966 body: {
10967 let child = node
10968 .child_by_field_name("body")
10969 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
10970 ::treesitter_types::runtime::maybe_grow_stack(|| {
10971 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
10972 })?
10973 },
10974 children: {
10975 #[allow(clippy::suspicious_else_formatting)]
10976 let non_field_children = {
10977 let mut cursor = node.walk();
10978 let mut result = ::std::vec::Vec::new();
10979 if cursor.goto_first_child() {
10980 loop {
10981 if cursor.field_name().is_none()
10982 && cursor.node().is_named()
10983 && !cursor.node().is_extra()
10984 {
10985 result.push(cursor.node());
10986 }
10987 if !cursor.goto_next_sibling() {
10988 break;
10989 }
10990 }
10991 }
10992 result
10993 };
10994 let mut items = ::std::vec::Vec::new();
10995 for child in non_field_children {
10996 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
10997 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
10998 child, src,
10999 )
11000 })?);
11001 }
11002 items
11003 },
11004 })
11005 }
11006}
11007impl ::treesitter_types::Spanned for TryStatement<'_> {
11008 fn span(&self) -> ::treesitter_types::Span {
11009 self.span
11010 }
11011}
11012#[derive(Debug, Clone, PartialEq, Eq)]
11013pub struct TypeDefinition<'tree> {
11014 pub span: ::treesitter_types::Span,
11015 pub declarator: ::std::vec::Vec<TypeDeclarator<'tree>>,
11016 pub r#type: TypeSpecifier<'tree>,
11017 pub children: ::std::vec::Vec<TypeDefinitionChildren<'tree>>,
11018}
11019impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinition<'tree> {
11020 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11021 fn from_node(
11022 node: ::treesitter_types::tree_sitter::Node<'tree>,
11023 src: &'tree [u8],
11024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11025 debug_assert_eq!(node.kind(), "type_definition");
11026 Ok(Self {
11027 span: ::treesitter_types::Span::from(node),
11028 declarator: {
11029 let mut cursor = node.walk();
11030 let mut items = ::std::vec::Vec::new();
11031 for child in node.children_by_field_name("declarator", &mut cursor) {
11032 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11033 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
11034 })?);
11035 }
11036 items
11037 },
11038 r#type: {
11039 let child = node
11040 .child_by_field_name("type")
11041 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11042 ::treesitter_types::runtime::maybe_grow_stack(|| {
11043 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
11044 })?
11045 },
11046 children: {
11047 #[allow(clippy::suspicious_else_formatting)]
11048 let non_field_children = {
11049 let mut cursor = node.walk();
11050 let mut result = ::std::vec::Vec::new();
11051 if cursor.goto_first_child() {
11052 loop {
11053 if cursor.field_name().is_none()
11054 && cursor.node().is_named()
11055 && !cursor.node().is_extra()
11056 {
11057 result.push(cursor.node());
11058 }
11059 if !cursor.goto_next_sibling() {
11060 break;
11061 }
11062 }
11063 }
11064 result
11065 };
11066 let mut items = ::std::vec::Vec::new();
11067 for child in non_field_children {
11068 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11069 <TypeDefinitionChildren as ::treesitter_types::FromNode>::from_node(
11070 child, src,
11071 )
11072 })?);
11073 }
11074 items
11075 },
11076 })
11077 }
11078}
11079impl ::treesitter_types::Spanned for TypeDefinition<'_> {
11080 fn span(&self) -> ::treesitter_types::Span {
11081 self.span
11082 }
11083}
11084#[derive(Debug, Clone, PartialEq, Eq)]
11085pub struct TypeDescriptor<'tree> {
11086 pub span: ::treesitter_types::Span,
11087 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
11088 pub r#type: TypeSpecifier<'tree>,
11089 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
11090}
11091impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDescriptor<'tree> {
11092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11093 fn from_node(
11094 node: ::treesitter_types::tree_sitter::Node<'tree>,
11095 src: &'tree [u8],
11096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11097 debug_assert_eq!(node.kind(), "type_descriptor");
11098 Ok(Self {
11099 span: ::treesitter_types::Span::from(node),
11100 declarator: match node.child_by_field_name("declarator") {
11101 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11102 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)
11103 })?),
11104 None => None,
11105 },
11106 r#type: {
11107 let child = node
11108 .child_by_field_name("type")
11109 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11110 ::treesitter_types::runtime::maybe_grow_stack(|| {
11111 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
11112 })?
11113 },
11114 children: {
11115 #[allow(clippy::suspicious_else_formatting)]
11116 let non_field_children = {
11117 let mut cursor = node.walk();
11118 let mut result = ::std::vec::Vec::new();
11119 if cursor.goto_first_child() {
11120 loop {
11121 if cursor.field_name().is_none()
11122 && cursor.node().is_named()
11123 && !cursor.node().is_extra()
11124 {
11125 result.push(cursor.node());
11126 }
11127 if !cursor.goto_next_sibling() {
11128 break;
11129 }
11130 }
11131 }
11132 result
11133 };
11134 let mut items = ::std::vec::Vec::new();
11135 for child in non_field_children {
11136 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11137 <TypeQualifier as ::treesitter_types::FromNode>::from_node(child, src)
11138 })?);
11139 }
11140 items
11141 },
11142 })
11143 }
11144}
11145impl ::treesitter_types::Spanned for TypeDescriptor<'_> {
11146 fn span(&self) -> ::treesitter_types::Span {
11147 self.span
11148 }
11149}
11150#[derive(Debug, Clone, PartialEq, Eq)]
11151pub struct TypeParameterDeclaration<'tree> {
11152 pub span: ::treesitter_types::Span,
11153 pub children: ::core::option::Option<TypeIdentifier<'tree>>,
11154}
11155impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterDeclaration<'tree> {
11156 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11157 fn from_node(
11158 node: ::treesitter_types::tree_sitter::Node<'tree>,
11159 src: &'tree [u8],
11160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11161 debug_assert_eq!(node.kind(), "type_parameter_declaration");
11162 Ok(Self {
11163 span: ::treesitter_types::Span::from(node),
11164 children: {
11165 #[allow(clippy::suspicious_else_formatting)]
11166 let non_field_children = {
11167 let mut cursor = node.walk();
11168 let mut result = ::std::vec::Vec::new();
11169 if cursor.goto_first_child() {
11170 loop {
11171 if cursor.field_name().is_none()
11172 && cursor.node().is_named()
11173 && !cursor.node().is_extra()
11174 {
11175 result.push(cursor.node());
11176 }
11177 if !cursor.goto_next_sibling() {
11178 break;
11179 }
11180 }
11181 }
11182 result
11183 };
11184 match non_field_children.first() {
11185 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11186 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
11187 })?),
11188 None => None,
11189 }
11190 },
11191 })
11192 }
11193}
11194impl ::treesitter_types::Spanned for TypeParameterDeclaration<'_> {
11195 fn span(&self) -> ::treesitter_types::Span {
11196 self.span
11197 }
11198}
11199#[derive(Debug, Clone, PartialEq, Eq)]
11200pub struct TypeQualifier<'tree> {
11201 pub span: ::treesitter_types::Span,
11202 pub children: ::core::option::Option<AlignasQualifier<'tree>>,
11203}
11204impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQualifier<'tree> {
11205 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11206 fn from_node(
11207 node: ::treesitter_types::tree_sitter::Node<'tree>,
11208 src: &'tree [u8],
11209 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11210 debug_assert_eq!(node.kind(), "type_qualifier");
11211 Ok(Self {
11212 span: ::treesitter_types::Span::from(node),
11213 children: {
11214 #[allow(clippy::suspicious_else_formatting)]
11215 let non_field_children = {
11216 let mut cursor = node.walk();
11217 let mut result = ::std::vec::Vec::new();
11218 if cursor.goto_first_child() {
11219 loop {
11220 if cursor.field_name().is_none()
11221 && cursor.node().is_named()
11222 && !cursor.node().is_extra()
11223 {
11224 result.push(cursor.node());
11225 }
11226 if !cursor.goto_next_sibling() {
11227 break;
11228 }
11229 }
11230 }
11231 result
11232 };
11233 match non_field_children.first() {
11234 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11235 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(child, src)
11236 })?),
11237 None => None,
11238 }
11239 },
11240 })
11241 }
11242}
11243impl ::treesitter_types::Spanned for TypeQualifier<'_> {
11244 fn span(&self) -> ::treesitter_types::Span {
11245 self.span
11246 }
11247}
11248#[derive(Debug, Clone, PartialEq, Eq)]
11249pub struct TypeRequirement<'tree> {
11250 pub span: ::treesitter_types::Span,
11251 pub children: TypeRequirementChildren<'tree>,
11252}
11253impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRequirement<'tree> {
11254 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11255 fn from_node(
11256 node: ::treesitter_types::tree_sitter::Node<'tree>,
11257 src: &'tree [u8],
11258 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11259 debug_assert_eq!(node.kind(), "type_requirement");
11260 Ok(Self {
11261 span: ::treesitter_types::Span::from(node),
11262 children: {
11263 #[allow(clippy::suspicious_else_formatting)]
11264 let non_field_children = {
11265 let mut cursor = node.walk();
11266 let mut result = ::std::vec::Vec::new();
11267 if cursor.goto_first_child() {
11268 loop {
11269 if cursor.field_name().is_none()
11270 && cursor.node().is_named()
11271 && !cursor.node().is_extra()
11272 {
11273 result.push(cursor.node());
11274 }
11275 if !cursor.goto_next_sibling() {
11276 break;
11277 }
11278 }
11279 }
11280 result
11281 };
11282 let child = if let Some(&c) = non_field_children.first() {
11283 c
11284 } else {
11285 let mut fallback_cursor = node.walk();
11286 let mut fallback_child = None;
11287 if fallback_cursor.goto_first_child() {
11288 loop {
11289 if fallback_cursor.field_name().is_none()
11290 && !fallback_cursor.node().is_extra()
11291 {
11292 let candidate = fallback_cursor.node();
11293 #[allow(clippy::needless_question_mark)]
11294 if (|| -> ::core::result::Result<
11295 _,
11296 ::treesitter_types::ParseError,
11297 > {
11298 let child = candidate;
11299 Ok(
11300 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(
11301 child,
11302 src,
11303 ))?,
11304 )
11305 })()
11306 .is_ok()
11307 {
11308 fallback_child = Some(candidate);
11309 break;
11310 }
11311 }
11312 if !fallback_cursor.goto_next_sibling() {
11313 break;
11314 }
11315 }
11316 }
11317 if fallback_child.is_none() {
11318 let mut cursor2 = node.walk();
11319 if cursor2.goto_first_child() {
11320 loop {
11321 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11322 let candidate = cursor2.node();
11323 #[allow(clippy::needless_question_mark)]
11324 if (|| -> ::core::result::Result<
11325 _,
11326 ::treesitter_types::ParseError,
11327 > {
11328 let child = candidate;
11329 Ok(
11330 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(
11331 child,
11332 src,
11333 ))?,
11334 )
11335 })()
11336 .is_ok()
11337 {
11338 fallback_child = Some(candidate);
11339 break;
11340 }
11341 }
11342 if !cursor2.goto_next_sibling() {
11343 break;
11344 }
11345 }
11346 }
11347 }
11348 fallback_child.ok_or_else(|| {
11349 ::treesitter_types::ParseError::missing_field("children", node)
11350 })?
11351 };
11352 ::treesitter_types::runtime::maybe_grow_stack(|| {
11353 <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(child, src)
11354 })?
11355 },
11356 })
11357 }
11358}
11359impl ::treesitter_types::Spanned for TypeRequirement<'_> {
11360 fn span(&self) -> ::treesitter_types::Span {
11361 self.span
11362 }
11363}
11364#[derive(Debug, Clone, PartialEq, Eq)]
11365pub struct UnaryExpression<'tree> {
11366 pub span: ::treesitter_types::Span,
11367 pub argument: UnaryExpressionArgument<'tree>,
11368 pub operator: UnaryExpressionOperator,
11369}
11370impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
11371 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11372 fn from_node(
11373 node: ::treesitter_types::tree_sitter::Node<'tree>,
11374 src: &'tree [u8],
11375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11376 debug_assert_eq!(node.kind(), "unary_expression");
11377 Ok(Self {
11378 span: ::treesitter_types::Span::from(node),
11379 argument: {
11380 let child = node.child_by_field_name("argument").ok_or_else(|| {
11381 ::treesitter_types::ParseError::missing_field("argument", node)
11382 })?;
11383 ::treesitter_types::runtime::maybe_grow_stack(|| {
11384 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)
11385 })?
11386 },
11387 operator: {
11388 let child = node.child_by_field_name("operator").ok_or_else(|| {
11389 ::treesitter_types::ParseError::missing_field("operator", node)
11390 })?;
11391 ::treesitter_types::runtime::maybe_grow_stack(|| {
11392 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)
11393 })?
11394 },
11395 })
11396 }
11397}
11398impl ::treesitter_types::Spanned for UnaryExpression<'_> {
11399 fn span(&self) -> ::treesitter_types::Span {
11400 self.span
11401 }
11402}
11403#[derive(Debug, Clone, PartialEq, Eq)]
11404pub struct UnionSpecifier<'tree> {
11405 pub span: ::treesitter_types::Span,
11406 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
11407 pub name: ::core::option::Option<UnionSpecifierName<'tree>>,
11408 pub children: ::std::vec::Vec<UnionSpecifierChildren<'tree>>,
11409}
11410impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifier<'tree> {
11411 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11412 fn from_node(
11413 node: ::treesitter_types::tree_sitter::Node<'tree>,
11414 src: &'tree [u8],
11415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11416 debug_assert_eq!(node.kind(), "union_specifier");
11417 Ok(Self {
11418 span: ::treesitter_types::Span::from(node),
11419 body: match node.child_by_field_name("body") {
11420 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11421 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
11422 })?),
11423 None => None,
11424 },
11425 name: match node.child_by_field_name("name") {
11426 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11427 <UnionSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)
11428 })?),
11429 None => None,
11430 },
11431 children: {
11432 #[allow(clippy::suspicious_else_formatting)]
11433 let non_field_children = {
11434 let mut cursor = node.walk();
11435 let mut result = ::std::vec::Vec::new();
11436 if cursor.goto_first_child() {
11437 loop {
11438 if cursor.field_name().is_none()
11439 && cursor.node().is_named()
11440 && !cursor.node().is_extra()
11441 {
11442 result.push(cursor.node());
11443 }
11444 if !cursor.goto_next_sibling() {
11445 break;
11446 }
11447 }
11448 }
11449 result
11450 };
11451 let mut items = ::std::vec::Vec::new();
11452 for child in non_field_children {
11453 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11454 <UnionSpecifierChildren as ::treesitter_types::FromNode>::from_node(
11455 child, src,
11456 )
11457 })?);
11458 }
11459 items
11460 },
11461 })
11462 }
11463}
11464impl ::treesitter_types::Spanned for UnionSpecifier<'_> {
11465 fn span(&self) -> ::treesitter_types::Span {
11466 self.span
11467 }
11468}
11469#[derive(Debug, Clone, PartialEq, Eq)]
11470pub struct UpdateExpression<'tree> {
11471 pub span: ::treesitter_types::Span,
11472 pub argument: Expression<'tree>,
11473 pub operator: UpdateExpressionOperator,
11474}
11475impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
11476 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11477 fn from_node(
11478 node: ::treesitter_types::tree_sitter::Node<'tree>,
11479 src: &'tree [u8],
11480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11481 debug_assert_eq!(node.kind(), "update_expression");
11482 Ok(Self {
11483 span: ::treesitter_types::Span::from(node),
11484 argument: {
11485 let child = node.child_by_field_name("argument").ok_or_else(|| {
11486 ::treesitter_types::ParseError::missing_field("argument", node)
11487 })?;
11488 ::treesitter_types::runtime::maybe_grow_stack(|| {
11489 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
11490 })?
11491 },
11492 operator: {
11493 let child = node.child_by_field_name("operator").ok_or_else(|| {
11494 ::treesitter_types::ParseError::missing_field("operator", node)
11495 })?;
11496 ::treesitter_types::runtime::maybe_grow_stack(|| {
11497 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(
11498 child, src,
11499 )
11500 })?
11501 },
11502 })
11503 }
11504}
11505impl ::treesitter_types::Spanned for UpdateExpression<'_> {
11506 fn span(&self) -> ::treesitter_types::Span {
11507 self.span
11508 }
11509}
11510#[derive(Debug, Clone, PartialEq, Eq)]
11511pub struct UserDefinedLiteral<'tree> {
11512 pub span: ::treesitter_types::Span,
11513 pub children: ::std::vec::Vec<UserDefinedLiteralChildren<'tree>>,
11514}
11515impl<'tree> ::treesitter_types::FromNode<'tree> for UserDefinedLiteral<'tree> {
11516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11517 fn from_node(
11518 node: ::treesitter_types::tree_sitter::Node<'tree>,
11519 src: &'tree [u8],
11520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11521 debug_assert_eq!(node.kind(), "user_defined_literal");
11522 Ok(Self {
11523 span: ::treesitter_types::Span::from(node),
11524 children: {
11525 #[allow(clippy::suspicious_else_formatting)]
11526 let non_field_children = {
11527 let mut cursor = node.walk();
11528 let mut result = ::std::vec::Vec::new();
11529 if cursor.goto_first_child() {
11530 loop {
11531 if cursor.field_name().is_none()
11532 && cursor.node().is_named()
11533 && !cursor.node().is_extra()
11534 {
11535 result.push(cursor.node());
11536 }
11537 if !cursor.goto_next_sibling() {
11538 break;
11539 }
11540 }
11541 }
11542 result
11543 };
11544 let mut items = ::std::vec::Vec::new();
11545 for child in non_field_children {
11546 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
11547 <UserDefinedLiteralChildren as ::treesitter_types::FromNode>::from_node(
11548 child, src,
11549 )
11550 })?);
11551 }
11552 items
11553 },
11554 })
11555 }
11556}
11557impl ::treesitter_types::Spanned for UserDefinedLiteral<'_> {
11558 fn span(&self) -> ::treesitter_types::Span {
11559 self.span
11560 }
11561}
11562#[derive(Debug, Clone, PartialEq, Eq)]
11563pub struct UsingDeclaration<'tree> {
11564 pub span: ::treesitter_types::Span,
11565 pub children: UsingDeclarationChildren<'tree>,
11566}
11567impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclaration<'tree> {
11568 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11569 fn from_node(
11570 node: ::treesitter_types::tree_sitter::Node<'tree>,
11571 src: &'tree [u8],
11572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11573 debug_assert_eq!(node.kind(), "using_declaration");
11574 Ok(Self {
11575 span: ::treesitter_types::Span::from(node),
11576 children: {
11577 #[allow(clippy::suspicious_else_formatting)]
11578 let non_field_children = {
11579 let mut cursor = node.walk();
11580 let mut result = ::std::vec::Vec::new();
11581 if cursor.goto_first_child() {
11582 loop {
11583 if cursor.field_name().is_none()
11584 && cursor.node().is_named()
11585 && !cursor.node().is_extra()
11586 {
11587 result.push(cursor.node());
11588 }
11589 if !cursor.goto_next_sibling() {
11590 break;
11591 }
11592 }
11593 }
11594 result
11595 };
11596 let child = if let Some(&c) = non_field_children.first() {
11597 c
11598 } else {
11599 let mut fallback_cursor = node.walk();
11600 let mut fallback_child = None;
11601 if fallback_cursor.goto_first_child() {
11602 loop {
11603 if fallback_cursor.field_name().is_none()
11604 && !fallback_cursor.node().is_extra()
11605 {
11606 let candidate = fallback_cursor.node();
11607 #[allow(clippy::needless_question_mark)]
11608 if (|| -> ::core::result::Result<
11609 _,
11610 ::treesitter_types::ParseError,
11611 > {
11612 let child = candidate;
11613 Ok(
11614 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11615 child,
11616 src,
11617 ))?,
11618 )
11619 })()
11620 .is_ok()
11621 {
11622 fallback_child = Some(candidate);
11623 break;
11624 }
11625 }
11626 if !fallback_cursor.goto_next_sibling() {
11627 break;
11628 }
11629 }
11630 }
11631 if fallback_child.is_none() {
11632 let mut cursor2 = node.walk();
11633 if cursor2.goto_first_child() {
11634 loop {
11635 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11636 let candidate = cursor2.node();
11637 #[allow(clippy::needless_question_mark)]
11638 if (|| -> ::core::result::Result<
11639 _,
11640 ::treesitter_types::ParseError,
11641 > {
11642 let child = candidate;
11643 Ok(
11644 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11645 child,
11646 src,
11647 ))?,
11648 )
11649 })()
11650 .is_ok()
11651 {
11652 fallback_child = Some(candidate);
11653 break;
11654 }
11655 }
11656 if !cursor2.goto_next_sibling() {
11657 break;
11658 }
11659 }
11660 }
11661 }
11662 fallback_child.ok_or_else(|| {
11663 ::treesitter_types::ParseError::missing_field("children", node)
11664 })?
11665 };
11666 ::treesitter_types::runtime::maybe_grow_stack(|| {
11667 <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11668 child, src,
11669 )
11670 })?
11671 },
11672 })
11673 }
11674}
11675impl ::treesitter_types::Spanned for UsingDeclaration<'_> {
11676 fn span(&self) -> ::treesitter_types::Span {
11677 self.span
11678 }
11679}
11680#[derive(Debug, Clone, PartialEq, Eq)]
11681pub struct VariadicDeclarator<'tree> {
11682 pub span: ::treesitter_types::Span,
11683 pub children: ::core::option::Option<Identifier<'tree>>,
11684}
11685impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicDeclarator<'tree> {
11686 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11687 fn from_node(
11688 node: ::treesitter_types::tree_sitter::Node<'tree>,
11689 src: &'tree [u8],
11690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11691 debug_assert_eq!(node.kind(), "variadic_declarator");
11692 Ok(Self {
11693 span: ::treesitter_types::Span::from(node),
11694 children: {
11695 #[allow(clippy::suspicious_else_formatting)]
11696 let non_field_children = {
11697 let mut cursor = node.walk();
11698 let mut result = ::std::vec::Vec::new();
11699 if cursor.goto_first_child() {
11700 loop {
11701 if cursor.field_name().is_none()
11702 && cursor.node().is_named()
11703 && !cursor.node().is_extra()
11704 {
11705 result.push(cursor.node());
11706 }
11707 if !cursor.goto_next_sibling() {
11708 break;
11709 }
11710 }
11711 }
11712 result
11713 };
11714 match non_field_children.first() {
11715 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11716 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)
11717 })?),
11718 None => None,
11719 }
11720 },
11721 })
11722 }
11723}
11724impl ::treesitter_types::Spanned for VariadicDeclarator<'_> {
11725 fn span(&self) -> ::treesitter_types::Span {
11726 self.span
11727 }
11728}
11729#[derive(Debug, Clone, PartialEq, Eq)]
11730pub struct VariadicParameterDeclaration<'tree> {
11731 pub span: ::treesitter_types::Span,
11732 pub declarator: VariadicParameterDeclarationDeclarator<'tree>,
11733 pub r#type: TypeSpecifier<'tree>,
11734 pub children: ::std::vec::Vec<VariadicParameterDeclarationChildren<'tree>>,
11735}
11736impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclaration<'tree> {
11737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11738 fn from_node(
11739 node: ::treesitter_types::tree_sitter::Node<'tree>,
11740 src: &'tree [u8],
11741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11742 debug_assert_eq!(node.kind(), "variadic_parameter_declaration");
11743 Ok(Self {
11744 span: ::treesitter_types::Span::from(node),
11745 declarator: {
11746 let child = node.child_by_field_name("declarator").ok_or_else(|| {
11747 ::treesitter_types::ParseError::missing_field("declarator", node)
11748 })?;
11749 ::treesitter_types::runtime::maybe_grow_stack(|| {
11750 <VariadicParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
11751 child,
11752 src,
11753 )
11754 })?
11755 },
11756 r#type: {
11757 let child = node
11758 .child_by_field_name("type")
11759 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11760 ::treesitter_types::runtime::maybe_grow_stack(|| {
11761 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)
11762 })?
11763 },
11764 children: {
11765 #[allow(clippy::suspicious_else_formatting)]
11766 let non_field_children = {
11767 let mut cursor = node.walk();
11768 let mut result = ::std::vec::Vec::new();
11769 if cursor.goto_first_child() {
11770 loop {
11771 if cursor.field_name().is_none()
11772 && cursor.node().is_named()
11773 && !cursor.node().is_extra()
11774 {
11775 result.push(cursor.node());
11776 }
11777 if !cursor.goto_next_sibling() {
11778 break;
11779 }
11780 }
11781 }
11782 result
11783 };
11784 let mut items = ::std::vec::Vec::new();
11785 for child in non_field_children {
11786 items
11787 .push(
11788 ::treesitter_types::runtime::maybe_grow_stack(|| <VariadicParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11789 child,
11790 src,
11791 ))?,
11792 );
11793 }
11794 items
11795 },
11796 })
11797 }
11798}
11799impl ::treesitter_types::Spanned for VariadicParameterDeclaration<'_> {
11800 fn span(&self) -> ::treesitter_types::Span {
11801 self.span
11802 }
11803}
11804#[derive(Debug, Clone, PartialEq, Eq)]
11805pub struct VariadicTypeParameterDeclaration<'tree> {
11806 pub span: ::treesitter_types::Span,
11807 pub children: ::core::option::Option<TypeIdentifier<'tree>>,
11808}
11809impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicTypeParameterDeclaration<'tree> {
11810 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11811 fn from_node(
11812 node: ::treesitter_types::tree_sitter::Node<'tree>,
11813 src: &'tree [u8],
11814 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11815 debug_assert_eq!(node.kind(), "variadic_type_parameter_declaration");
11816 Ok(Self {
11817 span: ::treesitter_types::Span::from(node),
11818 children: {
11819 #[allow(clippy::suspicious_else_formatting)]
11820 let non_field_children = {
11821 let mut cursor = node.walk();
11822 let mut result = ::std::vec::Vec::new();
11823 if cursor.goto_first_child() {
11824 loop {
11825 if cursor.field_name().is_none()
11826 && cursor.node().is_named()
11827 && !cursor.node().is_extra()
11828 {
11829 result.push(cursor.node());
11830 }
11831 if !cursor.goto_next_sibling() {
11832 break;
11833 }
11834 }
11835 }
11836 result
11837 };
11838 match non_field_children.first() {
11839 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
11840 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)
11841 })?),
11842 None => None,
11843 }
11844 },
11845 })
11846 }
11847}
11848impl ::treesitter_types::Spanned for VariadicTypeParameterDeclaration<'_> {
11849 fn span(&self) -> ::treesitter_types::Span {
11850 self.span
11851 }
11852}
11853#[derive(Debug, Clone, PartialEq, Eq)]
11854pub struct VirtualSpecifier<'tree> {
11855 pub span: ::treesitter_types::Span,
11856 text: &'tree str,
11857}
11858impl<'tree> ::treesitter_types::FromNode<'tree> for VirtualSpecifier<'tree> {
11859 fn from_node(
11860 node: ::treesitter_types::tree_sitter::Node<'tree>,
11861 src: &'tree [u8],
11862 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11863 debug_assert_eq!(node.kind(), "virtual_specifier");
11864 Ok(Self {
11865 span: ::treesitter_types::Span::from(node),
11866 text: node.utf8_text(src)?,
11867 })
11868 }
11869}
11870impl<'tree> ::treesitter_types::LeafNode<'tree> for VirtualSpecifier<'tree> {
11871 fn text(&self) -> &'tree str {
11872 self.text
11873 }
11874}
11875impl ::treesitter_types::Spanned for VirtualSpecifier<'_> {
11876 fn span(&self) -> ::treesitter_types::Span {
11877 self.span
11878 }
11879}
11880#[derive(Debug, Clone, PartialEq, Eq)]
11881pub struct WhileStatement<'tree> {
11882 pub span: ::treesitter_types::Span,
11883 pub body: Statement<'tree>,
11884 pub condition: ConditionClause<'tree>,
11885}
11886impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
11887 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11888 fn from_node(
11889 node: ::treesitter_types::tree_sitter::Node<'tree>,
11890 src: &'tree [u8],
11891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11892 debug_assert_eq!(node.kind(), "while_statement");
11893 Ok(Self {
11894 span: ::treesitter_types::Span::from(node),
11895 body: {
11896 let child = node
11897 .child_by_field_name("body")
11898 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11899 ::treesitter_types::runtime::maybe_grow_stack(|| {
11900 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
11901 })?
11902 },
11903 condition: {
11904 let child = node.child_by_field_name("condition").ok_or_else(|| {
11905 ::treesitter_types::ParseError::missing_field("condition", node)
11906 })?;
11907 ::treesitter_types::runtime::maybe_grow_stack(|| {
11908 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)
11909 })?
11910 },
11911 })
11912 }
11913}
11914impl ::treesitter_types::Spanned for WhileStatement<'_> {
11915 fn span(&self) -> ::treesitter_types::Span {
11916 self.span
11917 }
11918}
11919#[derive(Debug, Clone, PartialEq, Eq)]
11920pub struct Auto<'tree> {
11921 pub span: ::treesitter_types::Span,
11922 text: &'tree str,
11923}
11924impl<'tree> ::treesitter_types::FromNode<'tree> for Auto<'tree> {
11925 fn from_node(
11926 node: ::treesitter_types::tree_sitter::Node<'tree>,
11927 src: &'tree [u8],
11928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11929 debug_assert_eq!(node.kind(), "auto");
11930 Ok(Self {
11931 span: ::treesitter_types::Span::from(node),
11932 text: node.utf8_text(src)?,
11933 })
11934 }
11935}
11936impl<'tree> ::treesitter_types::LeafNode<'tree> for Auto<'tree> {
11937 fn text(&self) -> &'tree str {
11938 self.text
11939 }
11940}
11941impl ::treesitter_types::Spanned for Auto<'_> {
11942 fn span(&self) -> ::treesitter_types::Span {
11943 self.span
11944 }
11945}
11946#[derive(Debug, Clone, PartialEq, Eq)]
11947pub struct Character<'tree> {
11948 pub span: ::treesitter_types::Span,
11949 text: &'tree str,
11950}
11951impl<'tree> ::treesitter_types::FromNode<'tree> for Character<'tree> {
11952 fn from_node(
11953 node: ::treesitter_types::tree_sitter::Node<'tree>,
11954 src: &'tree [u8],
11955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11956 debug_assert_eq!(node.kind(), "character");
11957 Ok(Self {
11958 span: ::treesitter_types::Span::from(node),
11959 text: node.utf8_text(src)?,
11960 })
11961 }
11962}
11963impl<'tree> ::treesitter_types::LeafNode<'tree> for Character<'tree> {
11964 fn text(&self) -> &'tree str {
11965 self.text
11966 }
11967}
11968impl ::treesitter_types::Spanned for Character<'_> {
11969 fn span(&self) -> ::treesitter_types::Span {
11970 self.span
11971 }
11972}
11973#[derive(Debug, Clone, PartialEq, Eq)]
11974pub struct Comment<'tree> {
11975 pub span: ::treesitter_types::Span,
11976 text: &'tree str,
11977}
11978impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
11979 fn from_node(
11980 node: ::treesitter_types::tree_sitter::Node<'tree>,
11981 src: &'tree [u8],
11982 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11983 debug_assert_eq!(node.kind(), "comment");
11984 Ok(Self {
11985 span: ::treesitter_types::Span::from(node),
11986 text: node.utf8_text(src)?,
11987 })
11988 }
11989}
11990impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
11991 fn text(&self) -> &'tree str {
11992 self.text
11993 }
11994}
11995impl ::treesitter_types::Spanned for Comment<'_> {
11996 fn span(&self) -> ::treesitter_types::Span {
11997 self.span
11998 }
11999}
12000#[derive(Debug, Clone, PartialEq, Eq)]
12001pub struct EscapeSequence<'tree> {
12002 pub span: ::treesitter_types::Span,
12003 text: &'tree str,
12004}
12005impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
12006 fn from_node(
12007 node: ::treesitter_types::tree_sitter::Node<'tree>,
12008 src: &'tree [u8],
12009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12010 debug_assert_eq!(node.kind(), "escape_sequence");
12011 Ok(Self {
12012 span: ::treesitter_types::Span::from(node),
12013 text: node.utf8_text(src)?,
12014 })
12015 }
12016}
12017impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
12018 fn text(&self) -> &'tree str {
12019 self.text
12020 }
12021}
12022impl ::treesitter_types::Spanned for EscapeSequence<'_> {
12023 fn span(&self) -> ::treesitter_types::Span {
12024 self.span
12025 }
12026}
12027#[derive(Debug, Clone, PartialEq, Eq)]
12028pub struct False<'tree> {
12029 pub span: ::treesitter_types::Span,
12030 text: &'tree str,
12031}
12032impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
12033 fn from_node(
12034 node: ::treesitter_types::tree_sitter::Node<'tree>,
12035 src: &'tree [u8],
12036 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12037 debug_assert_eq!(node.kind(), "false");
12038 Ok(Self {
12039 span: ::treesitter_types::Span::from(node),
12040 text: node.utf8_text(src)?,
12041 })
12042 }
12043}
12044impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
12045 fn text(&self) -> &'tree str {
12046 self.text
12047 }
12048}
12049impl ::treesitter_types::Spanned for False<'_> {
12050 fn span(&self) -> ::treesitter_types::Span {
12051 self.span
12052 }
12053}
12054#[derive(Debug, Clone, PartialEq, Eq)]
12055pub struct FieldIdentifier<'tree> {
12056 pub span: ::treesitter_types::Span,
12057 text: &'tree str,
12058}
12059impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
12060 fn from_node(
12061 node: ::treesitter_types::tree_sitter::Node<'tree>,
12062 src: &'tree [u8],
12063 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12064 debug_assert_eq!(node.kind(), "field_identifier");
12065 Ok(Self {
12066 span: ::treesitter_types::Span::from(node),
12067 text: node.utf8_text(src)?,
12068 })
12069 }
12070}
12071impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
12072 fn text(&self) -> &'tree str {
12073 self.text
12074 }
12075}
12076impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
12077 fn span(&self) -> ::treesitter_types::Span {
12078 self.span
12079 }
12080}
12081#[derive(Debug, Clone, PartialEq, Eq)]
12082pub struct Identifier<'tree> {
12083 pub span: ::treesitter_types::Span,
12084 text: &'tree str,
12085}
12086impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
12087 fn from_node(
12088 node: ::treesitter_types::tree_sitter::Node<'tree>,
12089 src: &'tree [u8],
12090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12091 debug_assert_eq!(node.kind(), "identifier");
12092 Ok(Self {
12093 span: ::treesitter_types::Span::from(node),
12094 text: node.utf8_text(src)?,
12095 })
12096 }
12097}
12098impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
12099 fn text(&self) -> &'tree str {
12100 self.text
12101 }
12102}
12103impl ::treesitter_types::Spanned for Identifier<'_> {
12104 fn span(&self) -> ::treesitter_types::Span {
12105 self.span
12106 }
12107}
12108#[derive(Debug, Clone, PartialEq, Eq)]
12109pub struct LiteralSuffix<'tree> {
12110 pub span: ::treesitter_types::Span,
12111 text: &'tree str,
12112}
12113impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralSuffix<'tree> {
12114 fn from_node(
12115 node: ::treesitter_types::tree_sitter::Node<'tree>,
12116 src: &'tree [u8],
12117 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12118 debug_assert_eq!(node.kind(), "literal_suffix");
12119 Ok(Self {
12120 span: ::treesitter_types::Span::from(node),
12121 text: node.utf8_text(src)?,
12122 })
12123 }
12124}
12125impl<'tree> ::treesitter_types::LeafNode<'tree> for LiteralSuffix<'tree> {
12126 fn text(&self) -> &'tree str {
12127 self.text
12128 }
12129}
12130impl ::treesitter_types::Spanned for LiteralSuffix<'_> {
12131 fn span(&self) -> ::treesitter_types::Span {
12132 self.span
12133 }
12134}
12135#[derive(Debug, Clone, PartialEq, Eq)]
12136pub struct MsRestrictModifier<'tree> {
12137 pub span: ::treesitter_types::Span,
12138 text: &'tree str,
12139}
12140impl<'tree> ::treesitter_types::FromNode<'tree> for MsRestrictModifier<'tree> {
12141 fn from_node(
12142 node: ::treesitter_types::tree_sitter::Node<'tree>,
12143 src: &'tree [u8],
12144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12145 debug_assert_eq!(node.kind(), "ms_restrict_modifier");
12146 Ok(Self {
12147 span: ::treesitter_types::Span::from(node),
12148 text: node.utf8_text(src)?,
12149 })
12150 }
12151}
12152impl<'tree> ::treesitter_types::LeafNode<'tree> for MsRestrictModifier<'tree> {
12153 fn text(&self) -> &'tree str {
12154 self.text
12155 }
12156}
12157impl ::treesitter_types::Spanned for MsRestrictModifier<'_> {
12158 fn span(&self) -> ::treesitter_types::Span {
12159 self.span
12160 }
12161}
12162#[derive(Debug, Clone, PartialEq, Eq)]
12163pub struct MsSignedPtrModifier<'tree> {
12164 pub span: ::treesitter_types::Span,
12165 text: &'tree str,
12166}
12167impl<'tree> ::treesitter_types::FromNode<'tree> for MsSignedPtrModifier<'tree> {
12168 fn from_node(
12169 node: ::treesitter_types::tree_sitter::Node<'tree>,
12170 src: &'tree [u8],
12171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12172 debug_assert_eq!(node.kind(), "ms_signed_ptr_modifier");
12173 Ok(Self {
12174 span: ::treesitter_types::Span::from(node),
12175 text: node.utf8_text(src)?,
12176 })
12177 }
12178}
12179impl<'tree> ::treesitter_types::LeafNode<'tree> for MsSignedPtrModifier<'tree> {
12180 fn text(&self) -> &'tree str {
12181 self.text
12182 }
12183}
12184impl ::treesitter_types::Spanned for MsSignedPtrModifier<'_> {
12185 fn span(&self) -> ::treesitter_types::Span {
12186 self.span
12187 }
12188}
12189#[derive(Debug, Clone, PartialEq, Eq)]
12190pub struct MsUnsignedPtrModifier<'tree> {
12191 pub span: ::treesitter_types::Span,
12192 text: &'tree str,
12193}
12194impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnsignedPtrModifier<'tree> {
12195 fn from_node(
12196 node: ::treesitter_types::tree_sitter::Node<'tree>,
12197 src: &'tree [u8],
12198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12199 debug_assert_eq!(node.kind(), "ms_unsigned_ptr_modifier");
12200 Ok(Self {
12201 span: ::treesitter_types::Span::from(node),
12202 text: node.utf8_text(src)?,
12203 })
12204 }
12205}
12206impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnsignedPtrModifier<'tree> {
12207 fn text(&self) -> &'tree str {
12208 self.text
12209 }
12210}
12211impl ::treesitter_types::Spanned for MsUnsignedPtrModifier<'_> {
12212 fn span(&self) -> ::treesitter_types::Span {
12213 self.span
12214 }
12215}
12216#[derive(Debug, Clone, PartialEq, Eq)]
12217pub struct NamespaceIdentifier<'tree> {
12218 pub span: ::treesitter_types::Span,
12219 text: &'tree str,
12220}
12221impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceIdentifier<'tree> {
12222 fn from_node(
12223 node: ::treesitter_types::tree_sitter::Node<'tree>,
12224 src: &'tree [u8],
12225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12226 debug_assert_eq!(node.kind(), "namespace_identifier");
12227 Ok(Self {
12228 span: ::treesitter_types::Span::from(node),
12229 text: node.utf8_text(src)?,
12230 })
12231 }
12232}
12233impl<'tree> ::treesitter_types::LeafNode<'tree> for NamespaceIdentifier<'tree> {
12234 fn text(&self) -> &'tree str {
12235 self.text
12236 }
12237}
12238impl ::treesitter_types::Spanned for NamespaceIdentifier<'_> {
12239 fn span(&self) -> ::treesitter_types::Span {
12240 self.span
12241 }
12242}
12243#[derive(Debug, Clone, PartialEq, Eq)]
12244pub struct NumberLiteral<'tree> {
12245 pub span: ::treesitter_types::Span,
12246 text: &'tree str,
12247}
12248impl<'tree> ::treesitter_types::FromNode<'tree> for NumberLiteral<'tree> {
12249 fn from_node(
12250 node: ::treesitter_types::tree_sitter::Node<'tree>,
12251 src: &'tree [u8],
12252 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12253 debug_assert_eq!(node.kind(), "number_literal");
12254 Ok(Self {
12255 span: ::treesitter_types::Span::from(node),
12256 text: node.utf8_text(src)?,
12257 })
12258 }
12259}
12260impl<'tree> ::treesitter_types::LeafNode<'tree> for NumberLiteral<'tree> {
12261 fn text(&self) -> &'tree str {
12262 self.text
12263 }
12264}
12265impl ::treesitter_types::Spanned for NumberLiteral<'_> {
12266 fn span(&self) -> ::treesitter_types::Span {
12267 self.span
12268 }
12269}
12270#[derive(Debug, Clone, PartialEq, Eq)]
12271pub struct PreprocArg<'tree> {
12272 pub span: ::treesitter_types::Span,
12273 text: &'tree str,
12274}
12275impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
12276 fn from_node(
12277 node: ::treesitter_types::tree_sitter::Node<'tree>,
12278 src: &'tree [u8],
12279 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12280 debug_assert_eq!(node.kind(), "preproc_arg");
12281 Ok(Self {
12282 span: ::treesitter_types::Span::from(node),
12283 text: node.utf8_text(src)?,
12284 })
12285 }
12286}
12287impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
12288 fn text(&self) -> &'tree str {
12289 self.text
12290 }
12291}
12292impl ::treesitter_types::Spanned for PreprocArg<'_> {
12293 fn span(&self) -> ::treesitter_types::Span {
12294 self.span
12295 }
12296}
12297#[derive(Debug, Clone, PartialEq, Eq)]
12298pub struct PreprocDirective<'tree> {
12299 pub span: ::treesitter_types::Span,
12300 text: &'tree str,
12301}
12302impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDirective<'tree> {
12303 fn from_node(
12304 node: ::treesitter_types::tree_sitter::Node<'tree>,
12305 src: &'tree [u8],
12306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12307 debug_assert_eq!(node.kind(), "preproc_directive");
12308 Ok(Self {
12309 span: ::treesitter_types::Span::from(node),
12310 text: node.utf8_text(src)?,
12311 })
12312 }
12313}
12314impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocDirective<'tree> {
12315 fn text(&self) -> &'tree str {
12316 self.text
12317 }
12318}
12319impl ::treesitter_types::Spanned for PreprocDirective<'_> {
12320 fn span(&self) -> ::treesitter_types::Span {
12321 self.span
12322 }
12323}
12324#[derive(Debug, Clone, PartialEq, Eq)]
12325pub struct PrimitiveType<'tree> {
12326 pub span: ::treesitter_types::Span,
12327 text: &'tree str,
12328}
12329impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
12330 fn from_node(
12331 node: ::treesitter_types::tree_sitter::Node<'tree>,
12332 src: &'tree [u8],
12333 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12334 debug_assert_eq!(node.kind(), "primitive_type");
12335 Ok(Self {
12336 span: ::treesitter_types::Span::from(node),
12337 text: node.utf8_text(src)?,
12338 })
12339 }
12340}
12341impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
12342 fn text(&self) -> &'tree str {
12343 self.text
12344 }
12345}
12346impl ::treesitter_types::Spanned for PrimitiveType<'_> {
12347 fn span(&self) -> ::treesitter_types::Span {
12348 self.span
12349 }
12350}
12351#[derive(Debug, Clone, PartialEq, Eq)]
12352pub struct RawStringContent<'tree> {
12353 pub span: ::treesitter_types::Span,
12354 text: &'tree str,
12355}
12356impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringContent<'tree> {
12357 fn from_node(
12358 node: ::treesitter_types::tree_sitter::Node<'tree>,
12359 src: &'tree [u8],
12360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12361 debug_assert_eq!(node.kind(), "raw_string_content");
12362 Ok(Self {
12363 span: ::treesitter_types::Span::from(node),
12364 text: node.utf8_text(src)?,
12365 })
12366 }
12367}
12368impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringContent<'tree> {
12369 fn text(&self) -> &'tree str {
12370 self.text
12371 }
12372}
12373impl ::treesitter_types::Spanned for RawStringContent<'_> {
12374 fn span(&self) -> ::treesitter_types::Span {
12375 self.span
12376 }
12377}
12378#[derive(Debug, Clone, PartialEq, Eq)]
12379pub struct RawStringDelimiter<'tree> {
12380 pub span: ::treesitter_types::Span,
12381 text: &'tree str,
12382}
12383impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringDelimiter<'tree> {
12384 fn from_node(
12385 node: ::treesitter_types::tree_sitter::Node<'tree>,
12386 src: &'tree [u8],
12387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12388 debug_assert_eq!(node.kind(), "raw_string_delimiter");
12389 Ok(Self {
12390 span: ::treesitter_types::Span::from(node),
12391 text: node.utf8_text(src)?,
12392 })
12393 }
12394}
12395impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringDelimiter<'tree> {
12396 fn text(&self) -> &'tree str {
12397 self.text
12398 }
12399}
12400impl ::treesitter_types::Spanned for RawStringDelimiter<'_> {
12401 fn span(&self) -> ::treesitter_types::Span {
12402 self.span
12403 }
12404}
12405#[derive(Debug, Clone, PartialEq, Eq)]
12406pub struct StatementIdentifier<'tree> {
12407 pub span: ::treesitter_types::Span,
12408 text: &'tree str,
12409}
12410impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
12411 fn from_node(
12412 node: ::treesitter_types::tree_sitter::Node<'tree>,
12413 src: &'tree [u8],
12414 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12415 debug_assert_eq!(node.kind(), "statement_identifier");
12416 Ok(Self {
12417 span: ::treesitter_types::Span::from(node),
12418 text: node.utf8_text(src)?,
12419 })
12420 }
12421}
12422impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
12423 fn text(&self) -> &'tree str {
12424 self.text
12425 }
12426}
12427impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
12428 fn span(&self) -> ::treesitter_types::Span {
12429 self.span
12430 }
12431}
12432#[derive(Debug, Clone, PartialEq, Eq)]
12433pub struct StringContent<'tree> {
12434 pub span: ::treesitter_types::Span,
12435 text: &'tree str,
12436}
12437impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
12438 fn from_node(
12439 node: ::treesitter_types::tree_sitter::Node<'tree>,
12440 src: &'tree [u8],
12441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12442 debug_assert_eq!(node.kind(), "string_content");
12443 Ok(Self {
12444 span: ::treesitter_types::Span::from(node),
12445 text: node.utf8_text(src)?,
12446 })
12447 }
12448}
12449impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
12450 fn text(&self) -> &'tree str {
12451 self.text
12452 }
12453}
12454impl ::treesitter_types::Spanned for StringContent<'_> {
12455 fn span(&self) -> ::treesitter_types::Span {
12456 self.span
12457 }
12458}
12459#[derive(Debug, Clone, PartialEq, Eq)]
12460pub struct SystemLibString<'tree> {
12461 pub span: ::treesitter_types::Span,
12462 text: &'tree str,
12463}
12464impl<'tree> ::treesitter_types::FromNode<'tree> for SystemLibString<'tree> {
12465 fn from_node(
12466 node: ::treesitter_types::tree_sitter::Node<'tree>,
12467 src: &'tree [u8],
12468 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12469 debug_assert_eq!(node.kind(), "system_lib_string");
12470 Ok(Self {
12471 span: ::treesitter_types::Span::from(node),
12472 text: node.utf8_text(src)?,
12473 })
12474 }
12475}
12476impl<'tree> ::treesitter_types::LeafNode<'tree> for SystemLibString<'tree> {
12477 fn text(&self) -> &'tree str {
12478 self.text
12479 }
12480}
12481impl ::treesitter_types::Spanned for SystemLibString<'_> {
12482 fn span(&self) -> ::treesitter_types::Span {
12483 self.span
12484 }
12485}
12486#[derive(Debug, Clone, PartialEq, Eq)]
12487pub struct This<'tree> {
12488 pub span: ::treesitter_types::Span,
12489 text: &'tree str,
12490}
12491impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
12492 fn from_node(
12493 node: ::treesitter_types::tree_sitter::Node<'tree>,
12494 src: &'tree [u8],
12495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12496 debug_assert_eq!(node.kind(), "this");
12497 Ok(Self {
12498 span: ::treesitter_types::Span::from(node),
12499 text: node.utf8_text(src)?,
12500 })
12501 }
12502}
12503impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
12504 fn text(&self) -> &'tree str {
12505 self.text
12506 }
12507}
12508impl ::treesitter_types::Spanned for This<'_> {
12509 fn span(&self) -> ::treesitter_types::Span {
12510 self.span
12511 }
12512}
12513#[derive(Debug, Clone, PartialEq, Eq)]
12514pub struct True<'tree> {
12515 pub span: ::treesitter_types::Span,
12516 text: &'tree str,
12517}
12518impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
12519 fn from_node(
12520 node: ::treesitter_types::tree_sitter::Node<'tree>,
12521 src: &'tree [u8],
12522 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12523 debug_assert_eq!(node.kind(), "true");
12524 Ok(Self {
12525 span: ::treesitter_types::Span::from(node),
12526 text: node.utf8_text(src)?,
12527 })
12528 }
12529}
12530impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
12531 fn text(&self) -> &'tree str {
12532 self.text
12533 }
12534}
12535impl ::treesitter_types::Spanned for True<'_> {
12536 fn span(&self) -> ::treesitter_types::Span {
12537 self.span
12538 }
12539}
12540#[derive(Debug, Clone, PartialEq, Eq)]
12541pub struct TypeIdentifier<'tree> {
12542 pub span: ::treesitter_types::Span,
12543 text: &'tree str,
12544}
12545impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
12546 fn from_node(
12547 node: ::treesitter_types::tree_sitter::Node<'tree>,
12548 src: &'tree [u8],
12549 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12550 debug_assert_eq!(node.kind(), "type_identifier");
12551 Ok(Self {
12552 span: ::treesitter_types::Span::from(node),
12553 text: node.utf8_text(src)?,
12554 })
12555 }
12556}
12557impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
12558 fn text(&self) -> &'tree str {
12559 self.text
12560 }
12561}
12562impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
12563 fn span(&self) -> ::treesitter_types::Span {
12564 self.span
12565 }
12566}
12567#[derive(Debug, Clone, PartialEq, Eq)]
12568pub enum AbstractArrayDeclaratorSize<'tree> {
12569 Star(::treesitter_types::Span),
12570 Expression(::std::boxed::Box<Expression<'tree>>),
12571}
12572impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclaratorSize<'tree> {
12573 #[allow(clippy::collapsible_else_if)]
12574 fn from_node(
12575 node: ::treesitter_types::tree_sitter::Node<'tree>,
12576 src: &'tree [u8],
12577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12578 match node.kind() {
12579 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
12580 _other => {
12581 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12582 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12583 }) {
12584 Ok(Self::Expression(::std::boxed::Box::new(v)))
12585 } else {
12586 Err(::treesitter_types::ParseError::unexpected_kind(
12587 _other, node,
12588 ))
12589 }
12590 }
12591 }
12592 }
12593}
12594impl ::treesitter_types::Spanned for AbstractArrayDeclaratorSize<'_> {
12595 fn span(&self) -> ::treesitter_types::Span {
12596 match self {
12597 Self::Star(span) => *span,
12598 Self::Expression(inner) => inner.span(),
12599 }
12600 }
12601}
12602#[derive(Debug, Clone, PartialEq, Eq)]
12603pub enum AbstractFunctionDeclaratorChildren<'tree> {
12604 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
12605 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
12606 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
12607 Noexcept(::std::boxed::Box<Noexcept<'tree>>),
12608 RefQualifier(::std::boxed::Box<RefQualifier<'tree>>),
12609 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
12610 ThrowSpecifier(::std::boxed::Box<ThrowSpecifier<'tree>>),
12611 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
12612 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
12613 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
12614}
12615impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFunctionDeclaratorChildren<'tree> {
12616 #[allow(clippy::collapsible_else_if)]
12617 fn from_node(
12618 node: ::treesitter_types::tree_sitter::Node<'tree>,
12619 src: &'tree [u8],
12620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12621 match node.kind() {
12622 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
12623 ::treesitter_types::runtime::maybe_grow_stack(|| {
12624 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
12625 })?,
12626 ))),
12627 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
12628 ::treesitter_types::runtime::maybe_grow_stack(|| {
12629 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12630 })?,
12631 ))),
12632 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
12633 ::treesitter_types::runtime::maybe_grow_stack(|| {
12634 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
12635 })?,
12636 ))),
12637 "noexcept" => Ok(Self::Noexcept(::std::boxed::Box::new(
12638 ::treesitter_types::runtime::maybe_grow_stack(|| {
12639 <Noexcept as ::treesitter_types::FromNode>::from_node(node, src)
12640 })?,
12641 ))),
12642 "ref_qualifier" => Ok(Self::RefQualifier(::std::boxed::Box::new(
12643 ::treesitter_types::runtime::maybe_grow_stack(|| {
12644 <RefQualifier as ::treesitter_types::FromNode>::from_node(node, src)
12645 })?,
12646 ))),
12647 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
12648 ::treesitter_types::runtime::maybe_grow_stack(|| {
12649 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)
12650 })?,
12651 ))),
12652 "throw_specifier" => Ok(Self::ThrowSpecifier(::std::boxed::Box::new(
12653 ::treesitter_types::runtime::maybe_grow_stack(|| {
12654 <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12655 })?,
12656 ))),
12657 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
12658 ::treesitter_types::runtime::maybe_grow_stack(|| {
12659 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)
12660 })?,
12661 ))),
12662 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
12663 ::treesitter_types::runtime::maybe_grow_stack(|| {
12664 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
12665 })?,
12666 ))),
12667 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
12668 ::treesitter_types::runtime::maybe_grow_stack(|| {
12669 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
12670 })?,
12671 ))),
12672 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12673 }
12674 }
12675}
12676impl ::treesitter_types::Spanned for AbstractFunctionDeclaratorChildren<'_> {
12677 fn span(&self) -> ::treesitter_types::Span {
12678 match self {
12679 Self::AttributeDeclaration(inner) => inner.span(),
12680 Self::AttributeSpecifier(inner) => inner.span(),
12681 Self::GnuAsmExpression(inner) => inner.span(),
12682 Self::Noexcept(inner) => inner.span(),
12683 Self::RefQualifier(inner) => inner.span(),
12684 Self::RequiresClause(inner) => inner.span(),
12685 Self::ThrowSpecifier(inner) => inner.span(),
12686 Self::TrailingReturnType(inner) => inner.span(),
12687 Self::TypeQualifier(inner) => inner.span(),
12688 Self::VirtualSpecifier(inner) => inner.span(),
12689 }
12690 }
12691}
12692#[derive(Debug, Clone, PartialEq, Eq)]
12693pub enum AbstractParenthesizedDeclaratorChildren<'tree> {
12694 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
12695 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
12696}
12697impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclaratorChildren<'tree> {
12698 #[allow(clippy::collapsible_else_if)]
12699 fn from_node(
12700 node: ::treesitter_types::tree_sitter::Node<'tree>,
12701 src: &'tree [u8],
12702 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12703 match node.kind() {
12704 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
12705 ::treesitter_types::runtime::maybe_grow_stack(|| {
12706 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
12707 })?,
12708 ))),
12709 _other => {
12710 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12711 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12712 }) {
12713 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
12714 } else {
12715 Err(::treesitter_types::ParseError::unexpected_kind(
12716 _other, node,
12717 ))
12718 }
12719 }
12720 }
12721 }
12722}
12723impl ::treesitter_types::Spanned for AbstractParenthesizedDeclaratorChildren<'_> {
12724 fn span(&self) -> ::treesitter_types::Span {
12725 match self {
12726 Self::AbstractDeclarator(inner) => inner.span(),
12727 Self::MsCallModifier(inner) => inner.span(),
12728 }
12729 }
12730}
12731#[derive(Debug, Clone, PartialEq, Eq)]
12732pub enum AbstractPointerDeclaratorChildren<'tree> {
12733 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
12734 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
12735}
12736impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclaratorChildren<'tree> {
12737 #[allow(clippy::collapsible_else_if)]
12738 fn from_node(
12739 node: ::treesitter_types::tree_sitter::Node<'tree>,
12740 src: &'tree [u8],
12741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12742 match node.kind() {
12743 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
12744 ::treesitter_types::runtime::maybe_grow_stack(|| {
12745 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
12746 })?,
12747 ))),
12748 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
12749 ::treesitter_types::runtime::maybe_grow_stack(|| {
12750 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
12751 })?,
12752 ))),
12753 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12754 }
12755 }
12756}
12757impl ::treesitter_types::Spanned for AbstractPointerDeclaratorChildren<'_> {
12758 fn span(&self) -> ::treesitter_types::Span {
12759 match self {
12760 Self::MsPointerModifier(inner) => inner.span(),
12761 Self::TypeQualifier(inner) => inner.span(),
12762 }
12763 }
12764}
12765#[derive(Debug, Clone, PartialEq, Eq)]
12766pub enum AlignasQualifierChildren<'tree> {
12767 Expression(::std::boxed::Box<Expression<'tree>>),
12768 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
12769}
12770impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifierChildren<'tree> {
12771 #[allow(clippy::collapsible_else_if)]
12772 fn from_node(
12773 node: ::treesitter_types::tree_sitter::Node<'tree>,
12774 src: &'tree [u8],
12775 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12776 match node.kind() {
12777 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
12778 ::treesitter_types::runtime::maybe_grow_stack(|| {
12779 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
12780 })?,
12781 ))),
12782 _other => {
12783 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12784 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12785 }) {
12786 Ok(Self::Expression(::std::boxed::Box::new(v)))
12787 } else {
12788 Err(::treesitter_types::ParseError::unexpected_kind(
12789 _other, node,
12790 ))
12791 }
12792 }
12793 }
12794 }
12795}
12796impl ::treesitter_types::Spanned for AlignasQualifierChildren<'_> {
12797 fn span(&self) -> ::treesitter_types::Span {
12798 match self {
12799 Self::Expression(inner) => inner.span(),
12800 Self::TypeDescriptor(inner) => inner.span(),
12801 }
12802 }
12803}
12804#[derive(Debug, Clone, PartialEq, Eq)]
12805pub enum ArgumentListChildren<'tree> {
12806 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
12807 Expression(::std::boxed::Box<Expression<'tree>>),
12808 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
12809 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
12810}
12811impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
12812 #[allow(clippy::collapsible_else_if)]
12813 fn from_node(
12814 node: ::treesitter_types::tree_sitter::Node<'tree>,
12815 src: &'tree [u8],
12816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12817 match node.kind() {
12818 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
12819 ::treesitter_types::runtime::maybe_grow_stack(|| {
12820 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
12821 })?,
12822 ))),
12823 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
12824 ::treesitter_types::runtime::maybe_grow_stack(|| {
12825 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
12826 })?,
12827 ))),
12828 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
12829 ::treesitter_types::runtime::maybe_grow_stack(|| {
12830 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
12831 })?,
12832 ))),
12833 _other => {
12834 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12835 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12836 }) {
12837 Ok(Self::Expression(::std::boxed::Box::new(v)))
12838 } else {
12839 Err(::treesitter_types::ParseError::unexpected_kind(
12840 _other, node,
12841 ))
12842 }
12843 }
12844 }
12845 }
12846}
12847impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
12848 fn span(&self) -> ::treesitter_types::Span {
12849 match self {
12850 Self::CompoundStatement(inner) => inner.span(),
12851 Self::Expression(inner) => inner.span(),
12852 Self::InitializerList(inner) => inner.span(),
12853 Self::PreprocDefined(inner) => inner.span(),
12854 }
12855 }
12856}
12857#[derive(Debug, Clone, PartialEq, Eq)]
12858pub enum ArrayDeclaratorDeclarator<'tree> {
12859 Declarator(::std::boxed::Box<Declarator<'tree>>),
12860 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
12861 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
12862}
12863impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorDeclarator<'tree> {
12864 #[allow(clippy::collapsible_else_if)]
12865 fn from_node(
12866 node: ::treesitter_types::tree_sitter::Node<'tree>,
12867 src: &'tree [u8],
12868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12869 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12870 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
12871 }) {
12872 Ok(Self::Declarator(::std::boxed::Box::new(v)))
12873 } else {
12874 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12875 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12876 }) {
12877 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
12878 } else {
12879 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12880 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12881 }) {
12882 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
12883 } else {
12884 Err(::treesitter_types::ParseError::unexpected_kind(
12885 node.kind(),
12886 node,
12887 ))
12888 }
12889 }
12890 }
12891 }
12892}
12893impl ::treesitter_types::Spanned for ArrayDeclaratorDeclarator<'_> {
12894 fn span(&self) -> ::treesitter_types::Span {
12895 match self {
12896 Self::Declarator(inner) => inner.span(),
12897 Self::FieldDeclarator(inner) => inner.span(),
12898 Self::TypeDeclarator(inner) => inner.span(),
12899 }
12900 }
12901}
12902#[derive(Debug, Clone, PartialEq, Eq)]
12903pub enum ArrayDeclaratorSize<'tree> {
12904 Star(::treesitter_types::Span),
12905 Expression(::std::boxed::Box<Expression<'tree>>),
12906}
12907impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorSize<'tree> {
12908 #[allow(clippy::collapsible_else_if)]
12909 fn from_node(
12910 node: ::treesitter_types::tree_sitter::Node<'tree>,
12911 src: &'tree [u8],
12912 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12913 match node.kind() {
12914 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
12915 _other => {
12916 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12917 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12918 }) {
12919 Ok(Self::Expression(::std::boxed::Box::new(v)))
12920 } else {
12921 Err(::treesitter_types::ParseError::unexpected_kind(
12922 _other, node,
12923 ))
12924 }
12925 }
12926 }
12927 }
12928}
12929impl ::treesitter_types::Spanned for ArrayDeclaratorSize<'_> {
12930 fn span(&self) -> ::treesitter_types::Span {
12931 match self {
12932 Self::Star(span) => *span,
12933 Self::Expression(inner) => inner.span(),
12934 }
12935 }
12936}
12937#[derive(Debug, Clone, PartialEq, Eq)]
12938pub enum AssignmentExpressionOperator {
12939 PercentEq(::treesitter_types::Span),
12940 AmpEq(::treesitter_types::Span),
12941 StarEq(::treesitter_types::Span),
12942 PlusEq(::treesitter_types::Span),
12943 MinusEq(::treesitter_types::Span),
12944 SlashEq(::treesitter_types::Span),
12945 ShlEq(::treesitter_types::Span),
12946 Eq(::treesitter_types::Span),
12947 ShrEq(::treesitter_types::Span),
12948 CaretEq(::treesitter_types::Span),
12949 AndEq(::treesitter_types::Span),
12950 OrEq(::treesitter_types::Span),
12951 XorEq(::treesitter_types::Span),
12952 PipeEq(::treesitter_types::Span),
12953}
12954impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
12955 #[allow(clippy::collapsible_else_if)]
12956 fn from_node(
12957 node: ::treesitter_types::tree_sitter::Node<'tree>,
12958 _src: &'tree [u8],
12959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12960 match node.kind() {
12961 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
12962 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
12963 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
12964 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
12965 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
12966 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
12967 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
12968 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
12969 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
12970 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
12971 "and_eq" => Ok(Self::AndEq(::treesitter_types::Span::from(node))),
12972 "or_eq" => Ok(Self::OrEq(::treesitter_types::Span::from(node))),
12973 "xor_eq" => Ok(Self::XorEq(::treesitter_types::Span::from(node))),
12974 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
12975 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12976 }
12977 }
12978}
12979impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
12980 fn span(&self) -> ::treesitter_types::Span {
12981 match self {
12982 Self::PercentEq(span) => *span,
12983 Self::AmpEq(span) => *span,
12984 Self::StarEq(span) => *span,
12985 Self::PlusEq(span) => *span,
12986 Self::MinusEq(span) => *span,
12987 Self::SlashEq(span) => *span,
12988 Self::ShlEq(span) => *span,
12989 Self::Eq(span) => *span,
12990 Self::ShrEq(span) => *span,
12991 Self::CaretEq(span) => *span,
12992 Self::AndEq(span) => *span,
12993 Self::OrEq(span) => *span,
12994 Self::XorEq(span) => *span,
12995 Self::PipeEq(span) => *span,
12996 }
12997 }
12998}
12999#[derive(Debug, Clone, PartialEq, Eq)]
13000pub enum AssignmentExpressionRight<'tree> {
13001 Expression(::std::boxed::Box<Expression<'tree>>),
13002 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
13003}
13004impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionRight<'tree> {
13005 #[allow(clippy::collapsible_else_if)]
13006 fn from_node(
13007 node: ::treesitter_types::tree_sitter::Node<'tree>,
13008 src: &'tree [u8],
13009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13010 match node.kind() {
13011 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
13012 ::treesitter_types::runtime::maybe_grow_stack(|| {
13013 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
13014 })?,
13015 ))),
13016 _other => {
13017 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13018 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13019 }) {
13020 Ok(Self::Expression(::std::boxed::Box::new(v)))
13021 } else {
13022 Err(::treesitter_types::ParseError::unexpected_kind(
13023 _other, node,
13024 ))
13025 }
13026 }
13027 }
13028 }
13029}
13030impl ::treesitter_types::Spanned for AssignmentExpressionRight<'_> {
13031 fn span(&self) -> ::treesitter_types::Span {
13032 match self {
13033 Self::Expression(inner) => inner.span(),
13034 Self::InitializerList(inner) => inner.span(),
13035 }
13036 }
13037}
13038#[derive(Debug, Clone, PartialEq, Eq)]
13039pub enum AttributedDeclaratorChildren<'tree> {
13040 Declarator(::std::boxed::Box<Declarator<'tree>>),
13041 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
13042 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
13043 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13044}
13045impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclaratorChildren<'tree> {
13046 #[allow(clippy::collapsible_else_if)]
13047 fn from_node(
13048 node: ::treesitter_types::tree_sitter::Node<'tree>,
13049 src: &'tree [u8],
13050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13051 match node.kind() {
13052 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13053 ::treesitter_types::runtime::maybe_grow_stack(|| {
13054 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13055 })?,
13056 ))),
13057 _other => {
13058 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13059 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
13060 }) {
13061 Ok(Self::Declarator(::std::boxed::Box::new(v)))
13062 } else {
13063 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13064 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
13065 }) {
13066 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
13067 } else {
13068 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13069 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
13070 }) {
13071 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
13072 } else {
13073 Err(::treesitter_types::ParseError::unexpected_kind(
13074 _other, node,
13075 ))
13076 }
13077 }
13078 }
13079 }
13080 }
13081 }
13082}
13083impl ::treesitter_types::Spanned for AttributedDeclaratorChildren<'_> {
13084 fn span(&self) -> ::treesitter_types::Span {
13085 match self {
13086 Self::Declarator(inner) => inner.span(),
13087 Self::FieldDeclarator(inner) => inner.span(),
13088 Self::TypeDeclarator(inner) => inner.span(),
13089 Self::AttributeDeclaration(inner) => inner.span(),
13090 }
13091 }
13092}
13093#[derive(Debug, Clone, PartialEq, Eq)]
13094pub enum AttributedStatementChildren<'tree> {
13095 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13096 Statement(::std::boxed::Box<Statement<'tree>>),
13097}
13098impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatementChildren<'tree> {
13099 #[allow(clippy::collapsible_else_if)]
13100 fn from_node(
13101 node: ::treesitter_types::tree_sitter::Node<'tree>,
13102 src: &'tree [u8],
13103 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13104 match node.kind() {
13105 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13106 ::treesitter_types::runtime::maybe_grow_stack(|| {
13107 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13108 })?,
13109 ))),
13110 _other => {
13111 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13112 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
13113 }) {
13114 Ok(Self::Statement(::std::boxed::Box::new(v)))
13115 } else {
13116 Err(::treesitter_types::ParseError::unexpected_kind(
13117 _other, node,
13118 ))
13119 }
13120 }
13121 }
13122 }
13123}
13124impl ::treesitter_types::Spanned for AttributedStatementChildren<'_> {
13125 fn span(&self) -> ::treesitter_types::Span {
13126 match self {
13127 Self::AttributeDeclaration(inner) => inner.span(),
13128 Self::Statement(inner) => inner.span(),
13129 }
13130 }
13131}
13132#[derive(Debug, Clone, PartialEq, Eq)]
13133pub enum BaseClassClauseChildren<'tree> {
13134 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
13135 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13136 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
13137 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13138 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13139}
13140impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClassClauseChildren<'tree> {
13141 #[allow(clippy::collapsible_else_if)]
13142 fn from_node(
13143 node: ::treesitter_types::tree_sitter::Node<'tree>,
13144 src: &'tree [u8],
13145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13146 match node.kind() {
13147 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
13148 ::treesitter_types::runtime::maybe_grow_stack(|| {
13149 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13150 })?,
13151 ))),
13152 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13153 ::treesitter_types::runtime::maybe_grow_stack(|| {
13154 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13155 })?,
13156 ))),
13157 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
13158 ::treesitter_types::runtime::maybe_grow_stack(|| {
13159 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13160 })?,
13161 ))),
13162 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13163 ::treesitter_types::runtime::maybe_grow_stack(|| {
13164 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
13165 })?,
13166 ))),
13167 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13168 ::treesitter_types::runtime::maybe_grow_stack(|| {
13169 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13170 })?,
13171 ))),
13172 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13173 }
13174 }
13175}
13176impl ::treesitter_types::Spanned for BaseClassClauseChildren<'_> {
13177 fn span(&self) -> ::treesitter_types::Span {
13178 match self {
13179 Self::AccessSpecifier(inner) => inner.span(),
13180 Self::AttributeDeclaration(inner) => inner.span(),
13181 Self::QualifiedIdentifier(inner) => inner.span(),
13182 Self::TemplateType(inner) => inner.span(),
13183 Self::TypeIdentifier(inner) => inner.span(),
13184 }
13185 }
13186}
13187#[derive(Debug, Clone, PartialEq, Eq)]
13188pub enum BinaryExpressionLeft<'tree> {
13189 Expression(::std::boxed::Box<Expression<'tree>>),
13190 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
13191}
13192impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
13193 #[allow(clippy::collapsible_else_if)]
13194 fn from_node(
13195 node: ::treesitter_types::tree_sitter::Node<'tree>,
13196 src: &'tree [u8],
13197 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13198 match node.kind() {
13199 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
13200 ::treesitter_types::runtime::maybe_grow_stack(|| {
13201 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
13202 })?,
13203 ))),
13204 _other => {
13205 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13206 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13207 }) {
13208 Ok(Self::Expression(::std::boxed::Box::new(v)))
13209 } else {
13210 Err(::treesitter_types::ParseError::unexpected_kind(
13211 _other, node,
13212 ))
13213 }
13214 }
13215 }
13216 }
13217}
13218impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
13219 fn span(&self) -> ::treesitter_types::Span {
13220 match self {
13221 Self::Expression(inner) => inner.span(),
13222 Self::PreprocDefined(inner) => inner.span(),
13223 }
13224 }
13225}
13226#[derive(Debug, Clone, PartialEq, Eq)]
13227pub enum BinaryExpressionOperator {
13228 NotEq(::treesitter_types::Span),
13229 Percent(::treesitter_types::Span),
13230 Amp(::treesitter_types::Span),
13231 AmpAmp(::treesitter_types::Span),
13232 Star(::treesitter_types::Span),
13233 Plus(::treesitter_types::Span),
13234 Minus(::treesitter_types::Span),
13235 Slash(::treesitter_types::Span),
13236 Lt(::treesitter_types::Span),
13237 Shl(::treesitter_types::Span),
13238 LtEq(::treesitter_types::Span),
13239 LtEqGt(::treesitter_types::Span),
13240 EqEq(::treesitter_types::Span),
13241 Gt(::treesitter_types::Span),
13242 GtEq(::treesitter_types::Span),
13243 Shr(::treesitter_types::Span),
13244 Caret(::treesitter_types::Span),
13245 And(::treesitter_types::Span),
13246 Bitand(::treesitter_types::Span),
13247 Bitor(::treesitter_types::Span),
13248 Or(::treesitter_types::Span),
13249 Xor(::treesitter_types::Span),
13250 Pipe(::treesitter_types::Span),
13251 PipePipe(::treesitter_types::Span),
13252}
13253impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
13254 #[allow(clippy::collapsible_else_if)]
13255 fn from_node(
13256 node: ::treesitter_types::tree_sitter::Node<'tree>,
13257 _src: &'tree [u8],
13258 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13259 match node.kind() {
13260 "!=" | "not_eq" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
13261 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
13262 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
13263 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
13264 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
13265 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
13266 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
13267 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
13268 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
13269 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
13270 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
13271 "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
13272 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
13273 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
13274 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
13275 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
13276 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
13277 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
13278 "bitand" => Ok(Self::Bitand(::treesitter_types::Span::from(node))),
13279 "bitor" => Ok(Self::Bitor(::treesitter_types::Span::from(node))),
13280 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
13281 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
13282 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
13283 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
13284 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13285 }
13286 }
13287}
13288impl ::treesitter_types::Spanned for BinaryExpressionOperator {
13289 fn span(&self) -> ::treesitter_types::Span {
13290 match self {
13291 Self::NotEq(span) => *span,
13292 Self::Percent(span) => *span,
13293 Self::Amp(span) => *span,
13294 Self::AmpAmp(span) => *span,
13295 Self::Star(span) => *span,
13296 Self::Plus(span) => *span,
13297 Self::Minus(span) => *span,
13298 Self::Slash(span) => *span,
13299 Self::Lt(span) => *span,
13300 Self::Shl(span) => *span,
13301 Self::LtEq(span) => *span,
13302 Self::LtEqGt(span) => *span,
13303 Self::EqEq(span) => *span,
13304 Self::Gt(span) => *span,
13305 Self::GtEq(span) => *span,
13306 Self::Shr(span) => *span,
13307 Self::Caret(span) => *span,
13308 Self::And(span) => *span,
13309 Self::Bitand(span) => *span,
13310 Self::Bitor(span) => *span,
13311 Self::Or(span) => *span,
13312 Self::Xor(span) => *span,
13313 Self::Pipe(span) => *span,
13314 Self::PipePipe(span) => *span,
13315 }
13316 }
13317}
13318#[derive(Debug, Clone, PartialEq, Eq)]
13319pub enum BinaryExpressionRight<'tree> {
13320 Expression(::std::boxed::Box<Expression<'tree>>),
13321 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
13322}
13323impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
13324 #[allow(clippy::collapsible_else_if)]
13325 fn from_node(
13326 node: ::treesitter_types::tree_sitter::Node<'tree>,
13327 src: &'tree [u8],
13328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13329 match node.kind() {
13330 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
13331 ::treesitter_types::runtime::maybe_grow_stack(|| {
13332 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
13333 })?,
13334 ))),
13335 _other => {
13336 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13337 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13338 }) {
13339 Ok(Self::Expression(::std::boxed::Box::new(v)))
13340 } else {
13341 Err(::treesitter_types::ParseError::unexpected_kind(
13342 _other, node,
13343 ))
13344 }
13345 }
13346 }
13347 }
13348}
13349impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
13350 fn span(&self) -> ::treesitter_types::Span {
13351 match self {
13352 Self::Expression(inner) => inner.span(),
13353 Self::PreprocDefined(inner) => inner.span(),
13354 }
13355 }
13356}
13357#[derive(Debug, Clone, PartialEq, Eq)]
13358pub enum CallExpressionFunction<'tree> {
13359 Expression(::std::boxed::Box<Expression<'tree>>),
13360 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13361}
13362impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
13363 #[allow(clippy::collapsible_else_if)]
13364 fn from_node(
13365 node: ::treesitter_types::tree_sitter::Node<'tree>,
13366 src: &'tree [u8],
13367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13368 match node.kind() {
13369 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13370 ::treesitter_types::runtime::maybe_grow_stack(|| {
13371 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13372 })?,
13373 ))),
13374 _other => {
13375 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13376 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13377 }) {
13378 Ok(Self::Expression(::std::boxed::Box::new(v)))
13379 } else {
13380 Err(::treesitter_types::ParseError::unexpected_kind(
13381 _other, node,
13382 ))
13383 }
13384 }
13385 }
13386 }
13387}
13388impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
13389 fn span(&self) -> ::treesitter_types::Span {
13390 match self {
13391 Self::Expression(inner) => inner.span(),
13392 Self::PrimitiveType(inner) => inner.span(),
13393 }
13394 }
13395}
13396#[derive(Debug, Clone, PartialEq, Eq)]
13397pub enum CaseStatementChildren<'tree> {
13398 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
13399 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
13400 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
13401 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
13402 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
13403 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
13404 Declaration(::std::boxed::Box<Declaration<'tree>>),
13405 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
13406 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
13407 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
13408 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
13409 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
13410 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
13411 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
13412 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
13413 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
13414 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
13415 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
13416 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
13417 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
13418 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
13419 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
13420}
13421impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatementChildren<'tree> {
13422 #[allow(clippy::collapsible_else_if)]
13423 fn from_node(
13424 node: ::treesitter_types::tree_sitter::Node<'tree>,
13425 src: &'tree [u8],
13426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13427 match node.kind() {
13428 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
13429 ::treesitter_types::runtime::maybe_grow_stack(|| {
13430 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
13431 })?,
13432 ))),
13433 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
13434 ::treesitter_types::runtime::maybe_grow_stack(|| {
13435 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
13436 })?,
13437 ))),
13438 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
13439 ::treesitter_types::runtime::maybe_grow_stack(|| {
13440 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
13441 })?,
13442 ))),
13443 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
13444 ::treesitter_types::runtime::maybe_grow_stack(|| {
13445 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
13446 })?,
13447 ))),
13448 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
13449 ::treesitter_types::runtime::maybe_grow_stack(|| {
13450 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
13451 })?,
13452 ))),
13453 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
13454 ::treesitter_types::runtime::maybe_grow_stack(|| {
13455 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
13456 })?,
13457 ))),
13458 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
13459 ::treesitter_types::runtime::maybe_grow_stack(|| {
13460 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
13461 })?,
13462 ))),
13463 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
13464 ::treesitter_types::runtime::maybe_grow_stack(|| {
13465 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
13466 })?,
13467 ))),
13468 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
13469 ::treesitter_types::runtime::maybe_grow_stack(|| {
13470 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
13471 })?,
13472 ))),
13473 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
13474 ::treesitter_types::runtime::maybe_grow_stack(|| {
13475 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)
13476 })?,
13477 ))),
13478 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
13479 ::treesitter_types::runtime::maybe_grow_stack(|| {
13480 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
13481 })?,
13482 ))),
13483 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
13484 ::treesitter_types::runtime::maybe_grow_stack(|| {
13485 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
13486 })?,
13487 ))),
13488 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
13489 ::treesitter_types::runtime::maybe_grow_stack(|| {
13490 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
13491 })?,
13492 ))),
13493 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
13494 ::treesitter_types::runtime::maybe_grow_stack(|| {
13495 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
13496 })?,
13497 ))),
13498 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
13499 ::treesitter_types::runtime::maybe_grow_stack(|| {
13500 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
13501 })?,
13502 ))),
13503 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
13504 ::treesitter_types::runtime::maybe_grow_stack(|| {
13505 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
13506 })?,
13507 ))),
13508 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
13509 ::treesitter_types::runtime::maybe_grow_stack(|| {
13510 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
13511 })?,
13512 ))),
13513 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
13514 ::treesitter_types::runtime::maybe_grow_stack(|| {
13515 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
13516 })?,
13517 ))),
13518 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
13519 ::treesitter_types::runtime::maybe_grow_stack(|| {
13520 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
13521 })?,
13522 ))),
13523 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
13524 ::treesitter_types::runtime::maybe_grow_stack(|| {
13525 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
13526 })?,
13527 ))),
13528 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
13529 ::treesitter_types::runtime::maybe_grow_stack(|| {
13530 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13531 })?,
13532 ))),
13533 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
13534 ::treesitter_types::runtime::maybe_grow_stack(|| {
13535 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
13536 })?,
13537 ))),
13538 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13539 }
13540 }
13541}
13542impl ::treesitter_types::Spanned for CaseStatementChildren<'_> {
13543 fn span(&self) -> ::treesitter_types::Span {
13544 match self {
13545 Self::AttributedStatement(inner) => inner.span(),
13546 Self::BreakStatement(inner) => inner.span(),
13547 Self::CoReturnStatement(inner) => inner.span(),
13548 Self::CoYieldStatement(inner) => inner.span(),
13549 Self::CompoundStatement(inner) => inner.span(),
13550 Self::ContinueStatement(inner) => inner.span(),
13551 Self::Declaration(inner) => inner.span(),
13552 Self::DoStatement(inner) => inner.span(),
13553 Self::ExpressionStatement(inner) => inner.span(),
13554 Self::ForRangeLoop(inner) => inner.span(),
13555 Self::ForStatement(inner) => inner.span(),
13556 Self::GotoStatement(inner) => inner.span(),
13557 Self::IfStatement(inner) => inner.span(),
13558 Self::LabeledStatement(inner) => inner.span(),
13559 Self::ReturnStatement(inner) => inner.span(),
13560 Self::SehLeaveStatement(inner) => inner.span(),
13561 Self::SehTryStatement(inner) => inner.span(),
13562 Self::SwitchStatement(inner) => inner.span(),
13563 Self::ThrowStatement(inner) => inner.span(),
13564 Self::TryStatement(inner) => inner.span(),
13565 Self::TypeDefinition(inner) => inner.span(),
13566 Self::WhileStatement(inner) => inner.span(),
13567 }
13568 }
13569}
13570#[derive(Debug, Clone, PartialEq, Eq)]
13571pub enum CharLiteralChildren<'tree> {
13572 Character(::std::boxed::Box<Character<'tree>>),
13573 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
13574}
13575impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteralChildren<'tree> {
13576 #[allow(clippy::collapsible_else_if)]
13577 fn from_node(
13578 node: ::treesitter_types::tree_sitter::Node<'tree>,
13579 src: &'tree [u8],
13580 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13581 match node.kind() {
13582 "character" => Ok(Self::Character(::std::boxed::Box::new(
13583 ::treesitter_types::runtime::maybe_grow_stack(|| {
13584 <Character as ::treesitter_types::FromNode>::from_node(node, src)
13585 })?,
13586 ))),
13587 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
13588 ::treesitter_types::runtime::maybe_grow_stack(|| {
13589 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
13590 })?,
13591 ))),
13592 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13593 }
13594 }
13595}
13596impl ::treesitter_types::Spanned for CharLiteralChildren<'_> {
13597 fn span(&self) -> ::treesitter_types::Span {
13598 match self {
13599 Self::Character(inner) => inner.span(),
13600 Self::EscapeSequence(inner) => inner.span(),
13601 }
13602 }
13603}
13604#[derive(Debug, Clone, PartialEq, Eq)]
13605pub enum ClassSpecifierName<'tree> {
13606 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
13607 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13608 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13609}
13610impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifierName<'tree> {
13611 #[allow(clippy::collapsible_else_if)]
13612 fn from_node(
13613 node: ::treesitter_types::tree_sitter::Node<'tree>,
13614 src: &'tree [u8],
13615 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13616 match node.kind() {
13617 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
13618 ::treesitter_types::runtime::maybe_grow_stack(|| {
13619 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13620 })?,
13621 ))),
13622 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13623 ::treesitter_types::runtime::maybe_grow_stack(|| {
13624 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
13625 })?,
13626 ))),
13627 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13628 ::treesitter_types::runtime::maybe_grow_stack(|| {
13629 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13630 })?,
13631 ))),
13632 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13633 }
13634 }
13635}
13636impl ::treesitter_types::Spanned for ClassSpecifierName<'_> {
13637 fn span(&self) -> ::treesitter_types::Span {
13638 match self {
13639 Self::QualifiedIdentifier(inner) => inner.span(),
13640 Self::TemplateType(inner) => inner.span(),
13641 Self::TypeIdentifier(inner) => inner.span(),
13642 }
13643 }
13644}
13645#[derive(Debug, Clone, PartialEq, Eq)]
13646pub enum ClassSpecifierChildren<'tree> {
13647 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
13648 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13649 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
13650 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
13651 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
13652 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
13653}
13654impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifierChildren<'tree> {
13655 #[allow(clippy::collapsible_else_if)]
13656 fn from_node(
13657 node: ::treesitter_types::tree_sitter::Node<'tree>,
13658 src: &'tree [u8],
13659 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13660 match node.kind() {
13661 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
13662 ::treesitter_types::runtime::maybe_grow_stack(|| {
13663 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)
13664 })?,
13665 ))),
13666 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13667 ::treesitter_types::runtime::maybe_grow_stack(|| {
13668 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13669 })?,
13670 ))),
13671 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
13672 ::treesitter_types::runtime::maybe_grow_stack(|| {
13673 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13674 })?,
13675 ))),
13676 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
13677 ::treesitter_types::runtime::maybe_grow_stack(|| {
13678 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)
13679 })?,
13680 ))),
13681 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
13682 ::treesitter_types::runtime::maybe_grow_stack(|| {
13683 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
13684 })?,
13685 ))),
13686 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
13687 ::treesitter_types::runtime::maybe_grow_stack(|| {
13688 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13689 })?,
13690 ))),
13691 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13692 }
13693 }
13694}
13695impl ::treesitter_types::Spanned for ClassSpecifierChildren<'_> {
13696 fn span(&self) -> ::treesitter_types::Span {
13697 match self {
13698 Self::AlignasQualifier(inner) => inner.span(),
13699 Self::AttributeDeclaration(inner) => inner.span(),
13700 Self::AttributeSpecifier(inner) => inner.span(),
13701 Self::BaseClassClause(inner) => inner.span(),
13702 Self::MsDeclspecModifier(inner) => inner.span(),
13703 Self::VirtualSpecifier(inner) => inner.span(),
13704 }
13705 }
13706}
13707#[derive(Debug, Clone, PartialEq, Eq)]
13708pub enum CoAwaitExpressionOperator {
13709 CoAwait(::treesitter_types::Span),
13710}
13711impl<'tree> ::treesitter_types::FromNode<'tree> for CoAwaitExpressionOperator {
13712 #[allow(clippy::collapsible_else_if)]
13713 fn from_node(
13714 node: ::treesitter_types::tree_sitter::Node<'tree>,
13715 _src: &'tree [u8],
13716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13717 match node.kind() {
13718 "co_await" => Ok(Self::CoAwait(::treesitter_types::Span::from(node))),
13719 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13720 }
13721 }
13722}
13723impl ::treesitter_types::Spanned for CoAwaitExpressionOperator {
13724 fn span(&self) -> ::treesitter_types::Span {
13725 match self {
13726 Self::CoAwait(span) => *span,
13727 }
13728 }
13729}
13730#[derive(Debug, Clone, PartialEq, Eq)]
13731pub enum CommaExpressionRight<'tree> {
13732 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
13733 Expression(::std::boxed::Box<Expression<'tree>>),
13734}
13735impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpressionRight<'tree> {
13736 #[allow(clippy::collapsible_else_if)]
13737 fn from_node(
13738 node: ::treesitter_types::tree_sitter::Node<'tree>,
13739 src: &'tree [u8],
13740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13741 match node.kind() {
13742 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
13743 ::treesitter_types::runtime::maybe_grow_stack(|| {
13744 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
13745 })?,
13746 ))),
13747 _other => {
13748 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13749 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13750 }) {
13751 Ok(Self::Expression(::std::boxed::Box::new(v)))
13752 } else {
13753 Err(::treesitter_types::ParseError::unexpected_kind(
13754 _other, node,
13755 ))
13756 }
13757 }
13758 }
13759 }
13760}
13761impl ::treesitter_types::Spanned for CommaExpressionRight<'_> {
13762 fn span(&self) -> ::treesitter_types::Span {
13763 match self {
13764 Self::CommaExpression(inner) => inner.span(),
13765 Self::Expression(inner) => inner.span(),
13766 }
13767 }
13768}
13769#[derive(Debug, Clone, PartialEq, Eq)]
13770pub enum CompoundLiteralExpressionType<'tree> {
13771 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13772 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
13773 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13774 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
13775 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13776}
13777impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundLiteralExpressionType<'tree> {
13778 #[allow(clippy::collapsible_else_if)]
13779 fn from_node(
13780 node: ::treesitter_types::tree_sitter::Node<'tree>,
13781 src: &'tree [u8],
13782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13783 match node.kind() {
13784 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13785 ::treesitter_types::runtime::maybe_grow_stack(|| {
13786 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
13787 })?,
13788 ))),
13789 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
13790 ::treesitter_types::runtime::maybe_grow_stack(|| {
13791 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13792 })?,
13793 ))),
13794 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13795 ::treesitter_types::runtime::maybe_grow_stack(|| {
13796 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
13797 })?,
13798 ))),
13799 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
13800 ::treesitter_types::runtime::maybe_grow_stack(|| {
13801 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
13802 })?,
13803 ))),
13804 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13805 ::treesitter_types::runtime::maybe_grow_stack(|| {
13806 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
13807 })?,
13808 ))),
13809 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13810 }
13811 }
13812}
13813impl ::treesitter_types::Spanned for CompoundLiteralExpressionType<'_> {
13814 fn span(&self) -> ::treesitter_types::Span {
13815 match self {
13816 Self::PrimitiveType(inner) => inner.span(),
13817 Self::QualifiedIdentifier(inner) => inner.span(),
13818 Self::TemplateType(inner) => inner.span(),
13819 Self::TypeDescriptor(inner) => inner.span(),
13820 Self::TypeIdentifier(inner) => inner.span(),
13821 }
13822 }
13823}
13824#[derive(Debug, Clone, PartialEq, Eq)]
13825pub enum CompoundRequirementChildren<'tree> {
13826 Expression(::std::boxed::Box<Expression<'tree>>),
13827 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
13828}
13829impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundRequirementChildren<'tree> {
13830 #[allow(clippy::collapsible_else_if)]
13831 fn from_node(
13832 node: ::treesitter_types::tree_sitter::Node<'tree>,
13833 src: &'tree [u8],
13834 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13835 match node.kind() {
13836 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
13837 ::treesitter_types::runtime::maybe_grow_stack(|| {
13838 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)
13839 })?,
13840 ))),
13841 _other => {
13842 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13843 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13844 }) {
13845 Ok(Self::Expression(::std::boxed::Box::new(v)))
13846 } else {
13847 Err(::treesitter_types::ParseError::unexpected_kind(
13848 _other, node,
13849 ))
13850 }
13851 }
13852 }
13853 }
13854}
13855impl ::treesitter_types::Spanned for CompoundRequirementChildren<'_> {
13856 fn span(&self) -> ::treesitter_types::Span {
13857 match self {
13858 Self::Expression(inner) => inner.span(),
13859 Self::TrailingReturnType(inner) => inner.span(),
13860 }
13861 }
13862}
13863#[derive(Debug, Clone, PartialEq, Eq)]
13864pub enum CompoundStatementChildren<'tree> {
13865 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
13866 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
13867 Declaration(::std::boxed::Box<Declaration<'tree>>),
13868 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
13869 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
13870 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
13871 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
13872 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
13873 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
13874 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
13875 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
13876 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
13877 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
13878 Statement(::std::boxed::Box<Statement<'tree>>),
13879 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
13880 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
13881 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
13882 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
13883 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
13884 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
13885}
13886impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatementChildren<'tree> {
13887 #[allow(clippy::collapsible_else_if)]
13888 fn from_node(
13889 node: ::treesitter_types::tree_sitter::Node<'tree>,
13890 src: &'tree [u8],
13891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13892 match node.kind() {
13893 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
13894 ::treesitter_types::runtime::maybe_grow_stack(|| {
13895 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13896 })?,
13897 ))),
13898 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
13899 ::treesitter_types::runtime::maybe_grow_stack(|| {
13900 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13901 })?,
13902 ))),
13903 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
13904 ::treesitter_types::runtime::maybe_grow_stack(|| {
13905 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
13906 })?,
13907 ))),
13908 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
13909 ::treesitter_types::runtime::maybe_grow_stack(|| {
13910 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13911 })?,
13912 ))),
13913 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
13914 ::treesitter_types::runtime::maybe_grow_stack(|| {
13915 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
13916 })?,
13917 ))),
13918 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
13919 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13920 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13921 })?),
13922 )),
13923 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
13924 ::treesitter_types::runtime::maybe_grow_stack(|| {
13925 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13926 })?,
13927 ))),
13928 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
13929 ::treesitter_types::runtime::maybe_grow_stack(|| {
13930 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
13931 })?,
13932 ))),
13933 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
13934 ::treesitter_types::runtime::maybe_grow_stack(|| {
13935 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
13936 })?,
13937 ))),
13938 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
13939 ::treesitter_types::runtime::maybe_grow_stack(|| {
13940 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
13941 })?,
13942 ))),
13943 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
13944 ::treesitter_types::runtime::maybe_grow_stack(|| {
13945 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
13946 })?,
13947 ))),
13948 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
13949 ::treesitter_types::runtime::maybe_grow_stack(|| {
13950 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
13951 })?,
13952 ))),
13953 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
13954 ::treesitter_types::runtime::maybe_grow_stack(|| {
13955 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
13956 })?,
13957 ))),
13958 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
13959 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13960 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13961 })?),
13962 )),
13963 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
13964 ::treesitter_types::runtime::maybe_grow_stack(|| {
13965 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13966 })?,
13967 ))),
13968 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
13969 ::treesitter_types::runtime::maybe_grow_stack(|| {
13970 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
13971 })?,
13972 ))),
13973 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
13974 ::treesitter_types::runtime::maybe_grow_stack(|| {
13975 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
13976 })?,
13977 ))),
13978 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
13979 ::treesitter_types::runtime::maybe_grow_stack(|| {
13980 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13981 })?,
13982 ))),
13983 _other => {
13984 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13985 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
13986 }) {
13987 Ok(Self::Statement(::std::boxed::Box::new(v)))
13988 } else {
13989 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13990 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13991 }) {
13992 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
13993 } else {
13994 Err(::treesitter_types::ParseError::unexpected_kind(
13995 _other, node,
13996 ))
13997 }
13998 }
13999 }
14000 }
14001 }
14002}
14003impl ::treesitter_types::Spanned for CompoundStatementChildren<'_> {
14004 fn span(&self) -> ::treesitter_types::Span {
14005 match self {
14006 Self::AliasDeclaration(inner) => inner.span(),
14007 Self::ConceptDefinition(inner) => inner.span(),
14008 Self::Declaration(inner) => inner.span(),
14009 Self::FunctionDefinition(inner) => inner.span(),
14010 Self::LinkageSpecification(inner) => inner.span(),
14011 Self::NamespaceAliasDefinition(inner) => inner.span(),
14012 Self::NamespaceDefinition(inner) => inner.span(),
14013 Self::PreprocCall(inner) => inner.span(),
14014 Self::PreprocDef(inner) => inner.span(),
14015 Self::PreprocFunctionDef(inner) => inner.span(),
14016 Self::PreprocIf(inner) => inner.span(),
14017 Self::PreprocIfdef(inner) => inner.span(),
14018 Self::PreprocInclude(inner) => inner.span(),
14019 Self::Statement(inner) => inner.span(),
14020 Self::StaticAssertDeclaration(inner) => inner.span(),
14021 Self::TemplateDeclaration(inner) => inner.span(),
14022 Self::TemplateInstantiation(inner) => inner.span(),
14023 Self::TypeDefinition(inner) => inner.span(),
14024 Self::TypeSpecifier(inner) => inner.span(),
14025 Self::UsingDeclaration(inner) => inner.span(),
14026 }
14027 }
14028}
14029#[derive(Debug, Clone, PartialEq, Eq)]
14030pub enum ConcatenatedStringChildren<'tree> {
14031 Identifier(::std::boxed::Box<Identifier<'tree>>),
14032 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
14033 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
14034}
14035impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedStringChildren<'tree> {
14036 #[allow(clippy::collapsible_else_if)]
14037 fn from_node(
14038 node: ::treesitter_types::tree_sitter::Node<'tree>,
14039 src: &'tree [u8],
14040 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14041 match node.kind() {
14042 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
14043 ::treesitter_types::runtime::maybe_grow_stack(|| {
14044 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14045 })?,
14046 ))),
14047 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
14048 ::treesitter_types::runtime::maybe_grow_stack(|| {
14049 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14050 })?,
14051 ))),
14052 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
14053 ::treesitter_types::runtime::maybe_grow_stack(|| {
14054 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14055 })?,
14056 ))),
14057 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14058 }
14059 }
14060}
14061impl ::treesitter_types::Spanned for ConcatenatedStringChildren<'_> {
14062 fn span(&self) -> ::treesitter_types::Span {
14063 match self {
14064 Self::Identifier(inner) => inner.span(),
14065 Self::RawStringLiteral(inner) => inner.span(),
14066 Self::StringLiteral(inner) => inner.span(),
14067 }
14068 }
14069}
14070#[derive(Debug, Clone, PartialEq, Eq)]
14071pub enum ConditionClauseValue<'tree> {
14072 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14073 Declaration(::std::boxed::Box<Declaration<'tree>>),
14074 Expression(::std::boxed::Box<Expression<'tree>>),
14075}
14076impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionClauseValue<'tree> {
14077 #[allow(clippy::collapsible_else_if)]
14078 fn from_node(
14079 node: ::treesitter_types::tree_sitter::Node<'tree>,
14080 src: &'tree [u8],
14081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14082 match node.kind() {
14083 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14084 ::treesitter_types::runtime::maybe_grow_stack(|| {
14085 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
14086 })?,
14087 ))),
14088 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
14089 ::treesitter_types::runtime::maybe_grow_stack(|| {
14090 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
14091 })?,
14092 ))),
14093 _other => {
14094 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14095 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14096 }) {
14097 Ok(Self::Expression(::std::boxed::Box::new(v)))
14098 } else {
14099 Err(::treesitter_types::ParseError::unexpected_kind(
14100 _other, node,
14101 ))
14102 }
14103 }
14104 }
14105 }
14106}
14107impl ::treesitter_types::Spanned for ConditionClauseValue<'_> {
14108 fn span(&self) -> ::treesitter_types::Span {
14109 match self {
14110 Self::CommaExpression(inner) => inner.span(),
14111 Self::Declaration(inner) => inner.span(),
14112 Self::Expression(inner) => inner.span(),
14113 }
14114 }
14115}
14116#[derive(Debug, Clone, PartialEq, Eq)]
14117pub enum ConditionalExpressionConsequence<'tree> {
14118 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14119 Expression(::std::boxed::Box<Expression<'tree>>),
14120}
14121impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpressionConsequence<'tree> {
14122 #[allow(clippy::collapsible_else_if)]
14123 fn from_node(
14124 node: ::treesitter_types::tree_sitter::Node<'tree>,
14125 src: &'tree [u8],
14126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14127 match node.kind() {
14128 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14129 ::treesitter_types::runtime::maybe_grow_stack(|| {
14130 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
14131 })?,
14132 ))),
14133 _other => {
14134 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14135 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14136 }) {
14137 Ok(Self::Expression(::std::boxed::Box::new(v)))
14138 } else {
14139 Err(::treesitter_types::ParseError::unexpected_kind(
14140 _other, node,
14141 ))
14142 }
14143 }
14144 }
14145 }
14146}
14147impl ::treesitter_types::Spanned for ConditionalExpressionConsequence<'_> {
14148 fn span(&self) -> ::treesitter_types::Span {
14149 match self {
14150 Self::CommaExpression(inner) => inner.span(),
14151 Self::Expression(inner) => inner.span(),
14152 }
14153 }
14154}
14155#[derive(Debug, Clone, PartialEq, Eq)]
14156pub enum ConstraintConjunctionLeft<'tree> {
14157 LParen(::treesitter_types::Span),
14158 RParen(::treesitter_types::Span),
14159 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
14160 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
14161 Expression(::std::boxed::Box<Expression<'tree>>),
14162 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14163 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14164}
14165impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionLeft<'tree> {
14166 #[allow(clippy::collapsible_else_if)]
14167 fn from_node(
14168 node: ::treesitter_types::tree_sitter::Node<'tree>,
14169 src: &'tree [u8],
14170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14171 match node.kind() {
14172 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
14173 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
14174 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
14175 ::treesitter_types::runtime::maybe_grow_stack(|| {
14176 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
14177 })?,
14178 ))),
14179 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
14180 ::treesitter_types::runtime::maybe_grow_stack(|| {
14181 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
14182 })?,
14183 ))),
14184 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14185 ::treesitter_types::runtime::maybe_grow_stack(|| {
14186 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14187 })?,
14188 ))),
14189 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14190 ::treesitter_types::runtime::maybe_grow_stack(|| {
14191 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14192 })?,
14193 ))),
14194 _other => {
14195 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14196 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14197 }) {
14198 Ok(Self::Expression(::std::boxed::Box::new(v)))
14199 } else {
14200 Err(::treesitter_types::ParseError::unexpected_kind(
14201 _other, node,
14202 ))
14203 }
14204 }
14205 }
14206 }
14207}
14208impl ::treesitter_types::Spanned for ConstraintConjunctionLeft<'_> {
14209 fn span(&self) -> ::treesitter_types::Span {
14210 match self {
14211 Self::LParen(span) => *span,
14212 Self::RParen(span) => *span,
14213 Self::ConstraintConjunction(inner) => inner.span(),
14214 Self::ConstraintDisjunction(inner) => inner.span(),
14215 Self::Expression(inner) => inner.span(),
14216 Self::TemplateType(inner) => inner.span(),
14217 Self::TypeIdentifier(inner) => inner.span(),
14218 }
14219 }
14220}
14221#[derive(Debug, Clone, PartialEq, Eq)]
14222pub enum ConstraintConjunctionOperator {
14223 AmpAmp(::treesitter_types::Span),
14224 And(::treesitter_types::Span),
14225}
14226impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionOperator {
14227 #[allow(clippy::collapsible_else_if)]
14228 fn from_node(
14229 node: ::treesitter_types::tree_sitter::Node<'tree>,
14230 _src: &'tree [u8],
14231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14232 match node.kind() {
14233 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
14234 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
14235 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14236 }
14237 }
14238}
14239impl ::treesitter_types::Spanned for ConstraintConjunctionOperator {
14240 fn span(&self) -> ::treesitter_types::Span {
14241 match self {
14242 Self::AmpAmp(span) => *span,
14243 Self::And(span) => *span,
14244 }
14245 }
14246}
14247#[derive(Debug, Clone, PartialEq, Eq)]
14248pub enum ConstraintConjunctionRight<'tree> {
14249 LParen(::treesitter_types::Span),
14250 RParen(::treesitter_types::Span),
14251 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
14252 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
14253 Expression(::std::boxed::Box<Expression<'tree>>),
14254 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14255 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14256}
14257impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionRight<'tree> {
14258 #[allow(clippy::collapsible_else_if)]
14259 fn from_node(
14260 node: ::treesitter_types::tree_sitter::Node<'tree>,
14261 src: &'tree [u8],
14262 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14263 match node.kind() {
14264 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
14265 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
14266 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
14267 ::treesitter_types::runtime::maybe_grow_stack(|| {
14268 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
14269 })?,
14270 ))),
14271 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
14272 ::treesitter_types::runtime::maybe_grow_stack(|| {
14273 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
14274 })?,
14275 ))),
14276 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14277 ::treesitter_types::runtime::maybe_grow_stack(|| {
14278 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14279 })?,
14280 ))),
14281 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14282 ::treesitter_types::runtime::maybe_grow_stack(|| {
14283 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14284 })?,
14285 ))),
14286 _other => {
14287 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14288 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14289 }) {
14290 Ok(Self::Expression(::std::boxed::Box::new(v)))
14291 } else {
14292 Err(::treesitter_types::ParseError::unexpected_kind(
14293 _other, node,
14294 ))
14295 }
14296 }
14297 }
14298 }
14299}
14300impl ::treesitter_types::Spanned for ConstraintConjunctionRight<'_> {
14301 fn span(&self) -> ::treesitter_types::Span {
14302 match self {
14303 Self::LParen(span) => *span,
14304 Self::RParen(span) => *span,
14305 Self::ConstraintConjunction(inner) => inner.span(),
14306 Self::ConstraintDisjunction(inner) => inner.span(),
14307 Self::Expression(inner) => inner.span(),
14308 Self::TemplateType(inner) => inner.span(),
14309 Self::TypeIdentifier(inner) => inner.span(),
14310 }
14311 }
14312}
14313#[derive(Debug, Clone, PartialEq, Eq)]
14314pub enum ConstraintDisjunctionLeft<'tree> {
14315 LParen(::treesitter_types::Span),
14316 RParen(::treesitter_types::Span),
14317 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
14318 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
14319 Expression(::std::boxed::Box<Expression<'tree>>),
14320 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14321 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14322}
14323impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionLeft<'tree> {
14324 #[allow(clippy::collapsible_else_if)]
14325 fn from_node(
14326 node: ::treesitter_types::tree_sitter::Node<'tree>,
14327 src: &'tree [u8],
14328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14329 match node.kind() {
14330 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
14331 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
14332 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
14333 ::treesitter_types::runtime::maybe_grow_stack(|| {
14334 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
14335 })?,
14336 ))),
14337 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
14338 ::treesitter_types::runtime::maybe_grow_stack(|| {
14339 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
14340 })?,
14341 ))),
14342 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14343 ::treesitter_types::runtime::maybe_grow_stack(|| {
14344 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14345 })?,
14346 ))),
14347 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14348 ::treesitter_types::runtime::maybe_grow_stack(|| {
14349 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14350 })?,
14351 ))),
14352 _other => {
14353 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14354 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14355 }) {
14356 Ok(Self::Expression(::std::boxed::Box::new(v)))
14357 } else {
14358 Err(::treesitter_types::ParseError::unexpected_kind(
14359 _other, node,
14360 ))
14361 }
14362 }
14363 }
14364 }
14365}
14366impl ::treesitter_types::Spanned for ConstraintDisjunctionLeft<'_> {
14367 fn span(&self) -> ::treesitter_types::Span {
14368 match self {
14369 Self::LParen(span) => *span,
14370 Self::RParen(span) => *span,
14371 Self::ConstraintConjunction(inner) => inner.span(),
14372 Self::ConstraintDisjunction(inner) => inner.span(),
14373 Self::Expression(inner) => inner.span(),
14374 Self::TemplateType(inner) => inner.span(),
14375 Self::TypeIdentifier(inner) => inner.span(),
14376 }
14377 }
14378}
14379#[derive(Debug, Clone, PartialEq, Eq)]
14380pub enum ConstraintDisjunctionOperator {
14381 Or(::treesitter_types::Span),
14382 PipePipe(::treesitter_types::Span),
14383}
14384impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionOperator {
14385 #[allow(clippy::collapsible_else_if)]
14386 fn from_node(
14387 node: ::treesitter_types::tree_sitter::Node<'tree>,
14388 _src: &'tree [u8],
14389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14390 match node.kind() {
14391 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
14392 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
14393 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14394 }
14395 }
14396}
14397impl ::treesitter_types::Spanned for ConstraintDisjunctionOperator {
14398 fn span(&self) -> ::treesitter_types::Span {
14399 match self {
14400 Self::Or(span) => *span,
14401 Self::PipePipe(span) => *span,
14402 }
14403 }
14404}
14405#[derive(Debug, Clone, PartialEq, Eq)]
14406pub enum ConstraintDisjunctionRight<'tree> {
14407 LParen(::treesitter_types::Span),
14408 RParen(::treesitter_types::Span),
14409 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
14410 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
14411 Expression(::std::boxed::Box<Expression<'tree>>),
14412 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14413 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14414}
14415impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionRight<'tree> {
14416 #[allow(clippy::collapsible_else_if)]
14417 fn from_node(
14418 node: ::treesitter_types::tree_sitter::Node<'tree>,
14419 src: &'tree [u8],
14420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14421 match node.kind() {
14422 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
14423 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
14424 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
14425 ::treesitter_types::runtime::maybe_grow_stack(|| {
14426 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
14427 })?,
14428 ))),
14429 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
14430 ::treesitter_types::runtime::maybe_grow_stack(|| {
14431 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
14432 })?,
14433 ))),
14434 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14435 ::treesitter_types::runtime::maybe_grow_stack(|| {
14436 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14437 })?,
14438 ))),
14439 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14440 ::treesitter_types::runtime::maybe_grow_stack(|| {
14441 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14442 })?,
14443 ))),
14444 _other => {
14445 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14446 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14447 }) {
14448 Ok(Self::Expression(::std::boxed::Box::new(v)))
14449 } else {
14450 Err(::treesitter_types::ParseError::unexpected_kind(
14451 _other, node,
14452 ))
14453 }
14454 }
14455 }
14456 }
14457}
14458impl ::treesitter_types::Spanned for ConstraintDisjunctionRight<'_> {
14459 fn span(&self) -> ::treesitter_types::Span {
14460 match self {
14461 Self::LParen(span) => *span,
14462 Self::RParen(span) => *span,
14463 Self::ConstraintConjunction(inner) => inner.span(),
14464 Self::ConstraintDisjunction(inner) => inner.span(),
14465 Self::Expression(inner) => inner.span(),
14466 Self::TemplateType(inner) => inner.span(),
14467 Self::TypeIdentifier(inner) => inner.span(),
14468 }
14469 }
14470}
14471#[derive(Debug, Clone, PartialEq, Eq)]
14472pub enum DeclarationDeclarator<'tree> {
14473 Declarator(::std::boxed::Box<Declarator<'tree>>),
14474 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
14475 InitDeclarator(::std::boxed::Box<InitDeclarator<'tree>>),
14476 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
14477}
14478impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationDeclarator<'tree> {
14479 #[allow(clippy::collapsible_else_if)]
14480 fn from_node(
14481 node: ::treesitter_types::tree_sitter::Node<'tree>,
14482 src: &'tree [u8],
14483 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14484 match node.kind() {
14485 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
14486 ::treesitter_types::runtime::maybe_grow_stack(|| {
14487 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
14488 })?,
14489 ))),
14490 "init_declarator" => Ok(Self::InitDeclarator(::std::boxed::Box::new(
14491 ::treesitter_types::runtime::maybe_grow_stack(|| {
14492 <InitDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
14493 })?,
14494 ))),
14495 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
14496 ::treesitter_types::runtime::maybe_grow_stack(|| {
14497 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)
14498 })?,
14499 ))),
14500 _other => {
14501 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14502 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
14503 }) {
14504 Ok(Self::Declarator(::std::boxed::Box::new(v)))
14505 } else {
14506 Err(::treesitter_types::ParseError::unexpected_kind(
14507 _other, node,
14508 ))
14509 }
14510 }
14511 }
14512 }
14513}
14514impl ::treesitter_types::Spanned for DeclarationDeclarator<'_> {
14515 fn span(&self) -> ::treesitter_types::Span {
14516 match self {
14517 Self::Declarator(inner) => inner.span(),
14518 Self::GnuAsmExpression(inner) => inner.span(),
14519 Self::InitDeclarator(inner) => inner.span(),
14520 Self::OperatorCast(inner) => inner.span(),
14521 }
14522 }
14523}
14524#[derive(Debug, Clone, PartialEq, Eq)]
14525pub enum DeclarationValue<'tree> {
14526 Expression(::std::boxed::Box<Expression<'tree>>),
14527 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
14528}
14529impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationValue<'tree> {
14530 #[allow(clippy::collapsible_else_if)]
14531 fn from_node(
14532 node: ::treesitter_types::tree_sitter::Node<'tree>,
14533 src: &'tree [u8],
14534 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14535 match node.kind() {
14536 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
14537 ::treesitter_types::runtime::maybe_grow_stack(|| {
14538 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
14539 })?,
14540 ))),
14541 _other => {
14542 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14543 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14544 }) {
14545 Ok(Self::Expression(::std::boxed::Box::new(v)))
14546 } else {
14547 Err(::treesitter_types::ParseError::unexpected_kind(
14548 _other, node,
14549 ))
14550 }
14551 }
14552 }
14553 }
14554}
14555impl ::treesitter_types::Spanned for DeclarationValue<'_> {
14556 fn span(&self) -> ::treesitter_types::Span {
14557 match self {
14558 Self::Expression(inner) => inner.span(),
14559 Self::InitializerList(inner) => inner.span(),
14560 }
14561 }
14562}
14563#[derive(Debug, Clone, PartialEq, Eq)]
14564pub enum DeclarationChildren<'tree> {
14565 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
14566 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
14567 ExplicitFunctionSpecifier(::std::boxed::Box<ExplicitFunctionSpecifier<'tree>>),
14568 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
14569 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
14570 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
14571}
14572impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationChildren<'tree> {
14573 #[allow(clippy::collapsible_else_if)]
14574 fn from_node(
14575 node: ::treesitter_types::tree_sitter::Node<'tree>,
14576 src: &'tree [u8],
14577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14578 match node.kind() {
14579 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
14580 ::treesitter_types::runtime::maybe_grow_stack(|| {
14581 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14582 })?,
14583 ))),
14584 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
14585 ::treesitter_types::runtime::maybe_grow_stack(|| {
14586 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14587 })?,
14588 ))),
14589 "explicit_function_specifier" => Ok(Self::ExplicitFunctionSpecifier(
14590 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14591 <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(
14592 node, src,
14593 )
14594 })?),
14595 )),
14596 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
14597 ::treesitter_types::runtime::maybe_grow_stack(|| {
14598 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
14599 })?,
14600 ))),
14601 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
14602 ::treesitter_types::runtime::maybe_grow_stack(|| {
14603 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14604 })?,
14605 ))),
14606 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
14607 ::treesitter_types::runtime::maybe_grow_stack(|| {
14608 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
14609 })?,
14610 ))),
14611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14612 }
14613 }
14614}
14615impl ::treesitter_types::Spanned for DeclarationChildren<'_> {
14616 fn span(&self) -> ::treesitter_types::Span {
14617 match self {
14618 Self::AttributeDeclaration(inner) => inner.span(),
14619 Self::AttributeSpecifier(inner) => inner.span(),
14620 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
14621 Self::MsDeclspecModifier(inner) => inner.span(),
14622 Self::StorageClassSpecifier(inner) => inner.span(),
14623 Self::TypeQualifier(inner) => inner.span(),
14624 }
14625 }
14626}
14627#[derive(Debug, Clone, PartialEq, Eq)]
14628pub enum DeclarationListChildren<'tree> {
14629 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
14630 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
14631 Declaration(::std::boxed::Box<Declaration<'tree>>),
14632 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
14633 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
14634 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
14635 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
14636 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
14637 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
14638 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
14639 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14640 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
14641 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
14642 Statement(::std::boxed::Box<Statement<'tree>>),
14643 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
14644 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
14645 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
14646 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
14647 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
14648 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
14649}
14650impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationListChildren<'tree> {
14651 #[allow(clippy::collapsible_else_if)]
14652 fn from_node(
14653 node: ::treesitter_types::tree_sitter::Node<'tree>,
14654 src: &'tree [u8],
14655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14656 match node.kind() {
14657 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
14658 ::treesitter_types::runtime::maybe_grow_stack(|| {
14659 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14660 })?,
14661 ))),
14662 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
14663 ::treesitter_types::runtime::maybe_grow_stack(|| {
14664 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14665 })?,
14666 ))),
14667 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
14668 ::treesitter_types::runtime::maybe_grow_stack(|| {
14669 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
14670 })?,
14671 ))),
14672 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
14673 ::treesitter_types::runtime::maybe_grow_stack(|| {
14674 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14675 })?,
14676 ))),
14677 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
14678 ::treesitter_types::runtime::maybe_grow_stack(|| {
14679 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
14680 })?,
14681 ))),
14682 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
14683 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14684 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14685 })?),
14686 )),
14687 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
14688 ::treesitter_types::runtime::maybe_grow_stack(|| {
14689 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14690 })?,
14691 ))),
14692 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
14693 ::treesitter_types::runtime::maybe_grow_stack(|| {
14694 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
14695 })?,
14696 ))),
14697 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
14698 ::treesitter_types::runtime::maybe_grow_stack(|| {
14699 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
14700 })?,
14701 ))),
14702 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
14703 ::treesitter_types::runtime::maybe_grow_stack(|| {
14704 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
14705 })?,
14706 ))),
14707 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14708 ::treesitter_types::runtime::maybe_grow_stack(|| {
14709 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
14710 })?,
14711 ))),
14712 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
14713 ::treesitter_types::runtime::maybe_grow_stack(|| {
14714 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
14715 })?,
14716 ))),
14717 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
14718 ::treesitter_types::runtime::maybe_grow_stack(|| {
14719 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
14720 })?,
14721 ))),
14722 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
14723 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14724 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14725 })?),
14726 )),
14727 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
14728 ::treesitter_types::runtime::maybe_grow_stack(|| {
14729 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14730 })?,
14731 ))),
14732 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
14733 ::treesitter_types::runtime::maybe_grow_stack(|| {
14734 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
14735 })?,
14736 ))),
14737 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
14738 ::treesitter_types::runtime::maybe_grow_stack(|| {
14739 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14740 })?,
14741 ))),
14742 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
14743 ::treesitter_types::runtime::maybe_grow_stack(|| {
14744 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14745 })?,
14746 ))),
14747 _other => {
14748 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14749 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
14750 }) {
14751 Ok(Self::Statement(::std::boxed::Box::new(v)))
14752 } else {
14753 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14754 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14755 }) {
14756 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
14757 } else {
14758 Err(::treesitter_types::ParseError::unexpected_kind(
14759 _other, node,
14760 ))
14761 }
14762 }
14763 }
14764 }
14765 }
14766}
14767impl ::treesitter_types::Spanned for DeclarationListChildren<'_> {
14768 fn span(&self) -> ::treesitter_types::Span {
14769 match self {
14770 Self::AliasDeclaration(inner) => inner.span(),
14771 Self::ConceptDefinition(inner) => inner.span(),
14772 Self::Declaration(inner) => inner.span(),
14773 Self::FunctionDefinition(inner) => inner.span(),
14774 Self::LinkageSpecification(inner) => inner.span(),
14775 Self::NamespaceAliasDefinition(inner) => inner.span(),
14776 Self::NamespaceDefinition(inner) => inner.span(),
14777 Self::PreprocCall(inner) => inner.span(),
14778 Self::PreprocDef(inner) => inner.span(),
14779 Self::PreprocFunctionDef(inner) => inner.span(),
14780 Self::PreprocIf(inner) => inner.span(),
14781 Self::PreprocIfdef(inner) => inner.span(),
14782 Self::PreprocInclude(inner) => inner.span(),
14783 Self::Statement(inner) => inner.span(),
14784 Self::StaticAssertDeclaration(inner) => inner.span(),
14785 Self::TemplateDeclaration(inner) => inner.span(),
14786 Self::TemplateInstantiation(inner) => inner.span(),
14787 Self::TypeDefinition(inner) => inner.span(),
14788 Self::TypeSpecifier(inner) => inner.span(),
14789 Self::UsingDeclaration(inner) => inner.span(),
14790 }
14791 }
14792}
14793#[derive(Debug, Clone, PartialEq, Eq)]
14794pub enum DecltypeChildren<'tree> {
14795 Auto(::std::boxed::Box<Auto<'tree>>),
14796 Expression(::std::boxed::Box<Expression<'tree>>),
14797}
14798impl<'tree> ::treesitter_types::FromNode<'tree> for DecltypeChildren<'tree> {
14799 #[allow(clippy::collapsible_else_if)]
14800 fn from_node(
14801 node: ::treesitter_types::tree_sitter::Node<'tree>,
14802 src: &'tree [u8],
14803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14804 match node.kind() {
14805 "auto" => Ok(Self::Auto(::std::boxed::Box::new(
14806 ::treesitter_types::runtime::maybe_grow_stack(|| {
14807 <Auto as ::treesitter_types::FromNode>::from_node(node, src)
14808 })?,
14809 ))),
14810 _other => {
14811 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14812 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14813 }) {
14814 Ok(Self::Expression(::std::boxed::Box::new(v)))
14815 } else {
14816 Err(::treesitter_types::ParseError::unexpected_kind(
14817 _other, node,
14818 ))
14819 }
14820 }
14821 }
14822 }
14823}
14824impl ::treesitter_types::Spanned for DecltypeChildren<'_> {
14825 fn span(&self) -> ::treesitter_types::Span {
14826 match self {
14827 Self::Auto(inner) => inner.span(),
14828 Self::Expression(inner) => inner.span(),
14829 }
14830 }
14831}
14832#[derive(Debug, Clone, PartialEq, Eq)]
14833pub enum DependentNameChildren<'tree> {
14834 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
14835 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
14836 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14837}
14838impl<'tree> ::treesitter_types::FromNode<'tree> for DependentNameChildren<'tree> {
14839 #[allow(clippy::collapsible_else_if)]
14840 fn from_node(
14841 node: ::treesitter_types::tree_sitter::Node<'tree>,
14842 src: &'tree [u8],
14843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14844 match node.kind() {
14845 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
14846 ::treesitter_types::runtime::maybe_grow_stack(|| {
14847 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)
14848 })?,
14849 ))),
14850 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
14851 ::treesitter_types::runtime::maybe_grow_stack(|| {
14852 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
14853 })?,
14854 ))),
14855 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14856 ::treesitter_types::runtime::maybe_grow_stack(|| {
14857 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14858 })?,
14859 ))),
14860 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14861 }
14862 }
14863}
14864impl ::treesitter_types::Spanned for DependentNameChildren<'_> {
14865 fn span(&self) -> ::treesitter_types::Span {
14866 match self {
14867 Self::TemplateFunction(inner) => inner.span(),
14868 Self::TemplateMethod(inner) => inner.span(),
14869 Self::TemplateType(inner) => inner.span(),
14870 }
14871 }
14872}
14873#[derive(Debug, Clone, PartialEq, Eq)]
14874pub enum EnumSpecifierBase<'tree> {
14875 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
14876 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14877 SizedTypeSpecifier(::std::boxed::Box<SizedTypeSpecifier<'tree>>),
14878 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14879}
14880impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifierBase<'tree> {
14881 #[allow(clippy::collapsible_else_if)]
14882 fn from_node(
14883 node: ::treesitter_types::tree_sitter::Node<'tree>,
14884 src: &'tree [u8],
14885 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14886 match node.kind() {
14887 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
14888 ::treesitter_types::runtime::maybe_grow_stack(|| {
14889 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
14890 })?,
14891 ))),
14892 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14893 ::treesitter_types::runtime::maybe_grow_stack(|| {
14894 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14895 })?,
14896 ))),
14897 "sized_type_specifier" => Ok(Self::SizedTypeSpecifier(::std::boxed::Box::new(
14898 ::treesitter_types::runtime::maybe_grow_stack(|| {
14899 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14900 })?,
14901 ))),
14902 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14903 ::treesitter_types::runtime::maybe_grow_stack(|| {
14904 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14905 })?,
14906 ))),
14907 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14908 }
14909 }
14910}
14911impl ::treesitter_types::Spanned for EnumSpecifierBase<'_> {
14912 fn span(&self) -> ::treesitter_types::Span {
14913 match self {
14914 Self::PrimitiveType(inner) => inner.span(),
14915 Self::QualifiedIdentifier(inner) => inner.span(),
14916 Self::SizedTypeSpecifier(inner) => inner.span(),
14917 Self::TypeIdentifier(inner) => inner.span(),
14918 }
14919 }
14920}
14921#[derive(Debug, Clone, PartialEq, Eq)]
14922pub enum EnumSpecifierName<'tree> {
14923 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14924 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14925 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14926}
14927impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifierName<'tree> {
14928 #[allow(clippy::collapsible_else_if)]
14929 fn from_node(
14930 node: ::treesitter_types::tree_sitter::Node<'tree>,
14931 src: &'tree [u8],
14932 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14933 match node.kind() {
14934 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14935 ::treesitter_types::runtime::maybe_grow_stack(|| {
14936 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14937 })?,
14938 ))),
14939 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14940 ::treesitter_types::runtime::maybe_grow_stack(|| {
14941 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14942 })?,
14943 ))),
14944 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14945 ::treesitter_types::runtime::maybe_grow_stack(|| {
14946 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14947 })?,
14948 ))),
14949 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14950 }
14951 }
14952}
14953impl ::treesitter_types::Spanned for EnumSpecifierName<'_> {
14954 fn span(&self) -> ::treesitter_types::Span {
14955 match self {
14956 Self::QualifiedIdentifier(inner) => inner.span(),
14957 Self::TemplateType(inner) => inner.span(),
14958 Self::TypeIdentifier(inner) => inner.span(),
14959 }
14960 }
14961}
14962#[derive(Debug, Clone, PartialEq, Eq)]
14963pub enum EnumeratorListChildren<'tree> {
14964 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
14965 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
14966 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14967 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
14968}
14969impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorListChildren<'tree> {
14970 #[allow(clippy::collapsible_else_if)]
14971 fn from_node(
14972 node: ::treesitter_types::tree_sitter::Node<'tree>,
14973 src: &'tree [u8],
14974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14975 match node.kind() {
14976 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
14977 ::treesitter_types::runtime::maybe_grow_stack(|| {
14978 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
14979 })?,
14980 ))),
14981 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
14982 ::treesitter_types::runtime::maybe_grow_stack(|| {
14983 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
14984 })?,
14985 ))),
14986 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14987 ::treesitter_types::runtime::maybe_grow_stack(|| {
14988 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
14989 })?,
14990 ))),
14991 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
14992 ::treesitter_types::runtime::maybe_grow_stack(|| {
14993 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
14994 })?,
14995 ))),
14996 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14997 }
14998 }
14999}
15000impl ::treesitter_types::Spanned for EnumeratorListChildren<'_> {
15001 fn span(&self) -> ::treesitter_types::Span {
15002 match self {
15003 Self::Enumerator(inner) => inner.span(),
15004 Self::PreprocCall(inner) => inner.span(),
15005 Self::PreprocIf(inner) => inner.span(),
15006 Self::PreprocIfdef(inner) => inner.span(),
15007 }
15008 }
15009}
15010#[derive(Debug, Clone, PartialEq, Eq)]
15011pub enum ExpressionStatementChildren<'tree> {
15012 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
15013 Expression(::std::boxed::Box<Expression<'tree>>),
15014}
15015impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
15016 #[allow(clippy::collapsible_else_if)]
15017 fn from_node(
15018 node: ::treesitter_types::tree_sitter::Node<'tree>,
15019 src: &'tree [u8],
15020 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15021 match node.kind() {
15022 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
15023 ::treesitter_types::runtime::maybe_grow_stack(|| {
15024 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
15025 })?,
15026 ))),
15027 _other => {
15028 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15029 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15030 }) {
15031 Ok(Self::Expression(::std::boxed::Box::new(v)))
15032 } else {
15033 Err(::treesitter_types::ParseError::unexpected_kind(
15034 _other, node,
15035 ))
15036 }
15037 }
15038 }
15039 }
15040}
15041impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
15042 fn span(&self) -> ::treesitter_types::Span {
15043 match self {
15044 Self::CommaExpression(inner) => inner.span(),
15045 Self::Expression(inner) => inner.span(),
15046 }
15047 }
15048}
15049#[derive(Debug, Clone, PartialEq, Eq)]
15050pub enum FieldDeclarationDefaultValue<'tree> {
15051 Expression(::std::boxed::Box<Expression<'tree>>),
15052 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15053}
15054impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationDefaultValue<'tree> {
15055 #[allow(clippy::collapsible_else_if)]
15056 fn from_node(
15057 node: ::treesitter_types::tree_sitter::Node<'tree>,
15058 src: &'tree [u8],
15059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15060 match node.kind() {
15061 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15062 ::treesitter_types::runtime::maybe_grow_stack(|| {
15063 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
15064 })?,
15065 ))),
15066 _other => {
15067 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15068 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15069 }) {
15070 Ok(Self::Expression(::std::boxed::Box::new(v)))
15071 } else {
15072 Err(::treesitter_types::ParseError::unexpected_kind(
15073 _other, node,
15074 ))
15075 }
15076 }
15077 }
15078 }
15079}
15080impl ::treesitter_types::Spanned for FieldDeclarationDefaultValue<'_> {
15081 fn span(&self) -> ::treesitter_types::Span {
15082 match self {
15083 Self::Expression(inner) => inner.span(),
15084 Self::InitializerList(inner) => inner.span(),
15085 }
15086 }
15087}
15088#[derive(Debug, Clone, PartialEq, Eq)]
15089pub enum FieldDeclarationChildren<'tree> {
15090 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15091 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15092 BitfieldClause(::std::boxed::Box<BitfieldClause<'tree>>),
15093 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
15094 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
15095 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15096}
15097impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
15098 #[allow(clippy::collapsible_else_if)]
15099 fn from_node(
15100 node: ::treesitter_types::tree_sitter::Node<'tree>,
15101 src: &'tree [u8],
15102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15103 match node.kind() {
15104 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15105 ::treesitter_types::runtime::maybe_grow_stack(|| {
15106 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15107 })?,
15108 ))),
15109 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15110 ::treesitter_types::runtime::maybe_grow_stack(|| {
15111 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15112 })?,
15113 ))),
15114 "bitfield_clause" => Ok(Self::BitfieldClause(::std::boxed::Box::new(
15115 ::treesitter_types::runtime::maybe_grow_stack(|| {
15116 <BitfieldClause as ::treesitter_types::FromNode>::from_node(node, src)
15117 })?,
15118 ))),
15119 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
15120 ::treesitter_types::runtime::maybe_grow_stack(|| {
15121 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
15122 })?,
15123 ))),
15124 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
15125 ::treesitter_types::runtime::maybe_grow_stack(|| {
15126 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15127 })?,
15128 ))),
15129 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15130 ::treesitter_types::runtime::maybe_grow_stack(|| {
15131 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
15132 })?,
15133 ))),
15134 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15135 }
15136 }
15137}
15138impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
15139 fn span(&self) -> ::treesitter_types::Span {
15140 match self {
15141 Self::AttributeDeclaration(inner) => inner.span(),
15142 Self::AttributeSpecifier(inner) => inner.span(),
15143 Self::BitfieldClause(inner) => inner.span(),
15144 Self::MsDeclspecModifier(inner) => inner.span(),
15145 Self::StorageClassSpecifier(inner) => inner.span(),
15146 Self::TypeQualifier(inner) => inner.span(),
15147 }
15148 }
15149}
15150#[derive(Debug, Clone, PartialEq, Eq)]
15151pub enum FieldDeclarationListChildren<'tree> {
15152 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
15153 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
15154 Declaration(::std::boxed::Box<Declaration<'tree>>),
15155 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
15156 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
15157 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
15158 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
15159 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
15160 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
15161 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
15162 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
15163 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
15164 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
15165 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
15166 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
15167}
15168impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
15169 #[allow(clippy::collapsible_else_if)]
15170 fn from_node(
15171 node: ::treesitter_types::tree_sitter::Node<'tree>,
15172 src: &'tree [u8],
15173 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15174 match node.kind() {
15175 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
15176 ::treesitter_types::runtime::maybe_grow_stack(|| {
15177 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15178 })?,
15179 ))),
15180 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
15181 ::treesitter_types::runtime::maybe_grow_stack(|| {
15182 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15183 })?,
15184 ))),
15185 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15186 ::treesitter_types::runtime::maybe_grow_stack(|| {
15187 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
15188 })?,
15189 ))),
15190 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
15191 ::treesitter_types::runtime::maybe_grow_stack(|| {
15192 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15193 })?,
15194 ))),
15195 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
15196 ::treesitter_types::runtime::maybe_grow_stack(|| {
15197 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15198 })?,
15199 ))),
15200 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
15201 ::treesitter_types::runtime::maybe_grow_stack(|| {
15202 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15203 })?,
15204 ))),
15205 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
15206 ::treesitter_types::runtime::maybe_grow_stack(|| {
15207 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
15208 })?,
15209 ))),
15210 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
15211 ::treesitter_types::runtime::maybe_grow_stack(|| {
15212 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
15213 })?,
15214 ))),
15215 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
15216 ::treesitter_types::runtime::maybe_grow_stack(|| {
15217 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
15218 })?,
15219 ))),
15220 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
15221 ::treesitter_types::runtime::maybe_grow_stack(|| {
15222 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
15223 })?,
15224 ))),
15225 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
15226 ::treesitter_types::runtime::maybe_grow_stack(|| {
15227 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
15228 })?,
15229 ))),
15230 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
15231 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15232 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15233 })?),
15234 )),
15235 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
15236 ::treesitter_types::runtime::maybe_grow_stack(|| {
15237 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15238 })?,
15239 ))),
15240 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
15241 ::treesitter_types::runtime::maybe_grow_stack(|| {
15242 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15243 })?,
15244 ))),
15245 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
15246 ::treesitter_types::runtime::maybe_grow_stack(|| {
15247 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15248 })?,
15249 ))),
15250 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15251 }
15252 }
15253}
15254impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
15255 fn span(&self) -> ::treesitter_types::Span {
15256 match self {
15257 Self::AccessSpecifier(inner) => inner.span(),
15258 Self::AliasDeclaration(inner) => inner.span(),
15259 Self::Declaration(inner) => inner.span(),
15260 Self::FieldDeclaration(inner) => inner.span(),
15261 Self::FriendDeclaration(inner) => inner.span(),
15262 Self::FunctionDefinition(inner) => inner.span(),
15263 Self::PreprocCall(inner) => inner.span(),
15264 Self::PreprocDef(inner) => inner.span(),
15265 Self::PreprocFunctionDef(inner) => inner.span(),
15266 Self::PreprocIf(inner) => inner.span(),
15267 Self::PreprocIfdef(inner) => inner.span(),
15268 Self::StaticAssertDeclaration(inner) => inner.span(),
15269 Self::TemplateDeclaration(inner) => inner.span(),
15270 Self::TypeDefinition(inner) => inner.span(),
15271 Self::UsingDeclaration(inner) => inner.span(),
15272 }
15273 }
15274}
15275#[derive(Debug, Clone, PartialEq, Eq)]
15276pub enum FieldExpressionField<'tree> {
15277 DependentName(::std::boxed::Box<DependentName<'tree>>),
15278 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
15279 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
15280 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
15281 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
15282}
15283impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionField<'tree> {
15284 #[allow(clippy::collapsible_else_if)]
15285 fn from_node(
15286 node: ::treesitter_types::tree_sitter::Node<'tree>,
15287 src: &'tree [u8],
15288 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15289 match node.kind() {
15290 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
15291 ::treesitter_types::runtime::maybe_grow_stack(|| {
15292 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)
15293 })?,
15294 ))),
15295 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
15296 ::treesitter_types::runtime::maybe_grow_stack(|| {
15297 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)
15298 })?,
15299 ))),
15300 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
15301 ::treesitter_types::runtime::maybe_grow_stack(|| {
15302 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15303 })?,
15304 ))),
15305 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
15306 ::treesitter_types::runtime::maybe_grow_stack(|| {
15307 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15308 })?,
15309 ))),
15310 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
15311 ::treesitter_types::runtime::maybe_grow_stack(|| {
15312 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
15313 })?,
15314 ))),
15315 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15316 }
15317 }
15318}
15319impl ::treesitter_types::Spanned for FieldExpressionField<'_> {
15320 fn span(&self) -> ::treesitter_types::Span {
15321 match self {
15322 Self::DependentName(inner) => inner.span(),
15323 Self::DestructorName(inner) => inner.span(),
15324 Self::FieldIdentifier(inner) => inner.span(),
15325 Self::QualifiedIdentifier(inner) => inner.span(),
15326 Self::TemplateMethod(inner) => inner.span(),
15327 }
15328 }
15329}
15330#[derive(Debug, Clone, PartialEq, Eq)]
15331pub enum FieldExpressionOperator {
15332 Arrow(::treesitter_types::Span),
15333 Dot(::treesitter_types::Span),
15334 DotStar(::treesitter_types::Span),
15335}
15336impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionOperator {
15337 #[allow(clippy::collapsible_else_if)]
15338 fn from_node(
15339 node: ::treesitter_types::tree_sitter::Node<'tree>,
15340 _src: &'tree [u8],
15341 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15342 match node.kind() {
15343 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
15344 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
15345 ".*" => Ok(Self::DotStar(::treesitter_types::Span::from(node))),
15346 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15347 }
15348 }
15349}
15350impl ::treesitter_types::Spanned for FieldExpressionOperator {
15351 fn span(&self) -> ::treesitter_types::Span {
15352 match self {
15353 Self::Arrow(span) => *span,
15354 Self::Dot(span) => *span,
15355 Self::DotStar(span) => *span,
15356 }
15357 }
15358}
15359#[derive(Debug, Clone, PartialEq, Eq)]
15360pub enum FieldInitializerChildren<'tree> {
15361 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
15362 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
15363 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15364 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
15365 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
15366}
15367impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerChildren<'tree> {
15368 #[allow(clippy::collapsible_else_if)]
15369 fn from_node(
15370 node: ::treesitter_types::tree_sitter::Node<'tree>,
15371 src: &'tree [u8],
15372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15373 match node.kind() {
15374 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
15375 ::treesitter_types::runtime::maybe_grow_stack(|| {
15376 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
15377 })?,
15378 ))),
15379 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
15380 ::treesitter_types::runtime::maybe_grow_stack(|| {
15381 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15382 })?,
15383 ))),
15384 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15385 ::treesitter_types::runtime::maybe_grow_stack(|| {
15386 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
15387 })?,
15388 ))),
15389 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
15390 ::treesitter_types::runtime::maybe_grow_stack(|| {
15391 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15392 })?,
15393 ))),
15394 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
15395 ::treesitter_types::runtime::maybe_grow_stack(|| {
15396 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
15397 })?,
15398 ))),
15399 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15400 }
15401 }
15402}
15403impl ::treesitter_types::Spanned for FieldInitializerChildren<'_> {
15404 fn span(&self) -> ::treesitter_types::Span {
15405 match self {
15406 Self::ArgumentList(inner) => inner.span(),
15407 Self::FieldIdentifier(inner) => inner.span(),
15408 Self::InitializerList(inner) => inner.span(),
15409 Self::QualifiedIdentifier(inner) => inner.span(),
15410 Self::TemplateMethod(inner) => inner.span(),
15411 }
15412 }
15413}
15414#[derive(Debug, Clone, PartialEq, Eq)]
15415pub enum FoldExpressionLeft<'tree> {
15416 Ellipsis(::treesitter_types::Span),
15417 Expression(::std::boxed::Box<Expression<'tree>>),
15418}
15419impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionLeft<'tree> {
15420 #[allow(clippy::collapsible_else_if)]
15421 fn from_node(
15422 node: ::treesitter_types::tree_sitter::Node<'tree>,
15423 src: &'tree [u8],
15424 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15425 match node.kind() {
15426 "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
15427 _other => {
15428 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15429 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15430 }) {
15431 Ok(Self::Expression(::std::boxed::Box::new(v)))
15432 } else {
15433 Err(::treesitter_types::ParseError::unexpected_kind(
15434 _other, node,
15435 ))
15436 }
15437 }
15438 }
15439 }
15440}
15441impl ::treesitter_types::Spanned for FoldExpressionLeft<'_> {
15442 fn span(&self) -> ::treesitter_types::Span {
15443 match self {
15444 Self::Ellipsis(span) => *span,
15445 Self::Expression(inner) => inner.span(),
15446 }
15447 }
15448}
15449#[derive(Debug, Clone, PartialEq, Eq)]
15450pub enum FoldExpressionOperator {
15451 NotEq(::treesitter_types::Span),
15452 Percent(::treesitter_types::Span),
15453 PercentEq(::treesitter_types::Span),
15454 Amp(::treesitter_types::Span),
15455 AmpAmp(::treesitter_types::Span),
15456 AmpEq(::treesitter_types::Span),
15457 Star(::treesitter_types::Span),
15458 StarEq(::treesitter_types::Span),
15459 Plus(::treesitter_types::Span),
15460 PlusEq(::treesitter_types::Span),
15461 Comma(::treesitter_types::Span),
15462 Minus(::treesitter_types::Span),
15463 MinusEq(::treesitter_types::Span),
15464 MinusGtStar(::treesitter_types::Span),
15465 DotStar(::treesitter_types::Span),
15466 Slash(::treesitter_types::Span),
15467 SlashEq(::treesitter_types::Span),
15468 Lt(::treesitter_types::Span),
15469 Shl(::treesitter_types::Span),
15470 ShlEq(::treesitter_types::Span),
15471 LtEq(::treesitter_types::Span),
15472 Eq(::treesitter_types::Span),
15473 EqEq(::treesitter_types::Span),
15474 Gt(::treesitter_types::Span),
15475 GtEq(::treesitter_types::Span),
15476 Shr(::treesitter_types::Span),
15477 ShrEq(::treesitter_types::Span),
15478 Caret(::treesitter_types::Span),
15479 CaretEq(::treesitter_types::Span),
15480 And(::treesitter_types::Span),
15481 Bitand(::treesitter_types::Span),
15482 Bitor(::treesitter_types::Span),
15483 Or(::treesitter_types::Span),
15484 Xor(::treesitter_types::Span),
15485 Pipe(::treesitter_types::Span),
15486 PipeEq(::treesitter_types::Span),
15487 PipePipe(::treesitter_types::Span),
15488}
15489impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionOperator {
15490 #[allow(clippy::collapsible_else_if)]
15491 fn from_node(
15492 node: ::treesitter_types::tree_sitter::Node<'tree>,
15493 _src: &'tree [u8],
15494 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15495 match node.kind() {
15496 "!=" | "not_eq" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
15497 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
15498 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
15499 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
15500 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
15501 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
15502 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
15503 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
15504 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
15505 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
15506 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
15507 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
15508 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
15509 "->*" => Ok(Self::MinusGtStar(::treesitter_types::Span::from(node))),
15510 ".*" => Ok(Self::DotStar(::treesitter_types::Span::from(node))),
15511 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
15512 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
15513 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
15514 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
15515 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
15516 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
15517 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
15518 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
15519 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
15520 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
15521 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
15522 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
15523 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
15524 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
15525 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
15526 "bitand" => Ok(Self::Bitand(::treesitter_types::Span::from(node))),
15527 "bitor" => Ok(Self::Bitor(::treesitter_types::Span::from(node))),
15528 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
15529 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
15530 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
15531 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
15532 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
15533 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15534 }
15535 }
15536}
15537impl ::treesitter_types::Spanned for FoldExpressionOperator {
15538 fn span(&self) -> ::treesitter_types::Span {
15539 match self {
15540 Self::NotEq(span) => *span,
15541 Self::Percent(span) => *span,
15542 Self::PercentEq(span) => *span,
15543 Self::Amp(span) => *span,
15544 Self::AmpAmp(span) => *span,
15545 Self::AmpEq(span) => *span,
15546 Self::Star(span) => *span,
15547 Self::StarEq(span) => *span,
15548 Self::Plus(span) => *span,
15549 Self::PlusEq(span) => *span,
15550 Self::Comma(span) => *span,
15551 Self::Minus(span) => *span,
15552 Self::MinusEq(span) => *span,
15553 Self::MinusGtStar(span) => *span,
15554 Self::DotStar(span) => *span,
15555 Self::Slash(span) => *span,
15556 Self::SlashEq(span) => *span,
15557 Self::Lt(span) => *span,
15558 Self::Shl(span) => *span,
15559 Self::ShlEq(span) => *span,
15560 Self::LtEq(span) => *span,
15561 Self::Eq(span) => *span,
15562 Self::EqEq(span) => *span,
15563 Self::Gt(span) => *span,
15564 Self::GtEq(span) => *span,
15565 Self::Shr(span) => *span,
15566 Self::ShrEq(span) => *span,
15567 Self::Caret(span) => *span,
15568 Self::CaretEq(span) => *span,
15569 Self::And(span) => *span,
15570 Self::Bitand(span) => *span,
15571 Self::Bitor(span) => *span,
15572 Self::Or(span) => *span,
15573 Self::Xor(span) => *span,
15574 Self::Pipe(span) => *span,
15575 Self::PipeEq(span) => *span,
15576 Self::PipePipe(span) => *span,
15577 }
15578 }
15579}
15580#[derive(Debug, Clone, PartialEq, Eq)]
15581pub enum FoldExpressionRight<'tree> {
15582 Ellipsis(::treesitter_types::Span),
15583 Expression(::std::boxed::Box<Expression<'tree>>),
15584}
15585impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionRight<'tree> {
15586 #[allow(clippy::collapsible_else_if)]
15587 fn from_node(
15588 node: ::treesitter_types::tree_sitter::Node<'tree>,
15589 src: &'tree [u8],
15590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15591 match node.kind() {
15592 "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
15593 _other => {
15594 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15595 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15596 }) {
15597 Ok(Self::Expression(::std::boxed::Box::new(v)))
15598 } else {
15599 Err(::treesitter_types::ParseError::unexpected_kind(
15600 _other, node,
15601 ))
15602 }
15603 }
15604 }
15605 }
15606}
15607impl ::treesitter_types::Spanned for FoldExpressionRight<'_> {
15608 fn span(&self) -> ::treesitter_types::Span {
15609 match self {
15610 Self::Ellipsis(span) => *span,
15611 Self::Expression(inner) => inner.span(),
15612 }
15613 }
15614}
15615#[derive(Debug, Clone, PartialEq, Eq)]
15616pub enum ForRangeLoopRight<'tree> {
15617 Expression(::std::boxed::Box<Expression<'tree>>),
15618 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15619}
15620impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoopRight<'tree> {
15621 #[allow(clippy::collapsible_else_if)]
15622 fn from_node(
15623 node: ::treesitter_types::tree_sitter::Node<'tree>,
15624 src: &'tree [u8],
15625 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15626 match node.kind() {
15627 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15628 ::treesitter_types::runtime::maybe_grow_stack(|| {
15629 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
15630 })?,
15631 ))),
15632 _other => {
15633 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15634 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15635 }) {
15636 Ok(Self::Expression(::std::boxed::Box::new(v)))
15637 } else {
15638 Err(::treesitter_types::ParseError::unexpected_kind(
15639 _other, node,
15640 ))
15641 }
15642 }
15643 }
15644 }
15645}
15646impl ::treesitter_types::Spanned for ForRangeLoopRight<'_> {
15647 fn span(&self) -> ::treesitter_types::Span {
15648 match self {
15649 Self::Expression(inner) => inner.span(),
15650 Self::InitializerList(inner) => inner.span(),
15651 }
15652 }
15653}
15654#[derive(Debug, Clone, PartialEq, Eq)]
15655pub enum ForRangeLoopChildren<'tree> {
15656 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15657 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15658 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
15659 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
15660 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15661}
15662impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoopChildren<'tree> {
15663 #[allow(clippy::collapsible_else_if)]
15664 fn from_node(
15665 node: ::treesitter_types::tree_sitter::Node<'tree>,
15666 src: &'tree [u8],
15667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15668 match node.kind() {
15669 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15670 ::treesitter_types::runtime::maybe_grow_stack(|| {
15671 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15672 })?,
15673 ))),
15674 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15675 ::treesitter_types::runtime::maybe_grow_stack(|| {
15676 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15677 })?,
15678 ))),
15679 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
15680 ::treesitter_types::runtime::maybe_grow_stack(|| {
15681 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
15682 })?,
15683 ))),
15684 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
15685 ::treesitter_types::runtime::maybe_grow_stack(|| {
15686 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15687 })?,
15688 ))),
15689 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15690 ::treesitter_types::runtime::maybe_grow_stack(|| {
15691 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
15692 })?,
15693 ))),
15694 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15695 }
15696 }
15697}
15698impl ::treesitter_types::Spanned for ForRangeLoopChildren<'_> {
15699 fn span(&self) -> ::treesitter_types::Span {
15700 match self {
15701 Self::AttributeDeclaration(inner) => inner.span(),
15702 Self::AttributeSpecifier(inner) => inner.span(),
15703 Self::MsDeclspecModifier(inner) => inner.span(),
15704 Self::StorageClassSpecifier(inner) => inner.span(),
15705 Self::TypeQualifier(inner) => inner.span(),
15706 }
15707 }
15708}
15709#[derive(Debug, Clone, PartialEq, Eq)]
15710pub enum ForStatementCondition<'tree> {
15711 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
15712 Expression(::std::boxed::Box<Expression<'tree>>),
15713}
15714impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
15715 #[allow(clippy::collapsible_else_if)]
15716 fn from_node(
15717 node: ::treesitter_types::tree_sitter::Node<'tree>,
15718 src: &'tree [u8],
15719 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15720 match node.kind() {
15721 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
15722 ::treesitter_types::runtime::maybe_grow_stack(|| {
15723 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
15724 })?,
15725 ))),
15726 _other => {
15727 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15728 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15729 }) {
15730 Ok(Self::Expression(::std::boxed::Box::new(v)))
15731 } else {
15732 Err(::treesitter_types::ParseError::unexpected_kind(
15733 _other, node,
15734 ))
15735 }
15736 }
15737 }
15738 }
15739}
15740impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
15741 fn span(&self) -> ::treesitter_types::Span {
15742 match self {
15743 Self::CommaExpression(inner) => inner.span(),
15744 Self::Expression(inner) => inner.span(),
15745 }
15746 }
15747}
15748#[derive(Debug, Clone, PartialEq, Eq)]
15749pub enum ForStatementInitializer<'tree> {
15750 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
15751 Declaration(::std::boxed::Box<Declaration<'tree>>),
15752 Expression(::std::boxed::Box<Expression<'tree>>),
15753}
15754impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
15755 #[allow(clippy::collapsible_else_if)]
15756 fn from_node(
15757 node: ::treesitter_types::tree_sitter::Node<'tree>,
15758 src: &'tree [u8],
15759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15760 match node.kind() {
15761 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
15762 ::treesitter_types::runtime::maybe_grow_stack(|| {
15763 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
15764 })?,
15765 ))),
15766 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15767 ::treesitter_types::runtime::maybe_grow_stack(|| {
15768 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
15769 })?,
15770 ))),
15771 _other => {
15772 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15773 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15774 }) {
15775 Ok(Self::Expression(::std::boxed::Box::new(v)))
15776 } else {
15777 Err(::treesitter_types::ParseError::unexpected_kind(
15778 _other, node,
15779 ))
15780 }
15781 }
15782 }
15783 }
15784}
15785impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
15786 fn span(&self) -> ::treesitter_types::Span {
15787 match self {
15788 Self::CommaExpression(inner) => inner.span(),
15789 Self::Declaration(inner) => inner.span(),
15790 Self::Expression(inner) => inner.span(),
15791 }
15792 }
15793}
15794#[derive(Debug, Clone, PartialEq, Eq)]
15795pub enum ForStatementUpdate<'tree> {
15796 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
15797 Expression(::std::boxed::Box<Expression<'tree>>),
15798}
15799impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
15800 #[allow(clippy::collapsible_else_if)]
15801 fn from_node(
15802 node: ::treesitter_types::tree_sitter::Node<'tree>,
15803 src: &'tree [u8],
15804 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15805 match node.kind() {
15806 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
15807 ::treesitter_types::runtime::maybe_grow_stack(|| {
15808 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
15809 })?,
15810 ))),
15811 _other => {
15812 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15813 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15814 }) {
15815 Ok(Self::Expression(::std::boxed::Box::new(v)))
15816 } else {
15817 Err(::treesitter_types::ParseError::unexpected_kind(
15818 _other, node,
15819 ))
15820 }
15821 }
15822 }
15823 }
15824}
15825impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
15826 fn span(&self) -> ::treesitter_types::Span {
15827 match self {
15828 Self::CommaExpression(inner) => inner.span(),
15829 Self::Expression(inner) => inner.span(),
15830 }
15831 }
15832}
15833#[derive(Debug, Clone, PartialEq, Eq)]
15834pub enum FriendDeclarationChildren<'tree> {
15835 Declaration(::std::boxed::Box<Declaration<'tree>>),
15836 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
15837 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
15838 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
15839 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
15840}
15841impl<'tree> ::treesitter_types::FromNode<'tree> for FriendDeclarationChildren<'tree> {
15842 #[allow(clippy::collapsible_else_if)]
15843 fn from_node(
15844 node: ::treesitter_types::tree_sitter::Node<'tree>,
15845 src: &'tree [u8],
15846 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15847 match node.kind() {
15848 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15849 ::treesitter_types::runtime::maybe_grow_stack(|| {
15850 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
15851 })?,
15852 ))),
15853 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
15854 ::treesitter_types::runtime::maybe_grow_stack(|| {
15855 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15856 })?,
15857 ))),
15858 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
15859 ::treesitter_types::runtime::maybe_grow_stack(|| {
15860 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15861 })?,
15862 ))),
15863 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
15864 ::treesitter_types::runtime::maybe_grow_stack(|| {
15865 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
15866 })?,
15867 ))),
15868 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
15869 ::treesitter_types::runtime::maybe_grow_stack(|| {
15870 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
15871 })?,
15872 ))),
15873 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15874 }
15875 }
15876}
15877impl ::treesitter_types::Spanned for FriendDeclarationChildren<'_> {
15878 fn span(&self) -> ::treesitter_types::Span {
15879 match self {
15880 Self::Declaration(inner) => inner.span(),
15881 Self::FunctionDefinition(inner) => inner.span(),
15882 Self::QualifiedIdentifier(inner) => inner.span(),
15883 Self::TemplateType(inner) => inner.span(),
15884 Self::TypeIdentifier(inner) => inner.span(),
15885 }
15886 }
15887}
15888#[derive(Debug, Clone, PartialEq, Eq)]
15889pub enum FunctionDeclaratorDeclarator<'tree> {
15890 Declarator(::std::boxed::Box<Declarator<'tree>>),
15891 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
15892 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
15893}
15894impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorDeclarator<'tree> {
15895 #[allow(clippy::collapsible_else_if)]
15896 fn from_node(
15897 node: ::treesitter_types::tree_sitter::Node<'tree>,
15898 src: &'tree [u8],
15899 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15900 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15901 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
15902 }) {
15903 Ok(Self::Declarator(::std::boxed::Box::new(v)))
15904 } else {
15905 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15906 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
15907 }) {
15908 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
15909 } else {
15910 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15911 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
15912 }) {
15913 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
15914 } else {
15915 Err(::treesitter_types::ParseError::unexpected_kind(
15916 node.kind(),
15917 node,
15918 ))
15919 }
15920 }
15921 }
15922 }
15923}
15924impl ::treesitter_types::Spanned for FunctionDeclaratorDeclarator<'_> {
15925 fn span(&self) -> ::treesitter_types::Span {
15926 match self {
15927 Self::Declarator(inner) => inner.span(),
15928 Self::FieldDeclarator(inner) => inner.span(),
15929 Self::TypeDeclarator(inner) => inner.span(),
15930 }
15931 }
15932}
15933#[derive(Debug, Clone, PartialEq, Eq)]
15934pub enum FunctionDeclaratorChildren<'tree> {
15935 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15936 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15937 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
15938 Noexcept(::std::boxed::Box<Noexcept<'tree>>),
15939 RefQualifier(::std::boxed::Box<RefQualifier<'tree>>),
15940 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
15941 ThrowSpecifier(::std::boxed::Box<ThrowSpecifier<'tree>>),
15942 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
15943 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15944 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
15945}
15946impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorChildren<'tree> {
15947 #[allow(clippy::collapsible_else_if)]
15948 fn from_node(
15949 node: ::treesitter_types::tree_sitter::Node<'tree>,
15950 src: &'tree [u8],
15951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15952 match node.kind() {
15953 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15954 ::treesitter_types::runtime::maybe_grow_stack(|| {
15955 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15956 })?,
15957 ))),
15958 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15959 ::treesitter_types::runtime::maybe_grow_stack(|| {
15960 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15961 })?,
15962 ))),
15963 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
15964 ::treesitter_types::runtime::maybe_grow_stack(|| {
15965 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
15966 })?,
15967 ))),
15968 "noexcept" => Ok(Self::Noexcept(::std::boxed::Box::new(
15969 ::treesitter_types::runtime::maybe_grow_stack(|| {
15970 <Noexcept as ::treesitter_types::FromNode>::from_node(node, src)
15971 })?,
15972 ))),
15973 "ref_qualifier" => Ok(Self::RefQualifier(::std::boxed::Box::new(
15974 ::treesitter_types::runtime::maybe_grow_stack(|| {
15975 <RefQualifier as ::treesitter_types::FromNode>::from_node(node, src)
15976 })?,
15977 ))),
15978 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
15979 ::treesitter_types::runtime::maybe_grow_stack(|| {
15980 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)
15981 })?,
15982 ))),
15983 "throw_specifier" => Ok(Self::ThrowSpecifier(::std::boxed::Box::new(
15984 ::treesitter_types::runtime::maybe_grow_stack(|| {
15985 <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
15986 })?,
15987 ))),
15988 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
15989 ::treesitter_types::runtime::maybe_grow_stack(|| {
15990 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)
15991 })?,
15992 ))),
15993 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15994 ::treesitter_types::runtime::maybe_grow_stack(|| {
15995 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
15996 })?,
15997 ))),
15998 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
15999 ::treesitter_types::runtime::maybe_grow_stack(|| {
16000 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16001 })?,
16002 ))),
16003 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16004 }
16005 }
16006}
16007impl ::treesitter_types::Spanned for FunctionDeclaratorChildren<'_> {
16008 fn span(&self) -> ::treesitter_types::Span {
16009 match self {
16010 Self::AttributeDeclaration(inner) => inner.span(),
16011 Self::AttributeSpecifier(inner) => inner.span(),
16012 Self::GnuAsmExpression(inner) => inner.span(),
16013 Self::Noexcept(inner) => inner.span(),
16014 Self::RefQualifier(inner) => inner.span(),
16015 Self::RequiresClause(inner) => inner.span(),
16016 Self::ThrowSpecifier(inner) => inner.span(),
16017 Self::TrailingReturnType(inner) => inner.span(),
16018 Self::TypeQualifier(inner) => inner.span(),
16019 Self::VirtualSpecifier(inner) => inner.span(),
16020 }
16021 }
16022}
16023#[derive(Debug, Clone, PartialEq, Eq)]
16024pub enum FunctionDefinitionBody<'tree> {
16025 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
16026 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
16027}
16028impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionBody<'tree> {
16029 #[allow(clippy::collapsible_else_if)]
16030 fn from_node(
16031 node: ::treesitter_types::tree_sitter::Node<'tree>,
16032 src: &'tree [u8],
16033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16034 match node.kind() {
16035 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
16036 ::treesitter_types::runtime::maybe_grow_stack(|| {
16037 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
16038 })?,
16039 ))),
16040 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
16041 ::treesitter_types::runtime::maybe_grow_stack(|| {
16042 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
16043 })?,
16044 ))),
16045 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16046 }
16047 }
16048}
16049impl ::treesitter_types::Spanned for FunctionDefinitionBody<'_> {
16050 fn span(&self) -> ::treesitter_types::Span {
16051 match self {
16052 Self::CompoundStatement(inner) => inner.span(),
16053 Self::TryStatement(inner) => inner.span(),
16054 }
16055 }
16056}
16057#[derive(Debug, Clone, PartialEq, Eq)]
16058pub enum FunctionDefinitionDeclarator<'tree> {
16059 Declarator(::std::boxed::Box<Declarator<'tree>>),
16060 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
16061 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
16062}
16063impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionDeclarator<'tree> {
16064 #[allow(clippy::collapsible_else_if)]
16065 fn from_node(
16066 node: ::treesitter_types::tree_sitter::Node<'tree>,
16067 src: &'tree [u8],
16068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16069 match node.kind() {
16070 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
16071 ::treesitter_types::runtime::maybe_grow_stack(|| {
16072 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)
16073 })?,
16074 ))),
16075 _other => {
16076 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16077 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
16078 }) {
16079 Ok(Self::Declarator(::std::boxed::Box::new(v)))
16080 } else {
16081 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16082 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
16083 }) {
16084 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
16085 } else {
16086 Err(::treesitter_types::ParseError::unexpected_kind(
16087 _other, node,
16088 ))
16089 }
16090 }
16091 }
16092 }
16093 }
16094}
16095impl ::treesitter_types::Spanned for FunctionDefinitionDeclarator<'_> {
16096 fn span(&self) -> ::treesitter_types::Span {
16097 match self {
16098 Self::Declarator(inner) => inner.span(),
16099 Self::FieldDeclarator(inner) => inner.span(),
16100 Self::OperatorCast(inner) => inner.span(),
16101 }
16102 }
16103}
16104#[derive(Debug, Clone, PartialEq, Eq)]
16105pub enum FunctionDefinitionChildren<'tree> {
16106 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
16107 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
16108 DefaultMethodClause(::std::boxed::Box<DefaultMethodClause<'tree>>),
16109 DeleteMethodClause(::std::boxed::Box<DeleteMethodClause<'tree>>),
16110 ExplicitFunctionSpecifier(::std::boxed::Box<ExplicitFunctionSpecifier<'tree>>),
16111 FieldInitializerList(::std::boxed::Box<FieldInitializerList<'tree>>),
16112 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
16113 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
16114 PureVirtualClause(::std::boxed::Box<PureVirtualClause<'tree>>),
16115 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
16116 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
16117 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16118}
16119impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionChildren<'tree> {
16120 #[allow(clippy::collapsible_else_if)]
16121 fn from_node(
16122 node: ::treesitter_types::tree_sitter::Node<'tree>,
16123 src: &'tree [u8],
16124 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16125 match node.kind() {
16126 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
16127 ::treesitter_types::runtime::maybe_grow_stack(|| {
16128 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16129 })?,
16130 ))),
16131 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
16132 ::treesitter_types::runtime::maybe_grow_stack(|| {
16133 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16134 })?,
16135 ))),
16136 "default_method_clause" => Ok(Self::DefaultMethodClause(::std::boxed::Box::new(
16137 ::treesitter_types::runtime::maybe_grow_stack(|| {
16138 <DefaultMethodClause as ::treesitter_types::FromNode>::from_node(node, src)
16139 })?,
16140 ))),
16141 "delete_method_clause" => Ok(Self::DeleteMethodClause(::std::boxed::Box::new(
16142 ::treesitter_types::runtime::maybe_grow_stack(|| {
16143 <DeleteMethodClause as ::treesitter_types::FromNode>::from_node(node, src)
16144 })?,
16145 ))),
16146 "explicit_function_specifier" => Ok(Self::ExplicitFunctionSpecifier(
16147 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16148 <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(
16149 node, src,
16150 )
16151 })?),
16152 )),
16153 "field_initializer_list" => Ok(Self::FieldInitializerList(::std::boxed::Box::new(
16154 ::treesitter_types::runtime::maybe_grow_stack(|| {
16155 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
16156 })?,
16157 ))),
16158 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
16159 ::treesitter_types::runtime::maybe_grow_stack(|| {
16160 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
16161 })?,
16162 ))),
16163 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
16164 ::treesitter_types::runtime::maybe_grow_stack(|| {
16165 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
16166 })?,
16167 ))),
16168 "pure_virtual_clause" => Ok(Self::PureVirtualClause(::std::boxed::Box::new(
16169 ::treesitter_types::runtime::maybe_grow_stack(|| {
16170 <PureVirtualClause as ::treesitter_types::FromNode>::from_node(node, src)
16171 })?,
16172 ))),
16173 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
16174 ::treesitter_types::runtime::maybe_grow_stack(|| {
16175 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16176 })?,
16177 ))),
16178 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
16179 ::treesitter_types::runtime::maybe_grow_stack(|| {
16180 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
16181 })?,
16182 ))),
16183 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
16184 ::treesitter_types::runtime::maybe_grow_stack(|| {
16185 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
16186 })?,
16187 ))),
16188 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16189 }
16190 }
16191}
16192impl ::treesitter_types::Spanned for FunctionDefinitionChildren<'_> {
16193 fn span(&self) -> ::treesitter_types::Span {
16194 match self {
16195 Self::AttributeDeclaration(inner) => inner.span(),
16196 Self::AttributeSpecifier(inner) => inner.span(),
16197 Self::DefaultMethodClause(inner) => inner.span(),
16198 Self::DeleteMethodClause(inner) => inner.span(),
16199 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
16200 Self::FieldInitializerList(inner) => inner.span(),
16201 Self::MsCallModifier(inner) => inner.span(),
16202 Self::MsDeclspecModifier(inner) => inner.span(),
16203 Self::PureVirtualClause(inner) => inner.span(),
16204 Self::StorageClassSpecifier(inner) => inner.span(),
16205 Self::TryStatement(inner) => inner.span(),
16206 Self::TypeQualifier(inner) => inner.span(),
16207 }
16208 }
16209}
16210#[derive(Debug, Clone, PartialEq, Eq)]
16211pub enum GenericExpressionChildren<'tree> {
16212 Expression(::std::boxed::Box<Expression<'tree>>),
16213 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
16214}
16215impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpressionChildren<'tree> {
16216 #[allow(clippy::collapsible_else_if)]
16217 fn from_node(
16218 node: ::treesitter_types::tree_sitter::Node<'tree>,
16219 src: &'tree [u8],
16220 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16221 match node.kind() {
16222 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
16223 ::treesitter_types::runtime::maybe_grow_stack(|| {
16224 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
16225 })?,
16226 ))),
16227 _other => {
16228 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16229 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16230 }) {
16231 Ok(Self::Expression(::std::boxed::Box::new(v)))
16232 } else {
16233 Err(::treesitter_types::ParseError::unexpected_kind(
16234 _other, node,
16235 ))
16236 }
16237 }
16238 }
16239 }
16240}
16241impl ::treesitter_types::Spanned for GenericExpressionChildren<'_> {
16242 fn span(&self) -> ::treesitter_types::Span {
16243 match self {
16244 Self::Expression(inner) => inner.span(),
16245 Self::TypeDescriptor(inner) => inner.span(),
16246 }
16247 }
16248}
16249#[derive(Debug, Clone, PartialEq, Eq)]
16250pub enum GnuAsmClobberListRegister<'tree> {
16251 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
16252 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
16253 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
16254}
16255impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberListRegister<'tree> {
16256 #[allow(clippy::collapsible_else_if)]
16257 fn from_node(
16258 node: ::treesitter_types::tree_sitter::Node<'tree>,
16259 src: &'tree [u8],
16260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16261 match node.kind() {
16262 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
16263 ::treesitter_types::runtime::maybe_grow_stack(|| {
16264 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
16265 })?,
16266 ))),
16267 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
16268 ::treesitter_types::runtime::maybe_grow_stack(|| {
16269 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
16270 })?,
16271 ))),
16272 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
16273 ::treesitter_types::runtime::maybe_grow_stack(|| {
16274 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
16275 })?,
16276 ))),
16277 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16278 }
16279 }
16280}
16281impl ::treesitter_types::Spanned for GnuAsmClobberListRegister<'_> {
16282 fn span(&self) -> ::treesitter_types::Span {
16283 match self {
16284 Self::ConcatenatedString(inner) => inner.span(),
16285 Self::RawStringLiteral(inner) => inner.span(),
16286 Self::StringLiteral(inner) => inner.span(),
16287 }
16288 }
16289}
16290#[derive(Debug, Clone, PartialEq, Eq)]
16291pub enum GnuAsmExpressionAssemblyCode<'tree> {
16292 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
16293 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
16294 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
16295}
16296impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpressionAssemblyCode<'tree> {
16297 #[allow(clippy::collapsible_else_if)]
16298 fn from_node(
16299 node: ::treesitter_types::tree_sitter::Node<'tree>,
16300 src: &'tree [u8],
16301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16302 match node.kind() {
16303 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
16304 ::treesitter_types::runtime::maybe_grow_stack(|| {
16305 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
16306 })?,
16307 ))),
16308 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
16309 ::treesitter_types::runtime::maybe_grow_stack(|| {
16310 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
16311 })?,
16312 ))),
16313 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
16314 ::treesitter_types::runtime::maybe_grow_stack(|| {
16315 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
16316 })?,
16317 ))),
16318 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16319 }
16320 }
16321}
16322impl ::treesitter_types::Spanned for GnuAsmExpressionAssemblyCode<'_> {
16323 fn span(&self) -> ::treesitter_types::Span {
16324 match self {
16325 Self::ConcatenatedString(inner) => inner.span(),
16326 Self::RawStringLiteral(inner) => inner.span(),
16327 Self::StringLiteral(inner) => inner.span(),
16328 }
16329 }
16330}
16331#[derive(Debug, Clone, PartialEq, Eq)]
16332pub enum InitDeclaratorValue<'tree> {
16333 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
16334 Expression(::std::boxed::Box<Expression<'tree>>),
16335 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
16336}
16337impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclaratorValue<'tree> {
16338 #[allow(clippy::collapsible_else_if)]
16339 fn from_node(
16340 node: ::treesitter_types::tree_sitter::Node<'tree>,
16341 src: &'tree [u8],
16342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16343 match node.kind() {
16344 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
16345 ::treesitter_types::runtime::maybe_grow_stack(|| {
16346 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16347 })?,
16348 ))),
16349 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
16350 ::treesitter_types::runtime::maybe_grow_stack(|| {
16351 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
16352 })?,
16353 ))),
16354 _other => {
16355 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16356 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16357 }) {
16358 Ok(Self::Expression(::std::boxed::Box::new(v)))
16359 } else {
16360 Err(::treesitter_types::ParseError::unexpected_kind(
16361 _other, node,
16362 ))
16363 }
16364 }
16365 }
16366 }
16367}
16368impl ::treesitter_types::Spanned for InitDeclaratorValue<'_> {
16369 fn span(&self) -> ::treesitter_types::Span {
16370 match self {
16371 Self::ArgumentList(inner) => inner.span(),
16372 Self::Expression(inner) => inner.span(),
16373 Self::InitializerList(inner) => inner.span(),
16374 }
16375 }
16376}
16377#[derive(Debug, Clone, PartialEq, Eq)]
16378pub enum InitStatementChildren<'tree> {
16379 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
16380 Declaration(::std::boxed::Box<Declaration<'tree>>),
16381 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
16382 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
16383}
16384impl<'tree> ::treesitter_types::FromNode<'tree> for InitStatementChildren<'tree> {
16385 #[allow(clippy::collapsible_else_if)]
16386 fn from_node(
16387 node: ::treesitter_types::tree_sitter::Node<'tree>,
16388 src: &'tree [u8],
16389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16390 match node.kind() {
16391 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
16392 ::treesitter_types::runtime::maybe_grow_stack(|| {
16393 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16394 })?,
16395 ))),
16396 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16397 ::treesitter_types::runtime::maybe_grow_stack(|| {
16398 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
16399 })?,
16400 ))),
16401 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
16402 ::treesitter_types::runtime::maybe_grow_stack(|| {
16403 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
16404 })?,
16405 ))),
16406 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
16407 ::treesitter_types::runtime::maybe_grow_stack(|| {
16408 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
16409 })?,
16410 ))),
16411 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16412 }
16413 }
16414}
16415impl ::treesitter_types::Spanned for InitStatementChildren<'_> {
16416 fn span(&self) -> ::treesitter_types::Span {
16417 match self {
16418 Self::AliasDeclaration(inner) => inner.span(),
16419 Self::Declaration(inner) => inner.span(),
16420 Self::ExpressionStatement(inner) => inner.span(),
16421 Self::TypeDefinition(inner) => inner.span(),
16422 }
16423 }
16424}
16425#[derive(Debug, Clone, PartialEq, Eq)]
16426pub enum InitializerListChildren<'tree> {
16427 Expression(::std::boxed::Box<Expression<'tree>>),
16428 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
16429 InitializerPair(::std::boxed::Box<InitializerPair<'tree>>),
16430}
16431impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerListChildren<'tree> {
16432 #[allow(clippy::collapsible_else_if)]
16433 fn from_node(
16434 node: ::treesitter_types::tree_sitter::Node<'tree>,
16435 src: &'tree [u8],
16436 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16437 match node.kind() {
16438 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
16439 ::treesitter_types::runtime::maybe_grow_stack(|| {
16440 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
16441 })?,
16442 ))),
16443 "initializer_pair" => Ok(Self::InitializerPair(::std::boxed::Box::new(
16444 ::treesitter_types::runtime::maybe_grow_stack(|| {
16445 <InitializerPair as ::treesitter_types::FromNode>::from_node(node, src)
16446 })?,
16447 ))),
16448 _other => {
16449 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16450 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16451 }) {
16452 Ok(Self::Expression(::std::boxed::Box::new(v)))
16453 } else {
16454 Err(::treesitter_types::ParseError::unexpected_kind(
16455 _other, node,
16456 ))
16457 }
16458 }
16459 }
16460 }
16461}
16462impl ::treesitter_types::Spanned for InitializerListChildren<'_> {
16463 fn span(&self) -> ::treesitter_types::Span {
16464 match self {
16465 Self::Expression(inner) => inner.span(),
16466 Self::InitializerList(inner) => inner.span(),
16467 Self::InitializerPair(inner) => inner.span(),
16468 }
16469 }
16470}
16471#[derive(Debug, Clone, PartialEq, Eq)]
16472pub enum InitializerPairDesignator<'tree> {
16473 FieldDesignator(::std::boxed::Box<FieldDesignator<'tree>>),
16474 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
16475 SubscriptDesignator(::std::boxed::Box<SubscriptDesignator<'tree>>),
16476 SubscriptRangeDesignator(::std::boxed::Box<SubscriptRangeDesignator<'tree>>),
16477}
16478impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairDesignator<'tree> {
16479 #[allow(clippy::collapsible_else_if)]
16480 fn from_node(
16481 node: ::treesitter_types::tree_sitter::Node<'tree>,
16482 src: &'tree [u8],
16483 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16484 match node.kind() {
16485 "field_designator" => Ok(Self::FieldDesignator(::std::boxed::Box::new(
16486 ::treesitter_types::runtime::maybe_grow_stack(|| {
16487 <FieldDesignator as ::treesitter_types::FromNode>::from_node(node, src)
16488 })?,
16489 ))),
16490 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
16491 ::treesitter_types::runtime::maybe_grow_stack(|| {
16492 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
16493 })?,
16494 ))),
16495 "subscript_designator" => Ok(Self::SubscriptDesignator(::std::boxed::Box::new(
16496 ::treesitter_types::runtime::maybe_grow_stack(|| {
16497 <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(node, src)
16498 })?,
16499 ))),
16500 "subscript_range_designator" => Ok(Self::SubscriptRangeDesignator(
16501 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16502 <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(node, src)
16503 })?),
16504 )),
16505 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16506 }
16507 }
16508}
16509impl ::treesitter_types::Spanned for InitializerPairDesignator<'_> {
16510 fn span(&self) -> ::treesitter_types::Span {
16511 match self {
16512 Self::FieldDesignator(inner) => inner.span(),
16513 Self::FieldIdentifier(inner) => inner.span(),
16514 Self::SubscriptDesignator(inner) => inner.span(),
16515 Self::SubscriptRangeDesignator(inner) => inner.span(),
16516 }
16517 }
16518}
16519#[derive(Debug, Clone, PartialEq, Eq)]
16520pub enum InitializerPairValue<'tree> {
16521 Expression(::std::boxed::Box<Expression<'tree>>),
16522 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
16523}
16524impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairValue<'tree> {
16525 #[allow(clippy::collapsible_else_if)]
16526 fn from_node(
16527 node: ::treesitter_types::tree_sitter::Node<'tree>,
16528 src: &'tree [u8],
16529 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16530 match node.kind() {
16531 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
16532 ::treesitter_types::runtime::maybe_grow_stack(|| {
16533 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
16534 })?,
16535 ))),
16536 _other => {
16537 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16538 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16539 }) {
16540 Ok(Self::Expression(::std::boxed::Box::new(v)))
16541 } else {
16542 Err(::treesitter_types::ParseError::unexpected_kind(
16543 _other, node,
16544 ))
16545 }
16546 }
16547 }
16548 }
16549}
16550impl ::treesitter_types::Spanned for InitializerPairValue<'_> {
16551 fn span(&self) -> ::treesitter_types::Span {
16552 match self {
16553 Self::Expression(inner) => inner.span(),
16554 Self::InitializerList(inner) => inner.span(),
16555 }
16556 }
16557}
16558#[derive(Debug, Clone, PartialEq, Eq)]
16559pub enum LabeledStatementChildren<'tree> {
16560 Declaration(::std::boxed::Box<Declaration<'tree>>),
16561 Statement(::std::boxed::Box<Statement<'tree>>),
16562}
16563impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
16564 #[allow(clippy::collapsible_else_if)]
16565 fn from_node(
16566 node: ::treesitter_types::tree_sitter::Node<'tree>,
16567 src: &'tree [u8],
16568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16569 match node.kind() {
16570 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16571 ::treesitter_types::runtime::maybe_grow_stack(|| {
16572 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
16573 })?,
16574 ))),
16575 _other => {
16576 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16577 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16578 }) {
16579 Ok(Self::Statement(::std::boxed::Box::new(v)))
16580 } else {
16581 Err(::treesitter_types::ParseError::unexpected_kind(
16582 _other, node,
16583 ))
16584 }
16585 }
16586 }
16587 }
16588}
16589impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
16590 fn span(&self) -> ::treesitter_types::Span {
16591 match self {
16592 Self::Declaration(inner) => inner.span(),
16593 Self::Statement(inner) => inner.span(),
16594 }
16595 }
16596}
16597#[derive(Debug, Clone, PartialEq, Eq)]
16598pub enum LambdaCaptureSpecifierChildren<'tree> {
16599 Identifier(::std::boxed::Box<Identifier<'tree>>),
16600 LambdaCaptureInitializer(::std::boxed::Box<LambdaCaptureInitializer<'tree>>),
16601 LambdaDefaultCapture(::std::boxed::Box<LambdaDefaultCapture<'tree>>),
16602 ParameterPackExpansion(::std::boxed::Box<ParameterPackExpansion<'tree>>),
16603 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
16604 This(::std::boxed::Box<This<'tree>>),
16605}
16606impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureSpecifierChildren<'tree> {
16607 #[allow(clippy::collapsible_else_if)]
16608 fn from_node(
16609 node: ::treesitter_types::tree_sitter::Node<'tree>,
16610 src: &'tree [u8],
16611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16612 match node.kind() {
16613 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16614 ::treesitter_types::runtime::maybe_grow_stack(|| {
16615 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
16616 })?,
16617 ))),
16618 "lambda_capture_initializer" => Ok(Self::LambdaCaptureInitializer(
16619 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16620 <LambdaCaptureInitializer as ::treesitter_types::FromNode>::from_node(node, src)
16621 })?),
16622 )),
16623 "lambda_default_capture" => Ok(Self::LambdaDefaultCapture(::std::boxed::Box::new(
16624 ::treesitter_types::runtime::maybe_grow_stack(|| {
16625 <LambdaDefaultCapture as ::treesitter_types::FromNode>::from_node(node, src)
16626 })?,
16627 ))),
16628 "parameter_pack_expansion" => Ok(Self::ParameterPackExpansion(::std::boxed::Box::new(
16629 ::treesitter_types::runtime::maybe_grow_stack(|| {
16630 <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(node, src)
16631 })?,
16632 ))),
16633 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
16634 ::treesitter_types::runtime::maybe_grow_stack(|| {
16635 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
16636 })?,
16637 ))),
16638 "this" => Ok(Self::This(::std::boxed::Box::new(
16639 ::treesitter_types::runtime::maybe_grow_stack(|| {
16640 <This as ::treesitter_types::FromNode>::from_node(node, src)
16641 })?,
16642 ))),
16643 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16644 }
16645 }
16646}
16647impl ::treesitter_types::Spanned for LambdaCaptureSpecifierChildren<'_> {
16648 fn span(&self) -> ::treesitter_types::Span {
16649 match self {
16650 Self::Identifier(inner) => inner.span(),
16651 Self::LambdaCaptureInitializer(inner) => inner.span(),
16652 Self::LambdaDefaultCapture(inner) => inner.span(),
16653 Self::ParameterPackExpansion(inner) => inner.span(),
16654 Self::QualifiedIdentifier(inner) => inner.span(),
16655 Self::This(inner) => inner.span(),
16656 }
16657 }
16658}
16659#[derive(Debug, Clone, PartialEq, Eq)]
16660pub enum LinkageSpecificationBody<'tree> {
16661 Declaration(::std::boxed::Box<Declaration<'tree>>),
16662 DeclarationList(::std::boxed::Box<DeclarationList<'tree>>),
16663 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
16664}
16665impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecificationBody<'tree> {
16666 #[allow(clippy::collapsible_else_if)]
16667 fn from_node(
16668 node: ::treesitter_types::tree_sitter::Node<'tree>,
16669 src: &'tree [u8],
16670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16671 match node.kind() {
16672 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16673 ::treesitter_types::runtime::maybe_grow_stack(|| {
16674 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
16675 })?,
16676 ))),
16677 "declaration_list" => Ok(Self::DeclarationList(::std::boxed::Box::new(
16678 ::treesitter_types::runtime::maybe_grow_stack(|| {
16679 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
16680 })?,
16681 ))),
16682 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
16683 ::treesitter_types::runtime::maybe_grow_stack(|| {
16684 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
16685 })?,
16686 ))),
16687 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16688 }
16689 }
16690}
16691impl ::treesitter_types::Spanned for LinkageSpecificationBody<'_> {
16692 fn span(&self) -> ::treesitter_types::Span {
16693 match self {
16694 Self::Declaration(inner) => inner.span(),
16695 Self::DeclarationList(inner) => inner.span(),
16696 Self::FunctionDefinition(inner) => inner.span(),
16697 }
16698 }
16699}
16700#[derive(Debug, Clone, PartialEq, Eq)]
16701pub enum MsPointerModifierChildren<'tree> {
16702 MsRestrictModifier(::std::boxed::Box<MsRestrictModifier<'tree>>),
16703 MsSignedPtrModifier(::std::boxed::Box<MsSignedPtrModifier<'tree>>),
16704 MsUnalignedPtrModifier(::std::boxed::Box<MsUnalignedPtrModifier<'tree>>),
16705 MsUnsignedPtrModifier(::std::boxed::Box<MsUnsignedPtrModifier<'tree>>),
16706}
16707impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifierChildren<'tree> {
16708 #[allow(clippy::collapsible_else_if)]
16709 fn from_node(
16710 node: ::treesitter_types::tree_sitter::Node<'tree>,
16711 src: &'tree [u8],
16712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16713 match node.kind() {
16714 "ms_restrict_modifier" => Ok(Self::MsRestrictModifier(::std::boxed::Box::new(
16715 ::treesitter_types::runtime::maybe_grow_stack(|| {
16716 <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(node, src)
16717 })?,
16718 ))),
16719 "ms_signed_ptr_modifier" => Ok(Self::MsSignedPtrModifier(::std::boxed::Box::new(
16720 ::treesitter_types::runtime::maybe_grow_stack(|| {
16721 <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
16722 })?,
16723 ))),
16724 "ms_unaligned_ptr_modifier" => Ok(Self::MsUnalignedPtrModifier(
16725 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16726 <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
16727 })?),
16728 )),
16729 "ms_unsigned_ptr_modifier" => Ok(Self::MsUnsignedPtrModifier(::std::boxed::Box::new(
16730 ::treesitter_types::runtime::maybe_grow_stack(|| {
16731 <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
16732 })?,
16733 ))),
16734 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16735 }
16736 }
16737}
16738impl ::treesitter_types::Spanned for MsPointerModifierChildren<'_> {
16739 fn span(&self) -> ::treesitter_types::Span {
16740 match self {
16741 Self::MsRestrictModifier(inner) => inner.span(),
16742 Self::MsSignedPtrModifier(inner) => inner.span(),
16743 Self::MsUnalignedPtrModifier(inner) => inner.span(),
16744 Self::MsUnsignedPtrModifier(inner) => inner.span(),
16745 }
16746 }
16747}
16748#[derive(Debug, Clone, PartialEq, Eq)]
16749pub enum NamespaceAliasDefinitionChildren<'tree> {
16750 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
16751 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
16752}
16753impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceAliasDefinitionChildren<'tree> {
16754 #[allow(clippy::collapsible_else_if)]
16755 fn from_node(
16756 node: ::treesitter_types::tree_sitter::Node<'tree>,
16757 src: &'tree [u8],
16758 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16759 match node.kind() {
16760 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
16761 ::treesitter_types::runtime::maybe_grow_stack(|| {
16762 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
16763 })?,
16764 ))),
16765 "nested_namespace_specifier" => Ok(Self::NestedNamespaceSpecifier(
16766 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16767 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16768 })?),
16769 )),
16770 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16771 }
16772 }
16773}
16774impl ::treesitter_types::Spanned for NamespaceAliasDefinitionChildren<'_> {
16775 fn span(&self) -> ::treesitter_types::Span {
16776 match self {
16777 Self::NamespaceIdentifier(inner) => inner.span(),
16778 Self::NestedNamespaceSpecifier(inner) => inner.span(),
16779 }
16780 }
16781}
16782#[derive(Debug, Clone, PartialEq, Eq)]
16783pub enum NamespaceDefinitionName<'tree> {
16784 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
16785 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
16786}
16787impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinitionName<'tree> {
16788 #[allow(clippy::collapsible_else_if)]
16789 fn from_node(
16790 node: ::treesitter_types::tree_sitter::Node<'tree>,
16791 src: &'tree [u8],
16792 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16793 match node.kind() {
16794 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
16795 ::treesitter_types::runtime::maybe_grow_stack(|| {
16796 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
16797 })?,
16798 ))),
16799 "nested_namespace_specifier" => Ok(Self::NestedNamespaceSpecifier(
16800 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16801 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16802 })?),
16803 )),
16804 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16805 }
16806 }
16807}
16808impl ::treesitter_types::Spanned for NamespaceDefinitionName<'_> {
16809 fn span(&self) -> ::treesitter_types::Span {
16810 match self {
16811 Self::NamespaceIdentifier(inner) => inner.span(),
16812 Self::NestedNamespaceSpecifier(inner) => inner.span(),
16813 }
16814 }
16815}
16816#[derive(Debug, Clone, PartialEq, Eq)]
16817pub enum NestedNamespaceSpecifierChildren<'tree> {
16818 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
16819 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
16820}
16821impl<'tree> ::treesitter_types::FromNode<'tree> for NestedNamespaceSpecifierChildren<'tree> {
16822 #[allow(clippy::collapsible_else_if)]
16823 fn from_node(
16824 node: ::treesitter_types::tree_sitter::Node<'tree>,
16825 src: &'tree [u8],
16826 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16827 match node.kind() {
16828 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
16829 ::treesitter_types::runtime::maybe_grow_stack(|| {
16830 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
16831 })?,
16832 ))),
16833 "nested_namespace_specifier" => Ok(Self::NestedNamespaceSpecifier(
16834 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16835 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16836 })?),
16837 )),
16838 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16839 }
16840 }
16841}
16842impl ::treesitter_types::Spanned for NestedNamespaceSpecifierChildren<'_> {
16843 fn span(&self) -> ::treesitter_types::Span {
16844 match self {
16845 Self::NamespaceIdentifier(inner) => inner.span(),
16846 Self::NestedNamespaceSpecifier(inner) => inner.span(),
16847 }
16848 }
16849}
16850#[derive(Debug, Clone, PartialEq, Eq)]
16851pub enum NewExpressionArguments<'tree> {
16852 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
16853 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
16854}
16855impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpressionArguments<'tree> {
16856 #[allow(clippy::collapsible_else_if)]
16857 fn from_node(
16858 node: ::treesitter_types::tree_sitter::Node<'tree>,
16859 src: &'tree [u8],
16860 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16861 match node.kind() {
16862 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
16863 ::treesitter_types::runtime::maybe_grow_stack(|| {
16864 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
16865 })?,
16866 ))),
16867 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
16868 ::treesitter_types::runtime::maybe_grow_stack(|| {
16869 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
16870 })?,
16871 ))),
16872 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16873 }
16874 }
16875}
16876impl ::treesitter_types::Spanned for NewExpressionArguments<'_> {
16877 fn span(&self) -> ::treesitter_types::Span {
16878 match self {
16879 Self::ArgumentList(inner) => inner.span(),
16880 Self::InitializerList(inner) => inner.span(),
16881 }
16882 }
16883}
16884#[derive(Debug, Clone, PartialEq, Eq)]
16885pub enum OperatorCastChildren<'tree> {
16886 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
16887 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
16888 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
16889 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
16890 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16891}
16892impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorCastChildren<'tree> {
16893 #[allow(clippy::collapsible_else_if)]
16894 fn from_node(
16895 node: ::treesitter_types::tree_sitter::Node<'tree>,
16896 src: &'tree [u8],
16897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16898 match node.kind() {
16899 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
16900 ::treesitter_types::runtime::maybe_grow_stack(|| {
16901 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16902 })?,
16903 ))),
16904 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
16905 ::treesitter_types::runtime::maybe_grow_stack(|| {
16906 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16907 })?,
16908 ))),
16909 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
16910 ::treesitter_types::runtime::maybe_grow_stack(|| {
16911 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
16912 })?,
16913 ))),
16914 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
16915 ::treesitter_types::runtime::maybe_grow_stack(|| {
16916 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16917 })?,
16918 ))),
16919 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
16920 ::treesitter_types::runtime::maybe_grow_stack(|| {
16921 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
16922 })?,
16923 ))),
16924 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16925 }
16926 }
16927}
16928impl ::treesitter_types::Spanned for OperatorCastChildren<'_> {
16929 fn span(&self) -> ::treesitter_types::Span {
16930 match self {
16931 Self::AttributeDeclaration(inner) => inner.span(),
16932 Self::AttributeSpecifier(inner) => inner.span(),
16933 Self::MsDeclspecModifier(inner) => inner.span(),
16934 Self::StorageClassSpecifier(inner) => inner.span(),
16935 Self::TypeQualifier(inner) => inner.span(),
16936 }
16937 }
16938}
16939#[derive(Debug, Clone, PartialEq, Eq)]
16940pub enum OptionalParameterDeclarationDeclarator<'tree> {
16941 Declarator(::std::boxed::Box<Declarator<'tree>>),
16942 AbstractReferenceDeclarator(::std::boxed::Box<AbstractReferenceDeclarator<'tree>>),
16943}
16944impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclarationDeclarator<'tree> {
16945 #[allow(clippy::collapsible_else_if)]
16946 fn from_node(
16947 node: ::treesitter_types::tree_sitter::Node<'tree>,
16948 src: &'tree [u8],
16949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16950 match node.kind() {
16951 "abstract_reference_declarator" => Ok(Self::AbstractReferenceDeclarator(
16952 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
16953 <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
16954 node, src,
16955 )
16956 })?),
16957 )),
16958 _other => {
16959 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16960 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
16961 }) {
16962 Ok(Self::Declarator(::std::boxed::Box::new(v)))
16963 } else {
16964 Err(::treesitter_types::ParseError::unexpected_kind(
16965 _other, node,
16966 ))
16967 }
16968 }
16969 }
16970 }
16971}
16972impl ::treesitter_types::Spanned for OptionalParameterDeclarationDeclarator<'_> {
16973 fn span(&self) -> ::treesitter_types::Span {
16974 match self {
16975 Self::Declarator(inner) => inner.span(),
16976 Self::AbstractReferenceDeclarator(inner) => inner.span(),
16977 }
16978 }
16979}
16980#[derive(Debug, Clone, PartialEq, Eq)]
16981pub enum OptionalParameterDeclarationChildren<'tree> {
16982 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
16983 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
16984 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
16985 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
16986 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16987}
16988impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclarationChildren<'tree> {
16989 #[allow(clippy::collapsible_else_if)]
16990 fn from_node(
16991 node: ::treesitter_types::tree_sitter::Node<'tree>,
16992 src: &'tree [u8],
16993 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16994 match node.kind() {
16995 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
16996 ::treesitter_types::runtime::maybe_grow_stack(|| {
16997 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16998 })?,
16999 ))),
17000 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
17001 ::treesitter_types::runtime::maybe_grow_stack(|| {
17002 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17003 })?,
17004 ))),
17005 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
17006 ::treesitter_types::runtime::maybe_grow_stack(|| {
17007 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
17008 })?,
17009 ))),
17010 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
17011 ::treesitter_types::runtime::maybe_grow_stack(|| {
17012 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17013 })?,
17014 ))),
17015 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
17016 ::treesitter_types::runtime::maybe_grow_stack(|| {
17017 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
17018 })?,
17019 ))),
17020 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17021 }
17022 }
17023}
17024impl ::treesitter_types::Spanned for OptionalParameterDeclarationChildren<'_> {
17025 fn span(&self) -> ::treesitter_types::Span {
17026 match self {
17027 Self::AttributeDeclaration(inner) => inner.span(),
17028 Self::AttributeSpecifier(inner) => inner.span(),
17029 Self::MsDeclspecModifier(inner) => inner.span(),
17030 Self::StorageClassSpecifier(inner) => inner.span(),
17031 Self::TypeQualifier(inner) => inner.span(),
17032 }
17033 }
17034}
17035#[derive(Debug, Clone, PartialEq, Eq)]
17036pub enum ParameterDeclarationDeclarator<'tree> {
17037 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
17038 Declarator(::std::boxed::Box<Declarator<'tree>>),
17039}
17040impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationDeclarator<'tree> {
17041 #[allow(clippy::collapsible_else_if)]
17042 fn from_node(
17043 node: ::treesitter_types::tree_sitter::Node<'tree>,
17044 src: &'tree [u8],
17045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17046 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17047 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17048 }) {
17049 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
17050 } else {
17051 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17052 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
17053 }) {
17054 Ok(Self::Declarator(::std::boxed::Box::new(v)))
17055 } else {
17056 Err(::treesitter_types::ParseError::unexpected_kind(
17057 node.kind(),
17058 node,
17059 ))
17060 }
17061 }
17062 }
17063}
17064impl ::treesitter_types::Spanned for ParameterDeclarationDeclarator<'_> {
17065 fn span(&self) -> ::treesitter_types::Span {
17066 match self {
17067 Self::AbstractDeclarator(inner) => inner.span(),
17068 Self::Declarator(inner) => inner.span(),
17069 }
17070 }
17071}
17072#[derive(Debug, Clone, PartialEq, Eq)]
17073pub enum ParameterDeclarationChildren<'tree> {
17074 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
17075 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
17076 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
17077 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
17078 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
17079}
17080impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationChildren<'tree> {
17081 #[allow(clippy::collapsible_else_if)]
17082 fn from_node(
17083 node: ::treesitter_types::tree_sitter::Node<'tree>,
17084 src: &'tree [u8],
17085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17086 match node.kind() {
17087 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
17088 ::treesitter_types::runtime::maybe_grow_stack(|| {
17089 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17090 })?,
17091 ))),
17092 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
17093 ::treesitter_types::runtime::maybe_grow_stack(|| {
17094 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17095 })?,
17096 ))),
17097 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
17098 ::treesitter_types::runtime::maybe_grow_stack(|| {
17099 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
17100 })?,
17101 ))),
17102 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
17103 ::treesitter_types::runtime::maybe_grow_stack(|| {
17104 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17105 })?,
17106 ))),
17107 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
17108 ::treesitter_types::runtime::maybe_grow_stack(|| {
17109 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
17110 })?,
17111 ))),
17112 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17113 }
17114 }
17115}
17116impl ::treesitter_types::Spanned for ParameterDeclarationChildren<'_> {
17117 fn span(&self) -> ::treesitter_types::Span {
17118 match self {
17119 Self::AttributeDeclaration(inner) => inner.span(),
17120 Self::AttributeSpecifier(inner) => inner.span(),
17121 Self::MsDeclspecModifier(inner) => inner.span(),
17122 Self::StorageClassSpecifier(inner) => inner.span(),
17123 Self::TypeQualifier(inner) => inner.span(),
17124 }
17125 }
17126}
17127#[derive(Debug, Clone, PartialEq, Eq)]
17128pub enum ParameterListChildren<'tree> {
17129 OptionalParameterDeclaration(::std::boxed::Box<OptionalParameterDeclaration<'tree>>),
17130 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
17131 VariadicParameterDeclaration(::std::boxed::Box<VariadicParameterDeclaration<'tree>>),
17132}
17133impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
17134 #[allow(clippy::collapsible_else_if)]
17135 fn from_node(
17136 node: ::treesitter_types::tree_sitter::Node<'tree>,
17137 src: &'tree [u8],
17138 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17139 match node.kind() {
17140 "optional_parameter_declaration" => Ok(Self::OptionalParameterDeclaration(
17141 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17142 <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(
17143 node, src,
17144 )
17145 })?),
17146 )),
17147 "parameter_declaration" => Ok(Self::ParameterDeclaration(::std::boxed::Box::new(
17148 ::treesitter_types::runtime::maybe_grow_stack(|| {
17149 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17150 })?,
17151 ))),
17152 "variadic_parameter_declaration" => Ok(Self::VariadicParameterDeclaration(
17153 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17154 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
17155 node, src,
17156 )
17157 })?),
17158 )),
17159 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17160 }
17161 }
17162}
17163impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
17164 fn span(&self) -> ::treesitter_types::Span {
17165 match self {
17166 Self::OptionalParameterDeclaration(inner) => inner.span(),
17167 Self::ParameterDeclaration(inner) => inner.span(),
17168 Self::VariadicParameterDeclaration(inner) => inner.span(),
17169 }
17170 }
17171}
17172#[derive(Debug, Clone, PartialEq, Eq)]
17173pub enum ParameterPackExpansionPattern<'tree> {
17174 Expression(::std::boxed::Box<Expression<'tree>>),
17175 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
17176}
17177impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPackExpansionPattern<'tree> {
17178 #[allow(clippy::collapsible_else_if)]
17179 fn from_node(
17180 node: ::treesitter_types::tree_sitter::Node<'tree>,
17181 src: &'tree [u8],
17182 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17183 match node.kind() {
17184 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
17185 ::treesitter_types::runtime::maybe_grow_stack(|| {
17186 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
17187 })?,
17188 ))),
17189 _other => {
17190 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17191 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17192 }) {
17193 Ok(Self::Expression(::std::boxed::Box::new(v)))
17194 } else {
17195 Err(::treesitter_types::ParseError::unexpected_kind(
17196 _other, node,
17197 ))
17198 }
17199 }
17200 }
17201 }
17202}
17203impl ::treesitter_types::Spanned for ParameterPackExpansionPattern<'_> {
17204 fn span(&self) -> ::treesitter_types::Span {
17205 match self {
17206 Self::Expression(inner) => inner.span(),
17207 Self::TypeDescriptor(inner) => inner.span(),
17208 }
17209 }
17210}
17211#[derive(Debug, Clone, PartialEq, Eq)]
17212pub enum ParenthesizedDeclaratorChildren<'tree> {
17213 Declarator(::std::boxed::Box<Declarator<'tree>>),
17214 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
17215 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
17216 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
17217}
17218impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclaratorChildren<'tree> {
17219 #[allow(clippy::collapsible_else_if)]
17220 fn from_node(
17221 node: ::treesitter_types::tree_sitter::Node<'tree>,
17222 src: &'tree [u8],
17223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17224 match node.kind() {
17225 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
17226 ::treesitter_types::runtime::maybe_grow_stack(|| {
17227 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
17228 })?,
17229 ))),
17230 _other => {
17231 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17232 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
17233 }) {
17234 Ok(Self::Declarator(::std::boxed::Box::new(v)))
17235 } else {
17236 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17237 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17238 }) {
17239 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
17240 } else {
17241 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17242 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17243 }) {
17244 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
17245 } else {
17246 Err(::treesitter_types::ParseError::unexpected_kind(
17247 _other, node,
17248 ))
17249 }
17250 }
17251 }
17252 }
17253 }
17254 }
17255}
17256impl ::treesitter_types::Spanned for ParenthesizedDeclaratorChildren<'_> {
17257 fn span(&self) -> ::treesitter_types::Span {
17258 match self {
17259 Self::Declarator(inner) => inner.span(),
17260 Self::FieldDeclarator(inner) => inner.span(),
17261 Self::TypeDeclarator(inner) => inner.span(),
17262 Self::MsCallModifier(inner) => inner.span(),
17263 }
17264 }
17265}
17266#[derive(Debug, Clone, PartialEq, Eq)]
17267pub enum ParenthesizedExpressionChildren<'tree> {
17268 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
17269 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
17270 Expression(::std::boxed::Box<Expression<'tree>>),
17271 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
17272}
17273impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
17274 #[allow(clippy::collapsible_else_if)]
17275 fn from_node(
17276 node: ::treesitter_types::tree_sitter::Node<'tree>,
17277 src: &'tree [u8],
17278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17279 match node.kind() {
17280 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
17281 ::treesitter_types::runtime::maybe_grow_stack(|| {
17282 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
17283 })?,
17284 ))),
17285 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
17286 ::treesitter_types::runtime::maybe_grow_stack(|| {
17287 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
17288 })?,
17289 ))),
17290 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
17291 ::treesitter_types::runtime::maybe_grow_stack(|| {
17292 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
17293 })?,
17294 ))),
17295 _other => {
17296 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17297 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
17298 }) {
17299 Ok(Self::Expression(::std::boxed::Box::new(v)))
17300 } else {
17301 Err(::treesitter_types::ParseError::unexpected_kind(
17302 _other, node,
17303 ))
17304 }
17305 }
17306 }
17307 }
17308}
17309impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
17310 fn span(&self) -> ::treesitter_types::Span {
17311 match self {
17312 Self::CommaExpression(inner) => inner.span(),
17313 Self::CompoundStatement(inner) => inner.span(),
17314 Self::Expression(inner) => inner.span(),
17315 Self::PreprocDefined(inner) => inner.span(),
17316 }
17317 }
17318}
17319#[derive(Debug, Clone, PartialEq, Eq)]
17320pub enum PlaceholderTypeSpecifierChildren<'tree> {
17321 Auto(::std::boxed::Box<Auto<'tree>>),
17322 Decltype(::std::boxed::Box<Decltype<'tree>>),
17323}
17324impl<'tree> ::treesitter_types::FromNode<'tree> for PlaceholderTypeSpecifierChildren<'tree> {
17325 #[allow(clippy::collapsible_else_if)]
17326 fn from_node(
17327 node: ::treesitter_types::tree_sitter::Node<'tree>,
17328 src: &'tree [u8],
17329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17330 match node.kind() {
17331 "auto" => Ok(Self::Auto(::std::boxed::Box::new(
17332 ::treesitter_types::runtime::maybe_grow_stack(|| {
17333 <Auto as ::treesitter_types::FromNode>::from_node(node, src)
17334 })?,
17335 ))),
17336 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
17337 ::treesitter_types::runtime::maybe_grow_stack(|| {
17338 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)
17339 })?,
17340 ))),
17341 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17342 }
17343 }
17344}
17345impl ::treesitter_types::Spanned for PlaceholderTypeSpecifierChildren<'_> {
17346 fn span(&self) -> ::treesitter_types::Span {
17347 match self {
17348 Self::Auto(inner) => inner.span(),
17349 Self::Decltype(inner) => inner.span(),
17350 }
17351 }
17352}
17353#[derive(Debug, Clone, PartialEq, Eq)]
17354pub enum PointerDeclaratorDeclarator<'tree> {
17355 Declarator(::std::boxed::Box<Declarator<'tree>>),
17356 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
17357 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
17358}
17359impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorDeclarator<'tree> {
17360 #[allow(clippy::collapsible_else_if)]
17361 fn from_node(
17362 node: ::treesitter_types::tree_sitter::Node<'tree>,
17363 src: &'tree [u8],
17364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17365 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17366 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
17367 }) {
17368 Ok(Self::Declarator(::std::boxed::Box::new(v)))
17369 } else {
17370 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17371 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17372 }) {
17373 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
17374 } else {
17375 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17376 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17377 }) {
17378 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
17379 } else {
17380 Err(::treesitter_types::ParseError::unexpected_kind(
17381 node.kind(),
17382 node,
17383 ))
17384 }
17385 }
17386 }
17387 }
17388}
17389impl ::treesitter_types::Spanned for PointerDeclaratorDeclarator<'_> {
17390 fn span(&self) -> ::treesitter_types::Span {
17391 match self {
17392 Self::Declarator(inner) => inner.span(),
17393 Self::FieldDeclarator(inner) => inner.span(),
17394 Self::TypeDeclarator(inner) => inner.span(),
17395 }
17396 }
17397}
17398#[derive(Debug, Clone, PartialEq, Eq)]
17399pub enum PointerDeclaratorChildren<'tree> {
17400 MsBasedModifier(::std::boxed::Box<MsBasedModifier<'tree>>),
17401 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
17402 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
17403}
17404impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorChildren<'tree> {
17405 #[allow(clippy::collapsible_else_if)]
17406 fn from_node(
17407 node: ::treesitter_types::tree_sitter::Node<'tree>,
17408 src: &'tree [u8],
17409 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17410 match node.kind() {
17411 "ms_based_modifier" => Ok(Self::MsBasedModifier(::std::boxed::Box::new(
17412 ::treesitter_types::runtime::maybe_grow_stack(|| {
17413 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)
17414 })?,
17415 ))),
17416 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
17417 ::treesitter_types::runtime::maybe_grow_stack(|| {
17418 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
17419 })?,
17420 ))),
17421 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
17422 ::treesitter_types::runtime::maybe_grow_stack(|| {
17423 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
17424 })?,
17425 ))),
17426 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17427 }
17428 }
17429}
17430impl ::treesitter_types::Spanned for PointerDeclaratorChildren<'_> {
17431 fn span(&self) -> ::treesitter_types::Span {
17432 match self {
17433 Self::MsBasedModifier(inner) => inner.span(),
17434 Self::MsPointerModifier(inner) => inner.span(),
17435 Self::TypeQualifier(inner) => inner.span(),
17436 }
17437 }
17438}
17439#[derive(Debug, Clone, PartialEq, Eq)]
17440pub enum PointerExpressionOperator {
17441 Amp(::treesitter_types::Span),
17442 Star(::treesitter_types::Span),
17443}
17444impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpressionOperator {
17445 #[allow(clippy::collapsible_else_if)]
17446 fn from_node(
17447 node: ::treesitter_types::tree_sitter::Node<'tree>,
17448 _src: &'tree [u8],
17449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17450 match node.kind() {
17451 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
17452 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
17453 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17454 }
17455 }
17456}
17457impl ::treesitter_types::Spanned for PointerExpressionOperator {
17458 fn span(&self) -> ::treesitter_types::Span {
17459 match self {
17460 Self::Amp(span) => *span,
17461 Self::Star(span) => *span,
17462 }
17463 }
17464}
17465#[derive(Debug, Clone, PartialEq, Eq)]
17466pub enum PointerTypeDeclaratorChildren<'tree> {
17467 MsBasedModifier(::std::boxed::Box<MsBasedModifier<'tree>>),
17468 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
17469 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
17470}
17471impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeDeclaratorChildren<'tree> {
17472 #[allow(clippy::collapsible_else_if)]
17473 fn from_node(
17474 node: ::treesitter_types::tree_sitter::Node<'tree>,
17475 src: &'tree [u8],
17476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17477 match node.kind() {
17478 "ms_based_modifier" => Ok(Self::MsBasedModifier(::std::boxed::Box::new(
17479 ::treesitter_types::runtime::maybe_grow_stack(|| {
17480 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)
17481 })?,
17482 ))),
17483 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
17484 ::treesitter_types::runtime::maybe_grow_stack(|| {
17485 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
17486 })?,
17487 ))),
17488 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
17489 ::treesitter_types::runtime::maybe_grow_stack(|| {
17490 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
17491 })?,
17492 ))),
17493 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17494 }
17495 }
17496}
17497impl ::treesitter_types::Spanned for PointerTypeDeclaratorChildren<'_> {
17498 fn span(&self) -> ::treesitter_types::Span {
17499 match self {
17500 Self::MsBasedModifier(inner) => inner.span(),
17501 Self::MsPointerModifier(inner) => inner.span(),
17502 Self::TypeQualifier(inner) => inner.span(),
17503 }
17504 }
17505}
17506#[derive(Debug, Clone, PartialEq, Eq)]
17507pub enum PreprocElifAlternative<'tree> {
17508 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17509 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
17510 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17511}
17512impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
17513 #[allow(clippy::collapsible_else_if)]
17514 fn from_node(
17515 node: ::treesitter_types::tree_sitter::Node<'tree>,
17516 src: &'tree [u8],
17517 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17518 match node.kind() {
17519 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17520 ::treesitter_types::runtime::maybe_grow_stack(|| {
17521 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
17522 })?,
17523 ))),
17524 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
17525 ::treesitter_types::runtime::maybe_grow_stack(|| {
17526 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
17527 })?,
17528 ))),
17529 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17530 ::treesitter_types::runtime::maybe_grow_stack(|| {
17531 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
17532 })?,
17533 ))),
17534 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17535 }
17536 }
17537}
17538impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
17539 fn span(&self) -> ::treesitter_types::Span {
17540 match self {
17541 Self::PreprocElif(inner) => inner.span(),
17542 Self::PreprocElifdef(inner) => inner.span(),
17543 Self::PreprocElse(inner) => inner.span(),
17544 }
17545 }
17546}
17547#[derive(Debug, Clone, PartialEq, Eq)]
17548pub enum PreprocElifCondition<'tree> {
17549 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
17550 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
17551 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
17552 Identifier(::std::boxed::Box<Identifier<'tree>>),
17553 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
17554 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17555 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
17556 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
17557}
17558impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
17559 #[allow(clippy::collapsible_else_if)]
17560 fn from_node(
17561 node: ::treesitter_types::tree_sitter::Node<'tree>,
17562 src: &'tree [u8],
17563 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17564 match node.kind() {
17565 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
17566 ::treesitter_types::runtime::maybe_grow_stack(|| {
17567 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
17568 })?,
17569 ))),
17570 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
17571 ::treesitter_types::runtime::maybe_grow_stack(|| {
17572 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
17573 })?,
17574 ))),
17575 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
17576 ::treesitter_types::runtime::maybe_grow_stack(|| {
17577 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17578 })?,
17579 ))),
17580 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17581 ::treesitter_types::runtime::maybe_grow_stack(|| {
17582 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
17583 })?,
17584 ))),
17585 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
17586 ::treesitter_types::runtime::maybe_grow_stack(|| {
17587 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
17588 })?,
17589 ))),
17590 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
17591 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17592 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
17593 })?),
17594 )),
17595 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
17596 ::treesitter_types::runtime::maybe_grow_stack(|| {
17597 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
17598 })?,
17599 ))),
17600 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
17601 ::treesitter_types::runtime::maybe_grow_stack(|| {
17602 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
17603 })?,
17604 ))),
17605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17606 }
17607 }
17608}
17609impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
17610 fn span(&self) -> ::treesitter_types::Span {
17611 match self {
17612 Self::BinaryExpression(inner) => inner.span(),
17613 Self::CallExpression(inner) => inner.span(),
17614 Self::CharLiteral(inner) => inner.span(),
17615 Self::Identifier(inner) => inner.span(),
17616 Self::NumberLiteral(inner) => inner.span(),
17617 Self::ParenthesizedExpression(inner) => inner.span(),
17618 Self::PreprocDefined(inner) => inner.span(),
17619 Self::UnaryExpression(inner) => inner.span(),
17620 }
17621 }
17622}
17623#[derive(Debug, Clone, PartialEq, Eq)]
17624pub enum PreprocElifChildren<'tree> {
17625 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
17626 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
17627 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
17628 Declaration(::std::boxed::Box<Declaration<'tree>>),
17629 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
17630 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
17631 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
17632 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
17633 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
17634 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
17635 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
17636 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
17637 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
17638 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
17639 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
17640 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
17641 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
17642 Statement(::std::boxed::Box<Statement<'tree>>),
17643 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
17644 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
17645 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
17646 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
17647 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
17648 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
17649}
17650impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
17651 #[allow(clippy::collapsible_else_if)]
17652 fn from_node(
17653 node: ::treesitter_types::tree_sitter::Node<'tree>,
17654 src: &'tree [u8],
17655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17656 match node.kind() {
17657 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
17658 ::treesitter_types::runtime::maybe_grow_stack(|| {
17659 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17660 })?,
17661 ))),
17662 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
17663 ::treesitter_types::runtime::maybe_grow_stack(|| {
17664 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17665 })?,
17666 ))),
17667 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
17668 ::treesitter_types::runtime::maybe_grow_stack(|| {
17669 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17670 })?,
17671 ))),
17672 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
17673 ::treesitter_types::runtime::maybe_grow_stack(|| {
17674 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
17675 })?,
17676 ))),
17677 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
17678 ::treesitter_types::runtime::maybe_grow_stack(|| {
17679 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
17680 })?,
17681 ))),
17682 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
17683 ::treesitter_types::runtime::maybe_grow_stack(|| {
17684 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17685 })?,
17686 ))),
17687 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
17688 ::treesitter_types::runtime::maybe_grow_stack(|| {
17689 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17690 })?,
17691 ))),
17692 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
17693 ::treesitter_types::runtime::maybe_grow_stack(|| {
17694 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17695 })?,
17696 ))),
17697 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
17698 ::treesitter_types::runtime::maybe_grow_stack(|| {
17699 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
17700 })?,
17701 ))),
17702 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
17703 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17704 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17705 })?),
17706 )),
17707 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
17708 ::treesitter_types::runtime::maybe_grow_stack(|| {
17709 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17710 })?,
17711 ))),
17712 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
17713 ::treesitter_types::runtime::maybe_grow_stack(|| {
17714 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
17715 })?,
17716 ))),
17717 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
17718 ::treesitter_types::runtime::maybe_grow_stack(|| {
17719 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
17720 })?,
17721 ))),
17722 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
17723 ::treesitter_types::runtime::maybe_grow_stack(|| {
17724 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
17725 })?,
17726 ))),
17727 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
17728 ::treesitter_types::runtime::maybe_grow_stack(|| {
17729 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
17730 })?,
17731 ))),
17732 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
17733 ::treesitter_types::runtime::maybe_grow_stack(|| {
17734 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
17735 })?,
17736 ))),
17737 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
17738 ::treesitter_types::runtime::maybe_grow_stack(|| {
17739 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
17740 })?,
17741 ))),
17742 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
17743 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17744 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17745 })?),
17746 )),
17747 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
17748 ::treesitter_types::runtime::maybe_grow_stack(|| {
17749 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17750 })?,
17751 ))),
17752 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
17753 ::treesitter_types::runtime::maybe_grow_stack(|| {
17754 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
17755 })?,
17756 ))),
17757 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
17758 ::treesitter_types::runtime::maybe_grow_stack(|| {
17759 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17760 })?,
17761 ))),
17762 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
17763 ::treesitter_types::runtime::maybe_grow_stack(|| {
17764 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17765 })?,
17766 ))),
17767 _other => {
17768 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17769 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
17770 }) {
17771 Ok(Self::Statement(::std::boxed::Box::new(v)))
17772 } else {
17773 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
17774 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17775 }) {
17776 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
17777 } else {
17778 Err(::treesitter_types::ParseError::unexpected_kind(
17779 _other, node,
17780 ))
17781 }
17782 }
17783 }
17784 }
17785 }
17786}
17787impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
17788 fn span(&self) -> ::treesitter_types::Span {
17789 match self {
17790 Self::AccessSpecifier(inner) => inner.span(),
17791 Self::AliasDeclaration(inner) => inner.span(),
17792 Self::ConceptDefinition(inner) => inner.span(),
17793 Self::Declaration(inner) => inner.span(),
17794 Self::Enumerator(inner) => inner.span(),
17795 Self::FieldDeclaration(inner) => inner.span(),
17796 Self::FriendDeclaration(inner) => inner.span(),
17797 Self::FunctionDefinition(inner) => inner.span(),
17798 Self::LinkageSpecification(inner) => inner.span(),
17799 Self::NamespaceAliasDefinition(inner) => inner.span(),
17800 Self::NamespaceDefinition(inner) => inner.span(),
17801 Self::PreprocCall(inner) => inner.span(),
17802 Self::PreprocDef(inner) => inner.span(),
17803 Self::PreprocFunctionDef(inner) => inner.span(),
17804 Self::PreprocIf(inner) => inner.span(),
17805 Self::PreprocIfdef(inner) => inner.span(),
17806 Self::PreprocInclude(inner) => inner.span(),
17807 Self::Statement(inner) => inner.span(),
17808 Self::StaticAssertDeclaration(inner) => inner.span(),
17809 Self::TemplateDeclaration(inner) => inner.span(),
17810 Self::TemplateInstantiation(inner) => inner.span(),
17811 Self::TypeDefinition(inner) => inner.span(),
17812 Self::TypeSpecifier(inner) => inner.span(),
17813 Self::UsingDeclaration(inner) => inner.span(),
17814 }
17815 }
17816}
17817#[derive(Debug, Clone, PartialEq, Eq)]
17818pub enum PreprocElifdefAlternative<'tree> {
17819 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17820 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
17821 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17822}
17823impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefAlternative<'tree> {
17824 #[allow(clippy::collapsible_else_if)]
17825 fn from_node(
17826 node: ::treesitter_types::tree_sitter::Node<'tree>,
17827 src: &'tree [u8],
17828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17829 match node.kind() {
17830 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17831 ::treesitter_types::runtime::maybe_grow_stack(|| {
17832 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
17833 })?,
17834 ))),
17835 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
17836 ::treesitter_types::runtime::maybe_grow_stack(|| {
17837 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
17838 })?,
17839 ))),
17840 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17841 ::treesitter_types::runtime::maybe_grow_stack(|| {
17842 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
17843 })?,
17844 ))),
17845 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17846 }
17847 }
17848}
17849impl ::treesitter_types::Spanned for PreprocElifdefAlternative<'_> {
17850 fn span(&self) -> ::treesitter_types::Span {
17851 match self {
17852 Self::PreprocElif(inner) => inner.span(),
17853 Self::PreprocElifdef(inner) => inner.span(),
17854 Self::PreprocElse(inner) => inner.span(),
17855 }
17856 }
17857}
17858#[derive(Debug, Clone, PartialEq, Eq)]
17859pub enum PreprocElifdefChildren<'tree> {
17860 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
17861 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
17862 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
17863 Declaration(::std::boxed::Box<Declaration<'tree>>),
17864 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
17865 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
17866 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
17867 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
17868 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
17869 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
17870 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
17871 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
17872 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
17873 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
17874 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
17875 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
17876 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
17877 Statement(::std::boxed::Box<Statement<'tree>>),
17878 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
17879 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
17880 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
17881 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
17882 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
17883 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
17884}
17885impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefChildren<'tree> {
17886 #[allow(clippy::collapsible_else_if)]
17887 fn from_node(
17888 node: ::treesitter_types::tree_sitter::Node<'tree>,
17889 src: &'tree [u8],
17890 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17891 match node.kind() {
17892 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
17893 ::treesitter_types::runtime::maybe_grow_stack(|| {
17894 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17895 })?,
17896 ))),
17897 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
17898 ::treesitter_types::runtime::maybe_grow_stack(|| {
17899 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17900 })?,
17901 ))),
17902 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
17903 ::treesitter_types::runtime::maybe_grow_stack(|| {
17904 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17905 })?,
17906 ))),
17907 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
17908 ::treesitter_types::runtime::maybe_grow_stack(|| {
17909 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
17910 })?,
17911 ))),
17912 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
17913 ::treesitter_types::runtime::maybe_grow_stack(|| {
17914 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
17915 })?,
17916 ))),
17917 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
17918 ::treesitter_types::runtime::maybe_grow_stack(|| {
17919 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17920 })?,
17921 ))),
17922 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
17923 ::treesitter_types::runtime::maybe_grow_stack(|| {
17924 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17925 })?,
17926 ))),
17927 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
17928 ::treesitter_types::runtime::maybe_grow_stack(|| {
17929 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17930 })?,
17931 ))),
17932 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
17933 ::treesitter_types::runtime::maybe_grow_stack(|| {
17934 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
17935 })?,
17936 ))),
17937 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
17938 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17939 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17940 })?),
17941 )),
17942 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
17943 ::treesitter_types::runtime::maybe_grow_stack(|| {
17944 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17945 })?,
17946 ))),
17947 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
17948 ::treesitter_types::runtime::maybe_grow_stack(|| {
17949 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
17950 })?,
17951 ))),
17952 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
17953 ::treesitter_types::runtime::maybe_grow_stack(|| {
17954 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
17955 })?,
17956 ))),
17957 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
17958 ::treesitter_types::runtime::maybe_grow_stack(|| {
17959 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
17960 })?,
17961 ))),
17962 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
17963 ::treesitter_types::runtime::maybe_grow_stack(|| {
17964 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
17965 })?,
17966 ))),
17967 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
17968 ::treesitter_types::runtime::maybe_grow_stack(|| {
17969 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
17970 })?,
17971 ))),
17972 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
17973 ::treesitter_types::runtime::maybe_grow_stack(|| {
17974 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
17975 })?,
17976 ))),
17977 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
17978 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
17979 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17980 })?),
17981 )),
17982 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
17983 ::treesitter_types::runtime::maybe_grow_stack(|| {
17984 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
17985 })?,
17986 ))),
17987 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
17988 ::treesitter_types::runtime::maybe_grow_stack(|| {
17989 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
17990 })?,
17991 ))),
17992 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
17993 ::treesitter_types::runtime::maybe_grow_stack(|| {
17994 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
17995 })?,
17996 ))),
17997 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
17998 ::treesitter_types::runtime::maybe_grow_stack(|| {
17999 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18000 })?,
18001 ))),
18002 _other => {
18003 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18004 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18005 }) {
18006 Ok(Self::Statement(::std::boxed::Box::new(v)))
18007 } else {
18008 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18009 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18010 }) {
18011 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18012 } else {
18013 Err(::treesitter_types::ParseError::unexpected_kind(
18014 _other, node,
18015 ))
18016 }
18017 }
18018 }
18019 }
18020 }
18021}
18022impl ::treesitter_types::Spanned for PreprocElifdefChildren<'_> {
18023 fn span(&self) -> ::treesitter_types::Span {
18024 match self {
18025 Self::AccessSpecifier(inner) => inner.span(),
18026 Self::AliasDeclaration(inner) => inner.span(),
18027 Self::ConceptDefinition(inner) => inner.span(),
18028 Self::Declaration(inner) => inner.span(),
18029 Self::Enumerator(inner) => inner.span(),
18030 Self::FieldDeclaration(inner) => inner.span(),
18031 Self::FriendDeclaration(inner) => inner.span(),
18032 Self::FunctionDefinition(inner) => inner.span(),
18033 Self::LinkageSpecification(inner) => inner.span(),
18034 Self::NamespaceAliasDefinition(inner) => inner.span(),
18035 Self::NamespaceDefinition(inner) => inner.span(),
18036 Self::PreprocCall(inner) => inner.span(),
18037 Self::PreprocDef(inner) => inner.span(),
18038 Self::PreprocFunctionDef(inner) => inner.span(),
18039 Self::PreprocIf(inner) => inner.span(),
18040 Self::PreprocIfdef(inner) => inner.span(),
18041 Self::PreprocInclude(inner) => inner.span(),
18042 Self::Statement(inner) => inner.span(),
18043 Self::StaticAssertDeclaration(inner) => inner.span(),
18044 Self::TemplateDeclaration(inner) => inner.span(),
18045 Self::TemplateInstantiation(inner) => inner.span(),
18046 Self::TypeDefinition(inner) => inner.span(),
18047 Self::TypeSpecifier(inner) => inner.span(),
18048 Self::UsingDeclaration(inner) => inner.span(),
18049 }
18050 }
18051}
18052#[derive(Debug, Clone, PartialEq, Eq)]
18053pub enum PreprocElseChildren<'tree> {
18054 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
18055 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
18056 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
18057 Declaration(::std::boxed::Box<Declaration<'tree>>),
18058 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
18059 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
18060 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
18061 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
18062 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
18063 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
18064 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
18065 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
18066 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
18067 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
18068 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
18069 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
18070 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
18071 Statement(::std::boxed::Box<Statement<'tree>>),
18072 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
18073 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
18074 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
18075 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
18076 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
18077 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
18078}
18079impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
18080 #[allow(clippy::collapsible_else_if)]
18081 fn from_node(
18082 node: ::treesitter_types::tree_sitter::Node<'tree>,
18083 src: &'tree [u8],
18084 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18085 match node.kind() {
18086 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
18087 ::treesitter_types::runtime::maybe_grow_stack(|| {
18088 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18089 })?,
18090 ))),
18091 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
18092 ::treesitter_types::runtime::maybe_grow_stack(|| {
18093 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18094 })?,
18095 ))),
18096 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
18097 ::treesitter_types::runtime::maybe_grow_stack(|| {
18098 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18099 })?,
18100 ))),
18101 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
18102 ::treesitter_types::runtime::maybe_grow_stack(|| {
18103 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18104 })?,
18105 ))),
18106 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
18107 ::treesitter_types::runtime::maybe_grow_stack(|| {
18108 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
18109 })?,
18110 ))),
18111 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
18112 ::treesitter_types::runtime::maybe_grow_stack(|| {
18113 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18114 })?,
18115 ))),
18116 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
18117 ::treesitter_types::runtime::maybe_grow_stack(|| {
18118 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18119 })?,
18120 ))),
18121 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
18122 ::treesitter_types::runtime::maybe_grow_stack(|| {
18123 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18124 })?,
18125 ))),
18126 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
18127 ::treesitter_types::runtime::maybe_grow_stack(|| {
18128 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
18129 })?,
18130 ))),
18131 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
18132 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18133 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18134 })?),
18135 )),
18136 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
18137 ::treesitter_types::runtime::maybe_grow_stack(|| {
18138 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18139 })?,
18140 ))),
18141 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
18142 ::treesitter_types::runtime::maybe_grow_stack(|| {
18143 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
18144 })?,
18145 ))),
18146 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
18147 ::treesitter_types::runtime::maybe_grow_stack(|| {
18148 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
18149 })?,
18150 ))),
18151 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
18152 ::treesitter_types::runtime::maybe_grow_stack(|| {
18153 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
18154 })?,
18155 ))),
18156 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
18157 ::treesitter_types::runtime::maybe_grow_stack(|| {
18158 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
18159 })?,
18160 ))),
18161 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
18162 ::treesitter_types::runtime::maybe_grow_stack(|| {
18163 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
18164 })?,
18165 ))),
18166 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
18167 ::treesitter_types::runtime::maybe_grow_stack(|| {
18168 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
18169 })?,
18170 ))),
18171 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
18172 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18173 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18174 })?),
18175 )),
18176 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
18177 ::treesitter_types::runtime::maybe_grow_stack(|| {
18178 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18179 })?,
18180 ))),
18181 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
18182 ::treesitter_types::runtime::maybe_grow_stack(|| {
18183 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
18184 })?,
18185 ))),
18186 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
18187 ::treesitter_types::runtime::maybe_grow_stack(|| {
18188 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18189 })?,
18190 ))),
18191 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
18192 ::treesitter_types::runtime::maybe_grow_stack(|| {
18193 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18194 })?,
18195 ))),
18196 _other => {
18197 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18198 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18199 }) {
18200 Ok(Self::Statement(::std::boxed::Box::new(v)))
18201 } else {
18202 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18203 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18204 }) {
18205 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18206 } else {
18207 Err(::treesitter_types::ParseError::unexpected_kind(
18208 _other, node,
18209 ))
18210 }
18211 }
18212 }
18213 }
18214 }
18215}
18216impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
18217 fn span(&self) -> ::treesitter_types::Span {
18218 match self {
18219 Self::AccessSpecifier(inner) => inner.span(),
18220 Self::AliasDeclaration(inner) => inner.span(),
18221 Self::ConceptDefinition(inner) => inner.span(),
18222 Self::Declaration(inner) => inner.span(),
18223 Self::Enumerator(inner) => inner.span(),
18224 Self::FieldDeclaration(inner) => inner.span(),
18225 Self::FriendDeclaration(inner) => inner.span(),
18226 Self::FunctionDefinition(inner) => inner.span(),
18227 Self::LinkageSpecification(inner) => inner.span(),
18228 Self::NamespaceAliasDefinition(inner) => inner.span(),
18229 Self::NamespaceDefinition(inner) => inner.span(),
18230 Self::PreprocCall(inner) => inner.span(),
18231 Self::PreprocDef(inner) => inner.span(),
18232 Self::PreprocFunctionDef(inner) => inner.span(),
18233 Self::PreprocIf(inner) => inner.span(),
18234 Self::PreprocIfdef(inner) => inner.span(),
18235 Self::PreprocInclude(inner) => inner.span(),
18236 Self::Statement(inner) => inner.span(),
18237 Self::StaticAssertDeclaration(inner) => inner.span(),
18238 Self::TemplateDeclaration(inner) => inner.span(),
18239 Self::TemplateInstantiation(inner) => inner.span(),
18240 Self::TypeDefinition(inner) => inner.span(),
18241 Self::TypeSpecifier(inner) => inner.span(),
18242 Self::UsingDeclaration(inner) => inner.span(),
18243 }
18244 }
18245}
18246#[derive(Debug, Clone, PartialEq, Eq)]
18247pub enum PreprocIfAlternative<'tree> {
18248 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
18249 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
18250 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
18251}
18252impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
18253 #[allow(clippy::collapsible_else_if)]
18254 fn from_node(
18255 node: ::treesitter_types::tree_sitter::Node<'tree>,
18256 src: &'tree [u8],
18257 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18258 match node.kind() {
18259 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
18260 ::treesitter_types::runtime::maybe_grow_stack(|| {
18261 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
18262 })?,
18263 ))),
18264 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
18265 ::treesitter_types::runtime::maybe_grow_stack(|| {
18266 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
18267 })?,
18268 ))),
18269 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
18270 ::treesitter_types::runtime::maybe_grow_stack(|| {
18271 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
18272 })?,
18273 ))),
18274 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18275 }
18276 }
18277}
18278impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
18279 fn span(&self) -> ::treesitter_types::Span {
18280 match self {
18281 Self::PreprocElif(inner) => inner.span(),
18282 Self::PreprocElifdef(inner) => inner.span(),
18283 Self::PreprocElse(inner) => inner.span(),
18284 }
18285 }
18286}
18287#[derive(Debug, Clone, PartialEq, Eq)]
18288pub enum PreprocIfCondition<'tree> {
18289 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
18290 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
18291 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
18292 Identifier(::std::boxed::Box<Identifier<'tree>>),
18293 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
18294 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
18295 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
18296 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
18297}
18298impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
18299 #[allow(clippy::collapsible_else_if)]
18300 fn from_node(
18301 node: ::treesitter_types::tree_sitter::Node<'tree>,
18302 src: &'tree [u8],
18303 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18304 match node.kind() {
18305 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
18306 ::treesitter_types::runtime::maybe_grow_stack(|| {
18307 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18308 })?,
18309 ))),
18310 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
18311 ::treesitter_types::runtime::maybe_grow_stack(|| {
18312 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
18313 })?,
18314 ))),
18315 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
18316 ::treesitter_types::runtime::maybe_grow_stack(|| {
18317 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18318 })?,
18319 ))),
18320 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18321 ::treesitter_types::runtime::maybe_grow_stack(|| {
18322 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18323 })?,
18324 ))),
18325 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
18326 ::treesitter_types::runtime::maybe_grow_stack(|| {
18327 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18328 })?,
18329 ))),
18330 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
18331 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18332 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
18333 })?),
18334 )),
18335 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
18336 ::treesitter_types::runtime::maybe_grow_stack(|| {
18337 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
18338 })?,
18339 ))),
18340 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
18341 ::treesitter_types::runtime::maybe_grow_stack(|| {
18342 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
18343 })?,
18344 ))),
18345 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18346 }
18347 }
18348}
18349impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
18350 fn span(&self) -> ::treesitter_types::Span {
18351 match self {
18352 Self::BinaryExpression(inner) => inner.span(),
18353 Self::CallExpression(inner) => inner.span(),
18354 Self::CharLiteral(inner) => inner.span(),
18355 Self::Identifier(inner) => inner.span(),
18356 Self::NumberLiteral(inner) => inner.span(),
18357 Self::ParenthesizedExpression(inner) => inner.span(),
18358 Self::PreprocDefined(inner) => inner.span(),
18359 Self::UnaryExpression(inner) => inner.span(),
18360 }
18361 }
18362}
18363#[derive(Debug, Clone, PartialEq, Eq)]
18364pub enum PreprocIfChildren<'tree> {
18365 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
18366 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
18367 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
18368 Declaration(::std::boxed::Box<Declaration<'tree>>),
18369 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
18370 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
18371 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
18372 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
18373 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
18374 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
18375 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
18376 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
18377 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
18378 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
18379 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
18380 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
18381 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
18382 Statement(::std::boxed::Box<Statement<'tree>>),
18383 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
18384 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
18385 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
18386 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
18387 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
18388 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
18389}
18390impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
18391 #[allow(clippy::collapsible_else_if)]
18392 fn from_node(
18393 node: ::treesitter_types::tree_sitter::Node<'tree>,
18394 src: &'tree [u8],
18395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18396 match node.kind() {
18397 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
18398 ::treesitter_types::runtime::maybe_grow_stack(|| {
18399 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18400 })?,
18401 ))),
18402 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
18403 ::treesitter_types::runtime::maybe_grow_stack(|| {
18404 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18405 })?,
18406 ))),
18407 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
18408 ::treesitter_types::runtime::maybe_grow_stack(|| {
18409 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18410 })?,
18411 ))),
18412 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
18413 ::treesitter_types::runtime::maybe_grow_stack(|| {
18414 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18415 })?,
18416 ))),
18417 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
18418 ::treesitter_types::runtime::maybe_grow_stack(|| {
18419 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
18420 })?,
18421 ))),
18422 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
18423 ::treesitter_types::runtime::maybe_grow_stack(|| {
18424 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18425 })?,
18426 ))),
18427 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
18428 ::treesitter_types::runtime::maybe_grow_stack(|| {
18429 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18430 })?,
18431 ))),
18432 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
18433 ::treesitter_types::runtime::maybe_grow_stack(|| {
18434 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18435 })?,
18436 ))),
18437 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
18438 ::treesitter_types::runtime::maybe_grow_stack(|| {
18439 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
18440 })?,
18441 ))),
18442 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
18443 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18444 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18445 })?),
18446 )),
18447 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
18448 ::treesitter_types::runtime::maybe_grow_stack(|| {
18449 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18450 })?,
18451 ))),
18452 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
18453 ::treesitter_types::runtime::maybe_grow_stack(|| {
18454 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
18455 })?,
18456 ))),
18457 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
18458 ::treesitter_types::runtime::maybe_grow_stack(|| {
18459 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
18460 })?,
18461 ))),
18462 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
18463 ::treesitter_types::runtime::maybe_grow_stack(|| {
18464 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
18465 })?,
18466 ))),
18467 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
18468 ::treesitter_types::runtime::maybe_grow_stack(|| {
18469 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
18470 })?,
18471 ))),
18472 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
18473 ::treesitter_types::runtime::maybe_grow_stack(|| {
18474 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
18475 })?,
18476 ))),
18477 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
18478 ::treesitter_types::runtime::maybe_grow_stack(|| {
18479 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
18480 })?,
18481 ))),
18482 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
18483 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18484 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18485 })?),
18486 )),
18487 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
18488 ::treesitter_types::runtime::maybe_grow_stack(|| {
18489 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18490 })?,
18491 ))),
18492 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
18493 ::treesitter_types::runtime::maybe_grow_stack(|| {
18494 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
18495 })?,
18496 ))),
18497 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
18498 ::treesitter_types::runtime::maybe_grow_stack(|| {
18499 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18500 })?,
18501 ))),
18502 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
18503 ::treesitter_types::runtime::maybe_grow_stack(|| {
18504 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18505 })?,
18506 ))),
18507 _other => {
18508 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18509 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18510 }) {
18511 Ok(Self::Statement(::std::boxed::Box::new(v)))
18512 } else {
18513 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18514 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18515 }) {
18516 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18517 } else {
18518 Err(::treesitter_types::ParseError::unexpected_kind(
18519 _other, node,
18520 ))
18521 }
18522 }
18523 }
18524 }
18525 }
18526}
18527impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
18528 fn span(&self) -> ::treesitter_types::Span {
18529 match self {
18530 Self::AccessSpecifier(inner) => inner.span(),
18531 Self::AliasDeclaration(inner) => inner.span(),
18532 Self::ConceptDefinition(inner) => inner.span(),
18533 Self::Declaration(inner) => inner.span(),
18534 Self::Enumerator(inner) => inner.span(),
18535 Self::FieldDeclaration(inner) => inner.span(),
18536 Self::FriendDeclaration(inner) => inner.span(),
18537 Self::FunctionDefinition(inner) => inner.span(),
18538 Self::LinkageSpecification(inner) => inner.span(),
18539 Self::NamespaceAliasDefinition(inner) => inner.span(),
18540 Self::NamespaceDefinition(inner) => inner.span(),
18541 Self::PreprocCall(inner) => inner.span(),
18542 Self::PreprocDef(inner) => inner.span(),
18543 Self::PreprocFunctionDef(inner) => inner.span(),
18544 Self::PreprocIf(inner) => inner.span(),
18545 Self::PreprocIfdef(inner) => inner.span(),
18546 Self::PreprocInclude(inner) => inner.span(),
18547 Self::Statement(inner) => inner.span(),
18548 Self::StaticAssertDeclaration(inner) => inner.span(),
18549 Self::TemplateDeclaration(inner) => inner.span(),
18550 Self::TemplateInstantiation(inner) => inner.span(),
18551 Self::TypeDefinition(inner) => inner.span(),
18552 Self::TypeSpecifier(inner) => inner.span(),
18553 Self::UsingDeclaration(inner) => inner.span(),
18554 }
18555 }
18556}
18557#[derive(Debug, Clone, PartialEq, Eq)]
18558pub enum PreprocIfdefAlternative<'tree> {
18559 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
18560 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
18561 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
18562}
18563impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefAlternative<'tree> {
18564 #[allow(clippy::collapsible_else_if)]
18565 fn from_node(
18566 node: ::treesitter_types::tree_sitter::Node<'tree>,
18567 src: &'tree [u8],
18568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18569 match node.kind() {
18570 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
18571 ::treesitter_types::runtime::maybe_grow_stack(|| {
18572 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
18573 })?,
18574 ))),
18575 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
18576 ::treesitter_types::runtime::maybe_grow_stack(|| {
18577 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
18578 })?,
18579 ))),
18580 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
18581 ::treesitter_types::runtime::maybe_grow_stack(|| {
18582 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
18583 })?,
18584 ))),
18585 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18586 }
18587 }
18588}
18589impl ::treesitter_types::Spanned for PreprocIfdefAlternative<'_> {
18590 fn span(&self) -> ::treesitter_types::Span {
18591 match self {
18592 Self::PreprocElif(inner) => inner.span(),
18593 Self::PreprocElifdef(inner) => inner.span(),
18594 Self::PreprocElse(inner) => inner.span(),
18595 }
18596 }
18597}
18598#[derive(Debug, Clone, PartialEq, Eq)]
18599pub enum PreprocIfdefChildren<'tree> {
18600 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
18601 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
18602 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
18603 Declaration(::std::boxed::Box<Declaration<'tree>>),
18604 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
18605 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
18606 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
18607 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
18608 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
18609 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
18610 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
18611 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
18612 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
18613 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
18614 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
18615 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
18616 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
18617 Statement(::std::boxed::Box<Statement<'tree>>),
18618 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
18619 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
18620 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
18621 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
18622 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
18623 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
18624}
18625impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefChildren<'tree> {
18626 #[allow(clippy::collapsible_else_if)]
18627 fn from_node(
18628 node: ::treesitter_types::tree_sitter::Node<'tree>,
18629 src: &'tree [u8],
18630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18631 match node.kind() {
18632 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
18633 ::treesitter_types::runtime::maybe_grow_stack(|| {
18634 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18635 })?,
18636 ))),
18637 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
18638 ::treesitter_types::runtime::maybe_grow_stack(|| {
18639 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18640 })?,
18641 ))),
18642 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
18643 ::treesitter_types::runtime::maybe_grow_stack(|| {
18644 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18645 })?,
18646 ))),
18647 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
18648 ::treesitter_types::runtime::maybe_grow_stack(|| {
18649 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
18650 })?,
18651 ))),
18652 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
18653 ::treesitter_types::runtime::maybe_grow_stack(|| {
18654 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
18655 })?,
18656 ))),
18657 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
18658 ::treesitter_types::runtime::maybe_grow_stack(|| {
18659 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18660 })?,
18661 ))),
18662 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
18663 ::treesitter_types::runtime::maybe_grow_stack(|| {
18664 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18665 })?,
18666 ))),
18667 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
18668 ::treesitter_types::runtime::maybe_grow_stack(|| {
18669 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18670 })?,
18671 ))),
18672 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
18673 ::treesitter_types::runtime::maybe_grow_stack(|| {
18674 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
18675 })?,
18676 ))),
18677 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
18678 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18679 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18680 })?),
18681 )),
18682 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
18683 ::treesitter_types::runtime::maybe_grow_stack(|| {
18684 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18685 })?,
18686 ))),
18687 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
18688 ::treesitter_types::runtime::maybe_grow_stack(|| {
18689 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
18690 })?,
18691 ))),
18692 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
18693 ::treesitter_types::runtime::maybe_grow_stack(|| {
18694 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
18695 })?,
18696 ))),
18697 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
18698 ::treesitter_types::runtime::maybe_grow_stack(|| {
18699 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
18700 })?,
18701 ))),
18702 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
18703 ::treesitter_types::runtime::maybe_grow_stack(|| {
18704 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
18705 })?,
18706 ))),
18707 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
18708 ::treesitter_types::runtime::maybe_grow_stack(|| {
18709 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
18710 })?,
18711 ))),
18712 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
18713 ::treesitter_types::runtime::maybe_grow_stack(|| {
18714 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
18715 })?,
18716 ))),
18717 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
18718 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
18719 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18720 })?),
18721 )),
18722 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
18723 ::treesitter_types::runtime::maybe_grow_stack(|| {
18724 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18725 })?,
18726 ))),
18727 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
18728 ::treesitter_types::runtime::maybe_grow_stack(|| {
18729 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
18730 })?,
18731 ))),
18732 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
18733 ::treesitter_types::runtime::maybe_grow_stack(|| {
18734 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
18735 })?,
18736 ))),
18737 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
18738 ::treesitter_types::runtime::maybe_grow_stack(|| {
18739 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
18740 })?,
18741 ))),
18742 _other => {
18743 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18744 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
18745 }) {
18746 Ok(Self::Statement(::std::boxed::Box::new(v)))
18747 } else {
18748 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
18749 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18750 }) {
18751 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18752 } else {
18753 Err(::treesitter_types::ParseError::unexpected_kind(
18754 _other, node,
18755 ))
18756 }
18757 }
18758 }
18759 }
18760 }
18761}
18762impl ::treesitter_types::Spanned for PreprocIfdefChildren<'_> {
18763 fn span(&self) -> ::treesitter_types::Span {
18764 match self {
18765 Self::AccessSpecifier(inner) => inner.span(),
18766 Self::AliasDeclaration(inner) => inner.span(),
18767 Self::ConceptDefinition(inner) => inner.span(),
18768 Self::Declaration(inner) => inner.span(),
18769 Self::Enumerator(inner) => inner.span(),
18770 Self::FieldDeclaration(inner) => inner.span(),
18771 Self::FriendDeclaration(inner) => inner.span(),
18772 Self::FunctionDefinition(inner) => inner.span(),
18773 Self::LinkageSpecification(inner) => inner.span(),
18774 Self::NamespaceAliasDefinition(inner) => inner.span(),
18775 Self::NamespaceDefinition(inner) => inner.span(),
18776 Self::PreprocCall(inner) => inner.span(),
18777 Self::PreprocDef(inner) => inner.span(),
18778 Self::PreprocFunctionDef(inner) => inner.span(),
18779 Self::PreprocIf(inner) => inner.span(),
18780 Self::PreprocIfdef(inner) => inner.span(),
18781 Self::PreprocInclude(inner) => inner.span(),
18782 Self::Statement(inner) => inner.span(),
18783 Self::StaticAssertDeclaration(inner) => inner.span(),
18784 Self::TemplateDeclaration(inner) => inner.span(),
18785 Self::TemplateInstantiation(inner) => inner.span(),
18786 Self::TypeDefinition(inner) => inner.span(),
18787 Self::TypeSpecifier(inner) => inner.span(),
18788 Self::UsingDeclaration(inner) => inner.span(),
18789 }
18790 }
18791}
18792#[derive(Debug, Clone, PartialEq, Eq)]
18793pub enum PreprocIncludePath<'tree> {
18794 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
18795 Identifier(::std::boxed::Box<Identifier<'tree>>),
18796 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
18797 SystemLibString(::std::boxed::Box<SystemLibString<'tree>>),
18798}
18799impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIncludePath<'tree> {
18800 #[allow(clippy::collapsible_else_if)]
18801 fn from_node(
18802 node: ::treesitter_types::tree_sitter::Node<'tree>,
18803 src: &'tree [u8],
18804 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18805 match node.kind() {
18806 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
18807 ::treesitter_types::runtime::maybe_grow_stack(|| {
18808 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
18809 })?,
18810 ))),
18811 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18812 ::treesitter_types::runtime::maybe_grow_stack(|| {
18813 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18814 })?,
18815 ))),
18816 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
18817 ::treesitter_types::runtime::maybe_grow_stack(|| {
18818 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
18819 })?,
18820 ))),
18821 "system_lib_string" => Ok(Self::SystemLibString(::std::boxed::Box::new(
18822 ::treesitter_types::runtime::maybe_grow_stack(|| {
18823 <SystemLibString as ::treesitter_types::FromNode>::from_node(node, src)
18824 })?,
18825 ))),
18826 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18827 }
18828 }
18829}
18830impl ::treesitter_types::Spanned for PreprocIncludePath<'_> {
18831 fn span(&self) -> ::treesitter_types::Span {
18832 match self {
18833 Self::CallExpression(inner) => inner.span(),
18834 Self::Identifier(inner) => inner.span(),
18835 Self::StringLiteral(inner) => inner.span(),
18836 Self::SystemLibString(inner) => inner.span(),
18837 }
18838 }
18839}
18840#[derive(Debug, Clone, PartialEq, Eq)]
18841pub enum QualifiedIdentifierName<'tree> {
18842 DependentName(::std::boxed::Box<DependentName<'tree>>),
18843 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
18844 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
18845 Identifier(::std::boxed::Box<Identifier<'tree>>),
18846 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
18847 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
18848 PointerTypeDeclarator(::std::boxed::Box<PointerTypeDeclarator<'tree>>),
18849 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
18850 Template(::treesitter_types::Span),
18851 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
18852 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
18853 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
18854 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
18855}
18856impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifierName<'tree> {
18857 #[allow(clippy::collapsible_else_if)]
18858 fn from_node(
18859 node: ::treesitter_types::tree_sitter::Node<'tree>,
18860 src: &'tree [u8],
18861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18862 match node.kind() {
18863 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
18864 ::treesitter_types::runtime::maybe_grow_stack(|| {
18865 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)
18866 })?,
18867 ))),
18868 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
18869 ::treesitter_types::runtime::maybe_grow_stack(|| {
18870 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)
18871 })?,
18872 ))),
18873 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
18874 ::treesitter_types::runtime::maybe_grow_stack(|| {
18875 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
18876 })?,
18877 ))),
18878 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
18879 ::treesitter_types::runtime::maybe_grow_stack(|| {
18880 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
18881 })?,
18882 ))),
18883 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
18884 ::treesitter_types::runtime::maybe_grow_stack(|| {
18885 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)
18886 })?,
18887 ))),
18888 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
18889 ::treesitter_types::runtime::maybe_grow_stack(|| {
18890 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)
18891 })?,
18892 ))),
18893 "pointer_type_declarator" => Ok(Self::PointerTypeDeclarator(::std::boxed::Box::new(
18894 ::treesitter_types::runtime::maybe_grow_stack(|| {
18895 <PointerTypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
18896 })?,
18897 ))),
18898 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
18899 ::treesitter_types::runtime::maybe_grow_stack(|| {
18900 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
18901 })?,
18902 ))),
18903 "template" => Ok(Self::Template(::treesitter_types::Span::from(node))),
18904 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
18905 ::treesitter_types::runtime::maybe_grow_stack(|| {
18906 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)
18907 })?,
18908 ))),
18909 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
18910 ::treesitter_types::runtime::maybe_grow_stack(|| {
18911 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
18912 })?,
18913 ))),
18914 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
18915 ::treesitter_types::runtime::maybe_grow_stack(|| {
18916 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
18917 })?,
18918 ))),
18919 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
18920 ::treesitter_types::runtime::maybe_grow_stack(|| {
18921 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
18922 })?,
18923 ))),
18924 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18925 }
18926 }
18927}
18928impl ::treesitter_types::Spanned for QualifiedIdentifierName<'_> {
18929 fn span(&self) -> ::treesitter_types::Span {
18930 match self {
18931 Self::DependentName(inner) => inner.span(),
18932 Self::DestructorName(inner) => inner.span(),
18933 Self::FieldIdentifier(inner) => inner.span(),
18934 Self::Identifier(inner) => inner.span(),
18935 Self::OperatorCast(inner) => inner.span(),
18936 Self::OperatorName(inner) => inner.span(),
18937 Self::PointerTypeDeclarator(inner) => inner.span(),
18938 Self::QualifiedIdentifier(inner) => inner.span(),
18939 Self::Template(span) => *span,
18940 Self::TemplateFunction(inner) => inner.span(),
18941 Self::TemplateMethod(inner) => inner.span(),
18942 Self::TemplateType(inner) => inner.span(),
18943 Self::TypeIdentifier(inner) => inner.span(),
18944 }
18945 }
18946}
18947#[derive(Debug, Clone, PartialEq, Eq)]
18948pub enum QualifiedIdentifierScope<'tree> {
18949 Decltype(::std::boxed::Box<Decltype<'tree>>),
18950 DependentName(::std::boxed::Box<DependentName<'tree>>),
18951 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
18952 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
18953}
18954impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifierScope<'tree> {
18955 #[allow(clippy::collapsible_else_if)]
18956 fn from_node(
18957 node: ::treesitter_types::tree_sitter::Node<'tree>,
18958 src: &'tree [u8],
18959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18960 match node.kind() {
18961 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
18962 ::treesitter_types::runtime::maybe_grow_stack(|| {
18963 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)
18964 })?,
18965 ))),
18966 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
18967 ::treesitter_types::runtime::maybe_grow_stack(|| {
18968 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)
18969 })?,
18970 ))),
18971 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
18972 ::treesitter_types::runtime::maybe_grow_stack(|| {
18973 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
18974 })?,
18975 ))),
18976 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
18977 ::treesitter_types::runtime::maybe_grow_stack(|| {
18978 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
18979 })?,
18980 ))),
18981 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18982 }
18983 }
18984}
18985impl ::treesitter_types::Spanned for QualifiedIdentifierScope<'_> {
18986 fn span(&self) -> ::treesitter_types::Span {
18987 match self {
18988 Self::Decltype(inner) => inner.span(),
18989 Self::DependentName(inner) => inner.span(),
18990 Self::NamespaceIdentifier(inner) => inner.span(),
18991 Self::TemplateType(inner) => inner.span(),
18992 }
18993 }
18994}
18995#[derive(Debug, Clone, PartialEq, Eq)]
18996pub enum RawStringLiteralChildren<'tree> {
18997 RawStringContent(::std::boxed::Box<RawStringContent<'tree>>),
18998 RawStringDelimiter(::std::boxed::Box<RawStringDelimiter<'tree>>),
18999}
19000impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralChildren<'tree> {
19001 #[allow(clippy::collapsible_else_if)]
19002 fn from_node(
19003 node: ::treesitter_types::tree_sitter::Node<'tree>,
19004 src: &'tree [u8],
19005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19006 match node.kind() {
19007 "raw_string_content" => Ok(Self::RawStringContent(::std::boxed::Box::new(
19008 ::treesitter_types::runtime::maybe_grow_stack(|| {
19009 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
19010 })?,
19011 ))),
19012 "raw_string_delimiter" => Ok(Self::RawStringDelimiter(::std::boxed::Box::new(
19013 ::treesitter_types::runtime::maybe_grow_stack(|| {
19014 <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(node, src)
19015 })?,
19016 ))),
19017 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19018 }
19019 }
19020}
19021impl ::treesitter_types::Spanned for RawStringLiteralChildren<'_> {
19022 fn span(&self) -> ::treesitter_types::Span {
19023 match self {
19024 Self::RawStringContent(inner) => inner.span(),
19025 Self::RawStringDelimiter(inner) => inner.span(),
19026 }
19027 }
19028}
19029#[derive(Debug, Clone, PartialEq, Eq)]
19030pub enum ReferenceDeclaratorChildren<'tree> {
19031 Declarator(::std::boxed::Box<Declarator<'tree>>),
19032 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
19033 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
19034 VariadicDeclarator(::std::boxed::Box<VariadicDeclarator<'tree>>),
19035}
19036impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceDeclaratorChildren<'tree> {
19037 #[allow(clippy::collapsible_else_if)]
19038 fn from_node(
19039 node: ::treesitter_types::tree_sitter::Node<'tree>,
19040 src: &'tree [u8],
19041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19042 match node.kind() {
19043 "variadic_declarator" => Ok(Self::VariadicDeclarator(::std::boxed::Box::new(
19044 ::treesitter_types::runtime::maybe_grow_stack(|| {
19045 <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19046 })?,
19047 ))),
19048 _other => {
19049 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19050 <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
19051 }) {
19052 Ok(Self::Declarator(::std::boxed::Box::new(v)))
19053 } else {
19054 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19055 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19056 }) {
19057 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
19058 } else {
19059 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19060 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19061 }) {
19062 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
19063 } else {
19064 Err(::treesitter_types::ParseError::unexpected_kind(
19065 _other, node,
19066 ))
19067 }
19068 }
19069 }
19070 }
19071 }
19072 }
19073}
19074impl ::treesitter_types::Spanned for ReferenceDeclaratorChildren<'_> {
19075 fn span(&self) -> ::treesitter_types::Span {
19076 match self {
19077 Self::Declarator(inner) => inner.span(),
19078 Self::FieldDeclarator(inner) => inner.span(),
19079 Self::TypeDeclarator(inner) => inner.span(),
19080 Self::VariadicDeclarator(inner) => inner.span(),
19081 }
19082 }
19083}
19084#[derive(Debug, Clone, PartialEq, Eq)]
19085pub enum RequirementSeqChildren<'tree> {
19086 CompoundRequirement(::std::boxed::Box<CompoundRequirement<'tree>>),
19087 SimpleRequirement(::std::boxed::Box<SimpleRequirement<'tree>>),
19088 TypeRequirement(::std::boxed::Box<TypeRequirement<'tree>>),
19089}
19090impl<'tree> ::treesitter_types::FromNode<'tree> for RequirementSeqChildren<'tree> {
19091 #[allow(clippy::collapsible_else_if)]
19092 fn from_node(
19093 node: ::treesitter_types::tree_sitter::Node<'tree>,
19094 src: &'tree [u8],
19095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19096 match node.kind() {
19097 "compound_requirement" => Ok(Self::CompoundRequirement(::std::boxed::Box::new(
19098 ::treesitter_types::runtime::maybe_grow_stack(|| {
19099 <CompoundRequirement as ::treesitter_types::FromNode>::from_node(node, src)
19100 })?,
19101 ))),
19102 "simple_requirement" => Ok(Self::SimpleRequirement(::std::boxed::Box::new(
19103 ::treesitter_types::runtime::maybe_grow_stack(|| {
19104 <SimpleRequirement as ::treesitter_types::FromNode>::from_node(node, src)
19105 })?,
19106 ))),
19107 "type_requirement" => Ok(Self::TypeRequirement(::std::boxed::Box::new(
19108 ::treesitter_types::runtime::maybe_grow_stack(|| {
19109 <TypeRequirement as ::treesitter_types::FromNode>::from_node(node, src)
19110 })?,
19111 ))),
19112 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19113 }
19114 }
19115}
19116impl ::treesitter_types::Spanned for RequirementSeqChildren<'_> {
19117 fn span(&self) -> ::treesitter_types::Span {
19118 match self {
19119 Self::CompoundRequirement(inner) => inner.span(),
19120 Self::SimpleRequirement(inner) => inner.span(),
19121 Self::TypeRequirement(inner) => inner.span(),
19122 }
19123 }
19124}
19125#[derive(Debug, Clone, PartialEq, Eq)]
19126pub enum RequiresClauseConstraint<'tree> {
19127 LParen(::treesitter_types::Span),
19128 RParen(::treesitter_types::Span),
19129 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
19130 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
19131 Expression(::std::boxed::Box<Expression<'tree>>),
19132 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
19133 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
19134}
19135impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresClauseConstraint<'tree> {
19136 #[allow(clippy::collapsible_else_if)]
19137 fn from_node(
19138 node: ::treesitter_types::tree_sitter::Node<'tree>,
19139 src: &'tree [u8],
19140 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19141 match node.kind() {
19142 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
19143 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
19144 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
19145 ::treesitter_types::runtime::maybe_grow_stack(|| {
19146 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
19147 })?,
19148 ))),
19149 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
19150 ::treesitter_types::runtime::maybe_grow_stack(|| {
19151 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
19152 })?,
19153 ))),
19154 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
19155 ::treesitter_types::runtime::maybe_grow_stack(|| {
19156 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
19157 })?,
19158 ))),
19159 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
19160 ::treesitter_types::runtime::maybe_grow_stack(|| {
19161 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19162 })?,
19163 ))),
19164 _other => {
19165 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19166 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19167 }) {
19168 Ok(Self::Expression(::std::boxed::Box::new(v)))
19169 } else {
19170 Err(::treesitter_types::ParseError::unexpected_kind(
19171 _other, node,
19172 ))
19173 }
19174 }
19175 }
19176 }
19177}
19178impl ::treesitter_types::Spanned for RequiresClauseConstraint<'_> {
19179 fn span(&self) -> ::treesitter_types::Span {
19180 match self {
19181 Self::LParen(span) => *span,
19182 Self::RParen(span) => *span,
19183 Self::ConstraintConjunction(inner) => inner.span(),
19184 Self::ConstraintDisjunction(inner) => inner.span(),
19185 Self::Expression(inner) => inner.span(),
19186 Self::TemplateType(inner) => inner.span(),
19187 Self::TypeIdentifier(inner) => inner.span(),
19188 }
19189 }
19190}
19191#[derive(Debug, Clone, PartialEq, Eq)]
19192pub enum ReturnStatementChildren<'tree> {
19193 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
19194 Expression(::std::boxed::Box<Expression<'tree>>),
19195 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
19196}
19197impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
19198 #[allow(clippy::collapsible_else_if)]
19199 fn from_node(
19200 node: ::treesitter_types::tree_sitter::Node<'tree>,
19201 src: &'tree [u8],
19202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19203 match node.kind() {
19204 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
19205 ::treesitter_types::runtime::maybe_grow_stack(|| {
19206 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
19207 })?,
19208 ))),
19209 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
19210 ::treesitter_types::runtime::maybe_grow_stack(|| {
19211 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
19212 })?,
19213 ))),
19214 _other => {
19215 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19216 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19217 }) {
19218 Ok(Self::Expression(::std::boxed::Box::new(v)))
19219 } else {
19220 Err(::treesitter_types::ParseError::unexpected_kind(
19221 _other, node,
19222 ))
19223 }
19224 }
19225 }
19226 }
19227}
19228impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
19229 fn span(&self) -> ::treesitter_types::Span {
19230 match self {
19231 Self::CommaExpression(inner) => inner.span(),
19232 Self::Expression(inner) => inner.span(),
19233 Self::InitializerList(inner) => inner.span(),
19234 }
19235 }
19236}
19237#[derive(Debug, Clone, PartialEq, Eq)]
19238pub enum SehTryStatementChildren<'tree> {
19239 SehExceptClause(::std::boxed::Box<SehExceptClause<'tree>>),
19240 SehFinallyClause(::std::boxed::Box<SehFinallyClause<'tree>>),
19241}
19242impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatementChildren<'tree> {
19243 #[allow(clippy::collapsible_else_if)]
19244 fn from_node(
19245 node: ::treesitter_types::tree_sitter::Node<'tree>,
19246 src: &'tree [u8],
19247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19248 match node.kind() {
19249 "seh_except_clause" => Ok(Self::SehExceptClause(::std::boxed::Box::new(
19250 ::treesitter_types::runtime::maybe_grow_stack(|| {
19251 <SehExceptClause as ::treesitter_types::FromNode>::from_node(node, src)
19252 })?,
19253 ))),
19254 "seh_finally_clause" => Ok(Self::SehFinallyClause(::std::boxed::Box::new(
19255 ::treesitter_types::runtime::maybe_grow_stack(|| {
19256 <SehFinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
19257 })?,
19258 ))),
19259 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19260 }
19261 }
19262}
19263impl ::treesitter_types::Spanned for SehTryStatementChildren<'_> {
19264 fn span(&self) -> ::treesitter_types::Span {
19265 match self {
19266 Self::SehExceptClause(inner) => inner.span(),
19267 Self::SehFinallyClause(inner) => inner.span(),
19268 }
19269 }
19270}
19271#[derive(Debug, Clone, PartialEq, Eq)]
19272pub enum SimpleRequirementChildren<'tree> {
19273 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
19274 Expression(::std::boxed::Box<Expression<'tree>>),
19275}
19276impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleRequirementChildren<'tree> {
19277 #[allow(clippy::collapsible_else_if)]
19278 fn from_node(
19279 node: ::treesitter_types::tree_sitter::Node<'tree>,
19280 src: &'tree [u8],
19281 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19282 match node.kind() {
19283 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
19284 ::treesitter_types::runtime::maybe_grow_stack(|| {
19285 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
19286 })?,
19287 ))),
19288 _other => {
19289 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19290 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19291 }) {
19292 Ok(Self::Expression(::std::boxed::Box::new(v)))
19293 } else {
19294 Err(::treesitter_types::ParseError::unexpected_kind(
19295 _other, node,
19296 ))
19297 }
19298 }
19299 }
19300 }
19301}
19302impl ::treesitter_types::Spanned for SimpleRequirementChildren<'_> {
19303 fn span(&self) -> ::treesitter_types::Span {
19304 match self {
19305 Self::CommaExpression(inner) => inner.span(),
19306 Self::Expression(inner) => inner.span(),
19307 }
19308 }
19309}
19310#[derive(Debug, Clone, PartialEq, Eq)]
19311pub enum SizedTypeSpecifierType<'tree> {
19312 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
19313 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
19314}
19315impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifierType<'tree> {
19316 #[allow(clippy::collapsible_else_if)]
19317 fn from_node(
19318 node: ::treesitter_types::tree_sitter::Node<'tree>,
19319 src: &'tree [u8],
19320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19321 match node.kind() {
19322 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
19323 ::treesitter_types::runtime::maybe_grow_stack(|| {
19324 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
19325 })?,
19326 ))),
19327 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
19328 ::treesitter_types::runtime::maybe_grow_stack(|| {
19329 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19330 })?,
19331 ))),
19332 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19333 }
19334 }
19335}
19336impl ::treesitter_types::Spanned for SizedTypeSpecifierType<'_> {
19337 fn span(&self) -> ::treesitter_types::Span {
19338 match self {
19339 Self::PrimitiveType(inner) => inner.span(),
19340 Self::TypeIdentifier(inner) => inner.span(),
19341 }
19342 }
19343}
19344#[derive(Debug, Clone, PartialEq, Eq)]
19345pub enum StaticAssertDeclarationMessage<'tree> {
19346 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
19347 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
19348 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
19349}
19350impl<'tree> ::treesitter_types::FromNode<'tree> for StaticAssertDeclarationMessage<'tree> {
19351 #[allow(clippy::collapsible_else_if)]
19352 fn from_node(
19353 node: ::treesitter_types::tree_sitter::Node<'tree>,
19354 src: &'tree [u8],
19355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19356 match node.kind() {
19357 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
19358 ::treesitter_types::runtime::maybe_grow_stack(|| {
19359 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
19360 })?,
19361 ))),
19362 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
19363 ::treesitter_types::runtime::maybe_grow_stack(|| {
19364 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19365 })?,
19366 ))),
19367 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
19368 ::treesitter_types::runtime::maybe_grow_stack(|| {
19369 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19370 })?,
19371 ))),
19372 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19373 }
19374 }
19375}
19376impl ::treesitter_types::Spanned for StaticAssertDeclarationMessage<'_> {
19377 fn span(&self) -> ::treesitter_types::Span {
19378 match self {
19379 Self::ConcatenatedString(inner) => inner.span(),
19380 Self::RawStringLiteral(inner) => inner.span(),
19381 Self::StringLiteral(inner) => inner.span(),
19382 }
19383 }
19384}
19385#[derive(Debug, Clone, PartialEq, Eq)]
19386pub enum StringLiteralChildren<'tree> {
19387 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
19388 StringContent(::std::boxed::Box<StringContent<'tree>>),
19389}
19390impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
19391 #[allow(clippy::collapsible_else_if)]
19392 fn from_node(
19393 node: ::treesitter_types::tree_sitter::Node<'tree>,
19394 src: &'tree [u8],
19395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19396 match node.kind() {
19397 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
19398 ::treesitter_types::runtime::maybe_grow_stack(|| {
19399 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
19400 })?,
19401 ))),
19402 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
19403 ::treesitter_types::runtime::maybe_grow_stack(|| {
19404 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
19405 })?,
19406 ))),
19407 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19408 }
19409 }
19410}
19411impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
19412 fn span(&self) -> ::treesitter_types::Span {
19413 match self {
19414 Self::EscapeSequence(inner) => inner.span(),
19415 Self::StringContent(inner) => inner.span(),
19416 }
19417 }
19418}
19419#[derive(Debug, Clone, PartialEq, Eq)]
19420pub enum StructSpecifierName<'tree> {
19421 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
19422 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
19423 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
19424}
19425impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifierName<'tree> {
19426 #[allow(clippy::collapsible_else_if)]
19427 fn from_node(
19428 node: ::treesitter_types::tree_sitter::Node<'tree>,
19429 src: &'tree [u8],
19430 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19431 match node.kind() {
19432 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
19433 ::treesitter_types::runtime::maybe_grow_stack(|| {
19434 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19435 })?,
19436 ))),
19437 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
19438 ::treesitter_types::runtime::maybe_grow_stack(|| {
19439 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
19440 })?,
19441 ))),
19442 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
19443 ::treesitter_types::runtime::maybe_grow_stack(|| {
19444 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19445 })?,
19446 ))),
19447 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19448 }
19449 }
19450}
19451impl ::treesitter_types::Spanned for StructSpecifierName<'_> {
19452 fn span(&self) -> ::treesitter_types::Span {
19453 match self {
19454 Self::QualifiedIdentifier(inner) => inner.span(),
19455 Self::TemplateType(inner) => inner.span(),
19456 Self::TypeIdentifier(inner) => inner.span(),
19457 }
19458 }
19459}
19460#[derive(Debug, Clone, PartialEq, Eq)]
19461pub enum StructSpecifierChildren<'tree> {
19462 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
19463 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
19464 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
19465 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
19466 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
19467 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
19468}
19469impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifierChildren<'tree> {
19470 #[allow(clippy::collapsible_else_if)]
19471 fn from_node(
19472 node: ::treesitter_types::tree_sitter::Node<'tree>,
19473 src: &'tree [u8],
19474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19475 match node.kind() {
19476 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
19477 ::treesitter_types::runtime::maybe_grow_stack(|| {
19478 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)
19479 })?,
19480 ))),
19481 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
19482 ::treesitter_types::runtime::maybe_grow_stack(|| {
19483 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19484 })?,
19485 ))),
19486 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
19487 ::treesitter_types::runtime::maybe_grow_stack(|| {
19488 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19489 })?,
19490 ))),
19491 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
19492 ::treesitter_types::runtime::maybe_grow_stack(|| {
19493 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)
19494 })?,
19495 ))),
19496 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
19497 ::treesitter_types::runtime::maybe_grow_stack(|| {
19498 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
19499 })?,
19500 ))),
19501 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
19502 ::treesitter_types::runtime::maybe_grow_stack(|| {
19503 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19504 })?,
19505 ))),
19506 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19507 }
19508 }
19509}
19510impl ::treesitter_types::Spanned for StructSpecifierChildren<'_> {
19511 fn span(&self) -> ::treesitter_types::Span {
19512 match self {
19513 Self::AlignasQualifier(inner) => inner.span(),
19514 Self::AttributeDeclaration(inner) => inner.span(),
19515 Self::AttributeSpecifier(inner) => inner.span(),
19516 Self::BaseClassClause(inner) => inner.span(),
19517 Self::MsDeclspecModifier(inner) => inner.span(),
19518 Self::VirtualSpecifier(inner) => inner.span(),
19519 }
19520 }
19521}
19522#[derive(Debug, Clone, PartialEq, Eq)]
19523pub enum SubscriptArgumentListChildren<'tree> {
19524 Expression(::std::boxed::Box<Expression<'tree>>),
19525 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
19526}
19527impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptArgumentListChildren<'tree> {
19528 #[allow(clippy::collapsible_else_if)]
19529 fn from_node(
19530 node: ::treesitter_types::tree_sitter::Node<'tree>,
19531 src: &'tree [u8],
19532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19533 match node.kind() {
19534 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
19535 ::treesitter_types::runtime::maybe_grow_stack(|| {
19536 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
19537 })?,
19538 ))),
19539 _other => {
19540 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19541 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19542 }) {
19543 Ok(Self::Expression(::std::boxed::Box::new(v)))
19544 } else {
19545 Err(::treesitter_types::ParseError::unexpected_kind(
19546 _other, node,
19547 ))
19548 }
19549 }
19550 }
19551 }
19552}
19553impl ::treesitter_types::Spanned for SubscriptArgumentListChildren<'_> {
19554 fn span(&self) -> ::treesitter_types::Span {
19555 match self {
19556 Self::Expression(inner) => inner.span(),
19557 Self::InitializerList(inner) => inner.span(),
19558 }
19559 }
19560}
19561#[derive(Debug, Clone, PartialEq, Eq)]
19562pub enum TemplateArgumentListChildren<'tree> {
19563 Expression(::std::boxed::Box<Expression<'tree>>),
19564 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
19565}
19566impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateArgumentListChildren<'tree> {
19567 #[allow(clippy::collapsible_else_if)]
19568 fn from_node(
19569 node: ::treesitter_types::tree_sitter::Node<'tree>,
19570 src: &'tree [u8],
19571 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19572 match node.kind() {
19573 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
19574 ::treesitter_types::runtime::maybe_grow_stack(|| {
19575 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
19576 })?,
19577 ))),
19578 _other => {
19579 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19580 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19581 }) {
19582 Ok(Self::Expression(::std::boxed::Box::new(v)))
19583 } else {
19584 Err(::treesitter_types::ParseError::unexpected_kind(
19585 _other, node,
19586 ))
19587 }
19588 }
19589 }
19590 }
19591}
19592impl ::treesitter_types::Spanned for TemplateArgumentListChildren<'_> {
19593 fn span(&self) -> ::treesitter_types::Span {
19594 match self {
19595 Self::Expression(inner) => inner.span(),
19596 Self::TypeDescriptor(inner) => inner.span(),
19597 }
19598 }
19599}
19600#[derive(Debug, Clone, PartialEq, Eq)]
19601pub enum TemplateDeclarationChildren<'tree> {
19602 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
19603 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
19604 Declaration(::std::boxed::Box<Declaration<'tree>>),
19605 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
19606 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
19607 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
19608 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
19609 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
19610}
19611impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateDeclarationChildren<'tree> {
19612 #[allow(clippy::collapsible_else_if)]
19613 fn from_node(
19614 node: ::treesitter_types::tree_sitter::Node<'tree>,
19615 src: &'tree [u8],
19616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19617 match node.kind() {
19618 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
19619 ::treesitter_types::runtime::maybe_grow_stack(|| {
19620 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19621 })?,
19622 ))),
19623 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
19624 ::treesitter_types::runtime::maybe_grow_stack(|| {
19625 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19626 })?,
19627 ))),
19628 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
19629 ::treesitter_types::runtime::maybe_grow_stack(|| {
19630 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
19631 })?,
19632 ))),
19633 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
19634 ::treesitter_types::runtime::maybe_grow_stack(|| {
19635 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19636 })?,
19637 ))),
19638 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
19639 ::treesitter_types::runtime::maybe_grow_stack(|| {
19640 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19641 })?,
19642 ))),
19643 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
19644 ::treesitter_types::runtime::maybe_grow_stack(|| {
19645 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)
19646 })?,
19647 ))),
19648 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
19649 ::treesitter_types::runtime::maybe_grow_stack(|| {
19650 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19651 })?,
19652 ))),
19653 _other => {
19654 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
19655 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19656 }) {
19657 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
19658 } else {
19659 Err(::treesitter_types::ParseError::unexpected_kind(
19660 _other, node,
19661 ))
19662 }
19663 }
19664 }
19665 }
19666}
19667impl ::treesitter_types::Spanned for TemplateDeclarationChildren<'_> {
19668 fn span(&self) -> ::treesitter_types::Span {
19669 match self {
19670 Self::AliasDeclaration(inner) => inner.span(),
19671 Self::ConceptDefinition(inner) => inner.span(),
19672 Self::Declaration(inner) => inner.span(),
19673 Self::FriendDeclaration(inner) => inner.span(),
19674 Self::FunctionDefinition(inner) => inner.span(),
19675 Self::RequiresClause(inner) => inner.span(),
19676 Self::TemplateDeclaration(inner) => inner.span(),
19677 Self::TypeSpecifier(inner) => inner.span(),
19678 }
19679 }
19680}
19681#[derive(Debug, Clone, PartialEq, Eq)]
19682pub enum TemplateInstantiationChildren<'tree> {
19683 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
19684 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
19685 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
19686 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
19687 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
19688}
19689impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateInstantiationChildren<'tree> {
19690 #[allow(clippy::collapsible_else_if)]
19691 fn from_node(
19692 node: ::treesitter_types::tree_sitter::Node<'tree>,
19693 src: &'tree [u8],
19694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19695 match node.kind() {
19696 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
19697 ::treesitter_types::runtime::maybe_grow_stack(|| {
19698 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19699 })?,
19700 ))),
19701 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
19702 ::treesitter_types::runtime::maybe_grow_stack(|| {
19703 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19704 })?,
19705 ))),
19706 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
19707 ::treesitter_types::runtime::maybe_grow_stack(|| {
19708 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
19709 })?,
19710 ))),
19711 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
19712 ::treesitter_types::runtime::maybe_grow_stack(|| {
19713 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19714 })?,
19715 ))),
19716 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
19717 ::treesitter_types::runtime::maybe_grow_stack(|| {
19718 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
19719 })?,
19720 ))),
19721 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19722 }
19723 }
19724}
19725impl ::treesitter_types::Spanned for TemplateInstantiationChildren<'_> {
19726 fn span(&self) -> ::treesitter_types::Span {
19727 match self {
19728 Self::AttributeDeclaration(inner) => inner.span(),
19729 Self::AttributeSpecifier(inner) => inner.span(),
19730 Self::MsDeclspecModifier(inner) => inner.span(),
19731 Self::StorageClassSpecifier(inner) => inner.span(),
19732 Self::TypeQualifier(inner) => inner.span(),
19733 }
19734 }
19735}
19736#[derive(Debug, Clone, PartialEq, Eq)]
19737pub enum TemplateMethodName<'tree> {
19738 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
19739 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
19740}
19741impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateMethodName<'tree> {
19742 #[allow(clippy::collapsible_else_if)]
19743 fn from_node(
19744 node: ::treesitter_types::tree_sitter::Node<'tree>,
19745 src: &'tree [u8],
19746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19747 match node.kind() {
19748 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
19749 ::treesitter_types::runtime::maybe_grow_stack(|| {
19750 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19751 })?,
19752 ))),
19753 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
19754 ::treesitter_types::runtime::maybe_grow_stack(|| {
19755 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)
19756 })?,
19757 ))),
19758 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19759 }
19760 }
19761}
19762impl ::treesitter_types::Spanned for TemplateMethodName<'_> {
19763 fn span(&self) -> ::treesitter_types::Span {
19764 match self {
19765 Self::FieldIdentifier(inner) => inner.span(),
19766 Self::OperatorName(inner) => inner.span(),
19767 }
19768 }
19769}
19770#[derive(Debug, Clone, PartialEq, Eq)]
19771pub enum TemplateParameterListChildren<'tree> {
19772 OptionalParameterDeclaration(::std::boxed::Box<OptionalParameterDeclaration<'tree>>),
19773 OptionalTypeParameterDeclaration(::std::boxed::Box<OptionalTypeParameterDeclaration<'tree>>),
19774 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
19775 TemplateTemplateParameterDeclaration(
19776 ::std::boxed::Box<TemplateTemplateParameterDeclaration<'tree>>,
19777 ),
19778 TypeParameterDeclaration(::std::boxed::Box<TypeParameterDeclaration<'tree>>),
19779 VariadicParameterDeclaration(::std::boxed::Box<VariadicParameterDeclaration<'tree>>),
19780 VariadicTypeParameterDeclaration(::std::boxed::Box<VariadicTypeParameterDeclaration<'tree>>),
19781}
19782impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateParameterListChildren<'tree> {
19783 #[allow(clippy::collapsible_else_if)]
19784 fn from_node(
19785 node: ::treesitter_types::tree_sitter::Node<'tree>,
19786 src: &'tree [u8],
19787 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19788 match node.kind() {
19789 "optional_parameter_declaration" => Ok(Self::OptionalParameterDeclaration(
19790 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19791 <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19792 node, src,
19793 )
19794 })?),
19795 )),
19796 "optional_type_parameter_declaration" => Ok(Self::OptionalTypeParameterDeclaration(
19797 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19798 <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19799 node, src,
19800 )
19801 })?),
19802 )),
19803 "parameter_declaration" => Ok(Self::ParameterDeclaration(::std::boxed::Box::new(
19804 ::treesitter_types::runtime::maybe_grow_stack(|| {
19805 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19806 })?,
19807 ))),
19808 "template_template_parameter_declaration" => {
19809 Ok(Self::TemplateTemplateParameterDeclaration(
19810 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19811 <TemplateTemplateParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19812 node,
19813 src,
19814 )
19815 })?),
19816 ))
19817 }
19818 "type_parameter_declaration" => Ok(Self::TypeParameterDeclaration(
19819 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19820 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19821 })?),
19822 )),
19823 "variadic_parameter_declaration" => Ok(Self::VariadicParameterDeclaration(
19824 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19825 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19826 node, src,
19827 )
19828 })?),
19829 )),
19830 "variadic_type_parameter_declaration" => Ok(Self::VariadicTypeParameterDeclaration(
19831 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19832 <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19833 node, src,
19834 )
19835 })?),
19836 )),
19837 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19838 }
19839 }
19840}
19841impl ::treesitter_types::Spanned for TemplateParameterListChildren<'_> {
19842 fn span(&self) -> ::treesitter_types::Span {
19843 match self {
19844 Self::OptionalParameterDeclaration(inner) => inner.span(),
19845 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
19846 Self::ParameterDeclaration(inner) => inner.span(),
19847 Self::TemplateTemplateParameterDeclaration(inner) => inner.span(),
19848 Self::TypeParameterDeclaration(inner) => inner.span(),
19849 Self::VariadicParameterDeclaration(inner) => inner.span(),
19850 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
19851 }
19852 }
19853}
19854#[derive(Debug, Clone, PartialEq, Eq)]
19855pub enum TemplateTemplateParameterDeclarationChildren<'tree> {
19856 OptionalTypeParameterDeclaration(::std::boxed::Box<OptionalTypeParameterDeclaration<'tree>>),
19857 TypeParameterDeclaration(::std::boxed::Box<TypeParameterDeclaration<'tree>>),
19858 VariadicTypeParameterDeclaration(::std::boxed::Box<VariadicTypeParameterDeclaration<'tree>>),
19859}
19860impl<'tree> ::treesitter_types::FromNode<'tree>
19861 for TemplateTemplateParameterDeclarationChildren<'tree>
19862{
19863 #[allow(clippy::collapsible_else_if)]
19864 fn from_node(
19865 node: ::treesitter_types::tree_sitter::Node<'tree>,
19866 src: &'tree [u8],
19867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19868 match node.kind() {
19869 "optional_type_parameter_declaration" => Ok(Self::OptionalTypeParameterDeclaration(
19870 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19871 <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19872 node, src,
19873 )
19874 })?),
19875 )),
19876 "type_parameter_declaration" => Ok(Self::TypeParameterDeclaration(
19877 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19878 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19879 })?),
19880 )),
19881 "variadic_type_parameter_declaration" => Ok(Self::VariadicTypeParameterDeclaration(
19882 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
19883 <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19884 node, src,
19885 )
19886 })?),
19887 )),
19888 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19889 }
19890 }
19891}
19892impl ::treesitter_types::Spanned for TemplateTemplateParameterDeclarationChildren<'_> {
19893 fn span(&self) -> ::treesitter_types::Span {
19894 match self {
19895 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
19896 Self::TypeParameterDeclaration(inner) => inner.span(),
19897 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
19898 }
19899 }
19900}
19901#[derive(Debug, Clone, PartialEq, Eq)]
19902pub enum TranslationUnitChildren<'tree> {
19903 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
19904 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
19905 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
19906 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
19907 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
19908 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
19909 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
19910 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
19911 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
19912 Declaration(::std::boxed::Box<Declaration<'tree>>),
19913 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
19914 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
19915 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
19916 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
19917 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
19918 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
19919 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
19920 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
19921 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
19922 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
19923 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
19924 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
19925 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
19926 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
19927 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
19928 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
19929 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
19930 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
19931 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
19932 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
19933 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
19934 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
19935 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
19936 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
19937 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
19938 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
19939 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
19940 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
19941}
19942impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnitChildren<'tree> {
19943 #[allow(clippy::collapsible_else_if)]
19944 fn from_node(
19945 node: ::treesitter_types::tree_sitter::Node<'tree>,
19946 src: &'tree [u8],
19947 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19948 match node.kind() {
19949 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
19950 ::treesitter_types::runtime::maybe_grow_stack(|| {
19951 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19952 })?,
19953 ))),
19954 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
19955 ::treesitter_types::runtime::maybe_grow_stack(|| {
19956 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
19957 })?,
19958 ))),
19959 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
19960 ::treesitter_types::runtime::maybe_grow_stack(|| {
19961 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
19962 })?,
19963 ))),
19964 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
19965 ::treesitter_types::runtime::maybe_grow_stack(|| {
19966 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
19967 })?,
19968 ))),
19969 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
19970 ::treesitter_types::runtime::maybe_grow_stack(|| {
19971 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
19972 })?,
19973 ))),
19974 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
19975 ::treesitter_types::runtime::maybe_grow_stack(|| {
19976 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
19977 })?,
19978 ))),
19979 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
19980 ::treesitter_types::runtime::maybe_grow_stack(|| {
19981 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
19982 })?,
19983 ))),
19984 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
19985 ::treesitter_types::runtime::maybe_grow_stack(|| {
19986 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19987 })?,
19988 ))),
19989 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
19990 ::treesitter_types::runtime::maybe_grow_stack(|| {
19991 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
19992 })?,
19993 ))),
19994 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
19995 ::treesitter_types::runtime::maybe_grow_stack(|| {
19996 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
19997 })?,
19998 ))),
19999 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
20000 ::treesitter_types::runtime::maybe_grow_stack(|| {
20001 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
20002 })?,
20003 ))),
20004 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
20005 ::treesitter_types::runtime::maybe_grow_stack(|| {
20006 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
20007 })?,
20008 ))),
20009 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
20010 ::treesitter_types::runtime::maybe_grow_stack(|| {
20011 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)
20012 })?,
20013 ))),
20014 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
20015 ::treesitter_types::runtime::maybe_grow_stack(|| {
20016 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
20017 })?,
20018 ))),
20019 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
20020 ::treesitter_types::runtime::maybe_grow_stack(|| {
20021 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
20022 })?,
20023 ))),
20024 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
20025 ::treesitter_types::runtime::maybe_grow_stack(|| {
20026 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
20027 })?,
20028 ))),
20029 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
20030 ::treesitter_types::runtime::maybe_grow_stack(|| {
20031 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
20032 })?,
20033 ))),
20034 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
20035 ::treesitter_types::runtime::maybe_grow_stack(|| {
20036 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
20037 })?,
20038 ))),
20039 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
20040 ::treesitter_types::runtime::maybe_grow_stack(|| {
20041 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
20042 })?,
20043 ))),
20044 "namespace_alias_definition" => Ok(Self::NamespaceAliasDefinition(
20045 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20046 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
20047 })?),
20048 )),
20049 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
20050 ::treesitter_types::runtime::maybe_grow_stack(|| {
20051 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
20052 })?,
20053 ))),
20054 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
20055 ::treesitter_types::runtime::maybe_grow_stack(|| {
20056 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
20057 })?,
20058 ))),
20059 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
20060 ::treesitter_types::runtime::maybe_grow_stack(|| {
20061 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
20062 })?,
20063 ))),
20064 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
20065 ::treesitter_types::runtime::maybe_grow_stack(|| {
20066 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
20067 })?,
20068 ))),
20069 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
20070 ::treesitter_types::runtime::maybe_grow_stack(|| {
20071 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
20072 })?,
20073 ))),
20074 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
20075 ::treesitter_types::runtime::maybe_grow_stack(|| {
20076 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
20077 })?,
20078 ))),
20079 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
20080 ::treesitter_types::runtime::maybe_grow_stack(|| {
20081 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
20082 })?,
20083 ))),
20084 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
20085 ::treesitter_types::runtime::maybe_grow_stack(|| {
20086 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
20087 })?,
20088 ))),
20089 "static_assert_declaration" => Ok(Self::StaticAssertDeclaration(
20090 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
20091 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20092 })?),
20093 )),
20094 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
20095 ::treesitter_types::runtime::maybe_grow_stack(|| {
20096 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
20097 })?,
20098 ))),
20099 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
20100 ::treesitter_types::runtime::maybe_grow_stack(|| {
20101 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20102 })?,
20103 ))),
20104 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
20105 ::treesitter_types::runtime::maybe_grow_stack(|| {
20106 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
20107 })?,
20108 ))),
20109 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
20110 ::treesitter_types::runtime::maybe_grow_stack(|| {
20111 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
20112 })?,
20113 ))),
20114 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
20115 ::treesitter_types::runtime::maybe_grow_stack(|| {
20116 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
20117 })?,
20118 ))),
20119 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
20120 ::treesitter_types::runtime::maybe_grow_stack(|| {
20121 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
20122 })?,
20123 ))),
20124 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
20125 ::treesitter_types::runtime::maybe_grow_stack(|| {
20126 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20127 })?,
20128 ))),
20129 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
20130 ::treesitter_types::runtime::maybe_grow_stack(|| {
20131 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
20132 })?,
20133 ))),
20134 _other => {
20135 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20136 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20137 }) {
20138 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
20139 } else {
20140 Err(::treesitter_types::ParseError::unexpected_kind(
20141 _other, node,
20142 ))
20143 }
20144 }
20145 }
20146 }
20147}
20148impl ::treesitter_types::Spanned for TranslationUnitChildren<'_> {
20149 fn span(&self) -> ::treesitter_types::Span {
20150 match self {
20151 Self::AliasDeclaration(inner) => inner.span(),
20152 Self::AttributedStatement(inner) => inner.span(),
20153 Self::BreakStatement(inner) => inner.span(),
20154 Self::CaseStatement(inner) => inner.span(),
20155 Self::CoReturnStatement(inner) => inner.span(),
20156 Self::CoYieldStatement(inner) => inner.span(),
20157 Self::CompoundStatement(inner) => inner.span(),
20158 Self::ConceptDefinition(inner) => inner.span(),
20159 Self::ContinueStatement(inner) => inner.span(),
20160 Self::Declaration(inner) => inner.span(),
20161 Self::DoStatement(inner) => inner.span(),
20162 Self::ExpressionStatement(inner) => inner.span(),
20163 Self::ForRangeLoop(inner) => inner.span(),
20164 Self::ForStatement(inner) => inner.span(),
20165 Self::FunctionDefinition(inner) => inner.span(),
20166 Self::GotoStatement(inner) => inner.span(),
20167 Self::IfStatement(inner) => inner.span(),
20168 Self::LabeledStatement(inner) => inner.span(),
20169 Self::LinkageSpecification(inner) => inner.span(),
20170 Self::NamespaceAliasDefinition(inner) => inner.span(),
20171 Self::NamespaceDefinition(inner) => inner.span(),
20172 Self::PreprocCall(inner) => inner.span(),
20173 Self::PreprocDef(inner) => inner.span(),
20174 Self::PreprocFunctionDef(inner) => inner.span(),
20175 Self::PreprocIf(inner) => inner.span(),
20176 Self::PreprocIfdef(inner) => inner.span(),
20177 Self::PreprocInclude(inner) => inner.span(),
20178 Self::ReturnStatement(inner) => inner.span(),
20179 Self::StaticAssertDeclaration(inner) => inner.span(),
20180 Self::SwitchStatement(inner) => inner.span(),
20181 Self::TemplateDeclaration(inner) => inner.span(),
20182 Self::TemplateInstantiation(inner) => inner.span(),
20183 Self::ThrowStatement(inner) => inner.span(),
20184 Self::TryStatement(inner) => inner.span(),
20185 Self::TypeDefinition(inner) => inner.span(),
20186 Self::TypeSpecifier(inner) => inner.span(),
20187 Self::UsingDeclaration(inner) => inner.span(),
20188 Self::WhileStatement(inner) => inner.span(),
20189 }
20190 }
20191}
20192#[derive(Debug, Clone, PartialEq, Eq)]
20193pub enum TryStatementChildren<'tree> {
20194 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
20195 FieldInitializerList(::std::boxed::Box<FieldInitializerList<'tree>>),
20196}
20197impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
20198 #[allow(clippy::collapsible_else_if)]
20199 fn from_node(
20200 node: ::treesitter_types::tree_sitter::Node<'tree>,
20201 src: &'tree [u8],
20202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20203 match node.kind() {
20204 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
20205 ::treesitter_types::runtime::maybe_grow_stack(|| {
20206 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
20207 })?,
20208 ))),
20209 "field_initializer_list" => Ok(Self::FieldInitializerList(::std::boxed::Box::new(
20210 ::treesitter_types::runtime::maybe_grow_stack(|| {
20211 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
20212 })?,
20213 ))),
20214 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20215 }
20216 }
20217}
20218impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
20219 fn span(&self) -> ::treesitter_types::Span {
20220 match self {
20221 Self::CatchClause(inner) => inner.span(),
20222 Self::FieldInitializerList(inner) => inner.span(),
20223 }
20224 }
20225}
20226#[derive(Debug, Clone, PartialEq, Eq)]
20227pub enum TypeDefinitionChildren<'tree> {
20228 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
20229 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
20230}
20231impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinitionChildren<'tree> {
20232 #[allow(clippy::collapsible_else_if)]
20233 fn from_node(
20234 node: ::treesitter_types::tree_sitter::Node<'tree>,
20235 src: &'tree [u8],
20236 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20237 match node.kind() {
20238 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
20239 ::treesitter_types::runtime::maybe_grow_stack(|| {
20240 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20241 })?,
20242 ))),
20243 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
20244 ::treesitter_types::runtime::maybe_grow_stack(|| {
20245 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
20246 })?,
20247 ))),
20248 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20249 }
20250 }
20251}
20252impl ::treesitter_types::Spanned for TypeDefinitionChildren<'_> {
20253 fn span(&self) -> ::treesitter_types::Span {
20254 match self {
20255 Self::AttributeSpecifier(inner) => inner.span(),
20256 Self::TypeQualifier(inner) => inner.span(),
20257 }
20258 }
20259}
20260#[derive(Debug, Clone, PartialEq, Eq)]
20261pub enum TypeRequirementChildren<'tree> {
20262 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
20263 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
20264 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
20265}
20266impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRequirementChildren<'tree> {
20267 #[allow(clippy::collapsible_else_if)]
20268 fn from_node(
20269 node: ::treesitter_types::tree_sitter::Node<'tree>,
20270 src: &'tree [u8],
20271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20272 match node.kind() {
20273 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
20274 ::treesitter_types::runtime::maybe_grow_stack(|| {
20275 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20276 })?,
20277 ))),
20278 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
20279 ::treesitter_types::runtime::maybe_grow_stack(|| {
20280 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
20281 })?,
20282 ))),
20283 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
20284 ::treesitter_types::runtime::maybe_grow_stack(|| {
20285 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20286 })?,
20287 ))),
20288 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20289 }
20290 }
20291}
20292impl ::treesitter_types::Spanned for TypeRequirementChildren<'_> {
20293 fn span(&self) -> ::treesitter_types::Span {
20294 match self {
20295 Self::QualifiedIdentifier(inner) => inner.span(),
20296 Self::TemplateType(inner) => inner.span(),
20297 Self::TypeIdentifier(inner) => inner.span(),
20298 }
20299 }
20300}
20301#[derive(Debug, Clone, PartialEq, Eq)]
20302pub enum UnaryExpressionArgument<'tree> {
20303 Expression(::std::boxed::Box<Expression<'tree>>),
20304 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
20305}
20306impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
20307 #[allow(clippy::collapsible_else_if)]
20308 fn from_node(
20309 node: ::treesitter_types::tree_sitter::Node<'tree>,
20310 src: &'tree [u8],
20311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20312 match node.kind() {
20313 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
20314 ::treesitter_types::runtime::maybe_grow_stack(|| {
20315 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
20316 })?,
20317 ))),
20318 _other => {
20319 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
20320 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
20321 }) {
20322 Ok(Self::Expression(::std::boxed::Box::new(v)))
20323 } else {
20324 Err(::treesitter_types::ParseError::unexpected_kind(
20325 _other, node,
20326 ))
20327 }
20328 }
20329 }
20330 }
20331}
20332impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
20333 fn span(&self) -> ::treesitter_types::Span {
20334 match self {
20335 Self::Expression(inner) => inner.span(),
20336 Self::PreprocDefined(inner) => inner.span(),
20337 }
20338 }
20339}
20340#[derive(Debug, Clone, PartialEq, Eq)]
20341pub enum UnaryExpressionOperator {
20342 Bang(::treesitter_types::Span),
20343 Plus(::treesitter_types::Span),
20344 Minus(::treesitter_types::Span),
20345 Compl(::treesitter_types::Span),
20346 Not(::treesitter_types::Span),
20347 Tilde(::treesitter_types::Span),
20348}
20349impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
20350 #[allow(clippy::collapsible_else_if)]
20351 fn from_node(
20352 node: ::treesitter_types::tree_sitter::Node<'tree>,
20353 _src: &'tree [u8],
20354 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20355 match node.kind() {
20356 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
20357 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
20358 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
20359 "compl" => Ok(Self::Compl(::treesitter_types::Span::from(node))),
20360 "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
20361 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
20362 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20363 }
20364 }
20365}
20366impl ::treesitter_types::Spanned for UnaryExpressionOperator {
20367 fn span(&self) -> ::treesitter_types::Span {
20368 match self {
20369 Self::Bang(span) => *span,
20370 Self::Plus(span) => *span,
20371 Self::Minus(span) => *span,
20372 Self::Compl(span) => *span,
20373 Self::Not(span) => *span,
20374 Self::Tilde(span) => *span,
20375 }
20376 }
20377}
20378#[derive(Debug, Clone, PartialEq, Eq)]
20379pub enum UnionSpecifierName<'tree> {
20380 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
20381 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
20382 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
20383}
20384impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifierName<'tree> {
20385 #[allow(clippy::collapsible_else_if)]
20386 fn from_node(
20387 node: ::treesitter_types::tree_sitter::Node<'tree>,
20388 src: &'tree [u8],
20389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20390 match node.kind() {
20391 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
20392 ::treesitter_types::runtime::maybe_grow_stack(|| {
20393 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20394 })?,
20395 ))),
20396 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
20397 ::treesitter_types::runtime::maybe_grow_stack(|| {
20398 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
20399 })?,
20400 ))),
20401 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
20402 ::treesitter_types::runtime::maybe_grow_stack(|| {
20403 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20404 })?,
20405 ))),
20406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20407 }
20408 }
20409}
20410impl ::treesitter_types::Spanned for UnionSpecifierName<'_> {
20411 fn span(&self) -> ::treesitter_types::Span {
20412 match self {
20413 Self::QualifiedIdentifier(inner) => inner.span(),
20414 Self::TemplateType(inner) => inner.span(),
20415 Self::TypeIdentifier(inner) => inner.span(),
20416 }
20417 }
20418}
20419#[derive(Debug, Clone, PartialEq, Eq)]
20420pub enum UnionSpecifierChildren<'tree> {
20421 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
20422 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
20423 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
20424 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
20425 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
20426 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
20427}
20428impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifierChildren<'tree> {
20429 #[allow(clippy::collapsible_else_if)]
20430 fn from_node(
20431 node: ::treesitter_types::tree_sitter::Node<'tree>,
20432 src: &'tree [u8],
20433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20434 match node.kind() {
20435 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
20436 ::treesitter_types::runtime::maybe_grow_stack(|| {
20437 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)
20438 })?,
20439 ))),
20440 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
20441 ::treesitter_types::runtime::maybe_grow_stack(|| {
20442 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20443 })?,
20444 ))),
20445 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
20446 ::treesitter_types::runtime::maybe_grow_stack(|| {
20447 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20448 })?,
20449 ))),
20450 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
20451 ::treesitter_types::runtime::maybe_grow_stack(|| {
20452 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)
20453 })?,
20454 ))),
20455 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
20456 ::treesitter_types::runtime::maybe_grow_stack(|| {
20457 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
20458 })?,
20459 ))),
20460 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
20461 ::treesitter_types::runtime::maybe_grow_stack(|| {
20462 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20463 })?,
20464 ))),
20465 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20466 }
20467 }
20468}
20469impl ::treesitter_types::Spanned for UnionSpecifierChildren<'_> {
20470 fn span(&self) -> ::treesitter_types::Span {
20471 match self {
20472 Self::AlignasQualifier(inner) => inner.span(),
20473 Self::AttributeDeclaration(inner) => inner.span(),
20474 Self::AttributeSpecifier(inner) => inner.span(),
20475 Self::BaseClassClause(inner) => inner.span(),
20476 Self::MsDeclspecModifier(inner) => inner.span(),
20477 Self::VirtualSpecifier(inner) => inner.span(),
20478 }
20479 }
20480}
20481#[derive(Debug, Clone, PartialEq, Eq)]
20482pub enum UpdateExpressionOperator {
20483 PlusPlus(::treesitter_types::Span),
20484 MinusMinus(::treesitter_types::Span),
20485}
20486impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
20487 #[allow(clippy::collapsible_else_if)]
20488 fn from_node(
20489 node: ::treesitter_types::tree_sitter::Node<'tree>,
20490 _src: &'tree [u8],
20491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20492 match node.kind() {
20493 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
20494 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
20495 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20496 }
20497 }
20498}
20499impl ::treesitter_types::Spanned for UpdateExpressionOperator {
20500 fn span(&self) -> ::treesitter_types::Span {
20501 match self {
20502 Self::PlusPlus(span) => *span,
20503 Self::MinusMinus(span) => *span,
20504 }
20505 }
20506}
20507#[derive(Debug, Clone, PartialEq, Eq)]
20508pub enum UserDefinedLiteralChildren<'tree> {
20509 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
20510 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
20511 LiteralSuffix(::std::boxed::Box<LiteralSuffix<'tree>>),
20512 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
20513 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
20514 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
20515}
20516impl<'tree> ::treesitter_types::FromNode<'tree> for UserDefinedLiteralChildren<'tree> {
20517 #[allow(clippy::collapsible_else_if)]
20518 fn from_node(
20519 node: ::treesitter_types::tree_sitter::Node<'tree>,
20520 src: &'tree [u8],
20521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20522 match node.kind() {
20523 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
20524 ::treesitter_types::runtime::maybe_grow_stack(|| {
20525 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20526 })?,
20527 ))),
20528 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
20529 ::treesitter_types::runtime::maybe_grow_stack(|| {
20530 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
20531 })?,
20532 ))),
20533 "literal_suffix" => Ok(Self::LiteralSuffix(::std::boxed::Box::new(
20534 ::treesitter_types::runtime::maybe_grow_stack(|| {
20535 <LiteralSuffix as ::treesitter_types::FromNode>::from_node(node, src)
20536 })?,
20537 ))),
20538 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
20539 ::treesitter_types::runtime::maybe_grow_stack(|| {
20540 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20541 })?,
20542 ))),
20543 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
20544 ::treesitter_types::runtime::maybe_grow_stack(|| {
20545 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20546 })?,
20547 ))),
20548 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
20549 ::treesitter_types::runtime::maybe_grow_stack(|| {
20550 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20551 })?,
20552 ))),
20553 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20554 }
20555 }
20556}
20557impl ::treesitter_types::Spanned for UserDefinedLiteralChildren<'_> {
20558 fn span(&self) -> ::treesitter_types::Span {
20559 match self {
20560 Self::CharLiteral(inner) => inner.span(),
20561 Self::ConcatenatedString(inner) => inner.span(),
20562 Self::LiteralSuffix(inner) => inner.span(),
20563 Self::NumberLiteral(inner) => inner.span(),
20564 Self::RawStringLiteral(inner) => inner.span(),
20565 Self::StringLiteral(inner) => inner.span(),
20566 }
20567 }
20568}
20569#[derive(Debug, Clone, PartialEq, Eq)]
20570pub enum UsingDeclarationChildren<'tree> {
20571 Identifier(::std::boxed::Box<Identifier<'tree>>),
20572 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
20573}
20574impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclarationChildren<'tree> {
20575 #[allow(clippy::collapsible_else_if)]
20576 fn from_node(
20577 node: ::treesitter_types::tree_sitter::Node<'tree>,
20578 src: &'tree [u8],
20579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20580 match node.kind() {
20581 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
20582 ::treesitter_types::runtime::maybe_grow_stack(|| {
20583 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20584 })?,
20585 ))),
20586 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
20587 ::treesitter_types::runtime::maybe_grow_stack(|| {
20588 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20589 })?,
20590 ))),
20591 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20592 }
20593 }
20594}
20595impl ::treesitter_types::Spanned for UsingDeclarationChildren<'_> {
20596 fn span(&self) -> ::treesitter_types::Span {
20597 match self {
20598 Self::Identifier(inner) => inner.span(),
20599 Self::QualifiedIdentifier(inner) => inner.span(),
20600 }
20601 }
20602}
20603#[derive(Debug, Clone, PartialEq, Eq)]
20604pub enum VariadicParameterDeclarationDeclarator<'tree> {
20605 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
20606 VariadicDeclarator(::std::boxed::Box<VariadicDeclarator<'tree>>),
20607}
20608impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclarationDeclarator<'tree> {
20609 #[allow(clippy::collapsible_else_if)]
20610 fn from_node(
20611 node: ::treesitter_types::tree_sitter::Node<'tree>,
20612 src: &'tree [u8],
20613 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20614 match node.kind() {
20615 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
20616 ::treesitter_types::runtime::maybe_grow_stack(|| {
20617 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
20618 })?,
20619 ))),
20620 "variadic_declarator" => Ok(Self::VariadicDeclarator(::std::boxed::Box::new(
20621 ::treesitter_types::runtime::maybe_grow_stack(|| {
20622 <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
20623 })?,
20624 ))),
20625 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20626 }
20627 }
20628}
20629impl ::treesitter_types::Spanned for VariadicParameterDeclarationDeclarator<'_> {
20630 fn span(&self) -> ::treesitter_types::Span {
20631 match self {
20632 Self::ReferenceDeclarator(inner) => inner.span(),
20633 Self::VariadicDeclarator(inner) => inner.span(),
20634 }
20635 }
20636}
20637#[derive(Debug, Clone, PartialEq, Eq)]
20638pub enum VariadicParameterDeclarationChildren<'tree> {
20639 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
20640 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
20641 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
20642 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
20643 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
20644}
20645impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclarationChildren<'tree> {
20646 #[allow(clippy::collapsible_else_if)]
20647 fn from_node(
20648 node: ::treesitter_types::tree_sitter::Node<'tree>,
20649 src: &'tree [u8],
20650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
20651 match node.kind() {
20652 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
20653 ::treesitter_types::runtime::maybe_grow_stack(|| {
20654 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20655 })?,
20656 ))),
20657 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
20658 ::treesitter_types::runtime::maybe_grow_stack(|| {
20659 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20660 })?,
20661 ))),
20662 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
20663 ::treesitter_types::runtime::maybe_grow_stack(|| {
20664 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
20665 })?,
20666 ))),
20667 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
20668 ::treesitter_types::runtime::maybe_grow_stack(|| {
20669 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20670 })?,
20671 ))),
20672 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
20673 ::treesitter_types::runtime::maybe_grow_stack(|| {
20674 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
20675 })?,
20676 ))),
20677 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
20678 }
20679 }
20680}
20681impl ::treesitter_types::Spanned for VariadicParameterDeclarationChildren<'_> {
20682 fn span(&self) -> ::treesitter_types::Span {
20683 match self {
20684 Self::AttributeDeclaration(inner) => inner.span(),
20685 Self::AttributeSpecifier(inner) => inner.span(),
20686 Self::MsDeclspecModifier(inner) => inner.span(),
20687 Self::StorageClassSpecifier(inner) => inner.span(),
20688 Self::TypeQualifier(inner) => inner.span(),
20689 }
20690 }
20691}
20692#[derive(Debug, Clone, PartialEq, Eq)]
20693pub enum AnyNode<'tree> {
20694 AbstractDeclarator(AbstractDeclarator<'tree>),
20695 Declarator(Declarator<'tree>),
20696 FieldDeclarator(FieldDeclarator<'tree>),
20697 TypeDeclarator(TypeDeclarator<'tree>),
20698 Expression(Expression<'tree>),
20699 Statement(Statement<'tree>),
20700 TypeSpecifier(TypeSpecifier<'tree>),
20701 AbstractArrayDeclarator(AbstractArrayDeclarator<'tree>),
20702 AbstractFunctionDeclarator(AbstractFunctionDeclarator<'tree>),
20703 AbstractParenthesizedDeclarator(AbstractParenthesizedDeclarator<'tree>),
20704 AbstractPointerDeclarator(AbstractPointerDeclarator<'tree>),
20705 AbstractReferenceDeclarator(AbstractReferenceDeclarator<'tree>),
20706 AccessSpecifier(AccessSpecifier<'tree>),
20707 AliasDeclaration(AliasDeclaration<'tree>),
20708 AlignasQualifier(AlignasQualifier<'tree>),
20709 AlignofExpression(AlignofExpression<'tree>),
20710 ArgumentList(ArgumentList<'tree>),
20711 ArrayDeclarator(ArrayDeclarator<'tree>),
20712 AssignmentExpression(AssignmentExpression<'tree>),
20713 Attribute(Attribute<'tree>),
20714 AttributeDeclaration(AttributeDeclaration<'tree>),
20715 AttributeSpecifier(AttributeSpecifier<'tree>),
20716 AttributedDeclarator(AttributedDeclarator<'tree>),
20717 AttributedStatement(AttributedStatement<'tree>),
20718 BaseClassClause(BaseClassClause<'tree>),
20719 BinaryExpression(BinaryExpression<'tree>),
20720 BitfieldClause(BitfieldClause<'tree>),
20721 BreakStatement(BreakStatement<'tree>),
20722 CallExpression(CallExpression<'tree>),
20723 CaseStatement(CaseStatement<'tree>),
20724 CastExpression(CastExpression<'tree>),
20725 CatchClause(CatchClause<'tree>),
20726 CharLiteral(CharLiteral<'tree>),
20727 ClassSpecifier(ClassSpecifier<'tree>),
20728 CoAwaitExpression(CoAwaitExpression<'tree>),
20729 CoReturnStatement(CoReturnStatement<'tree>),
20730 CoYieldStatement(CoYieldStatement<'tree>),
20731 CommaExpression(CommaExpression<'tree>),
20732 CompoundLiteralExpression(CompoundLiteralExpression<'tree>),
20733 CompoundRequirement(CompoundRequirement<'tree>),
20734 CompoundStatement(CompoundStatement<'tree>),
20735 ConcatenatedString(ConcatenatedString<'tree>),
20736 ConceptDefinition(ConceptDefinition<'tree>),
20737 ConditionClause(ConditionClause<'tree>),
20738 ConditionalExpression(ConditionalExpression<'tree>),
20739 ConstraintConjunction(ConstraintConjunction<'tree>),
20740 ConstraintDisjunction(ConstraintDisjunction<'tree>),
20741 ContinueStatement(ContinueStatement<'tree>),
20742 Declaration(Declaration<'tree>),
20743 DeclarationList(DeclarationList<'tree>),
20744 Decltype(Decltype<'tree>),
20745 DefaultMethodClause(DefaultMethodClause<'tree>),
20746 DeleteExpression(DeleteExpression<'tree>),
20747 DeleteMethodClause(DeleteMethodClause<'tree>),
20748 DependentName(DependentName<'tree>),
20749 DependentType(DependentType<'tree>),
20750 DestructorName(DestructorName<'tree>),
20751 DoStatement(DoStatement<'tree>),
20752 ElseClause(ElseClause<'tree>),
20753 EnumSpecifier(EnumSpecifier<'tree>),
20754 Enumerator(Enumerator<'tree>),
20755 EnumeratorList(EnumeratorList<'tree>),
20756 ExplicitFunctionSpecifier(ExplicitFunctionSpecifier<'tree>),
20757 ExpressionStatement(ExpressionStatement<'tree>),
20758 ExtensionExpression(ExtensionExpression<'tree>),
20759 FieldDeclaration(FieldDeclaration<'tree>),
20760 FieldDeclarationList(FieldDeclarationList<'tree>),
20761 FieldDesignator(FieldDesignator<'tree>),
20762 FieldExpression(FieldExpression<'tree>),
20763 FieldInitializer(FieldInitializer<'tree>),
20764 FieldInitializerList(FieldInitializerList<'tree>),
20765 FoldExpression(FoldExpression<'tree>),
20766 ForRangeLoop(ForRangeLoop<'tree>),
20767 ForStatement(ForStatement<'tree>),
20768 FriendDeclaration(FriendDeclaration<'tree>),
20769 FunctionDeclarator(FunctionDeclarator<'tree>),
20770 FunctionDefinition(FunctionDefinition<'tree>),
20771 GenericExpression(GenericExpression<'tree>),
20772 GnuAsmClobberList(GnuAsmClobberList<'tree>),
20773 GnuAsmExpression(GnuAsmExpression<'tree>),
20774 GnuAsmGotoList(GnuAsmGotoList<'tree>),
20775 GnuAsmInputOperand(GnuAsmInputOperand<'tree>),
20776 GnuAsmInputOperandList(GnuAsmInputOperandList<'tree>),
20777 GnuAsmOutputOperand(GnuAsmOutputOperand<'tree>),
20778 GnuAsmOutputOperandList(GnuAsmOutputOperandList<'tree>),
20779 GnuAsmQualifier(GnuAsmQualifier<'tree>),
20780 GotoStatement(GotoStatement<'tree>),
20781 IfStatement(IfStatement<'tree>),
20782 InitDeclarator(InitDeclarator<'tree>),
20783 InitStatement(InitStatement<'tree>),
20784 InitializerList(InitializerList<'tree>),
20785 InitializerPair(InitializerPair<'tree>),
20786 LabeledStatement(LabeledStatement<'tree>),
20787 LambdaCaptureInitializer(LambdaCaptureInitializer<'tree>),
20788 LambdaCaptureSpecifier(LambdaCaptureSpecifier<'tree>),
20789 LambdaDefaultCapture(LambdaDefaultCapture<'tree>),
20790 LambdaExpression(LambdaExpression<'tree>),
20791 LinkageSpecification(LinkageSpecification<'tree>),
20792 MsBasedModifier(MsBasedModifier<'tree>),
20793 MsCallModifier(MsCallModifier<'tree>),
20794 MsDeclspecModifier(MsDeclspecModifier<'tree>),
20795 MsPointerModifier(MsPointerModifier<'tree>),
20796 MsUnalignedPtrModifier(MsUnalignedPtrModifier<'tree>),
20797 NamespaceAliasDefinition(NamespaceAliasDefinition<'tree>),
20798 NamespaceDefinition(NamespaceDefinition<'tree>),
20799 NestedNamespaceSpecifier(NestedNamespaceSpecifier<'tree>),
20800 NewDeclarator(NewDeclarator<'tree>),
20801 NewExpression(NewExpression<'tree>),
20802 Noexcept(Noexcept<'tree>),
20803 Null(Null<'tree>),
20804 OffsetofExpression(OffsetofExpression<'tree>),
20805 OperatorCast(OperatorCast<'tree>),
20806 OperatorName(OperatorName<'tree>),
20807 OptionalParameterDeclaration(OptionalParameterDeclaration<'tree>),
20808 OptionalTypeParameterDeclaration(OptionalTypeParameterDeclaration<'tree>),
20809 ParameterDeclaration(ParameterDeclaration<'tree>),
20810 ParameterList(ParameterList<'tree>),
20811 ParameterPackExpansion(ParameterPackExpansion<'tree>),
20812 ParenthesizedDeclarator(ParenthesizedDeclarator<'tree>),
20813 ParenthesizedExpression(ParenthesizedExpression<'tree>),
20814 PlaceholderTypeSpecifier(PlaceholderTypeSpecifier<'tree>),
20815 PointerDeclarator(PointerDeclarator<'tree>),
20816 PointerExpression(PointerExpression<'tree>),
20817 PointerTypeDeclarator(PointerTypeDeclarator<'tree>),
20818 PreprocCall(PreprocCall<'tree>),
20819 PreprocDef(PreprocDef<'tree>),
20820 PreprocDefined(PreprocDefined<'tree>),
20821 PreprocElif(PreprocElif<'tree>),
20822 PreprocElifdef(PreprocElifdef<'tree>),
20823 PreprocElse(PreprocElse<'tree>),
20824 PreprocFunctionDef(PreprocFunctionDef<'tree>),
20825 PreprocIf(PreprocIf<'tree>),
20826 PreprocIfdef(PreprocIfdef<'tree>),
20827 PreprocInclude(PreprocInclude<'tree>),
20828 PreprocParams(PreprocParams<'tree>),
20829 PureVirtualClause(PureVirtualClause<'tree>),
20830 QualifiedIdentifier(QualifiedIdentifier<'tree>),
20831 RawStringLiteral(RawStringLiteral<'tree>),
20832 RefQualifier(RefQualifier<'tree>),
20833 ReferenceDeclarator(ReferenceDeclarator<'tree>),
20834 RequirementSeq(RequirementSeq<'tree>),
20835 RequiresClause(RequiresClause<'tree>),
20836 RequiresExpression(RequiresExpression<'tree>),
20837 ReturnStatement(ReturnStatement<'tree>),
20838 SehExceptClause(SehExceptClause<'tree>),
20839 SehFinallyClause(SehFinallyClause<'tree>),
20840 SehLeaveStatement(SehLeaveStatement<'tree>),
20841 SehTryStatement(SehTryStatement<'tree>),
20842 SimpleRequirement(SimpleRequirement<'tree>),
20843 SizedTypeSpecifier(SizedTypeSpecifier<'tree>),
20844 SizeofExpression(SizeofExpression<'tree>),
20845 StaticAssertDeclaration(StaticAssertDeclaration<'tree>),
20846 StorageClassSpecifier(StorageClassSpecifier<'tree>),
20847 StringLiteral(StringLiteral<'tree>),
20848 StructSpecifier(StructSpecifier<'tree>),
20849 StructuredBindingDeclarator(StructuredBindingDeclarator<'tree>),
20850 SubscriptArgumentList(SubscriptArgumentList<'tree>),
20851 SubscriptDesignator(SubscriptDesignator<'tree>),
20852 SubscriptExpression(SubscriptExpression<'tree>),
20853 SubscriptRangeDesignator(SubscriptRangeDesignator<'tree>),
20854 SwitchStatement(SwitchStatement<'tree>),
20855 TemplateArgumentList(TemplateArgumentList<'tree>),
20856 TemplateDeclaration(TemplateDeclaration<'tree>),
20857 TemplateFunction(TemplateFunction<'tree>),
20858 TemplateInstantiation(TemplateInstantiation<'tree>),
20859 TemplateMethod(TemplateMethod<'tree>),
20860 TemplateParameterList(TemplateParameterList<'tree>),
20861 TemplateTemplateParameterDeclaration(TemplateTemplateParameterDeclaration<'tree>),
20862 TemplateType(TemplateType<'tree>),
20863 ThrowSpecifier(ThrowSpecifier<'tree>),
20864 ThrowStatement(ThrowStatement<'tree>),
20865 TrailingReturnType(TrailingReturnType<'tree>),
20866 TranslationUnit(TranslationUnit<'tree>),
20867 TryStatement(TryStatement<'tree>),
20868 TypeDefinition(TypeDefinition<'tree>),
20869 TypeDescriptor(TypeDescriptor<'tree>),
20870 TypeParameterDeclaration(TypeParameterDeclaration<'tree>),
20871 TypeQualifier(TypeQualifier<'tree>),
20872 TypeRequirement(TypeRequirement<'tree>),
20873 UnaryExpression(UnaryExpression<'tree>),
20874 UnionSpecifier(UnionSpecifier<'tree>),
20875 UpdateExpression(UpdateExpression<'tree>),
20876 UserDefinedLiteral(UserDefinedLiteral<'tree>),
20877 UsingDeclaration(UsingDeclaration<'tree>),
20878 VariadicDeclarator(VariadicDeclarator<'tree>),
20879 VariadicParameterDeclaration(VariadicParameterDeclaration<'tree>),
20880 VariadicTypeParameterDeclaration(VariadicTypeParameterDeclaration<'tree>),
20881 VirtualSpecifier(VirtualSpecifier<'tree>),
20882 WhileStatement(WhileStatement<'tree>),
20883 Auto(Auto<'tree>),
20884 Character(Character<'tree>),
20885 Comment(Comment<'tree>),
20886 EscapeSequence(EscapeSequence<'tree>),
20887 False(False<'tree>),
20888 FieldIdentifier(FieldIdentifier<'tree>),
20889 Identifier(Identifier<'tree>),
20890 LiteralSuffix(LiteralSuffix<'tree>),
20891 MsRestrictModifier(MsRestrictModifier<'tree>),
20892 MsSignedPtrModifier(MsSignedPtrModifier<'tree>),
20893 MsUnsignedPtrModifier(MsUnsignedPtrModifier<'tree>),
20894 NamespaceIdentifier(NamespaceIdentifier<'tree>),
20895 NumberLiteral(NumberLiteral<'tree>),
20896 PreprocArg(PreprocArg<'tree>),
20897 PreprocDirective(PreprocDirective<'tree>),
20898 PrimitiveType(PrimitiveType<'tree>),
20899 RawStringContent(RawStringContent<'tree>),
20900 RawStringDelimiter(RawStringDelimiter<'tree>),
20901 StatementIdentifier(StatementIdentifier<'tree>),
20902 StringContent(StringContent<'tree>),
20903 SystemLibString(SystemLibString<'tree>),
20904 This(This<'tree>),
20905 True(True<'tree>),
20906 TypeIdentifier(TypeIdentifier<'tree>),
20907 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
20908}
20909impl<'tree> AnyNode<'tree> {
20910 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
20911 match node.kind() {
20912 "_abstract_declarator" => {
20913 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(
20914 node,
20915 src,
20916 ))
20917 .map(Self::AbstractDeclarator)
20918 .unwrap_or(Self::Unknown(node))
20919 }
20920 "_declarator" => {
20921 ::treesitter_types::runtime::maybe_grow_stack(|| <Declarator as ::treesitter_types::FromNode>::from_node(
20922 node,
20923 src,
20924 ))
20925 .map(Self::Declarator)
20926 .unwrap_or(Self::Unknown(node))
20927 }
20928 "_field_declarator" => {
20929 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDeclarator as ::treesitter_types::FromNode>::from_node(
20930 node,
20931 src,
20932 ))
20933 .map(Self::FieldDeclarator)
20934 .unwrap_or(Self::Unknown(node))
20935 }
20936 "_type_declarator" => {
20937 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeDeclarator as ::treesitter_types::FromNode>::from_node(
20938 node,
20939 src,
20940 ))
20941 .map(Self::TypeDeclarator)
20942 .unwrap_or(Self::Unknown(node))
20943 }
20944 "expression" => {
20945 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
20946 node,
20947 src,
20948 ))
20949 .map(Self::Expression)
20950 .unwrap_or(Self::Unknown(node))
20951 }
20952 "statement" => {
20953 ::treesitter_types::runtime::maybe_grow_stack(|| <Statement as ::treesitter_types::FromNode>::from_node(
20954 node,
20955 src,
20956 ))
20957 .map(Self::Statement)
20958 .unwrap_or(Self::Unknown(node))
20959 }
20960 "type_specifier" => {
20961 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeSpecifier as ::treesitter_types::FromNode>::from_node(
20962 node,
20963 src,
20964 ))
20965 .map(Self::TypeSpecifier)
20966 .unwrap_or(Self::Unknown(node))
20967 }
20968 "abstract_array_declarator" => {
20969 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(
20970 node,
20971 src,
20972 ))
20973 .map(Self::AbstractArrayDeclarator)
20974 .unwrap_or(Self::Unknown(node))
20975 }
20976 "abstract_function_declarator" => {
20977 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
20978 node,
20979 src,
20980 ))
20981 .map(Self::AbstractFunctionDeclarator)
20982 .unwrap_or(Self::Unknown(node))
20983 }
20984 "abstract_parenthesized_declarator" => {
20985 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
20986 node,
20987 src,
20988 ))
20989 .map(Self::AbstractParenthesizedDeclarator)
20990 .unwrap_or(Self::Unknown(node))
20991 }
20992 "abstract_pointer_declarator" => {
20993 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(
20994 node,
20995 src,
20996 ))
20997 .map(Self::AbstractPointerDeclarator)
20998 .unwrap_or(Self::Unknown(node))
20999 }
21000 "abstract_reference_declarator" => {
21001 ::treesitter_types::runtime::maybe_grow_stack(|| <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
21002 node,
21003 src,
21004 ))
21005 .map(Self::AbstractReferenceDeclarator)
21006 .unwrap_or(Self::Unknown(node))
21007 }
21008 "access_specifier" => {
21009 ::treesitter_types::runtime::maybe_grow_stack(|| <AccessSpecifier as ::treesitter_types::FromNode>::from_node(
21010 node,
21011 src,
21012 ))
21013 .map(Self::AccessSpecifier)
21014 .unwrap_or(Self::Unknown(node))
21015 }
21016 "alias_declaration" => {
21017 ::treesitter_types::runtime::maybe_grow_stack(|| <AliasDeclaration as ::treesitter_types::FromNode>::from_node(
21018 node,
21019 src,
21020 ))
21021 .map(Self::AliasDeclaration)
21022 .unwrap_or(Self::Unknown(node))
21023 }
21024 "alignas_qualifier" => {
21025 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignasQualifier as ::treesitter_types::FromNode>::from_node(
21026 node,
21027 src,
21028 ))
21029 .map(Self::AlignasQualifier)
21030 .unwrap_or(Self::Unknown(node))
21031 }
21032 "alignof_expression" => {
21033 ::treesitter_types::runtime::maybe_grow_stack(|| <AlignofExpression as ::treesitter_types::FromNode>::from_node(
21034 node,
21035 src,
21036 ))
21037 .map(Self::AlignofExpression)
21038 .unwrap_or(Self::Unknown(node))
21039 }
21040 "argument_list" => {
21041 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentList as ::treesitter_types::FromNode>::from_node(
21042 node,
21043 src,
21044 ))
21045 .map(Self::ArgumentList)
21046 .unwrap_or(Self::Unknown(node))
21047 }
21048 "array_declarator" => {
21049 ::treesitter_types::runtime::maybe_grow_stack(|| <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(
21050 node,
21051 src,
21052 ))
21053 .map(Self::ArrayDeclarator)
21054 .unwrap_or(Self::Unknown(node))
21055 }
21056 "assignment_expression" => {
21057 ::treesitter_types::runtime::maybe_grow_stack(|| <AssignmentExpression as ::treesitter_types::FromNode>::from_node(
21058 node,
21059 src,
21060 ))
21061 .map(Self::AssignmentExpression)
21062 .unwrap_or(Self::Unknown(node))
21063 }
21064 "attribute" => {
21065 ::treesitter_types::runtime::maybe_grow_stack(|| <Attribute as ::treesitter_types::FromNode>::from_node(
21066 node,
21067 src,
21068 ))
21069 .map(Self::Attribute)
21070 .unwrap_or(Self::Unknown(node))
21071 }
21072 "attribute_declaration" => {
21073 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(
21074 node,
21075 src,
21076 ))
21077 .map(Self::AttributeDeclaration)
21078 .unwrap_or(Self::Unknown(node))
21079 }
21080 "attribute_specifier" => {
21081 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(
21082 node,
21083 src,
21084 ))
21085 .map(Self::AttributeSpecifier)
21086 .unwrap_or(Self::Unknown(node))
21087 }
21088 "attributed_declarator" => {
21089 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(
21090 node,
21091 src,
21092 ))
21093 .map(Self::AttributedDeclarator)
21094 .unwrap_or(Self::Unknown(node))
21095 }
21096 "attributed_statement" => {
21097 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributedStatement as ::treesitter_types::FromNode>::from_node(
21098 node,
21099 src,
21100 ))
21101 .map(Self::AttributedStatement)
21102 .unwrap_or(Self::Unknown(node))
21103 }
21104 "base_class_clause" => {
21105 ::treesitter_types::runtime::maybe_grow_stack(|| <BaseClassClause as ::treesitter_types::FromNode>::from_node(
21106 node,
21107 src,
21108 ))
21109 .map(Self::BaseClassClause)
21110 .unwrap_or(Self::Unknown(node))
21111 }
21112 "binary_expression" => {
21113 ::treesitter_types::runtime::maybe_grow_stack(|| <BinaryExpression as ::treesitter_types::FromNode>::from_node(
21114 node,
21115 src,
21116 ))
21117 .map(Self::BinaryExpression)
21118 .unwrap_or(Self::Unknown(node))
21119 }
21120 "bitfield_clause" => {
21121 ::treesitter_types::runtime::maybe_grow_stack(|| <BitfieldClause as ::treesitter_types::FromNode>::from_node(
21122 node,
21123 src,
21124 ))
21125 .map(Self::BitfieldClause)
21126 .unwrap_or(Self::Unknown(node))
21127 }
21128 "break_statement" => {
21129 ::treesitter_types::runtime::maybe_grow_stack(|| <BreakStatement as ::treesitter_types::FromNode>::from_node(
21130 node,
21131 src,
21132 ))
21133 .map(Self::BreakStatement)
21134 .unwrap_or(Self::Unknown(node))
21135 }
21136 "call_expression" => {
21137 ::treesitter_types::runtime::maybe_grow_stack(|| <CallExpression as ::treesitter_types::FromNode>::from_node(
21138 node,
21139 src,
21140 ))
21141 .map(Self::CallExpression)
21142 .unwrap_or(Self::Unknown(node))
21143 }
21144 "case_statement" => {
21145 ::treesitter_types::runtime::maybe_grow_stack(|| <CaseStatement as ::treesitter_types::FromNode>::from_node(
21146 node,
21147 src,
21148 ))
21149 .map(Self::CaseStatement)
21150 .unwrap_or(Self::Unknown(node))
21151 }
21152 "cast_expression" => {
21153 ::treesitter_types::runtime::maybe_grow_stack(|| <CastExpression as ::treesitter_types::FromNode>::from_node(
21154 node,
21155 src,
21156 ))
21157 .map(Self::CastExpression)
21158 .unwrap_or(Self::Unknown(node))
21159 }
21160 "catch_clause" => {
21161 ::treesitter_types::runtime::maybe_grow_stack(|| <CatchClause as ::treesitter_types::FromNode>::from_node(
21162 node,
21163 src,
21164 ))
21165 .map(Self::CatchClause)
21166 .unwrap_or(Self::Unknown(node))
21167 }
21168 "char_literal" => {
21169 ::treesitter_types::runtime::maybe_grow_stack(|| <CharLiteral as ::treesitter_types::FromNode>::from_node(
21170 node,
21171 src,
21172 ))
21173 .map(Self::CharLiteral)
21174 .unwrap_or(Self::Unknown(node))
21175 }
21176 "class_specifier" => {
21177 ::treesitter_types::runtime::maybe_grow_stack(|| <ClassSpecifier as ::treesitter_types::FromNode>::from_node(
21178 node,
21179 src,
21180 ))
21181 .map(Self::ClassSpecifier)
21182 .unwrap_or(Self::Unknown(node))
21183 }
21184 "co_await_expression" => {
21185 ::treesitter_types::runtime::maybe_grow_stack(|| <CoAwaitExpression as ::treesitter_types::FromNode>::from_node(
21186 node,
21187 src,
21188 ))
21189 .map(Self::CoAwaitExpression)
21190 .unwrap_or(Self::Unknown(node))
21191 }
21192 "co_return_statement" => {
21193 ::treesitter_types::runtime::maybe_grow_stack(|| <CoReturnStatement as ::treesitter_types::FromNode>::from_node(
21194 node,
21195 src,
21196 ))
21197 .map(Self::CoReturnStatement)
21198 .unwrap_or(Self::Unknown(node))
21199 }
21200 "co_yield_statement" => {
21201 ::treesitter_types::runtime::maybe_grow_stack(|| <CoYieldStatement as ::treesitter_types::FromNode>::from_node(
21202 node,
21203 src,
21204 ))
21205 .map(Self::CoYieldStatement)
21206 .unwrap_or(Self::Unknown(node))
21207 }
21208 "comma_expression" => {
21209 ::treesitter_types::runtime::maybe_grow_stack(|| <CommaExpression as ::treesitter_types::FromNode>::from_node(
21210 node,
21211 src,
21212 ))
21213 .map(Self::CommaExpression)
21214 .unwrap_or(Self::Unknown(node))
21215 }
21216 "compound_literal_expression" => {
21217 ::treesitter_types::runtime::maybe_grow_stack(|| <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(
21218 node,
21219 src,
21220 ))
21221 .map(Self::CompoundLiteralExpression)
21222 .unwrap_or(Self::Unknown(node))
21223 }
21224 "compound_requirement" => {
21225 ::treesitter_types::runtime::maybe_grow_stack(|| <CompoundRequirement as ::treesitter_types::FromNode>::from_node(
21226 node,
21227 src,
21228 ))
21229 .map(Self::CompoundRequirement)
21230 .unwrap_or(Self::Unknown(node))
21231 }
21232 "compound_statement" => {
21233 ::treesitter_types::runtime::maybe_grow_stack(|| <CompoundStatement as ::treesitter_types::FromNode>::from_node(
21234 node,
21235 src,
21236 ))
21237 .map(Self::CompoundStatement)
21238 .unwrap_or(Self::Unknown(node))
21239 }
21240 "concatenated_string" => {
21241 ::treesitter_types::runtime::maybe_grow_stack(|| <ConcatenatedString as ::treesitter_types::FromNode>::from_node(
21242 node,
21243 src,
21244 ))
21245 .map(Self::ConcatenatedString)
21246 .unwrap_or(Self::Unknown(node))
21247 }
21248 "concept_definition" => {
21249 ::treesitter_types::runtime::maybe_grow_stack(|| <ConceptDefinition as ::treesitter_types::FromNode>::from_node(
21250 node,
21251 src,
21252 ))
21253 .map(Self::ConceptDefinition)
21254 .unwrap_or(Self::Unknown(node))
21255 }
21256 "condition_clause" => {
21257 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionClause as ::treesitter_types::FromNode>::from_node(
21258 node,
21259 src,
21260 ))
21261 .map(Self::ConditionClause)
21262 .unwrap_or(Self::Unknown(node))
21263 }
21264 "conditional_expression" => {
21265 ::treesitter_types::runtime::maybe_grow_stack(|| <ConditionalExpression as ::treesitter_types::FromNode>::from_node(
21266 node,
21267 src,
21268 ))
21269 .map(Self::ConditionalExpression)
21270 .unwrap_or(Self::Unknown(node))
21271 }
21272 "constraint_conjunction" => {
21273 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(
21274 node,
21275 src,
21276 ))
21277 .map(Self::ConstraintConjunction)
21278 .unwrap_or(Self::Unknown(node))
21279 }
21280 "constraint_disjunction" => {
21281 ::treesitter_types::runtime::maybe_grow_stack(|| <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(
21282 node,
21283 src,
21284 ))
21285 .map(Self::ConstraintDisjunction)
21286 .unwrap_or(Self::Unknown(node))
21287 }
21288 "continue_statement" => {
21289 ::treesitter_types::runtime::maybe_grow_stack(|| <ContinueStatement as ::treesitter_types::FromNode>::from_node(
21290 node,
21291 src,
21292 ))
21293 .map(Self::ContinueStatement)
21294 .unwrap_or(Self::Unknown(node))
21295 }
21296 "declaration" => {
21297 ::treesitter_types::runtime::maybe_grow_stack(|| <Declaration as ::treesitter_types::FromNode>::from_node(
21298 node,
21299 src,
21300 ))
21301 .map(Self::Declaration)
21302 .unwrap_or(Self::Unknown(node))
21303 }
21304 "declaration_list" => {
21305 ::treesitter_types::runtime::maybe_grow_stack(|| <DeclarationList as ::treesitter_types::FromNode>::from_node(
21306 node,
21307 src,
21308 ))
21309 .map(Self::DeclarationList)
21310 .unwrap_or(Self::Unknown(node))
21311 }
21312 "decltype" => {
21313 ::treesitter_types::runtime::maybe_grow_stack(|| <Decltype as ::treesitter_types::FromNode>::from_node(
21314 node,
21315 src,
21316 ))
21317 .map(Self::Decltype)
21318 .unwrap_or(Self::Unknown(node))
21319 }
21320 "default_method_clause" => {
21321 ::treesitter_types::runtime::maybe_grow_stack(|| <DefaultMethodClause as ::treesitter_types::FromNode>::from_node(
21322 node,
21323 src,
21324 ))
21325 .map(Self::DefaultMethodClause)
21326 .unwrap_or(Self::Unknown(node))
21327 }
21328 "delete_expression" => {
21329 ::treesitter_types::runtime::maybe_grow_stack(|| <DeleteExpression as ::treesitter_types::FromNode>::from_node(
21330 node,
21331 src,
21332 ))
21333 .map(Self::DeleteExpression)
21334 .unwrap_or(Self::Unknown(node))
21335 }
21336 "delete_method_clause" => {
21337 ::treesitter_types::runtime::maybe_grow_stack(|| <DeleteMethodClause as ::treesitter_types::FromNode>::from_node(
21338 node,
21339 src,
21340 ))
21341 .map(Self::DeleteMethodClause)
21342 .unwrap_or(Self::Unknown(node))
21343 }
21344 "dependent_name" => {
21345 ::treesitter_types::runtime::maybe_grow_stack(|| <DependentName as ::treesitter_types::FromNode>::from_node(
21346 node,
21347 src,
21348 ))
21349 .map(Self::DependentName)
21350 .unwrap_or(Self::Unknown(node))
21351 }
21352 "dependent_type" => {
21353 ::treesitter_types::runtime::maybe_grow_stack(|| <DependentType as ::treesitter_types::FromNode>::from_node(
21354 node,
21355 src,
21356 ))
21357 .map(Self::DependentType)
21358 .unwrap_or(Self::Unknown(node))
21359 }
21360 "destructor_name" => {
21361 ::treesitter_types::runtime::maybe_grow_stack(|| <DestructorName as ::treesitter_types::FromNode>::from_node(
21362 node,
21363 src,
21364 ))
21365 .map(Self::DestructorName)
21366 .unwrap_or(Self::Unknown(node))
21367 }
21368 "do_statement" => {
21369 ::treesitter_types::runtime::maybe_grow_stack(|| <DoStatement as ::treesitter_types::FromNode>::from_node(
21370 node,
21371 src,
21372 ))
21373 .map(Self::DoStatement)
21374 .unwrap_or(Self::Unknown(node))
21375 }
21376 "else_clause" => {
21377 ::treesitter_types::runtime::maybe_grow_stack(|| <ElseClause as ::treesitter_types::FromNode>::from_node(
21378 node,
21379 src,
21380 ))
21381 .map(Self::ElseClause)
21382 .unwrap_or(Self::Unknown(node))
21383 }
21384 "enum_specifier" => {
21385 ::treesitter_types::runtime::maybe_grow_stack(|| <EnumSpecifier as ::treesitter_types::FromNode>::from_node(
21386 node,
21387 src,
21388 ))
21389 .map(Self::EnumSpecifier)
21390 .unwrap_or(Self::Unknown(node))
21391 }
21392 "enumerator" => {
21393 ::treesitter_types::runtime::maybe_grow_stack(|| <Enumerator as ::treesitter_types::FromNode>::from_node(
21394 node,
21395 src,
21396 ))
21397 .map(Self::Enumerator)
21398 .unwrap_or(Self::Unknown(node))
21399 }
21400 "enumerator_list" => {
21401 ::treesitter_types::runtime::maybe_grow_stack(|| <EnumeratorList as ::treesitter_types::FromNode>::from_node(
21402 node,
21403 src,
21404 ))
21405 .map(Self::EnumeratorList)
21406 .unwrap_or(Self::Unknown(node))
21407 }
21408 "explicit_function_specifier" => {
21409 ::treesitter_types::runtime::maybe_grow_stack(|| <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(
21410 node,
21411 src,
21412 ))
21413 .map(Self::ExplicitFunctionSpecifier)
21414 .unwrap_or(Self::Unknown(node))
21415 }
21416 "expression_statement" => {
21417 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpressionStatement as ::treesitter_types::FromNode>::from_node(
21418 node,
21419 src,
21420 ))
21421 .map(Self::ExpressionStatement)
21422 .unwrap_or(Self::Unknown(node))
21423 }
21424 "extension_expression" => {
21425 ::treesitter_types::runtime::maybe_grow_stack(|| <ExtensionExpression as ::treesitter_types::FromNode>::from_node(
21426 node,
21427 src,
21428 ))
21429 .map(Self::ExtensionExpression)
21430 .unwrap_or(Self::Unknown(node))
21431 }
21432 "field_declaration" => {
21433 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDeclaration as ::treesitter_types::FromNode>::from_node(
21434 node,
21435 src,
21436 ))
21437 .map(Self::FieldDeclaration)
21438 .unwrap_or(Self::Unknown(node))
21439 }
21440 "field_declaration_list" => {
21441 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(
21442 node,
21443 src,
21444 ))
21445 .map(Self::FieldDeclarationList)
21446 .unwrap_or(Self::Unknown(node))
21447 }
21448 "field_designator" => {
21449 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldDesignator as ::treesitter_types::FromNode>::from_node(
21450 node,
21451 src,
21452 ))
21453 .map(Self::FieldDesignator)
21454 .unwrap_or(Self::Unknown(node))
21455 }
21456 "field_expression" => {
21457 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldExpression as ::treesitter_types::FromNode>::from_node(
21458 node,
21459 src,
21460 ))
21461 .map(Self::FieldExpression)
21462 .unwrap_or(Self::Unknown(node))
21463 }
21464 "field_initializer" => {
21465 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldInitializer as ::treesitter_types::FromNode>::from_node(
21466 node,
21467 src,
21468 ))
21469 .map(Self::FieldInitializer)
21470 .unwrap_or(Self::Unknown(node))
21471 }
21472 "field_initializer_list" => {
21473 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldInitializerList as ::treesitter_types::FromNode>::from_node(
21474 node,
21475 src,
21476 ))
21477 .map(Self::FieldInitializerList)
21478 .unwrap_or(Self::Unknown(node))
21479 }
21480 "fold_expression" => {
21481 ::treesitter_types::runtime::maybe_grow_stack(|| <FoldExpression as ::treesitter_types::FromNode>::from_node(
21482 node,
21483 src,
21484 ))
21485 .map(Self::FoldExpression)
21486 .unwrap_or(Self::Unknown(node))
21487 }
21488 "for_range_loop" => {
21489 ::treesitter_types::runtime::maybe_grow_stack(|| <ForRangeLoop as ::treesitter_types::FromNode>::from_node(
21490 node,
21491 src,
21492 ))
21493 .map(Self::ForRangeLoop)
21494 .unwrap_or(Self::Unknown(node))
21495 }
21496 "for_statement" => {
21497 ::treesitter_types::runtime::maybe_grow_stack(|| <ForStatement as ::treesitter_types::FromNode>::from_node(
21498 node,
21499 src,
21500 ))
21501 .map(Self::ForStatement)
21502 .unwrap_or(Self::Unknown(node))
21503 }
21504 "friend_declaration" => {
21505 ::treesitter_types::runtime::maybe_grow_stack(|| <FriendDeclaration as ::treesitter_types::FromNode>::from_node(
21506 node,
21507 src,
21508 ))
21509 .map(Self::FriendDeclaration)
21510 .unwrap_or(Self::Unknown(node))
21511 }
21512 "function_declarator" => {
21513 ::treesitter_types::runtime::maybe_grow_stack(|| <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(
21514 node,
21515 src,
21516 ))
21517 .map(Self::FunctionDeclarator)
21518 .unwrap_or(Self::Unknown(node))
21519 }
21520 "function_definition" => {
21521 ::treesitter_types::runtime::maybe_grow_stack(|| <FunctionDefinition as ::treesitter_types::FromNode>::from_node(
21522 node,
21523 src,
21524 ))
21525 .map(Self::FunctionDefinition)
21526 .unwrap_or(Self::Unknown(node))
21527 }
21528 "generic_expression" => {
21529 ::treesitter_types::runtime::maybe_grow_stack(|| <GenericExpression as ::treesitter_types::FromNode>::from_node(
21530 node,
21531 src,
21532 ))
21533 .map(Self::GenericExpression)
21534 .unwrap_or(Self::Unknown(node))
21535 }
21536 "gnu_asm_clobber_list" => {
21537 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(
21538 node,
21539 src,
21540 ))
21541 .map(Self::GnuAsmClobberList)
21542 .unwrap_or(Self::Unknown(node))
21543 }
21544 "gnu_asm_expression" => {
21545 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(
21546 node,
21547 src,
21548 ))
21549 .map(Self::GnuAsmExpression)
21550 .unwrap_or(Self::Unknown(node))
21551 }
21552 "gnu_asm_goto_list" => {
21553 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(
21554 node,
21555 src,
21556 ))
21557 .map(Self::GnuAsmGotoList)
21558 .unwrap_or(Self::Unknown(node))
21559 }
21560 "gnu_asm_input_operand" => {
21561 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(
21562 node,
21563 src,
21564 ))
21565 .map(Self::GnuAsmInputOperand)
21566 .unwrap_or(Self::Unknown(node))
21567 }
21568 "gnu_asm_input_operand_list" => {
21569 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(
21570 node,
21571 src,
21572 ))
21573 .map(Self::GnuAsmInputOperandList)
21574 .unwrap_or(Self::Unknown(node))
21575 }
21576 "gnu_asm_output_operand" => {
21577 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(
21578 node,
21579 src,
21580 ))
21581 .map(Self::GnuAsmOutputOperand)
21582 .unwrap_or(Self::Unknown(node))
21583 }
21584 "gnu_asm_output_operand_list" => {
21585 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(
21586 node,
21587 src,
21588 ))
21589 .map(Self::GnuAsmOutputOperandList)
21590 .unwrap_or(Self::Unknown(node))
21591 }
21592 "gnu_asm_qualifier" => {
21593 ::treesitter_types::runtime::maybe_grow_stack(|| <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(
21594 node,
21595 src,
21596 ))
21597 .map(Self::GnuAsmQualifier)
21598 .unwrap_or(Self::Unknown(node))
21599 }
21600 "goto_statement" => {
21601 ::treesitter_types::runtime::maybe_grow_stack(|| <GotoStatement as ::treesitter_types::FromNode>::from_node(
21602 node,
21603 src,
21604 ))
21605 .map(Self::GotoStatement)
21606 .unwrap_or(Self::Unknown(node))
21607 }
21608 "if_statement" => {
21609 ::treesitter_types::runtime::maybe_grow_stack(|| <IfStatement as ::treesitter_types::FromNode>::from_node(
21610 node,
21611 src,
21612 ))
21613 .map(Self::IfStatement)
21614 .unwrap_or(Self::Unknown(node))
21615 }
21616 "init_declarator" => {
21617 ::treesitter_types::runtime::maybe_grow_stack(|| <InitDeclarator as ::treesitter_types::FromNode>::from_node(
21618 node,
21619 src,
21620 ))
21621 .map(Self::InitDeclarator)
21622 .unwrap_or(Self::Unknown(node))
21623 }
21624 "init_statement" => {
21625 ::treesitter_types::runtime::maybe_grow_stack(|| <InitStatement as ::treesitter_types::FromNode>::from_node(
21626 node,
21627 src,
21628 ))
21629 .map(Self::InitStatement)
21630 .unwrap_or(Self::Unknown(node))
21631 }
21632 "initializer_list" => {
21633 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerList as ::treesitter_types::FromNode>::from_node(
21634 node,
21635 src,
21636 ))
21637 .map(Self::InitializerList)
21638 .unwrap_or(Self::Unknown(node))
21639 }
21640 "initializer_pair" => {
21641 ::treesitter_types::runtime::maybe_grow_stack(|| <InitializerPair as ::treesitter_types::FromNode>::from_node(
21642 node,
21643 src,
21644 ))
21645 .map(Self::InitializerPair)
21646 .unwrap_or(Self::Unknown(node))
21647 }
21648 "labeled_statement" => {
21649 ::treesitter_types::runtime::maybe_grow_stack(|| <LabeledStatement as ::treesitter_types::FromNode>::from_node(
21650 node,
21651 src,
21652 ))
21653 .map(Self::LabeledStatement)
21654 .unwrap_or(Self::Unknown(node))
21655 }
21656 "lambda_capture_initializer" => {
21657 ::treesitter_types::runtime::maybe_grow_stack(|| <LambdaCaptureInitializer as ::treesitter_types::FromNode>::from_node(
21658 node,
21659 src,
21660 ))
21661 .map(Self::LambdaCaptureInitializer)
21662 .unwrap_or(Self::Unknown(node))
21663 }
21664 "lambda_capture_specifier" => {
21665 ::treesitter_types::runtime::maybe_grow_stack(|| <LambdaCaptureSpecifier as ::treesitter_types::FromNode>::from_node(
21666 node,
21667 src,
21668 ))
21669 .map(Self::LambdaCaptureSpecifier)
21670 .unwrap_or(Self::Unknown(node))
21671 }
21672 "lambda_default_capture" => {
21673 ::treesitter_types::runtime::maybe_grow_stack(|| <LambdaDefaultCapture as ::treesitter_types::FromNode>::from_node(
21674 node,
21675 src,
21676 ))
21677 .map(Self::LambdaDefaultCapture)
21678 .unwrap_or(Self::Unknown(node))
21679 }
21680 "lambda_expression" => {
21681 ::treesitter_types::runtime::maybe_grow_stack(|| <LambdaExpression as ::treesitter_types::FromNode>::from_node(
21682 node,
21683 src,
21684 ))
21685 .map(Self::LambdaExpression)
21686 .unwrap_or(Self::Unknown(node))
21687 }
21688 "linkage_specification" => {
21689 ::treesitter_types::runtime::maybe_grow_stack(|| <LinkageSpecification as ::treesitter_types::FromNode>::from_node(
21690 node,
21691 src,
21692 ))
21693 .map(Self::LinkageSpecification)
21694 .unwrap_or(Self::Unknown(node))
21695 }
21696 "ms_based_modifier" => {
21697 ::treesitter_types::runtime::maybe_grow_stack(|| <MsBasedModifier as ::treesitter_types::FromNode>::from_node(
21698 node,
21699 src,
21700 ))
21701 .map(Self::MsBasedModifier)
21702 .unwrap_or(Self::Unknown(node))
21703 }
21704 "ms_call_modifier" => {
21705 ::treesitter_types::runtime::maybe_grow_stack(|| <MsCallModifier as ::treesitter_types::FromNode>::from_node(
21706 node,
21707 src,
21708 ))
21709 .map(Self::MsCallModifier)
21710 .unwrap_or(Self::Unknown(node))
21711 }
21712 "ms_declspec_modifier" => {
21713 ::treesitter_types::runtime::maybe_grow_stack(|| <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(
21714 node,
21715 src,
21716 ))
21717 .map(Self::MsDeclspecModifier)
21718 .unwrap_or(Self::Unknown(node))
21719 }
21720 "ms_pointer_modifier" => {
21721 ::treesitter_types::runtime::maybe_grow_stack(|| <MsPointerModifier as ::treesitter_types::FromNode>::from_node(
21722 node,
21723 src,
21724 ))
21725 .map(Self::MsPointerModifier)
21726 .unwrap_or(Self::Unknown(node))
21727 }
21728 "ms_unaligned_ptr_modifier" => {
21729 ::treesitter_types::runtime::maybe_grow_stack(|| <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(
21730 node,
21731 src,
21732 ))
21733 .map(Self::MsUnalignedPtrModifier)
21734 .unwrap_or(Self::Unknown(node))
21735 }
21736 "namespace_alias_definition" => {
21737 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
21738 node,
21739 src,
21740 ))
21741 .map(Self::NamespaceAliasDefinition)
21742 .unwrap_or(Self::Unknown(node))
21743 }
21744 "namespace_definition" => {
21745 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(
21746 node,
21747 src,
21748 ))
21749 .map(Self::NamespaceDefinition)
21750 .unwrap_or(Self::Unknown(node))
21751 }
21752 "nested_namespace_specifier" => {
21753 ::treesitter_types::runtime::maybe_grow_stack(|| <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(
21754 node,
21755 src,
21756 ))
21757 .map(Self::NestedNamespaceSpecifier)
21758 .unwrap_or(Self::Unknown(node))
21759 }
21760 "new_declarator" => {
21761 ::treesitter_types::runtime::maybe_grow_stack(|| <NewDeclarator as ::treesitter_types::FromNode>::from_node(
21762 node,
21763 src,
21764 ))
21765 .map(Self::NewDeclarator)
21766 .unwrap_or(Self::Unknown(node))
21767 }
21768 "new_expression" => {
21769 ::treesitter_types::runtime::maybe_grow_stack(|| <NewExpression as ::treesitter_types::FromNode>::from_node(
21770 node,
21771 src,
21772 ))
21773 .map(Self::NewExpression)
21774 .unwrap_or(Self::Unknown(node))
21775 }
21776 "noexcept" => {
21777 ::treesitter_types::runtime::maybe_grow_stack(|| <Noexcept as ::treesitter_types::FromNode>::from_node(
21778 node,
21779 src,
21780 ))
21781 .map(Self::Noexcept)
21782 .unwrap_or(Self::Unknown(node))
21783 }
21784 "null" => {
21785 ::treesitter_types::runtime::maybe_grow_stack(|| <Null as ::treesitter_types::FromNode>::from_node(
21786 node,
21787 src,
21788 ))
21789 .map(Self::Null)
21790 .unwrap_or(Self::Unknown(node))
21791 }
21792 "offsetof_expression" => {
21793 ::treesitter_types::runtime::maybe_grow_stack(|| <OffsetofExpression as ::treesitter_types::FromNode>::from_node(
21794 node,
21795 src,
21796 ))
21797 .map(Self::OffsetofExpression)
21798 .unwrap_or(Self::Unknown(node))
21799 }
21800 "operator_cast" => {
21801 ::treesitter_types::runtime::maybe_grow_stack(|| <OperatorCast as ::treesitter_types::FromNode>::from_node(
21802 node,
21803 src,
21804 ))
21805 .map(Self::OperatorCast)
21806 .unwrap_or(Self::Unknown(node))
21807 }
21808 "operator_name" => {
21809 ::treesitter_types::runtime::maybe_grow_stack(|| <OperatorName as ::treesitter_types::FromNode>::from_node(
21810 node,
21811 src,
21812 ))
21813 .map(Self::OperatorName)
21814 .unwrap_or(Self::Unknown(node))
21815 }
21816 "optional_parameter_declaration" => {
21817 ::treesitter_types::runtime::maybe_grow_stack(|| <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(
21818 node,
21819 src,
21820 ))
21821 .map(Self::OptionalParameterDeclaration)
21822 .unwrap_or(Self::Unknown(node))
21823 }
21824 "optional_type_parameter_declaration" => {
21825 ::treesitter_types::runtime::maybe_grow_stack(|| <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
21826 node,
21827 src,
21828 ))
21829 .map(Self::OptionalTypeParameterDeclaration)
21830 .unwrap_or(Self::Unknown(node))
21831 }
21832 "parameter_declaration" => {
21833 ::treesitter_types::runtime::maybe_grow_stack(|| <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(
21834 node,
21835 src,
21836 ))
21837 .map(Self::ParameterDeclaration)
21838 .unwrap_or(Self::Unknown(node))
21839 }
21840 "parameter_list" => {
21841 ::treesitter_types::runtime::maybe_grow_stack(|| <ParameterList as ::treesitter_types::FromNode>::from_node(
21842 node,
21843 src,
21844 ))
21845 .map(Self::ParameterList)
21846 .unwrap_or(Self::Unknown(node))
21847 }
21848 "parameter_pack_expansion" => {
21849 ::treesitter_types::runtime::maybe_grow_stack(|| <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(
21850 node,
21851 src,
21852 ))
21853 .map(Self::ParameterPackExpansion)
21854 .unwrap_or(Self::Unknown(node))
21855 }
21856 "parenthesized_declarator" => {
21857 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
21858 node,
21859 src,
21860 ))
21861 .map(Self::ParenthesizedDeclarator)
21862 .unwrap_or(Self::Unknown(node))
21863 }
21864 "parenthesized_expression" => {
21865 ::treesitter_types::runtime::maybe_grow_stack(|| <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
21866 node,
21867 src,
21868 ))
21869 .map(Self::ParenthesizedExpression)
21870 .unwrap_or(Self::Unknown(node))
21871 }
21872 "placeholder_type_specifier" => {
21873 ::treesitter_types::runtime::maybe_grow_stack(|| <PlaceholderTypeSpecifier as ::treesitter_types::FromNode>::from_node(
21874 node,
21875 src,
21876 ))
21877 .map(Self::PlaceholderTypeSpecifier)
21878 .unwrap_or(Self::Unknown(node))
21879 }
21880 "pointer_declarator" => {
21881 ::treesitter_types::runtime::maybe_grow_stack(|| <PointerDeclarator as ::treesitter_types::FromNode>::from_node(
21882 node,
21883 src,
21884 ))
21885 .map(Self::PointerDeclarator)
21886 .unwrap_or(Self::Unknown(node))
21887 }
21888 "pointer_expression" => {
21889 ::treesitter_types::runtime::maybe_grow_stack(|| <PointerExpression as ::treesitter_types::FromNode>::from_node(
21890 node,
21891 src,
21892 ))
21893 .map(Self::PointerExpression)
21894 .unwrap_or(Self::Unknown(node))
21895 }
21896 "pointer_type_declarator" => {
21897 ::treesitter_types::runtime::maybe_grow_stack(|| <PointerTypeDeclarator as ::treesitter_types::FromNode>::from_node(
21898 node,
21899 src,
21900 ))
21901 .map(Self::PointerTypeDeclarator)
21902 .unwrap_or(Self::Unknown(node))
21903 }
21904 "preproc_call" => {
21905 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocCall as ::treesitter_types::FromNode>::from_node(
21906 node,
21907 src,
21908 ))
21909 .map(Self::PreprocCall)
21910 .unwrap_or(Self::Unknown(node))
21911 }
21912 "preproc_def" => {
21913 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocDef as ::treesitter_types::FromNode>::from_node(
21914 node,
21915 src,
21916 ))
21917 .map(Self::PreprocDef)
21918 .unwrap_or(Self::Unknown(node))
21919 }
21920 "preproc_defined" => {
21921 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocDefined as ::treesitter_types::FromNode>::from_node(
21922 node,
21923 src,
21924 ))
21925 .map(Self::PreprocDefined)
21926 .unwrap_or(Self::Unknown(node))
21927 }
21928 "preproc_elif" => {
21929 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocElif as ::treesitter_types::FromNode>::from_node(
21930 node,
21931 src,
21932 ))
21933 .map(Self::PreprocElif)
21934 .unwrap_or(Self::Unknown(node))
21935 }
21936 "preproc_elifdef" => {
21937 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocElifdef as ::treesitter_types::FromNode>::from_node(
21938 node,
21939 src,
21940 ))
21941 .map(Self::PreprocElifdef)
21942 .unwrap_or(Self::Unknown(node))
21943 }
21944 "preproc_else" => {
21945 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocElse as ::treesitter_types::FromNode>::from_node(
21946 node,
21947 src,
21948 ))
21949 .map(Self::PreprocElse)
21950 .unwrap_or(Self::Unknown(node))
21951 }
21952 "preproc_function_def" => {
21953 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(
21954 node,
21955 src,
21956 ))
21957 .map(Self::PreprocFunctionDef)
21958 .unwrap_or(Self::Unknown(node))
21959 }
21960 "preproc_if" => {
21961 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocIf as ::treesitter_types::FromNode>::from_node(
21962 node,
21963 src,
21964 ))
21965 .map(Self::PreprocIf)
21966 .unwrap_or(Self::Unknown(node))
21967 }
21968 "preproc_ifdef" => {
21969 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocIfdef as ::treesitter_types::FromNode>::from_node(
21970 node,
21971 src,
21972 ))
21973 .map(Self::PreprocIfdef)
21974 .unwrap_or(Self::Unknown(node))
21975 }
21976 "preproc_include" => {
21977 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocInclude as ::treesitter_types::FromNode>::from_node(
21978 node,
21979 src,
21980 ))
21981 .map(Self::PreprocInclude)
21982 .unwrap_or(Self::Unknown(node))
21983 }
21984 "preproc_params" => {
21985 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocParams as ::treesitter_types::FromNode>::from_node(
21986 node,
21987 src,
21988 ))
21989 .map(Self::PreprocParams)
21990 .unwrap_or(Self::Unknown(node))
21991 }
21992 "pure_virtual_clause" => {
21993 ::treesitter_types::runtime::maybe_grow_stack(|| <PureVirtualClause as ::treesitter_types::FromNode>::from_node(
21994 node,
21995 src,
21996 ))
21997 .map(Self::PureVirtualClause)
21998 .unwrap_or(Self::Unknown(node))
21999 }
22000 "qualified_identifier" => {
22001 ::treesitter_types::runtime::maybe_grow_stack(|| <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(
22002 node,
22003 src,
22004 ))
22005 .map(Self::QualifiedIdentifier)
22006 .unwrap_or(Self::Unknown(node))
22007 }
22008 "raw_string_literal" => {
22009 ::treesitter_types::runtime::maybe_grow_stack(|| <RawStringLiteral as ::treesitter_types::FromNode>::from_node(
22010 node,
22011 src,
22012 ))
22013 .map(Self::RawStringLiteral)
22014 .unwrap_or(Self::Unknown(node))
22015 }
22016 "ref_qualifier" => {
22017 ::treesitter_types::runtime::maybe_grow_stack(|| <RefQualifier as ::treesitter_types::FromNode>::from_node(
22018 node,
22019 src,
22020 ))
22021 .map(Self::RefQualifier)
22022 .unwrap_or(Self::Unknown(node))
22023 }
22024 "reference_declarator" => {
22025 ::treesitter_types::runtime::maybe_grow_stack(|| <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
22026 node,
22027 src,
22028 ))
22029 .map(Self::ReferenceDeclarator)
22030 .unwrap_or(Self::Unknown(node))
22031 }
22032 "requirement_seq" => {
22033 ::treesitter_types::runtime::maybe_grow_stack(|| <RequirementSeq as ::treesitter_types::FromNode>::from_node(
22034 node,
22035 src,
22036 ))
22037 .map(Self::RequirementSeq)
22038 .unwrap_or(Self::Unknown(node))
22039 }
22040 "requires_clause" => {
22041 ::treesitter_types::runtime::maybe_grow_stack(|| <RequiresClause as ::treesitter_types::FromNode>::from_node(
22042 node,
22043 src,
22044 ))
22045 .map(Self::RequiresClause)
22046 .unwrap_or(Self::Unknown(node))
22047 }
22048 "requires_expression" => {
22049 ::treesitter_types::runtime::maybe_grow_stack(|| <RequiresExpression as ::treesitter_types::FromNode>::from_node(
22050 node,
22051 src,
22052 ))
22053 .map(Self::RequiresExpression)
22054 .unwrap_or(Self::Unknown(node))
22055 }
22056 "return_statement" => {
22057 ::treesitter_types::runtime::maybe_grow_stack(|| <ReturnStatement as ::treesitter_types::FromNode>::from_node(
22058 node,
22059 src,
22060 ))
22061 .map(Self::ReturnStatement)
22062 .unwrap_or(Self::Unknown(node))
22063 }
22064 "seh_except_clause" => {
22065 ::treesitter_types::runtime::maybe_grow_stack(|| <SehExceptClause as ::treesitter_types::FromNode>::from_node(
22066 node,
22067 src,
22068 ))
22069 .map(Self::SehExceptClause)
22070 .unwrap_or(Self::Unknown(node))
22071 }
22072 "seh_finally_clause" => {
22073 ::treesitter_types::runtime::maybe_grow_stack(|| <SehFinallyClause as ::treesitter_types::FromNode>::from_node(
22074 node,
22075 src,
22076 ))
22077 .map(Self::SehFinallyClause)
22078 .unwrap_or(Self::Unknown(node))
22079 }
22080 "seh_leave_statement" => {
22081 ::treesitter_types::runtime::maybe_grow_stack(|| <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(
22082 node,
22083 src,
22084 ))
22085 .map(Self::SehLeaveStatement)
22086 .unwrap_or(Self::Unknown(node))
22087 }
22088 "seh_try_statement" => {
22089 ::treesitter_types::runtime::maybe_grow_stack(|| <SehTryStatement as ::treesitter_types::FromNode>::from_node(
22090 node,
22091 src,
22092 ))
22093 .map(Self::SehTryStatement)
22094 .unwrap_or(Self::Unknown(node))
22095 }
22096 "simple_requirement" => {
22097 ::treesitter_types::runtime::maybe_grow_stack(|| <SimpleRequirement as ::treesitter_types::FromNode>::from_node(
22098 node,
22099 src,
22100 ))
22101 .map(Self::SimpleRequirement)
22102 .unwrap_or(Self::Unknown(node))
22103 }
22104 "sized_type_specifier" => {
22105 ::treesitter_types::runtime::maybe_grow_stack(|| <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(
22106 node,
22107 src,
22108 ))
22109 .map(Self::SizedTypeSpecifier)
22110 .unwrap_or(Self::Unknown(node))
22111 }
22112 "sizeof_expression" => {
22113 ::treesitter_types::runtime::maybe_grow_stack(|| <SizeofExpression as ::treesitter_types::FromNode>::from_node(
22114 node,
22115 src,
22116 ))
22117 .map(Self::SizeofExpression)
22118 .unwrap_or(Self::Unknown(node))
22119 }
22120 "static_assert_declaration" => {
22121 ::treesitter_types::runtime::maybe_grow_stack(|| <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
22122 node,
22123 src,
22124 ))
22125 .map(Self::StaticAssertDeclaration)
22126 .unwrap_or(Self::Unknown(node))
22127 }
22128 "storage_class_specifier" => {
22129 ::treesitter_types::runtime::maybe_grow_stack(|| <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(
22130 node,
22131 src,
22132 ))
22133 .map(Self::StorageClassSpecifier)
22134 .unwrap_or(Self::Unknown(node))
22135 }
22136 "string_literal" => {
22137 ::treesitter_types::runtime::maybe_grow_stack(|| <StringLiteral as ::treesitter_types::FromNode>::from_node(
22138 node,
22139 src,
22140 ))
22141 .map(Self::StringLiteral)
22142 .unwrap_or(Self::Unknown(node))
22143 }
22144 "struct_specifier" => {
22145 ::treesitter_types::runtime::maybe_grow_stack(|| <StructSpecifier as ::treesitter_types::FromNode>::from_node(
22146 node,
22147 src,
22148 ))
22149 .map(Self::StructSpecifier)
22150 .unwrap_or(Self::Unknown(node))
22151 }
22152 "structured_binding_declarator" => {
22153 ::treesitter_types::runtime::maybe_grow_stack(|| <StructuredBindingDeclarator as ::treesitter_types::FromNode>::from_node(
22154 node,
22155 src,
22156 ))
22157 .map(Self::StructuredBindingDeclarator)
22158 .unwrap_or(Self::Unknown(node))
22159 }
22160 "subscript_argument_list" => {
22161 ::treesitter_types::runtime::maybe_grow_stack(|| <SubscriptArgumentList as ::treesitter_types::FromNode>::from_node(
22162 node,
22163 src,
22164 ))
22165 .map(Self::SubscriptArgumentList)
22166 .unwrap_or(Self::Unknown(node))
22167 }
22168 "subscript_designator" => {
22169 ::treesitter_types::runtime::maybe_grow_stack(|| <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(
22170 node,
22171 src,
22172 ))
22173 .map(Self::SubscriptDesignator)
22174 .unwrap_or(Self::Unknown(node))
22175 }
22176 "subscript_expression" => {
22177 ::treesitter_types::runtime::maybe_grow_stack(|| <SubscriptExpression as ::treesitter_types::FromNode>::from_node(
22178 node,
22179 src,
22180 ))
22181 .map(Self::SubscriptExpression)
22182 .unwrap_or(Self::Unknown(node))
22183 }
22184 "subscript_range_designator" => {
22185 ::treesitter_types::runtime::maybe_grow_stack(|| <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(
22186 node,
22187 src,
22188 ))
22189 .map(Self::SubscriptRangeDesignator)
22190 .unwrap_or(Self::Unknown(node))
22191 }
22192 "switch_statement" => {
22193 ::treesitter_types::runtime::maybe_grow_stack(|| <SwitchStatement as ::treesitter_types::FromNode>::from_node(
22194 node,
22195 src,
22196 ))
22197 .map(Self::SwitchStatement)
22198 .unwrap_or(Self::Unknown(node))
22199 }
22200 "template_argument_list" => {
22201 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(
22202 node,
22203 src,
22204 ))
22205 .map(Self::TemplateArgumentList)
22206 .unwrap_or(Self::Unknown(node))
22207 }
22208 "template_declaration" => {
22209 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(
22210 node,
22211 src,
22212 ))
22213 .map(Self::TemplateDeclaration)
22214 .unwrap_or(Self::Unknown(node))
22215 }
22216 "template_function" => {
22217 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateFunction as ::treesitter_types::FromNode>::from_node(
22218 node,
22219 src,
22220 ))
22221 .map(Self::TemplateFunction)
22222 .unwrap_or(Self::Unknown(node))
22223 }
22224 "template_instantiation" => {
22225 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(
22226 node,
22227 src,
22228 ))
22229 .map(Self::TemplateInstantiation)
22230 .unwrap_or(Self::Unknown(node))
22231 }
22232 "template_method" => {
22233 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateMethod as ::treesitter_types::FromNode>::from_node(
22234 node,
22235 src,
22236 ))
22237 .map(Self::TemplateMethod)
22238 .unwrap_or(Self::Unknown(node))
22239 }
22240 "template_parameter_list" => {
22241 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateParameterList as ::treesitter_types::FromNode>::from_node(
22242 node,
22243 src,
22244 ))
22245 .map(Self::TemplateParameterList)
22246 .unwrap_or(Self::Unknown(node))
22247 }
22248 "template_template_parameter_declaration" => {
22249 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateTemplateParameterDeclaration as ::treesitter_types::FromNode>::from_node(
22250 node,
22251 src,
22252 ))
22253 .map(Self::TemplateTemplateParameterDeclaration)
22254 .unwrap_or(Self::Unknown(node))
22255 }
22256 "template_type" => {
22257 ::treesitter_types::runtime::maybe_grow_stack(|| <TemplateType as ::treesitter_types::FromNode>::from_node(
22258 node,
22259 src,
22260 ))
22261 .map(Self::TemplateType)
22262 .unwrap_or(Self::Unknown(node))
22263 }
22264 "throw_specifier" => {
22265 ::treesitter_types::runtime::maybe_grow_stack(|| <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(
22266 node,
22267 src,
22268 ))
22269 .map(Self::ThrowSpecifier)
22270 .unwrap_or(Self::Unknown(node))
22271 }
22272 "throw_statement" => {
22273 ::treesitter_types::runtime::maybe_grow_stack(|| <ThrowStatement as ::treesitter_types::FromNode>::from_node(
22274 node,
22275 src,
22276 ))
22277 .map(Self::ThrowStatement)
22278 .unwrap_or(Self::Unknown(node))
22279 }
22280 "trailing_return_type" => {
22281 ::treesitter_types::runtime::maybe_grow_stack(|| <TrailingReturnType as ::treesitter_types::FromNode>::from_node(
22282 node,
22283 src,
22284 ))
22285 .map(Self::TrailingReturnType)
22286 .unwrap_or(Self::Unknown(node))
22287 }
22288 "translation_unit" => {
22289 ::treesitter_types::runtime::maybe_grow_stack(|| <TranslationUnit as ::treesitter_types::FromNode>::from_node(
22290 node,
22291 src,
22292 ))
22293 .map(Self::TranslationUnit)
22294 .unwrap_or(Self::Unknown(node))
22295 }
22296 "try_statement" => {
22297 ::treesitter_types::runtime::maybe_grow_stack(|| <TryStatement as ::treesitter_types::FromNode>::from_node(
22298 node,
22299 src,
22300 ))
22301 .map(Self::TryStatement)
22302 .unwrap_or(Self::Unknown(node))
22303 }
22304 "type_definition" => {
22305 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeDefinition as ::treesitter_types::FromNode>::from_node(
22306 node,
22307 src,
22308 ))
22309 .map(Self::TypeDefinition)
22310 .unwrap_or(Self::Unknown(node))
22311 }
22312 "type_descriptor" => {
22313 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeDescriptor as ::treesitter_types::FromNode>::from_node(
22314 node,
22315 src,
22316 ))
22317 .map(Self::TypeDescriptor)
22318 .unwrap_or(Self::Unknown(node))
22319 }
22320 "type_parameter_declaration" => {
22321 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
22322 node,
22323 src,
22324 ))
22325 .map(Self::TypeParameterDeclaration)
22326 .unwrap_or(Self::Unknown(node))
22327 }
22328 "type_qualifier" => {
22329 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeQualifier as ::treesitter_types::FromNode>::from_node(
22330 node,
22331 src,
22332 ))
22333 .map(Self::TypeQualifier)
22334 .unwrap_or(Self::Unknown(node))
22335 }
22336 "type_requirement" => {
22337 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeRequirement as ::treesitter_types::FromNode>::from_node(
22338 node,
22339 src,
22340 ))
22341 .map(Self::TypeRequirement)
22342 .unwrap_or(Self::Unknown(node))
22343 }
22344 "unary_expression" => {
22345 ::treesitter_types::runtime::maybe_grow_stack(|| <UnaryExpression as ::treesitter_types::FromNode>::from_node(
22346 node,
22347 src,
22348 ))
22349 .map(Self::UnaryExpression)
22350 .unwrap_or(Self::Unknown(node))
22351 }
22352 "union_specifier" => {
22353 ::treesitter_types::runtime::maybe_grow_stack(|| <UnionSpecifier as ::treesitter_types::FromNode>::from_node(
22354 node,
22355 src,
22356 ))
22357 .map(Self::UnionSpecifier)
22358 .unwrap_or(Self::Unknown(node))
22359 }
22360 "update_expression" => {
22361 ::treesitter_types::runtime::maybe_grow_stack(|| <UpdateExpression as ::treesitter_types::FromNode>::from_node(
22362 node,
22363 src,
22364 ))
22365 .map(Self::UpdateExpression)
22366 .unwrap_or(Self::Unknown(node))
22367 }
22368 "user_defined_literal" => {
22369 ::treesitter_types::runtime::maybe_grow_stack(|| <UserDefinedLiteral as ::treesitter_types::FromNode>::from_node(
22370 node,
22371 src,
22372 ))
22373 .map(Self::UserDefinedLiteral)
22374 .unwrap_or(Self::Unknown(node))
22375 }
22376 "using_declaration" => {
22377 ::treesitter_types::runtime::maybe_grow_stack(|| <UsingDeclaration as ::treesitter_types::FromNode>::from_node(
22378 node,
22379 src,
22380 ))
22381 .map(Self::UsingDeclaration)
22382 .unwrap_or(Self::Unknown(node))
22383 }
22384 "variadic_declarator" => {
22385 ::treesitter_types::runtime::maybe_grow_stack(|| <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(
22386 node,
22387 src,
22388 ))
22389 .map(Self::VariadicDeclarator)
22390 .unwrap_or(Self::Unknown(node))
22391 }
22392 "variadic_parameter_declaration" => {
22393 ::treesitter_types::runtime::maybe_grow_stack(|| <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
22394 node,
22395 src,
22396 ))
22397 .map(Self::VariadicParameterDeclaration)
22398 .unwrap_or(Self::Unknown(node))
22399 }
22400 "variadic_type_parameter_declaration" => {
22401 ::treesitter_types::runtime::maybe_grow_stack(|| <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
22402 node,
22403 src,
22404 ))
22405 .map(Self::VariadicTypeParameterDeclaration)
22406 .unwrap_or(Self::Unknown(node))
22407 }
22408 "virtual_specifier" => {
22409 ::treesitter_types::runtime::maybe_grow_stack(|| <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(
22410 node,
22411 src,
22412 ))
22413 .map(Self::VirtualSpecifier)
22414 .unwrap_or(Self::Unknown(node))
22415 }
22416 "while_statement" => {
22417 ::treesitter_types::runtime::maybe_grow_stack(|| <WhileStatement as ::treesitter_types::FromNode>::from_node(
22418 node,
22419 src,
22420 ))
22421 .map(Self::WhileStatement)
22422 .unwrap_or(Self::Unknown(node))
22423 }
22424 "auto" => {
22425 ::treesitter_types::runtime::maybe_grow_stack(|| <Auto as ::treesitter_types::FromNode>::from_node(
22426 node,
22427 src,
22428 ))
22429 .map(Self::Auto)
22430 .unwrap_or(Self::Unknown(node))
22431 }
22432 "character" => {
22433 ::treesitter_types::runtime::maybe_grow_stack(|| <Character as ::treesitter_types::FromNode>::from_node(
22434 node,
22435 src,
22436 ))
22437 .map(Self::Character)
22438 .unwrap_or(Self::Unknown(node))
22439 }
22440 "comment" => {
22441 ::treesitter_types::runtime::maybe_grow_stack(|| <Comment as ::treesitter_types::FromNode>::from_node(
22442 node,
22443 src,
22444 ))
22445 .map(Self::Comment)
22446 .unwrap_or(Self::Unknown(node))
22447 }
22448 "escape_sequence" => {
22449 ::treesitter_types::runtime::maybe_grow_stack(|| <EscapeSequence as ::treesitter_types::FromNode>::from_node(
22450 node,
22451 src,
22452 ))
22453 .map(Self::EscapeSequence)
22454 .unwrap_or(Self::Unknown(node))
22455 }
22456 "false" => {
22457 ::treesitter_types::runtime::maybe_grow_stack(|| <False as ::treesitter_types::FromNode>::from_node(
22458 node,
22459 src,
22460 ))
22461 .map(Self::False)
22462 .unwrap_or(Self::Unknown(node))
22463 }
22464 "field_identifier" => {
22465 ::treesitter_types::runtime::maybe_grow_stack(|| <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
22466 node,
22467 src,
22468 ))
22469 .map(Self::FieldIdentifier)
22470 .unwrap_or(Self::Unknown(node))
22471 }
22472 "identifier" => {
22473 ::treesitter_types::runtime::maybe_grow_stack(|| <Identifier as ::treesitter_types::FromNode>::from_node(
22474 node,
22475 src,
22476 ))
22477 .map(Self::Identifier)
22478 .unwrap_or(Self::Unknown(node))
22479 }
22480 "literal_suffix" => {
22481 ::treesitter_types::runtime::maybe_grow_stack(|| <LiteralSuffix as ::treesitter_types::FromNode>::from_node(
22482 node,
22483 src,
22484 ))
22485 .map(Self::LiteralSuffix)
22486 .unwrap_or(Self::Unknown(node))
22487 }
22488 "ms_restrict_modifier" => {
22489 ::treesitter_types::runtime::maybe_grow_stack(|| <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(
22490 node,
22491 src,
22492 ))
22493 .map(Self::MsRestrictModifier)
22494 .unwrap_or(Self::Unknown(node))
22495 }
22496 "ms_signed_ptr_modifier" => {
22497 ::treesitter_types::runtime::maybe_grow_stack(|| <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(
22498 node,
22499 src,
22500 ))
22501 .map(Self::MsSignedPtrModifier)
22502 .unwrap_or(Self::Unknown(node))
22503 }
22504 "ms_unsigned_ptr_modifier" => {
22505 ::treesitter_types::runtime::maybe_grow_stack(|| <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(
22506 node,
22507 src,
22508 ))
22509 .map(Self::MsUnsignedPtrModifier)
22510 .unwrap_or(Self::Unknown(node))
22511 }
22512 "namespace_identifier" => {
22513 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(
22514 node,
22515 src,
22516 ))
22517 .map(Self::NamespaceIdentifier)
22518 .unwrap_or(Self::Unknown(node))
22519 }
22520 "number_literal" => {
22521 ::treesitter_types::runtime::maybe_grow_stack(|| <NumberLiteral as ::treesitter_types::FromNode>::from_node(
22522 node,
22523 src,
22524 ))
22525 .map(Self::NumberLiteral)
22526 .unwrap_or(Self::Unknown(node))
22527 }
22528 "preproc_arg" => {
22529 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocArg as ::treesitter_types::FromNode>::from_node(
22530 node,
22531 src,
22532 ))
22533 .map(Self::PreprocArg)
22534 .unwrap_or(Self::Unknown(node))
22535 }
22536 "preproc_directive" => {
22537 ::treesitter_types::runtime::maybe_grow_stack(|| <PreprocDirective as ::treesitter_types::FromNode>::from_node(
22538 node,
22539 src,
22540 ))
22541 .map(Self::PreprocDirective)
22542 .unwrap_or(Self::Unknown(node))
22543 }
22544 "primitive_type" => {
22545 ::treesitter_types::runtime::maybe_grow_stack(|| <PrimitiveType as ::treesitter_types::FromNode>::from_node(
22546 node,
22547 src,
22548 ))
22549 .map(Self::PrimitiveType)
22550 .unwrap_or(Self::Unknown(node))
22551 }
22552 "raw_string_content" => {
22553 ::treesitter_types::runtime::maybe_grow_stack(|| <RawStringContent as ::treesitter_types::FromNode>::from_node(
22554 node,
22555 src,
22556 ))
22557 .map(Self::RawStringContent)
22558 .unwrap_or(Self::Unknown(node))
22559 }
22560 "raw_string_delimiter" => {
22561 ::treesitter_types::runtime::maybe_grow_stack(|| <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(
22562 node,
22563 src,
22564 ))
22565 .map(Self::RawStringDelimiter)
22566 .unwrap_or(Self::Unknown(node))
22567 }
22568 "statement_identifier" => {
22569 ::treesitter_types::runtime::maybe_grow_stack(|| <StatementIdentifier as ::treesitter_types::FromNode>::from_node(
22570 node,
22571 src,
22572 ))
22573 .map(Self::StatementIdentifier)
22574 .unwrap_or(Self::Unknown(node))
22575 }
22576 "string_content" => {
22577 ::treesitter_types::runtime::maybe_grow_stack(|| <StringContent as ::treesitter_types::FromNode>::from_node(
22578 node,
22579 src,
22580 ))
22581 .map(Self::StringContent)
22582 .unwrap_or(Self::Unknown(node))
22583 }
22584 "system_lib_string" => {
22585 ::treesitter_types::runtime::maybe_grow_stack(|| <SystemLibString as ::treesitter_types::FromNode>::from_node(
22586 node,
22587 src,
22588 ))
22589 .map(Self::SystemLibString)
22590 .unwrap_or(Self::Unknown(node))
22591 }
22592 "this" => {
22593 ::treesitter_types::runtime::maybe_grow_stack(|| <This as ::treesitter_types::FromNode>::from_node(
22594 node,
22595 src,
22596 ))
22597 .map(Self::This)
22598 .unwrap_or(Self::Unknown(node))
22599 }
22600 "true" => {
22601 ::treesitter_types::runtime::maybe_grow_stack(|| <True as ::treesitter_types::FromNode>::from_node(
22602 node,
22603 src,
22604 ))
22605 .map(Self::True)
22606 .unwrap_or(Self::Unknown(node))
22607 }
22608 "type_identifier" => {
22609 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeIdentifier as ::treesitter_types::FromNode>::from_node(
22610 node,
22611 src,
22612 ))
22613 .map(Self::TypeIdentifier)
22614 .unwrap_or(Self::Unknown(node))
22615 }
22616 _ => Self::Unknown(node),
22617 }
22618 }
22619}
22620impl ::treesitter_types::Spanned for AnyNode<'_> {
22621 fn span(&self) -> ::treesitter_types::Span {
22622 match self {
22623 Self::AbstractDeclarator(inner) => inner.span(),
22624 Self::Declarator(inner) => inner.span(),
22625 Self::FieldDeclarator(inner) => inner.span(),
22626 Self::TypeDeclarator(inner) => inner.span(),
22627 Self::Expression(inner) => inner.span(),
22628 Self::Statement(inner) => inner.span(),
22629 Self::TypeSpecifier(inner) => inner.span(),
22630 Self::AbstractArrayDeclarator(inner) => inner.span(),
22631 Self::AbstractFunctionDeclarator(inner) => inner.span(),
22632 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
22633 Self::AbstractPointerDeclarator(inner) => inner.span(),
22634 Self::AbstractReferenceDeclarator(inner) => inner.span(),
22635 Self::AccessSpecifier(inner) => inner.span(),
22636 Self::AliasDeclaration(inner) => inner.span(),
22637 Self::AlignasQualifier(inner) => inner.span(),
22638 Self::AlignofExpression(inner) => inner.span(),
22639 Self::ArgumentList(inner) => inner.span(),
22640 Self::ArrayDeclarator(inner) => inner.span(),
22641 Self::AssignmentExpression(inner) => inner.span(),
22642 Self::Attribute(inner) => inner.span(),
22643 Self::AttributeDeclaration(inner) => inner.span(),
22644 Self::AttributeSpecifier(inner) => inner.span(),
22645 Self::AttributedDeclarator(inner) => inner.span(),
22646 Self::AttributedStatement(inner) => inner.span(),
22647 Self::BaseClassClause(inner) => inner.span(),
22648 Self::BinaryExpression(inner) => inner.span(),
22649 Self::BitfieldClause(inner) => inner.span(),
22650 Self::BreakStatement(inner) => inner.span(),
22651 Self::CallExpression(inner) => inner.span(),
22652 Self::CaseStatement(inner) => inner.span(),
22653 Self::CastExpression(inner) => inner.span(),
22654 Self::CatchClause(inner) => inner.span(),
22655 Self::CharLiteral(inner) => inner.span(),
22656 Self::ClassSpecifier(inner) => inner.span(),
22657 Self::CoAwaitExpression(inner) => inner.span(),
22658 Self::CoReturnStatement(inner) => inner.span(),
22659 Self::CoYieldStatement(inner) => inner.span(),
22660 Self::CommaExpression(inner) => inner.span(),
22661 Self::CompoundLiteralExpression(inner) => inner.span(),
22662 Self::CompoundRequirement(inner) => inner.span(),
22663 Self::CompoundStatement(inner) => inner.span(),
22664 Self::ConcatenatedString(inner) => inner.span(),
22665 Self::ConceptDefinition(inner) => inner.span(),
22666 Self::ConditionClause(inner) => inner.span(),
22667 Self::ConditionalExpression(inner) => inner.span(),
22668 Self::ConstraintConjunction(inner) => inner.span(),
22669 Self::ConstraintDisjunction(inner) => inner.span(),
22670 Self::ContinueStatement(inner) => inner.span(),
22671 Self::Declaration(inner) => inner.span(),
22672 Self::DeclarationList(inner) => inner.span(),
22673 Self::Decltype(inner) => inner.span(),
22674 Self::DefaultMethodClause(inner) => inner.span(),
22675 Self::DeleteExpression(inner) => inner.span(),
22676 Self::DeleteMethodClause(inner) => inner.span(),
22677 Self::DependentName(inner) => inner.span(),
22678 Self::DependentType(inner) => inner.span(),
22679 Self::DestructorName(inner) => inner.span(),
22680 Self::DoStatement(inner) => inner.span(),
22681 Self::ElseClause(inner) => inner.span(),
22682 Self::EnumSpecifier(inner) => inner.span(),
22683 Self::Enumerator(inner) => inner.span(),
22684 Self::EnumeratorList(inner) => inner.span(),
22685 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
22686 Self::ExpressionStatement(inner) => inner.span(),
22687 Self::ExtensionExpression(inner) => inner.span(),
22688 Self::FieldDeclaration(inner) => inner.span(),
22689 Self::FieldDeclarationList(inner) => inner.span(),
22690 Self::FieldDesignator(inner) => inner.span(),
22691 Self::FieldExpression(inner) => inner.span(),
22692 Self::FieldInitializer(inner) => inner.span(),
22693 Self::FieldInitializerList(inner) => inner.span(),
22694 Self::FoldExpression(inner) => inner.span(),
22695 Self::ForRangeLoop(inner) => inner.span(),
22696 Self::ForStatement(inner) => inner.span(),
22697 Self::FriendDeclaration(inner) => inner.span(),
22698 Self::FunctionDeclarator(inner) => inner.span(),
22699 Self::FunctionDefinition(inner) => inner.span(),
22700 Self::GenericExpression(inner) => inner.span(),
22701 Self::GnuAsmClobberList(inner) => inner.span(),
22702 Self::GnuAsmExpression(inner) => inner.span(),
22703 Self::GnuAsmGotoList(inner) => inner.span(),
22704 Self::GnuAsmInputOperand(inner) => inner.span(),
22705 Self::GnuAsmInputOperandList(inner) => inner.span(),
22706 Self::GnuAsmOutputOperand(inner) => inner.span(),
22707 Self::GnuAsmOutputOperandList(inner) => inner.span(),
22708 Self::GnuAsmQualifier(inner) => inner.span(),
22709 Self::GotoStatement(inner) => inner.span(),
22710 Self::IfStatement(inner) => inner.span(),
22711 Self::InitDeclarator(inner) => inner.span(),
22712 Self::InitStatement(inner) => inner.span(),
22713 Self::InitializerList(inner) => inner.span(),
22714 Self::InitializerPair(inner) => inner.span(),
22715 Self::LabeledStatement(inner) => inner.span(),
22716 Self::LambdaCaptureInitializer(inner) => inner.span(),
22717 Self::LambdaCaptureSpecifier(inner) => inner.span(),
22718 Self::LambdaDefaultCapture(inner) => inner.span(),
22719 Self::LambdaExpression(inner) => inner.span(),
22720 Self::LinkageSpecification(inner) => inner.span(),
22721 Self::MsBasedModifier(inner) => inner.span(),
22722 Self::MsCallModifier(inner) => inner.span(),
22723 Self::MsDeclspecModifier(inner) => inner.span(),
22724 Self::MsPointerModifier(inner) => inner.span(),
22725 Self::MsUnalignedPtrModifier(inner) => inner.span(),
22726 Self::NamespaceAliasDefinition(inner) => inner.span(),
22727 Self::NamespaceDefinition(inner) => inner.span(),
22728 Self::NestedNamespaceSpecifier(inner) => inner.span(),
22729 Self::NewDeclarator(inner) => inner.span(),
22730 Self::NewExpression(inner) => inner.span(),
22731 Self::Noexcept(inner) => inner.span(),
22732 Self::Null(inner) => inner.span(),
22733 Self::OffsetofExpression(inner) => inner.span(),
22734 Self::OperatorCast(inner) => inner.span(),
22735 Self::OperatorName(inner) => inner.span(),
22736 Self::OptionalParameterDeclaration(inner) => inner.span(),
22737 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
22738 Self::ParameterDeclaration(inner) => inner.span(),
22739 Self::ParameterList(inner) => inner.span(),
22740 Self::ParameterPackExpansion(inner) => inner.span(),
22741 Self::ParenthesizedDeclarator(inner) => inner.span(),
22742 Self::ParenthesizedExpression(inner) => inner.span(),
22743 Self::PlaceholderTypeSpecifier(inner) => inner.span(),
22744 Self::PointerDeclarator(inner) => inner.span(),
22745 Self::PointerExpression(inner) => inner.span(),
22746 Self::PointerTypeDeclarator(inner) => inner.span(),
22747 Self::PreprocCall(inner) => inner.span(),
22748 Self::PreprocDef(inner) => inner.span(),
22749 Self::PreprocDefined(inner) => inner.span(),
22750 Self::PreprocElif(inner) => inner.span(),
22751 Self::PreprocElifdef(inner) => inner.span(),
22752 Self::PreprocElse(inner) => inner.span(),
22753 Self::PreprocFunctionDef(inner) => inner.span(),
22754 Self::PreprocIf(inner) => inner.span(),
22755 Self::PreprocIfdef(inner) => inner.span(),
22756 Self::PreprocInclude(inner) => inner.span(),
22757 Self::PreprocParams(inner) => inner.span(),
22758 Self::PureVirtualClause(inner) => inner.span(),
22759 Self::QualifiedIdentifier(inner) => inner.span(),
22760 Self::RawStringLiteral(inner) => inner.span(),
22761 Self::RefQualifier(inner) => inner.span(),
22762 Self::ReferenceDeclarator(inner) => inner.span(),
22763 Self::RequirementSeq(inner) => inner.span(),
22764 Self::RequiresClause(inner) => inner.span(),
22765 Self::RequiresExpression(inner) => inner.span(),
22766 Self::ReturnStatement(inner) => inner.span(),
22767 Self::SehExceptClause(inner) => inner.span(),
22768 Self::SehFinallyClause(inner) => inner.span(),
22769 Self::SehLeaveStatement(inner) => inner.span(),
22770 Self::SehTryStatement(inner) => inner.span(),
22771 Self::SimpleRequirement(inner) => inner.span(),
22772 Self::SizedTypeSpecifier(inner) => inner.span(),
22773 Self::SizeofExpression(inner) => inner.span(),
22774 Self::StaticAssertDeclaration(inner) => inner.span(),
22775 Self::StorageClassSpecifier(inner) => inner.span(),
22776 Self::StringLiteral(inner) => inner.span(),
22777 Self::StructSpecifier(inner) => inner.span(),
22778 Self::StructuredBindingDeclarator(inner) => inner.span(),
22779 Self::SubscriptArgumentList(inner) => inner.span(),
22780 Self::SubscriptDesignator(inner) => inner.span(),
22781 Self::SubscriptExpression(inner) => inner.span(),
22782 Self::SubscriptRangeDesignator(inner) => inner.span(),
22783 Self::SwitchStatement(inner) => inner.span(),
22784 Self::TemplateArgumentList(inner) => inner.span(),
22785 Self::TemplateDeclaration(inner) => inner.span(),
22786 Self::TemplateFunction(inner) => inner.span(),
22787 Self::TemplateInstantiation(inner) => inner.span(),
22788 Self::TemplateMethod(inner) => inner.span(),
22789 Self::TemplateParameterList(inner) => inner.span(),
22790 Self::TemplateTemplateParameterDeclaration(inner) => inner.span(),
22791 Self::TemplateType(inner) => inner.span(),
22792 Self::ThrowSpecifier(inner) => inner.span(),
22793 Self::ThrowStatement(inner) => inner.span(),
22794 Self::TrailingReturnType(inner) => inner.span(),
22795 Self::TranslationUnit(inner) => inner.span(),
22796 Self::TryStatement(inner) => inner.span(),
22797 Self::TypeDefinition(inner) => inner.span(),
22798 Self::TypeDescriptor(inner) => inner.span(),
22799 Self::TypeParameterDeclaration(inner) => inner.span(),
22800 Self::TypeQualifier(inner) => inner.span(),
22801 Self::TypeRequirement(inner) => inner.span(),
22802 Self::UnaryExpression(inner) => inner.span(),
22803 Self::UnionSpecifier(inner) => inner.span(),
22804 Self::UpdateExpression(inner) => inner.span(),
22805 Self::UserDefinedLiteral(inner) => inner.span(),
22806 Self::UsingDeclaration(inner) => inner.span(),
22807 Self::VariadicDeclarator(inner) => inner.span(),
22808 Self::VariadicParameterDeclaration(inner) => inner.span(),
22809 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
22810 Self::VirtualSpecifier(inner) => inner.span(),
22811 Self::WhileStatement(inner) => inner.span(),
22812 Self::Auto(inner) => inner.span(),
22813 Self::Character(inner) => inner.span(),
22814 Self::Comment(inner) => inner.span(),
22815 Self::EscapeSequence(inner) => inner.span(),
22816 Self::False(inner) => inner.span(),
22817 Self::FieldIdentifier(inner) => inner.span(),
22818 Self::Identifier(inner) => inner.span(),
22819 Self::LiteralSuffix(inner) => inner.span(),
22820 Self::MsRestrictModifier(inner) => inner.span(),
22821 Self::MsSignedPtrModifier(inner) => inner.span(),
22822 Self::MsUnsignedPtrModifier(inner) => inner.span(),
22823 Self::NamespaceIdentifier(inner) => inner.span(),
22824 Self::NumberLiteral(inner) => inner.span(),
22825 Self::PreprocArg(inner) => inner.span(),
22826 Self::PreprocDirective(inner) => inner.span(),
22827 Self::PrimitiveType(inner) => inner.span(),
22828 Self::RawStringContent(inner) => inner.span(),
22829 Self::RawStringDelimiter(inner) => inner.span(),
22830 Self::StatementIdentifier(inner) => inner.span(),
22831 Self::StringContent(inner) => inner.span(),
22832 Self::SystemLibString(inner) => inner.span(),
22833 Self::This(inner) => inner.span(),
22834 Self::True(inner) => inner.span(),
22835 Self::TypeIdentifier(inner) => inner.span(),
22836 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
22837 }
22838 }
22839}