1#[derive(Debug, Clone)]
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: ::tree_sitter::Node<'tree>,
13 src: &'tree [u8],
14 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15 match node.kind() {
16 "abstract_array_declarator" => {
17 Ok(Self::AbstractArrayDeclarator(::std::boxed::Box::new(
18 <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(
19 node, src,
20 )?,
21 )))
22 }
23 "abstract_function_declarator" => {
24 Ok(Self::AbstractFunctionDeclarator(::std::boxed::Box::new(
25 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
26 node, src,
27 )?,
28 )))
29 }
30 "abstract_parenthesized_declarator" => Ok(Self::AbstractParenthesizedDeclarator(
31 ::std::boxed::Box::new(
32 <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
33 node, src,
34 )?,
35 ),
36 )),
37 "abstract_pointer_declarator" => {
38 Ok(Self::AbstractPointerDeclarator(::std::boxed::Box::new(
39 <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(
40 node, src,
41 )?,
42 )))
43 }
44 "abstract_reference_declarator" => {
45 Ok(Self::AbstractReferenceDeclarator(::std::boxed::Box::new(
46 <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
47 node, src,
48 )?,
49 )))
50 }
51 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
52 }
53 }
54}
55impl ::treesitter_types::Spanned for AbstractDeclarator<'_> {
56 fn span(&self) -> ::treesitter_types::Span {
57 match self {
58 Self::AbstractArrayDeclarator(inner) => inner.span(),
59 Self::AbstractFunctionDeclarator(inner) => inner.span(),
60 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
61 Self::AbstractPointerDeclarator(inner) => inner.span(),
62 Self::AbstractReferenceDeclarator(inner) => inner.span(),
63 }
64 }
65}
66#[derive(Debug, Clone)]
67pub enum Declarator<'tree> {
68 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
69 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
70 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
71 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
72 Identifier(::std::boxed::Box<Identifier<'tree>>),
73 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
74 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
75 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
76 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
77 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
78 StructuredBindingDeclarator(::std::boxed::Box<StructuredBindingDeclarator<'tree>>),
79 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
80}
81impl<'tree> ::treesitter_types::FromNode<'tree> for Declarator<'tree> {
82 #[allow(clippy::collapsible_else_if)]
83 fn from_node(
84 node: ::tree_sitter::Node<'tree>,
85 src: &'tree [u8],
86 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
87 match node.kind() {
88 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
89 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
90 ))),
91 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
92 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
93 ))),
94 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
95 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)?,
96 ))),
97 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
98 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
99 ))),
100 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
101 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
102 ))),
103 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
104 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)?,
105 ))),
106 "parenthesized_declarator" => {
107 Ok(Self::ParenthesizedDeclarator(::std::boxed::Box::new(
108 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
109 node, src,
110 )?,
111 )))
112 }
113 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
114 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
115 ))),
116 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
117 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
118 ))),
119 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
120 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
121 ))),
122 "structured_binding_declarator" => {
123 Ok(Self::StructuredBindingDeclarator(::std::boxed::Box::new(
124 <StructuredBindingDeclarator as ::treesitter_types::FromNode>::from_node(
125 node, src,
126 )?,
127 )))
128 }
129 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
130 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
131 ))),
132 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
133 }
134 }
135}
136impl ::treesitter_types::Spanned for Declarator<'_> {
137 fn span(&self) -> ::treesitter_types::Span {
138 match self {
139 Self::ArrayDeclarator(inner) => inner.span(),
140 Self::AttributedDeclarator(inner) => inner.span(),
141 Self::DestructorName(inner) => inner.span(),
142 Self::FunctionDeclarator(inner) => inner.span(),
143 Self::Identifier(inner) => inner.span(),
144 Self::OperatorName(inner) => inner.span(),
145 Self::ParenthesizedDeclarator(inner) => inner.span(),
146 Self::PointerDeclarator(inner) => inner.span(),
147 Self::QualifiedIdentifier(inner) => inner.span(),
148 Self::ReferenceDeclarator(inner) => inner.span(),
149 Self::StructuredBindingDeclarator(inner) => inner.span(),
150 Self::TemplateFunction(inner) => inner.span(),
151 }
152 }
153}
154#[derive(Debug, Clone)]
155pub enum FieldDeclarator<'tree> {
156 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
157 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
158 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
159 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
160 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
161 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
162 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
163 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
164 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
165}
166impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarator<'tree> {
167 #[allow(clippy::collapsible_else_if)]
168 fn from_node(
169 node: ::tree_sitter::Node<'tree>,
170 src: &'tree [u8],
171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
172 match node.kind() {
173 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
174 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
175 ))),
176 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
177 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
178 ))),
179 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
180 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
181 ))),
182 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
183 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
184 ))),
185 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
186 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)?,
187 ))),
188 "parenthesized_declarator" => {
189 Ok(Self::ParenthesizedDeclarator(::std::boxed::Box::new(
190 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
191 node, src,
192 )?,
193 )))
194 }
195 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
196 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
197 ))),
198 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
199 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
200 ))),
201 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
202 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
203 ))),
204 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
205 }
206 }
207}
208impl ::treesitter_types::Spanned for FieldDeclarator<'_> {
209 fn span(&self) -> ::treesitter_types::Span {
210 match self {
211 Self::ArrayDeclarator(inner) => inner.span(),
212 Self::AttributedDeclarator(inner) => inner.span(),
213 Self::FieldIdentifier(inner) => inner.span(),
214 Self::FunctionDeclarator(inner) => inner.span(),
215 Self::OperatorName(inner) => inner.span(),
216 Self::ParenthesizedDeclarator(inner) => inner.span(),
217 Self::PointerDeclarator(inner) => inner.span(),
218 Self::ReferenceDeclarator(inner) => inner.span(),
219 Self::TemplateMethod(inner) => inner.span(),
220 }
221 }
222}
223#[derive(Debug, Clone)]
224pub enum TypeDeclarator<'tree> {
225 ArrayDeclarator(::std::boxed::Box<ArrayDeclarator<'tree>>),
226 AttributedDeclarator(::std::boxed::Box<AttributedDeclarator<'tree>>),
227 FunctionDeclarator(::std::boxed::Box<FunctionDeclarator<'tree>>),
228 ParenthesizedDeclarator(::std::boxed::Box<ParenthesizedDeclarator<'tree>>),
229 PointerDeclarator(::std::boxed::Box<PointerDeclarator<'tree>>),
230 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
231 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
232 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
233}
234impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDeclarator<'tree> {
235 #[allow(clippy::collapsible_else_if)]
236 fn from_node(
237 node: ::tree_sitter::Node<'tree>,
238 src: &'tree [u8],
239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
240 match node.kind() {
241 "array_declarator" => Ok(Self::ArrayDeclarator(::std::boxed::Box::new(
242 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
243 ))),
244 "attributed_declarator" => Ok(Self::AttributedDeclarator(::std::boxed::Box::new(
245 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
246 ))),
247 "function_declarator" => Ok(Self::FunctionDeclarator(::std::boxed::Box::new(
248 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
249 ))),
250 "parenthesized_declarator" => {
251 Ok(Self::ParenthesizedDeclarator(::std::boxed::Box::new(
252 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
253 node, src,
254 )?,
255 )))
256 }
257 "pointer_declarator" => Ok(Self::PointerDeclarator(::std::boxed::Box::new(
258 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
259 ))),
260 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
261 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
262 ))),
263 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
264 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
265 ))),
266 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
267 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
268 ))),
269 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
270 }
271 }
272}
273impl ::treesitter_types::Spanned for TypeDeclarator<'_> {
274 fn span(&self) -> ::treesitter_types::Span {
275 match self {
276 Self::ArrayDeclarator(inner) => inner.span(),
277 Self::AttributedDeclarator(inner) => inner.span(),
278 Self::FunctionDeclarator(inner) => inner.span(),
279 Self::ParenthesizedDeclarator(inner) => inner.span(),
280 Self::PointerDeclarator(inner) => inner.span(),
281 Self::PrimitiveType(inner) => inner.span(),
282 Self::ReferenceDeclarator(inner) => inner.span(),
283 Self::TypeIdentifier(inner) => inner.span(),
284 }
285 }
286}
287#[derive(Debug, Clone)]
288pub enum Expression<'tree> {
289 AlignofExpression(::std::boxed::Box<AlignofExpression<'tree>>),
290 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
291 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
292 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
293 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
294 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
295 CoAwaitExpression(::std::boxed::Box<CoAwaitExpression<'tree>>),
296 CompoundLiteralExpression(::std::boxed::Box<CompoundLiteralExpression<'tree>>),
297 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
298 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
299 DeleteExpression(::std::boxed::Box<DeleteExpression<'tree>>),
300 ExtensionExpression(::std::boxed::Box<ExtensionExpression<'tree>>),
301 False(::std::boxed::Box<False<'tree>>),
302 FieldExpression(::std::boxed::Box<FieldExpression<'tree>>),
303 FoldExpression(::std::boxed::Box<FoldExpression<'tree>>),
304 GenericExpression(::std::boxed::Box<GenericExpression<'tree>>),
305 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
306 Identifier(::std::boxed::Box<Identifier<'tree>>),
307 LambdaExpression(::std::boxed::Box<LambdaExpression<'tree>>),
308 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
309 Null(::std::boxed::Box<Null<'tree>>),
310 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
311 OffsetofExpression(::std::boxed::Box<OffsetofExpression<'tree>>),
312 ParameterPackExpansion(::std::boxed::Box<ParameterPackExpansion<'tree>>),
313 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
314 PointerExpression(::std::boxed::Box<PointerExpression<'tree>>),
315 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
316 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
317 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
318 RequiresExpression(::std::boxed::Box<RequiresExpression<'tree>>),
319 SizeofExpression(::std::boxed::Box<SizeofExpression<'tree>>),
320 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
321 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
322 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
323 This(::std::boxed::Box<This<'tree>>),
324 True(::std::boxed::Box<True<'tree>>),
325 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
326 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
327 UserDefinedLiteral(::std::boxed::Box<UserDefinedLiteral<'tree>>),
328}
329impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
330 #[allow(clippy::collapsible_else_if)]
331 fn from_node(
332 node: ::tree_sitter::Node<'tree>,
333 src: &'tree [u8],
334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
335 match node.kind() {
336 "alignof_expression" => Ok(Self::AlignofExpression(::std::boxed::Box::new(
337 <AlignofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
338 ))),
339 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
340 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
341 ))),
342 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
343 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
344 ))),
345 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
346 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
347 ))),
348 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
349 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
350 ))),
351 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
352 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
353 ))),
354 "co_await_expression" => Ok(Self::CoAwaitExpression(::std::boxed::Box::new(
355 <CoAwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
356 ))),
357 "compound_literal_expression" => {
358 Ok(Self::CompoundLiteralExpression(::std::boxed::Box::new(
359 <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(
360 node, src,
361 )?,
362 )))
363 }
364 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
365 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)?,
366 ))),
367 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
368 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
369 ))),
370 "delete_expression" => Ok(Self::DeleteExpression(::std::boxed::Box::new(
371 <DeleteExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
372 ))),
373 "extension_expression" => Ok(Self::ExtensionExpression(::std::boxed::Box::new(
374 <ExtensionExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
375 ))),
376 "false" => Ok(Self::False(::std::boxed::Box::new(
377 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
378 ))),
379 "field_expression" => Ok(Self::FieldExpression(::std::boxed::Box::new(
380 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
381 ))),
382 "fold_expression" => Ok(Self::FoldExpression(::std::boxed::Box::new(
383 <FoldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
384 ))),
385 "generic_expression" => Ok(Self::GenericExpression(::std::boxed::Box::new(
386 <GenericExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
387 ))),
388 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
389 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
390 ))),
391 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
392 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
393 ))),
394 "lambda_expression" => Ok(Self::LambdaExpression(::std::boxed::Box::new(
395 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
396 ))),
397 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
398 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
399 ))),
400 "null" => Ok(Self::Null(::std::boxed::Box::new(
401 <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
402 ))),
403 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
404 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
405 ))),
406 "offsetof_expression" => Ok(Self::OffsetofExpression(::std::boxed::Box::new(
407 <OffsetofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
408 ))),
409 "parameter_pack_expansion" => Ok(Self::ParameterPackExpansion(::std::boxed::Box::new(
410 <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(node, src)?,
411 ))),
412 "parenthesized_expression" => {
413 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
414 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
415 node, src,
416 )?,
417 )))
418 }
419 "pointer_expression" => Ok(Self::PointerExpression(::std::boxed::Box::new(
420 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
421 ))),
422 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
423 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
424 ))),
425 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
426 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
427 ))),
428 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
429 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)?,
430 ))),
431 "requires_expression" => Ok(Self::RequiresExpression(::std::boxed::Box::new(
432 <RequiresExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
433 ))),
434 "sizeof_expression" => Ok(Self::SizeofExpression(::std::boxed::Box::new(
435 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
436 ))),
437 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
438 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
439 ))),
440 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
441 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
442 ))),
443 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
444 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
445 ))),
446 "this" => Ok(Self::This(::std::boxed::Box::new(
447 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
448 ))),
449 "true" => Ok(Self::True(::std::boxed::Box::new(
450 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
451 ))),
452 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
453 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
454 ))),
455 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
456 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
457 ))),
458 "user_defined_literal" => Ok(Self::UserDefinedLiteral(::std::boxed::Box::new(
459 <UserDefinedLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
460 ))),
461 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
462 }
463 }
464}
465impl ::treesitter_types::Spanned for Expression<'_> {
466 fn span(&self) -> ::treesitter_types::Span {
467 match self {
468 Self::AlignofExpression(inner) => inner.span(),
469 Self::AssignmentExpression(inner) => inner.span(),
470 Self::BinaryExpression(inner) => inner.span(),
471 Self::CallExpression(inner) => inner.span(),
472 Self::CastExpression(inner) => inner.span(),
473 Self::CharLiteral(inner) => inner.span(),
474 Self::CoAwaitExpression(inner) => inner.span(),
475 Self::CompoundLiteralExpression(inner) => inner.span(),
476 Self::ConcatenatedString(inner) => inner.span(),
477 Self::ConditionalExpression(inner) => inner.span(),
478 Self::DeleteExpression(inner) => inner.span(),
479 Self::ExtensionExpression(inner) => inner.span(),
480 Self::False(inner) => inner.span(),
481 Self::FieldExpression(inner) => inner.span(),
482 Self::FoldExpression(inner) => inner.span(),
483 Self::GenericExpression(inner) => inner.span(),
484 Self::GnuAsmExpression(inner) => inner.span(),
485 Self::Identifier(inner) => inner.span(),
486 Self::LambdaExpression(inner) => inner.span(),
487 Self::NewExpression(inner) => inner.span(),
488 Self::Null(inner) => inner.span(),
489 Self::NumberLiteral(inner) => inner.span(),
490 Self::OffsetofExpression(inner) => inner.span(),
491 Self::ParameterPackExpansion(inner) => inner.span(),
492 Self::ParenthesizedExpression(inner) => inner.span(),
493 Self::PointerExpression(inner) => inner.span(),
494 Self::QualifiedIdentifier(inner) => inner.span(),
495 Self::RawStringLiteral(inner) => inner.span(),
496 Self::RequiresClause(inner) => inner.span(),
497 Self::RequiresExpression(inner) => inner.span(),
498 Self::SizeofExpression(inner) => inner.span(),
499 Self::StringLiteral(inner) => inner.span(),
500 Self::SubscriptExpression(inner) => inner.span(),
501 Self::TemplateFunction(inner) => inner.span(),
502 Self::This(inner) => inner.span(),
503 Self::True(inner) => inner.span(),
504 Self::UnaryExpression(inner) => inner.span(),
505 Self::UpdateExpression(inner) => inner.span(),
506 Self::UserDefinedLiteral(inner) => inner.span(),
507 }
508 }
509}
510#[derive(Debug, Clone)]
511pub enum Statement<'tree> {
512 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
513 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
514 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
515 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
516 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
517 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
518 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
519 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
520 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
521 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
522 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
523 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
524 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
525 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
526 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
527 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
528 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
529 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
530 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
531 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
532 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
533}
534impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
535 #[allow(clippy::collapsible_else_if)]
536 fn from_node(
537 node: ::tree_sitter::Node<'tree>,
538 src: &'tree [u8],
539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
540 match node.kind() {
541 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
542 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
543 ))),
544 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
545 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
546 ))),
547 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
548 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
549 ))),
550 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
551 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
552 ))),
553 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
554 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
555 ))),
556 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
557 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
558 ))),
559 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
560 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
561 ))),
562 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
563 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
564 ))),
565 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
566 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
567 ))),
568 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
569 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)?,
570 ))),
571 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
572 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
573 ))),
574 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
575 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
576 ))),
577 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
578 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
579 ))),
580 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
581 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
582 ))),
583 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
584 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
585 ))),
586 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
587 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
588 ))),
589 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
590 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
591 ))),
592 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
593 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
594 ))),
595 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
596 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
597 ))),
598 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
599 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
600 ))),
601 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
602 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
603 ))),
604 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
605 }
606 }
607}
608impl ::treesitter_types::Spanned for Statement<'_> {
609 fn span(&self) -> ::treesitter_types::Span {
610 match self {
611 Self::AttributedStatement(inner) => inner.span(),
612 Self::BreakStatement(inner) => inner.span(),
613 Self::CaseStatement(inner) => inner.span(),
614 Self::CoReturnStatement(inner) => inner.span(),
615 Self::CoYieldStatement(inner) => inner.span(),
616 Self::CompoundStatement(inner) => inner.span(),
617 Self::ContinueStatement(inner) => inner.span(),
618 Self::DoStatement(inner) => inner.span(),
619 Self::ExpressionStatement(inner) => inner.span(),
620 Self::ForRangeLoop(inner) => inner.span(),
621 Self::ForStatement(inner) => inner.span(),
622 Self::GotoStatement(inner) => inner.span(),
623 Self::IfStatement(inner) => inner.span(),
624 Self::LabeledStatement(inner) => inner.span(),
625 Self::ReturnStatement(inner) => inner.span(),
626 Self::SehLeaveStatement(inner) => inner.span(),
627 Self::SehTryStatement(inner) => inner.span(),
628 Self::SwitchStatement(inner) => inner.span(),
629 Self::ThrowStatement(inner) => inner.span(),
630 Self::TryStatement(inner) => inner.span(),
631 Self::WhileStatement(inner) => inner.span(),
632 }
633 }
634}
635#[derive(Debug, Clone)]
636pub enum TypeSpecifier<'tree> {
637 ClassSpecifier(::std::boxed::Box<ClassSpecifier<'tree>>),
638 Decltype(::std::boxed::Box<Decltype<'tree>>),
639 DependentType(::std::boxed::Box<DependentType<'tree>>),
640 EnumSpecifier(::std::boxed::Box<EnumSpecifier<'tree>>),
641 PlaceholderTypeSpecifier(::std::boxed::Box<PlaceholderTypeSpecifier<'tree>>),
642 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
643 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
644 SizedTypeSpecifier(::std::boxed::Box<SizedTypeSpecifier<'tree>>),
645 StructSpecifier(::std::boxed::Box<StructSpecifier<'tree>>),
646 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
647 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
648 UnionSpecifier(::std::boxed::Box<UnionSpecifier<'tree>>),
649}
650impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSpecifier<'tree> {
651 #[allow(clippy::collapsible_else_if)]
652 fn from_node(
653 node: ::tree_sitter::Node<'tree>,
654 src: &'tree [u8],
655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
656 match node.kind() {
657 "class_specifier" => Ok(Self::ClassSpecifier(::std::boxed::Box::new(
658 <ClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
659 ))),
660 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
661 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)?,
662 ))),
663 "dependent_type" => Ok(Self::DependentType(::std::boxed::Box::new(
664 <DependentType as ::treesitter_types::FromNode>::from_node(node, src)?,
665 ))),
666 "enum_specifier" => Ok(Self::EnumSpecifier(::std::boxed::Box::new(
667 <EnumSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
668 ))),
669 "placeholder_type_specifier" => {
670 Ok(Self::PlaceholderTypeSpecifier(::std::boxed::Box::new(
671 <PlaceholderTypeSpecifier as ::treesitter_types::FromNode>::from_node(
672 node, src,
673 )?,
674 )))
675 }
676 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
677 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
678 ))),
679 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
680 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
681 ))),
682 "sized_type_specifier" => Ok(Self::SizedTypeSpecifier(::std::boxed::Box::new(
683 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
684 ))),
685 "struct_specifier" => Ok(Self::StructSpecifier(::std::boxed::Box::new(
686 <StructSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
687 ))),
688 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
689 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
690 ))),
691 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
692 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
693 ))),
694 "union_specifier" => Ok(Self::UnionSpecifier(::std::boxed::Box::new(
695 <UnionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
696 ))),
697 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
698 }
699 }
700}
701impl ::treesitter_types::Spanned for TypeSpecifier<'_> {
702 fn span(&self) -> ::treesitter_types::Span {
703 match self {
704 Self::ClassSpecifier(inner) => inner.span(),
705 Self::Decltype(inner) => inner.span(),
706 Self::DependentType(inner) => inner.span(),
707 Self::EnumSpecifier(inner) => inner.span(),
708 Self::PlaceholderTypeSpecifier(inner) => inner.span(),
709 Self::PrimitiveType(inner) => inner.span(),
710 Self::QualifiedIdentifier(inner) => inner.span(),
711 Self::SizedTypeSpecifier(inner) => inner.span(),
712 Self::StructSpecifier(inner) => inner.span(),
713 Self::TemplateType(inner) => inner.span(),
714 Self::TypeIdentifier(inner) => inner.span(),
715 Self::UnionSpecifier(inner) => inner.span(),
716 }
717 }
718}
719#[derive(Debug, Clone)]
720pub struct AbstractArrayDeclarator<'tree> {
721 pub span: ::treesitter_types::Span,
722 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
723 pub size: ::core::option::Option<AbstractArrayDeclaratorSize<'tree>>,
724 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
725}
726impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclarator<'tree> {
727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
728 fn from_node(
729 node: ::tree_sitter::Node<'tree>,
730 src: &'tree [u8],
731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
732 debug_assert_eq!(node.kind(), "abstract_array_declarator");
733 Ok(Self {
734 span: ::treesitter_types::Span::from(node),
735 declarator: match node.child_by_field_name("declarator") {
736 Some(child) => Some(
737 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
738 ),
739 None => None,
740 },
741 size: match node.child_by_field_name("size") {
742 Some(child) => Some(
743 <AbstractArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(
744 child, src,
745 )?,
746 ),
747 None => None,
748 },
749 children: {
750 #[allow(clippy::suspicious_else_formatting)]
751 let non_field_children = {
752 let mut cursor = node.walk();
753 let mut result = ::std::vec::Vec::new();
754 if cursor.goto_first_child() {
755 loop {
756 if cursor.field_name().is_none()
757 && cursor.node().is_named()
758 && !cursor.node().is_extra()
759 {
760 result.push(cursor.node());
761 }
762 if !cursor.goto_next_sibling() {
763 break;
764 }
765 }
766 }
767 result
768 };
769 let mut items = ::std::vec::Vec::new();
770 for child in non_field_children {
771 items.push(<TypeQualifier as ::treesitter_types::FromNode>::from_node(
772 child, src,
773 )?);
774 }
775 items
776 },
777 })
778 }
779}
780impl ::treesitter_types::Spanned for AbstractArrayDeclarator<'_> {
781 fn span(&self) -> ::treesitter_types::Span {
782 self.span
783 }
784}
785#[derive(Debug, Clone)]
786pub struct AbstractFunctionDeclarator<'tree> {
787 pub span: ::treesitter_types::Span,
788 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
789 pub parameters: ParameterList<'tree>,
790 pub children: ::std::vec::Vec<AbstractFunctionDeclaratorChildren<'tree>>,
791}
792impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFunctionDeclarator<'tree> {
793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
794 fn from_node(
795 node: ::tree_sitter::Node<'tree>,
796 src: &'tree [u8],
797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
798 debug_assert_eq!(node.kind(), "abstract_function_declarator");
799 Ok(Self {
800 span: ::treesitter_types::Span::from(node),
801 declarator: match node.child_by_field_name("declarator") {
802 Some(child) => Some(
803 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
804 ),
805 None => None,
806 },
807 parameters: {
808 let child = node.child_by_field_name("parameters").ok_or_else(|| {
809 ::treesitter_types::ParseError::missing_field("parameters", node)
810 })?;
811 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
812 },
813 children: {
814 #[allow(clippy::suspicious_else_formatting)]
815 let non_field_children = {
816 let mut cursor = node.walk();
817 let mut result = ::std::vec::Vec::new();
818 if cursor.goto_first_child() {
819 loop {
820 if cursor.field_name().is_none()
821 && cursor.node().is_named()
822 && !cursor.node().is_extra()
823 {
824 result.push(cursor.node());
825 }
826 if !cursor.goto_next_sibling() {
827 break;
828 }
829 }
830 }
831 result
832 };
833 let mut items = ::std::vec::Vec::new();
834 for child in non_field_children {
835 items
836 .push(
837 <AbstractFunctionDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
838 child,
839 src,
840 )?,
841 );
842 }
843 items
844 },
845 })
846 }
847}
848impl ::treesitter_types::Spanned for AbstractFunctionDeclarator<'_> {
849 fn span(&self) -> ::treesitter_types::Span {
850 self.span
851 }
852}
853#[derive(Debug, Clone)]
854pub struct AbstractParenthesizedDeclarator<'tree> {
855 pub span: ::treesitter_types::Span,
856 pub children: ::std::vec::Vec<AbstractParenthesizedDeclaratorChildren<'tree>>,
857}
858impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclarator<'tree> {
859 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
860 fn from_node(
861 node: ::tree_sitter::Node<'tree>,
862 src: &'tree [u8],
863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
864 debug_assert_eq!(node.kind(), "abstract_parenthesized_declarator");
865 Ok(Self {
866 span: ::treesitter_types::Span::from(node),
867 children: {
868 #[allow(clippy::suspicious_else_formatting)]
869 let non_field_children = {
870 let mut cursor = node.walk();
871 let mut result = ::std::vec::Vec::new();
872 if cursor.goto_first_child() {
873 loop {
874 if cursor.field_name().is_none()
875 && cursor.node().is_named()
876 && !cursor.node().is_extra()
877 {
878 result.push(cursor.node());
879 }
880 if !cursor.goto_next_sibling() {
881 break;
882 }
883 }
884 }
885 result
886 };
887 let mut items = ::std::vec::Vec::new();
888 for child in non_field_children {
889 items
890 .push(
891 <AbstractParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
892 child,
893 src,
894 )?,
895 );
896 }
897 items
898 },
899 })
900 }
901}
902impl ::treesitter_types::Spanned for AbstractParenthesizedDeclarator<'_> {
903 fn span(&self) -> ::treesitter_types::Span {
904 self.span
905 }
906}
907#[derive(Debug, Clone)]
908pub struct AbstractPointerDeclarator<'tree> {
909 pub span: ::treesitter_types::Span,
910 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
911 pub children: ::std::vec::Vec<AbstractPointerDeclaratorChildren<'tree>>,
912}
913impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclarator<'tree> {
914 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
915 fn from_node(
916 node: ::tree_sitter::Node<'tree>,
917 src: &'tree [u8],
918 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
919 debug_assert_eq!(node.kind(), "abstract_pointer_declarator");
920 Ok(Self {
921 span: ::treesitter_types::Span::from(node),
922 declarator: match node.child_by_field_name("declarator") {
923 Some(child) => Some(
924 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
925 ),
926 None => None,
927 },
928 children: {
929 #[allow(clippy::suspicious_else_formatting)]
930 let non_field_children = {
931 let mut cursor = node.walk();
932 let mut result = ::std::vec::Vec::new();
933 if cursor.goto_first_child() {
934 loop {
935 if cursor.field_name().is_none()
936 && cursor.node().is_named()
937 && !cursor.node().is_extra()
938 {
939 result.push(cursor.node());
940 }
941 if !cursor.goto_next_sibling() {
942 break;
943 }
944 }
945 }
946 result
947 };
948 let mut items = ::std::vec::Vec::new();
949 for child in non_field_children {
950 items
951 .push(
952 <AbstractPointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
953 child,
954 src,
955 )?,
956 );
957 }
958 items
959 },
960 })
961 }
962}
963impl ::treesitter_types::Spanned for AbstractPointerDeclarator<'_> {
964 fn span(&self) -> ::treesitter_types::Span {
965 self.span
966 }
967}
968#[derive(Debug, Clone)]
969pub struct AbstractReferenceDeclarator<'tree> {
970 pub span: ::treesitter_types::Span,
971 pub children: ::core::option::Option<AbstractDeclarator<'tree>>,
972}
973impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractReferenceDeclarator<'tree> {
974 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
975 fn from_node(
976 node: ::tree_sitter::Node<'tree>,
977 src: &'tree [u8],
978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
979 debug_assert_eq!(node.kind(), "abstract_reference_declarator");
980 Ok(Self {
981 span: ::treesitter_types::Span::from(node),
982 children: {
983 #[allow(clippy::suspicious_else_formatting)]
984 let non_field_children = {
985 let mut cursor = node.walk();
986 let mut result = ::std::vec::Vec::new();
987 if cursor.goto_first_child() {
988 loop {
989 if cursor.field_name().is_none()
990 && cursor.node().is_named()
991 && !cursor.node().is_extra()
992 {
993 result.push(cursor.node());
994 }
995 if !cursor.goto_next_sibling() {
996 break;
997 }
998 }
999 }
1000 result
1001 };
1002 match non_field_children.first() {
1003 Some(&child) => Some(
1004 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(
1005 child, src,
1006 )?,
1007 ),
1008 None => None,
1009 }
1010 },
1011 })
1012 }
1013}
1014impl ::treesitter_types::Spanned for AbstractReferenceDeclarator<'_> {
1015 fn span(&self) -> ::treesitter_types::Span {
1016 self.span
1017 }
1018}
1019#[derive(Debug, Clone)]
1020pub struct AccessSpecifier<'tree> {
1021 pub span: ::treesitter_types::Span,
1022 text: &'tree str,
1023}
1024impl<'tree> ::treesitter_types::FromNode<'tree> for AccessSpecifier<'tree> {
1025 fn from_node(
1026 node: ::tree_sitter::Node<'tree>,
1027 src: &'tree [u8],
1028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1029 debug_assert_eq!(node.kind(), "access_specifier");
1030 Ok(Self {
1031 span: ::treesitter_types::Span::from(node),
1032 text: node.utf8_text(src)?,
1033 })
1034 }
1035}
1036impl<'tree> ::treesitter_types::LeafNode<'tree> for AccessSpecifier<'tree> {
1037 fn text(&self) -> &'tree str {
1038 self.text
1039 }
1040}
1041impl ::treesitter_types::Spanned for AccessSpecifier<'_> {
1042 fn span(&self) -> ::treesitter_types::Span {
1043 self.span
1044 }
1045}
1046#[derive(Debug, Clone)]
1047pub struct AliasDeclaration<'tree> {
1048 pub span: ::treesitter_types::Span,
1049 pub name: TypeIdentifier<'tree>,
1050 pub r#type: TypeDescriptor<'tree>,
1051 pub children: ::std::vec::Vec<AttributeDeclaration<'tree>>,
1052}
1053impl<'tree> ::treesitter_types::FromNode<'tree> for AliasDeclaration<'tree> {
1054 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1055 fn from_node(
1056 node: ::tree_sitter::Node<'tree>,
1057 src: &'tree [u8],
1058 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1059 debug_assert_eq!(node.kind(), "alias_declaration");
1060 Ok(Self {
1061 span: ::treesitter_types::Span::from(node),
1062 name: {
1063 let child = node
1064 .child_by_field_name("name")
1065 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1066 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
1067 },
1068 r#type: {
1069 let child = node
1070 .child_by_field_name("type")
1071 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1072 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)?
1073 },
1074 children: {
1075 #[allow(clippy::suspicious_else_formatting)]
1076 let non_field_children = {
1077 let mut cursor = node.walk();
1078 let mut result = ::std::vec::Vec::new();
1079 if cursor.goto_first_child() {
1080 loop {
1081 if cursor.field_name().is_none()
1082 && cursor.node().is_named()
1083 && !cursor.node().is_extra()
1084 {
1085 result.push(cursor.node());
1086 }
1087 if !cursor.goto_next_sibling() {
1088 break;
1089 }
1090 }
1091 }
1092 result
1093 };
1094 let mut items = ::std::vec::Vec::new();
1095 for child in non_field_children {
1096 items.push(
1097 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(
1098 child, src,
1099 )?,
1100 );
1101 }
1102 items
1103 },
1104 })
1105 }
1106}
1107impl ::treesitter_types::Spanned for AliasDeclaration<'_> {
1108 fn span(&self) -> ::treesitter_types::Span {
1109 self.span
1110 }
1111}
1112#[derive(Debug, Clone)]
1113pub struct AlignasQualifier<'tree> {
1114 pub span: ::treesitter_types::Span,
1115 pub children: AlignasQualifierChildren<'tree>,
1116}
1117impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifier<'tree> {
1118 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1119 fn from_node(
1120 node: ::tree_sitter::Node<'tree>,
1121 src: &'tree [u8],
1122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1123 debug_assert_eq!(node.kind(), "alignas_qualifier");
1124 Ok(Self {
1125 span: ::treesitter_types::Span::from(node),
1126 children: {
1127 #[allow(clippy::suspicious_else_formatting)]
1128 let non_field_children = {
1129 let mut cursor = node.walk();
1130 let mut result = ::std::vec::Vec::new();
1131 if cursor.goto_first_child() {
1132 loop {
1133 if cursor.field_name().is_none()
1134 && cursor.node().is_named()
1135 && !cursor.node().is_extra()
1136 {
1137 result.push(cursor.node());
1138 }
1139 if !cursor.goto_next_sibling() {
1140 break;
1141 }
1142 }
1143 }
1144 result
1145 };
1146 let child = if let Some(&c) = non_field_children.first() {
1147 c
1148 } else {
1149 let mut fallback_cursor = node.walk();
1150 let mut fallback_child = None;
1151 if fallback_cursor.goto_first_child() {
1152 loop {
1153 if fallback_cursor.field_name().is_none()
1154 && !fallback_cursor.node().is_extra()
1155 {
1156 let candidate = fallback_cursor.node();
1157 #[allow(clippy::needless_question_mark)]
1158 if (|| -> ::core::result::Result<
1159 _,
1160 ::treesitter_types::ParseError,
1161 > {
1162 let child = candidate;
1163 Ok(
1164 <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
1165 child,
1166 src,
1167 )?,
1168 )
1169 })()
1170 .is_ok()
1171 {
1172 fallback_child = Some(candidate);
1173 break;
1174 }
1175 }
1176 if !fallback_cursor.goto_next_sibling() {
1177 break;
1178 }
1179 }
1180 }
1181 if fallback_child.is_none() {
1182 let mut cursor2 = node.walk();
1183 if cursor2.goto_first_child() {
1184 loop {
1185 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1186 let candidate = cursor2.node();
1187 #[allow(clippy::needless_question_mark)]
1188 if (|| -> ::core::result::Result<
1189 _,
1190 ::treesitter_types::ParseError,
1191 > {
1192 let child = candidate;
1193 Ok(
1194 <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(
1195 child,
1196 src,
1197 )?,
1198 )
1199 })()
1200 .is_ok()
1201 {
1202 fallback_child = Some(candidate);
1203 break;
1204 }
1205 }
1206 if !cursor2.goto_next_sibling() {
1207 break;
1208 }
1209 }
1210 }
1211 }
1212 fallback_child.ok_or_else(|| {
1213 ::treesitter_types::ParseError::missing_field("children", node)
1214 })?
1215 };
1216 <AlignasQualifierChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1217 },
1218 })
1219 }
1220}
1221impl ::treesitter_types::Spanned for AlignasQualifier<'_> {
1222 fn span(&self) -> ::treesitter_types::Span {
1223 self.span
1224 }
1225}
1226#[derive(Debug, Clone)]
1227pub struct AlignofExpression<'tree> {
1228 pub span: ::treesitter_types::Span,
1229 pub r#type: TypeDescriptor<'tree>,
1230}
1231impl<'tree> ::treesitter_types::FromNode<'tree> for AlignofExpression<'tree> {
1232 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1233 fn from_node(
1234 node: ::tree_sitter::Node<'tree>,
1235 src: &'tree [u8],
1236 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1237 debug_assert_eq!(node.kind(), "alignof_expression");
1238 Ok(Self {
1239 span: ::treesitter_types::Span::from(node),
1240 r#type: {
1241 let child = node
1242 .child_by_field_name("type")
1243 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1244 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)?
1245 },
1246 })
1247 }
1248}
1249impl ::treesitter_types::Spanned for AlignofExpression<'_> {
1250 fn span(&self) -> ::treesitter_types::Span {
1251 self.span
1252 }
1253}
1254#[derive(Debug, Clone)]
1255pub struct ArgumentList<'tree> {
1256 pub span: ::treesitter_types::Span,
1257 pub children: ::std::vec::Vec<ArgumentListChildren<'tree>>,
1258}
1259impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentList<'tree> {
1260 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1261 fn from_node(
1262 node: ::tree_sitter::Node<'tree>,
1263 src: &'tree [u8],
1264 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1265 debug_assert_eq!(node.kind(), "argument_list");
1266 Ok(Self {
1267 span: ::treesitter_types::Span::from(node),
1268 children: {
1269 #[allow(clippy::suspicious_else_formatting)]
1270 let non_field_children = {
1271 let mut cursor = node.walk();
1272 let mut result = ::std::vec::Vec::new();
1273 if cursor.goto_first_child() {
1274 loop {
1275 if cursor.field_name().is_none()
1276 && cursor.node().is_named()
1277 && !cursor.node().is_extra()
1278 {
1279 result.push(cursor.node());
1280 }
1281 if !cursor.goto_next_sibling() {
1282 break;
1283 }
1284 }
1285 }
1286 result
1287 };
1288 let mut items = ::std::vec::Vec::new();
1289 for child in non_field_children {
1290 items.push(
1291 <ArgumentListChildren as ::treesitter_types::FromNode>::from_node(
1292 child, src,
1293 )?,
1294 );
1295 }
1296 items
1297 },
1298 })
1299 }
1300}
1301impl ::treesitter_types::Spanned for ArgumentList<'_> {
1302 fn span(&self) -> ::treesitter_types::Span {
1303 self.span
1304 }
1305}
1306#[derive(Debug, Clone)]
1307pub struct ArrayDeclarator<'tree> {
1308 pub span: ::treesitter_types::Span,
1309 pub declarator: ArrayDeclaratorDeclarator<'tree>,
1310 pub size: ::core::option::Option<ArrayDeclaratorSize<'tree>>,
1311 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
1312}
1313impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclarator<'tree> {
1314 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1315 fn from_node(
1316 node: ::tree_sitter::Node<'tree>,
1317 src: &'tree [u8],
1318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1319 debug_assert_eq!(node.kind(), "array_declarator");
1320 Ok(Self {
1321 span: ::treesitter_types::Span::from(node),
1322 declarator: {
1323 let child = node.child_by_field_name("declarator").ok_or_else(|| {
1324 ::treesitter_types::ParseError::missing_field("declarator", node)
1325 })?;
1326 <ArrayDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?
1327 },
1328 size: match node.child_by_field_name("size") {
1329 Some(child) => Some(
1330 <ArrayDeclaratorSize as ::treesitter_types::FromNode>::from_node(child, src)?,
1331 ),
1332 None => None,
1333 },
1334 children: {
1335 #[allow(clippy::suspicious_else_formatting)]
1336 let non_field_children = {
1337 let mut cursor = node.walk();
1338 let mut result = ::std::vec::Vec::new();
1339 if cursor.goto_first_child() {
1340 loop {
1341 if cursor.field_name().is_none()
1342 && cursor.node().is_named()
1343 && !cursor.node().is_extra()
1344 {
1345 result.push(cursor.node());
1346 }
1347 if !cursor.goto_next_sibling() {
1348 break;
1349 }
1350 }
1351 }
1352 result
1353 };
1354 let mut items = ::std::vec::Vec::new();
1355 for child in non_field_children {
1356 items.push(<TypeQualifier as ::treesitter_types::FromNode>::from_node(
1357 child, src,
1358 )?);
1359 }
1360 items
1361 },
1362 })
1363 }
1364}
1365impl ::treesitter_types::Spanned for ArrayDeclarator<'_> {
1366 fn span(&self) -> ::treesitter_types::Span {
1367 self.span
1368 }
1369}
1370#[derive(Debug, Clone)]
1371pub struct AssignmentExpression<'tree> {
1372 pub span: ::treesitter_types::Span,
1373 pub left: Expression<'tree>,
1374 pub operator: AssignmentExpressionOperator,
1375 pub right: AssignmentExpressionRight<'tree>,
1376}
1377impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1378 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1379 fn from_node(
1380 node: ::tree_sitter::Node<'tree>,
1381 src: &'tree [u8],
1382 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1383 debug_assert_eq!(node.kind(), "assignment_expression");
1384 Ok(Self {
1385 span: ::treesitter_types::Span::from(node),
1386 left: {
1387 let child = node
1388 .child_by_field_name("left")
1389 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1390 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1391 },
1392 operator: {
1393 let child = node.child_by_field_name("operator").ok_or_else(|| {
1394 ::treesitter_types::ParseError::missing_field("operator", node)
1395 })?;
1396 <AssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1397 child, src,
1398 )?
1399 },
1400 right: {
1401 let child = node
1402 .child_by_field_name("right")
1403 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1404 <AssignmentExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
1405 },
1406 })
1407 }
1408}
1409impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1410 fn span(&self) -> ::treesitter_types::Span {
1411 self.span
1412 }
1413}
1414#[derive(Debug, Clone)]
1415pub struct Attribute<'tree> {
1416 pub span: ::treesitter_types::Span,
1417 pub name: Identifier<'tree>,
1418 pub prefix: ::core::option::Option<Identifier<'tree>>,
1419 pub children: ::core::option::Option<ArgumentList<'tree>>,
1420}
1421impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1422 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1423 fn from_node(
1424 node: ::tree_sitter::Node<'tree>,
1425 src: &'tree [u8],
1426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1427 debug_assert_eq!(node.kind(), "attribute");
1428 Ok(Self {
1429 span: ::treesitter_types::Span::from(node),
1430 name: {
1431 let child = node
1432 .child_by_field_name("name")
1433 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1434 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1435 },
1436 prefix: match node.child_by_field_name("prefix") {
1437 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1438 child, src,
1439 )?),
1440 None => None,
1441 },
1442 children: {
1443 #[allow(clippy::suspicious_else_formatting)]
1444 let non_field_children = {
1445 let mut cursor = node.walk();
1446 let mut result = ::std::vec::Vec::new();
1447 if cursor.goto_first_child() {
1448 loop {
1449 if cursor.field_name().is_none()
1450 && cursor.node().is_named()
1451 && !cursor.node().is_extra()
1452 {
1453 result.push(cursor.node());
1454 }
1455 if !cursor.goto_next_sibling() {
1456 break;
1457 }
1458 }
1459 }
1460 result
1461 };
1462 match non_field_children.first() {
1463 Some(&child) => Some(
1464 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?,
1465 ),
1466 None => None,
1467 }
1468 },
1469 })
1470 }
1471}
1472impl ::treesitter_types::Spanned for Attribute<'_> {
1473 fn span(&self) -> ::treesitter_types::Span {
1474 self.span
1475 }
1476}
1477#[derive(Debug, Clone)]
1478pub struct AttributeDeclaration<'tree> {
1479 pub span: ::treesitter_types::Span,
1480 pub children: ::std::vec::Vec<Attribute<'tree>>,
1481}
1482impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeDeclaration<'tree> {
1483 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1484 fn from_node(
1485 node: ::tree_sitter::Node<'tree>,
1486 src: &'tree [u8],
1487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1488 debug_assert_eq!(node.kind(), "attribute_declaration");
1489 Ok(Self {
1490 span: ::treesitter_types::Span::from(node),
1491 children: {
1492 #[allow(clippy::suspicious_else_formatting)]
1493 let non_field_children = {
1494 let mut cursor = node.walk();
1495 let mut result = ::std::vec::Vec::new();
1496 if cursor.goto_first_child() {
1497 loop {
1498 if cursor.field_name().is_none()
1499 && cursor.node().is_named()
1500 && !cursor.node().is_extra()
1501 {
1502 result.push(cursor.node());
1503 }
1504 if !cursor.goto_next_sibling() {
1505 break;
1506 }
1507 }
1508 }
1509 result
1510 };
1511 let mut items = ::std::vec::Vec::new();
1512 for child in non_field_children {
1513 items.push(<Attribute as ::treesitter_types::FromNode>::from_node(
1514 child, src,
1515 )?);
1516 }
1517 items
1518 },
1519 })
1520 }
1521}
1522impl ::treesitter_types::Spanned for AttributeDeclaration<'_> {
1523 fn span(&self) -> ::treesitter_types::Span {
1524 self.span
1525 }
1526}
1527#[derive(Debug, Clone)]
1528pub struct AttributeSpecifier<'tree> {
1529 pub span: ::treesitter_types::Span,
1530 pub children: ArgumentList<'tree>,
1531}
1532impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeSpecifier<'tree> {
1533 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1534 fn from_node(
1535 node: ::tree_sitter::Node<'tree>,
1536 src: &'tree [u8],
1537 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1538 debug_assert_eq!(node.kind(), "attribute_specifier");
1539 Ok(Self {
1540 span: ::treesitter_types::Span::from(node),
1541 children: {
1542 #[allow(clippy::suspicious_else_formatting)]
1543 let non_field_children = {
1544 let mut cursor = node.walk();
1545 let mut result = ::std::vec::Vec::new();
1546 if cursor.goto_first_child() {
1547 loop {
1548 if cursor.field_name().is_none()
1549 && cursor.node().is_named()
1550 && !cursor.node().is_extra()
1551 {
1552 result.push(cursor.node());
1553 }
1554 if !cursor.goto_next_sibling() {
1555 break;
1556 }
1557 }
1558 }
1559 result
1560 };
1561 let child = if let Some(&c) = non_field_children.first() {
1562 c
1563 } else {
1564 let mut fallback_cursor = node.walk();
1565 let mut fallback_child = None;
1566 if fallback_cursor.goto_first_child() {
1567 loop {
1568 if fallback_cursor.field_name().is_none()
1569 && !fallback_cursor.node().is_extra()
1570 {
1571 let candidate = fallback_cursor.node();
1572 #[allow(clippy::needless_question_mark)]
1573 if (|| -> ::core::result::Result<
1574 _,
1575 ::treesitter_types::ParseError,
1576 > {
1577 let child = candidate;
1578 Ok(
1579 <ArgumentList as ::treesitter_types::FromNode>::from_node(
1580 child,
1581 src,
1582 )?,
1583 )
1584 })()
1585 .is_ok()
1586 {
1587 fallback_child = Some(candidate);
1588 break;
1589 }
1590 }
1591 if !fallback_cursor.goto_next_sibling() {
1592 break;
1593 }
1594 }
1595 }
1596 if fallback_child.is_none() {
1597 let mut cursor2 = node.walk();
1598 if cursor2.goto_first_child() {
1599 loop {
1600 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1601 let candidate = cursor2.node();
1602 #[allow(clippy::needless_question_mark)]
1603 if (|| -> ::core::result::Result<
1604 _,
1605 ::treesitter_types::ParseError,
1606 > {
1607 let child = candidate;
1608 Ok(
1609 <ArgumentList as ::treesitter_types::FromNode>::from_node(
1610 child,
1611 src,
1612 )?,
1613 )
1614 })()
1615 .is_ok()
1616 {
1617 fallback_child = Some(candidate);
1618 break;
1619 }
1620 }
1621 if !cursor2.goto_next_sibling() {
1622 break;
1623 }
1624 }
1625 }
1626 }
1627 fallback_child.ok_or_else(|| {
1628 ::treesitter_types::ParseError::missing_field("children", node)
1629 })?
1630 };
1631 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
1632 },
1633 })
1634 }
1635}
1636impl ::treesitter_types::Spanned for AttributeSpecifier<'_> {
1637 fn span(&self) -> ::treesitter_types::Span {
1638 self.span
1639 }
1640}
1641#[derive(Debug, Clone)]
1642pub struct AttributedDeclarator<'tree> {
1643 pub span: ::treesitter_types::Span,
1644 pub children: ::std::vec::Vec<AttributedDeclaratorChildren<'tree>>,
1645}
1646impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclarator<'tree> {
1647 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1648 fn from_node(
1649 node: ::tree_sitter::Node<'tree>,
1650 src: &'tree [u8],
1651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1652 debug_assert_eq!(node.kind(), "attributed_declarator");
1653 Ok(Self {
1654 span: ::treesitter_types::Span::from(node),
1655 children: {
1656 #[allow(clippy::suspicious_else_formatting)]
1657 let non_field_children = {
1658 let mut cursor = node.walk();
1659 let mut result = ::std::vec::Vec::new();
1660 if cursor.goto_first_child() {
1661 loop {
1662 if cursor.field_name().is_none()
1663 && cursor.node().is_named()
1664 && !cursor.node().is_extra()
1665 {
1666 result.push(cursor.node());
1667 }
1668 if !cursor.goto_next_sibling() {
1669 break;
1670 }
1671 }
1672 }
1673 result
1674 };
1675 let mut items = ::std::vec::Vec::new();
1676 for child in non_field_children {
1677 items.push(
1678 <AttributedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
1679 child, src,
1680 )?,
1681 );
1682 }
1683 items
1684 },
1685 })
1686 }
1687}
1688impl ::treesitter_types::Spanned for AttributedDeclarator<'_> {
1689 fn span(&self) -> ::treesitter_types::Span {
1690 self.span
1691 }
1692}
1693#[derive(Debug, Clone)]
1694pub struct AttributedStatement<'tree> {
1695 pub span: ::treesitter_types::Span,
1696 pub children: ::std::vec::Vec<AttributedStatementChildren<'tree>>,
1697}
1698impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatement<'tree> {
1699 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1700 fn from_node(
1701 node: ::tree_sitter::Node<'tree>,
1702 src: &'tree [u8],
1703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1704 debug_assert_eq!(node.kind(), "attributed_statement");
1705 Ok(Self {
1706 span: ::treesitter_types::Span::from(node),
1707 children: {
1708 #[allow(clippy::suspicious_else_formatting)]
1709 let non_field_children = {
1710 let mut cursor = node.walk();
1711 let mut result = ::std::vec::Vec::new();
1712 if cursor.goto_first_child() {
1713 loop {
1714 if cursor.field_name().is_none()
1715 && cursor.node().is_named()
1716 && !cursor.node().is_extra()
1717 {
1718 result.push(cursor.node());
1719 }
1720 if !cursor.goto_next_sibling() {
1721 break;
1722 }
1723 }
1724 }
1725 result
1726 };
1727 let mut items = ::std::vec::Vec::new();
1728 for child in non_field_children {
1729 items.push(
1730 <AttributedStatementChildren as ::treesitter_types::FromNode>::from_node(
1731 child, src,
1732 )?,
1733 );
1734 }
1735 items
1736 },
1737 })
1738 }
1739}
1740impl ::treesitter_types::Spanned for AttributedStatement<'_> {
1741 fn span(&self) -> ::treesitter_types::Span {
1742 self.span
1743 }
1744}
1745#[derive(Debug, Clone)]
1746pub struct BaseClassClause<'tree> {
1747 pub span: ::treesitter_types::Span,
1748 pub children: ::std::vec::Vec<BaseClassClauseChildren<'tree>>,
1749}
1750impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClassClause<'tree> {
1751 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1752 fn from_node(
1753 node: ::tree_sitter::Node<'tree>,
1754 src: &'tree [u8],
1755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1756 debug_assert_eq!(node.kind(), "base_class_clause");
1757 Ok(Self {
1758 span: ::treesitter_types::Span::from(node),
1759 children: {
1760 #[allow(clippy::suspicious_else_formatting)]
1761 let non_field_children = {
1762 let mut cursor = node.walk();
1763 let mut result = ::std::vec::Vec::new();
1764 if cursor.goto_first_child() {
1765 loop {
1766 if cursor.field_name().is_none()
1767 && cursor.node().is_named()
1768 && !cursor.node().is_extra()
1769 {
1770 result.push(cursor.node());
1771 }
1772 if !cursor.goto_next_sibling() {
1773 break;
1774 }
1775 }
1776 }
1777 result
1778 };
1779 let mut items = ::std::vec::Vec::new();
1780 for child in non_field_children {
1781 items.push(
1782 <BaseClassClauseChildren as ::treesitter_types::FromNode>::from_node(
1783 child, src,
1784 )?,
1785 );
1786 }
1787 items
1788 },
1789 })
1790 }
1791}
1792impl ::treesitter_types::Spanned for BaseClassClause<'_> {
1793 fn span(&self) -> ::treesitter_types::Span {
1794 self.span
1795 }
1796}
1797#[derive(Debug, Clone)]
1798pub struct BinaryExpression<'tree> {
1799 pub span: ::treesitter_types::Span,
1800 pub left: BinaryExpressionLeft<'tree>,
1801 pub operator: BinaryExpressionOperator,
1802 pub right: BinaryExpressionRight<'tree>,
1803}
1804impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1805 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1806 fn from_node(
1807 node: ::tree_sitter::Node<'tree>,
1808 src: &'tree [u8],
1809 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1810 debug_assert_eq!(node.kind(), "binary_expression");
1811 Ok(Self {
1812 span: ::treesitter_types::Span::from(node),
1813 left: {
1814 let child = node
1815 .child_by_field_name("left")
1816 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1817 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1818 },
1819 operator: {
1820 let child = node.child_by_field_name("operator").ok_or_else(|| {
1821 ::treesitter_types::ParseError::missing_field("operator", node)
1822 })?;
1823 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1824 },
1825 right: {
1826 let child = node
1827 .child_by_field_name("right")
1828 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1829 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
1830 },
1831 })
1832 }
1833}
1834impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1835 fn span(&self) -> ::treesitter_types::Span {
1836 self.span
1837 }
1838}
1839#[derive(Debug, Clone)]
1840pub struct BitfieldClause<'tree> {
1841 pub span: ::treesitter_types::Span,
1842 pub children: Expression<'tree>,
1843}
1844impl<'tree> ::treesitter_types::FromNode<'tree> for BitfieldClause<'tree> {
1845 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1846 fn from_node(
1847 node: ::tree_sitter::Node<'tree>,
1848 src: &'tree [u8],
1849 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1850 debug_assert_eq!(node.kind(), "bitfield_clause");
1851 Ok(Self {
1852 span: ::treesitter_types::Span::from(node),
1853 children: {
1854 #[allow(clippy::suspicious_else_formatting)]
1855 let non_field_children = {
1856 let mut cursor = node.walk();
1857 let mut result = ::std::vec::Vec::new();
1858 if cursor.goto_first_child() {
1859 loop {
1860 if cursor.field_name().is_none()
1861 && cursor.node().is_named()
1862 && !cursor.node().is_extra()
1863 {
1864 result.push(cursor.node());
1865 }
1866 if !cursor.goto_next_sibling() {
1867 break;
1868 }
1869 }
1870 }
1871 result
1872 };
1873 let child = if let Some(&c) = non_field_children.first() {
1874 c
1875 } else {
1876 let mut fallback_cursor = node.walk();
1877 let mut fallback_child = None;
1878 if fallback_cursor.goto_first_child() {
1879 loop {
1880 if fallback_cursor.field_name().is_none()
1881 && !fallback_cursor.node().is_extra()
1882 {
1883 let candidate = fallback_cursor.node();
1884 #[allow(clippy::needless_question_mark)]
1885 if (|| -> ::core::result::Result<
1886 _,
1887 ::treesitter_types::ParseError,
1888 > {
1889 let child = candidate;
1890 Ok(
1891 <Expression as ::treesitter_types::FromNode>::from_node(
1892 child,
1893 src,
1894 )?,
1895 )
1896 })()
1897 .is_ok()
1898 {
1899 fallback_child = Some(candidate);
1900 break;
1901 }
1902 }
1903 if !fallback_cursor.goto_next_sibling() {
1904 break;
1905 }
1906 }
1907 }
1908 if fallback_child.is_none() {
1909 let mut cursor2 = node.walk();
1910 if cursor2.goto_first_child() {
1911 loop {
1912 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1913 let candidate = cursor2.node();
1914 #[allow(clippy::needless_question_mark)]
1915 if (|| -> ::core::result::Result<
1916 _,
1917 ::treesitter_types::ParseError,
1918 > {
1919 let child = candidate;
1920 Ok(
1921 <Expression as ::treesitter_types::FromNode>::from_node(
1922 child,
1923 src,
1924 )?,
1925 )
1926 })()
1927 .is_ok()
1928 {
1929 fallback_child = Some(candidate);
1930 break;
1931 }
1932 }
1933 if !cursor2.goto_next_sibling() {
1934 break;
1935 }
1936 }
1937 }
1938 }
1939 fallback_child.ok_or_else(|| {
1940 ::treesitter_types::ParseError::missing_field("children", node)
1941 })?
1942 };
1943 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1944 },
1945 })
1946 }
1947}
1948impl ::treesitter_types::Spanned for BitfieldClause<'_> {
1949 fn span(&self) -> ::treesitter_types::Span {
1950 self.span
1951 }
1952}
1953#[derive(Debug, Clone)]
1954pub struct BreakStatement<'tree> {
1955 pub span: ::treesitter_types::Span,
1956 text: &'tree str,
1957}
1958impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1959 fn from_node(
1960 node: ::tree_sitter::Node<'tree>,
1961 src: &'tree [u8],
1962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1963 debug_assert_eq!(node.kind(), "break_statement");
1964 Ok(Self {
1965 span: ::treesitter_types::Span::from(node),
1966 text: node.utf8_text(src)?,
1967 })
1968 }
1969}
1970impl<'tree> ::treesitter_types::LeafNode<'tree> for BreakStatement<'tree> {
1971 fn text(&self) -> &'tree str {
1972 self.text
1973 }
1974}
1975impl ::treesitter_types::Spanned for BreakStatement<'_> {
1976 fn span(&self) -> ::treesitter_types::Span {
1977 self.span
1978 }
1979}
1980#[derive(Debug, Clone)]
1981pub struct CallExpression<'tree> {
1982 pub span: ::treesitter_types::Span,
1983 pub arguments: ArgumentList<'tree>,
1984 pub function: CallExpressionFunction<'tree>,
1985}
1986impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1987 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1988 fn from_node(
1989 node: ::tree_sitter::Node<'tree>,
1990 src: &'tree [u8],
1991 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1992 debug_assert_eq!(node.kind(), "call_expression");
1993 Ok(Self {
1994 span: ::treesitter_types::Span::from(node),
1995 arguments: {
1996 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1997 ::treesitter_types::ParseError::missing_field("arguments", node)
1998 })?;
1999 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
2000 },
2001 function: {
2002 let child = node.child_by_field_name("function").ok_or_else(|| {
2003 ::treesitter_types::ParseError::missing_field("function", node)
2004 })?;
2005 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
2006 },
2007 })
2008 }
2009}
2010impl ::treesitter_types::Spanned for CallExpression<'_> {
2011 fn span(&self) -> ::treesitter_types::Span {
2012 self.span
2013 }
2014}
2015#[derive(Debug, Clone)]
2016pub struct CaseStatement<'tree> {
2017 pub span: ::treesitter_types::Span,
2018 pub value: ::core::option::Option<Expression<'tree>>,
2019 pub children: ::std::vec::Vec<CaseStatementChildren<'tree>>,
2020}
2021impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatement<'tree> {
2022 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2023 fn from_node(
2024 node: ::tree_sitter::Node<'tree>,
2025 src: &'tree [u8],
2026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2027 debug_assert_eq!(node.kind(), "case_statement");
2028 Ok(Self {
2029 span: ::treesitter_types::Span::from(node),
2030 value: match node.child_by_field_name("value") {
2031 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2032 child, src,
2033 )?),
2034 None => None,
2035 },
2036 children: {
2037 #[allow(clippy::suspicious_else_formatting)]
2038 let non_field_children = {
2039 let mut cursor = node.walk();
2040 let mut result = ::std::vec::Vec::new();
2041 if cursor.goto_first_child() {
2042 loop {
2043 if cursor.field_name().is_none()
2044 && cursor.node().is_named()
2045 && !cursor.node().is_extra()
2046 {
2047 result.push(cursor.node());
2048 }
2049 if !cursor.goto_next_sibling() {
2050 break;
2051 }
2052 }
2053 }
2054 result
2055 };
2056 let mut items = ::std::vec::Vec::new();
2057 for child in non_field_children {
2058 items.push(
2059 <CaseStatementChildren as ::treesitter_types::FromNode>::from_node(
2060 child, src,
2061 )?,
2062 );
2063 }
2064 items
2065 },
2066 })
2067 }
2068}
2069impl ::treesitter_types::Spanned for CaseStatement<'_> {
2070 fn span(&self) -> ::treesitter_types::Span {
2071 self.span
2072 }
2073}
2074#[derive(Debug, Clone)]
2075pub struct CastExpression<'tree> {
2076 pub span: ::treesitter_types::Span,
2077 pub r#type: TypeDescriptor<'tree>,
2078 pub value: Expression<'tree>,
2079}
2080impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
2081 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2082 fn from_node(
2083 node: ::tree_sitter::Node<'tree>,
2084 src: &'tree [u8],
2085 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2086 debug_assert_eq!(node.kind(), "cast_expression");
2087 Ok(Self {
2088 span: ::treesitter_types::Span::from(node),
2089 r#type: {
2090 let child = node
2091 .child_by_field_name("type")
2092 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2093 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)?
2094 },
2095 value: {
2096 let child = node
2097 .child_by_field_name("value")
2098 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2099 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2100 },
2101 })
2102 }
2103}
2104impl ::treesitter_types::Spanned for CastExpression<'_> {
2105 fn span(&self) -> ::treesitter_types::Span {
2106 self.span
2107 }
2108}
2109#[derive(Debug, Clone)]
2110pub struct CatchClause<'tree> {
2111 pub span: ::treesitter_types::Span,
2112 pub body: CompoundStatement<'tree>,
2113 pub parameters: ParameterList<'tree>,
2114}
2115impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2116 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2117 fn from_node(
2118 node: ::tree_sitter::Node<'tree>,
2119 src: &'tree [u8],
2120 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2121 debug_assert_eq!(node.kind(), "catch_clause");
2122 Ok(Self {
2123 span: ::treesitter_types::Span::from(node),
2124 body: {
2125 let child = node
2126 .child_by_field_name("body")
2127 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2128 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
2129 },
2130 parameters: {
2131 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2132 ::treesitter_types::ParseError::missing_field("parameters", node)
2133 })?;
2134 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
2135 },
2136 })
2137 }
2138}
2139impl ::treesitter_types::Spanned for CatchClause<'_> {
2140 fn span(&self) -> ::treesitter_types::Span {
2141 self.span
2142 }
2143}
2144#[derive(Debug, Clone)]
2145pub struct CharLiteral<'tree> {
2146 pub span: ::treesitter_types::Span,
2147 pub children: ::std::vec::Vec<CharLiteralChildren<'tree>>,
2148}
2149impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteral<'tree> {
2150 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2151 fn from_node(
2152 node: ::tree_sitter::Node<'tree>,
2153 src: &'tree [u8],
2154 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2155 debug_assert_eq!(node.kind(), "char_literal");
2156 Ok(Self {
2157 span: ::treesitter_types::Span::from(node),
2158 children: {
2159 #[allow(clippy::suspicious_else_formatting)]
2160 let non_field_children = {
2161 let mut cursor = node.walk();
2162 let mut result = ::std::vec::Vec::new();
2163 if cursor.goto_first_child() {
2164 loop {
2165 if cursor.field_name().is_none()
2166 && cursor.node().is_named()
2167 && !cursor.node().is_extra()
2168 {
2169 result.push(cursor.node());
2170 }
2171 if !cursor.goto_next_sibling() {
2172 break;
2173 }
2174 }
2175 }
2176 result
2177 };
2178 let mut items = ::std::vec::Vec::new();
2179 for child in non_field_children {
2180 items.push(
2181 <CharLiteralChildren as ::treesitter_types::FromNode>::from_node(
2182 child, src,
2183 )?,
2184 );
2185 }
2186 items
2187 },
2188 })
2189 }
2190}
2191impl ::treesitter_types::Spanned for CharLiteral<'_> {
2192 fn span(&self) -> ::treesitter_types::Span {
2193 self.span
2194 }
2195}
2196#[derive(Debug, Clone)]
2197pub struct ClassSpecifier<'tree> {
2198 pub span: ::treesitter_types::Span,
2199 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
2200 pub name: ::core::option::Option<ClassSpecifierName<'tree>>,
2201 pub children: ::std::vec::Vec<ClassSpecifierChildren<'tree>>,
2202}
2203impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifier<'tree> {
2204 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2205 fn from_node(
2206 node: ::tree_sitter::Node<'tree>,
2207 src: &'tree [u8],
2208 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2209 debug_assert_eq!(node.kind(), "class_specifier");
2210 Ok(Self {
2211 span: ::treesitter_types::Span::from(node),
2212 body: match node.child_by_field_name("body") {
2213 Some(child) => Some(
2214 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?,
2215 ),
2216 None => None,
2217 },
2218 name: match node.child_by_field_name("name") {
2219 Some(child) => Some(
2220 <ClassSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?,
2221 ),
2222 None => None,
2223 },
2224 children: {
2225 #[allow(clippy::suspicious_else_formatting)]
2226 let non_field_children = {
2227 let mut cursor = node.walk();
2228 let mut result = ::std::vec::Vec::new();
2229 if cursor.goto_first_child() {
2230 loop {
2231 if cursor.field_name().is_none()
2232 && cursor.node().is_named()
2233 && !cursor.node().is_extra()
2234 {
2235 result.push(cursor.node());
2236 }
2237 if !cursor.goto_next_sibling() {
2238 break;
2239 }
2240 }
2241 }
2242 result
2243 };
2244 let mut items = ::std::vec::Vec::new();
2245 for child in non_field_children {
2246 items.push(
2247 <ClassSpecifierChildren as ::treesitter_types::FromNode>::from_node(
2248 child, src,
2249 )?,
2250 );
2251 }
2252 items
2253 },
2254 })
2255 }
2256}
2257impl ::treesitter_types::Spanned for ClassSpecifier<'_> {
2258 fn span(&self) -> ::treesitter_types::Span {
2259 self.span
2260 }
2261}
2262#[derive(Debug, Clone)]
2263pub struct CoAwaitExpression<'tree> {
2264 pub span: ::treesitter_types::Span,
2265 pub argument: Expression<'tree>,
2266 pub operator: CoAwaitExpressionOperator,
2267}
2268impl<'tree> ::treesitter_types::FromNode<'tree> for CoAwaitExpression<'tree> {
2269 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2270 fn from_node(
2271 node: ::tree_sitter::Node<'tree>,
2272 src: &'tree [u8],
2273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2274 debug_assert_eq!(node.kind(), "co_await_expression");
2275 Ok(Self {
2276 span: ::treesitter_types::Span::from(node),
2277 argument: {
2278 let child = node.child_by_field_name("argument").ok_or_else(|| {
2279 ::treesitter_types::ParseError::missing_field("argument", node)
2280 })?;
2281 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2282 },
2283 operator: {
2284 let child = node.child_by_field_name("operator").ok_or_else(|| {
2285 ::treesitter_types::ParseError::missing_field("operator", node)
2286 })?;
2287 <CoAwaitExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
2288 },
2289 })
2290 }
2291}
2292impl ::treesitter_types::Spanned for CoAwaitExpression<'_> {
2293 fn span(&self) -> ::treesitter_types::Span {
2294 self.span
2295 }
2296}
2297#[derive(Debug, Clone)]
2298pub struct CoReturnStatement<'tree> {
2299 pub span: ::treesitter_types::Span,
2300 pub children: ::core::option::Option<Expression<'tree>>,
2301}
2302impl<'tree> ::treesitter_types::FromNode<'tree> for CoReturnStatement<'tree> {
2303 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2304 fn from_node(
2305 node: ::tree_sitter::Node<'tree>,
2306 src: &'tree [u8],
2307 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2308 debug_assert_eq!(node.kind(), "co_return_statement");
2309 Ok(Self {
2310 span: ::treesitter_types::Span::from(node),
2311 children: {
2312 #[allow(clippy::suspicious_else_formatting)]
2313 let non_field_children = {
2314 let mut cursor = node.walk();
2315 let mut result = ::std::vec::Vec::new();
2316 if cursor.goto_first_child() {
2317 loop {
2318 if cursor.field_name().is_none()
2319 && cursor.node().is_named()
2320 && !cursor.node().is_extra()
2321 {
2322 result.push(cursor.node());
2323 }
2324 if !cursor.goto_next_sibling() {
2325 break;
2326 }
2327 }
2328 }
2329 result
2330 };
2331 match non_field_children.first() {
2332 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2333 child, src,
2334 )?),
2335 None => None,
2336 }
2337 },
2338 })
2339 }
2340}
2341impl ::treesitter_types::Spanned for CoReturnStatement<'_> {
2342 fn span(&self) -> ::treesitter_types::Span {
2343 self.span
2344 }
2345}
2346#[derive(Debug, Clone)]
2347pub struct CoYieldStatement<'tree> {
2348 pub span: ::treesitter_types::Span,
2349 pub children: Expression<'tree>,
2350}
2351impl<'tree> ::treesitter_types::FromNode<'tree> for CoYieldStatement<'tree> {
2352 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2353 fn from_node(
2354 node: ::tree_sitter::Node<'tree>,
2355 src: &'tree [u8],
2356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2357 debug_assert_eq!(node.kind(), "co_yield_statement");
2358 Ok(Self {
2359 span: ::treesitter_types::Span::from(node),
2360 children: {
2361 #[allow(clippy::suspicious_else_formatting)]
2362 let non_field_children = {
2363 let mut cursor = node.walk();
2364 let mut result = ::std::vec::Vec::new();
2365 if cursor.goto_first_child() {
2366 loop {
2367 if cursor.field_name().is_none()
2368 && cursor.node().is_named()
2369 && !cursor.node().is_extra()
2370 {
2371 result.push(cursor.node());
2372 }
2373 if !cursor.goto_next_sibling() {
2374 break;
2375 }
2376 }
2377 }
2378 result
2379 };
2380 let child = if let Some(&c) = non_field_children.first() {
2381 c
2382 } else {
2383 let mut fallback_cursor = node.walk();
2384 let mut fallback_child = None;
2385 if fallback_cursor.goto_first_child() {
2386 loop {
2387 if fallback_cursor.field_name().is_none()
2388 && !fallback_cursor.node().is_extra()
2389 {
2390 let candidate = fallback_cursor.node();
2391 #[allow(clippy::needless_question_mark)]
2392 if (|| -> ::core::result::Result<
2393 _,
2394 ::treesitter_types::ParseError,
2395 > {
2396 let child = candidate;
2397 Ok(
2398 <Expression as ::treesitter_types::FromNode>::from_node(
2399 child,
2400 src,
2401 )?,
2402 )
2403 })()
2404 .is_ok()
2405 {
2406 fallback_child = Some(candidate);
2407 break;
2408 }
2409 }
2410 if !fallback_cursor.goto_next_sibling() {
2411 break;
2412 }
2413 }
2414 }
2415 if fallback_child.is_none() {
2416 let mut cursor2 = node.walk();
2417 if cursor2.goto_first_child() {
2418 loop {
2419 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2420 let candidate = cursor2.node();
2421 #[allow(clippy::needless_question_mark)]
2422 if (|| -> ::core::result::Result<
2423 _,
2424 ::treesitter_types::ParseError,
2425 > {
2426 let child = candidate;
2427 Ok(
2428 <Expression as ::treesitter_types::FromNode>::from_node(
2429 child,
2430 src,
2431 )?,
2432 )
2433 })()
2434 .is_ok()
2435 {
2436 fallback_child = Some(candidate);
2437 break;
2438 }
2439 }
2440 if !cursor2.goto_next_sibling() {
2441 break;
2442 }
2443 }
2444 }
2445 }
2446 fallback_child.ok_or_else(|| {
2447 ::treesitter_types::ParseError::missing_field("children", node)
2448 })?
2449 };
2450 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2451 },
2452 })
2453 }
2454}
2455impl ::treesitter_types::Spanned for CoYieldStatement<'_> {
2456 fn span(&self) -> ::treesitter_types::Span {
2457 self.span
2458 }
2459}
2460#[derive(Debug, Clone)]
2461pub struct CommaExpression<'tree> {
2462 pub span: ::treesitter_types::Span,
2463 pub left: Expression<'tree>,
2464 pub right: CommaExpressionRight<'tree>,
2465}
2466impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpression<'tree> {
2467 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2468 fn from_node(
2469 node: ::tree_sitter::Node<'tree>,
2470 src: &'tree [u8],
2471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2472 debug_assert_eq!(node.kind(), "comma_expression");
2473 Ok(Self {
2474 span: ::treesitter_types::Span::from(node),
2475 left: {
2476 let child = node
2477 .child_by_field_name("left")
2478 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2479 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2480 },
2481 right: {
2482 let child = node
2483 .child_by_field_name("right")
2484 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2485 <CommaExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
2486 },
2487 })
2488 }
2489}
2490impl ::treesitter_types::Spanned for CommaExpression<'_> {
2491 fn span(&self) -> ::treesitter_types::Span {
2492 self.span
2493 }
2494}
2495#[derive(Debug, Clone)]
2496pub struct CompoundLiteralExpression<'tree> {
2497 pub span: ::treesitter_types::Span,
2498 pub r#type: CompoundLiteralExpressionType<'tree>,
2499 pub value: InitializerList<'tree>,
2500}
2501impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundLiteralExpression<'tree> {
2502 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2503 fn from_node(
2504 node: ::tree_sitter::Node<'tree>,
2505 src: &'tree [u8],
2506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2507 debug_assert_eq!(node.kind(), "compound_literal_expression");
2508 Ok(Self {
2509 span: ::treesitter_types::Span::from(node),
2510 r#type: {
2511 let child = node
2512 .child_by_field_name("type")
2513 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2514 <CompoundLiteralExpressionType as ::treesitter_types::FromNode>::from_node(
2515 child, src,
2516 )?
2517 },
2518 value: {
2519 let child = node
2520 .child_by_field_name("value")
2521 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2522 <InitializerList as ::treesitter_types::FromNode>::from_node(child, src)?
2523 },
2524 })
2525 }
2526}
2527impl ::treesitter_types::Spanned for CompoundLiteralExpression<'_> {
2528 fn span(&self) -> ::treesitter_types::Span {
2529 self.span
2530 }
2531}
2532#[derive(Debug, Clone)]
2533pub struct CompoundRequirement<'tree> {
2534 pub span: ::treesitter_types::Span,
2535 pub children: ::std::vec::Vec<CompoundRequirementChildren<'tree>>,
2536}
2537impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundRequirement<'tree> {
2538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2539 fn from_node(
2540 node: ::tree_sitter::Node<'tree>,
2541 src: &'tree [u8],
2542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2543 debug_assert_eq!(node.kind(), "compound_requirement");
2544 Ok(Self {
2545 span: ::treesitter_types::Span::from(node),
2546 children: {
2547 #[allow(clippy::suspicious_else_formatting)]
2548 let non_field_children = {
2549 let mut cursor = node.walk();
2550 let mut result = ::std::vec::Vec::new();
2551 if cursor.goto_first_child() {
2552 loop {
2553 if cursor.field_name().is_none()
2554 && cursor.node().is_named()
2555 && !cursor.node().is_extra()
2556 {
2557 result.push(cursor.node());
2558 }
2559 if !cursor.goto_next_sibling() {
2560 break;
2561 }
2562 }
2563 }
2564 result
2565 };
2566 let mut items = ::std::vec::Vec::new();
2567 for child in non_field_children {
2568 items.push(
2569 <CompoundRequirementChildren as ::treesitter_types::FromNode>::from_node(
2570 child, src,
2571 )?,
2572 );
2573 }
2574 items
2575 },
2576 })
2577 }
2578}
2579impl ::treesitter_types::Spanned for CompoundRequirement<'_> {
2580 fn span(&self) -> ::treesitter_types::Span {
2581 self.span
2582 }
2583}
2584#[derive(Debug, Clone)]
2585pub struct CompoundStatement<'tree> {
2586 pub span: ::treesitter_types::Span,
2587 pub children: ::std::vec::Vec<CompoundStatementChildren<'tree>>,
2588}
2589impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatement<'tree> {
2590 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2591 fn from_node(
2592 node: ::tree_sitter::Node<'tree>,
2593 src: &'tree [u8],
2594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2595 debug_assert_eq!(node.kind(), "compound_statement");
2596 Ok(Self {
2597 span: ::treesitter_types::Span::from(node),
2598 children: {
2599 #[allow(clippy::suspicious_else_formatting)]
2600 let non_field_children = {
2601 let mut cursor = node.walk();
2602 let mut result = ::std::vec::Vec::new();
2603 if cursor.goto_first_child() {
2604 loop {
2605 if cursor.field_name().is_none()
2606 && cursor.node().is_named()
2607 && !cursor.node().is_extra()
2608 {
2609 result.push(cursor.node());
2610 }
2611 if !cursor.goto_next_sibling() {
2612 break;
2613 }
2614 }
2615 }
2616 result
2617 };
2618 let mut items = ::std::vec::Vec::new();
2619 for child in non_field_children {
2620 items.push(
2621 <CompoundStatementChildren as ::treesitter_types::FromNode>::from_node(
2622 child, src,
2623 )?,
2624 );
2625 }
2626 items
2627 },
2628 })
2629 }
2630}
2631impl ::treesitter_types::Spanned for CompoundStatement<'_> {
2632 fn span(&self) -> ::treesitter_types::Span {
2633 self.span
2634 }
2635}
2636#[derive(Debug, Clone)]
2637pub struct ConcatenatedString<'tree> {
2638 pub span: ::treesitter_types::Span,
2639 pub children: ::std::vec::Vec<ConcatenatedStringChildren<'tree>>,
2640}
2641impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedString<'tree> {
2642 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2643 fn from_node(
2644 node: ::tree_sitter::Node<'tree>,
2645 src: &'tree [u8],
2646 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2647 debug_assert_eq!(node.kind(), "concatenated_string");
2648 Ok(Self {
2649 span: ::treesitter_types::Span::from(node),
2650 children: {
2651 #[allow(clippy::suspicious_else_formatting)]
2652 let non_field_children = {
2653 let mut cursor = node.walk();
2654 let mut result = ::std::vec::Vec::new();
2655 if cursor.goto_first_child() {
2656 loop {
2657 if cursor.field_name().is_none()
2658 && cursor.node().is_named()
2659 && !cursor.node().is_extra()
2660 {
2661 result.push(cursor.node());
2662 }
2663 if !cursor.goto_next_sibling() {
2664 break;
2665 }
2666 }
2667 }
2668 result
2669 };
2670 let mut items = ::std::vec::Vec::new();
2671 for child in non_field_children {
2672 items.push(
2673 <ConcatenatedStringChildren as ::treesitter_types::FromNode>::from_node(
2674 child, src,
2675 )?,
2676 );
2677 }
2678 items
2679 },
2680 })
2681 }
2682}
2683impl ::treesitter_types::Spanned for ConcatenatedString<'_> {
2684 fn span(&self) -> ::treesitter_types::Span {
2685 self.span
2686 }
2687}
2688#[derive(Debug, Clone)]
2689pub struct ConceptDefinition<'tree> {
2690 pub span: ::treesitter_types::Span,
2691 pub name: Identifier<'tree>,
2692 pub children: Expression<'tree>,
2693}
2694impl<'tree> ::treesitter_types::FromNode<'tree> for ConceptDefinition<'tree> {
2695 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2696 fn from_node(
2697 node: ::tree_sitter::Node<'tree>,
2698 src: &'tree [u8],
2699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2700 debug_assert_eq!(node.kind(), "concept_definition");
2701 Ok(Self {
2702 span: ::treesitter_types::Span::from(node),
2703 name: {
2704 let child = node
2705 .child_by_field_name("name")
2706 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2707 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2708 },
2709 children: {
2710 #[allow(clippy::suspicious_else_formatting)]
2711 let non_field_children = {
2712 let mut cursor = node.walk();
2713 let mut result = ::std::vec::Vec::new();
2714 if cursor.goto_first_child() {
2715 loop {
2716 if cursor.field_name().is_none()
2717 && cursor.node().is_named()
2718 && !cursor.node().is_extra()
2719 {
2720 result.push(cursor.node());
2721 }
2722 if !cursor.goto_next_sibling() {
2723 break;
2724 }
2725 }
2726 }
2727 result
2728 };
2729 let child = if let Some(&c) = non_field_children.first() {
2730 c
2731 } else {
2732 let mut fallback_cursor = node.walk();
2733 let mut fallback_child = None;
2734 if fallback_cursor.goto_first_child() {
2735 loop {
2736 if fallback_cursor.field_name().is_none()
2737 && !fallback_cursor.node().is_extra()
2738 {
2739 let candidate = fallback_cursor.node();
2740 #[allow(clippy::needless_question_mark)]
2741 if (|| -> ::core::result::Result<
2742 _,
2743 ::treesitter_types::ParseError,
2744 > {
2745 let child = candidate;
2746 Ok(
2747 <Expression as ::treesitter_types::FromNode>::from_node(
2748 child,
2749 src,
2750 )?,
2751 )
2752 })()
2753 .is_ok()
2754 {
2755 fallback_child = Some(candidate);
2756 break;
2757 }
2758 }
2759 if !fallback_cursor.goto_next_sibling() {
2760 break;
2761 }
2762 }
2763 }
2764 if fallback_child.is_none() {
2765 let mut cursor2 = node.walk();
2766 if cursor2.goto_first_child() {
2767 loop {
2768 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2769 let candidate = cursor2.node();
2770 #[allow(clippy::needless_question_mark)]
2771 if (|| -> ::core::result::Result<
2772 _,
2773 ::treesitter_types::ParseError,
2774 > {
2775 let child = candidate;
2776 Ok(
2777 <Expression as ::treesitter_types::FromNode>::from_node(
2778 child,
2779 src,
2780 )?,
2781 )
2782 })()
2783 .is_ok()
2784 {
2785 fallback_child = Some(candidate);
2786 break;
2787 }
2788 }
2789 if !cursor2.goto_next_sibling() {
2790 break;
2791 }
2792 }
2793 }
2794 }
2795 fallback_child.ok_or_else(|| {
2796 ::treesitter_types::ParseError::missing_field("children", node)
2797 })?
2798 };
2799 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2800 },
2801 })
2802 }
2803}
2804impl ::treesitter_types::Spanned for ConceptDefinition<'_> {
2805 fn span(&self) -> ::treesitter_types::Span {
2806 self.span
2807 }
2808}
2809#[derive(Debug, Clone)]
2810pub struct ConditionClause<'tree> {
2811 pub span: ::treesitter_types::Span,
2812 pub initializer: ::core::option::Option<InitStatement<'tree>>,
2813 pub value: ConditionClauseValue<'tree>,
2814}
2815impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionClause<'tree> {
2816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2817 fn from_node(
2818 node: ::tree_sitter::Node<'tree>,
2819 src: &'tree [u8],
2820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2821 debug_assert_eq!(node.kind(), "condition_clause");
2822 Ok(Self {
2823 span: ::treesitter_types::Span::from(node),
2824 initializer: match node.child_by_field_name("initializer") {
2825 Some(child) => Some(<InitStatement as ::treesitter_types::FromNode>::from_node(
2826 child, src,
2827 )?),
2828 None => None,
2829 },
2830 value: {
2831 let child = node
2832 .child_by_field_name("value")
2833 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2834 <ConditionClauseValue as ::treesitter_types::FromNode>::from_node(child, src)?
2835 },
2836 })
2837 }
2838}
2839impl ::treesitter_types::Spanned for ConditionClause<'_> {
2840 fn span(&self) -> ::treesitter_types::Span {
2841 self.span
2842 }
2843}
2844#[derive(Debug, Clone)]
2845pub struct ConditionalExpression<'tree> {
2846 pub span: ::treesitter_types::Span,
2847 pub alternative: Expression<'tree>,
2848 pub condition: Expression<'tree>,
2849 pub consequence: ::core::option::Option<ConditionalExpressionConsequence<'tree>>,
2850}
2851impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
2852 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2853 fn from_node(
2854 node: ::tree_sitter::Node<'tree>,
2855 src: &'tree [u8],
2856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2857 debug_assert_eq!(node.kind(), "conditional_expression");
2858 Ok(Self {
2859 span: ::treesitter_types::Span::from(node),
2860 alternative: {
2861 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2862 ::treesitter_types::ParseError::missing_field("alternative", node)
2863 })?;
2864 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2865 },
2866 condition: {
2867 let child = node.child_by_field_name("condition").ok_or_else(|| {
2868 ::treesitter_types::ParseError::missing_field("condition", node)
2869 })?;
2870 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2871 },
2872 consequence: match node.child_by_field_name("consequence") {
2873 Some(child) => Some(
2874 <ConditionalExpressionConsequence as ::treesitter_types::FromNode>::from_node(
2875 child, src,
2876 )?,
2877 ),
2878 None => None,
2879 },
2880 })
2881 }
2882}
2883impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
2884 fn span(&self) -> ::treesitter_types::Span {
2885 self.span
2886 }
2887}
2888#[derive(Debug, Clone)]
2889pub struct ConstraintConjunction<'tree> {
2890 pub span: ::treesitter_types::Span,
2891 pub left: ::std::vec::Vec<ConstraintConjunctionLeft<'tree>>,
2892 pub operator: ConstraintConjunctionOperator,
2893 pub right: ::std::vec::Vec<ConstraintConjunctionRight<'tree>>,
2894}
2895impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunction<'tree> {
2896 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2897 fn from_node(
2898 node: ::tree_sitter::Node<'tree>,
2899 src: &'tree [u8],
2900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2901 debug_assert_eq!(node.kind(), "constraint_conjunction");
2902 Ok(Self {
2903 span: ::treesitter_types::Span::from(node),
2904 left: {
2905 let mut cursor = node.walk();
2906 let mut items = ::std::vec::Vec::new();
2907 for child in node.children_by_field_name("left", &mut cursor) {
2908 items.push(
2909 <ConstraintConjunctionLeft as ::treesitter_types::FromNode>::from_node(
2910 child, src,
2911 )?,
2912 );
2913 }
2914 items
2915 },
2916 operator: {
2917 let child = node.child_by_field_name("operator").ok_or_else(|| {
2918 ::treesitter_types::ParseError::missing_field("operator", node)
2919 })?;
2920 <ConstraintConjunctionOperator as ::treesitter_types::FromNode>::from_node(
2921 child, src,
2922 )?
2923 },
2924 right: {
2925 let mut cursor = node.walk();
2926 let mut items = ::std::vec::Vec::new();
2927 for child in node.children_by_field_name("right", &mut cursor) {
2928 items.push(
2929 <ConstraintConjunctionRight as ::treesitter_types::FromNode>::from_node(
2930 child, src,
2931 )?,
2932 );
2933 }
2934 items
2935 },
2936 })
2937 }
2938}
2939impl ::treesitter_types::Spanned for ConstraintConjunction<'_> {
2940 fn span(&self) -> ::treesitter_types::Span {
2941 self.span
2942 }
2943}
2944#[derive(Debug, Clone)]
2945pub struct ConstraintDisjunction<'tree> {
2946 pub span: ::treesitter_types::Span,
2947 pub left: ::std::vec::Vec<ConstraintDisjunctionLeft<'tree>>,
2948 pub operator: ConstraintDisjunctionOperator,
2949 pub right: ::std::vec::Vec<ConstraintDisjunctionRight<'tree>>,
2950}
2951impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunction<'tree> {
2952 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2953 fn from_node(
2954 node: ::tree_sitter::Node<'tree>,
2955 src: &'tree [u8],
2956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2957 debug_assert_eq!(node.kind(), "constraint_disjunction");
2958 Ok(Self {
2959 span: ::treesitter_types::Span::from(node),
2960 left: {
2961 let mut cursor = node.walk();
2962 let mut items = ::std::vec::Vec::new();
2963 for child in node.children_by_field_name("left", &mut cursor) {
2964 items.push(
2965 <ConstraintDisjunctionLeft as ::treesitter_types::FromNode>::from_node(
2966 child, src,
2967 )?,
2968 );
2969 }
2970 items
2971 },
2972 operator: {
2973 let child = node.child_by_field_name("operator").ok_or_else(|| {
2974 ::treesitter_types::ParseError::missing_field("operator", node)
2975 })?;
2976 <ConstraintDisjunctionOperator as ::treesitter_types::FromNode>::from_node(
2977 child, src,
2978 )?
2979 },
2980 right: {
2981 let mut cursor = node.walk();
2982 let mut items = ::std::vec::Vec::new();
2983 for child in node.children_by_field_name("right", &mut cursor) {
2984 items.push(
2985 <ConstraintDisjunctionRight as ::treesitter_types::FromNode>::from_node(
2986 child, src,
2987 )?,
2988 );
2989 }
2990 items
2991 },
2992 })
2993 }
2994}
2995impl ::treesitter_types::Spanned for ConstraintDisjunction<'_> {
2996 fn span(&self) -> ::treesitter_types::Span {
2997 self.span
2998 }
2999}
3000#[derive(Debug, Clone)]
3001pub struct ContinueStatement<'tree> {
3002 pub span: ::treesitter_types::Span,
3003 text: &'tree str,
3004}
3005impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
3006 fn from_node(
3007 node: ::tree_sitter::Node<'tree>,
3008 src: &'tree [u8],
3009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3010 debug_assert_eq!(node.kind(), "continue_statement");
3011 Ok(Self {
3012 span: ::treesitter_types::Span::from(node),
3013 text: node.utf8_text(src)?,
3014 })
3015 }
3016}
3017impl<'tree> ::treesitter_types::LeafNode<'tree> for ContinueStatement<'tree> {
3018 fn text(&self) -> &'tree str {
3019 self.text
3020 }
3021}
3022impl ::treesitter_types::Spanned for ContinueStatement<'_> {
3023 fn span(&self) -> ::treesitter_types::Span {
3024 self.span
3025 }
3026}
3027#[derive(Debug, Clone)]
3028pub struct Declaration<'tree> {
3029 pub span: ::treesitter_types::Span,
3030 pub declarator: ::std::vec::Vec<DeclarationDeclarator<'tree>>,
3031 pub default_value: ::core::option::Option<Expression<'tree>>,
3032 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
3033 pub value: ::core::option::Option<DeclarationValue<'tree>>,
3034 pub children: ::std::vec::Vec<DeclarationChildren<'tree>>,
3035}
3036impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
3037 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3038 fn from_node(
3039 node: ::tree_sitter::Node<'tree>,
3040 src: &'tree [u8],
3041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3042 debug_assert_eq!(node.kind(), "declaration");
3043 Ok(Self {
3044 span: ::treesitter_types::Span::from(node),
3045 declarator: {
3046 let mut cursor = node.walk();
3047 let mut items = ::std::vec::Vec::new();
3048 for child in node.children_by_field_name("declarator", &mut cursor) {
3049 items.push(
3050 <DeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
3051 child, src,
3052 )?,
3053 );
3054 }
3055 items
3056 },
3057 default_value: match node.child_by_field_name("default_value") {
3058 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3059 child, src,
3060 )?),
3061 None => None,
3062 },
3063 r#type: match node.child_by_field_name("type") {
3064 Some(child) => Some(<TypeSpecifier as ::treesitter_types::FromNode>::from_node(
3065 child, src,
3066 )?),
3067 None => None,
3068 },
3069 value: match node.child_by_field_name("value") {
3070 Some(child) => {
3071 Some(<DeclarationValue as ::treesitter_types::FromNode>::from_node(child, src)?)
3072 }
3073 None => None,
3074 },
3075 children: {
3076 #[allow(clippy::suspicious_else_formatting)]
3077 let non_field_children = {
3078 let mut cursor = node.walk();
3079 let mut result = ::std::vec::Vec::new();
3080 if cursor.goto_first_child() {
3081 loop {
3082 if cursor.field_name().is_none()
3083 && cursor.node().is_named()
3084 && !cursor.node().is_extra()
3085 {
3086 result.push(cursor.node());
3087 }
3088 if !cursor.goto_next_sibling() {
3089 break;
3090 }
3091 }
3092 }
3093 result
3094 };
3095 let mut items = ::std::vec::Vec::new();
3096 for child in non_field_children {
3097 items.push(
3098 <DeclarationChildren as ::treesitter_types::FromNode>::from_node(
3099 child, src,
3100 )?,
3101 );
3102 }
3103 items
3104 },
3105 })
3106 }
3107}
3108impl ::treesitter_types::Spanned for Declaration<'_> {
3109 fn span(&self) -> ::treesitter_types::Span {
3110 self.span
3111 }
3112}
3113#[derive(Debug, Clone)]
3114pub struct DeclarationList<'tree> {
3115 pub span: ::treesitter_types::Span,
3116 pub children: ::std::vec::Vec<DeclarationListChildren<'tree>>,
3117}
3118impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
3119 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3120 fn from_node(
3121 node: ::tree_sitter::Node<'tree>,
3122 src: &'tree [u8],
3123 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3124 debug_assert_eq!(node.kind(), "declaration_list");
3125 Ok(Self {
3126 span: ::treesitter_types::Span::from(node),
3127 children: {
3128 #[allow(clippy::suspicious_else_formatting)]
3129 let non_field_children = {
3130 let mut cursor = node.walk();
3131 let mut result = ::std::vec::Vec::new();
3132 if cursor.goto_first_child() {
3133 loop {
3134 if cursor.field_name().is_none()
3135 && cursor.node().is_named()
3136 && !cursor.node().is_extra()
3137 {
3138 result.push(cursor.node());
3139 }
3140 if !cursor.goto_next_sibling() {
3141 break;
3142 }
3143 }
3144 }
3145 result
3146 };
3147 let mut items = ::std::vec::Vec::new();
3148 for child in non_field_children {
3149 items.push(
3150 <DeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3151 child, src,
3152 )?,
3153 );
3154 }
3155 items
3156 },
3157 })
3158 }
3159}
3160impl ::treesitter_types::Spanned for DeclarationList<'_> {
3161 fn span(&self) -> ::treesitter_types::Span {
3162 self.span
3163 }
3164}
3165#[derive(Debug, Clone)]
3166pub struct Decltype<'tree> {
3167 pub span: ::treesitter_types::Span,
3168 pub children: DecltypeChildren<'tree>,
3169}
3170impl<'tree> ::treesitter_types::FromNode<'tree> for Decltype<'tree> {
3171 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3172 fn from_node(
3173 node: ::tree_sitter::Node<'tree>,
3174 src: &'tree [u8],
3175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3176 debug_assert_eq!(node.kind(), "decltype");
3177 Ok(Self {
3178 span: ::treesitter_types::Span::from(node),
3179 children: {
3180 #[allow(clippy::suspicious_else_formatting)]
3181 let non_field_children = {
3182 let mut cursor = node.walk();
3183 let mut result = ::std::vec::Vec::new();
3184 if cursor.goto_first_child() {
3185 loop {
3186 if cursor.field_name().is_none()
3187 && cursor.node().is_named()
3188 && !cursor.node().is_extra()
3189 {
3190 result.push(cursor.node());
3191 }
3192 if !cursor.goto_next_sibling() {
3193 break;
3194 }
3195 }
3196 }
3197 result
3198 };
3199 let child = if let Some(&c) = non_field_children.first() {
3200 c
3201 } else {
3202 let mut fallback_cursor = node.walk();
3203 let mut fallback_child = None;
3204 if fallback_cursor.goto_first_child() {
3205 loop {
3206 if fallback_cursor.field_name().is_none()
3207 && !fallback_cursor.node().is_extra()
3208 {
3209 let candidate = fallback_cursor.node();
3210 #[allow(clippy::needless_question_mark)]
3211 if (|| -> ::core::result::Result<
3212 _,
3213 ::treesitter_types::ParseError,
3214 > {
3215 let child = candidate;
3216 Ok(
3217 <DecltypeChildren as ::treesitter_types::FromNode>::from_node(
3218 child,
3219 src,
3220 )?,
3221 )
3222 })()
3223 .is_ok()
3224 {
3225 fallback_child = Some(candidate);
3226 break;
3227 }
3228 }
3229 if !fallback_cursor.goto_next_sibling() {
3230 break;
3231 }
3232 }
3233 }
3234 if fallback_child.is_none() {
3235 let mut cursor2 = node.walk();
3236 if cursor2.goto_first_child() {
3237 loop {
3238 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3239 let candidate = cursor2.node();
3240 #[allow(clippy::needless_question_mark)]
3241 if (|| -> ::core::result::Result<
3242 _,
3243 ::treesitter_types::ParseError,
3244 > {
3245 let child = candidate;
3246 Ok(
3247 <DecltypeChildren as ::treesitter_types::FromNode>::from_node(
3248 child,
3249 src,
3250 )?,
3251 )
3252 })()
3253 .is_ok()
3254 {
3255 fallback_child = Some(candidate);
3256 break;
3257 }
3258 }
3259 if !cursor2.goto_next_sibling() {
3260 break;
3261 }
3262 }
3263 }
3264 }
3265 fallback_child.ok_or_else(|| {
3266 ::treesitter_types::ParseError::missing_field("children", node)
3267 })?
3268 };
3269 <DecltypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3270 },
3271 })
3272 }
3273}
3274impl ::treesitter_types::Spanned for Decltype<'_> {
3275 fn span(&self) -> ::treesitter_types::Span {
3276 self.span
3277 }
3278}
3279#[derive(Debug, Clone)]
3280pub struct DefaultMethodClause<'tree> {
3281 pub span: ::treesitter_types::Span,
3282 text: &'tree str,
3283}
3284impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultMethodClause<'tree> {
3285 fn from_node(
3286 node: ::tree_sitter::Node<'tree>,
3287 src: &'tree [u8],
3288 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3289 debug_assert_eq!(node.kind(), "default_method_clause");
3290 Ok(Self {
3291 span: ::treesitter_types::Span::from(node),
3292 text: node.utf8_text(src)?,
3293 })
3294 }
3295}
3296impl<'tree> ::treesitter_types::LeafNode<'tree> for DefaultMethodClause<'tree> {
3297 fn text(&self) -> &'tree str {
3298 self.text
3299 }
3300}
3301impl ::treesitter_types::Spanned for DefaultMethodClause<'_> {
3302 fn span(&self) -> ::treesitter_types::Span {
3303 self.span
3304 }
3305}
3306#[derive(Debug, Clone)]
3307pub struct DeleteExpression<'tree> {
3308 pub span: ::treesitter_types::Span,
3309 pub children: Expression<'tree>,
3310}
3311impl<'tree> ::treesitter_types::FromNode<'tree> for DeleteExpression<'tree> {
3312 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3313 fn from_node(
3314 node: ::tree_sitter::Node<'tree>,
3315 src: &'tree [u8],
3316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3317 debug_assert_eq!(node.kind(), "delete_expression");
3318 Ok(Self {
3319 span: ::treesitter_types::Span::from(node),
3320 children: {
3321 #[allow(clippy::suspicious_else_formatting)]
3322 let non_field_children = {
3323 let mut cursor = node.walk();
3324 let mut result = ::std::vec::Vec::new();
3325 if cursor.goto_first_child() {
3326 loop {
3327 if cursor.field_name().is_none()
3328 && cursor.node().is_named()
3329 && !cursor.node().is_extra()
3330 {
3331 result.push(cursor.node());
3332 }
3333 if !cursor.goto_next_sibling() {
3334 break;
3335 }
3336 }
3337 }
3338 result
3339 };
3340 let child = if let Some(&c) = non_field_children.first() {
3341 c
3342 } else {
3343 let mut fallback_cursor = node.walk();
3344 let mut fallback_child = None;
3345 if fallback_cursor.goto_first_child() {
3346 loop {
3347 if fallback_cursor.field_name().is_none()
3348 && !fallback_cursor.node().is_extra()
3349 {
3350 let candidate = fallback_cursor.node();
3351 #[allow(clippy::needless_question_mark)]
3352 if (|| -> ::core::result::Result<
3353 _,
3354 ::treesitter_types::ParseError,
3355 > {
3356 let child = candidate;
3357 Ok(
3358 <Expression as ::treesitter_types::FromNode>::from_node(
3359 child,
3360 src,
3361 )?,
3362 )
3363 })()
3364 .is_ok()
3365 {
3366 fallback_child = Some(candidate);
3367 break;
3368 }
3369 }
3370 if !fallback_cursor.goto_next_sibling() {
3371 break;
3372 }
3373 }
3374 }
3375 if fallback_child.is_none() {
3376 let mut cursor2 = node.walk();
3377 if cursor2.goto_first_child() {
3378 loop {
3379 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3380 let candidate = cursor2.node();
3381 #[allow(clippy::needless_question_mark)]
3382 if (|| -> ::core::result::Result<
3383 _,
3384 ::treesitter_types::ParseError,
3385 > {
3386 let child = candidate;
3387 Ok(
3388 <Expression as ::treesitter_types::FromNode>::from_node(
3389 child,
3390 src,
3391 )?,
3392 )
3393 })()
3394 .is_ok()
3395 {
3396 fallback_child = Some(candidate);
3397 break;
3398 }
3399 }
3400 if !cursor2.goto_next_sibling() {
3401 break;
3402 }
3403 }
3404 }
3405 }
3406 fallback_child.ok_or_else(|| {
3407 ::treesitter_types::ParseError::missing_field("children", node)
3408 })?
3409 };
3410 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3411 },
3412 })
3413 }
3414}
3415impl ::treesitter_types::Spanned for DeleteExpression<'_> {
3416 fn span(&self) -> ::treesitter_types::Span {
3417 self.span
3418 }
3419}
3420#[derive(Debug, Clone)]
3421pub struct DeleteMethodClause<'tree> {
3422 pub span: ::treesitter_types::Span,
3423 text: &'tree str,
3424}
3425impl<'tree> ::treesitter_types::FromNode<'tree> for DeleteMethodClause<'tree> {
3426 fn from_node(
3427 node: ::tree_sitter::Node<'tree>,
3428 src: &'tree [u8],
3429 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3430 debug_assert_eq!(node.kind(), "delete_method_clause");
3431 Ok(Self {
3432 span: ::treesitter_types::Span::from(node),
3433 text: node.utf8_text(src)?,
3434 })
3435 }
3436}
3437impl<'tree> ::treesitter_types::LeafNode<'tree> for DeleteMethodClause<'tree> {
3438 fn text(&self) -> &'tree str {
3439 self.text
3440 }
3441}
3442impl ::treesitter_types::Spanned for DeleteMethodClause<'_> {
3443 fn span(&self) -> ::treesitter_types::Span {
3444 self.span
3445 }
3446}
3447#[derive(Debug, Clone)]
3448pub struct DependentName<'tree> {
3449 pub span: ::treesitter_types::Span,
3450 pub children: DependentNameChildren<'tree>,
3451}
3452impl<'tree> ::treesitter_types::FromNode<'tree> for DependentName<'tree> {
3453 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3454 fn from_node(
3455 node: ::tree_sitter::Node<'tree>,
3456 src: &'tree [u8],
3457 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3458 debug_assert_eq!(node.kind(), "dependent_name");
3459 Ok(Self {
3460 span: ::treesitter_types::Span::from(node),
3461 children: {
3462 #[allow(clippy::suspicious_else_formatting)]
3463 let non_field_children = {
3464 let mut cursor = node.walk();
3465 let mut result = ::std::vec::Vec::new();
3466 if cursor.goto_first_child() {
3467 loop {
3468 if cursor.field_name().is_none()
3469 && cursor.node().is_named()
3470 && !cursor.node().is_extra()
3471 {
3472 result.push(cursor.node());
3473 }
3474 if !cursor.goto_next_sibling() {
3475 break;
3476 }
3477 }
3478 }
3479 result
3480 };
3481 let child = if let Some(&c) = non_field_children.first() {
3482 c
3483 } else {
3484 let mut fallback_cursor = node.walk();
3485 let mut fallback_child = None;
3486 if fallback_cursor.goto_first_child() {
3487 loop {
3488 if fallback_cursor.field_name().is_none()
3489 && !fallback_cursor.node().is_extra()
3490 {
3491 let candidate = fallback_cursor.node();
3492 #[allow(clippy::needless_question_mark)]
3493 if (|| -> ::core::result::Result<
3494 _,
3495 ::treesitter_types::ParseError,
3496 > {
3497 let child = candidate;
3498 Ok(
3499 <DependentNameChildren as ::treesitter_types::FromNode>::from_node(
3500 child,
3501 src,
3502 )?,
3503 )
3504 })()
3505 .is_ok()
3506 {
3507 fallback_child = Some(candidate);
3508 break;
3509 }
3510 }
3511 if !fallback_cursor.goto_next_sibling() {
3512 break;
3513 }
3514 }
3515 }
3516 if fallback_child.is_none() {
3517 let mut cursor2 = node.walk();
3518 if cursor2.goto_first_child() {
3519 loop {
3520 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3521 let candidate = cursor2.node();
3522 #[allow(clippy::needless_question_mark)]
3523 if (|| -> ::core::result::Result<
3524 _,
3525 ::treesitter_types::ParseError,
3526 > {
3527 let child = candidate;
3528 Ok(
3529 <DependentNameChildren as ::treesitter_types::FromNode>::from_node(
3530 child,
3531 src,
3532 )?,
3533 )
3534 })()
3535 .is_ok()
3536 {
3537 fallback_child = Some(candidate);
3538 break;
3539 }
3540 }
3541 if !cursor2.goto_next_sibling() {
3542 break;
3543 }
3544 }
3545 }
3546 }
3547 fallback_child.ok_or_else(|| {
3548 ::treesitter_types::ParseError::missing_field("children", node)
3549 })?
3550 };
3551 <DependentNameChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3552 },
3553 })
3554 }
3555}
3556impl ::treesitter_types::Spanned for DependentName<'_> {
3557 fn span(&self) -> ::treesitter_types::Span {
3558 self.span
3559 }
3560}
3561#[derive(Debug, Clone)]
3562pub struct DependentType<'tree> {
3563 pub span: ::treesitter_types::Span,
3564 pub children: TypeSpecifier<'tree>,
3565}
3566impl<'tree> ::treesitter_types::FromNode<'tree> for DependentType<'tree> {
3567 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3568 fn from_node(
3569 node: ::tree_sitter::Node<'tree>,
3570 src: &'tree [u8],
3571 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3572 debug_assert_eq!(node.kind(), "dependent_type");
3573 Ok(Self {
3574 span: ::treesitter_types::Span::from(node),
3575 children: {
3576 #[allow(clippy::suspicious_else_formatting)]
3577 let non_field_children = {
3578 let mut cursor = node.walk();
3579 let mut result = ::std::vec::Vec::new();
3580 if cursor.goto_first_child() {
3581 loop {
3582 if cursor.field_name().is_none()
3583 && cursor.node().is_named()
3584 && !cursor.node().is_extra()
3585 {
3586 result.push(cursor.node());
3587 }
3588 if !cursor.goto_next_sibling() {
3589 break;
3590 }
3591 }
3592 }
3593 result
3594 };
3595 let child = if let Some(&c) = non_field_children.first() {
3596 c
3597 } else {
3598 let mut fallback_cursor = node.walk();
3599 let mut fallback_child = None;
3600 if fallback_cursor.goto_first_child() {
3601 loop {
3602 if fallback_cursor.field_name().is_none()
3603 && !fallback_cursor.node().is_extra()
3604 {
3605 let candidate = fallback_cursor.node();
3606 #[allow(clippy::needless_question_mark)]
3607 if (|| -> ::core::result::Result<
3608 _,
3609 ::treesitter_types::ParseError,
3610 > {
3611 let child = candidate;
3612 Ok(
3613 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(
3614 child,
3615 src,
3616 )?,
3617 )
3618 })()
3619 .is_ok()
3620 {
3621 fallback_child = Some(candidate);
3622 break;
3623 }
3624 }
3625 if !fallback_cursor.goto_next_sibling() {
3626 break;
3627 }
3628 }
3629 }
3630 if fallback_child.is_none() {
3631 let mut cursor2 = node.walk();
3632 if cursor2.goto_first_child() {
3633 loop {
3634 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3635 let candidate = cursor2.node();
3636 #[allow(clippy::needless_question_mark)]
3637 if (|| -> ::core::result::Result<
3638 _,
3639 ::treesitter_types::ParseError,
3640 > {
3641 let child = candidate;
3642 Ok(
3643 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(
3644 child,
3645 src,
3646 )?,
3647 )
3648 })()
3649 .is_ok()
3650 {
3651 fallback_child = Some(candidate);
3652 break;
3653 }
3654 }
3655 if !cursor2.goto_next_sibling() {
3656 break;
3657 }
3658 }
3659 }
3660 }
3661 fallback_child.ok_or_else(|| {
3662 ::treesitter_types::ParseError::missing_field("children", node)
3663 })?
3664 };
3665 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
3666 },
3667 })
3668 }
3669}
3670impl ::treesitter_types::Spanned for DependentType<'_> {
3671 fn span(&self) -> ::treesitter_types::Span {
3672 self.span
3673 }
3674}
3675#[derive(Debug, Clone)]
3676pub struct DestructorName<'tree> {
3677 pub span: ::treesitter_types::Span,
3678 pub children: Identifier<'tree>,
3679}
3680impl<'tree> ::treesitter_types::FromNode<'tree> for DestructorName<'tree> {
3681 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3682 fn from_node(
3683 node: ::tree_sitter::Node<'tree>,
3684 src: &'tree [u8],
3685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3686 debug_assert_eq!(node.kind(), "destructor_name");
3687 Ok(Self {
3688 span: ::treesitter_types::Span::from(node),
3689 children: {
3690 #[allow(clippy::suspicious_else_formatting)]
3691 let non_field_children = {
3692 let mut cursor = node.walk();
3693 let mut result = ::std::vec::Vec::new();
3694 if cursor.goto_first_child() {
3695 loop {
3696 if cursor.field_name().is_none()
3697 && cursor.node().is_named()
3698 && !cursor.node().is_extra()
3699 {
3700 result.push(cursor.node());
3701 }
3702 if !cursor.goto_next_sibling() {
3703 break;
3704 }
3705 }
3706 }
3707 result
3708 };
3709 let child = if let Some(&c) = non_field_children.first() {
3710 c
3711 } else {
3712 let mut fallback_cursor = node.walk();
3713 let mut fallback_child = None;
3714 if fallback_cursor.goto_first_child() {
3715 loop {
3716 if fallback_cursor.field_name().is_none()
3717 && !fallback_cursor.node().is_extra()
3718 {
3719 let candidate = fallback_cursor.node();
3720 #[allow(clippy::needless_question_mark)]
3721 if (|| -> ::core::result::Result<
3722 _,
3723 ::treesitter_types::ParseError,
3724 > {
3725 let child = candidate;
3726 Ok(
3727 <Identifier as ::treesitter_types::FromNode>::from_node(
3728 child,
3729 src,
3730 )?,
3731 )
3732 })()
3733 .is_ok()
3734 {
3735 fallback_child = Some(candidate);
3736 break;
3737 }
3738 }
3739 if !fallback_cursor.goto_next_sibling() {
3740 break;
3741 }
3742 }
3743 }
3744 if fallback_child.is_none() {
3745 let mut cursor2 = node.walk();
3746 if cursor2.goto_first_child() {
3747 loop {
3748 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3749 let candidate = cursor2.node();
3750 #[allow(clippy::needless_question_mark)]
3751 if (|| -> ::core::result::Result<
3752 _,
3753 ::treesitter_types::ParseError,
3754 > {
3755 let child = candidate;
3756 Ok(
3757 <Identifier as ::treesitter_types::FromNode>::from_node(
3758 child,
3759 src,
3760 )?,
3761 )
3762 })()
3763 .is_ok()
3764 {
3765 fallback_child = Some(candidate);
3766 break;
3767 }
3768 }
3769 if !cursor2.goto_next_sibling() {
3770 break;
3771 }
3772 }
3773 }
3774 }
3775 fallback_child.ok_or_else(|| {
3776 ::treesitter_types::ParseError::missing_field("children", node)
3777 })?
3778 };
3779 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3780 },
3781 })
3782 }
3783}
3784impl ::treesitter_types::Spanned for DestructorName<'_> {
3785 fn span(&self) -> ::treesitter_types::Span {
3786 self.span
3787 }
3788}
3789#[derive(Debug, Clone)]
3790pub struct DoStatement<'tree> {
3791 pub span: ::treesitter_types::Span,
3792 pub body: Statement<'tree>,
3793 pub condition: ParenthesizedExpression<'tree>,
3794}
3795impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
3796 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3797 fn from_node(
3798 node: ::tree_sitter::Node<'tree>,
3799 src: &'tree [u8],
3800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3801 debug_assert_eq!(node.kind(), "do_statement");
3802 Ok(Self {
3803 span: ::treesitter_types::Span::from(node),
3804 body: {
3805 let child = node
3806 .child_by_field_name("body")
3807 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3808 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3809 },
3810 condition: {
3811 let child = node.child_by_field_name("condition").ok_or_else(|| {
3812 ::treesitter_types::ParseError::missing_field("condition", node)
3813 })?;
3814 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
3815 },
3816 })
3817 }
3818}
3819impl ::treesitter_types::Spanned for DoStatement<'_> {
3820 fn span(&self) -> ::treesitter_types::Span {
3821 self.span
3822 }
3823}
3824#[derive(Debug, Clone)]
3825pub struct ElseClause<'tree> {
3826 pub span: ::treesitter_types::Span,
3827 pub children: Statement<'tree>,
3828}
3829impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
3830 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3831 fn from_node(
3832 node: ::tree_sitter::Node<'tree>,
3833 src: &'tree [u8],
3834 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3835 debug_assert_eq!(node.kind(), "else_clause");
3836 Ok(Self {
3837 span: ::treesitter_types::Span::from(node),
3838 children: {
3839 #[allow(clippy::suspicious_else_formatting)]
3840 let non_field_children = {
3841 let mut cursor = node.walk();
3842 let mut result = ::std::vec::Vec::new();
3843 if cursor.goto_first_child() {
3844 loop {
3845 if cursor.field_name().is_none()
3846 && cursor.node().is_named()
3847 && !cursor.node().is_extra()
3848 {
3849 result.push(cursor.node());
3850 }
3851 if !cursor.goto_next_sibling() {
3852 break;
3853 }
3854 }
3855 }
3856 result
3857 };
3858 let child = if let Some(&c) = non_field_children.first() {
3859 c
3860 } else {
3861 let mut fallback_cursor = node.walk();
3862 let mut fallback_child = None;
3863 if fallback_cursor.goto_first_child() {
3864 loop {
3865 if fallback_cursor.field_name().is_none()
3866 && !fallback_cursor.node().is_extra()
3867 {
3868 let candidate = fallback_cursor.node();
3869 #[allow(clippy::needless_question_mark)]
3870 if (|| -> ::core::result::Result<
3871 _,
3872 ::treesitter_types::ParseError,
3873 > {
3874 let child = candidate;
3875 Ok(
3876 <Statement as ::treesitter_types::FromNode>::from_node(
3877 child,
3878 src,
3879 )?,
3880 )
3881 })()
3882 .is_ok()
3883 {
3884 fallback_child = Some(candidate);
3885 break;
3886 }
3887 }
3888 if !fallback_cursor.goto_next_sibling() {
3889 break;
3890 }
3891 }
3892 }
3893 if fallback_child.is_none() {
3894 let mut cursor2 = node.walk();
3895 if cursor2.goto_first_child() {
3896 loop {
3897 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3898 let candidate = cursor2.node();
3899 #[allow(clippy::needless_question_mark)]
3900 if (|| -> ::core::result::Result<
3901 _,
3902 ::treesitter_types::ParseError,
3903 > {
3904 let child = candidate;
3905 Ok(
3906 <Statement as ::treesitter_types::FromNode>::from_node(
3907 child,
3908 src,
3909 )?,
3910 )
3911 })()
3912 .is_ok()
3913 {
3914 fallback_child = Some(candidate);
3915 break;
3916 }
3917 }
3918 if !cursor2.goto_next_sibling() {
3919 break;
3920 }
3921 }
3922 }
3923 }
3924 fallback_child.ok_or_else(|| {
3925 ::treesitter_types::ParseError::missing_field("children", node)
3926 })?
3927 };
3928 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3929 },
3930 })
3931 }
3932}
3933impl ::treesitter_types::Spanned for ElseClause<'_> {
3934 fn span(&self) -> ::treesitter_types::Span {
3935 self.span
3936 }
3937}
3938#[derive(Debug, Clone)]
3939pub struct EnumSpecifier<'tree> {
3940 pub span: ::treesitter_types::Span,
3941 pub base: ::core::option::Option<EnumSpecifierBase<'tree>>,
3942 pub body: ::core::option::Option<EnumeratorList<'tree>>,
3943 pub name: ::core::option::Option<EnumSpecifierName<'tree>>,
3944 pub children: ::core::option::Option<AttributeSpecifier<'tree>>,
3945}
3946impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifier<'tree> {
3947 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3948 fn from_node(
3949 node: ::tree_sitter::Node<'tree>,
3950 src: &'tree [u8],
3951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3952 debug_assert_eq!(node.kind(), "enum_specifier");
3953 Ok(Self {
3954 span: ::treesitter_types::Span::from(node),
3955 base: match node.child_by_field_name("base") {
3956 Some(child) => Some(
3957 <EnumSpecifierBase as ::treesitter_types::FromNode>::from_node(child, src)?,
3958 ),
3959 None => None,
3960 },
3961 body: match node.child_by_field_name("body") {
3962 Some(child) => Some(<EnumeratorList as ::treesitter_types::FromNode>::from_node(
3963 child, src,
3964 )?),
3965 None => None,
3966 },
3967 name: match node.child_by_field_name("name") {
3968 Some(child) => Some(
3969 <EnumSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?,
3970 ),
3971 None => None,
3972 },
3973 children: {
3974 #[allow(clippy::suspicious_else_formatting)]
3975 let non_field_children = {
3976 let mut cursor = node.walk();
3977 let mut result = ::std::vec::Vec::new();
3978 if cursor.goto_first_child() {
3979 loop {
3980 if cursor.field_name().is_none()
3981 && cursor.node().is_named()
3982 && !cursor.node().is_extra()
3983 {
3984 result.push(cursor.node());
3985 }
3986 if !cursor.goto_next_sibling() {
3987 break;
3988 }
3989 }
3990 }
3991 result
3992 };
3993 match non_field_children.first() {
3994 Some(&child) => Some(
3995 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(
3996 child, src,
3997 )?,
3998 ),
3999 None => None,
4000 }
4001 },
4002 })
4003 }
4004}
4005impl ::treesitter_types::Spanned for EnumSpecifier<'_> {
4006 fn span(&self) -> ::treesitter_types::Span {
4007 self.span
4008 }
4009}
4010#[derive(Debug, Clone)]
4011pub struct Enumerator<'tree> {
4012 pub span: ::treesitter_types::Span,
4013 pub name: Identifier<'tree>,
4014 pub value: ::core::option::Option<Expression<'tree>>,
4015}
4016impl<'tree> ::treesitter_types::FromNode<'tree> for Enumerator<'tree> {
4017 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4018 fn from_node(
4019 node: ::tree_sitter::Node<'tree>,
4020 src: &'tree [u8],
4021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4022 debug_assert_eq!(node.kind(), "enumerator");
4023 Ok(Self {
4024 span: ::treesitter_types::Span::from(node),
4025 name: {
4026 let child = node
4027 .child_by_field_name("name")
4028 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4029 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4030 },
4031 value: match node.child_by_field_name("value") {
4032 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4033 child, src,
4034 )?),
4035 None => None,
4036 },
4037 })
4038 }
4039}
4040impl ::treesitter_types::Spanned for Enumerator<'_> {
4041 fn span(&self) -> ::treesitter_types::Span {
4042 self.span
4043 }
4044}
4045#[derive(Debug, Clone)]
4046pub struct EnumeratorList<'tree> {
4047 pub span: ::treesitter_types::Span,
4048 pub children: ::std::vec::Vec<EnumeratorListChildren<'tree>>,
4049}
4050impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorList<'tree> {
4051 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4052 fn from_node(
4053 node: ::tree_sitter::Node<'tree>,
4054 src: &'tree [u8],
4055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4056 debug_assert_eq!(node.kind(), "enumerator_list");
4057 Ok(Self {
4058 span: ::treesitter_types::Span::from(node),
4059 children: {
4060 #[allow(clippy::suspicious_else_formatting)]
4061 let non_field_children = {
4062 let mut cursor = node.walk();
4063 let mut result = ::std::vec::Vec::new();
4064 if cursor.goto_first_child() {
4065 loop {
4066 if cursor.field_name().is_none()
4067 && cursor.node().is_named()
4068 && !cursor.node().is_extra()
4069 {
4070 result.push(cursor.node());
4071 }
4072 if !cursor.goto_next_sibling() {
4073 break;
4074 }
4075 }
4076 }
4077 result
4078 };
4079 let mut items = ::std::vec::Vec::new();
4080 for child in non_field_children {
4081 items.push(
4082 <EnumeratorListChildren as ::treesitter_types::FromNode>::from_node(
4083 child, src,
4084 )?,
4085 );
4086 }
4087 items
4088 },
4089 })
4090 }
4091}
4092impl ::treesitter_types::Spanned for EnumeratorList<'_> {
4093 fn span(&self) -> ::treesitter_types::Span {
4094 self.span
4095 }
4096}
4097#[derive(Debug, Clone)]
4098pub struct ExplicitFunctionSpecifier<'tree> {
4099 pub span: ::treesitter_types::Span,
4100 pub children: ::core::option::Option<Expression<'tree>>,
4101}
4102impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitFunctionSpecifier<'tree> {
4103 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4104 fn from_node(
4105 node: ::tree_sitter::Node<'tree>,
4106 src: &'tree [u8],
4107 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4108 debug_assert_eq!(node.kind(), "explicit_function_specifier");
4109 Ok(Self {
4110 span: ::treesitter_types::Span::from(node),
4111 children: {
4112 #[allow(clippy::suspicious_else_formatting)]
4113 let non_field_children = {
4114 let mut cursor = node.walk();
4115 let mut result = ::std::vec::Vec::new();
4116 if cursor.goto_first_child() {
4117 loop {
4118 if cursor.field_name().is_none()
4119 && cursor.node().is_named()
4120 && !cursor.node().is_extra()
4121 {
4122 result.push(cursor.node());
4123 }
4124 if !cursor.goto_next_sibling() {
4125 break;
4126 }
4127 }
4128 }
4129 result
4130 };
4131 match non_field_children.first() {
4132 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4133 child, src,
4134 )?),
4135 None => None,
4136 }
4137 },
4138 })
4139 }
4140}
4141impl ::treesitter_types::Spanned for ExplicitFunctionSpecifier<'_> {
4142 fn span(&self) -> ::treesitter_types::Span {
4143 self.span
4144 }
4145}
4146#[derive(Debug, Clone)]
4147pub struct ExpressionStatement<'tree> {
4148 pub span: ::treesitter_types::Span,
4149 pub children: ::core::option::Option<ExpressionStatementChildren<'tree>>,
4150}
4151impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
4152 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4153 fn from_node(
4154 node: ::tree_sitter::Node<'tree>,
4155 src: &'tree [u8],
4156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4157 debug_assert_eq!(node.kind(), "expression_statement");
4158 Ok(Self {
4159 span: ::treesitter_types::Span::from(node),
4160 children: {
4161 #[allow(clippy::suspicious_else_formatting)]
4162 let non_field_children = {
4163 let mut cursor = node.walk();
4164 let mut result = ::std::vec::Vec::new();
4165 if cursor.goto_first_child() {
4166 loop {
4167 if cursor.field_name().is_none()
4168 && cursor.node().is_named()
4169 && !cursor.node().is_extra()
4170 {
4171 result.push(cursor.node());
4172 }
4173 if !cursor.goto_next_sibling() {
4174 break;
4175 }
4176 }
4177 }
4178 result
4179 };
4180 match non_field_children.first() {
4181 Some(&child) => Some(
4182 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
4183 child, src,
4184 )?,
4185 ),
4186 None => None,
4187 }
4188 },
4189 })
4190 }
4191}
4192impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
4193 fn span(&self) -> ::treesitter_types::Span {
4194 self.span
4195 }
4196}
4197#[derive(Debug, Clone)]
4198pub struct ExtensionExpression<'tree> {
4199 pub span: ::treesitter_types::Span,
4200 pub children: Expression<'tree>,
4201}
4202impl<'tree> ::treesitter_types::FromNode<'tree> for ExtensionExpression<'tree> {
4203 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4204 fn from_node(
4205 node: ::tree_sitter::Node<'tree>,
4206 src: &'tree [u8],
4207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4208 debug_assert_eq!(node.kind(), "extension_expression");
4209 Ok(Self {
4210 span: ::treesitter_types::Span::from(node),
4211 children: {
4212 #[allow(clippy::suspicious_else_formatting)]
4213 let non_field_children = {
4214 let mut cursor = node.walk();
4215 let mut result = ::std::vec::Vec::new();
4216 if cursor.goto_first_child() {
4217 loop {
4218 if cursor.field_name().is_none()
4219 && cursor.node().is_named()
4220 && !cursor.node().is_extra()
4221 {
4222 result.push(cursor.node());
4223 }
4224 if !cursor.goto_next_sibling() {
4225 break;
4226 }
4227 }
4228 }
4229 result
4230 };
4231 let child = if let Some(&c) = non_field_children.first() {
4232 c
4233 } else {
4234 let mut fallback_cursor = node.walk();
4235 let mut fallback_child = None;
4236 if fallback_cursor.goto_first_child() {
4237 loop {
4238 if fallback_cursor.field_name().is_none()
4239 && !fallback_cursor.node().is_extra()
4240 {
4241 let candidate = fallback_cursor.node();
4242 #[allow(clippy::needless_question_mark)]
4243 if (|| -> ::core::result::Result<
4244 _,
4245 ::treesitter_types::ParseError,
4246 > {
4247 let child = candidate;
4248 Ok(
4249 <Expression as ::treesitter_types::FromNode>::from_node(
4250 child,
4251 src,
4252 )?,
4253 )
4254 })()
4255 .is_ok()
4256 {
4257 fallback_child = Some(candidate);
4258 break;
4259 }
4260 }
4261 if !fallback_cursor.goto_next_sibling() {
4262 break;
4263 }
4264 }
4265 }
4266 if fallback_child.is_none() {
4267 let mut cursor2 = node.walk();
4268 if cursor2.goto_first_child() {
4269 loop {
4270 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4271 let candidate = cursor2.node();
4272 #[allow(clippy::needless_question_mark)]
4273 if (|| -> ::core::result::Result<
4274 _,
4275 ::treesitter_types::ParseError,
4276 > {
4277 let child = candidate;
4278 Ok(
4279 <Expression as ::treesitter_types::FromNode>::from_node(
4280 child,
4281 src,
4282 )?,
4283 )
4284 })()
4285 .is_ok()
4286 {
4287 fallback_child = Some(candidate);
4288 break;
4289 }
4290 }
4291 if !cursor2.goto_next_sibling() {
4292 break;
4293 }
4294 }
4295 }
4296 }
4297 fallback_child.ok_or_else(|| {
4298 ::treesitter_types::ParseError::missing_field("children", node)
4299 })?
4300 };
4301 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4302 },
4303 })
4304 }
4305}
4306impl ::treesitter_types::Spanned for ExtensionExpression<'_> {
4307 fn span(&self) -> ::treesitter_types::Span {
4308 self.span
4309 }
4310}
4311#[derive(Debug, Clone)]
4312pub struct FieldDeclaration<'tree> {
4313 pub span: ::treesitter_types::Span,
4314 pub declarator: ::std::vec::Vec<FieldDeclarator<'tree>>,
4315 pub default_value: ::std::vec::Vec<FieldDeclarationDefaultValue<'tree>>,
4316 pub r#type: TypeSpecifier<'tree>,
4317 pub children: ::std::vec::Vec<FieldDeclarationChildren<'tree>>,
4318}
4319impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclaration<'tree> {
4320 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4321 fn from_node(
4322 node: ::tree_sitter::Node<'tree>,
4323 src: &'tree [u8],
4324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4325 debug_assert_eq!(node.kind(), "field_declaration");
4326 Ok(Self {
4327 span: ::treesitter_types::Span::from(node),
4328 declarator: {
4329 let mut cursor = node.walk();
4330 let mut items = ::std::vec::Vec::new();
4331 for child in node.children_by_field_name("declarator", &mut cursor) {
4332 items.push(
4333 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
4334 );
4335 }
4336 items
4337 },
4338 default_value: {
4339 let mut cursor = node.walk();
4340 let mut items = ::std::vec::Vec::new();
4341 for child in node.children_by_field_name("default_value", &mut cursor) {
4342 items.push(
4343 <FieldDeclarationDefaultValue as ::treesitter_types::FromNode>::from_node(
4344 child, src,
4345 )?,
4346 );
4347 }
4348 items
4349 },
4350 r#type: {
4351 let child = node
4352 .child_by_field_name("type")
4353 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4354 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
4355 },
4356 children: {
4357 #[allow(clippy::suspicious_else_formatting)]
4358 let non_field_children = {
4359 let mut cursor = node.walk();
4360 let mut result = ::std::vec::Vec::new();
4361 if cursor.goto_first_child() {
4362 loop {
4363 if cursor.field_name().is_none()
4364 && cursor.node().is_named()
4365 && !cursor.node().is_extra()
4366 {
4367 result.push(cursor.node());
4368 }
4369 if !cursor.goto_next_sibling() {
4370 break;
4371 }
4372 }
4373 }
4374 result
4375 };
4376 let mut items = ::std::vec::Vec::new();
4377 for child in non_field_children {
4378 items.push(
4379 <FieldDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4380 child, src,
4381 )?,
4382 );
4383 }
4384 items
4385 },
4386 })
4387 }
4388}
4389impl ::treesitter_types::Spanned for FieldDeclaration<'_> {
4390 fn span(&self) -> ::treesitter_types::Span {
4391 self.span
4392 }
4393}
4394#[derive(Debug, Clone)]
4395pub struct FieldDeclarationList<'tree> {
4396 pub span: ::treesitter_types::Span,
4397 pub children: ::std::vec::Vec<FieldDeclarationListChildren<'tree>>,
4398}
4399impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationList<'tree> {
4400 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4401 fn from_node(
4402 node: ::tree_sitter::Node<'tree>,
4403 src: &'tree [u8],
4404 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4405 debug_assert_eq!(node.kind(), "field_declaration_list");
4406 Ok(Self {
4407 span: ::treesitter_types::Span::from(node),
4408 children: {
4409 #[allow(clippy::suspicious_else_formatting)]
4410 let non_field_children = {
4411 let mut cursor = node.walk();
4412 let mut result = ::std::vec::Vec::new();
4413 if cursor.goto_first_child() {
4414 loop {
4415 if cursor.field_name().is_none()
4416 && cursor.node().is_named()
4417 && !cursor.node().is_extra()
4418 {
4419 result.push(cursor.node());
4420 }
4421 if !cursor.goto_next_sibling() {
4422 break;
4423 }
4424 }
4425 }
4426 result
4427 };
4428 let mut items = ::std::vec::Vec::new();
4429 for child in non_field_children {
4430 items.push(
4431 <FieldDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
4432 child, src,
4433 )?,
4434 );
4435 }
4436 items
4437 },
4438 })
4439 }
4440}
4441impl ::treesitter_types::Spanned for FieldDeclarationList<'_> {
4442 fn span(&self) -> ::treesitter_types::Span {
4443 self.span
4444 }
4445}
4446#[derive(Debug, Clone)]
4447pub struct FieldDesignator<'tree> {
4448 pub span: ::treesitter_types::Span,
4449 pub children: FieldIdentifier<'tree>,
4450}
4451impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDesignator<'tree> {
4452 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4453 fn from_node(
4454 node: ::tree_sitter::Node<'tree>,
4455 src: &'tree [u8],
4456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4457 debug_assert_eq!(node.kind(), "field_designator");
4458 Ok(Self {
4459 span: ::treesitter_types::Span::from(node),
4460 children: {
4461 #[allow(clippy::suspicious_else_formatting)]
4462 let non_field_children = {
4463 let mut cursor = node.walk();
4464 let mut result = ::std::vec::Vec::new();
4465 if cursor.goto_first_child() {
4466 loop {
4467 if cursor.field_name().is_none()
4468 && cursor.node().is_named()
4469 && !cursor.node().is_extra()
4470 {
4471 result.push(cursor.node());
4472 }
4473 if !cursor.goto_next_sibling() {
4474 break;
4475 }
4476 }
4477 }
4478 result
4479 };
4480 let child = if let Some(&c) = non_field_children.first() {
4481 c
4482 } else {
4483 let mut fallback_cursor = node.walk();
4484 let mut fallback_child = None;
4485 if fallback_cursor.goto_first_child() {
4486 loop {
4487 if fallback_cursor.field_name().is_none()
4488 && !fallback_cursor.node().is_extra()
4489 {
4490 let candidate = fallback_cursor.node();
4491 #[allow(clippy::needless_question_mark)]
4492 if (|| -> ::core::result::Result<
4493 _,
4494 ::treesitter_types::ParseError,
4495 > {
4496 let child = candidate;
4497 Ok(
4498 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
4499 child,
4500 src,
4501 )?,
4502 )
4503 })()
4504 .is_ok()
4505 {
4506 fallback_child = Some(candidate);
4507 break;
4508 }
4509 }
4510 if !fallback_cursor.goto_next_sibling() {
4511 break;
4512 }
4513 }
4514 }
4515 if fallback_child.is_none() {
4516 let mut cursor2 = node.walk();
4517 if cursor2.goto_first_child() {
4518 loop {
4519 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4520 let candidate = cursor2.node();
4521 #[allow(clippy::needless_question_mark)]
4522 if (|| -> ::core::result::Result<
4523 _,
4524 ::treesitter_types::ParseError,
4525 > {
4526 let child = candidate;
4527 Ok(
4528 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(
4529 child,
4530 src,
4531 )?,
4532 )
4533 })()
4534 .is_ok()
4535 {
4536 fallback_child = Some(candidate);
4537 break;
4538 }
4539 }
4540 if !cursor2.goto_next_sibling() {
4541 break;
4542 }
4543 }
4544 }
4545 }
4546 fallback_child.ok_or_else(|| {
4547 ::treesitter_types::ParseError::missing_field("children", node)
4548 })?
4549 };
4550 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
4551 },
4552 })
4553 }
4554}
4555impl ::treesitter_types::Spanned for FieldDesignator<'_> {
4556 fn span(&self) -> ::treesitter_types::Span {
4557 self.span
4558 }
4559}
4560#[derive(Debug, Clone)]
4561pub struct FieldExpression<'tree> {
4562 pub span: ::treesitter_types::Span,
4563 pub argument: Expression<'tree>,
4564 pub field: FieldExpressionField<'tree>,
4565 pub operator: FieldExpressionOperator,
4566}
4567impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpression<'tree> {
4568 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4569 fn from_node(
4570 node: ::tree_sitter::Node<'tree>,
4571 src: &'tree [u8],
4572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4573 debug_assert_eq!(node.kind(), "field_expression");
4574 Ok(Self {
4575 span: ::treesitter_types::Span::from(node),
4576 argument: {
4577 let child = node.child_by_field_name("argument").ok_or_else(|| {
4578 ::treesitter_types::ParseError::missing_field("argument", node)
4579 })?;
4580 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4581 },
4582 field: {
4583 let child = node
4584 .child_by_field_name("field")
4585 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
4586 <FieldExpressionField as ::treesitter_types::FromNode>::from_node(child, src)?
4587 },
4588 operator: {
4589 let child = node.child_by_field_name("operator").ok_or_else(|| {
4590 ::treesitter_types::ParseError::missing_field("operator", node)
4591 })?;
4592 <FieldExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
4593 },
4594 })
4595 }
4596}
4597impl ::treesitter_types::Spanned for FieldExpression<'_> {
4598 fn span(&self) -> ::treesitter_types::Span {
4599 self.span
4600 }
4601}
4602#[derive(Debug, Clone)]
4603pub struct FieldInitializer<'tree> {
4604 pub span: ::treesitter_types::Span,
4605 pub children: ::std::vec::Vec<FieldInitializerChildren<'tree>>,
4606}
4607impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializer<'tree> {
4608 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4609 fn from_node(
4610 node: ::tree_sitter::Node<'tree>,
4611 src: &'tree [u8],
4612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4613 debug_assert_eq!(node.kind(), "field_initializer");
4614 Ok(Self {
4615 span: ::treesitter_types::Span::from(node),
4616 children: {
4617 #[allow(clippy::suspicious_else_formatting)]
4618 let non_field_children = {
4619 let mut cursor = node.walk();
4620 let mut result = ::std::vec::Vec::new();
4621 if cursor.goto_first_child() {
4622 loop {
4623 if cursor.field_name().is_none()
4624 && cursor.node().is_named()
4625 && !cursor.node().is_extra()
4626 {
4627 result.push(cursor.node());
4628 }
4629 if !cursor.goto_next_sibling() {
4630 break;
4631 }
4632 }
4633 }
4634 result
4635 };
4636 let mut items = ::std::vec::Vec::new();
4637 for child in non_field_children {
4638 items.push(
4639 <FieldInitializerChildren as ::treesitter_types::FromNode>::from_node(
4640 child, src,
4641 )?,
4642 );
4643 }
4644 items
4645 },
4646 })
4647 }
4648}
4649impl ::treesitter_types::Spanned for FieldInitializer<'_> {
4650 fn span(&self) -> ::treesitter_types::Span {
4651 self.span
4652 }
4653}
4654#[derive(Debug, Clone)]
4655pub struct FieldInitializerList<'tree> {
4656 pub span: ::treesitter_types::Span,
4657 pub children: ::std::vec::Vec<FieldInitializer<'tree>>,
4658}
4659impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerList<'tree> {
4660 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4661 fn from_node(
4662 node: ::tree_sitter::Node<'tree>,
4663 src: &'tree [u8],
4664 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4665 debug_assert_eq!(node.kind(), "field_initializer_list");
4666 Ok(Self {
4667 span: ::treesitter_types::Span::from(node),
4668 children: {
4669 #[allow(clippy::suspicious_else_formatting)]
4670 let non_field_children = {
4671 let mut cursor = node.walk();
4672 let mut result = ::std::vec::Vec::new();
4673 if cursor.goto_first_child() {
4674 loop {
4675 if cursor.field_name().is_none()
4676 && cursor.node().is_named()
4677 && !cursor.node().is_extra()
4678 {
4679 result.push(cursor.node());
4680 }
4681 if !cursor.goto_next_sibling() {
4682 break;
4683 }
4684 }
4685 }
4686 result
4687 };
4688 let mut items = ::std::vec::Vec::new();
4689 for child in non_field_children {
4690 items.push(
4691 <FieldInitializer as ::treesitter_types::FromNode>::from_node(child, src)?,
4692 );
4693 }
4694 items
4695 },
4696 })
4697 }
4698}
4699impl ::treesitter_types::Spanned for FieldInitializerList<'_> {
4700 fn span(&self) -> ::treesitter_types::Span {
4701 self.span
4702 }
4703}
4704#[derive(Debug, Clone)]
4705pub struct FoldExpression<'tree> {
4706 pub span: ::treesitter_types::Span,
4707 pub left: FoldExpressionLeft<'tree>,
4708 pub operator: FoldExpressionOperator,
4709 pub right: FoldExpressionRight<'tree>,
4710}
4711impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpression<'tree> {
4712 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4713 fn from_node(
4714 node: ::tree_sitter::Node<'tree>,
4715 src: &'tree [u8],
4716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4717 debug_assert_eq!(node.kind(), "fold_expression");
4718 Ok(Self {
4719 span: ::treesitter_types::Span::from(node),
4720 left: {
4721 let child = node
4722 .child_by_field_name("left")
4723 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
4724 <FoldExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
4725 },
4726 operator: {
4727 let child = node.child_by_field_name("operator").ok_or_else(|| {
4728 ::treesitter_types::ParseError::missing_field("operator", node)
4729 })?;
4730 <FoldExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
4731 },
4732 right: {
4733 let child = node
4734 .child_by_field_name("right")
4735 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4736 <FoldExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
4737 },
4738 })
4739 }
4740}
4741impl ::treesitter_types::Spanned for FoldExpression<'_> {
4742 fn span(&self) -> ::treesitter_types::Span {
4743 self.span
4744 }
4745}
4746#[derive(Debug, Clone)]
4747pub struct ForRangeLoop<'tree> {
4748 pub span: ::treesitter_types::Span,
4749 pub body: Statement<'tree>,
4750 pub declarator: Declarator<'tree>,
4751 pub initializer: ::core::option::Option<InitStatement<'tree>>,
4752 pub right: ForRangeLoopRight<'tree>,
4753 pub r#type: TypeSpecifier<'tree>,
4754 pub children: ::std::vec::Vec<ForRangeLoopChildren<'tree>>,
4755}
4756impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoop<'tree> {
4757 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4758 fn from_node(
4759 node: ::tree_sitter::Node<'tree>,
4760 src: &'tree [u8],
4761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4762 debug_assert_eq!(node.kind(), "for_range_loop");
4763 Ok(Self {
4764 span: ::treesitter_types::Span::from(node),
4765 body: {
4766 let child = node
4767 .child_by_field_name("body")
4768 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4769 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
4770 },
4771 declarator: {
4772 let child = node.child_by_field_name("declarator").ok_or_else(|| {
4773 ::treesitter_types::ParseError::missing_field("declarator", node)
4774 })?;
4775 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)?
4776 },
4777 initializer: match node.child_by_field_name("initializer") {
4778 Some(child) => Some(<InitStatement as ::treesitter_types::FromNode>::from_node(
4779 child, src,
4780 )?),
4781 None => None,
4782 },
4783 right: {
4784 let child = node
4785 .child_by_field_name("right")
4786 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
4787 <ForRangeLoopRight as ::treesitter_types::FromNode>::from_node(child, src)?
4788 },
4789 r#type: {
4790 let child = node
4791 .child_by_field_name("type")
4792 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4793 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
4794 },
4795 children: {
4796 #[allow(clippy::suspicious_else_formatting)]
4797 let non_field_children = {
4798 let mut cursor = node.walk();
4799 let mut result = ::std::vec::Vec::new();
4800 if cursor.goto_first_child() {
4801 loop {
4802 if cursor.field_name().is_none()
4803 && cursor.node().is_named()
4804 && !cursor.node().is_extra()
4805 {
4806 result.push(cursor.node());
4807 }
4808 if !cursor.goto_next_sibling() {
4809 break;
4810 }
4811 }
4812 }
4813 result
4814 };
4815 let mut items = ::std::vec::Vec::new();
4816 for child in non_field_children {
4817 items.push(
4818 <ForRangeLoopChildren as ::treesitter_types::FromNode>::from_node(
4819 child, src,
4820 )?,
4821 );
4822 }
4823 items
4824 },
4825 })
4826 }
4827}
4828impl ::treesitter_types::Spanned for ForRangeLoop<'_> {
4829 fn span(&self) -> ::treesitter_types::Span {
4830 self.span
4831 }
4832}
4833#[derive(Debug, Clone)]
4834pub struct ForStatement<'tree> {
4835 pub span: ::treesitter_types::Span,
4836 pub body: Statement<'tree>,
4837 pub condition: ::core::option::Option<ForStatementCondition<'tree>>,
4838 pub initializer: ::core::option::Option<ForStatementInitializer<'tree>>,
4839 pub update: ::core::option::Option<ForStatementUpdate<'tree>>,
4840}
4841impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
4842 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4843 fn from_node(
4844 node: ::tree_sitter::Node<'tree>,
4845 src: &'tree [u8],
4846 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4847 debug_assert_eq!(node.kind(), "for_statement");
4848 Ok(Self {
4849 span: ::treesitter_types::Span::from(node),
4850 body: {
4851 let child = node
4852 .child_by_field_name("body")
4853 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4854 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
4855 },
4856 condition: match node.child_by_field_name("condition") {
4857 Some(child) => Some(
4858 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(child, src)?,
4859 ),
4860 None => None,
4861 },
4862 initializer: match node.child_by_field_name("initializer") {
4863 Some(child) => Some(
4864 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(
4865 child, src,
4866 )?,
4867 ),
4868 None => None,
4869 },
4870 update: match node.child_by_field_name("update") {
4871 Some(child) => Some(
4872 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)?,
4873 ),
4874 None => None,
4875 },
4876 })
4877 }
4878}
4879impl ::treesitter_types::Spanned for ForStatement<'_> {
4880 fn span(&self) -> ::treesitter_types::Span {
4881 self.span
4882 }
4883}
4884#[derive(Debug, Clone)]
4885pub struct FriendDeclaration<'tree> {
4886 pub span: ::treesitter_types::Span,
4887 pub children: FriendDeclarationChildren<'tree>,
4888}
4889impl<'tree> ::treesitter_types::FromNode<'tree> for FriendDeclaration<'tree> {
4890 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4891 fn from_node(
4892 node: ::tree_sitter::Node<'tree>,
4893 src: &'tree [u8],
4894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4895 debug_assert_eq!(node.kind(), "friend_declaration");
4896 Ok(Self {
4897 span: ::treesitter_types::Span::from(node),
4898 children: {
4899 #[allow(clippy::suspicious_else_formatting)]
4900 let non_field_children = {
4901 let mut cursor = node.walk();
4902 let mut result = ::std::vec::Vec::new();
4903 if cursor.goto_first_child() {
4904 loop {
4905 if cursor.field_name().is_none()
4906 && cursor.node().is_named()
4907 && !cursor.node().is_extra()
4908 {
4909 result.push(cursor.node());
4910 }
4911 if !cursor.goto_next_sibling() {
4912 break;
4913 }
4914 }
4915 }
4916 result
4917 };
4918 let child = if let Some(&c) = non_field_children.first() {
4919 c
4920 } else {
4921 let mut fallback_cursor = node.walk();
4922 let mut fallback_child = None;
4923 if fallback_cursor.goto_first_child() {
4924 loop {
4925 if fallback_cursor.field_name().is_none()
4926 && !fallback_cursor.node().is_extra()
4927 {
4928 let candidate = fallback_cursor.node();
4929 #[allow(clippy::needless_question_mark)]
4930 if (|| -> ::core::result::Result<
4931 _,
4932 ::treesitter_types::ParseError,
4933 > {
4934 let child = candidate;
4935 Ok(
4936 <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4937 child,
4938 src,
4939 )?,
4940 )
4941 })()
4942 .is_ok()
4943 {
4944 fallback_child = Some(candidate);
4945 break;
4946 }
4947 }
4948 if !fallback_cursor.goto_next_sibling() {
4949 break;
4950 }
4951 }
4952 }
4953 if fallback_child.is_none() {
4954 let mut cursor2 = node.walk();
4955 if cursor2.goto_first_child() {
4956 loop {
4957 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4958 let candidate = cursor2.node();
4959 #[allow(clippy::needless_question_mark)]
4960 if (|| -> ::core::result::Result<
4961 _,
4962 ::treesitter_types::ParseError,
4963 > {
4964 let child = candidate;
4965 Ok(
4966 <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4967 child,
4968 src,
4969 )?,
4970 )
4971 })()
4972 .is_ok()
4973 {
4974 fallback_child = Some(candidate);
4975 break;
4976 }
4977 }
4978 if !cursor2.goto_next_sibling() {
4979 break;
4980 }
4981 }
4982 }
4983 }
4984 fallback_child.ok_or_else(|| {
4985 ::treesitter_types::ParseError::missing_field("children", node)
4986 })?
4987 };
4988 <FriendDeclarationChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4989 },
4990 })
4991 }
4992}
4993impl ::treesitter_types::Spanned for FriendDeclaration<'_> {
4994 fn span(&self) -> ::treesitter_types::Span {
4995 self.span
4996 }
4997}
4998#[derive(Debug, Clone)]
4999pub struct FunctionDeclarator<'tree> {
5000 pub span: ::treesitter_types::Span,
5001 pub declarator: FunctionDeclaratorDeclarator<'tree>,
5002 pub parameters: ParameterList<'tree>,
5003 pub children: ::std::vec::Vec<FunctionDeclaratorChildren<'tree>>,
5004}
5005impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarator<'tree> {
5006 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5007 fn from_node(
5008 node: ::tree_sitter::Node<'tree>,
5009 src: &'tree [u8],
5010 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5011 debug_assert_eq!(node.kind(), "function_declarator");
5012 Ok(Self {
5013 span: ::treesitter_types::Span::from(node),
5014 declarator: {
5015 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5016 ::treesitter_types::ParseError::missing_field("declarator", node)
5017 })?;
5018 <FunctionDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
5019 child, src,
5020 )?
5021 },
5022 parameters: {
5023 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5024 ::treesitter_types::ParseError::missing_field("parameters", node)
5025 })?;
5026 <ParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
5027 },
5028 children: {
5029 #[allow(clippy::suspicious_else_formatting)]
5030 let non_field_children = {
5031 let mut cursor = node.walk();
5032 let mut result = ::std::vec::Vec::new();
5033 if cursor.goto_first_child() {
5034 loop {
5035 if cursor.field_name().is_none()
5036 && cursor.node().is_named()
5037 && !cursor.node().is_extra()
5038 {
5039 result.push(cursor.node());
5040 }
5041 if !cursor.goto_next_sibling() {
5042 break;
5043 }
5044 }
5045 }
5046 result
5047 };
5048 let mut items = ::std::vec::Vec::new();
5049 for child in non_field_children {
5050 items.push(
5051 <FunctionDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
5052 child, src,
5053 )?,
5054 );
5055 }
5056 items
5057 },
5058 })
5059 }
5060}
5061impl ::treesitter_types::Spanned for FunctionDeclarator<'_> {
5062 fn span(&self) -> ::treesitter_types::Span {
5063 self.span
5064 }
5065}
5066#[derive(Debug, Clone)]
5067pub struct FunctionDefinition<'tree> {
5068 pub span: ::treesitter_types::Span,
5069 pub body: ::core::option::Option<FunctionDefinitionBody<'tree>>,
5070 pub declarator: FunctionDefinitionDeclarator<'tree>,
5071 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
5072 pub children: ::std::vec::Vec<FunctionDefinitionChildren<'tree>>,
5073}
5074impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
5075 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5076 fn from_node(
5077 node: ::tree_sitter::Node<'tree>,
5078 src: &'tree [u8],
5079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5080 debug_assert_eq!(node.kind(), "function_definition");
5081 Ok(Self {
5082 span: ::treesitter_types::Span::from(node),
5083 body: match node.child_by_field_name("body") {
5084 Some(child) => Some(
5085 <FunctionDefinitionBody as ::treesitter_types::FromNode>::from_node(
5086 child, src,
5087 )?,
5088 ),
5089 None => None,
5090 },
5091 declarator: {
5092 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5093 ::treesitter_types::ParseError::missing_field("declarator", node)
5094 })?;
5095 <FunctionDefinitionDeclarator as ::treesitter_types::FromNode>::from_node(
5096 child, src,
5097 )?
5098 },
5099 r#type: match node.child_by_field_name("type") {
5100 Some(child) => Some(<TypeSpecifier as ::treesitter_types::FromNode>::from_node(
5101 child, src,
5102 )?),
5103 None => None,
5104 },
5105 children: {
5106 #[allow(clippy::suspicious_else_formatting)]
5107 let non_field_children = {
5108 let mut cursor = node.walk();
5109 let mut result = ::std::vec::Vec::new();
5110 if cursor.goto_first_child() {
5111 loop {
5112 if cursor.field_name().is_none()
5113 && cursor.node().is_named()
5114 && !cursor.node().is_extra()
5115 {
5116 result.push(cursor.node());
5117 }
5118 if !cursor.goto_next_sibling() {
5119 break;
5120 }
5121 }
5122 }
5123 result
5124 };
5125 let mut items = ::std::vec::Vec::new();
5126 for child in non_field_children {
5127 items.push(
5128 <FunctionDefinitionChildren as ::treesitter_types::FromNode>::from_node(
5129 child, src,
5130 )?,
5131 );
5132 }
5133 items
5134 },
5135 })
5136 }
5137}
5138impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
5139 fn span(&self) -> ::treesitter_types::Span {
5140 self.span
5141 }
5142}
5143#[derive(Debug, Clone)]
5144pub struct GenericExpression<'tree> {
5145 pub span: ::treesitter_types::Span,
5146 pub children: ::std::vec::Vec<GenericExpressionChildren<'tree>>,
5147}
5148impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpression<'tree> {
5149 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5150 fn from_node(
5151 node: ::tree_sitter::Node<'tree>,
5152 src: &'tree [u8],
5153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5154 debug_assert_eq!(node.kind(), "generic_expression");
5155 Ok(Self {
5156 span: ::treesitter_types::Span::from(node),
5157 children: {
5158 #[allow(clippy::suspicious_else_formatting)]
5159 let non_field_children = {
5160 let mut cursor = node.walk();
5161 let mut result = ::std::vec::Vec::new();
5162 if cursor.goto_first_child() {
5163 loop {
5164 if cursor.field_name().is_none()
5165 && cursor.node().is_named()
5166 && !cursor.node().is_extra()
5167 {
5168 result.push(cursor.node());
5169 }
5170 if !cursor.goto_next_sibling() {
5171 break;
5172 }
5173 }
5174 }
5175 result
5176 };
5177 let mut items = ::std::vec::Vec::new();
5178 for child in non_field_children {
5179 items.push(
5180 <GenericExpressionChildren as ::treesitter_types::FromNode>::from_node(
5181 child, src,
5182 )?,
5183 );
5184 }
5185 items
5186 },
5187 })
5188 }
5189}
5190impl ::treesitter_types::Spanned for GenericExpression<'_> {
5191 fn span(&self) -> ::treesitter_types::Span {
5192 self.span
5193 }
5194}
5195#[derive(Debug, Clone)]
5196pub struct GnuAsmClobberList<'tree> {
5197 pub span: ::treesitter_types::Span,
5198 pub register: ::std::vec::Vec<GnuAsmClobberListRegister<'tree>>,
5199}
5200impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberList<'tree> {
5201 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5202 fn from_node(
5203 node: ::tree_sitter::Node<'tree>,
5204 src: &'tree [u8],
5205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5206 debug_assert_eq!(node.kind(), "gnu_asm_clobber_list");
5207 Ok(Self {
5208 span: ::treesitter_types::Span::from(node),
5209 register: {
5210 let mut cursor = node.walk();
5211 let mut items = ::std::vec::Vec::new();
5212 for child in node.children_by_field_name("register", &mut cursor) {
5213 items.push(
5214 <GnuAsmClobberListRegister as ::treesitter_types::FromNode>::from_node(
5215 child, src,
5216 )?,
5217 );
5218 }
5219 items
5220 },
5221 })
5222 }
5223}
5224impl ::treesitter_types::Spanned for GnuAsmClobberList<'_> {
5225 fn span(&self) -> ::treesitter_types::Span {
5226 self.span
5227 }
5228}
5229#[derive(Debug, Clone)]
5230pub struct GnuAsmExpression<'tree> {
5231 pub span: ::treesitter_types::Span,
5232 pub assembly_code: GnuAsmExpressionAssemblyCode<'tree>,
5233 pub clobbers: ::core::option::Option<GnuAsmClobberList<'tree>>,
5234 pub goto_labels: ::core::option::Option<GnuAsmGotoList<'tree>>,
5235 pub input_operands: ::core::option::Option<GnuAsmInputOperandList<'tree>>,
5236 pub output_operands: ::core::option::Option<GnuAsmOutputOperandList<'tree>>,
5237 pub children: ::std::vec::Vec<GnuAsmQualifier<'tree>>,
5238}
5239impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpression<'tree> {
5240 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5241 fn from_node(
5242 node: ::tree_sitter::Node<'tree>,
5243 src: &'tree [u8],
5244 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5245 debug_assert_eq!(node.kind(), "gnu_asm_expression");
5246 Ok(Self {
5247 span: ::treesitter_types::Span::from(node),
5248 assembly_code: {
5249 let child = node.child_by_field_name("assembly_code").ok_or_else(|| {
5250 ::treesitter_types::ParseError::missing_field("assembly_code", node)
5251 })?;
5252 <GnuAsmExpressionAssemblyCode as ::treesitter_types::FromNode>::from_node(
5253 child, src,
5254 )?
5255 },
5256 clobbers: match node.child_by_field_name("clobbers") {
5257 Some(child) => Some(
5258 <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(child, src)?,
5259 ),
5260 None => None,
5261 },
5262 goto_labels: match node.child_by_field_name("goto_labels") {
5263 Some(child) => Some(<GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(
5264 child, src,
5265 )?),
5266 None => None,
5267 },
5268 input_operands: match node.child_by_field_name("input_operands") {
5269 Some(child) => Some(
5270 <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(
5271 child, src,
5272 )?,
5273 ),
5274 None => None,
5275 },
5276 output_operands: match node.child_by_field_name("output_operands") {
5277 Some(child) => Some(
5278 <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(
5279 child, src,
5280 )?,
5281 ),
5282 None => None,
5283 },
5284 children: {
5285 #[allow(clippy::suspicious_else_formatting)]
5286 let non_field_children = {
5287 let mut cursor = node.walk();
5288 let mut result = ::std::vec::Vec::new();
5289 if cursor.goto_first_child() {
5290 loop {
5291 if cursor.field_name().is_none()
5292 && cursor.node().is_named()
5293 && !cursor.node().is_extra()
5294 {
5295 result.push(cursor.node());
5296 }
5297 if !cursor.goto_next_sibling() {
5298 break;
5299 }
5300 }
5301 }
5302 result
5303 };
5304 let mut items = ::std::vec::Vec::new();
5305 for child in non_field_children {
5306 items.push(
5307 <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5308 );
5309 }
5310 items
5311 },
5312 })
5313 }
5314}
5315impl ::treesitter_types::Spanned for GnuAsmExpression<'_> {
5316 fn span(&self) -> ::treesitter_types::Span {
5317 self.span
5318 }
5319}
5320#[derive(Debug, Clone)]
5321pub struct GnuAsmGotoList<'tree> {
5322 pub span: ::treesitter_types::Span,
5323 pub label: ::std::vec::Vec<Identifier<'tree>>,
5324}
5325impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmGotoList<'tree> {
5326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5327 fn from_node(
5328 node: ::tree_sitter::Node<'tree>,
5329 src: &'tree [u8],
5330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5331 debug_assert_eq!(node.kind(), "gnu_asm_goto_list");
5332 Ok(Self {
5333 span: ::treesitter_types::Span::from(node),
5334 label: {
5335 let mut cursor = node.walk();
5336 let mut items = ::std::vec::Vec::new();
5337 for child in node.children_by_field_name("label", &mut cursor) {
5338 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
5339 child, src,
5340 )?);
5341 }
5342 items
5343 },
5344 })
5345 }
5346}
5347impl ::treesitter_types::Spanned for GnuAsmGotoList<'_> {
5348 fn span(&self) -> ::treesitter_types::Span {
5349 self.span
5350 }
5351}
5352#[derive(Debug, Clone)]
5353pub struct GnuAsmInputOperand<'tree> {
5354 pub span: ::treesitter_types::Span,
5355 pub constraint: StringLiteral<'tree>,
5356 pub symbol: ::core::option::Option<Identifier<'tree>>,
5357 pub value: Expression<'tree>,
5358}
5359impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperand<'tree> {
5360 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5361 fn from_node(
5362 node: ::tree_sitter::Node<'tree>,
5363 src: &'tree [u8],
5364 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5365 debug_assert_eq!(node.kind(), "gnu_asm_input_operand");
5366 Ok(Self {
5367 span: ::treesitter_types::Span::from(node),
5368 constraint: {
5369 let child = node.child_by_field_name("constraint").ok_or_else(|| {
5370 ::treesitter_types::ParseError::missing_field("constraint", node)
5371 })?;
5372 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?
5373 },
5374 symbol: match node.child_by_field_name("symbol") {
5375 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
5376 child, src,
5377 )?),
5378 None => None,
5379 },
5380 value: {
5381 let child = node
5382 .child_by_field_name("value")
5383 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5384 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5385 },
5386 })
5387 }
5388}
5389impl ::treesitter_types::Spanned for GnuAsmInputOperand<'_> {
5390 fn span(&self) -> ::treesitter_types::Span {
5391 self.span
5392 }
5393}
5394#[derive(Debug, Clone)]
5395pub struct GnuAsmInputOperandList<'tree> {
5396 pub span: ::treesitter_types::Span,
5397 pub operand: ::std::vec::Vec<GnuAsmInputOperand<'tree>>,
5398}
5399impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmInputOperandList<'tree> {
5400 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5401 fn from_node(
5402 node: ::tree_sitter::Node<'tree>,
5403 src: &'tree [u8],
5404 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5405 debug_assert_eq!(node.kind(), "gnu_asm_input_operand_list");
5406 Ok(Self {
5407 span: ::treesitter_types::Span::from(node),
5408 operand: {
5409 let mut cursor = node.walk();
5410 let mut items = ::std::vec::Vec::new();
5411 for child in node.children_by_field_name("operand", &mut cursor) {
5412 items.push(
5413 <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(
5414 child, src,
5415 )?,
5416 );
5417 }
5418 items
5419 },
5420 })
5421 }
5422}
5423impl ::treesitter_types::Spanned for GnuAsmInputOperandList<'_> {
5424 fn span(&self) -> ::treesitter_types::Span {
5425 self.span
5426 }
5427}
5428#[derive(Debug, Clone)]
5429pub struct GnuAsmOutputOperand<'tree> {
5430 pub span: ::treesitter_types::Span,
5431 pub constraint: StringLiteral<'tree>,
5432 pub symbol: ::core::option::Option<Identifier<'tree>>,
5433 pub value: Expression<'tree>,
5434}
5435impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperand<'tree> {
5436 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5437 fn from_node(
5438 node: ::tree_sitter::Node<'tree>,
5439 src: &'tree [u8],
5440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5441 debug_assert_eq!(node.kind(), "gnu_asm_output_operand");
5442 Ok(Self {
5443 span: ::treesitter_types::Span::from(node),
5444 constraint: {
5445 let child = node.child_by_field_name("constraint").ok_or_else(|| {
5446 ::treesitter_types::ParseError::missing_field("constraint", node)
5447 })?;
5448 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?
5449 },
5450 symbol: match node.child_by_field_name("symbol") {
5451 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
5452 child, src,
5453 )?),
5454 None => None,
5455 },
5456 value: {
5457 let child = node
5458 .child_by_field_name("value")
5459 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5460 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5461 },
5462 })
5463 }
5464}
5465impl ::treesitter_types::Spanned for GnuAsmOutputOperand<'_> {
5466 fn span(&self) -> ::treesitter_types::Span {
5467 self.span
5468 }
5469}
5470#[derive(Debug, Clone)]
5471pub struct GnuAsmOutputOperandList<'tree> {
5472 pub span: ::treesitter_types::Span,
5473 pub operand: ::std::vec::Vec<GnuAsmOutputOperand<'tree>>,
5474}
5475impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmOutputOperandList<'tree> {
5476 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5477 fn from_node(
5478 node: ::tree_sitter::Node<'tree>,
5479 src: &'tree [u8],
5480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5481 debug_assert_eq!(node.kind(), "gnu_asm_output_operand_list");
5482 Ok(Self {
5483 span: ::treesitter_types::Span::from(node),
5484 operand: {
5485 let mut cursor = node.walk();
5486 let mut items = ::std::vec::Vec::new();
5487 for child in node.children_by_field_name("operand", &mut cursor) {
5488 items.push(
5489 <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(
5490 child, src,
5491 )?,
5492 );
5493 }
5494 items
5495 },
5496 })
5497 }
5498}
5499impl ::treesitter_types::Spanned for GnuAsmOutputOperandList<'_> {
5500 fn span(&self) -> ::treesitter_types::Span {
5501 self.span
5502 }
5503}
5504#[derive(Debug, Clone)]
5505pub struct GnuAsmQualifier<'tree> {
5506 pub span: ::treesitter_types::Span,
5507 text: &'tree str,
5508}
5509impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmQualifier<'tree> {
5510 fn from_node(
5511 node: ::tree_sitter::Node<'tree>,
5512 src: &'tree [u8],
5513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5514 debug_assert_eq!(node.kind(), "gnu_asm_qualifier");
5515 Ok(Self {
5516 span: ::treesitter_types::Span::from(node),
5517 text: node.utf8_text(src)?,
5518 })
5519 }
5520}
5521impl<'tree> ::treesitter_types::LeafNode<'tree> for GnuAsmQualifier<'tree> {
5522 fn text(&self) -> &'tree str {
5523 self.text
5524 }
5525}
5526impl ::treesitter_types::Spanned for GnuAsmQualifier<'_> {
5527 fn span(&self) -> ::treesitter_types::Span {
5528 self.span
5529 }
5530}
5531#[derive(Debug, Clone)]
5532pub struct GotoStatement<'tree> {
5533 pub span: ::treesitter_types::Span,
5534 pub label: StatementIdentifier<'tree>,
5535}
5536impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
5537 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5538 fn from_node(
5539 node: ::tree_sitter::Node<'tree>,
5540 src: &'tree [u8],
5541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5542 debug_assert_eq!(node.kind(), "goto_statement");
5543 Ok(Self {
5544 span: ::treesitter_types::Span::from(node),
5545 label: {
5546 let child = node
5547 .child_by_field_name("label")
5548 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
5549 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
5550 },
5551 })
5552 }
5553}
5554impl ::treesitter_types::Spanned for GotoStatement<'_> {
5555 fn span(&self) -> ::treesitter_types::Span {
5556 self.span
5557 }
5558}
5559#[derive(Debug, Clone)]
5560pub struct IfStatement<'tree> {
5561 pub span: ::treesitter_types::Span,
5562 pub alternative: ::core::option::Option<ElseClause<'tree>>,
5563 pub condition: ConditionClause<'tree>,
5564 pub consequence: Statement<'tree>,
5565}
5566impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
5567 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5568 fn from_node(
5569 node: ::tree_sitter::Node<'tree>,
5570 src: &'tree [u8],
5571 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5572 debug_assert_eq!(node.kind(), "if_statement");
5573 Ok(Self {
5574 span: ::treesitter_types::Span::from(node),
5575 alternative: match node.child_by_field_name("alternative") {
5576 Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
5577 child, src,
5578 )?),
5579 None => None,
5580 },
5581 condition: {
5582 let child = node.child_by_field_name("condition").ok_or_else(|| {
5583 ::treesitter_types::ParseError::missing_field("condition", node)
5584 })?;
5585 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)?
5586 },
5587 consequence: {
5588 let child = node.child_by_field_name("consequence").ok_or_else(|| {
5589 ::treesitter_types::ParseError::missing_field("consequence", node)
5590 })?;
5591 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5592 },
5593 })
5594 }
5595}
5596impl ::treesitter_types::Spanned for IfStatement<'_> {
5597 fn span(&self) -> ::treesitter_types::Span {
5598 self.span
5599 }
5600}
5601#[derive(Debug, Clone)]
5602pub struct InitDeclarator<'tree> {
5603 pub span: ::treesitter_types::Span,
5604 pub declarator: Declarator<'tree>,
5605 pub value: InitDeclaratorValue<'tree>,
5606}
5607impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclarator<'tree> {
5608 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5609 fn from_node(
5610 node: ::tree_sitter::Node<'tree>,
5611 src: &'tree [u8],
5612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5613 debug_assert_eq!(node.kind(), "init_declarator");
5614 Ok(Self {
5615 span: ::treesitter_types::Span::from(node),
5616 declarator: {
5617 let child = node.child_by_field_name("declarator").ok_or_else(|| {
5618 ::treesitter_types::ParseError::missing_field("declarator", node)
5619 })?;
5620 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)?
5621 },
5622 value: {
5623 let child = node
5624 .child_by_field_name("value")
5625 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5626 <InitDeclaratorValue as ::treesitter_types::FromNode>::from_node(child, src)?
5627 },
5628 })
5629 }
5630}
5631impl ::treesitter_types::Spanned for InitDeclarator<'_> {
5632 fn span(&self) -> ::treesitter_types::Span {
5633 self.span
5634 }
5635}
5636#[derive(Debug, Clone)]
5637pub struct InitStatement<'tree> {
5638 pub span: ::treesitter_types::Span,
5639 pub children: InitStatementChildren<'tree>,
5640}
5641impl<'tree> ::treesitter_types::FromNode<'tree> for InitStatement<'tree> {
5642 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5643 fn from_node(
5644 node: ::tree_sitter::Node<'tree>,
5645 src: &'tree [u8],
5646 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5647 debug_assert_eq!(node.kind(), "init_statement");
5648 Ok(Self {
5649 span: ::treesitter_types::Span::from(node),
5650 children: {
5651 #[allow(clippy::suspicious_else_formatting)]
5652 let non_field_children = {
5653 let mut cursor = node.walk();
5654 let mut result = ::std::vec::Vec::new();
5655 if cursor.goto_first_child() {
5656 loop {
5657 if cursor.field_name().is_none()
5658 && cursor.node().is_named()
5659 && !cursor.node().is_extra()
5660 {
5661 result.push(cursor.node());
5662 }
5663 if !cursor.goto_next_sibling() {
5664 break;
5665 }
5666 }
5667 }
5668 result
5669 };
5670 let child = if let Some(&c) = non_field_children.first() {
5671 c
5672 } else {
5673 let mut fallback_cursor = node.walk();
5674 let mut fallback_child = None;
5675 if fallback_cursor.goto_first_child() {
5676 loop {
5677 if fallback_cursor.field_name().is_none()
5678 && !fallback_cursor.node().is_extra()
5679 {
5680 let candidate = fallback_cursor.node();
5681 #[allow(clippy::needless_question_mark)]
5682 if (|| -> ::core::result::Result<
5683 _,
5684 ::treesitter_types::ParseError,
5685 > {
5686 let child = candidate;
5687 Ok(
5688 <InitStatementChildren as ::treesitter_types::FromNode>::from_node(
5689 child,
5690 src,
5691 )?,
5692 )
5693 })()
5694 .is_ok()
5695 {
5696 fallback_child = Some(candidate);
5697 break;
5698 }
5699 }
5700 if !fallback_cursor.goto_next_sibling() {
5701 break;
5702 }
5703 }
5704 }
5705 if fallback_child.is_none() {
5706 let mut cursor2 = node.walk();
5707 if cursor2.goto_first_child() {
5708 loop {
5709 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5710 let candidate = cursor2.node();
5711 #[allow(clippy::needless_question_mark)]
5712 if (|| -> ::core::result::Result<
5713 _,
5714 ::treesitter_types::ParseError,
5715 > {
5716 let child = candidate;
5717 Ok(
5718 <InitStatementChildren as ::treesitter_types::FromNode>::from_node(
5719 child,
5720 src,
5721 )?,
5722 )
5723 })()
5724 .is_ok()
5725 {
5726 fallback_child = Some(candidate);
5727 break;
5728 }
5729 }
5730 if !cursor2.goto_next_sibling() {
5731 break;
5732 }
5733 }
5734 }
5735 }
5736 fallback_child.ok_or_else(|| {
5737 ::treesitter_types::ParseError::missing_field("children", node)
5738 })?
5739 };
5740 <InitStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5741 },
5742 })
5743 }
5744}
5745impl ::treesitter_types::Spanned for InitStatement<'_> {
5746 fn span(&self) -> ::treesitter_types::Span {
5747 self.span
5748 }
5749}
5750#[derive(Debug, Clone)]
5751pub struct InitializerList<'tree> {
5752 pub span: ::treesitter_types::Span,
5753 pub children: ::std::vec::Vec<InitializerListChildren<'tree>>,
5754}
5755impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerList<'tree> {
5756 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5757 fn from_node(
5758 node: ::tree_sitter::Node<'tree>,
5759 src: &'tree [u8],
5760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5761 debug_assert_eq!(node.kind(), "initializer_list");
5762 Ok(Self {
5763 span: ::treesitter_types::Span::from(node),
5764 children: {
5765 #[allow(clippy::suspicious_else_formatting)]
5766 let non_field_children = {
5767 let mut cursor = node.walk();
5768 let mut result = ::std::vec::Vec::new();
5769 if cursor.goto_first_child() {
5770 loop {
5771 if cursor.field_name().is_none()
5772 && cursor.node().is_named()
5773 && !cursor.node().is_extra()
5774 {
5775 result.push(cursor.node());
5776 }
5777 if !cursor.goto_next_sibling() {
5778 break;
5779 }
5780 }
5781 }
5782 result
5783 };
5784 let mut items = ::std::vec::Vec::new();
5785 for child in non_field_children {
5786 items.push(
5787 <InitializerListChildren as ::treesitter_types::FromNode>::from_node(
5788 child, src,
5789 )?,
5790 );
5791 }
5792 items
5793 },
5794 })
5795 }
5796}
5797impl ::treesitter_types::Spanned for InitializerList<'_> {
5798 fn span(&self) -> ::treesitter_types::Span {
5799 self.span
5800 }
5801}
5802#[derive(Debug, Clone)]
5803pub struct InitializerPair<'tree> {
5804 pub span: ::treesitter_types::Span,
5805 pub designator: ::std::vec::Vec<InitializerPairDesignator<'tree>>,
5806 pub value: InitializerPairValue<'tree>,
5807}
5808impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPair<'tree> {
5809 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5810 fn from_node(
5811 node: ::tree_sitter::Node<'tree>,
5812 src: &'tree [u8],
5813 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5814 debug_assert_eq!(node.kind(), "initializer_pair");
5815 Ok(Self {
5816 span: ::treesitter_types::Span::from(node),
5817 designator: {
5818 let mut cursor = node.walk();
5819 let mut items = ::std::vec::Vec::new();
5820 for child in node.children_by_field_name("designator", &mut cursor) {
5821 items.push(
5822 <InitializerPairDesignator as ::treesitter_types::FromNode>::from_node(
5823 child, src,
5824 )?,
5825 );
5826 }
5827 items
5828 },
5829 value: {
5830 let child = node
5831 .child_by_field_name("value")
5832 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
5833 <InitializerPairValue as ::treesitter_types::FromNode>::from_node(child, src)?
5834 },
5835 })
5836 }
5837}
5838impl ::treesitter_types::Spanned for InitializerPair<'_> {
5839 fn span(&self) -> ::treesitter_types::Span {
5840 self.span
5841 }
5842}
5843#[derive(Debug, Clone)]
5844pub struct LabeledStatement<'tree> {
5845 pub span: ::treesitter_types::Span,
5846 pub label: StatementIdentifier<'tree>,
5847 pub children: LabeledStatementChildren<'tree>,
5848}
5849impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
5850 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5851 fn from_node(
5852 node: ::tree_sitter::Node<'tree>,
5853 src: &'tree [u8],
5854 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5855 debug_assert_eq!(node.kind(), "labeled_statement");
5856 Ok(Self {
5857 span: ::treesitter_types::Span::from(node),
5858 label: {
5859 let child = node
5860 .child_by_field_name("label")
5861 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
5862 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
5863 },
5864 children: {
5865 #[allow(clippy::suspicious_else_formatting)]
5866 let non_field_children = {
5867 let mut cursor = node.walk();
5868 let mut result = ::std::vec::Vec::new();
5869 if cursor.goto_first_child() {
5870 loop {
5871 if cursor.field_name().is_none()
5872 && cursor.node().is_named()
5873 && !cursor.node().is_extra()
5874 {
5875 result.push(cursor.node());
5876 }
5877 if !cursor.goto_next_sibling() {
5878 break;
5879 }
5880 }
5881 }
5882 result
5883 };
5884 let child = if let Some(&c) = non_field_children.first() {
5885 c
5886 } else {
5887 let mut fallback_cursor = node.walk();
5888 let mut fallback_child = None;
5889 if fallback_cursor.goto_first_child() {
5890 loop {
5891 if fallback_cursor.field_name().is_none()
5892 && !fallback_cursor.node().is_extra()
5893 {
5894 let candidate = fallback_cursor.node();
5895 #[allow(clippy::needless_question_mark)]
5896 if (|| -> ::core::result::Result<
5897 _,
5898 ::treesitter_types::ParseError,
5899 > {
5900 let child = candidate;
5901 Ok(
5902 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
5903 child,
5904 src,
5905 )?,
5906 )
5907 })()
5908 .is_ok()
5909 {
5910 fallback_child = Some(candidate);
5911 break;
5912 }
5913 }
5914 if !fallback_cursor.goto_next_sibling() {
5915 break;
5916 }
5917 }
5918 }
5919 if fallback_child.is_none() {
5920 let mut cursor2 = node.walk();
5921 if cursor2.goto_first_child() {
5922 loop {
5923 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5924 let candidate = cursor2.node();
5925 #[allow(clippy::needless_question_mark)]
5926 if (|| -> ::core::result::Result<
5927 _,
5928 ::treesitter_types::ParseError,
5929 > {
5930 let child = candidate;
5931 Ok(
5932 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(
5933 child,
5934 src,
5935 )?,
5936 )
5937 })()
5938 .is_ok()
5939 {
5940 fallback_child = Some(candidate);
5941 break;
5942 }
5943 }
5944 if !cursor2.goto_next_sibling() {
5945 break;
5946 }
5947 }
5948 }
5949 }
5950 fallback_child.ok_or_else(|| {
5951 ::treesitter_types::ParseError::missing_field("children", node)
5952 })?
5953 };
5954 <LabeledStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5955 },
5956 })
5957 }
5958}
5959impl ::treesitter_types::Spanned for LabeledStatement<'_> {
5960 fn span(&self) -> ::treesitter_types::Span {
5961 self.span
5962 }
5963}
5964#[derive(Debug, Clone)]
5965pub struct LambdaCaptureInitializer<'tree> {
5966 pub span: ::treesitter_types::Span,
5967 pub left: Identifier<'tree>,
5968 pub right: Expression<'tree>,
5969}
5970impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureInitializer<'tree> {
5971 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5972 fn from_node(
5973 node: ::tree_sitter::Node<'tree>,
5974 src: &'tree [u8],
5975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5976 debug_assert_eq!(node.kind(), "lambda_capture_initializer");
5977 Ok(Self {
5978 span: ::treesitter_types::Span::from(node),
5979 left: {
5980 let child = node
5981 .child_by_field_name("left")
5982 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5983 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5984 },
5985 right: {
5986 let child = node
5987 .child_by_field_name("right")
5988 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5989 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5990 },
5991 })
5992 }
5993}
5994impl ::treesitter_types::Spanned for LambdaCaptureInitializer<'_> {
5995 fn span(&self) -> ::treesitter_types::Span {
5996 self.span
5997 }
5998}
5999#[derive(Debug, Clone)]
6000pub struct LambdaCaptureSpecifier<'tree> {
6001 pub span: ::treesitter_types::Span,
6002 pub children: ::std::vec::Vec<LambdaCaptureSpecifierChildren<'tree>>,
6003}
6004impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureSpecifier<'tree> {
6005 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6006 fn from_node(
6007 node: ::tree_sitter::Node<'tree>,
6008 src: &'tree [u8],
6009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6010 debug_assert_eq!(node.kind(), "lambda_capture_specifier");
6011 Ok(Self {
6012 span: ::treesitter_types::Span::from(node),
6013 children: {
6014 #[allow(clippy::suspicious_else_formatting)]
6015 let non_field_children = {
6016 let mut cursor = node.walk();
6017 let mut result = ::std::vec::Vec::new();
6018 if cursor.goto_first_child() {
6019 loop {
6020 if cursor.field_name().is_none()
6021 && cursor.node().is_named()
6022 && !cursor.node().is_extra()
6023 {
6024 result.push(cursor.node());
6025 }
6026 if !cursor.goto_next_sibling() {
6027 break;
6028 }
6029 }
6030 }
6031 result
6032 };
6033 let mut items = ::std::vec::Vec::new();
6034 for child in non_field_children {
6035 items
6036 .push(
6037 <LambdaCaptureSpecifierChildren as ::treesitter_types::FromNode>::from_node(
6038 child,
6039 src,
6040 )?,
6041 );
6042 }
6043 items
6044 },
6045 })
6046 }
6047}
6048impl ::treesitter_types::Spanned for LambdaCaptureSpecifier<'_> {
6049 fn span(&self) -> ::treesitter_types::Span {
6050 self.span
6051 }
6052}
6053#[derive(Debug, Clone)]
6054pub struct LambdaDefaultCapture<'tree> {
6055 pub span: ::treesitter_types::Span,
6056 text: &'tree str,
6057}
6058impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaDefaultCapture<'tree> {
6059 fn from_node(
6060 node: ::tree_sitter::Node<'tree>,
6061 src: &'tree [u8],
6062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6063 debug_assert_eq!(node.kind(), "lambda_default_capture");
6064 Ok(Self {
6065 span: ::treesitter_types::Span::from(node),
6066 text: node.utf8_text(src)?,
6067 })
6068 }
6069}
6070impl<'tree> ::treesitter_types::LeafNode<'tree> for LambdaDefaultCapture<'tree> {
6071 fn text(&self) -> &'tree str {
6072 self.text
6073 }
6074}
6075impl ::treesitter_types::Spanned for LambdaDefaultCapture<'_> {
6076 fn span(&self) -> ::treesitter_types::Span {
6077 self.span
6078 }
6079}
6080#[derive(Debug, Clone)]
6081pub struct LambdaExpression<'tree> {
6082 pub span: ::treesitter_types::Span,
6083 pub body: CompoundStatement<'tree>,
6084 pub captures: LambdaCaptureSpecifier<'tree>,
6085 pub constraint: ::core::option::Option<RequiresClause<'tree>>,
6086 pub declarator: ::core::option::Option<AbstractFunctionDeclarator<'tree>>,
6087 pub template_parameters: ::core::option::Option<TemplateParameterList<'tree>>,
6088}
6089impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
6090 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6091 fn from_node(
6092 node: ::tree_sitter::Node<'tree>,
6093 src: &'tree [u8],
6094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6095 debug_assert_eq!(node.kind(), "lambda_expression");
6096 Ok(Self {
6097 span: ::treesitter_types::Span::from(node),
6098 body: {
6099 let child = node
6100 .child_by_field_name("body")
6101 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6102 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
6103 },
6104 captures: {
6105 let child = node.child_by_field_name("captures").ok_or_else(|| {
6106 ::treesitter_types::ParseError::missing_field("captures", node)
6107 })?;
6108 <LambdaCaptureSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
6109 },
6110 constraint: match node.child_by_field_name("constraint") {
6111 Some(child) => Some(<RequiresClause as ::treesitter_types::FromNode>::from_node(
6112 child, src,
6113 )?),
6114 None => None,
6115 },
6116 declarator: match node.child_by_field_name("declarator") {
6117 Some(child) => Some(
6118 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(
6119 child, src,
6120 )?,
6121 ),
6122 None => None,
6123 },
6124 template_parameters: match node.child_by_field_name("template_parameters") {
6125 Some(child) => Some(
6126 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)?,
6127 ),
6128 None => None,
6129 },
6130 })
6131 }
6132}
6133impl ::treesitter_types::Spanned for LambdaExpression<'_> {
6134 fn span(&self) -> ::treesitter_types::Span {
6135 self.span
6136 }
6137}
6138#[derive(Debug, Clone)]
6139pub struct LinkageSpecification<'tree> {
6140 pub span: ::treesitter_types::Span,
6141 pub body: LinkageSpecificationBody<'tree>,
6142 pub value: StringLiteral<'tree>,
6143}
6144impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecification<'tree> {
6145 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6146 fn from_node(
6147 node: ::tree_sitter::Node<'tree>,
6148 src: &'tree [u8],
6149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6150 debug_assert_eq!(node.kind(), "linkage_specification");
6151 Ok(Self {
6152 span: ::treesitter_types::Span::from(node),
6153 body: {
6154 let child = node
6155 .child_by_field_name("body")
6156 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6157 <LinkageSpecificationBody as ::treesitter_types::FromNode>::from_node(child, src)?
6158 },
6159 value: {
6160 let child = node
6161 .child_by_field_name("value")
6162 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6163 <StringLiteral as ::treesitter_types::FromNode>::from_node(child, src)?
6164 },
6165 })
6166 }
6167}
6168impl ::treesitter_types::Spanned for LinkageSpecification<'_> {
6169 fn span(&self) -> ::treesitter_types::Span {
6170 self.span
6171 }
6172}
6173#[derive(Debug, Clone)]
6174pub struct MsBasedModifier<'tree> {
6175 pub span: ::treesitter_types::Span,
6176 pub children: ArgumentList<'tree>,
6177}
6178impl<'tree> ::treesitter_types::FromNode<'tree> for MsBasedModifier<'tree> {
6179 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6180 fn from_node(
6181 node: ::tree_sitter::Node<'tree>,
6182 src: &'tree [u8],
6183 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6184 debug_assert_eq!(node.kind(), "ms_based_modifier");
6185 Ok(Self {
6186 span: ::treesitter_types::Span::from(node),
6187 children: {
6188 #[allow(clippy::suspicious_else_formatting)]
6189 let non_field_children = {
6190 let mut cursor = node.walk();
6191 let mut result = ::std::vec::Vec::new();
6192 if cursor.goto_first_child() {
6193 loop {
6194 if cursor.field_name().is_none()
6195 && cursor.node().is_named()
6196 && !cursor.node().is_extra()
6197 {
6198 result.push(cursor.node());
6199 }
6200 if !cursor.goto_next_sibling() {
6201 break;
6202 }
6203 }
6204 }
6205 result
6206 };
6207 let child = if let Some(&c) = non_field_children.first() {
6208 c
6209 } else {
6210 let mut fallback_cursor = node.walk();
6211 let mut fallback_child = None;
6212 if fallback_cursor.goto_first_child() {
6213 loop {
6214 if fallback_cursor.field_name().is_none()
6215 && !fallback_cursor.node().is_extra()
6216 {
6217 let candidate = fallback_cursor.node();
6218 #[allow(clippy::needless_question_mark)]
6219 if (|| -> ::core::result::Result<
6220 _,
6221 ::treesitter_types::ParseError,
6222 > {
6223 let child = candidate;
6224 Ok(
6225 <ArgumentList as ::treesitter_types::FromNode>::from_node(
6226 child,
6227 src,
6228 )?,
6229 )
6230 })()
6231 .is_ok()
6232 {
6233 fallback_child = Some(candidate);
6234 break;
6235 }
6236 }
6237 if !fallback_cursor.goto_next_sibling() {
6238 break;
6239 }
6240 }
6241 }
6242 if fallback_child.is_none() {
6243 let mut cursor2 = node.walk();
6244 if cursor2.goto_first_child() {
6245 loop {
6246 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6247 let candidate = cursor2.node();
6248 #[allow(clippy::needless_question_mark)]
6249 if (|| -> ::core::result::Result<
6250 _,
6251 ::treesitter_types::ParseError,
6252 > {
6253 let child = candidate;
6254 Ok(
6255 <ArgumentList as ::treesitter_types::FromNode>::from_node(
6256 child,
6257 src,
6258 )?,
6259 )
6260 })()
6261 .is_ok()
6262 {
6263 fallback_child = Some(candidate);
6264 break;
6265 }
6266 }
6267 if !cursor2.goto_next_sibling() {
6268 break;
6269 }
6270 }
6271 }
6272 }
6273 fallback_child.ok_or_else(|| {
6274 ::treesitter_types::ParseError::missing_field("children", node)
6275 })?
6276 };
6277 <ArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
6278 },
6279 })
6280 }
6281}
6282impl ::treesitter_types::Spanned for MsBasedModifier<'_> {
6283 fn span(&self) -> ::treesitter_types::Span {
6284 self.span
6285 }
6286}
6287#[derive(Debug, Clone)]
6288pub struct MsCallModifier<'tree> {
6289 pub span: ::treesitter_types::Span,
6290 text: &'tree str,
6291}
6292impl<'tree> ::treesitter_types::FromNode<'tree> for MsCallModifier<'tree> {
6293 fn from_node(
6294 node: ::tree_sitter::Node<'tree>,
6295 src: &'tree [u8],
6296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6297 debug_assert_eq!(node.kind(), "ms_call_modifier");
6298 Ok(Self {
6299 span: ::treesitter_types::Span::from(node),
6300 text: node.utf8_text(src)?,
6301 })
6302 }
6303}
6304impl<'tree> ::treesitter_types::LeafNode<'tree> for MsCallModifier<'tree> {
6305 fn text(&self) -> &'tree str {
6306 self.text
6307 }
6308}
6309impl ::treesitter_types::Spanned for MsCallModifier<'_> {
6310 fn span(&self) -> ::treesitter_types::Span {
6311 self.span
6312 }
6313}
6314#[derive(Debug, Clone)]
6315pub struct MsDeclspecModifier<'tree> {
6316 pub span: ::treesitter_types::Span,
6317 pub children: Identifier<'tree>,
6318}
6319impl<'tree> ::treesitter_types::FromNode<'tree> for MsDeclspecModifier<'tree> {
6320 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6321 fn from_node(
6322 node: ::tree_sitter::Node<'tree>,
6323 src: &'tree [u8],
6324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6325 debug_assert_eq!(node.kind(), "ms_declspec_modifier");
6326 Ok(Self {
6327 span: ::treesitter_types::Span::from(node),
6328 children: {
6329 #[allow(clippy::suspicious_else_formatting)]
6330 let non_field_children = {
6331 let mut cursor = node.walk();
6332 let mut result = ::std::vec::Vec::new();
6333 if cursor.goto_first_child() {
6334 loop {
6335 if cursor.field_name().is_none()
6336 && cursor.node().is_named()
6337 && !cursor.node().is_extra()
6338 {
6339 result.push(cursor.node());
6340 }
6341 if !cursor.goto_next_sibling() {
6342 break;
6343 }
6344 }
6345 }
6346 result
6347 };
6348 let child = if let Some(&c) = non_field_children.first() {
6349 c
6350 } else {
6351 let mut fallback_cursor = node.walk();
6352 let mut fallback_child = None;
6353 if fallback_cursor.goto_first_child() {
6354 loop {
6355 if fallback_cursor.field_name().is_none()
6356 && !fallback_cursor.node().is_extra()
6357 {
6358 let candidate = fallback_cursor.node();
6359 #[allow(clippy::needless_question_mark)]
6360 if (|| -> ::core::result::Result<
6361 _,
6362 ::treesitter_types::ParseError,
6363 > {
6364 let child = candidate;
6365 Ok(
6366 <Identifier as ::treesitter_types::FromNode>::from_node(
6367 child,
6368 src,
6369 )?,
6370 )
6371 })()
6372 .is_ok()
6373 {
6374 fallback_child = Some(candidate);
6375 break;
6376 }
6377 }
6378 if !fallback_cursor.goto_next_sibling() {
6379 break;
6380 }
6381 }
6382 }
6383 if fallback_child.is_none() {
6384 let mut cursor2 = node.walk();
6385 if cursor2.goto_first_child() {
6386 loop {
6387 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6388 let candidate = cursor2.node();
6389 #[allow(clippy::needless_question_mark)]
6390 if (|| -> ::core::result::Result<
6391 _,
6392 ::treesitter_types::ParseError,
6393 > {
6394 let child = candidate;
6395 Ok(
6396 <Identifier as ::treesitter_types::FromNode>::from_node(
6397 child,
6398 src,
6399 )?,
6400 )
6401 })()
6402 .is_ok()
6403 {
6404 fallback_child = Some(candidate);
6405 break;
6406 }
6407 }
6408 if !cursor2.goto_next_sibling() {
6409 break;
6410 }
6411 }
6412 }
6413 }
6414 fallback_child.ok_or_else(|| {
6415 ::treesitter_types::ParseError::missing_field("children", node)
6416 })?
6417 };
6418 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
6419 },
6420 })
6421 }
6422}
6423impl ::treesitter_types::Spanned for MsDeclspecModifier<'_> {
6424 fn span(&self) -> ::treesitter_types::Span {
6425 self.span
6426 }
6427}
6428#[derive(Debug, Clone)]
6429pub struct MsPointerModifier<'tree> {
6430 pub span: ::treesitter_types::Span,
6431 pub children: MsPointerModifierChildren<'tree>,
6432}
6433impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifier<'tree> {
6434 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6435 fn from_node(
6436 node: ::tree_sitter::Node<'tree>,
6437 src: &'tree [u8],
6438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6439 debug_assert_eq!(node.kind(), "ms_pointer_modifier");
6440 Ok(Self {
6441 span: ::treesitter_types::Span::from(node),
6442 children: {
6443 #[allow(clippy::suspicious_else_formatting)]
6444 let non_field_children = {
6445 let mut cursor = node.walk();
6446 let mut result = ::std::vec::Vec::new();
6447 if cursor.goto_first_child() {
6448 loop {
6449 if cursor.field_name().is_none()
6450 && cursor.node().is_named()
6451 && !cursor.node().is_extra()
6452 {
6453 result.push(cursor.node());
6454 }
6455 if !cursor.goto_next_sibling() {
6456 break;
6457 }
6458 }
6459 }
6460 result
6461 };
6462 let child = if let Some(&c) = non_field_children.first() {
6463 c
6464 } else {
6465 let mut fallback_cursor = node.walk();
6466 let mut fallback_child = None;
6467 if fallback_cursor.goto_first_child() {
6468 loop {
6469 if fallback_cursor.field_name().is_none()
6470 && !fallback_cursor.node().is_extra()
6471 {
6472 let candidate = fallback_cursor.node();
6473 #[allow(clippy::needless_question_mark)]
6474 if (|| -> ::core::result::Result<
6475 _,
6476 ::treesitter_types::ParseError,
6477 > {
6478 let child = candidate;
6479 Ok(
6480 <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
6481 child,
6482 src,
6483 )?,
6484 )
6485 })()
6486 .is_ok()
6487 {
6488 fallback_child = Some(candidate);
6489 break;
6490 }
6491 }
6492 if !fallback_cursor.goto_next_sibling() {
6493 break;
6494 }
6495 }
6496 }
6497 if fallback_child.is_none() {
6498 let mut cursor2 = node.walk();
6499 if cursor2.goto_first_child() {
6500 loop {
6501 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6502 let candidate = cursor2.node();
6503 #[allow(clippy::needless_question_mark)]
6504 if (|| -> ::core::result::Result<
6505 _,
6506 ::treesitter_types::ParseError,
6507 > {
6508 let child = candidate;
6509 Ok(
6510 <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(
6511 child,
6512 src,
6513 )?,
6514 )
6515 })()
6516 .is_ok()
6517 {
6518 fallback_child = Some(candidate);
6519 break;
6520 }
6521 }
6522 if !cursor2.goto_next_sibling() {
6523 break;
6524 }
6525 }
6526 }
6527 }
6528 fallback_child.ok_or_else(|| {
6529 ::treesitter_types::ParseError::missing_field("children", node)
6530 })?
6531 };
6532 <MsPointerModifierChildren as ::treesitter_types::FromNode>::from_node(child, src)?
6533 },
6534 })
6535 }
6536}
6537impl ::treesitter_types::Spanned for MsPointerModifier<'_> {
6538 fn span(&self) -> ::treesitter_types::Span {
6539 self.span
6540 }
6541}
6542#[derive(Debug, Clone)]
6543pub struct MsUnalignedPtrModifier<'tree> {
6544 pub span: ::treesitter_types::Span,
6545 text: &'tree str,
6546}
6547impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnalignedPtrModifier<'tree> {
6548 fn from_node(
6549 node: ::tree_sitter::Node<'tree>,
6550 src: &'tree [u8],
6551 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6552 debug_assert_eq!(node.kind(), "ms_unaligned_ptr_modifier");
6553 Ok(Self {
6554 span: ::treesitter_types::Span::from(node),
6555 text: node.utf8_text(src)?,
6556 })
6557 }
6558}
6559impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnalignedPtrModifier<'tree> {
6560 fn text(&self) -> &'tree str {
6561 self.text
6562 }
6563}
6564impl ::treesitter_types::Spanned for MsUnalignedPtrModifier<'_> {
6565 fn span(&self) -> ::treesitter_types::Span {
6566 self.span
6567 }
6568}
6569#[derive(Debug, Clone)]
6570pub struct NamespaceAliasDefinition<'tree> {
6571 pub span: ::treesitter_types::Span,
6572 pub name: NamespaceIdentifier<'tree>,
6573 pub children: NamespaceAliasDefinitionChildren<'tree>,
6574}
6575impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceAliasDefinition<'tree> {
6576 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6577 fn from_node(
6578 node: ::tree_sitter::Node<'tree>,
6579 src: &'tree [u8],
6580 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6581 debug_assert_eq!(node.kind(), "namespace_alias_definition");
6582 Ok(Self {
6583 span: ::treesitter_types::Span::from(node),
6584 name: {
6585 let child = node
6586 .child_by_field_name("name")
6587 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6588 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
6589 },
6590 children: {
6591 #[allow(clippy::suspicious_else_formatting)]
6592 let non_field_children = {
6593 let mut cursor = node.walk();
6594 let mut result = ::std::vec::Vec::new();
6595 if cursor.goto_first_child() {
6596 loop {
6597 if cursor.field_name().is_none()
6598 && cursor.node().is_named()
6599 && !cursor.node().is_extra()
6600 {
6601 result.push(cursor.node());
6602 }
6603 if !cursor.goto_next_sibling() {
6604 break;
6605 }
6606 }
6607 }
6608 result
6609 };
6610 let child = if let Some(&c) = non_field_children.first() {
6611 c
6612 } else {
6613 let mut fallback_cursor = node.walk();
6614 let mut fallback_child = None;
6615 if fallback_cursor.goto_first_child() {
6616 loop {
6617 if fallback_cursor.field_name().is_none()
6618 && !fallback_cursor.node().is_extra()
6619 {
6620 let candidate = fallback_cursor.node();
6621 #[allow(clippy::needless_question_mark)]
6622 if (|| -> ::core::result::Result<
6623 _,
6624 ::treesitter_types::ParseError,
6625 > {
6626 let child = candidate;
6627 Ok(
6628 <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6629 child,
6630 src,
6631 )?,
6632 )
6633 })()
6634 .is_ok()
6635 {
6636 fallback_child = Some(candidate);
6637 break;
6638 }
6639 }
6640 if !fallback_cursor.goto_next_sibling() {
6641 break;
6642 }
6643 }
6644 }
6645 if fallback_child.is_none() {
6646 let mut cursor2 = node.walk();
6647 if cursor2.goto_first_child() {
6648 loop {
6649 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6650 let candidate = cursor2.node();
6651 #[allow(clippy::needless_question_mark)]
6652 if (|| -> ::core::result::Result<
6653 _,
6654 ::treesitter_types::ParseError,
6655 > {
6656 let child = candidate;
6657 Ok(
6658 <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6659 child,
6660 src,
6661 )?,
6662 )
6663 })()
6664 .is_ok()
6665 {
6666 fallback_child = Some(candidate);
6667 break;
6668 }
6669 }
6670 if !cursor2.goto_next_sibling() {
6671 break;
6672 }
6673 }
6674 }
6675 }
6676 fallback_child.ok_or_else(|| {
6677 ::treesitter_types::ParseError::missing_field("children", node)
6678 })?
6679 };
6680 <NamespaceAliasDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6681 child, src,
6682 )?
6683 },
6684 })
6685 }
6686}
6687impl ::treesitter_types::Spanned for NamespaceAliasDefinition<'_> {
6688 fn span(&self) -> ::treesitter_types::Span {
6689 self.span
6690 }
6691}
6692#[derive(Debug, Clone)]
6693pub struct NamespaceDefinition<'tree> {
6694 pub span: ::treesitter_types::Span,
6695 pub body: DeclarationList<'tree>,
6696 pub name: ::core::option::Option<NamespaceDefinitionName<'tree>>,
6697 pub children: ::core::option::Option<AttributeDeclaration<'tree>>,
6698}
6699impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinition<'tree> {
6700 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6701 fn from_node(
6702 node: ::tree_sitter::Node<'tree>,
6703 src: &'tree [u8],
6704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6705 debug_assert_eq!(node.kind(), "namespace_definition");
6706 Ok(Self {
6707 span: ::treesitter_types::Span::from(node),
6708 body: {
6709 let child = node
6710 .child_by_field_name("body")
6711 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
6712 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
6713 },
6714 name: match node.child_by_field_name("name") {
6715 Some(child) => Some(
6716 <NamespaceDefinitionName as ::treesitter_types::FromNode>::from_node(
6717 child, src,
6718 )?,
6719 ),
6720 None => None,
6721 },
6722 children: {
6723 #[allow(clippy::suspicious_else_formatting)]
6724 let non_field_children = {
6725 let mut cursor = node.walk();
6726 let mut result = ::std::vec::Vec::new();
6727 if cursor.goto_first_child() {
6728 loop {
6729 if cursor.field_name().is_none()
6730 && cursor.node().is_named()
6731 && !cursor.node().is_extra()
6732 {
6733 result.push(cursor.node());
6734 }
6735 if !cursor.goto_next_sibling() {
6736 break;
6737 }
6738 }
6739 }
6740 result
6741 };
6742 match non_field_children.first() {
6743 Some(&child) => Some(
6744 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(
6745 child, src,
6746 )?,
6747 ),
6748 None => None,
6749 }
6750 },
6751 })
6752 }
6753}
6754impl ::treesitter_types::Spanned for NamespaceDefinition<'_> {
6755 fn span(&self) -> ::treesitter_types::Span {
6756 self.span
6757 }
6758}
6759#[derive(Debug, Clone)]
6760pub struct NestedNamespaceSpecifier<'tree> {
6761 pub span: ::treesitter_types::Span,
6762 pub children: ::std::vec::Vec<NestedNamespaceSpecifierChildren<'tree>>,
6763}
6764impl<'tree> ::treesitter_types::FromNode<'tree> for NestedNamespaceSpecifier<'tree> {
6765 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6766 fn from_node(
6767 node: ::tree_sitter::Node<'tree>,
6768 src: &'tree [u8],
6769 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6770 debug_assert_eq!(node.kind(), "nested_namespace_specifier");
6771 Ok(Self {
6772 span: ::treesitter_types::Span::from(node),
6773 children: {
6774 #[allow(clippy::suspicious_else_formatting)]
6775 let non_field_children = {
6776 let mut cursor = node.walk();
6777 let mut result = ::std::vec::Vec::new();
6778 if cursor.goto_first_child() {
6779 loop {
6780 if cursor.field_name().is_none()
6781 && cursor.node().is_named()
6782 && !cursor.node().is_extra()
6783 {
6784 result.push(cursor.node());
6785 }
6786 if !cursor.goto_next_sibling() {
6787 break;
6788 }
6789 }
6790 }
6791 result
6792 };
6793 let mut items = ::std::vec::Vec::new();
6794 for child in non_field_children {
6795 items
6796 .push(
6797 <NestedNamespaceSpecifierChildren as ::treesitter_types::FromNode>::from_node(
6798 child,
6799 src,
6800 )?,
6801 );
6802 }
6803 items
6804 },
6805 })
6806 }
6807}
6808impl ::treesitter_types::Spanned for NestedNamespaceSpecifier<'_> {
6809 fn span(&self) -> ::treesitter_types::Span {
6810 self.span
6811 }
6812}
6813#[derive(Debug, Clone)]
6814pub struct NewDeclarator<'tree> {
6815 pub span: ::treesitter_types::Span,
6816 pub length: Expression<'tree>,
6817 pub children: ::core::option::Option<::std::boxed::Box<NewDeclarator<'tree>>>,
6818}
6819impl<'tree> ::treesitter_types::FromNode<'tree> for NewDeclarator<'tree> {
6820 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6821 fn from_node(
6822 node: ::tree_sitter::Node<'tree>,
6823 src: &'tree [u8],
6824 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6825 debug_assert_eq!(node.kind(), "new_declarator");
6826 Ok(Self {
6827 span: ::treesitter_types::Span::from(node),
6828 length: {
6829 let child = node
6830 .child_by_field_name("length")
6831 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("length", node))?;
6832 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6833 },
6834 children: {
6835 #[allow(clippy::suspicious_else_formatting)]
6836 let non_field_children = {
6837 let mut cursor = node.walk();
6838 let mut result = ::std::vec::Vec::new();
6839 if cursor.goto_first_child() {
6840 loop {
6841 if cursor.field_name().is_none()
6842 && cursor.node().is_named()
6843 && !cursor.node().is_extra()
6844 {
6845 result.push(cursor.node());
6846 }
6847 if !cursor.goto_next_sibling() {
6848 break;
6849 }
6850 }
6851 }
6852 result
6853 };
6854 match non_field_children.first() {
6855 Some(&child) => Some(::std::boxed::Box::new(
6856 <NewDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
6857 )),
6858 None => None,
6859 }
6860 },
6861 })
6862 }
6863}
6864impl ::treesitter_types::Spanned for NewDeclarator<'_> {
6865 fn span(&self) -> ::treesitter_types::Span {
6866 self.span
6867 }
6868}
6869#[derive(Debug, Clone)]
6870pub struct NewExpression<'tree> {
6871 pub span: ::treesitter_types::Span,
6872 pub arguments: ::core::option::Option<NewExpressionArguments<'tree>>,
6873 pub declarator: ::core::option::Option<NewDeclarator<'tree>>,
6874 pub placement: ::core::option::Option<ArgumentList<'tree>>,
6875 pub r#type: TypeSpecifier<'tree>,
6876}
6877impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
6878 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6879 fn from_node(
6880 node: ::tree_sitter::Node<'tree>,
6881 src: &'tree [u8],
6882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6883 debug_assert_eq!(node.kind(), "new_expression");
6884 Ok(Self {
6885 span: ::treesitter_types::Span::from(node),
6886 arguments: match node.child_by_field_name("arguments") {
6887 Some(child) => Some(
6888 <NewExpressionArguments as ::treesitter_types::FromNode>::from_node(
6889 child, src,
6890 )?,
6891 ),
6892 None => None,
6893 },
6894 declarator: match node.child_by_field_name("declarator") {
6895 Some(child) => Some(<NewDeclarator as ::treesitter_types::FromNode>::from_node(
6896 child, src,
6897 )?),
6898 None => None,
6899 },
6900 placement: match node.child_by_field_name("placement") {
6901 Some(child) => Some(<ArgumentList as ::treesitter_types::FromNode>::from_node(
6902 child, src,
6903 )?),
6904 None => None,
6905 },
6906 r#type: {
6907 let child = node
6908 .child_by_field_name("type")
6909 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
6910 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
6911 },
6912 })
6913 }
6914}
6915impl ::treesitter_types::Spanned for NewExpression<'_> {
6916 fn span(&self) -> ::treesitter_types::Span {
6917 self.span
6918 }
6919}
6920#[derive(Debug, Clone)]
6921pub struct Noexcept<'tree> {
6922 pub span: ::treesitter_types::Span,
6923 pub children: ::core::option::Option<Expression<'tree>>,
6924}
6925impl<'tree> ::treesitter_types::FromNode<'tree> for Noexcept<'tree> {
6926 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6927 fn from_node(
6928 node: ::tree_sitter::Node<'tree>,
6929 src: &'tree [u8],
6930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6931 debug_assert_eq!(node.kind(), "noexcept");
6932 Ok(Self {
6933 span: ::treesitter_types::Span::from(node),
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 match non_field_children.first() {
6955 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6956 child, src,
6957 )?),
6958 None => None,
6959 }
6960 },
6961 })
6962 }
6963}
6964impl ::treesitter_types::Spanned for Noexcept<'_> {
6965 fn span(&self) -> ::treesitter_types::Span {
6966 self.span
6967 }
6968}
6969#[derive(Debug, Clone)]
6970pub struct Null<'tree> {
6971 pub span: ::treesitter_types::Span,
6972 text: &'tree str,
6973}
6974impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
6975 fn from_node(
6976 node: ::tree_sitter::Node<'tree>,
6977 src: &'tree [u8],
6978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6979 debug_assert_eq!(node.kind(), "null");
6980 Ok(Self {
6981 span: ::treesitter_types::Span::from(node),
6982 text: node.utf8_text(src)?,
6983 })
6984 }
6985}
6986impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
6987 fn text(&self) -> &'tree str {
6988 self.text
6989 }
6990}
6991impl ::treesitter_types::Spanned for Null<'_> {
6992 fn span(&self) -> ::treesitter_types::Span {
6993 self.span
6994 }
6995}
6996#[derive(Debug, Clone)]
6997pub struct OffsetofExpression<'tree> {
6998 pub span: ::treesitter_types::Span,
6999 pub member: FieldIdentifier<'tree>,
7000 pub r#type: TypeDescriptor<'tree>,
7001}
7002impl<'tree> ::treesitter_types::FromNode<'tree> for OffsetofExpression<'tree> {
7003 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7004 fn from_node(
7005 node: ::tree_sitter::Node<'tree>,
7006 src: &'tree [u8],
7007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7008 debug_assert_eq!(node.kind(), "offsetof_expression");
7009 Ok(Self {
7010 span: ::treesitter_types::Span::from(node),
7011 member: {
7012 let child = node
7013 .child_by_field_name("member")
7014 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("member", node))?;
7015 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7016 },
7017 r#type: {
7018 let child = node
7019 .child_by_field_name("type")
7020 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7021 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)?
7022 },
7023 })
7024 }
7025}
7026impl ::treesitter_types::Spanned for OffsetofExpression<'_> {
7027 fn span(&self) -> ::treesitter_types::Span {
7028 self.span
7029 }
7030}
7031#[derive(Debug, Clone)]
7032pub struct OperatorCast<'tree> {
7033 pub span: ::treesitter_types::Span,
7034 pub declarator: AbstractDeclarator<'tree>,
7035 pub r#type: TypeSpecifier<'tree>,
7036 pub children: ::std::vec::Vec<OperatorCastChildren<'tree>>,
7037}
7038impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorCast<'tree> {
7039 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7040 fn from_node(
7041 node: ::tree_sitter::Node<'tree>,
7042 src: &'tree [u8],
7043 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7044 debug_assert_eq!(node.kind(), "operator_cast");
7045 Ok(Self {
7046 span: ::treesitter_types::Span::from(node),
7047 declarator: {
7048 let child = node.child_by_field_name("declarator").ok_or_else(|| {
7049 ::treesitter_types::ParseError::missing_field("declarator", node)
7050 })?;
7051 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?
7052 },
7053 r#type: {
7054 let child = node
7055 .child_by_field_name("type")
7056 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7057 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
7058 },
7059 children: {
7060 #[allow(clippy::suspicious_else_formatting)]
7061 let non_field_children = {
7062 let mut cursor = node.walk();
7063 let mut result = ::std::vec::Vec::new();
7064 if cursor.goto_first_child() {
7065 loop {
7066 if cursor.field_name().is_none()
7067 && cursor.node().is_named()
7068 && !cursor.node().is_extra()
7069 {
7070 result.push(cursor.node());
7071 }
7072 if !cursor.goto_next_sibling() {
7073 break;
7074 }
7075 }
7076 }
7077 result
7078 };
7079 let mut items = ::std::vec::Vec::new();
7080 for child in non_field_children {
7081 items.push(
7082 <OperatorCastChildren as ::treesitter_types::FromNode>::from_node(
7083 child, src,
7084 )?,
7085 );
7086 }
7087 items
7088 },
7089 })
7090 }
7091}
7092impl ::treesitter_types::Spanned for OperatorCast<'_> {
7093 fn span(&self) -> ::treesitter_types::Span {
7094 self.span
7095 }
7096}
7097#[derive(Debug, Clone)]
7098pub struct OperatorName<'tree> {
7099 pub span: ::treesitter_types::Span,
7100 pub children: ::core::option::Option<Identifier<'tree>>,
7101}
7102impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorName<'tree> {
7103 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7104 fn from_node(
7105 node: ::tree_sitter::Node<'tree>,
7106 src: &'tree [u8],
7107 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7108 debug_assert_eq!(node.kind(), "operator_name");
7109 Ok(Self {
7110 span: ::treesitter_types::Span::from(node),
7111 children: {
7112 #[allow(clippy::suspicious_else_formatting)]
7113 let non_field_children = {
7114 let mut cursor = node.walk();
7115 let mut result = ::std::vec::Vec::new();
7116 if cursor.goto_first_child() {
7117 loop {
7118 if cursor.field_name().is_none()
7119 && cursor.node().is_named()
7120 && !cursor.node().is_extra()
7121 {
7122 result.push(cursor.node());
7123 }
7124 if !cursor.goto_next_sibling() {
7125 break;
7126 }
7127 }
7128 }
7129 result
7130 };
7131 match non_field_children.first() {
7132 Some(&child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
7133 child, src,
7134 )?),
7135 None => None,
7136 }
7137 },
7138 })
7139 }
7140}
7141impl ::treesitter_types::Spanned for OperatorName<'_> {
7142 fn span(&self) -> ::treesitter_types::Span {
7143 self.span
7144 }
7145}
7146#[derive(Debug, Clone)]
7147pub struct OptionalParameterDeclaration<'tree> {
7148 pub span: ::treesitter_types::Span,
7149 pub declarator: ::core::option::Option<OptionalParameterDeclarationDeclarator<'tree>>,
7150 pub default_value: Expression<'tree>,
7151 pub r#type: TypeSpecifier<'tree>,
7152 pub children: ::std::vec::Vec<OptionalParameterDeclarationChildren<'tree>>,
7153}
7154impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclaration<'tree> {
7155 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7156 fn from_node(
7157 node: ::tree_sitter::Node<'tree>,
7158 src: &'tree [u8],
7159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7160 debug_assert_eq!(node.kind(), "optional_parameter_declaration");
7161 Ok(Self {
7162 span: ::treesitter_types::Span::from(node),
7163 declarator: match node.child_by_field_name("declarator") {
7164 Some(child) => {
7165 Some(
7166 <OptionalParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
7167 child,
7168 src,
7169 )?,
7170 )
7171 }
7172 None => None,
7173 },
7174 default_value: {
7175 let child = node
7176 .child_by_field_name("default_value")
7177 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
7178 "default_value",
7179 node,
7180 ))?;
7181 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7182 },
7183 r#type: {
7184 let child = node
7185 .child_by_field_name("type")
7186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
7187 "type",
7188 node,
7189 ))?;
7190 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
7191 },
7192 children: {
7193 #[allow(clippy::suspicious_else_formatting)]
7194 let non_field_children = {
7195 let mut cursor = node.walk();
7196 let mut result = ::std::vec::Vec::new();
7197 if cursor.goto_first_child() {
7198 loop {
7199 if cursor.field_name().is_none() && cursor.node().is_named()
7200 && !cursor.node().is_extra()
7201 {
7202 result.push(cursor.node());
7203 }
7204 if !cursor.goto_next_sibling() {
7205 break;
7206 }
7207 }
7208 }
7209 result
7210 };
7211 let mut items = ::std::vec::Vec::new();
7212 for child in non_field_children {
7213 items
7214 .push(
7215 <OptionalParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7216 child,
7217 src,
7218 )?,
7219 );
7220 }
7221 items
7222 },
7223 })
7224 }
7225}
7226impl ::treesitter_types::Spanned for OptionalParameterDeclaration<'_> {
7227 fn span(&self) -> ::treesitter_types::Span {
7228 self.span
7229 }
7230}
7231#[derive(Debug, Clone)]
7232pub struct OptionalTypeParameterDeclaration<'tree> {
7233 pub span: ::treesitter_types::Span,
7234 pub default_type: TypeSpecifier<'tree>,
7235 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
7236}
7237impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalTypeParameterDeclaration<'tree> {
7238 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7239 fn from_node(
7240 node: ::tree_sitter::Node<'tree>,
7241 src: &'tree [u8],
7242 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7243 debug_assert_eq!(node.kind(), "optional_type_parameter_declaration");
7244 Ok(Self {
7245 span: ::treesitter_types::Span::from(node),
7246 default_type: {
7247 let child = node.child_by_field_name("default_type").ok_or_else(|| {
7248 ::treesitter_types::ParseError::missing_field("default_type", node)
7249 })?;
7250 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
7251 },
7252 name: match node.child_by_field_name("name") {
7253 Some(child) => Some(<TypeIdentifier as ::treesitter_types::FromNode>::from_node(
7254 child, src,
7255 )?),
7256 None => None,
7257 },
7258 })
7259 }
7260}
7261impl ::treesitter_types::Spanned for OptionalTypeParameterDeclaration<'_> {
7262 fn span(&self) -> ::treesitter_types::Span {
7263 self.span
7264 }
7265}
7266#[derive(Debug, Clone)]
7267pub struct ParameterDeclaration<'tree> {
7268 pub span: ::treesitter_types::Span,
7269 pub declarator: ::core::option::Option<ParameterDeclarationDeclarator<'tree>>,
7270 pub r#type: TypeSpecifier<'tree>,
7271 pub children: ::std::vec::Vec<ParameterDeclarationChildren<'tree>>,
7272}
7273impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclaration<'tree> {
7274 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7275 fn from_node(
7276 node: ::tree_sitter::Node<'tree>,
7277 src: &'tree [u8],
7278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7279 debug_assert_eq!(node.kind(), "parameter_declaration");
7280 Ok(Self {
7281 span: ::treesitter_types::Span::from(node),
7282 declarator: match node.child_by_field_name("declarator") {
7283 Some(child) => Some(
7284 <ParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
7285 child, src,
7286 )?,
7287 ),
7288 None => None,
7289 },
7290 r#type: {
7291 let child = node
7292 .child_by_field_name("type")
7293 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
7294 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
7295 },
7296 children: {
7297 #[allow(clippy::suspicious_else_formatting)]
7298 let non_field_children = {
7299 let mut cursor = node.walk();
7300 let mut result = ::std::vec::Vec::new();
7301 if cursor.goto_first_child() {
7302 loop {
7303 if cursor.field_name().is_none()
7304 && cursor.node().is_named()
7305 && !cursor.node().is_extra()
7306 {
7307 result.push(cursor.node());
7308 }
7309 if !cursor.goto_next_sibling() {
7310 break;
7311 }
7312 }
7313 }
7314 result
7315 };
7316 let mut items = ::std::vec::Vec::new();
7317 for child in non_field_children {
7318 items.push(
7319 <ParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
7320 child, src,
7321 )?,
7322 );
7323 }
7324 items
7325 },
7326 })
7327 }
7328}
7329impl ::treesitter_types::Spanned for ParameterDeclaration<'_> {
7330 fn span(&self) -> ::treesitter_types::Span {
7331 self.span
7332 }
7333}
7334#[derive(Debug, Clone)]
7335pub struct ParameterList<'tree> {
7336 pub span: ::treesitter_types::Span,
7337 pub children: ::std::vec::Vec<ParameterListChildren<'tree>>,
7338}
7339impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterList<'tree> {
7340 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7341 fn from_node(
7342 node: ::tree_sitter::Node<'tree>,
7343 src: &'tree [u8],
7344 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7345 debug_assert_eq!(node.kind(), "parameter_list");
7346 Ok(Self {
7347 span: ::treesitter_types::Span::from(node),
7348 children: {
7349 #[allow(clippy::suspicious_else_formatting)]
7350 let non_field_children = {
7351 let mut cursor = node.walk();
7352 let mut result = ::std::vec::Vec::new();
7353 if cursor.goto_first_child() {
7354 loop {
7355 if cursor.field_name().is_none()
7356 && cursor.node().is_named()
7357 && !cursor.node().is_extra()
7358 {
7359 result.push(cursor.node());
7360 }
7361 if !cursor.goto_next_sibling() {
7362 break;
7363 }
7364 }
7365 }
7366 result
7367 };
7368 let mut items = ::std::vec::Vec::new();
7369 for child in non_field_children {
7370 items.push(
7371 <ParameterListChildren as ::treesitter_types::FromNode>::from_node(
7372 child, src,
7373 )?,
7374 );
7375 }
7376 items
7377 },
7378 })
7379 }
7380}
7381impl ::treesitter_types::Spanned for ParameterList<'_> {
7382 fn span(&self) -> ::treesitter_types::Span {
7383 self.span
7384 }
7385}
7386#[derive(Debug, Clone)]
7387pub struct ParameterPackExpansion<'tree> {
7388 pub span: ::treesitter_types::Span,
7389 pub pattern: ParameterPackExpansionPattern<'tree>,
7390}
7391impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPackExpansion<'tree> {
7392 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7393 fn from_node(
7394 node: ::tree_sitter::Node<'tree>,
7395 src: &'tree [u8],
7396 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7397 debug_assert_eq!(node.kind(), "parameter_pack_expansion");
7398 Ok(Self {
7399 span: ::treesitter_types::Span::from(node),
7400 pattern: {
7401 let child = node.child_by_field_name("pattern").ok_or_else(|| {
7402 ::treesitter_types::ParseError::missing_field("pattern", node)
7403 })?;
7404 <ParameterPackExpansionPattern as ::treesitter_types::FromNode>::from_node(
7405 child, src,
7406 )?
7407 },
7408 })
7409 }
7410}
7411impl ::treesitter_types::Spanned for ParameterPackExpansion<'_> {
7412 fn span(&self) -> ::treesitter_types::Span {
7413 self.span
7414 }
7415}
7416#[derive(Debug, Clone)]
7417pub struct ParenthesizedDeclarator<'tree> {
7418 pub span: ::treesitter_types::Span,
7419 pub children: ::std::vec::Vec<ParenthesizedDeclaratorChildren<'tree>>,
7420}
7421impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclarator<'tree> {
7422 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7423 fn from_node(
7424 node: ::tree_sitter::Node<'tree>,
7425 src: &'tree [u8],
7426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7427 debug_assert_eq!(node.kind(), "parenthesized_declarator");
7428 Ok(Self {
7429 span: ::treesitter_types::Span::from(node),
7430 children: {
7431 #[allow(clippy::suspicious_else_formatting)]
7432 let non_field_children = {
7433 let mut cursor = node.walk();
7434 let mut result = ::std::vec::Vec::new();
7435 if cursor.goto_first_child() {
7436 loop {
7437 if cursor.field_name().is_none()
7438 && cursor.node().is_named()
7439 && !cursor.node().is_extra()
7440 {
7441 result.push(cursor.node());
7442 }
7443 if !cursor.goto_next_sibling() {
7444 break;
7445 }
7446 }
7447 }
7448 result
7449 };
7450 let mut items = ::std::vec::Vec::new();
7451 for child in non_field_children {
7452 items
7453 .push(
7454 <ParenthesizedDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
7455 child,
7456 src,
7457 )?,
7458 );
7459 }
7460 items
7461 },
7462 })
7463 }
7464}
7465impl ::treesitter_types::Spanned for ParenthesizedDeclarator<'_> {
7466 fn span(&self) -> ::treesitter_types::Span {
7467 self.span
7468 }
7469}
7470#[derive(Debug, Clone)]
7471pub struct ParenthesizedExpression<'tree> {
7472 pub span: ::treesitter_types::Span,
7473 pub children: ParenthesizedExpressionChildren<'tree>,
7474}
7475impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
7476 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7477 fn from_node(
7478 node: ::tree_sitter::Node<'tree>,
7479 src: &'tree [u8],
7480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7481 debug_assert_eq!(node.kind(), "parenthesized_expression");
7482 Ok(Self {
7483 span: ::treesitter_types::Span::from(node),
7484 children: {
7485 #[allow(clippy::suspicious_else_formatting)]
7486 let non_field_children = {
7487 let mut cursor = node.walk();
7488 let mut result = ::std::vec::Vec::new();
7489 if cursor.goto_first_child() {
7490 loop {
7491 if cursor.field_name().is_none()
7492 && cursor.node().is_named()
7493 && !cursor.node().is_extra()
7494 {
7495 result.push(cursor.node());
7496 }
7497 if !cursor.goto_next_sibling() {
7498 break;
7499 }
7500 }
7501 }
7502 result
7503 };
7504 let child = if let Some(&c) = non_field_children.first() {
7505 c
7506 } else {
7507 let mut fallback_cursor = node.walk();
7508 let mut fallback_child = None;
7509 if fallback_cursor.goto_first_child() {
7510 loop {
7511 if fallback_cursor.field_name().is_none()
7512 && !fallback_cursor.node().is_extra()
7513 {
7514 let candidate = fallback_cursor.node();
7515 #[allow(clippy::needless_question_mark)]
7516 if (|| -> ::core::result::Result<
7517 _,
7518 ::treesitter_types::ParseError,
7519 > {
7520 let child = candidate;
7521 Ok(
7522 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7523 child,
7524 src,
7525 )?,
7526 )
7527 })()
7528 .is_ok()
7529 {
7530 fallback_child = Some(candidate);
7531 break;
7532 }
7533 }
7534 if !fallback_cursor.goto_next_sibling() {
7535 break;
7536 }
7537 }
7538 }
7539 if fallback_child.is_none() {
7540 let mut cursor2 = node.walk();
7541 if cursor2.goto_first_child() {
7542 loop {
7543 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7544 let candidate = cursor2.node();
7545 #[allow(clippy::needless_question_mark)]
7546 if (|| -> ::core::result::Result<
7547 _,
7548 ::treesitter_types::ParseError,
7549 > {
7550 let child = candidate;
7551 Ok(
7552 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7553 child,
7554 src,
7555 )?,
7556 )
7557 })()
7558 .is_ok()
7559 {
7560 fallback_child = Some(candidate);
7561 break;
7562 }
7563 }
7564 if !cursor2.goto_next_sibling() {
7565 break;
7566 }
7567 }
7568 }
7569 }
7570 fallback_child.ok_or_else(|| {
7571 ::treesitter_types::ParseError::missing_field("children", node)
7572 })?
7573 };
7574 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7575 child, src,
7576 )?
7577 },
7578 })
7579 }
7580}
7581impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
7582 fn span(&self) -> ::treesitter_types::Span {
7583 self.span
7584 }
7585}
7586#[derive(Debug, Clone)]
7587pub struct PlaceholderTypeSpecifier<'tree> {
7588 pub span: ::treesitter_types::Span,
7589 pub constraint: ::core::option::Option<TypeSpecifier<'tree>>,
7590 pub children: PlaceholderTypeSpecifierChildren<'tree>,
7591}
7592impl<'tree> ::treesitter_types::FromNode<'tree> for PlaceholderTypeSpecifier<'tree> {
7593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7594 fn from_node(
7595 node: ::tree_sitter::Node<'tree>,
7596 src: &'tree [u8],
7597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7598 debug_assert_eq!(node.kind(), "placeholder_type_specifier");
7599 Ok(Self {
7600 span: ::treesitter_types::Span::from(node),
7601 constraint: match node.child_by_field_name("constraint") {
7602 Some(child) => Some(<TypeSpecifier as ::treesitter_types::FromNode>::from_node(
7603 child, src,
7604 )?),
7605 None => None,
7606 },
7607 children: {
7608 #[allow(clippy::suspicious_else_formatting)]
7609 let non_field_children = {
7610 let mut cursor = node.walk();
7611 let mut result = ::std::vec::Vec::new();
7612 if cursor.goto_first_child() {
7613 loop {
7614 if cursor.field_name().is_none()
7615 && cursor.node().is_named()
7616 && !cursor.node().is_extra()
7617 {
7618 result.push(cursor.node());
7619 }
7620 if !cursor.goto_next_sibling() {
7621 break;
7622 }
7623 }
7624 }
7625 result
7626 };
7627 let child = if let Some(&c) = non_field_children.first() {
7628 c
7629 } else {
7630 let mut fallback_cursor = node.walk();
7631 let mut fallback_child = None;
7632 if fallback_cursor.goto_first_child() {
7633 loop {
7634 if fallback_cursor.field_name().is_none()
7635 && !fallback_cursor.node().is_extra()
7636 {
7637 let candidate = fallback_cursor.node();
7638 #[allow(clippy::needless_question_mark)]
7639 if (|| -> ::core::result::Result<
7640 _,
7641 ::treesitter_types::ParseError,
7642 > {
7643 let child = candidate;
7644 Ok(
7645 <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
7646 child,
7647 src,
7648 )?,
7649 )
7650 })()
7651 .is_ok()
7652 {
7653 fallback_child = Some(candidate);
7654 break;
7655 }
7656 }
7657 if !fallback_cursor.goto_next_sibling() {
7658 break;
7659 }
7660 }
7661 }
7662 if fallback_child.is_none() {
7663 let mut cursor2 = node.walk();
7664 if cursor2.goto_first_child() {
7665 loop {
7666 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7667 let candidate = cursor2.node();
7668 #[allow(clippy::needless_question_mark)]
7669 if (|| -> ::core::result::Result<
7670 _,
7671 ::treesitter_types::ParseError,
7672 > {
7673 let child = candidate;
7674 Ok(
7675 <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
7676 child,
7677 src,
7678 )?,
7679 )
7680 })()
7681 .is_ok()
7682 {
7683 fallback_child = Some(candidate);
7684 break;
7685 }
7686 }
7687 if !cursor2.goto_next_sibling() {
7688 break;
7689 }
7690 }
7691 }
7692 }
7693 fallback_child.ok_or_else(|| {
7694 ::treesitter_types::ParseError::missing_field("children", node)
7695 })?
7696 };
7697 <PlaceholderTypeSpecifierChildren as ::treesitter_types::FromNode>::from_node(
7698 child, src,
7699 )?
7700 },
7701 })
7702 }
7703}
7704impl ::treesitter_types::Spanned for PlaceholderTypeSpecifier<'_> {
7705 fn span(&self) -> ::treesitter_types::Span {
7706 self.span
7707 }
7708}
7709#[derive(Debug, Clone)]
7710pub struct PointerDeclarator<'tree> {
7711 pub span: ::treesitter_types::Span,
7712 pub declarator: PointerDeclaratorDeclarator<'tree>,
7713 pub children: ::std::vec::Vec<PointerDeclaratorChildren<'tree>>,
7714}
7715impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclarator<'tree> {
7716 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7717 fn from_node(
7718 node: ::tree_sitter::Node<'tree>,
7719 src: &'tree [u8],
7720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7721 debug_assert_eq!(node.kind(), "pointer_declarator");
7722 Ok(Self {
7723 span: ::treesitter_types::Span::from(node),
7724 declarator: {
7725 let child = node.child_by_field_name("declarator").ok_or_else(|| {
7726 ::treesitter_types::ParseError::missing_field("declarator", node)
7727 })?;
7728 <PointerDeclaratorDeclarator as ::treesitter_types::FromNode>::from_node(
7729 child, src,
7730 )?
7731 },
7732 children: {
7733 #[allow(clippy::suspicious_else_formatting)]
7734 let non_field_children = {
7735 let mut cursor = node.walk();
7736 let mut result = ::std::vec::Vec::new();
7737 if cursor.goto_first_child() {
7738 loop {
7739 if cursor.field_name().is_none()
7740 && cursor.node().is_named()
7741 && !cursor.node().is_extra()
7742 {
7743 result.push(cursor.node());
7744 }
7745 if !cursor.goto_next_sibling() {
7746 break;
7747 }
7748 }
7749 }
7750 result
7751 };
7752 let mut items = ::std::vec::Vec::new();
7753 for child in non_field_children {
7754 items.push(
7755 <PointerDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
7756 child, src,
7757 )?,
7758 );
7759 }
7760 items
7761 },
7762 })
7763 }
7764}
7765impl ::treesitter_types::Spanned for PointerDeclarator<'_> {
7766 fn span(&self) -> ::treesitter_types::Span {
7767 self.span
7768 }
7769}
7770#[derive(Debug, Clone)]
7771pub struct PointerExpression<'tree> {
7772 pub span: ::treesitter_types::Span,
7773 pub argument: Expression<'tree>,
7774 pub operator: PointerExpressionOperator,
7775}
7776impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpression<'tree> {
7777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7778 fn from_node(
7779 node: ::tree_sitter::Node<'tree>,
7780 src: &'tree [u8],
7781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7782 debug_assert_eq!(node.kind(), "pointer_expression");
7783 Ok(Self {
7784 span: ::treesitter_types::Span::from(node),
7785 argument: {
7786 let child = node.child_by_field_name("argument").ok_or_else(|| {
7787 ::treesitter_types::ParseError::missing_field("argument", node)
7788 })?;
7789 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7790 },
7791 operator: {
7792 let child = node.child_by_field_name("operator").ok_or_else(|| {
7793 ::treesitter_types::ParseError::missing_field("operator", node)
7794 })?;
7795 <PointerExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
7796 },
7797 })
7798 }
7799}
7800impl ::treesitter_types::Spanned for PointerExpression<'_> {
7801 fn span(&self) -> ::treesitter_types::Span {
7802 self.span
7803 }
7804}
7805#[derive(Debug, Clone)]
7806pub struct PointerTypeDeclarator<'tree> {
7807 pub span: ::treesitter_types::Span,
7808 pub declarator: TypeDeclarator<'tree>,
7809 pub children: ::std::vec::Vec<PointerTypeDeclaratorChildren<'tree>>,
7810}
7811impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeDeclarator<'tree> {
7812 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7813 fn from_node(
7814 node: ::tree_sitter::Node<'tree>,
7815 src: &'tree [u8],
7816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7817 debug_assert_eq!(node.kind(), "pointer_type_declarator");
7818 Ok(Self {
7819 span: ::treesitter_types::Span::from(node),
7820 declarator: {
7821 let child = node.child_by_field_name("declarator").ok_or_else(|| {
7822 ::treesitter_types::ParseError::missing_field("declarator", node)
7823 })?;
7824 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?
7825 },
7826 children: {
7827 #[allow(clippy::suspicious_else_formatting)]
7828 let non_field_children = {
7829 let mut cursor = node.walk();
7830 let mut result = ::std::vec::Vec::new();
7831 if cursor.goto_first_child() {
7832 loop {
7833 if cursor.field_name().is_none()
7834 && cursor.node().is_named()
7835 && !cursor.node().is_extra()
7836 {
7837 result.push(cursor.node());
7838 }
7839 if !cursor.goto_next_sibling() {
7840 break;
7841 }
7842 }
7843 }
7844 result
7845 };
7846 let mut items = ::std::vec::Vec::new();
7847 for child in non_field_children {
7848 items.push(
7849 <PointerTypeDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
7850 child, src,
7851 )?,
7852 );
7853 }
7854 items
7855 },
7856 })
7857 }
7858}
7859impl ::treesitter_types::Spanned for PointerTypeDeclarator<'_> {
7860 fn span(&self) -> ::treesitter_types::Span {
7861 self.span
7862 }
7863}
7864#[derive(Debug, Clone)]
7865pub struct PreprocCall<'tree> {
7866 pub span: ::treesitter_types::Span,
7867 pub argument: ::core::option::Option<PreprocArg<'tree>>,
7868 pub directive: PreprocDirective<'tree>,
7869}
7870impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocCall<'tree> {
7871 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7872 fn from_node(
7873 node: ::tree_sitter::Node<'tree>,
7874 src: &'tree [u8],
7875 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7876 debug_assert_eq!(node.kind(), "preproc_call");
7877 Ok(Self {
7878 span: ::treesitter_types::Span::from(node),
7879 argument: match node.child_by_field_name("argument") {
7880 Some(child) => Some(<PreprocArg as ::treesitter_types::FromNode>::from_node(
7881 child, src,
7882 )?),
7883 None => None,
7884 },
7885 directive: {
7886 let child = node.child_by_field_name("directive").ok_or_else(|| {
7887 ::treesitter_types::ParseError::missing_field("directive", node)
7888 })?;
7889 <PreprocDirective as ::treesitter_types::FromNode>::from_node(child, src)?
7890 },
7891 })
7892 }
7893}
7894impl ::treesitter_types::Spanned for PreprocCall<'_> {
7895 fn span(&self) -> ::treesitter_types::Span {
7896 self.span
7897 }
7898}
7899#[derive(Debug, Clone)]
7900pub struct PreprocDef<'tree> {
7901 pub span: ::treesitter_types::Span,
7902 pub name: Identifier<'tree>,
7903 pub value: ::core::option::Option<PreprocArg<'tree>>,
7904}
7905impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDef<'tree> {
7906 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7907 fn from_node(
7908 node: ::tree_sitter::Node<'tree>,
7909 src: &'tree [u8],
7910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7911 debug_assert_eq!(node.kind(), "preproc_def");
7912 Ok(Self {
7913 span: ::treesitter_types::Span::from(node),
7914 name: {
7915 let child = node
7916 .child_by_field_name("name")
7917 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7918 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
7919 },
7920 value: match node.child_by_field_name("value") {
7921 Some(child) => Some(<PreprocArg as ::treesitter_types::FromNode>::from_node(
7922 child, src,
7923 )?),
7924 None => None,
7925 },
7926 })
7927 }
7928}
7929impl ::treesitter_types::Spanned for PreprocDef<'_> {
7930 fn span(&self) -> ::treesitter_types::Span {
7931 self.span
7932 }
7933}
7934#[derive(Debug, Clone)]
7935pub struct PreprocDefined<'tree> {
7936 pub span: ::treesitter_types::Span,
7937 pub children: Identifier<'tree>,
7938}
7939impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDefined<'tree> {
7940 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7941 fn from_node(
7942 node: ::tree_sitter::Node<'tree>,
7943 src: &'tree [u8],
7944 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7945 debug_assert_eq!(node.kind(), "preproc_defined");
7946 Ok(Self {
7947 span: ::treesitter_types::Span::from(node),
7948 children: {
7949 #[allow(clippy::suspicious_else_formatting)]
7950 let non_field_children = {
7951 let mut cursor = node.walk();
7952 let mut result = ::std::vec::Vec::new();
7953 if cursor.goto_first_child() {
7954 loop {
7955 if cursor.field_name().is_none()
7956 && cursor.node().is_named()
7957 && !cursor.node().is_extra()
7958 {
7959 result.push(cursor.node());
7960 }
7961 if !cursor.goto_next_sibling() {
7962 break;
7963 }
7964 }
7965 }
7966 result
7967 };
7968 let child = if let Some(&c) = non_field_children.first() {
7969 c
7970 } else {
7971 let mut fallback_cursor = node.walk();
7972 let mut fallback_child = None;
7973 if fallback_cursor.goto_first_child() {
7974 loop {
7975 if fallback_cursor.field_name().is_none()
7976 && !fallback_cursor.node().is_extra()
7977 {
7978 let candidate = fallback_cursor.node();
7979 #[allow(clippy::needless_question_mark)]
7980 if (|| -> ::core::result::Result<
7981 _,
7982 ::treesitter_types::ParseError,
7983 > {
7984 let child = candidate;
7985 Ok(
7986 <Identifier as ::treesitter_types::FromNode>::from_node(
7987 child,
7988 src,
7989 )?,
7990 )
7991 })()
7992 .is_ok()
7993 {
7994 fallback_child = Some(candidate);
7995 break;
7996 }
7997 }
7998 if !fallback_cursor.goto_next_sibling() {
7999 break;
8000 }
8001 }
8002 }
8003 if fallback_child.is_none() {
8004 let mut cursor2 = node.walk();
8005 if cursor2.goto_first_child() {
8006 loop {
8007 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8008 let candidate = cursor2.node();
8009 #[allow(clippy::needless_question_mark)]
8010 if (|| -> ::core::result::Result<
8011 _,
8012 ::treesitter_types::ParseError,
8013 > {
8014 let child = candidate;
8015 Ok(
8016 <Identifier as ::treesitter_types::FromNode>::from_node(
8017 child,
8018 src,
8019 )?,
8020 )
8021 })()
8022 .is_ok()
8023 {
8024 fallback_child = Some(candidate);
8025 break;
8026 }
8027 }
8028 if !cursor2.goto_next_sibling() {
8029 break;
8030 }
8031 }
8032 }
8033 }
8034 fallback_child.ok_or_else(|| {
8035 ::treesitter_types::ParseError::missing_field("children", node)
8036 })?
8037 };
8038 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
8039 },
8040 })
8041 }
8042}
8043impl ::treesitter_types::Spanned for PreprocDefined<'_> {
8044 fn span(&self) -> ::treesitter_types::Span {
8045 self.span
8046 }
8047}
8048#[derive(Debug, Clone)]
8049pub struct PreprocElif<'tree> {
8050 pub span: ::treesitter_types::Span,
8051 pub alternative: ::core::option::Option<PreprocElifAlternative<'tree>>,
8052 pub condition: PreprocElifCondition<'tree>,
8053 pub children: ::std::vec::Vec<PreprocElifChildren<'tree>>,
8054}
8055impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElif<'tree> {
8056 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8057 fn from_node(
8058 node: ::tree_sitter::Node<'tree>,
8059 src: &'tree [u8],
8060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8061 debug_assert_eq!(node.kind(), "preproc_elif");
8062 Ok(Self {
8063 span: ::treesitter_types::Span::from(node),
8064 alternative: match node.child_by_field_name("alternative") {
8065 Some(child) => Some(
8066 <PreprocElifAlternative as ::treesitter_types::FromNode>::from_node(
8067 child, src,
8068 )?,
8069 ),
8070 None => None,
8071 },
8072 condition: {
8073 let child = node.child_by_field_name("condition").ok_or_else(|| {
8074 ::treesitter_types::ParseError::missing_field("condition", node)
8075 })?;
8076 <PreprocElifCondition as ::treesitter_types::FromNode>::from_node(child, src)?
8077 },
8078 children: {
8079 #[allow(clippy::suspicious_else_formatting)]
8080 let non_field_children = {
8081 let mut cursor = node.walk();
8082 let mut result = ::std::vec::Vec::new();
8083 if cursor.goto_first_child() {
8084 loop {
8085 if cursor.field_name().is_none()
8086 && cursor.node().is_named()
8087 && !cursor.node().is_extra()
8088 {
8089 result.push(cursor.node());
8090 }
8091 if !cursor.goto_next_sibling() {
8092 break;
8093 }
8094 }
8095 }
8096 result
8097 };
8098 let mut items = ::std::vec::Vec::new();
8099 for child in non_field_children {
8100 items.push(
8101 <PreprocElifChildren as ::treesitter_types::FromNode>::from_node(
8102 child, src,
8103 )?,
8104 );
8105 }
8106 items
8107 },
8108 })
8109 }
8110}
8111impl ::treesitter_types::Spanned for PreprocElif<'_> {
8112 fn span(&self) -> ::treesitter_types::Span {
8113 self.span
8114 }
8115}
8116#[derive(Debug, Clone)]
8117pub struct PreprocElifdef<'tree> {
8118 pub span: ::treesitter_types::Span,
8119 pub alternative: ::core::option::Option<PreprocElifdefAlternative<'tree>>,
8120 pub name: Identifier<'tree>,
8121 pub children: ::std::vec::Vec<PreprocElifdefChildren<'tree>>,
8122}
8123impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdef<'tree> {
8124 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8125 fn from_node(
8126 node: ::tree_sitter::Node<'tree>,
8127 src: &'tree [u8],
8128 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8129 debug_assert_eq!(node.kind(), "preproc_elifdef");
8130 Ok(Self {
8131 span: ::treesitter_types::Span::from(node),
8132 alternative: match node.child_by_field_name("alternative") {
8133 Some(child) => Some(
8134 <PreprocElifdefAlternative as ::treesitter_types::FromNode>::from_node(
8135 child, src,
8136 )?,
8137 ),
8138 None => None,
8139 },
8140 name: {
8141 let child = node
8142 .child_by_field_name("name")
8143 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8144 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
8145 },
8146 children: {
8147 #[allow(clippy::suspicious_else_formatting)]
8148 let non_field_children = {
8149 let mut cursor = node.walk();
8150 let mut result = ::std::vec::Vec::new();
8151 if cursor.goto_first_child() {
8152 loop {
8153 if cursor.field_name().is_none()
8154 && cursor.node().is_named()
8155 && !cursor.node().is_extra()
8156 {
8157 result.push(cursor.node());
8158 }
8159 if !cursor.goto_next_sibling() {
8160 break;
8161 }
8162 }
8163 }
8164 result
8165 };
8166 let mut items = ::std::vec::Vec::new();
8167 for child in non_field_children {
8168 items.push(
8169 <PreprocElifdefChildren as ::treesitter_types::FromNode>::from_node(
8170 child, src,
8171 )?,
8172 );
8173 }
8174 items
8175 },
8176 })
8177 }
8178}
8179impl ::treesitter_types::Spanned for PreprocElifdef<'_> {
8180 fn span(&self) -> ::treesitter_types::Span {
8181 self.span
8182 }
8183}
8184#[derive(Debug, Clone)]
8185pub struct PreprocElse<'tree> {
8186 pub span: ::treesitter_types::Span,
8187 pub children: ::std::vec::Vec<PreprocElseChildren<'tree>>,
8188}
8189impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElse<'tree> {
8190 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8191 fn from_node(
8192 node: ::tree_sitter::Node<'tree>,
8193 src: &'tree [u8],
8194 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8195 debug_assert_eq!(node.kind(), "preproc_else");
8196 Ok(Self {
8197 span: ::treesitter_types::Span::from(node),
8198 children: {
8199 #[allow(clippy::suspicious_else_formatting)]
8200 let non_field_children = {
8201 let mut cursor = node.walk();
8202 let mut result = ::std::vec::Vec::new();
8203 if cursor.goto_first_child() {
8204 loop {
8205 if cursor.field_name().is_none()
8206 && cursor.node().is_named()
8207 && !cursor.node().is_extra()
8208 {
8209 result.push(cursor.node());
8210 }
8211 if !cursor.goto_next_sibling() {
8212 break;
8213 }
8214 }
8215 }
8216 result
8217 };
8218 let mut items = ::std::vec::Vec::new();
8219 for child in non_field_children {
8220 items.push(
8221 <PreprocElseChildren as ::treesitter_types::FromNode>::from_node(
8222 child, src,
8223 )?,
8224 );
8225 }
8226 items
8227 },
8228 })
8229 }
8230}
8231impl ::treesitter_types::Spanned for PreprocElse<'_> {
8232 fn span(&self) -> ::treesitter_types::Span {
8233 self.span
8234 }
8235}
8236#[derive(Debug, Clone)]
8237pub struct PreprocFunctionDef<'tree> {
8238 pub span: ::treesitter_types::Span,
8239 pub name: Identifier<'tree>,
8240 pub parameters: PreprocParams<'tree>,
8241 pub value: ::core::option::Option<PreprocArg<'tree>>,
8242}
8243impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocFunctionDef<'tree> {
8244 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8245 fn from_node(
8246 node: ::tree_sitter::Node<'tree>,
8247 src: &'tree [u8],
8248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8249 debug_assert_eq!(node.kind(), "preproc_function_def");
8250 Ok(Self {
8251 span: ::treesitter_types::Span::from(node),
8252 name: {
8253 let child = node
8254 .child_by_field_name("name")
8255 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8256 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
8257 },
8258 parameters: {
8259 let child = node.child_by_field_name("parameters").ok_or_else(|| {
8260 ::treesitter_types::ParseError::missing_field("parameters", node)
8261 })?;
8262 <PreprocParams as ::treesitter_types::FromNode>::from_node(child, src)?
8263 },
8264 value: match node.child_by_field_name("value") {
8265 Some(child) => Some(<PreprocArg as ::treesitter_types::FromNode>::from_node(
8266 child, src,
8267 )?),
8268 None => None,
8269 },
8270 })
8271 }
8272}
8273impl ::treesitter_types::Spanned for PreprocFunctionDef<'_> {
8274 fn span(&self) -> ::treesitter_types::Span {
8275 self.span
8276 }
8277}
8278#[derive(Debug, Clone)]
8279pub struct PreprocIf<'tree> {
8280 pub span: ::treesitter_types::Span,
8281 pub alternative: ::core::option::Option<PreprocIfAlternative<'tree>>,
8282 pub condition: PreprocIfCondition<'tree>,
8283 pub children: ::std::vec::Vec<PreprocIfChildren<'tree>>,
8284}
8285impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIf<'tree> {
8286 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8287 fn from_node(
8288 node: ::tree_sitter::Node<'tree>,
8289 src: &'tree [u8],
8290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8291 debug_assert_eq!(node.kind(), "preproc_if");
8292 Ok(Self {
8293 span: ::treesitter_types::Span::from(node),
8294 alternative: match node.child_by_field_name("alternative") {
8295 Some(child) => Some(
8296 <PreprocIfAlternative as ::treesitter_types::FromNode>::from_node(child, src)?,
8297 ),
8298 None => None,
8299 },
8300 condition: {
8301 let child = node.child_by_field_name("condition").ok_or_else(|| {
8302 ::treesitter_types::ParseError::missing_field("condition", node)
8303 })?;
8304 <PreprocIfCondition as ::treesitter_types::FromNode>::from_node(child, src)?
8305 },
8306 children: {
8307 #[allow(clippy::suspicious_else_formatting)]
8308 let non_field_children = {
8309 let mut cursor = node.walk();
8310 let mut result = ::std::vec::Vec::new();
8311 if cursor.goto_first_child() {
8312 loop {
8313 if cursor.field_name().is_none()
8314 && cursor.node().is_named()
8315 && !cursor.node().is_extra()
8316 {
8317 result.push(cursor.node());
8318 }
8319 if !cursor.goto_next_sibling() {
8320 break;
8321 }
8322 }
8323 }
8324 result
8325 };
8326 let mut items = ::std::vec::Vec::new();
8327 for child in non_field_children {
8328 items.push(
8329 <PreprocIfChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8330 );
8331 }
8332 items
8333 },
8334 })
8335 }
8336}
8337impl ::treesitter_types::Spanned for PreprocIf<'_> {
8338 fn span(&self) -> ::treesitter_types::Span {
8339 self.span
8340 }
8341}
8342#[derive(Debug, Clone)]
8343pub struct PreprocIfdef<'tree> {
8344 pub span: ::treesitter_types::Span,
8345 pub alternative: ::core::option::Option<PreprocIfdefAlternative<'tree>>,
8346 pub name: Identifier<'tree>,
8347 pub children: ::std::vec::Vec<PreprocIfdefChildren<'tree>>,
8348}
8349impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdef<'tree> {
8350 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8351 fn from_node(
8352 node: ::tree_sitter::Node<'tree>,
8353 src: &'tree [u8],
8354 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8355 debug_assert_eq!(node.kind(), "preproc_ifdef");
8356 Ok(Self {
8357 span: ::treesitter_types::Span::from(node),
8358 alternative: match node.child_by_field_name("alternative") {
8359 Some(child) => Some(
8360 <PreprocIfdefAlternative as ::treesitter_types::FromNode>::from_node(
8361 child, src,
8362 )?,
8363 ),
8364 None => None,
8365 },
8366 name: {
8367 let child = node
8368 .child_by_field_name("name")
8369 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8370 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
8371 },
8372 children: {
8373 #[allow(clippy::suspicious_else_formatting)]
8374 let non_field_children = {
8375 let mut cursor = node.walk();
8376 let mut result = ::std::vec::Vec::new();
8377 if cursor.goto_first_child() {
8378 loop {
8379 if cursor.field_name().is_none()
8380 && cursor.node().is_named()
8381 && !cursor.node().is_extra()
8382 {
8383 result.push(cursor.node());
8384 }
8385 if !cursor.goto_next_sibling() {
8386 break;
8387 }
8388 }
8389 }
8390 result
8391 };
8392 let mut items = ::std::vec::Vec::new();
8393 for child in non_field_children {
8394 items.push(
8395 <PreprocIfdefChildren as ::treesitter_types::FromNode>::from_node(
8396 child, src,
8397 )?,
8398 );
8399 }
8400 items
8401 },
8402 })
8403 }
8404}
8405impl ::treesitter_types::Spanned for PreprocIfdef<'_> {
8406 fn span(&self) -> ::treesitter_types::Span {
8407 self.span
8408 }
8409}
8410#[derive(Debug, Clone)]
8411pub struct PreprocInclude<'tree> {
8412 pub span: ::treesitter_types::Span,
8413 pub path: PreprocIncludePath<'tree>,
8414}
8415impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocInclude<'tree> {
8416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8417 fn from_node(
8418 node: ::tree_sitter::Node<'tree>,
8419 src: &'tree [u8],
8420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8421 debug_assert_eq!(node.kind(), "preproc_include");
8422 Ok(Self {
8423 span: ::treesitter_types::Span::from(node),
8424 path: {
8425 let child = node
8426 .child_by_field_name("path")
8427 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("path", node))?;
8428 <PreprocIncludePath as ::treesitter_types::FromNode>::from_node(child, src)?
8429 },
8430 })
8431 }
8432}
8433impl ::treesitter_types::Spanned for PreprocInclude<'_> {
8434 fn span(&self) -> ::treesitter_types::Span {
8435 self.span
8436 }
8437}
8438#[derive(Debug, Clone)]
8439pub struct PreprocParams<'tree> {
8440 pub span: ::treesitter_types::Span,
8441 pub children: ::std::vec::Vec<Identifier<'tree>>,
8442}
8443impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocParams<'tree> {
8444 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8445 fn from_node(
8446 node: ::tree_sitter::Node<'tree>,
8447 src: &'tree [u8],
8448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8449 debug_assert_eq!(node.kind(), "preproc_params");
8450 Ok(Self {
8451 span: ::treesitter_types::Span::from(node),
8452 children: {
8453 #[allow(clippy::suspicious_else_formatting)]
8454 let non_field_children = {
8455 let mut cursor = node.walk();
8456 let mut result = ::std::vec::Vec::new();
8457 if cursor.goto_first_child() {
8458 loop {
8459 if cursor.field_name().is_none()
8460 && cursor.node().is_named()
8461 && !cursor.node().is_extra()
8462 {
8463 result.push(cursor.node());
8464 }
8465 if !cursor.goto_next_sibling() {
8466 break;
8467 }
8468 }
8469 }
8470 result
8471 };
8472 let mut items = ::std::vec::Vec::new();
8473 for child in non_field_children {
8474 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
8475 child, src,
8476 )?);
8477 }
8478 items
8479 },
8480 })
8481 }
8482}
8483impl ::treesitter_types::Spanned for PreprocParams<'_> {
8484 fn span(&self) -> ::treesitter_types::Span {
8485 self.span
8486 }
8487}
8488#[derive(Debug, Clone)]
8489pub struct PureVirtualClause<'tree> {
8490 pub span: ::treesitter_types::Span,
8491 text: &'tree str,
8492}
8493impl<'tree> ::treesitter_types::FromNode<'tree> for PureVirtualClause<'tree> {
8494 fn from_node(
8495 node: ::tree_sitter::Node<'tree>,
8496 src: &'tree [u8],
8497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8498 debug_assert_eq!(node.kind(), "pure_virtual_clause");
8499 Ok(Self {
8500 span: ::treesitter_types::Span::from(node),
8501 text: node.utf8_text(src)?,
8502 })
8503 }
8504}
8505impl<'tree> ::treesitter_types::LeafNode<'tree> for PureVirtualClause<'tree> {
8506 fn text(&self) -> &'tree str {
8507 self.text
8508 }
8509}
8510impl ::treesitter_types::Spanned for PureVirtualClause<'_> {
8511 fn span(&self) -> ::treesitter_types::Span {
8512 self.span
8513 }
8514}
8515#[derive(Debug, Clone)]
8516pub struct QualifiedIdentifier<'tree> {
8517 pub span: ::treesitter_types::Span,
8518 pub name: ::std::vec::Vec<QualifiedIdentifierName<'tree>>,
8519 pub scope: ::core::option::Option<QualifiedIdentifierScope<'tree>>,
8520}
8521impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifier<'tree> {
8522 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8523 fn from_node(
8524 node: ::tree_sitter::Node<'tree>,
8525 src: &'tree [u8],
8526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8527 debug_assert_eq!(node.kind(), "qualified_identifier");
8528 Ok(Self {
8529 span: ::treesitter_types::Span::from(node),
8530 name: {
8531 let mut cursor = node.walk();
8532 let mut items = ::std::vec::Vec::new();
8533 for child in node.children_by_field_name("name", &mut cursor) {
8534 items.push(
8535 <QualifiedIdentifierName as ::treesitter_types::FromNode>::from_node(
8536 child, src,
8537 )?,
8538 );
8539 }
8540 items
8541 },
8542 scope: match node.child_by_field_name("scope") {
8543 Some(child) => Some(
8544 <QualifiedIdentifierScope as ::treesitter_types::FromNode>::from_node(
8545 child, src,
8546 )?,
8547 ),
8548 None => None,
8549 },
8550 })
8551 }
8552}
8553impl ::treesitter_types::Spanned for QualifiedIdentifier<'_> {
8554 fn span(&self) -> ::treesitter_types::Span {
8555 self.span
8556 }
8557}
8558#[derive(Debug, Clone)]
8559pub struct RawStringLiteral<'tree> {
8560 pub span: ::treesitter_types::Span,
8561 pub delimiter: ::core::option::Option<RawStringDelimiter<'tree>>,
8562 pub children: ::std::vec::Vec<RawStringLiteralChildren<'tree>>,
8563}
8564impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteral<'tree> {
8565 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8566 fn from_node(
8567 node: ::tree_sitter::Node<'tree>,
8568 src: &'tree [u8],
8569 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8570 debug_assert_eq!(node.kind(), "raw_string_literal");
8571 Ok(Self {
8572 span: ::treesitter_types::Span::from(node),
8573 delimiter: match node.child_by_field_name("delimiter") {
8574 Some(child) => Some(
8575 <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(child, src)?,
8576 ),
8577 None => None,
8578 },
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(
8602 <RawStringLiteralChildren as ::treesitter_types::FromNode>::from_node(
8603 child, src,
8604 )?,
8605 );
8606 }
8607 items
8608 },
8609 })
8610 }
8611}
8612impl ::treesitter_types::Spanned for RawStringLiteral<'_> {
8613 fn span(&self) -> ::treesitter_types::Span {
8614 self.span
8615 }
8616}
8617#[derive(Debug, Clone)]
8618pub struct RefQualifier<'tree> {
8619 pub span: ::treesitter_types::Span,
8620 text: &'tree str,
8621}
8622impl<'tree> ::treesitter_types::FromNode<'tree> for RefQualifier<'tree> {
8623 fn from_node(
8624 node: ::tree_sitter::Node<'tree>,
8625 src: &'tree [u8],
8626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8627 debug_assert_eq!(node.kind(), "ref_qualifier");
8628 Ok(Self {
8629 span: ::treesitter_types::Span::from(node),
8630 text: node.utf8_text(src)?,
8631 })
8632 }
8633}
8634impl<'tree> ::treesitter_types::LeafNode<'tree> for RefQualifier<'tree> {
8635 fn text(&self) -> &'tree str {
8636 self.text
8637 }
8638}
8639impl ::treesitter_types::Spanned for RefQualifier<'_> {
8640 fn span(&self) -> ::treesitter_types::Span {
8641 self.span
8642 }
8643}
8644#[derive(Debug, Clone)]
8645pub struct ReferenceDeclarator<'tree> {
8646 pub span: ::treesitter_types::Span,
8647 pub children: ReferenceDeclaratorChildren<'tree>,
8648}
8649impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceDeclarator<'tree> {
8650 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8651 fn from_node(
8652 node: ::tree_sitter::Node<'tree>,
8653 src: &'tree [u8],
8654 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8655 debug_assert_eq!(node.kind(), "reference_declarator");
8656 Ok(Self {
8657 span: ::treesitter_types::Span::from(node),
8658 children: {
8659 #[allow(clippy::suspicious_else_formatting)]
8660 let non_field_children = {
8661 let mut cursor = node.walk();
8662 let mut result = ::std::vec::Vec::new();
8663 if cursor.goto_first_child() {
8664 loop {
8665 if cursor.field_name().is_none()
8666 && cursor.node().is_named()
8667 && !cursor.node().is_extra()
8668 {
8669 result.push(cursor.node());
8670 }
8671 if !cursor.goto_next_sibling() {
8672 break;
8673 }
8674 }
8675 }
8676 result
8677 };
8678 let child = if let Some(&c) = non_field_children.first() {
8679 c
8680 } else {
8681 let mut fallback_cursor = node.walk();
8682 let mut fallback_child = None;
8683 if fallback_cursor.goto_first_child() {
8684 loop {
8685 if fallback_cursor.field_name().is_none()
8686 && !fallback_cursor.node().is_extra()
8687 {
8688 let candidate = fallback_cursor.node();
8689 #[allow(clippy::needless_question_mark)]
8690 if (|| -> ::core::result::Result<
8691 _,
8692 ::treesitter_types::ParseError,
8693 > {
8694 let child = candidate;
8695 Ok(
8696 <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
8697 child,
8698 src,
8699 )?,
8700 )
8701 })()
8702 .is_ok()
8703 {
8704 fallback_child = Some(candidate);
8705 break;
8706 }
8707 }
8708 if !fallback_cursor.goto_next_sibling() {
8709 break;
8710 }
8711 }
8712 }
8713 if fallback_child.is_none() {
8714 let mut cursor2 = node.walk();
8715 if cursor2.goto_first_child() {
8716 loop {
8717 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8718 let candidate = cursor2.node();
8719 #[allow(clippy::needless_question_mark)]
8720 if (|| -> ::core::result::Result<
8721 _,
8722 ::treesitter_types::ParseError,
8723 > {
8724 let child = candidate;
8725 Ok(
8726 <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
8727 child,
8728 src,
8729 )?,
8730 )
8731 })()
8732 .is_ok()
8733 {
8734 fallback_child = Some(candidate);
8735 break;
8736 }
8737 }
8738 if !cursor2.goto_next_sibling() {
8739 break;
8740 }
8741 }
8742 }
8743 }
8744 fallback_child.ok_or_else(|| {
8745 ::treesitter_types::ParseError::missing_field("children", node)
8746 })?
8747 };
8748 <ReferenceDeclaratorChildren as ::treesitter_types::FromNode>::from_node(
8749 child, src,
8750 )?
8751 },
8752 })
8753 }
8754}
8755impl ::treesitter_types::Spanned for ReferenceDeclarator<'_> {
8756 fn span(&self) -> ::treesitter_types::Span {
8757 self.span
8758 }
8759}
8760#[derive(Debug, Clone)]
8761pub struct RequirementSeq<'tree> {
8762 pub span: ::treesitter_types::Span,
8763 pub children: ::std::vec::Vec<RequirementSeqChildren<'tree>>,
8764}
8765impl<'tree> ::treesitter_types::FromNode<'tree> for RequirementSeq<'tree> {
8766 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8767 fn from_node(
8768 node: ::tree_sitter::Node<'tree>,
8769 src: &'tree [u8],
8770 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8771 debug_assert_eq!(node.kind(), "requirement_seq");
8772 Ok(Self {
8773 span: ::treesitter_types::Span::from(node),
8774 children: {
8775 #[allow(clippy::suspicious_else_formatting)]
8776 let non_field_children = {
8777 let mut cursor = node.walk();
8778 let mut result = ::std::vec::Vec::new();
8779 if cursor.goto_first_child() {
8780 loop {
8781 if cursor.field_name().is_none()
8782 && cursor.node().is_named()
8783 && !cursor.node().is_extra()
8784 {
8785 result.push(cursor.node());
8786 }
8787 if !cursor.goto_next_sibling() {
8788 break;
8789 }
8790 }
8791 }
8792 result
8793 };
8794 let mut items = ::std::vec::Vec::new();
8795 for child in non_field_children {
8796 items.push(
8797 <RequirementSeqChildren as ::treesitter_types::FromNode>::from_node(
8798 child, src,
8799 )?,
8800 );
8801 }
8802 items
8803 },
8804 })
8805 }
8806}
8807impl ::treesitter_types::Spanned for RequirementSeq<'_> {
8808 fn span(&self) -> ::treesitter_types::Span {
8809 self.span
8810 }
8811}
8812#[derive(Debug, Clone)]
8813pub struct RequiresClause<'tree> {
8814 pub span: ::treesitter_types::Span,
8815 pub constraint: ::std::vec::Vec<RequiresClauseConstraint<'tree>>,
8816}
8817impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresClause<'tree> {
8818 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8819 fn from_node(
8820 node: ::tree_sitter::Node<'tree>,
8821 src: &'tree [u8],
8822 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8823 debug_assert_eq!(node.kind(), "requires_clause");
8824 Ok(Self {
8825 span: ::treesitter_types::Span::from(node),
8826 constraint: {
8827 let mut cursor = node.walk();
8828 let mut items = ::std::vec::Vec::new();
8829 for child in node.children_by_field_name("constraint", &mut cursor) {
8830 items.push(
8831 <RequiresClauseConstraint as ::treesitter_types::FromNode>::from_node(
8832 child, src,
8833 )?,
8834 );
8835 }
8836 items
8837 },
8838 })
8839 }
8840}
8841impl ::treesitter_types::Spanned for RequiresClause<'_> {
8842 fn span(&self) -> ::treesitter_types::Span {
8843 self.span
8844 }
8845}
8846#[derive(Debug, Clone)]
8847pub struct RequiresExpression<'tree> {
8848 pub span: ::treesitter_types::Span,
8849 pub parameters: ::core::option::Option<ParameterList<'tree>>,
8850 pub requirements: RequirementSeq<'tree>,
8851}
8852impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresExpression<'tree> {
8853 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8854 fn from_node(
8855 node: ::tree_sitter::Node<'tree>,
8856 src: &'tree [u8],
8857 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8858 debug_assert_eq!(node.kind(), "requires_expression");
8859 Ok(Self {
8860 span: ::treesitter_types::Span::from(node),
8861 parameters: match node.child_by_field_name("parameters") {
8862 Some(child) => Some(<ParameterList as ::treesitter_types::FromNode>::from_node(
8863 child, src,
8864 )?),
8865 None => None,
8866 },
8867 requirements: {
8868 let child = node.child_by_field_name("requirements").ok_or_else(|| {
8869 ::treesitter_types::ParseError::missing_field("requirements", node)
8870 })?;
8871 <RequirementSeq as ::treesitter_types::FromNode>::from_node(child, src)?
8872 },
8873 })
8874 }
8875}
8876impl ::treesitter_types::Spanned for RequiresExpression<'_> {
8877 fn span(&self) -> ::treesitter_types::Span {
8878 self.span
8879 }
8880}
8881#[derive(Debug, Clone)]
8882pub struct ReturnStatement<'tree> {
8883 pub span: ::treesitter_types::Span,
8884 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
8885}
8886impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
8887 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8888 fn from_node(
8889 node: ::tree_sitter::Node<'tree>,
8890 src: &'tree [u8],
8891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8892 debug_assert_eq!(node.kind(), "return_statement");
8893 Ok(Self {
8894 span: ::treesitter_types::Span::from(node),
8895 children: {
8896 #[allow(clippy::suspicious_else_formatting)]
8897 let non_field_children = {
8898 let mut cursor = node.walk();
8899 let mut result = ::std::vec::Vec::new();
8900 if cursor.goto_first_child() {
8901 loop {
8902 if cursor.field_name().is_none()
8903 && cursor.node().is_named()
8904 && !cursor.node().is_extra()
8905 {
8906 result.push(cursor.node());
8907 }
8908 if !cursor.goto_next_sibling() {
8909 break;
8910 }
8911 }
8912 }
8913 result
8914 };
8915 match non_field_children.first() {
8916 Some(&child) => Some(
8917 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
8918 child, src,
8919 )?,
8920 ),
8921 None => None,
8922 }
8923 },
8924 })
8925 }
8926}
8927impl ::treesitter_types::Spanned for ReturnStatement<'_> {
8928 fn span(&self) -> ::treesitter_types::Span {
8929 self.span
8930 }
8931}
8932#[derive(Debug, Clone)]
8933pub struct SehExceptClause<'tree> {
8934 pub span: ::treesitter_types::Span,
8935 pub body: CompoundStatement<'tree>,
8936 pub filter: ParenthesizedExpression<'tree>,
8937}
8938impl<'tree> ::treesitter_types::FromNode<'tree> for SehExceptClause<'tree> {
8939 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8940 fn from_node(
8941 node: ::tree_sitter::Node<'tree>,
8942 src: &'tree [u8],
8943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8944 debug_assert_eq!(node.kind(), "seh_except_clause");
8945 Ok(Self {
8946 span: ::treesitter_types::Span::from(node),
8947 body: {
8948 let child = node
8949 .child_by_field_name("body")
8950 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8951 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
8952 },
8953 filter: {
8954 let child = node
8955 .child_by_field_name("filter")
8956 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("filter", node))?;
8957 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
8958 },
8959 })
8960 }
8961}
8962impl ::treesitter_types::Spanned for SehExceptClause<'_> {
8963 fn span(&self) -> ::treesitter_types::Span {
8964 self.span
8965 }
8966}
8967#[derive(Debug, Clone)]
8968pub struct SehFinallyClause<'tree> {
8969 pub span: ::treesitter_types::Span,
8970 pub body: CompoundStatement<'tree>,
8971}
8972impl<'tree> ::treesitter_types::FromNode<'tree> for SehFinallyClause<'tree> {
8973 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8974 fn from_node(
8975 node: ::tree_sitter::Node<'tree>,
8976 src: &'tree [u8],
8977 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8978 debug_assert_eq!(node.kind(), "seh_finally_clause");
8979 Ok(Self {
8980 span: ::treesitter_types::Span::from(node),
8981 body: {
8982 let child = node
8983 .child_by_field_name("body")
8984 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8985 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
8986 },
8987 })
8988 }
8989}
8990impl ::treesitter_types::Spanned for SehFinallyClause<'_> {
8991 fn span(&self) -> ::treesitter_types::Span {
8992 self.span
8993 }
8994}
8995#[derive(Debug, Clone)]
8996pub struct SehLeaveStatement<'tree> {
8997 pub span: ::treesitter_types::Span,
8998 text: &'tree str,
8999}
9000impl<'tree> ::treesitter_types::FromNode<'tree> for SehLeaveStatement<'tree> {
9001 fn from_node(
9002 node: ::tree_sitter::Node<'tree>,
9003 src: &'tree [u8],
9004 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9005 debug_assert_eq!(node.kind(), "seh_leave_statement");
9006 Ok(Self {
9007 span: ::treesitter_types::Span::from(node),
9008 text: node.utf8_text(src)?,
9009 })
9010 }
9011}
9012impl<'tree> ::treesitter_types::LeafNode<'tree> for SehLeaveStatement<'tree> {
9013 fn text(&self) -> &'tree str {
9014 self.text
9015 }
9016}
9017impl ::treesitter_types::Spanned for SehLeaveStatement<'_> {
9018 fn span(&self) -> ::treesitter_types::Span {
9019 self.span
9020 }
9021}
9022#[derive(Debug, Clone)]
9023pub struct SehTryStatement<'tree> {
9024 pub span: ::treesitter_types::Span,
9025 pub body: CompoundStatement<'tree>,
9026 pub children: SehTryStatementChildren<'tree>,
9027}
9028impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatement<'tree> {
9029 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9030 fn from_node(
9031 node: ::tree_sitter::Node<'tree>,
9032 src: &'tree [u8],
9033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9034 debug_assert_eq!(node.kind(), "seh_try_statement");
9035 Ok(Self {
9036 span: ::treesitter_types::Span::from(node),
9037 body: {
9038 let child = node
9039 .child_by_field_name("body")
9040 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9041 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
9042 },
9043 children: {
9044 #[allow(clippy::suspicious_else_formatting)]
9045 let non_field_children = {
9046 let mut cursor = node.walk();
9047 let mut result = ::std::vec::Vec::new();
9048 if cursor.goto_first_child() {
9049 loop {
9050 if cursor.field_name().is_none()
9051 && cursor.node().is_named()
9052 && !cursor.node().is_extra()
9053 {
9054 result.push(cursor.node());
9055 }
9056 if !cursor.goto_next_sibling() {
9057 break;
9058 }
9059 }
9060 }
9061 result
9062 };
9063 let child = if let Some(&c) = non_field_children.first() {
9064 c
9065 } else {
9066 let mut fallback_cursor = node.walk();
9067 let mut fallback_child = None;
9068 if fallback_cursor.goto_first_child() {
9069 loop {
9070 if fallback_cursor.field_name().is_none()
9071 && !fallback_cursor.node().is_extra()
9072 {
9073 let candidate = fallback_cursor.node();
9074 #[allow(clippy::needless_question_mark)]
9075 if (|| -> ::core::result::Result<
9076 _,
9077 ::treesitter_types::ParseError,
9078 > {
9079 let child = candidate;
9080 Ok(
9081 <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
9082 child,
9083 src,
9084 )?,
9085 )
9086 })()
9087 .is_ok()
9088 {
9089 fallback_child = Some(candidate);
9090 break;
9091 }
9092 }
9093 if !fallback_cursor.goto_next_sibling() {
9094 break;
9095 }
9096 }
9097 }
9098 if fallback_child.is_none() {
9099 let mut cursor2 = node.walk();
9100 if cursor2.goto_first_child() {
9101 loop {
9102 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9103 let candidate = cursor2.node();
9104 #[allow(clippy::needless_question_mark)]
9105 if (|| -> ::core::result::Result<
9106 _,
9107 ::treesitter_types::ParseError,
9108 > {
9109 let child = candidate;
9110 Ok(
9111 <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(
9112 child,
9113 src,
9114 )?,
9115 )
9116 })()
9117 .is_ok()
9118 {
9119 fallback_child = Some(candidate);
9120 break;
9121 }
9122 }
9123 if !cursor2.goto_next_sibling() {
9124 break;
9125 }
9126 }
9127 }
9128 }
9129 fallback_child.ok_or_else(|| {
9130 ::treesitter_types::ParseError::missing_field("children", node)
9131 })?
9132 };
9133 <SehTryStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
9134 },
9135 })
9136 }
9137}
9138impl ::treesitter_types::Spanned for SehTryStatement<'_> {
9139 fn span(&self) -> ::treesitter_types::Span {
9140 self.span
9141 }
9142}
9143#[derive(Debug, Clone)]
9144pub struct SimpleRequirement<'tree> {
9145 pub span: ::treesitter_types::Span,
9146 pub children: ::core::option::Option<SimpleRequirementChildren<'tree>>,
9147}
9148impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleRequirement<'tree> {
9149 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9150 fn from_node(
9151 node: ::tree_sitter::Node<'tree>,
9152 src: &'tree [u8],
9153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9154 debug_assert_eq!(node.kind(), "simple_requirement");
9155 Ok(Self {
9156 span: ::treesitter_types::Span::from(node),
9157 children: {
9158 #[allow(clippy::suspicious_else_formatting)]
9159 let non_field_children = {
9160 let mut cursor = node.walk();
9161 let mut result = ::std::vec::Vec::new();
9162 if cursor.goto_first_child() {
9163 loop {
9164 if cursor.field_name().is_none()
9165 && cursor.node().is_named()
9166 && !cursor.node().is_extra()
9167 {
9168 result.push(cursor.node());
9169 }
9170 if !cursor.goto_next_sibling() {
9171 break;
9172 }
9173 }
9174 }
9175 result
9176 };
9177 match non_field_children.first() {
9178 Some(&child) => Some(
9179 <SimpleRequirementChildren as ::treesitter_types::FromNode>::from_node(
9180 child, src,
9181 )?,
9182 ),
9183 None => None,
9184 }
9185 },
9186 })
9187 }
9188}
9189impl ::treesitter_types::Spanned for SimpleRequirement<'_> {
9190 fn span(&self) -> ::treesitter_types::Span {
9191 self.span
9192 }
9193}
9194#[derive(Debug, Clone)]
9195pub struct SizedTypeSpecifier<'tree> {
9196 pub span: ::treesitter_types::Span,
9197 pub r#type: ::core::option::Option<SizedTypeSpecifierType<'tree>>,
9198 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
9199}
9200impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifier<'tree> {
9201 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9202 fn from_node(
9203 node: ::tree_sitter::Node<'tree>,
9204 src: &'tree [u8],
9205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9206 debug_assert_eq!(node.kind(), "sized_type_specifier");
9207 Ok(Self {
9208 span: ::treesitter_types::Span::from(node),
9209 r#type: match node.child_by_field_name("type") {
9210 Some(child) => Some(
9211 <SizedTypeSpecifierType as ::treesitter_types::FromNode>::from_node(
9212 child, src,
9213 )?,
9214 ),
9215 None => None,
9216 },
9217 children: {
9218 #[allow(clippy::suspicious_else_formatting)]
9219 let non_field_children = {
9220 let mut cursor = node.walk();
9221 let mut result = ::std::vec::Vec::new();
9222 if cursor.goto_first_child() {
9223 loop {
9224 if cursor.field_name().is_none()
9225 && cursor.node().is_named()
9226 && !cursor.node().is_extra()
9227 {
9228 result.push(cursor.node());
9229 }
9230 if !cursor.goto_next_sibling() {
9231 break;
9232 }
9233 }
9234 }
9235 result
9236 };
9237 let mut items = ::std::vec::Vec::new();
9238 for child in non_field_children {
9239 items.push(<TypeQualifier as ::treesitter_types::FromNode>::from_node(
9240 child, src,
9241 )?);
9242 }
9243 items
9244 },
9245 })
9246 }
9247}
9248impl ::treesitter_types::Spanned for SizedTypeSpecifier<'_> {
9249 fn span(&self) -> ::treesitter_types::Span {
9250 self.span
9251 }
9252}
9253#[derive(Debug, Clone)]
9254pub struct SizeofExpression<'tree> {
9255 pub span: ::treesitter_types::Span,
9256 pub r#type: ::core::option::Option<TypeDescriptor<'tree>>,
9257 pub value: ::core::option::Option<Expression<'tree>>,
9258}
9259impl<'tree> ::treesitter_types::FromNode<'tree> for SizeofExpression<'tree> {
9260 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9261 fn from_node(
9262 node: ::tree_sitter::Node<'tree>,
9263 src: &'tree [u8],
9264 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9265 debug_assert_eq!(node.kind(), "sizeof_expression");
9266 Ok(Self {
9267 span: ::treesitter_types::Span::from(node),
9268 r#type: match node.child_by_field_name("type") {
9269 Some(child) => Some(<TypeDescriptor as ::treesitter_types::FromNode>::from_node(
9270 child, src,
9271 )?),
9272 None => None,
9273 },
9274 value: match node.child_by_field_name("value") {
9275 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
9276 child, src,
9277 )?),
9278 None => None,
9279 },
9280 })
9281 }
9282}
9283impl ::treesitter_types::Spanned for SizeofExpression<'_> {
9284 fn span(&self) -> ::treesitter_types::Span {
9285 self.span
9286 }
9287}
9288#[derive(Debug, Clone)]
9289pub struct StaticAssertDeclaration<'tree> {
9290 pub span: ::treesitter_types::Span,
9291 pub condition: Expression<'tree>,
9292 pub message: ::core::option::Option<StaticAssertDeclarationMessage<'tree>>,
9293}
9294impl<'tree> ::treesitter_types::FromNode<'tree> for StaticAssertDeclaration<'tree> {
9295 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9296 fn from_node(
9297 node: ::tree_sitter::Node<'tree>,
9298 src: &'tree [u8],
9299 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9300 debug_assert_eq!(node.kind(), "static_assert_declaration");
9301 Ok(Self {
9302 span: ::treesitter_types::Span::from(node),
9303 condition: {
9304 let child = node.child_by_field_name("condition").ok_or_else(|| {
9305 ::treesitter_types::ParseError::missing_field("condition", node)
9306 })?;
9307 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9308 },
9309 message: match node.child_by_field_name("message") {
9310 Some(child) => Some(
9311 <StaticAssertDeclarationMessage as ::treesitter_types::FromNode>::from_node(
9312 child, src,
9313 )?,
9314 ),
9315 None => None,
9316 },
9317 })
9318 }
9319}
9320impl ::treesitter_types::Spanned for StaticAssertDeclaration<'_> {
9321 fn span(&self) -> ::treesitter_types::Span {
9322 self.span
9323 }
9324}
9325#[derive(Debug, Clone)]
9326pub struct StorageClassSpecifier<'tree> {
9327 pub span: ::treesitter_types::Span,
9328 text: &'tree str,
9329}
9330impl<'tree> ::treesitter_types::FromNode<'tree> for StorageClassSpecifier<'tree> {
9331 fn from_node(
9332 node: ::tree_sitter::Node<'tree>,
9333 src: &'tree [u8],
9334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9335 debug_assert_eq!(node.kind(), "storage_class_specifier");
9336 Ok(Self {
9337 span: ::treesitter_types::Span::from(node),
9338 text: node.utf8_text(src)?,
9339 })
9340 }
9341}
9342impl<'tree> ::treesitter_types::LeafNode<'tree> for StorageClassSpecifier<'tree> {
9343 fn text(&self) -> &'tree str {
9344 self.text
9345 }
9346}
9347impl ::treesitter_types::Spanned for StorageClassSpecifier<'_> {
9348 fn span(&self) -> ::treesitter_types::Span {
9349 self.span
9350 }
9351}
9352#[derive(Debug, Clone)]
9353pub struct StringLiteral<'tree> {
9354 pub span: ::treesitter_types::Span,
9355 pub children: ::std::vec::Vec<StringLiteralChildren<'tree>>,
9356}
9357impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteral<'tree> {
9358 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9359 fn from_node(
9360 node: ::tree_sitter::Node<'tree>,
9361 src: &'tree [u8],
9362 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9363 debug_assert_eq!(node.kind(), "string_literal");
9364 Ok(Self {
9365 span: ::treesitter_types::Span::from(node),
9366 children: {
9367 #[allow(clippy::suspicious_else_formatting)]
9368 let non_field_children = {
9369 let mut cursor = node.walk();
9370 let mut result = ::std::vec::Vec::new();
9371 if cursor.goto_first_child() {
9372 loop {
9373 if cursor.field_name().is_none()
9374 && cursor.node().is_named()
9375 && !cursor.node().is_extra()
9376 {
9377 result.push(cursor.node());
9378 }
9379 if !cursor.goto_next_sibling() {
9380 break;
9381 }
9382 }
9383 }
9384 result
9385 };
9386 let mut items = ::std::vec::Vec::new();
9387 for child in non_field_children {
9388 items.push(
9389 <StringLiteralChildren as ::treesitter_types::FromNode>::from_node(
9390 child, src,
9391 )?,
9392 );
9393 }
9394 items
9395 },
9396 })
9397 }
9398}
9399impl ::treesitter_types::Spanned for StringLiteral<'_> {
9400 fn span(&self) -> ::treesitter_types::Span {
9401 self.span
9402 }
9403}
9404#[derive(Debug, Clone)]
9405pub struct StructSpecifier<'tree> {
9406 pub span: ::treesitter_types::Span,
9407 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
9408 pub name: ::core::option::Option<StructSpecifierName<'tree>>,
9409 pub children: ::std::vec::Vec<StructSpecifierChildren<'tree>>,
9410}
9411impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifier<'tree> {
9412 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9413 fn from_node(
9414 node: ::tree_sitter::Node<'tree>,
9415 src: &'tree [u8],
9416 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9417 debug_assert_eq!(node.kind(), "struct_specifier");
9418 Ok(Self {
9419 span: ::treesitter_types::Span::from(node),
9420 body: match node.child_by_field_name("body") {
9421 Some(child) => Some(
9422 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?,
9423 ),
9424 None => None,
9425 },
9426 name: match node.child_by_field_name("name") {
9427 Some(child) => Some(
9428 <StructSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?,
9429 ),
9430 None => None,
9431 },
9432 children: {
9433 #[allow(clippy::suspicious_else_formatting)]
9434 let non_field_children = {
9435 let mut cursor = node.walk();
9436 let mut result = ::std::vec::Vec::new();
9437 if cursor.goto_first_child() {
9438 loop {
9439 if cursor.field_name().is_none()
9440 && cursor.node().is_named()
9441 && !cursor.node().is_extra()
9442 {
9443 result.push(cursor.node());
9444 }
9445 if !cursor.goto_next_sibling() {
9446 break;
9447 }
9448 }
9449 }
9450 result
9451 };
9452 let mut items = ::std::vec::Vec::new();
9453 for child in non_field_children {
9454 items.push(
9455 <StructSpecifierChildren as ::treesitter_types::FromNode>::from_node(
9456 child, src,
9457 )?,
9458 );
9459 }
9460 items
9461 },
9462 })
9463 }
9464}
9465impl ::treesitter_types::Spanned for StructSpecifier<'_> {
9466 fn span(&self) -> ::treesitter_types::Span {
9467 self.span
9468 }
9469}
9470#[derive(Debug, Clone)]
9471pub struct StructuredBindingDeclarator<'tree> {
9472 pub span: ::treesitter_types::Span,
9473 pub children: ::std::vec::Vec<Identifier<'tree>>,
9474}
9475impl<'tree> ::treesitter_types::FromNode<'tree> for StructuredBindingDeclarator<'tree> {
9476 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9477 fn from_node(
9478 node: ::tree_sitter::Node<'tree>,
9479 src: &'tree [u8],
9480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9481 debug_assert_eq!(node.kind(), "structured_binding_declarator");
9482 Ok(Self {
9483 span: ::treesitter_types::Span::from(node),
9484 children: {
9485 #[allow(clippy::suspicious_else_formatting)]
9486 let non_field_children = {
9487 let mut cursor = node.walk();
9488 let mut result = ::std::vec::Vec::new();
9489 if cursor.goto_first_child() {
9490 loop {
9491 if cursor.field_name().is_none()
9492 && cursor.node().is_named()
9493 && !cursor.node().is_extra()
9494 {
9495 result.push(cursor.node());
9496 }
9497 if !cursor.goto_next_sibling() {
9498 break;
9499 }
9500 }
9501 }
9502 result
9503 };
9504 let mut items = ::std::vec::Vec::new();
9505 for child in non_field_children {
9506 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
9507 child, src,
9508 )?);
9509 }
9510 items
9511 },
9512 })
9513 }
9514}
9515impl ::treesitter_types::Spanned for StructuredBindingDeclarator<'_> {
9516 fn span(&self) -> ::treesitter_types::Span {
9517 self.span
9518 }
9519}
9520#[derive(Debug, Clone)]
9521pub struct SubscriptArgumentList<'tree> {
9522 pub span: ::treesitter_types::Span,
9523 pub children: ::std::vec::Vec<SubscriptArgumentListChildren<'tree>>,
9524}
9525impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptArgumentList<'tree> {
9526 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9527 fn from_node(
9528 node: ::tree_sitter::Node<'tree>,
9529 src: &'tree [u8],
9530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9531 debug_assert_eq!(node.kind(), "subscript_argument_list");
9532 Ok(Self {
9533 span: ::treesitter_types::Span::from(node),
9534 children: {
9535 #[allow(clippy::suspicious_else_formatting)]
9536 let non_field_children = {
9537 let mut cursor = node.walk();
9538 let mut result = ::std::vec::Vec::new();
9539 if cursor.goto_first_child() {
9540 loop {
9541 if cursor.field_name().is_none()
9542 && cursor.node().is_named()
9543 && !cursor.node().is_extra()
9544 {
9545 result.push(cursor.node());
9546 }
9547 if !cursor.goto_next_sibling() {
9548 break;
9549 }
9550 }
9551 }
9552 result
9553 };
9554 let mut items = ::std::vec::Vec::new();
9555 for child in non_field_children {
9556 items.push(
9557 <SubscriptArgumentListChildren as ::treesitter_types::FromNode>::from_node(
9558 child, src,
9559 )?,
9560 );
9561 }
9562 items
9563 },
9564 })
9565 }
9566}
9567impl ::treesitter_types::Spanned for SubscriptArgumentList<'_> {
9568 fn span(&self) -> ::treesitter_types::Span {
9569 self.span
9570 }
9571}
9572#[derive(Debug, Clone)]
9573pub struct SubscriptDesignator<'tree> {
9574 pub span: ::treesitter_types::Span,
9575 pub children: Expression<'tree>,
9576}
9577impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptDesignator<'tree> {
9578 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9579 fn from_node(
9580 node: ::tree_sitter::Node<'tree>,
9581 src: &'tree [u8],
9582 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9583 debug_assert_eq!(node.kind(), "subscript_designator");
9584 Ok(Self {
9585 span: ::treesitter_types::Span::from(node),
9586 children: {
9587 #[allow(clippy::suspicious_else_formatting)]
9588 let non_field_children = {
9589 let mut cursor = node.walk();
9590 let mut result = ::std::vec::Vec::new();
9591 if cursor.goto_first_child() {
9592 loop {
9593 if cursor.field_name().is_none()
9594 && cursor.node().is_named()
9595 && !cursor.node().is_extra()
9596 {
9597 result.push(cursor.node());
9598 }
9599 if !cursor.goto_next_sibling() {
9600 break;
9601 }
9602 }
9603 }
9604 result
9605 };
9606 let child = if let Some(&c) = non_field_children.first() {
9607 c
9608 } else {
9609 let mut fallback_cursor = node.walk();
9610 let mut fallback_child = None;
9611 if fallback_cursor.goto_first_child() {
9612 loop {
9613 if fallback_cursor.field_name().is_none()
9614 && !fallback_cursor.node().is_extra()
9615 {
9616 let candidate = fallback_cursor.node();
9617 #[allow(clippy::needless_question_mark)]
9618 if (|| -> ::core::result::Result<
9619 _,
9620 ::treesitter_types::ParseError,
9621 > {
9622 let child = candidate;
9623 Ok(
9624 <Expression as ::treesitter_types::FromNode>::from_node(
9625 child,
9626 src,
9627 )?,
9628 )
9629 })()
9630 .is_ok()
9631 {
9632 fallback_child = Some(candidate);
9633 break;
9634 }
9635 }
9636 if !fallback_cursor.goto_next_sibling() {
9637 break;
9638 }
9639 }
9640 }
9641 if fallback_child.is_none() {
9642 let mut cursor2 = node.walk();
9643 if cursor2.goto_first_child() {
9644 loop {
9645 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9646 let candidate = cursor2.node();
9647 #[allow(clippy::needless_question_mark)]
9648 if (|| -> ::core::result::Result<
9649 _,
9650 ::treesitter_types::ParseError,
9651 > {
9652 let child = candidate;
9653 Ok(
9654 <Expression as ::treesitter_types::FromNode>::from_node(
9655 child,
9656 src,
9657 )?,
9658 )
9659 })()
9660 .is_ok()
9661 {
9662 fallback_child = Some(candidate);
9663 break;
9664 }
9665 }
9666 if !cursor2.goto_next_sibling() {
9667 break;
9668 }
9669 }
9670 }
9671 }
9672 fallback_child.ok_or_else(|| {
9673 ::treesitter_types::ParseError::missing_field("children", node)
9674 })?
9675 };
9676 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9677 },
9678 })
9679 }
9680}
9681impl ::treesitter_types::Spanned for SubscriptDesignator<'_> {
9682 fn span(&self) -> ::treesitter_types::Span {
9683 self.span
9684 }
9685}
9686#[derive(Debug, Clone)]
9687pub struct SubscriptExpression<'tree> {
9688 pub span: ::treesitter_types::Span,
9689 pub argument: Expression<'tree>,
9690 pub indices: SubscriptArgumentList<'tree>,
9691}
9692impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
9693 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9694 fn from_node(
9695 node: ::tree_sitter::Node<'tree>,
9696 src: &'tree [u8],
9697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9698 debug_assert_eq!(node.kind(), "subscript_expression");
9699 Ok(Self {
9700 span: ::treesitter_types::Span::from(node),
9701 argument: {
9702 let child = node.child_by_field_name("argument").ok_or_else(|| {
9703 ::treesitter_types::ParseError::missing_field("argument", node)
9704 })?;
9705 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9706 },
9707 indices: {
9708 let child = node.child_by_field_name("indices").ok_or_else(|| {
9709 ::treesitter_types::ParseError::missing_field("indices", node)
9710 })?;
9711 <SubscriptArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
9712 },
9713 })
9714 }
9715}
9716impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
9717 fn span(&self) -> ::treesitter_types::Span {
9718 self.span
9719 }
9720}
9721#[derive(Debug, Clone)]
9722pub struct SubscriptRangeDesignator<'tree> {
9723 pub span: ::treesitter_types::Span,
9724 pub end: Expression<'tree>,
9725 pub start: Expression<'tree>,
9726}
9727impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptRangeDesignator<'tree> {
9728 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9729 fn from_node(
9730 node: ::tree_sitter::Node<'tree>,
9731 src: &'tree [u8],
9732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9733 debug_assert_eq!(node.kind(), "subscript_range_designator");
9734 Ok(Self {
9735 span: ::treesitter_types::Span::from(node),
9736 end: {
9737 let child = node
9738 .child_by_field_name("end")
9739 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("end", node))?;
9740 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9741 },
9742 start: {
9743 let child = node
9744 .child_by_field_name("start")
9745 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("start", node))?;
9746 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9747 },
9748 })
9749 }
9750}
9751impl ::treesitter_types::Spanned for SubscriptRangeDesignator<'_> {
9752 fn span(&self) -> ::treesitter_types::Span {
9753 self.span
9754 }
9755}
9756#[derive(Debug, Clone)]
9757pub struct SwitchStatement<'tree> {
9758 pub span: ::treesitter_types::Span,
9759 pub body: CompoundStatement<'tree>,
9760 pub condition: ConditionClause<'tree>,
9761}
9762impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
9763 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9764 fn from_node(
9765 node: ::tree_sitter::Node<'tree>,
9766 src: &'tree [u8],
9767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9768 debug_assert_eq!(node.kind(), "switch_statement");
9769 Ok(Self {
9770 span: ::treesitter_types::Span::from(node),
9771 body: {
9772 let child = node
9773 .child_by_field_name("body")
9774 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9775 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
9776 },
9777 condition: {
9778 let child = node.child_by_field_name("condition").ok_or_else(|| {
9779 ::treesitter_types::ParseError::missing_field("condition", node)
9780 })?;
9781 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)?
9782 },
9783 })
9784 }
9785}
9786impl ::treesitter_types::Spanned for SwitchStatement<'_> {
9787 fn span(&self) -> ::treesitter_types::Span {
9788 self.span
9789 }
9790}
9791#[derive(Debug, Clone)]
9792pub struct TemplateArgumentList<'tree> {
9793 pub span: ::treesitter_types::Span,
9794 pub children: ::std::vec::Vec<TemplateArgumentListChildren<'tree>>,
9795}
9796impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateArgumentList<'tree> {
9797 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9798 fn from_node(
9799 node: ::tree_sitter::Node<'tree>,
9800 src: &'tree [u8],
9801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9802 debug_assert_eq!(node.kind(), "template_argument_list");
9803 Ok(Self {
9804 span: ::treesitter_types::Span::from(node),
9805 children: {
9806 #[allow(clippy::suspicious_else_formatting)]
9807 let non_field_children = {
9808 let mut cursor = node.walk();
9809 let mut result = ::std::vec::Vec::new();
9810 if cursor.goto_first_child() {
9811 loop {
9812 if cursor.field_name().is_none()
9813 && cursor.node().is_named()
9814 && !cursor.node().is_extra()
9815 {
9816 result.push(cursor.node());
9817 }
9818 if !cursor.goto_next_sibling() {
9819 break;
9820 }
9821 }
9822 }
9823 result
9824 };
9825 let mut items = ::std::vec::Vec::new();
9826 for child in non_field_children {
9827 items.push(
9828 <TemplateArgumentListChildren as ::treesitter_types::FromNode>::from_node(
9829 child, src,
9830 )?,
9831 );
9832 }
9833 items
9834 },
9835 })
9836 }
9837}
9838impl ::treesitter_types::Spanned for TemplateArgumentList<'_> {
9839 fn span(&self) -> ::treesitter_types::Span {
9840 self.span
9841 }
9842}
9843#[derive(Debug, Clone)]
9844pub struct TemplateDeclaration<'tree> {
9845 pub span: ::treesitter_types::Span,
9846 pub parameters: TemplateParameterList<'tree>,
9847 pub children: ::std::vec::Vec<TemplateDeclarationChildren<'tree>>,
9848}
9849impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateDeclaration<'tree> {
9850 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9851 fn from_node(
9852 node: ::tree_sitter::Node<'tree>,
9853 src: &'tree [u8],
9854 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9855 debug_assert_eq!(node.kind(), "template_declaration");
9856 Ok(Self {
9857 span: ::treesitter_types::Span::from(node),
9858 parameters: {
9859 let child = node.child_by_field_name("parameters").ok_or_else(|| {
9860 ::treesitter_types::ParseError::missing_field("parameters", node)
9861 })?;
9862 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
9863 },
9864 children: {
9865 #[allow(clippy::suspicious_else_formatting)]
9866 let non_field_children = {
9867 let mut cursor = node.walk();
9868 let mut result = ::std::vec::Vec::new();
9869 if cursor.goto_first_child() {
9870 loop {
9871 if cursor.field_name().is_none()
9872 && cursor.node().is_named()
9873 && !cursor.node().is_extra()
9874 {
9875 result.push(cursor.node());
9876 }
9877 if !cursor.goto_next_sibling() {
9878 break;
9879 }
9880 }
9881 }
9882 result
9883 };
9884 let mut items = ::std::vec::Vec::new();
9885 for child in non_field_children {
9886 items.push(
9887 <TemplateDeclarationChildren as ::treesitter_types::FromNode>::from_node(
9888 child, src,
9889 )?,
9890 );
9891 }
9892 items
9893 },
9894 })
9895 }
9896}
9897impl ::treesitter_types::Spanned for TemplateDeclaration<'_> {
9898 fn span(&self) -> ::treesitter_types::Span {
9899 self.span
9900 }
9901}
9902#[derive(Debug, Clone)]
9903pub struct TemplateFunction<'tree> {
9904 pub span: ::treesitter_types::Span,
9905 pub arguments: TemplateArgumentList<'tree>,
9906 pub name: Identifier<'tree>,
9907}
9908impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateFunction<'tree> {
9909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9910 fn from_node(
9911 node: ::tree_sitter::Node<'tree>,
9912 src: &'tree [u8],
9913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9914 debug_assert_eq!(node.kind(), "template_function");
9915 Ok(Self {
9916 span: ::treesitter_types::Span::from(node),
9917 arguments: {
9918 let child = node.child_by_field_name("arguments").ok_or_else(|| {
9919 ::treesitter_types::ParseError::missing_field("arguments", node)
9920 })?;
9921 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
9922 },
9923 name: {
9924 let child = node
9925 .child_by_field_name("name")
9926 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9927 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
9928 },
9929 })
9930 }
9931}
9932impl ::treesitter_types::Spanned for TemplateFunction<'_> {
9933 fn span(&self) -> ::treesitter_types::Span {
9934 self.span
9935 }
9936}
9937#[derive(Debug, Clone)]
9938pub struct TemplateInstantiation<'tree> {
9939 pub span: ::treesitter_types::Span,
9940 pub declarator: Declarator<'tree>,
9941 pub r#type: ::core::option::Option<TypeSpecifier<'tree>>,
9942 pub children: ::std::vec::Vec<TemplateInstantiationChildren<'tree>>,
9943}
9944impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateInstantiation<'tree> {
9945 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9946 fn from_node(
9947 node: ::tree_sitter::Node<'tree>,
9948 src: &'tree [u8],
9949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9950 debug_assert_eq!(node.kind(), "template_instantiation");
9951 Ok(Self {
9952 span: ::treesitter_types::Span::from(node),
9953 declarator: {
9954 let child = node.child_by_field_name("declarator").ok_or_else(|| {
9955 ::treesitter_types::ParseError::missing_field("declarator", node)
9956 })?;
9957 <Declarator as ::treesitter_types::FromNode>::from_node(child, src)?
9958 },
9959 r#type: match node.child_by_field_name("type") {
9960 Some(child) => Some(<TypeSpecifier as ::treesitter_types::FromNode>::from_node(
9961 child, src,
9962 )?),
9963 None => None,
9964 },
9965 children: {
9966 #[allow(clippy::suspicious_else_formatting)]
9967 let non_field_children = {
9968 let mut cursor = node.walk();
9969 let mut result = ::std::vec::Vec::new();
9970 if cursor.goto_first_child() {
9971 loop {
9972 if cursor.field_name().is_none()
9973 && cursor.node().is_named()
9974 && !cursor.node().is_extra()
9975 {
9976 result.push(cursor.node());
9977 }
9978 if !cursor.goto_next_sibling() {
9979 break;
9980 }
9981 }
9982 }
9983 result
9984 };
9985 let mut items = ::std::vec::Vec::new();
9986 for child in non_field_children {
9987 items.push(
9988 <TemplateInstantiationChildren as ::treesitter_types::FromNode>::from_node(
9989 child, src,
9990 )?,
9991 );
9992 }
9993 items
9994 },
9995 })
9996 }
9997}
9998impl ::treesitter_types::Spanned for TemplateInstantiation<'_> {
9999 fn span(&self) -> ::treesitter_types::Span {
10000 self.span
10001 }
10002}
10003#[derive(Debug, Clone)]
10004pub struct TemplateMethod<'tree> {
10005 pub span: ::treesitter_types::Span,
10006 pub arguments: TemplateArgumentList<'tree>,
10007 pub name: TemplateMethodName<'tree>,
10008}
10009impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateMethod<'tree> {
10010 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10011 fn from_node(
10012 node: ::tree_sitter::Node<'tree>,
10013 src: &'tree [u8],
10014 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10015 debug_assert_eq!(node.kind(), "template_method");
10016 Ok(Self {
10017 span: ::treesitter_types::Span::from(node),
10018 arguments: {
10019 let child = node.child_by_field_name("arguments").ok_or_else(|| {
10020 ::treesitter_types::ParseError::missing_field("arguments", node)
10021 })?;
10022 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
10023 },
10024 name: {
10025 let child = node
10026 .child_by_field_name("name")
10027 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10028 <TemplateMethodName as ::treesitter_types::FromNode>::from_node(child, src)?
10029 },
10030 })
10031 }
10032}
10033impl ::treesitter_types::Spanned for TemplateMethod<'_> {
10034 fn span(&self) -> ::treesitter_types::Span {
10035 self.span
10036 }
10037}
10038#[derive(Debug, Clone)]
10039pub struct TemplateParameterList<'tree> {
10040 pub span: ::treesitter_types::Span,
10041 pub children: ::std::vec::Vec<TemplateParameterListChildren<'tree>>,
10042}
10043impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateParameterList<'tree> {
10044 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10045 fn from_node(
10046 node: ::tree_sitter::Node<'tree>,
10047 src: &'tree [u8],
10048 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10049 debug_assert_eq!(node.kind(), "template_parameter_list");
10050 Ok(Self {
10051 span: ::treesitter_types::Span::from(node),
10052 children: {
10053 #[allow(clippy::suspicious_else_formatting)]
10054 let non_field_children = {
10055 let mut cursor = node.walk();
10056 let mut result = ::std::vec::Vec::new();
10057 if cursor.goto_first_child() {
10058 loop {
10059 if cursor.field_name().is_none()
10060 && cursor.node().is_named()
10061 && !cursor.node().is_extra()
10062 {
10063 result.push(cursor.node());
10064 }
10065 if !cursor.goto_next_sibling() {
10066 break;
10067 }
10068 }
10069 }
10070 result
10071 };
10072 let mut items = ::std::vec::Vec::new();
10073 for child in non_field_children {
10074 items.push(
10075 <TemplateParameterListChildren as ::treesitter_types::FromNode>::from_node(
10076 child, src,
10077 )?,
10078 );
10079 }
10080 items
10081 },
10082 })
10083 }
10084}
10085impl ::treesitter_types::Spanned for TemplateParameterList<'_> {
10086 fn span(&self) -> ::treesitter_types::Span {
10087 self.span
10088 }
10089}
10090#[derive(Debug, Clone)]
10091pub struct TemplateTemplateParameterDeclaration<'tree> {
10092 pub span: ::treesitter_types::Span,
10093 pub parameters: TemplateParameterList<'tree>,
10094 pub children: TemplateTemplateParameterDeclarationChildren<'tree>,
10095}
10096impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateTemplateParameterDeclaration<'tree> {
10097 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10098 fn from_node(
10099 node: ::tree_sitter::Node<'tree>,
10100 src: &'tree [u8],
10101 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10102 debug_assert_eq!(node.kind(), "template_template_parameter_declaration");
10103 Ok(Self {
10104 span: ::treesitter_types::Span::from(node),
10105 parameters: {
10106 let child = node.child_by_field_name("parameters").ok_or_else(|| {
10107 ::treesitter_types::ParseError::missing_field("parameters", node)
10108 })?;
10109 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(child, src)?
10110 },
10111 children: {
10112 #[allow(clippy::suspicious_else_formatting)]
10113 let non_field_children = {
10114 let mut cursor = node.walk();
10115 let mut result = ::std::vec::Vec::new();
10116 if cursor.goto_first_child() {
10117 loop {
10118 if cursor.field_name().is_none()
10119 && cursor.node().is_named()
10120 && !cursor.node().is_extra()
10121 {
10122 result.push(cursor.node());
10123 }
10124 if !cursor.goto_next_sibling() {
10125 break;
10126 }
10127 }
10128 }
10129 result
10130 };
10131 let child = if let Some(&c) = non_field_children.first() {
10132 c
10133 } else {
10134 let mut fallback_cursor = node.walk();
10135 let mut fallback_child = None;
10136 if fallback_cursor.goto_first_child() {
10137 loop {
10138 if fallback_cursor.field_name().is_none()
10139 && !fallback_cursor.node().is_extra()
10140 {
10141 let candidate = fallback_cursor.node();
10142 #[allow(clippy::needless_question_mark)]
10143 if (|| -> ::core::result::Result<
10144 _,
10145 ::treesitter_types::ParseError,
10146 > {
10147 let child = candidate;
10148 Ok(
10149 <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10150 child,
10151 src,
10152 )?,
10153 )
10154 })()
10155 .is_ok()
10156 {
10157 fallback_child = Some(candidate);
10158 break;
10159 }
10160 }
10161 if !fallback_cursor.goto_next_sibling() {
10162 break;
10163 }
10164 }
10165 }
10166 if fallback_child.is_none() {
10167 let mut cursor2 = node.walk();
10168 if cursor2.goto_first_child() {
10169 loop {
10170 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10171 let candidate = cursor2.node();
10172 #[allow(clippy::needless_question_mark)]
10173 if (|| -> ::core::result::Result<
10174 _,
10175 ::treesitter_types::ParseError,
10176 > {
10177 let child = candidate;
10178 Ok(
10179 <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10180 child,
10181 src,
10182 )?,
10183 )
10184 })()
10185 .is_ok()
10186 {
10187 fallback_child = Some(candidate);
10188 break;
10189 }
10190 }
10191 if !cursor2.goto_next_sibling() {
10192 break;
10193 }
10194 }
10195 }
10196 }
10197 fallback_child.ok_or_else(|| {
10198 ::treesitter_types::ParseError::missing_field("children", node)
10199 })?
10200 };
10201 <TemplateTemplateParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
10202 child,
10203 src,
10204 )?
10205 },
10206 })
10207 }
10208}
10209impl ::treesitter_types::Spanned for TemplateTemplateParameterDeclaration<'_> {
10210 fn span(&self) -> ::treesitter_types::Span {
10211 self.span
10212 }
10213}
10214#[derive(Debug, Clone)]
10215pub struct TemplateType<'tree> {
10216 pub span: ::treesitter_types::Span,
10217 pub arguments: TemplateArgumentList<'tree>,
10218 pub name: TypeIdentifier<'tree>,
10219}
10220impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateType<'tree> {
10221 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10222 fn from_node(
10223 node: ::tree_sitter::Node<'tree>,
10224 src: &'tree [u8],
10225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10226 debug_assert_eq!(node.kind(), "template_type");
10227 Ok(Self {
10228 span: ::treesitter_types::Span::from(node),
10229 arguments: {
10230 let child = node.child_by_field_name("arguments").ok_or_else(|| {
10231 ::treesitter_types::ParseError::missing_field("arguments", node)
10232 })?;
10233 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(child, src)?
10234 },
10235 name: {
10236 let child = node
10237 .child_by_field_name("name")
10238 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
10239 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
10240 },
10241 })
10242 }
10243}
10244impl ::treesitter_types::Spanned for TemplateType<'_> {
10245 fn span(&self) -> ::treesitter_types::Span {
10246 self.span
10247 }
10248}
10249#[derive(Debug, Clone)]
10250pub struct ThrowSpecifier<'tree> {
10251 pub span: ::treesitter_types::Span,
10252 pub children: ::std::vec::Vec<TypeDescriptor<'tree>>,
10253}
10254impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowSpecifier<'tree> {
10255 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10256 fn from_node(
10257 node: ::tree_sitter::Node<'tree>,
10258 src: &'tree [u8],
10259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10260 debug_assert_eq!(node.kind(), "throw_specifier");
10261 Ok(Self {
10262 span: ::treesitter_types::Span::from(node),
10263 children: {
10264 #[allow(clippy::suspicious_else_formatting)]
10265 let non_field_children = {
10266 let mut cursor = node.walk();
10267 let mut result = ::std::vec::Vec::new();
10268 if cursor.goto_first_child() {
10269 loop {
10270 if cursor.field_name().is_none()
10271 && cursor.node().is_named()
10272 && !cursor.node().is_extra()
10273 {
10274 result.push(cursor.node());
10275 }
10276 if !cursor.goto_next_sibling() {
10277 break;
10278 }
10279 }
10280 }
10281 result
10282 };
10283 let mut items = ::std::vec::Vec::new();
10284 for child in non_field_children {
10285 items.push(<TypeDescriptor as ::treesitter_types::FromNode>::from_node(
10286 child, src,
10287 )?);
10288 }
10289 items
10290 },
10291 })
10292 }
10293}
10294impl ::treesitter_types::Spanned for ThrowSpecifier<'_> {
10295 fn span(&self) -> ::treesitter_types::Span {
10296 self.span
10297 }
10298}
10299#[derive(Debug, Clone)]
10300pub struct ThrowStatement<'tree> {
10301 pub span: ::treesitter_types::Span,
10302 pub children: ::core::option::Option<Expression<'tree>>,
10303}
10304impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
10305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10306 fn from_node(
10307 node: ::tree_sitter::Node<'tree>,
10308 src: &'tree [u8],
10309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10310 debug_assert_eq!(node.kind(), "throw_statement");
10311 Ok(Self {
10312 span: ::treesitter_types::Span::from(node),
10313 children: {
10314 #[allow(clippy::suspicious_else_formatting)]
10315 let non_field_children = {
10316 let mut cursor = node.walk();
10317 let mut result = ::std::vec::Vec::new();
10318 if cursor.goto_first_child() {
10319 loop {
10320 if cursor.field_name().is_none()
10321 && cursor.node().is_named()
10322 && !cursor.node().is_extra()
10323 {
10324 result.push(cursor.node());
10325 }
10326 if !cursor.goto_next_sibling() {
10327 break;
10328 }
10329 }
10330 }
10331 result
10332 };
10333 match non_field_children.first() {
10334 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
10335 child, src,
10336 )?),
10337 None => None,
10338 }
10339 },
10340 })
10341 }
10342}
10343impl ::treesitter_types::Spanned for ThrowStatement<'_> {
10344 fn span(&self) -> ::treesitter_types::Span {
10345 self.span
10346 }
10347}
10348#[derive(Debug, Clone)]
10349pub struct TrailingReturnType<'tree> {
10350 pub span: ::treesitter_types::Span,
10351 pub children: TypeDescriptor<'tree>,
10352}
10353impl<'tree> ::treesitter_types::FromNode<'tree> for TrailingReturnType<'tree> {
10354 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10355 fn from_node(
10356 node: ::tree_sitter::Node<'tree>,
10357 src: &'tree [u8],
10358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10359 debug_assert_eq!(node.kind(), "trailing_return_type");
10360 Ok(Self {
10361 span: ::treesitter_types::Span::from(node),
10362 children: {
10363 #[allow(clippy::suspicious_else_formatting)]
10364 let non_field_children = {
10365 let mut cursor = node.walk();
10366 let mut result = ::std::vec::Vec::new();
10367 if cursor.goto_first_child() {
10368 loop {
10369 if cursor.field_name().is_none()
10370 && cursor.node().is_named()
10371 && !cursor.node().is_extra()
10372 {
10373 result.push(cursor.node());
10374 }
10375 if !cursor.goto_next_sibling() {
10376 break;
10377 }
10378 }
10379 }
10380 result
10381 };
10382 let child = if let Some(&c) = non_field_children.first() {
10383 c
10384 } else {
10385 let mut fallback_cursor = node.walk();
10386 let mut fallback_child = None;
10387 if fallback_cursor.goto_first_child() {
10388 loop {
10389 if fallback_cursor.field_name().is_none()
10390 && !fallback_cursor.node().is_extra()
10391 {
10392 let candidate = fallback_cursor.node();
10393 #[allow(clippy::needless_question_mark)]
10394 if (|| -> ::core::result::Result<
10395 _,
10396 ::treesitter_types::ParseError,
10397 > {
10398 let child = candidate;
10399 Ok(
10400 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(
10401 child,
10402 src,
10403 )?,
10404 )
10405 })()
10406 .is_ok()
10407 {
10408 fallback_child = Some(candidate);
10409 break;
10410 }
10411 }
10412 if !fallback_cursor.goto_next_sibling() {
10413 break;
10414 }
10415 }
10416 }
10417 if fallback_child.is_none() {
10418 let mut cursor2 = node.walk();
10419 if cursor2.goto_first_child() {
10420 loop {
10421 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10422 let candidate = cursor2.node();
10423 #[allow(clippy::needless_question_mark)]
10424 if (|| -> ::core::result::Result<
10425 _,
10426 ::treesitter_types::ParseError,
10427 > {
10428 let child = candidate;
10429 Ok(
10430 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(
10431 child,
10432 src,
10433 )?,
10434 )
10435 })()
10436 .is_ok()
10437 {
10438 fallback_child = Some(candidate);
10439 break;
10440 }
10441 }
10442 if !cursor2.goto_next_sibling() {
10443 break;
10444 }
10445 }
10446 }
10447 }
10448 fallback_child.ok_or_else(|| {
10449 ::treesitter_types::ParseError::missing_field("children", node)
10450 })?
10451 };
10452 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(child, src)?
10453 },
10454 })
10455 }
10456}
10457impl ::treesitter_types::Spanned for TrailingReturnType<'_> {
10458 fn span(&self) -> ::treesitter_types::Span {
10459 self.span
10460 }
10461}
10462#[derive(Debug, Clone)]
10463pub struct TranslationUnit<'tree> {
10464 pub span: ::treesitter_types::Span,
10465 pub children: ::std::vec::Vec<TranslationUnitChildren<'tree>>,
10466}
10467impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnit<'tree> {
10468 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10469 fn from_node(
10470 node: ::tree_sitter::Node<'tree>,
10471 src: &'tree [u8],
10472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10473 debug_assert_eq!(node.kind(), "translation_unit");
10474 Ok(Self {
10475 span: ::treesitter_types::Span::from(node),
10476 children: {
10477 #[allow(clippy::suspicious_else_formatting)]
10478 let non_field_children = {
10479 let mut cursor = node.walk();
10480 let mut result = ::std::vec::Vec::new();
10481 if cursor.goto_first_child() {
10482 loop {
10483 if cursor.field_name().is_none()
10484 && cursor.node().is_named()
10485 && !cursor.node().is_extra()
10486 {
10487 result.push(cursor.node());
10488 }
10489 if !cursor.goto_next_sibling() {
10490 break;
10491 }
10492 }
10493 }
10494 result
10495 };
10496 let mut items = ::std::vec::Vec::new();
10497 for child in non_field_children {
10498 items.push(
10499 <TranslationUnitChildren as ::treesitter_types::FromNode>::from_node(
10500 child, src,
10501 )?,
10502 );
10503 }
10504 items
10505 },
10506 })
10507 }
10508}
10509impl ::treesitter_types::Spanned for TranslationUnit<'_> {
10510 fn span(&self) -> ::treesitter_types::Span {
10511 self.span
10512 }
10513}
10514#[derive(Debug, Clone)]
10515pub struct TryStatement<'tree> {
10516 pub span: ::treesitter_types::Span,
10517 pub body: CompoundStatement<'tree>,
10518 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
10519}
10520impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
10521 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10522 fn from_node(
10523 node: ::tree_sitter::Node<'tree>,
10524 src: &'tree [u8],
10525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10526 debug_assert_eq!(node.kind(), "try_statement");
10527 Ok(Self {
10528 span: ::treesitter_types::Span::from(node),
10529 body: {
10530 let child = node
10531 .child_by_field_name("body")
10532 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
10533 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
10534 },
10535 children: {
10536 #[allow(clippy::suspicious_else_formatting)]
10537 let non_field_children = {
10538 let mut cursor = node.walk();
10539 let mut result = ::std::vec::Vec::new();
10540 if cursor.goto_first_child() {
10541 loop {
10542 if cursor.field_name().is_none()
10543 && cursor.node().is_named()
10544 && !cursor.node().is_extra()
10545 {
10546 result.push(cursor.node());
10547 }
10548 if !cursor.goto_next_sibling() {
10549 break;
10550 }
10551 }
10552 }
10553 result
10554 };
10555 let mut items = ::std::vec::Vec::new();
10556 for child in non_field_children {
10557 items.push(
10558 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
10559 child, src,
10560 )?,
10561 );
10562 }
10563 items
10564 },
10565 })
10566 }
10567}
10568impl ::treesitter_types::Spanned for TryStatement<'_> {
10569 fn span(&self) -> ::treesitter_types::Span {
10570 self.span
10571 }
10572}
10573#[derive(Debug, Clone)]
10574pub struct TypeDefinition<'tree> {
10575 pub span: ::treesitter_types::Span,
10576 pub declarator: ::std::vec::Vec<TypeDeclarator<'tree>>,
10577 pub r#type: TypeSpecifier<'tree>,
10578 pub children: ::std::vec::Vec<TypeDefinitionChildren<'tree>>,
10579}
10580impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinition<'tree> {
10581 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10582 fn from_node(
10583 node: ::tree_sitter::Node<'tree>,
10584 src: &'tree [u8],
10585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10586 debug_assert_eq!(node.kind(), "type_definition");
10587 Ok(Self {
10588 span: ::treesitter_types::Span::from(node),
10589 declarator: {
10590 let mut cursor = node.walk();
10591 let mut items = ::std::vec::Vec::new();
10592 for child in node.children_by_field_name("declarator", &mut cursor) {
10593 items.push(<TypeDeclarator as ::treesitter_types::FromNode>::from_node(
10594 child, src,
10595 )?);
10596 }
10597 items
10598 },
10599 r#type: {
10600 let child = node
10601 .child_by_field_name("type")
10602 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10603 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
10604 },
10605 children: {
10606 #[allow(clippy::suspicious_else_formatting)]
10607 let non_field_children = {
10608 let mut cursor = node.walk();
10609 let mut result = ::std::vec::Vec::new();
10610 if cursor.goto_first_child() {
10611 loop {
10612 if cursor.field_name().is_none()
10613 && cursor.node().is_named()
10614 && !cursor.node().is_extra()
10615 {
10616 result.push(cursor.node());
10617 }
10618 if !cursor.goto_next_sibling() {
10619 break;
10620 }
10621 }
10622 }
10623 result
10624 };
10625 let mut items = ::std::vec::Vec::new();
10626 for child in non_field_children {
10627 items.push(
10628 <TypeDefinitionChildren as ::treesitter_types::FromNode>::from_node(
10629 child, src,
10630 )?,
10631 );
10632 }
10633 items
10634 },
10635 })
10636 }
10637}
10638impl ::treesitter_types::Spanned for TypeDefinition<'_> {
10639 fn span(&self) -> ::treesitter_types::Span {
10640 self.span
10641 }
10642}
10643#[derive(Debug, Clone)]
10644pub struct TypeDescriptor<'tree> {
10645 pub span: ::treesitter_types::Span,
10646 pub declarator: ::core::option::Option<AbstractDeclarator<'tree>>,
10647 pub r#type: TypeSpecifier<'tree>,
10648 pub children: ::std::vec::Vec<TypeQualifier<'tree>>,
10649}
10650impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDescriptor<'tree> {
10651 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10652 fn from_node(
10653 node: ::tree_sitter::Node<'tree>,
10654 src: &'tree [u8],
10655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10656 debug_assert_eq!(node.kind(), "type_descriptor");
10657 Ok(Self {
10658 span: ::treesitter_types::Span::from(node),
10659 declarator: match node.child_by_field_name("declarator") {
10660 Some(child) => Some(
10661 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(child, src)?,
10662 ),
10663 None => None,
10664 },
10665 r#type: {
10666 let child = node
10667 .child_by_field_name("type")
10668 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
10669 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
10670 },
10671 children: {
10672 #[allow(clippy::suspicious_else_formatting)]
10673 let non_field_children = {
10674 let mut cursor = node.walk();
10675 let mut result = ::std::vec::Vec::new();
10676 if cursor.goto_first_child() {
10677 loop {
10678 if cursor.field_name().is_none()
10679 && cursor.node().is_named()
10680 && !cursor.node().is_extra()
10681 {
10682 result.push(cursor.node());
10683 }
10684 if !cursor.goto_next_sibling() {
10685 break;
10686 }
10687 }
10688 }
10689 result
10690 };
10691 let mut items = ::std::vec::Vec::new();
10692 for child in non_field_children {
10693 items.push(<TypeQualifier as ::treesitter_types::FromNode>::from_node(
10694 child, src,
10695 )?);
10696 }
10697 items
10698 },
10699 })
10700 }
10701}
10702impl ::treesitter_types::Spanned for TypeDescriptor<'_> {
10703 fn span(&self) -> ::treesitter_types::Span {
10704 self.span
10705 }
10706}
10707#[derive(Debug, Clone)]
10708pub struct TypeParameterDeclaration<'tree> {
10709 pub span: ::treesitter_types::Span,
10710 pub children: ::core::option::Option<TypeIdentifier<'tree>>,
10711}
10712impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameterDeclaration<'tree> {
10713 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10714 fn from_node(
10715 node: ::tree_sitter::Node<'tree>,
10716 src: &'tree [u8],
10717 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10718 debug_assert_eq!(node.kind(), "type_parameter_declaration");
10719 Ok(Self {
10720 span: ::treesitter_types::Span::from(node),
10721 children: {
10722 #[allow(clippy::suspicious_else_formatting)]
10723 let non_field_children = {
10724 let mut cursor = node.walk();
10725 let mut result = ::std::vec::Vec::new();
10726 if cursor.goto_first_child() {
10727 loop {
10728 if cursor.field_name().is_none()
10729 && cursor.node().is_named()
10730 && !cursor.node().is_extra()
10731 {
10732 result.push(cursor.node());
10733 }
10734 if !cursor.goto_next_sibling() {
10735 break;
10736 }
10737 }
10738 }
10739 result
10740 };
10741 match non_field_children.first() {
10742 Some(&child) => Some(
10743 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
10744 ),
10745 None => None,
10746 }
10747 },
10748 })
10749 }
10750}
10751impl ::treesitter_types::Spanned for TypeParameterDeclaration<'_> {
10752 fn span(&self) -> ::treesitter_types::Span {
10753 self.span
10754 }
10755}
10756#[derive(Debug, Clone)]
10757pub struct TypeQualifier<'tree> {
10758 pub span: ::treesitter_types::Span,
10759 pub children: ::core::option::Option<AlignasQualifier<'tree>>,
10760}
10761impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQualifier<'tree> {
10762 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10763 fn from_node(
10764 node: ::tree_sitter::Node<'tree>,
10765 src: &'tree [u8],
10766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10767 debug_assert_eq!(node.kind(), "type_qualifier");
10768 Ok(Self {
10769 span: ::treesitter_types::Span::from(node),
10770 children: {
10771 #[allow(clippy::suspicious_else_formatting)]
10772 let non_field_children = {
10773 let mut cursor = node.walk();
10774 let mut result = ::std::vec::Vec::new();
10775 if cursor.goto_first_child() {
10776 loop {
10777 if cursor.field_name().is_none()
10778 && cursor.node().is_named()
10779 && !cursor.node().is_extra()
10780 {
10781 result.push(cursor.node());
10782 }
10783 if !cursor.goto_next_sibling() {
10784 break;
10785 }
10786 }
10787 }
10788 result
10789 };
10790 match non_field_children.first() {
10791 Some(&child) => Some(
10792 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(child, src)?,
10793 ),
10794 None => None,
10795 }
10796 },
10797 })
10798 }
10799}
10800impl ::treesitter_types::Spanned for TypeQualifier<'_> {
10801 fn span(&self) -> ::treesitter_types::Span {
10802 self.span
10803 }
10804}
10805#[derive(Debug, Clone)]
10806pub struct TypeRequirement<'tree> {
10807 pub span: ::treesitter_types::Span,
10808 pub children: TypeRequirementChildren<'tree>,
10809}
10810impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRequirement<'tree> {
10811 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10812 fn from_node(
10813 node: ::tree_sitter::Node<'tree>,
10814 src: &'tree [u8],
10815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10816 debug_assert_eq!(node.kind(), "type_requirement");
10817 Ok(Self {
10818 span: ::treesitter_types::Span::from(node),
10819 children: {
10820 #[allow(clippy::suspicious_else_formatting)]
10821 let non_field_children = {
10822 let mut cursor = node.walk();
10823 let mut result = ::std::vec::Vec::new();
10824 if cursor.goto_first_child() {
10825 loop {
10826 if cursor.field_name().is_none()
10827 && cursor.node().is_named()
10828 && !cursor.node().is_extra()
10829 {
10830 result.push(cursor.node());
10831 }
10832 if !cursor.goto_next_sibling() {
10833 break;
10834 }
10835 }
10836 }
10837 result
10838 };
10839 let child = if let Some(&c) = non_field_children.first() {
10840 c
10841 } else {
10842 let mut fallback_cursor = node.walk();
10843 let mut fallback_child = None;
10844 if fallback_cursor.goto_first_child() {
10845 loop {
10846 if fallback_cursor.field_name().is_none()
10847 && !fallback_cursor.node().is_extra()
10848 {
10849 let candidate = fallback_cursor.node();
10850 #[allow(clippy::needless_question_mark)]
10851 if (|| -> ::core::result::Result<
10852 _,
10853 ::treesitter_types::ParseError,
10854 > {
10855 let child = candidate;
10856 Ok(
10857 <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(
10858 child,
10859 src,
10860 )?,
10861 )
10862 })()
10863 .is_ok()
10864 {
10865 fallback_child = Some(candidate);
10866 break;
10867 }
10868 }
10869 if !fallback_cursor.goto_next_sibling() {
10870 break;
10871 }
10872 }
10873 }
10874 if fallback_child.is_none() {
10875 let mut cursor2 = node.walk();
10876 if cursor2.goto_first_child() {
10877 loop {
10878 if cursor2.node().is_named() && !cursor2.node().is_extra() {
10879 let candidate = cursor2.node();
10880 #[allow(clippy::needless_question_mark)]
10881 if (|| -> ::core::result::Result<
10882 _,
10883 ::treesitter_types::ParseError,
10884 > {
10885 let child = candidate;
10886 Ok(
10887 <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(
10888 child,
10889 src,
10890 )?,
10891 )
10892 })()
10893 .is_ok()
10894 {
10895 fallback_child = Some(candidate);
10896 break;
10897 }
10898 }
10899 if !cursor2.goto_next_sibling() {
10900 break;
10901 }
10902 }
10903 }
10904 }
10905 fallback_child.ok_or_else(|| {
10906 ::treesitter_types::ParseError::missing_field("children", node)
10907 })?
10908 };
10909 <TypeRequirementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
10910 },
10911 })
10912 }
10913}
10914impl ::treesitter_types::Spanned for TypeRequirement<'_> {
10915 fn span(&self) -> ::treesitter_types::Span {
10916 self.span
10917 }
10918}
10919#[derive(Debug, Clone)]
10920pub struct UnaryExpression<'tree> {
10921 pub span: ::treesitter_types::Span,
10922 pub argument: UnaryExpressionArgument<'tree>,
10923 pub operator: UnaryExpressionOperator,
10924}
10925impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
10926 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10927 fn from_node(
10928 node: ::tree_sitter::Node<'tree>,
10929 src: &'tree [u8],
10930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10931 debug_assert_eq!(node.kind(), "unary_expression");
10932 Ok(Self {
10933 span: ::treesitter_types::Span::from(node),
10934 argument: {
10935 let child = node.child_by_field_name("argument").ok_or_else(|| {
10936 ::treesitter_types::ParseError::missing_field("argument", node)
10937 })?;
10938 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)?
10939 },
10940 operator: {
10941 let child = node.child_by_field_name("operator").ok_or_else(|| {
10942 ::treesitter_types::ParseError::missing_field("operator", node)
10943 })?;
10944 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
10945 },
10946 })
10947 }
10948}
10949impl ::treesitter_types::Spanned for UnaryExpression<'_> {
10950 fn span(&self) -> ::treesitter_types::Span {
10951 self.span
10952 }
10953}
10954#[derive(Debug, Clone)]
10955pub struct UnionSpecifier<'tree> {
10956 pub span: ::treesitter_types::Span,
10957 pub body: ::core::option::Option<FieldDeclarationList<'tree>>,
10958 pub name: ::core::option::Option<UnionSpecifierName<'tree>>,
10959 pub children: ::std::vec::Vec<UnionSpecifierChildren<'tree>>,
10960}
10961impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifier<'tree> {
10962 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
10963 fn from_node(
10964 node: ::tree_sitter::Node<'tree>,
10965 src: &'tree [u8],
10966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10967 debug_assert_eq!(node.kind(), "union_specifier");
10968 Ok(Self {
10969 span: ::treesitter_types::Span::from(node),
10970 body: match node.child_by_field_name("body") {
10971 Some(child) => Some(
10972 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?,
10973 ),
10974 None => None,
10975 },
10976 name: match node.child_by_field_name("name") {
10977 Some(child) => Some(
10978 <UnionSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?,
10979 ),
10980 None => None,
10981 },
10982 children: {
10983 #[allow(clippy::suspicious_else_formatting)]
10984 let non_field_children = {
10985 let mut cursor = node.walk();
10986 let mut result = ::std::vec::Vec::new();
10987 if cursor.goto_first_child() {
10988 loop {
10989 if cursor.field_name().is_none()
10990 && cursor.node().is_named()
10991 && !cursor.node().is_extra()
10992 {
10993 result.push(cursor.node());
10994 }
10995 if !cursor.goto_next_sibling() {
10996 break;
10997 }
10998 }
10999 }
11000 result
11001 };
11002 let mut items = ::std::vec::Vec::new();
11003 for child in non_field_children {
11004 items.push(
11005 <UnionSpecifierChildren as ::treesitter_types::FromNode>::from_node(
11006 child, src,
11007 )?,
11008 );
11009 }
11010 items
11011 },
11012 })
11013 }
11014}
11015impl ::treesitter_types::Spanned for UnionSpecifier<'_> {
11016 fn span(&self) -> ::treesitter_types::Span {
11017 self.span
11018 }
11019}
11020#[derive(Debug, Clone)]
11021pub struct UpdateExpression<'tree> {
11022 pub span: ::treesitter_types::Span,
11023 pub argument: Expression<'tree>,
11024 pub operator: UpdateExpressionOperator,
11025}
11026impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
11027 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11028 fn from_node(
11029 node: ::tree_sitter::Node<'tree>,
11030 src: &'tree [u8],
11031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11032 debug_assert_eq!(node.kind(), "update_expression");
11033 Ok(Self {
11034 span: ::treesitter_types::Span::from(node),
11035 argument: {
11036 let child = node.child_by_field_name("argument").ok_or_else(|| {
11037 ::treesitter_types::ParseError::missing_field("argument", node)
11038 })?;
11039 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
11040 },
11041 operator: {
11042 let child = node.child_by_field_name("operator").ok_or_else(|| {
11043 ::treesitter_types::ParseError::missing_field("operator", node)
11044 })?;
11045 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
11046 },
11047 })
11048 }
11049}
11050impl ::treesitter_types::Spanned for UpdateExpression<'_> {
11051 fn span(&self) -> ::treesitter_types::Span {
11052 self.span
11053 }
11054}
11055#[derive(Debug, Clone)]
11056pub struct UserDefinedLiteral<'tree> {
11057 pub span: ::treesitter_types::Span,
11058 pub children: ::std::vec::Vec<UserDefinedLiteralChildren<'tree>>,
11059}
11060impl<'tree> ::treesitter_types::FromNode<'tree> for UserDefinedLiteral<'tree> {
11061 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11062 fn from_node(
11063 node: ::tree_sitter::Node<'tree>,
11064 src: &'tree [u8],
11065 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11066 debug_assert_eq!(node.kind(), "user_defined_literal");
11067 Ok(Self {
11068 span: ::treesitter_types::Span::from(node),
11069 children: {
11070 #[allow(clippy::suspicious_else_formatting)]
11071 let non_field_children = {
11072 let mut cursor = node.walk();
11073 let mut result = ::std::vec::Vec::new();
11074 if cursor.goto_first_child() {
11075 loop {
11076 if cursor.field_name().is_none()
11077 && cursor.node().is_named()
11078 && !cursor.node().is_extra()
11079 {
11080 result.push(cursor.node());
11081 }
11082 if !cursor.goto_next_sibling() {
11083 break;
11084 }
11085 }
11086 }
11087 result
11088 };
11089 let mut items = ::std::vec::Vec::new();
11090 for child in non_field_children {
11091 items.push(
11092 <UserDefinedLiteralChildren as ::treesitter_types::FromNode>::from_node(
11093 child, src,
11094 )?,
11095 );
11096 }
11097 items
11098 },
11099 })
11100 }
11101}
11102impl ::treesitter_types::Spanned for UserDefinedLiteral<'_> {
11103 fn span(&self) -> ::treesitter_types::Span {
11104 self.span
11105 }
11106}
11107#[derive(Debug, Clone)]
11108pub struct UsingDeclaration<'tree> {
11109 pub span: ::treesitter_types::Span,
11110 pub children: UsingDeclarationChildren<'tree>,
11111}
11112impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclaration<'tree> {
11113 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11114 fn from_node(
11115 node: ::tree_sitter::Node<'tree>,
11116 src: &'tree [u8],
11117 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11118 debug_assert_eq!(node.kind(), "using_declaration");
11119 Ok(Self {
11120 span: ::treesitter_types::Span::from(node),
11121 children: {
11122 #[allow(clippy::suspicious_else_formatting)]
11123 let non_field_children = {
11124 let mut cursor = node.walk();
11125 let mut result = ::std::vec::Vec::new();
11126 if cursor.goto_first_child() {
11127 loop {
11128 if cursor.field_name().is_none()
11129 && cursor.node().is_named()
11130 && !cursor.node().is_extra()
11131 {
11132 result.push(cursor.node());
11133 }
11134 if !cursor.goto_next_sibling() {
11135 break;
11136 }
11137 }
11138 }
11139 result
11140 };
11141 let child = if let Some(&c) = non_field_children.first() {
11142 c
11143 } else {
11144 let mut fallback_cursor = node.walk();
11145 let mut fallback_child = None;
11146 if fallback_cursor.goto_first_child() {
11147 loop {
11148 if fallback_cursor.field_name().is_none()
11149 && !fallback_cursor.node().is_extra()
11150 {
11151 let candidate = fallback_cursor.node();
11152 #[allow(clippy::needless_question_mark)]
11153 if (|| -> ::core::result::Result<
11154 _,
11155 ::treesitter_types::ParseError,
11156 > {
11157 let child = candidate;
11158 Ok(
11159 <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11160 child,
11161 src,
11162 )?,
11163 )
11164 })()
11165 .is_ok()
11166 {
11167 fallback_child = Some(candidate);
11168 break;
11169 }
11170 }
11171 if !fallback_cursor.goto_next_sibling() {
11172 break;
11173 }
11174 }
11175 }
11176 if fallback_child.is_none() {
11177 let mut cursor2 = node.walk();
11178 if cursor2.goto_first_child() {
11179 loop {
11180 if cursor2.node().is_named() && !cursor2.node().is_extra() {
11181 let candidate = cursor2.node();
11182 #[allow(clippy::needless_question_mark)]
11183 if (|| -> ::core::result::Result<
11184 _,
11185 ::treesitter_types::ParseError,
11186 > {
11187 let child = candidate;
11188 Ok(
11189 <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11190 child,
11191 src,
11192 )?,
11193 )
11194 })()
11195 .is_ok()
11196 {
11197 fallback_child = Some(candidate);
11198 break;
11199 }
11200 }
11201 if !cursor2.goto_next_sibling() {
11202 break;
11203 }
11204 }
11205 }
11206 }
11207 fallback_child.ok_or_else(|| {
11208 ::treesitter_types::ParseError::missing_field("children", node)
11209 })?
11210 };
11211 <UsingDeclarationChildren as ::treesitter_types::FromNode>::from_node(child, src)?
11212 },
11213 })
11214 }
11215}
11216impl ::treesitter_types::Spanned for UsingDeclaration<'_> {
11217 fn span(&self) -> ::treesitter_types::Span {
11218 self.span
11219 }
11220}
11221#[derive(Debug, Clone)]
11222pub struct VariadicDeclarator<'tree> {
11223 pub span: ::treesitter_types::Span,
11224 pub children: ::core::option::Option<Identifier<'tree>>,
11225}
11226impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicDeclarator<'tree> {
11227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11228 fn from_node(
11229 node: ::tree_sitter::Node<'tree>,
11230 src: &'tree [u8],
11231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11232 debug_assert_eq!(node.kind(), "variadic_declarator");
11233 Ok(Self {
11234 span: ::treesitter_types::Span::from(node),
11235 children: {
11236 #[allow(clippy::suspicious_else_formatting)]
11237 let non_field_children = {
11238 let mut cursor = node.walk();
11239 let mut result = ::std::vec::Vec::new();
11240 if cursor.goto_first_child() {
11241 loop {
11242 if cursor.field_name().is_none()
11243 && cursor.node().is_named()
11244 && !cursor.node().is_extra()
11245 {
11246 result.push(cursor.node());
11247 }
11248 if !cursor.goto_next_sibling() {
11249 break;
11250 }
11251 }
11252 }
11253 result
11254 };
11255 match non_field_children.first() {
11256 Some(&child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
11257 child, src,
11258 )?),
11259 None => None,
11260 }
11261 },
11262 })
11263 }
11264}
11265impl ::treesitter_types::Spanned for VariadicDeclarator<'_> {
11266 fn span(&self) -> ::treesitter_types::Span {
11267 self.span
11268 }
11269}
11270#[derive(Debug, Clone)]
11271pub struct VariadicParameterDeclaration<'tree> {
11272 pub span: ::treesitter_types::Span,
11273 pub declarator: VariadicParameterDeclarationDeclarator<'tree>,
11274 pub r#type: TypeSpecifier<'tree>,
11275 pub children: ::std::vec::Vec<VariadicParameterDeclarationChildren<'tree>>,
11276}
11277impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclaration<'tree> {
11278 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11279 fn from_node(
11280 node: ::tree_sitter::Node<'tree>,
11281 src: &'tree [u8],
11282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11283 debug_assert_eq!(node.kind(), "variadic_parameter_declaration");
11284 Ok(Self {
11285 span: ::treesitter_types::Span::from(node),
11286 declarator: {
11287 let child = node.child_by_field_name("declarator").ok_or_else(|| {
11288 ::treesitter_types::ParseError::missing_field("declarator", node)
11289 })?;
11290 <VariadicParameterDeclarationDeclarator as ::treesitter_types::FromNode>::from_node(
11291 child, src,
11292 )?
11293 },
11294 r#type: {
11295 let child = node
11296 .child_by_field_name("type")
11297 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
11298 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?
11299 },
11300 children: {
11301 #[allow(clippy::suspicious_else_formatting)]
11302 let non_field_children = {
11303 let mut cursor = node.walk();
11304 let mut result = ::std::vec::Vec::new();
11305 if cursor.goto_first_child() {
11306 loop {
11307 if cursor.field_name().is_none()
11308 && cursor.node().is_named()
11309 && !cursor.node().is_extra()
11310 {
11311 result.push(cursor.node());
11312 }
11313 if !cursor.goto_next_sibling() {
11314 break;
11315 }
11316 }
11317 }
11318 result
11319 };
11320 let mut items = ::std::vec::Vec::new();
11321 for child in non_field_children {
11322 items
11323 .push(
11324 <VariadicParameterDeclarationChildren as ::treesitter_types::FromNode>::from_node(
11325 child,
11326 src,
11327 )?,
11328 );
11329 }
11330 items
11331 },
11332 })
11333 }
11334}
11335impl ::treesitter_types::Spanned for VariadicParameterDeclaration<'_> {
11336 fn span(&self) -> ::treesitter_types::Span {
11337 self.span
11338 }
11339}
11340#[derive(Debug, Clone)]
11341pub struct VariadicTypeParameterDeclaration<'tree> {
11342 pub span: ::treesitter_types::Span,
11343 pub children: ::core::option::Option<TypeIdentifier<'tree>>,
11344}
11345impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicTypeParameterDeclaration<'tree> {
11346 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11347 fn from_node(
11348 node: ::tree_sitter::Node<'tree>,
11349 src: &'tree [u8],
11350 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11351 debug_assert_eq!(node.kind(), "variadic_type_parameter_declaration");
11352 Ok(Self {
11353 span: ::treesitter_types::Span::from(node),
11354 children: {
11355 #[allow(clippy::suspicious_else_formatting)]
11356 let non_field_children = {
11357 let mut cursor = node.walk();
11358 let mut result = ::std::vec::Vec::new();
11359 if cursor.goto_first_child() {
11360 loop {
11361 if cursor.field_name().is_none()
11362 && cursor.node().is_named()
11363 && !cursor.node().is_extra()
11364 {
11365 result.push(cursor.node());
11366 }
11367 if !cursor.goto_next_sibling() {
11368 break;
11369 }
11370 }
11371 }
11372 result
11373 };
11374 match non_field_children.first() {
11375 Some(&child) => Some(
11376 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
11377 ),
11378 None => None,
11379 }
11380 },
11381 })
11382 }
11383}
11384impl ::treesitter_types::Spanned for VariadicTypeParameterDeclaration<'_> {
11385 fn span(&self) -> ::treesitter_types::Span {
11386 self.span
11387 }
11388}
11389#[derive(Debug, Clone)]
11390pub struct VirtualSpecifier<'tree> {
11391 pub span: ::treesitter_types::Span,
11392 text: &'tree str,
11393}
11394impl<'tree> ::treesitter_types::FromNode<'tree> for VirtualSpecifier<'tree> {
11395 fn from_node(
11396 node: ::tree_sitter::Node<'tree>,
11397 src: &'tree [u8],
11398 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11399 debug_assert_eq!(node.kind(), "virtual_specifier");
11400 Ok(Self {
11401 span: ::treesitter_types::Span::from(node),
11402 text: node.utf8_text(src)?,
11403 })
11404 }
11405}
11406impl<'tree> ::treesitter_types::LeafNode<'tree> for VirtualSpecifier<'tree> {
11407 fn text(&self) -> &'tree str {
11408 self.text
11409 }
11410}
11411impl ::treesitter_types::Spanned for VirtualSpecifier<'_> {
11412 fn span(&self) -> ::treesitter_types::Span {
11413 self.span
11414 }
11415}
11416#[derive(Debug, Clone)]
11417pub struct WhileStatement<'tree> {
11418 pub span: ::treesitter_types::Span,
11419 pub body: Statement<'tree>,
11420 pub condition: ConditionClause<'tree>,
11421}
11422impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
11423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
11424 fn from_node(
11425 node: ::tree_sitter::Node<'tree>,
11426 src: &'tree [u8],
11427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11428 debug_assert_eq!(node.kind(), "while_statement");
11429 Ok(Self {
11430 span: ::treesitter_types::Span::from(node),
11431 body: {
11432 let child = node
11433 .child_by_field_name("body")
11434 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
11435 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
11436 },
11437 condition: {
11438 let child = node.child_by_field_name("condition").ok_or_else(|| {
11439 ::treesitter_types::ParseError::missing_field("condition", node)
11440 })?;
11441 <ConditionClause as ::treesitter_types::FromNode>::from_node(child, src)?
11442 },
11443 })
11444 }
11445}
11446impl ::treesitter_types::Spanned for WhileStatement<'_> {
11447 fn span(&self) -> ::treesitter_types::Span {
11448 self.span
11449 }
11450}
11451#[derive(Debug, Clone)]
11452pub struct Auto<'tree> {
11453 pub span: ::treesitter_types::Span,
11454 text: &'tree str,
11455}
11456impl<'tree> ::treesitter_types::FromNode<'tree> for Auto<'tree> {
11457 fn from_node(
11458 node: ::tree_sitter::Node<'tree>,
11459 src: &'tree [u8],
11460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11461 debug_assert_eq!(node.kind(), "auto");
11462 Ok(Self {
11463 span: ::treesitter_types::Span::from(node),
11464 text: node.utf8_text(src)?,
11465 })
11466 }
11467}
11468impl<'tree> ::treesitter_types::LeafNode<'tree> for Auto<'tree> {
11469 fn text(&self) -> &'tree str {
11470 self.text
11471 }
11472}
11473impl ::treesitter_types::Spanned for Auto<'_> {
11474 fn span(&self) -> ::treesitter_types::Span {
11475 self.span
11476 }
11477}
11478#[derive(Debug, Clone)]
11479pub struct Character<'tree> {
11480 pub span: ::treesitter_types::Span,
11481 text: &'tree str,
11482}
11483impl<'tree> ::treesitter_types::FromNode<'tree> for Character<'tree> {
11484 fn from_node(
11485 node: ::tree_sitter::Node<'tree>,
11486 src: &'tree [u8],
11487 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11488 debug_assert_eq!(node.kind(), "character");
11489 Ok(Self {
11490 span: ::treesitter_types::Span::from(node),
11491 text: node.utf8_text(src)?,
11492 })
11493 }
11494}
11495impl<'tree> ::treesitter_types::LeafNode<'tree> for Character<'tree> {
11496 fn text(&self) -> &'tree str {
11497 self.text
11498 }
11499}
11500impl ::treesitter_types::Spanned for Character<'_> {
11501 fn span(&self) -> ::treesitter_types::Span {
11502 self.span
11503 }
11504}
11505#[derive(Debug, Clone)]
11506pub struct Comment<'tree> {
11507 pub span: ::treesitter_types::Span,
11508 text: &'tree str,
11509}
11510impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
11511 fn from_node(
11512 node: ::tree_sitter::Node<'tree>,
11513 src: &'tree [u8],
11514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11515 debug_assert_eq!(node.kind(), "comment");
11516 Ok(Self {
11517 span: ::treesitter_types::Span::from(node),
11518 text: node.utf8_text(src)?,
11519 })
11520 }
11521}
11522impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
11523 fn text(&self) -> &'tree str {
11524 self.text
11525 }
11526}
11527impl ::treesitter_types::Spanned for Comment<'_> {
11528 fn span(&self) -> ::treesitter_types::Span {
11529 self.span
11530 }
11531}
11532#[derive(Debug, Clone)]
11533pub struct EscapeSequence<'tree> {
11534 pub span: ::treesitter_types::Span,
11535 text: &'tree str,
11536}
11537impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
11538 fn from_node(
11539 node: ::tree_sitter::Node<'tree>,
11540 src: &'tree [u8],
11541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11542 debug_assert_eq!(node.kind(), "escape_sequence");
11543 Ok(Self {
11544 span: ::treesitter_types::Span::from(node),
11545 text: node.utf8_text(src)?,
11546 })
11547 }
11548}
11549impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
11550 fn text(&self) -> &'tree str {
11551 self.text
11552 }
11553}
11554impl ::treesitter_types::Spanned for EscapeSequence<'_> {
11555 fn span(&self) -> ::treesitter_types::Span {
11556 self.span
11557 }
11558}
11559#[derive(Debug, Clone)]
11560pub struct False<'tree> {
11561 pub span: ::treesitter_types::Span,
11562 text: &'tree str,
11563}
11564impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
11565 fn from_node(
11566 node: ::tree_sitter::Node<'tree>,
11567 src: &'tree [u8],
11568 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11569 debug_assert_eq!(node.kind(), "false");
11570 Ok(Self {
11571 span: ::treesitter_types::Span::from(node),
11572 text: node.utf8_text(src)?,
11573 })
11574 }
11575}
11576impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
11577 fn text(&self) -> &'tree str {
11578 self.text
11579 }
11580}
11581impl ::treesitter_types::Spanned for False<'_> {
11582 fn span(&self) -> ::treesitter_types::Span {
11583 self.span
11584 }
11585}
11586#[derive(Debug, Clone)]
11587pub struct FieldIdentifier<'tree> {
11588 pub span: ::treesitter_types::Span,
11589 text: &'tree str,
11590}
11591impl<'tree> ::treesitter_types::FromNode<'tree> for FieldIdentifier<'tree> {
11592 fn from_node(
11593 node: ::tree_sitter::Node<'tree>,
11594 src: &'tree [u8],
11595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11596 debug_assert_eq!(node.kind(), "field_identifier");
11597 Ok(Self {
11598 span: ::treesitter_types::Span::from(node),
11599 text: node.utf8_text(src)?,
11600 })
11601 }
11602}
11603impl<'tree> ::treesitter_types::LeafNode<'tree> for FieldIdentifier<'tree> {
11604 fn text(&self) -> &'tree str {
11605 self.text
11606 }
11607}
11608impl ::treesitter_types::Spanned for FieldIdentifier<'_> {
11609 fn span(&self) -> ::treesitter_types::Span {
11610 self.span
11611 }
11612}
11613#[derive(Debug, Clone)]
11614pub struct Identifier<'tree> {
11615 pub span: ::treesitter_types::Span,
11616 text: &'tree str,
11617}
11618impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
11619 fn from_node(
11620 node: ::tree_sitter::Node<'tree>,
11621 src: &'tree [u8],
11622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11623 debug_assert_eq!(node.kind(), "identifier");
11624 Ok(Self {
11625 span: ::treesitter_types::Span::from(node),
11626 text: node.utf8_text(src)?,
11627 })
11628 }
11629}
11630impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
11631 fn text(&self) -> &'tree str {
11632 self.text
11633 }
11634}
11635impl ::treesitter_types::Spanned for Identifier<'_> {
11636 fn span(&self) -> ::treesitter_types::Span {
11637 self.span
11638 }
11639}
11640#[derive(Debug, Clone)]
11641pub struct LiteralSuffix<'tree> {
11642 pub span: ::treesitter_types::Span,
11643 text: &'tree str,
11644}
11645impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralSuffix<'tree> {
11646 fn from_node(
11647 node: ::tree_sitter::Node<'tree>,
11648 src: &'tree [u8],
11649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11650 debug_assert_eq!(node.kind(), "literal_suffix");
11651 Ok(Self {
11652 span: ::treesitter_types::Span::from(node),
11653 text: node.utf8_text(src)?,
11654 })
11655 }
11656}
11657impl<'tree> ::treesitter_types::LeafNode<'tree> for LiteralSuffix<'tree> {
11658 fn text(&self) -> &'tree str {
11659 self.text
11660 }
11661}
11662impl ::treesitter_types::Spanned for LiteralSuffix<'_> {
11663 fn span(&self) -> ::treesitter_types::Span {
11664 self.span
11665 }
11666}
11667#[derive(Debug, Clone)]
11668pub struct MsRestrictModifier<'tree> {
11669 pub span: ::treesitter_types::Span,
11670 text: &'tree str,
11671}
11672impl<'tree> ::treesitter_types::FromNode<'tree> for MsRestrictModifier<'tree> {
11673 fn from_node(
11674 node: ::tree_sitter::Node<'tree>,
11675 src: &'tree [u8],
11676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11677 debug_assert_eq!(node.kind(), "ms_restrict_modifier");
11678 Ok(Self {
11679 span: ::treesitter_types::Span::from(node),
11680 text: node.utf8_text(src)?,
11681 })
11682 }
11683}
11684impl<'tree> ::treesitter_types::LeafNode<'tree> for MsRestrictModifier<'tree> {
11685 fn text(&self) -> &'tree str {
11686 self.text
11687 }
11688}
11689impl ::treesitter_types::Spanned for MsRestrictModifier<'_> {
11690 fn span(&self) -> ::treesitter_types::Span {
11691 self.span
11692 }
11693}
11694#[derive(Debug, Clone)]
11695pub struct MsSignedPtrModifier<'tree> {
11696 pub span: ::treesitter_types::Span,
11697 text: &'tree str,
11698}
11699impl<'tree> ::treesitter_types::FromNode<'tree> for MsSignedPtrModifier<'tree> {
11700 fn from_node(
11701 node: ::tree_sitter::Node<'tree>,
11702 src: &'tree [u8],
11703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11704 debug_assert_eq!(node.kind(), "ms_signed_ptr_modifier");
11705 Ok(Self {
11706 span: ::treesitter_types::Span::from(node),
11707 text: node.utf8_text(src)?,
11708 })
11709 }
11710}
11711impl<'tree> ::treesitter_types::LeafNode<'tree> for MsSignedPtrModifier<'tree> {
11712 fn text(&self) -> &'tree str {
11713 self.text
11714 }
11715}
11716impl ::treesitter_types::Spanned for MsSignedPtrModifier<'_> {
11717 fn span(&self) -> ::treesitter_types::Span {
11718 self.span
11719 }
11720}
11721#[derive(Debug, Clone)]
11722pub struct MsUnsignedPtrModifier<'tree> {
11723 pub span: ::treesitter_types::Span,
11724 text: &'tree str,
11725}
11726impl<'tree> ::treesitter_types::FromNode<'tree> for MsUnsignedPtrModifier<'tree> {
11727 fn from_node(
11728 node: ::tree_sitter::Node<'tree>,
11729 src: &'tree [u8],
11730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11731 debug_assert_eq!(node.kind(), "ms_unsigned_ptr_modifier");
11732 Ok(Self {
11733 span: ::treesitter_types::Span::from(node),
11734 text: node.utf8_text(src)?,
11735 })
11736 }
11737}
11738impl<'tree> ::treesitter_types::LeafNode<'tree> for MsUnsignedPtrModifier<'tree> {
11739 fn text(&self) -> &'tree str {
11740 self.text
11741 }
11742}
11743impl ::treesitter_types::Spanned for MsUnsignedPtrModifier<'_> {
11744 fn span(&self) -> ::treesitter_types::Span {
11745 self.span
11746 }
11747}
11748#[derive(Debug, Clone)]
11749pub struct NamespaceIdentifier<'tree> {
11750 pub span: ::treesitter_types::Span,
11751 text: &'tree str,
11752}
11753impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceIdentifier<'tree> {
11754 fn from_node(
11755 node: ::tree_sitter::Node<'tree>,
11756 src: &'tree [u8],
11757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11758 debug_assert_eq!(node.kind(), "namespace_identifier");
11759 Ok(Self {
11760 span: ::treesitter_types::Span::from(node),
11761 text: node.utf8_text(src)?,
11762 })
11763 }
11764}
11765impl<'tree> ::treesitter_types::LeafNode<'tree> for NamespaceIdentifier<'tree> {
11766 fn text(&self) -> &'tree str {
11767 self.text
11768 }
11769}
11770impl ::treesitter_types::Spanned for NamespaceIdentifier<'_> {
11771 fn span(&self) -> ::treesitter_types::Span {
11772 self.span
11773 }
11774}
11775#[derive(Debug, Clone)]
11776pub struct NumberLiteral<'tree> {
11777 pub span: ::treesitter_types::Span,
11778 text: &'tree str,
11779}
11780impl<'tree> ::treesitter_types::FromNode<'tree> for NumberLiteral<'tree> {
11781 fn from_node(
11782 node: ::tree_sitter::Node<'tree>,
11783 src: &'tree [u8],
11784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11785 debug_assert_eq!(node.kind(), "number_literal");
11786 Ok(Self {
11787 span: ::treesitter_types::Span::from(node),
11788 text: node.utf8_text(src)?,
11789 })
11790 }
11791}
11792impl<'tree> ::treesitter_types::LeafNode<'tree> for NumberLiteral<'tree> {
11793 fn text(&self) -> &'tree str {
11794 self.text
11795 }
11796}
11797impl ::treesitter_types::Spanned for NumberLiteral<'_> {
11798 fn span(&self) -> ::treesitter_types::Span {
11799 self.span
11800 }
11801}
11802#[derive(Debug, Clone)]
11803pub struct PreprocArg<'tree> {
11804 pub span: ::treesitter_types::Span,
11805 text: &'tree str,
11806}
11807impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocArg<'tree> {
11808 fn from_node(
11809 node: ::tree_sitter::Node<'tree>,
11810 src: &'tree [u8],
11811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11812 debug_assert_eq!(node.kind(), "preproc_arg");
11813 Ok(Self {
11814 span: ::treesitter_types::Span::from(node),
11815 text: node.utf8_text(src)?,
11816 })
11817 }
11818}
11819impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocArg<'tree> {
11820 fn text(&self) -> &'tree str {
11821 self.text
11822 }
11823}
11824impl ::treesitter_types::Spanned for PreprocArg<'_> {
11825 fn span(&self) -> ::treesitter_types::Span {
11826 self.span
11827 }
11828}
11829#[derive(Debug, Clone)]
11830pub struct PreprocDirective<'tree> {
11831 pub span: ::treesitter_types::Span,
11832 text: &'tree str,
11833}
11834impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocDirective<'tree> {
11835 fn from_node(
11836 node: ::tree_sitter::Node<'tree>,
11837 src: &'tree [u8],
11838 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11839 debug_assert_eq!(node.kind(), "preproc_directive");
11840 Ok(Self {
11841 span: ::treesitter_types::Span::from(node),
11842 text: node.utf8_text(src)?,
11843 })
11844 }
11845}
11846impl<'tree> ::treesitter_types::LeafNode<'tree> for PreprocDirective<'tree> {
11847 fn text(&self) -> &'tree str {
11848 self.text
11849 }
11850}
11851impl ::treesitter_types::Spanned for PreprocDirective<'_> {
11852 fn span(&self) -> ::treesitter_types::Span {
11853 self.span
11854 }
11855}
11856#[derive(Debug, Clone)]
11857pub struct PrimitiveType<'tree> {
11858 pub span: ::treesitter_types::Span,
11859 text: &'tree str,
11860}
11861impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
11862 fn from_node(
11863 node: ::tree_sitter::Node<'tree>,
11864 src: &'tree [u8],
11865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11866 debug_assert_eq!(node.kind(), "primitive_type");
11867 Ok(Self {
11868 span: ::treesitter_types::Span::from(node),
11869 text: node.utf8_text(src)?,
11870 })
11871 }
11872}
11873impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
11874 fn text(&self) -> &'tree str {
11875 self.text
11876 }
11877}
11878impl ::treesitter_types::Spanned for PrimitiveType<'_> {
11879 fn span(&self) -> ::treesitter_types::Span {
11880 self.span
11881 }
11882}
11883#[derive(Debug, Clone)]
11884pub struct RawStringContent<'tree> {
11885 pub span: ::treesitter_types::Span,
11886 text: &'tree str,
11887}
11888impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringContent<'tree> {
11889 fn from_node(
11890 node: ::tree_sitter::Node<'tree>,
11891 src: &'tree [u8],
11892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11893 debug_assert_eq!(node.kind(), "raw_string_content");
11894 Ok(Self {
11895 span: ::treesitter_types::Span::from(node),
11896 text: node.utf8_text(src)?,
11897 })
11898 }
11899}
11900impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringContent<'tree> {
11901 fn text(&self) -> &'tree str {
11902 self.text
11903 }
11904}
11905impl ::treesitter_types::Spanned for RawStringContent<'_> {
11906 fn span(&self) -> ::treesitter_types::Span {
11907 self.span
11908 }
11909}
11910#[derive(Debug, Clone)]
11911pub struct RawStringDelimiter<'tree> {
11912 pub span: ::treesitter_types::Span,
11913 text: &'tree str,
11914}
11915impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringDelimiter<'tree> {
11916 fn from_node(
11917 node: ::tree_sitter::Node<'tree>,
11918 src: &'tree [u8],
11919 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11920 debug_assert_eq!(node.kind(), "raw_string_delimiter");
11921 Ok(Self {
11922 span: ::treesitter_types::Span::from(node),
11923 text: node.utf8_text(src)?,
11924 })
11925 }
11926}
11927impl<'tree> ::treesitter_types::LeafNode<'tree> for RawStringDelimiter<'tree> {
11928 fn text(&self) -> &'tree str {
11929 self.text
11930 }
11931}
11932impl ::treesitter_types::Spanned for RawStringDelimiter<'_> {
11933 fn span(&self) -> ::treesitter_types::Span {
11934 self.span
11935 }
11936}
11937#[derive(Debug, Clone)]
11938pub struct StatementIdentifier<'tree> {
11939 pub span: ::treesitter_types::Span,
11940 text: &'tree str,
11941}
11942impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
11943 fn from_node(
11944 node: ::tree_sitter::Node<'tree>,
11945 src: &'tree [u8],
11946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11947 debug_assert_eq!(node.kind(), "statement_identifier");
11948 Ok(Self {
11949 span: ::treesitter_types::Span::from(node),
11950 text: node.utf8_text(src)?,
11951 })
11952 }
11953}
11954impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
11955 fn text(&self) -> &'tree str {
11956 self.text
11957 }
11958}
11959impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
11960 fn span(&self) -> ::treesitter_types::Span {
11961 self.span
11962 }
11963}
11964#[derive(Debug, Clone)]
11965pub struct StringContent<'tree> {
11966 pub span: ::treesitter_types::Span,
11967 text: &'tree str,
11968}
11969impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
11970 fn from_node(
11971 node: ::tree_sitter::Node<'tree>,
11972 src: &'tree [u8],
11973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11974 debug_assert_eq!(node.kind(), "string_content");
11975 Ok(Self {
11976 span: ::treesitter_types::Span::from(node),
11977 text: node.utf8_text(src)?,
11978 })
11979 }
11980}
11981impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
11982 fn text(&self) -> &'tree str {
11983 self.text
11984 }
11985}
11986impl ::treesitter_types::Spanned for StringContent<'_> {
11987 fn span(&self) -> ::treesitter_types::Span {
11988 self.span
11989 }
11990}
11991#[derive(Debug, Clone)]
11992pub struct SystemLibString<'tree> {
11993 pub span: ::treesitter_types::Span,
11994 text: &'tree str,
11995}
11996impl<'tree> ::treesitter_types::FromNode<'tree> for SystemLibString<'tree> {
11997 fn from_node(
11998 node: ::tree_sitter::Node<'tree>,
11999 src: &'tree [u8],
12000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12001 debug_assert_eq!(node.kind(), "system_lib_string");
12002 Ok(Self {
12003 span: ::treesitter_types::Span::from(node),
12004 text: node.utf8_text(src)?,
12005 })
12006 }
12007}
12008impl<'tree> ::treesitter_types::LeafNode<'tree> for SystemLibString<'tree> {
12009 fn text(&self) -> &'tree str {
12010 self.text
12011 }
12012}
12013impl ::treesitter_types::Spanned for SystemLibString<'_> {
12014 fn span(&self) -> ::treesitter_types::Span {
12015 self.span
12016 }
12017}
12018#[derive(Debug, Clone)]
12019pub struct This<'tree> {
12020 pub span: ::treesitter_types::Span,
12021 text: &'tree str,
12022}
12023impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
12024 fn from_node(
12025 node: ::tree_sitter::Node<'tree>,
12026 src: &'tree [u8],
12027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12028 debug_assert_eq!(node.kind(), "this");
12029 Ok(Self {
12030 span: ::treesitter_types::Span::from(node),
12031 text: node.utf8_text(src)?,
12032 })
12033 }
12034}
12035impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
12036 fn text(&self) -> &'tree str {
12037 self.text
12038 }
12039}
12040impl ::treesitter_types::Spanned for This<'_> {
12041 fn span(&self) -> ::treesitter_types::Span {
12042 self.span
12043 }
12044}
12045#[derive(Debug, Clone)]
12046pub struct True<'tree> {
12047 pub span: ::treesitter_types::Span,
12048 text: &'tree str,
12049}
12050impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
12051 fn from_node(
12052 node: ::tree_sitter::Node<'tree>,
12053 src: &'tree [u8],
12054 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12055 debug_assert_eq!(node.kind(), "true");
12056 Ok(Self {
12057 span: ::treesitter_types::Span::from(node),
12058 text: node.utf8_text(src)?,
12059 })
12060 }
12061}
12062impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
12063 fn text(&self) -> &'tree str {
12064 self.text
12065 }
12066}
12067impl ::treesitter_types::Spanned for True<'_> {
12068 fn span(&self) -> ::treesitter_types::Span {
12069 self.span
12070 }
12071}
12072#[derive(Debug, Clone)]
12073pub struct TypeIdentifier<'tree> {
12074 pub span: ::treesitter_types::Span,
12075 text: &'tree str,
12076}
12077impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
12078 fn from_node(
12079 node: ::tree_sitter::Node<'tree>,
12080 src: &'tree [u8],
12081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12082 debug_assert_eq!(node.kind(), "type_identifier");
12083 Ok(Self {
12084 span: ::treesitter_types::Span::from(node),
12085 text: node.utf8_text(src)?,
12086 })
12087 }
12088}
12089impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
12090 fn text(&self) -> &'tree str {
12091 self.text
12092 }
12093}
12094impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
12095 fn span(&self) -> ::treesitter_types::Span {
12096 self.span
12097 }
12098}
12099#[derive(Debug, Clone)]
12100pub enum AbstractArrayDeclaratorSize<'tree> {
12101 Star(::treesitter_types::Span),
12102 Expression(::std::boxed::Box<Expression<'tree>>),
12103}
12104impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractArrayDeclaratorSize<'tree> {
12105 #[allow(clippy::collapsible_else_if)]
12106 fn from_node(
12107 node: ::tree_sitter::Node<'tree>,
12108 src: &'tree [u8],
12109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12110 match node.kind() {
12111 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
12112 _other => {
12113 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12114 Ok(Self::Expression(::std::boxed::Box::new(v)))
12115 } else {
12116 Err(::treesitter_types::ParseError::unexpected_kind(
12117 _other, node,
12118 ))
12119 }
12120 }
12121 }
12122 }
12123}
12124impl ::treesitter_types::Spanned for AbstractArrayDeclaratorSize<'_> {
12125 fn span(&self) -> ::treesitter_types::Span {
12126 match self {
12127 Self::Star(span) => *span,
12128 Self::Expression(inner) => inner.span(),
12129 }
12130 }
12131}
12132#[derive(Debug, Clone)]
12133pub enum AbstractFunctionDeclaratorChildren<'tree> {
12134 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
12135 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
12136 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
12137 Noexcept(::std::boxed::Box<Noexcept<'tree>>),
12138 RefQualifier(::std::boxed::Box<RefQualifier<'tree>>),
12139 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
12140 ThrowSpecifier(::std::boxed::Box<ThrowSpecifier<'tree>>),
12141 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
12142 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
12143 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
12144}
12145impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFunctionDeclaratorChildren<'tree> {
12146 #[allow(clippy::collapsible_else_if)]
12147 fn from_node(
12148 node: ::tree_sitter::Node<'tree>,
12149 src: &'tree [u8],
12150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12151 match node.kind() {
12152 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
12153 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
12154 ))),
12155 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
12156 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12157 ))),
12158 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
12159 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12160 ))),
12161 "noexcept" => Ok(Self::Noexcept(::std::boxed::Box::new(
12162 <Noexcept as ::treesitter_types::FromNode>::from_node(node, src)?,
12163 ))),
12164 "ref_qualifier" => Ok(Self::RefQualifier(::std::boxed::Box::new(
12165 <RefQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12166 ))),
12167 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
12168 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12169 ))),
12170 "throw_specifier" => Ok(Self::ThrowSpecifier(::std::boxed::Box::new(
12171 <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12172 ))),
12173 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
12174 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)?,
12175 ))),
12176 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
12177 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12178 ))),
12179 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
12180 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12181 ))),
12182 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12183 }
12184 }
12185}
12186impl ::treesitter_types::Spanned for AbstractFunctionDeclaratorChildren<'_> {
12187 fn span(&self) -> ::treesitter_types::Span {
12188 match self {
12189 Self::AttributeDeclaration(inner) => inner.span(),
12190 Self::AttributeSpecifier(inner) => inner.span(),
12191 Self::GnuAsmExpression(inner) => inner.span(),
12192 Self::Noexcept(inner) => inner.span(),
12193 Self::RefQualifier(inner) => inner.span(),
12194 Self::RequiresClause(inner) => inner.span(),
12195 Self::ThrowSpecifier(inner) => inner.span(),
12196 Self::TrailingReturnType(inner) => inner.span(),
12197 Self::TypeQualifier(inner) => inner.span(),
12198 Self::VirtualSpecifier(inner) => inner.span(),
12199 }
12200 }
12201}
12202#[derive(Debug, Clone)]
12203pub enum AbstractParenthesizedDeclaratorChildren<'tree> {
12204 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
12205 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
12206}
12207impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractParenthesizedDeclaratorChildren<'tree> {
12208 #[allow(clippy::collapsible_else_if)]
12209 fn from_node(
12210 node: ::tree_sitter::Node<'tree>,
12211 src: &'tree [u8],
12212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12213 match node.kind() {
12214 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
12215 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12216 ))),
12217 _other => {
12218 if let Ok(v) =
12219 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12220 {
12221 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
12222 } else {
12223 Err(::treesitter_types::ParseError::unexpected_kind(
12224 _other, node,
12225 ))
12226 }
12227 }
12228 }
12229 }
12230}
12231impl ::treesitter_types::Spanned for AbstractParenthesizedDeclaratorChildren<'_> {
12232 fn span(&self) -> ::treesitter_types::Span {
12233 match self {
12234 Self::AbstractDeclarator(inner) => inner.span(),
12235 Self::MsCallModifier(inner) => inner.span(),
12236 }
12237 }
12238}
12239#[derive(Debug, Clone)]
12240pub enum AbstractPointerDeclaratorChildren<'tree> {
12241 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
12242 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
12243}
12244impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractPointerDeclaratorChildren<'tree> {
12245 #[allow(clippy::collapsible_else_if)]
12246 fn from_node(
12247 node: ::tree_sitter::Node<'tree>,
12248 src: &'tree [u8],
12249 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12250 match node.kind() {
12251 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
12252 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12253 ))),
12254 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
12255 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12256 ))),
12257 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12258 }
12259 }
12260}
12261impl ::treesitter_types::Spanned for AbstractPointerDeclaratorChildren<'_> {
12262 fn span(&self) -> ::treesitter_types::Span {
12263 match self {
12264 Self::MsPointerModifier(inner) => inner.span(),
12265 Self::TypeQualifier(inner) => inner.span(),
12266 }
12267 }
12268}
12269#[derive(Debug, Clone)]
12270pub enum AlignasQualifierChildren<'tree> {
12271 Expression(::std::boxed::Box<Expression<'tree>>),
12272 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
12273}
12274impl<'tree> ::treesitter_types::FromNode<'tree> for AlignasQualifierChildren<'tree> {
12275 #[allow(clippy::collapsible_else_if)]
12276 fn from_node(
12277 node: ::tree_sitter::Node<'tree>,
12278 src: &'tree [u8],
12279 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12280 match node.kind() {
12281 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
12282 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)?,
12283 ))),
12284 _other => {
12285 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12286 Ok(Self::Expression(::std::boxed::Box::new(v)))
12287 } else {
12288 Err(::treesitter_types::ParseError::unexpected_kind(
12289 _other, node,
12290 ))
12291 }
12292 }
12293 }
12294 }
12295}
12296impl ::treesitter_types::Spanned for AlignasQualifierChildren<'_> {
12297 fn span(&self) -> ::treesitter_types::Span {
12298 match self {
12299 Self::Expression(inner) => inner.span(),
12300 Self::TypeDescriptor(inner) => inner.span(),
12301 }
12302 }
12303}
12304#[derive(Debug, Clone)]
12305pub enum ArgumentListChildren<'tree> {
12306 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
12307 Expression(::std::boxed::Box<Expression<'tree>>),
12308 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
12309 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
12310}
12311impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentListChildren<'tree> {
12312 #[allow(clippy::collapsible_else_if)]
12313 fn from_node(
12314 node: ::tree_sitter::Node<'tree>,
12315 src: &'tree [u8],
12316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12317 match node.kind() {
12318 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
12319 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12320 ))),
12321 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
12322 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
12323 ))),
12324 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
12325 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
12326 ))),
12327 _other => {
12328 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12329 Ok(Self::Expression(::std::boxed::Box::new(v)))
12330 } else {
12331 Err(::treesitter_types::ParseError::unexpected_kind(
12332 _other, node,
12333 ))
12334 }
12335 }
12336 }
12337 }
12338}
12339impl ::treesitter_types::Spanned for ArgumentListChildren<'_> {
12340 fn span(&self) -> ::treesitter_types::Span {
12341 match self {
12342 Self::CompoundStatement(inner) => inner.span(),
12343 Self::Expression(inner) => inner.span(),
12344 Self::InitializerList(inner) => inner.span(),
12345 Self::PreprocDefined(inner) => inner.span(),
12346 }
12347 }
12348}
12349#[derive(Debug, Clone)]
12350pub enum ArrayDeclaratorDeclarator<'tree> {
12351 Declarator(::std::boxed::Box<Declarator<'tree>>),
12352 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
12353 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
12354}
12355impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorDeclarator<'tree> {
12356 #[allow(clippy::collapsible_else_if)]
12357 fn from_node(
12358 node: ::tree_sitter::Node<'tree>,
12359 src: &'tree [u8],
12360 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12361 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
12362 Ok(Self::Declarator(::std::boxed::Box::new(v)))
12363 } else {
12364 if let Ok(v) = <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src) {
12365 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
12366 } else {
12367 if let Ok(v) =
12368 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12369 {
12370 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
12371 } else {
12372 Err(::treesitter_types::ParseError::unexpected_kind(
12373 node.kind(),
12374 node,
12375 ))
12376 }
12377 }
12378 }
12379 }
12380}
12381impl ::treesitter_types::Spanned for ArrayDeclaratorDeclarator<'_> {
12382 fn span(&self) -> ::treesitter_types::Span {
12383 match self {
12384 Self::Declarator(inner) => inner.span(),
12385 Self::FieldDeclarator(inner) => inner.span(),
12386 Self::TypeDeclarator(inner) => inner.span(),
12387 }
12388 }
12389}
12390#[derive(Debug, Clone)]
12391pub enum ArrayDeclaratorSize<'tree> {
12392 Star(::treesitter_types::Span),
12393 Expression(::std::boxed::Box<Expression<'tree>>),
12394}
12395impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayDeclaratorSize<'tree> {
12396 #[allow(clippy::collapsible_else_if)]
12397 fn from_node(
12398 node: ::tree_sitter::Node<'tree>,
12399 src: &'tree [u8],
12400 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12401 match node.kind() {
12402 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
12403 _other => {
12404 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12405 Ok(Self::Expression(::std::boxed::Box::new(v)))
12406 } else {
12407 Err(::treesitter_types::ParseError::unexpected_kind(
12408 _other, node,
12409 ))
12410 }
12411 }
12412 }
12413 }
12414}
12415impl ::treesitter_types::Spanned for ArrayDeclaratorSize<'_> {
12416 fn span(&self) -> ::treesitter_types::Span {
12417 match self {
12418 Self::Star(span) => *span,
12419 Self::Expression(inner) => inner.span(),
12420 }
12421 }
12422}
12423#[derive(Debug, Clone)]
12424pub enum AssignmentExpressionOperator {
12425 PercentEq(::treesitter_types::Span),
12426 AmpEq(::treesitter_types::Span),
12427 StarEq(::treesitter_types::Span),
12428 PlusEq(::treesitter_types::Span),
12429 MinusEq(::treesitter_types::Span),
12430 SlashEq(::treesitter_types::Span),
12431 ShlEq(::treesitter_types::Span),
12432 Eq(::treesitter_types::Span),
12433 ShrEq(::treesitter_types::Span),
12434 CaretEq(::treesitter_types::Span),
12435 AndEq(::treesitter_types::Span),
12436 OrEq(::treesitter_types::Span),
12437 XorEq(::treesitter_types::Span),
12438 PipeEq(::treesitter_types::Span),
12439}
12440impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionOperator {
12441 #[allow(clippy::collapsible_else_if)]
12442 fn from_node(
12443 node: ::tree_sitter::Node<'tree>,
12444 _src: &'tree [u8],
12445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12446 match node.kind() {
12447 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
12448 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
12449 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
12450 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
12451 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
12452 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
12453 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
12454 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
12455 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
12456 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
12457 "and_eq" => Ok(Self::AndEq(::treesitter_types::Span::from(node))),
12458 "or_eq" => Ok(Self::OrEq(::treesitter_types::Span::from(node))),
12459 "xor_eq" => Ok(Self::XorEq(::treesitter_types::Span::from(node))),
12460 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
12461 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12462 }
12463 }
12464}
12465impl ::treesitter_types::Spanned for AssignmentExpressionOperator {
12466 fn span(&self) -> ::treesitter_types::Span {
12467 match self {
12468 Self::PercentEq(span) => *span,
12469 Self::AmpEq(span) => *span,
12470 Self::StarEq(span) => *span,
12471 Self::PlusEq(span) => *span,
12472 Self::MinusEq(span) => *span,
12473 Self::SlashEq(span) => *span,
12474 Self::ShlEq(span) => *span,
12475 Self::Eq(span) => *span,
12476 Self::ShrEq(span) => *span,
12477 Self::CaretEq(span) => *span,
12478 Self::AndEq(span) => *span,
12479 Self::OrEq(span) => *span,
12480 Self::XorEq(span) => *span,
12481 Self::PipeEq(span) => *span,
12482 }
12483 }
12484}
12485#[derive(Debug, Clone)]
12486pub enum AssignmentExpressionRight<'tree> {
12487 Expression(::std::boxed::Box<Expression<'tree>>),
12488 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
12489}
12490impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionRight<'tree> {
12491 #[allow(clippy::collapsible_else_if)]
12492 fn from_node(
12493 node: ::tree_sitter::Node<'tree>,
12494 src: &'tree [u8],
12495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12496 match node.kind() {
12497 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
12498 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
12499 ))),
12500 _other => {
12501 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12502 Ok(Self::Expression(::std::boxed::Box::new(v)))
12503 } else {
12504 Err(::treesitter_types::ParseError::unexpected_kind(
12505 _other, node,
12506 ))
12507 }
12508 }
12509 }
12510 }
12511}
12512impl ::treesitter_types::Spanned for AssignmentExpressionRight<'_> {
12513 fn span(&self) -> ::treesitter_types::Span {
12514 match self {
12515 Self::Expression(inner) => inner.span(),
12516 Self::InitializerList(inner) => inner.span(),
12517 }
12518 }
12519}
12520#[derive(Debug, Clone)]
12521pub enum AttributedDeclaratorChildren<'tree> {
12522 Declarator(::std::boxed::Box<Declarator<'tree>>),
12523 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
12524 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
12525 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
12526}
12527impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedDeclaratorChildren<'tree> {
12528 #[allow(clippy::collapsible_else_if)]
12529 fn from_node(
12530 node: ::tree_sitter::Node<'tree>,
12531 src: &'tree [u8],
12532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12533 match node.kind() {
12534 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
12535 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
12536 ))),
12537 _other => {
12538 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
12539 Ok(Self::Declarator(::std::boxed::Box::new(v)))
12540 } else {
12541 if let Ok(v) =
12542 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12543 {
12544 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
12545 } else {
12546 if let Ok(v) =
12547 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
12548 {
12549 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
12550 } else {
12551 Err(::treesitter_types::ParseError::unexpected_kind(
12552 _other, node,
12553 ))
12554 }
12555 }
12556 }
12557 }
12558 }
12559 }
12560}
12561impl ::treesitter_types::Spanned for AttributedDeclaratorChildren<'_> {
12562 fn span(&self) -> ::treesitter_types::Span {
12563 match self {
12564 Self::Declarator(inner) => inner.span(),
12565 Self::FieldDeclarator(inner) => inner.span(),
12566 Self::TypeDeclarator(inner) => inner.span(),
12567 Self::AttributeDeclaration(inner) => inner.span(),
12568 }
12569 }
12570}
12571#[derive(Debug, Clone)]
12572pub enum AttributedStatementChildren<'tree> {
12573 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
12574 Statement(::std::boxed::Box<Statement<'tree>>),
12575}
12576impl<'tree> ::treesitter_types::FromNode<'tree> for AttributedStatementChildren<'tree> {
12577 #[allow(clippy::collapsible_else_if)]
12578 fn from_node(
12579 node: ::tree_sitter::Node<'tree>,
12580 src: &'tree [u8],
12581 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12582 match node.kind() {
12583 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
12584 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
12585 ))),
12586 _other => {
12587 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
12588 Ok(Self::Statement(::std::boxed::Box::new(v)))
12589 } else {
12590 Err(::treesitter_types::ParseError::unexpected_kind(
12591 _other, node,
12592 ))
12593 }
12594 }
12595 }
12596 }
12597}
12598impl ::treesitter_types::Spanned for AttributedStatementChildren<'_> {
12599 fn span(&self) -> ::treesitter_types::Span {
12600 match self {
12601 Self::AttributeDeclaration(inner) => inner.span(),
12602 Self::Statement(inner) => inner.span(),
12603 }
12604 }
12605}
12606#[derive(Debug, Clone)]
12607pub enum BaseClassClauseChildren<'tree> {
12608 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
12609 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
12610 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
12611 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
12612 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
12613}
12614impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClassClauseChildren<'tree> {
12615 #[allow(clippy::collapsible_else_if)]
12616 fn from_node(
12617 node: ::tree_sitter::Node<'tree>,
12618 src: &'tree [u8],
12619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12620 match node.kind() {
12621 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
12622 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12623 ))),
12624 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
12625 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
12626 ))),
12627 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
12628 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12629 ))),
12630 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
12631 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
12632 ))),
12633 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
12634 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12635 ))),
12636 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12637 }
12638 }
12639}
12640impl ::treesitter_types::Spanned for BaseClassClauseChildren<'_> {
12641 fn span(&self) -> ::treesitter_types::Span {
12642 match self {
12643 Self::AccessSpecifier(inner) => inner.span(),
12644 Self::AttributeDeclaration(inner) => inner.span(),
12645 Self::QualifiedIdentifier(inner) => inner.span(),
12646 Self::TemplateType(inner) => inner.span(),
12647 Self::TypeIdentifier(inner) => inner.span(),
12648 }
12649 }
12650}
12651#[derive(Debug, Clone)]
12652pub enum BinaryExpressionLeft<'tree> {
12653 Expression(::std::boxed::Box<Expression<'tree>>),
12654 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
12655}
12656impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
12657 #[allow(clippy::collapsible_else_if)]
12658 fn from_node(
12659 node: ::tree_sitter::Node<'tree>,
12660 src: &'tree [u8],
12661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12662 match node.kind() {
12663 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
12664 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
12665 ))),
12666 _other => {
12667 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12668 Ok(Self::Expression(::std::boxed::Box::new(v)))
12669 } else {
12670 Err(::treesitter_types::ParseError::unexpected_kind(
12671 _other, node,
12672 ))
12673 }
12674 }
12675 }
12676 }
12677}
12678impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
12679 fn span(&self) -> ::treesitter_types::Span {
12680 match self {
12681 Self::Expression(inner) => inner.span(),
12682 Self::PreprocDefined(inner) => inner.span(),
12683 }
12684 }
12685}
12686#[derive(Debug, Clone)]
12687pub enum BinaryExpressionOperator {
12688 NotEq(::treesitter_types::Span),
12689 Percent(::treesitter_types::Span),
12690 Amp(::treesitter_types::Span),
12691 AmpAmp(::treesitter_types::Span),
12692 Star(::treesitter_types::Span),
12693 Plus(::treesitter_types::Span),
12694 Minus(::treesitter_types::Span),
12695 Slash(::treesitter_types::Span),
12696 Lt(::treesitter_types::Span),
12697 Shl(::treesitter_types::Span),
12698 LtEq(::treesitter_types::Span),
12699 LtEqGt(::treesitter_types::Span),
12700 EqEq(::treesitter_types::Span),
12701 Gt(::treesitter_types::Span),
12702 GtEq(::treesitter_types::Span),
12703 Shr(::treesitter_types::Span),
12704 Caret(::treesitter_types::Span),
12705 And(::treesitter_types::Span),
12706 Bitand(::treesitter_types::Span),
12707 Bitor(::treesitter_types::Span),
12708 Or(::treesitter_types::Span),
12709 Xor(::treesitter_types::Span),
12710 Pipe(::treesitter_types::Span),
12711 PipePipe(::treesitter_types::Span),
12712}
12713impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
12714 #[allow(clippy::collapsible_else_if)]
12715 fn from_node(
12716 node: ::tree_sitter::Node<'tree>,
12717 _src: &'tree [u8],
12718 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12719 match node.kind() {
12720 "!=" | "not_eq" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
12721 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
12722 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
12723 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
12724 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
12725 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
12726 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
12727 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
12728 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
12729 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
12730 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
12731 "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
12732 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
12733 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
12734 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
12735 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
12736 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
12737 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
12738 "bitand" => Ok(Self::Bitand(::treesitter_types::Span::from(node))),
12739 "bitor" => Ok(Self::Bitor(::treesitter_types::Span::from(node))),
12740 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
12741 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
12742 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
12743 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
12744 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12745 }
12746 }
12747}
12748impl ::treesitter_types::Spanned for BinaryExpressionOperator {
12749 fn span(&self) -> ::treesitter_types::Span {
12750 match self {
12751 Self::NotEq(span) => *span,
12752 Self::Percent(span) => *span,
12753 Self::Amp(span) => *span,
12754 Self::AmpAmp(span) => *span,
12755 Self::Star(span) => *span,
12756 Self::Plus(span) => *span,
12757 Self::Minus(span) => *span,
12758 Self::Slash(span) => *span,
12759 Self::Lt(span) => *span,
12760 Self::Shl(span) => *span,
12761 Self::LtEq(span) => *span,
12762 Self::LtEqGt(span) => *span,
12763 Self::EqEq(span) => *span,
12764 Self::Gt(span) => *span,
12765 Self::GtEq(span) => *span,
12766 Self::Shr(span) => *span,
12767 Self::Caret(span) => *span,
12768 Self::And(span) => *span,
12769 Self::Bitand(span) => *span,
12770 Self::Bitor(span) => *span,
12771 Self::Or(span) => *span,
12772 Self::Xor(span) => *span,
12773 Self::Pipe(span) => *span,
12774 Self::PipePipe(span) => *span,
12775 }
12776 }
12777}
12778#[derive(Debug, Clone)]
12779pub enum BinaryExpressionRight<'tree> {
12780 Expression(::std::boxed::Box<Expression<'tree>>),
12781 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
12782}
12783impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
12784 #[allow(clippy::collapsible_else_if)]
12785 fn from_node(
12786 node: ::tree_sitter::Node<'tree>,
12787 src: &'tree [u8],
12788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12789 match node.kind() {
12790 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
12791 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
12792 ))),
12793 _other => {
12794 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12795 Ok(Self::Expression(::std::boxed::Box::new(v)))
12796 } else {
12797 Err(::treesitter_types::ParseError::unexpected_kind(
12798 _other, node,
12799 ))
12800 }
12801 }
12802 }
12803 }
12804}
12805impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
12806 fn span(&self) -> ::treesitter_types::Span {
12807 match self {
12808 Self::Expression(inner) => inner.span(),
12809 Self::PreprocDefined(inner) => inner.span(),
12810 }
12811 }
12812}
12813#[derive(Debug, Clone)]
12814pub enum CallExpressionFunction<'tree> {
12815 Expression(::std::boxed::Box<Expression<'tree>>),
12816 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12817}
12818impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
12819 #[allow(clippy::collapsible_else_if)]
12820 fn from_node(
12821 node: ::tree_sitter::Node<'tree>,
12822 src: &'tree [u8],
12823 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12824 match node.kind() {
12825 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12826 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
12827 ))),
12828 _other => {
12829 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12830 Ok(Self::Expression(::std::boxed::Box::new(v)))
12831 } else {
12832 Err(::treesitter_types::ParseError::unexpected_kind(
12833 _other, node,
12834 ))
12835 }
12836 }
12837 }
12838 }
12839}
12840impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
12841 fn span(&self) -> ::treesitter_types::Span {
12842 match self {
12843 Self::Expression(inner) => inner.span(),
12844 Self::PrimitiveType(inner) => inner.span(),
12845 }
12846 }
12847}
12848#[derive(Debug, Clone)]
12849pub enum CaseStatementChildren<'tree> {
12850 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
12851 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
12852 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
12853 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
12854 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
12855 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
12856 Declaration(::std::boxed::Box<Declaration<'tree>>),
12857 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
12858 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
12859 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
12860 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
12861 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
12862 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
12863 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
12864 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
12865 SehLeaveStatement(::std::boxed::Box<SehLeaveStatement<'tree>>),
12866 SehTryStatement(::std::boxed::Box<SehTryStatement<'tree>>),
12867 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
12868 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
12869 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
12870 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
12871 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
12872}
12873impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatementChildren<'tree> {
12874 #[allow(clippy::collapsible_else_if)]
12875 fn from_node(
12876 node: ::tree_sitter::Node<'tree>,
12877 src: &'tree [u8],
12878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12879 match node.kind() {
12880 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
12881 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12882 ))),
12883 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
12884 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12885 ))),
12886 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
12887 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12888 ))),
12889 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
12890 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12891 ))),
12892 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
12893 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12894 ))),
12895 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
12896 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12897 ))),
12898 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
12899 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
12900 ))),
12901 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
12902 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12903 ))),
12904 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
12905 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12906 ))),
12907 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
12908 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)?,
12909 ))),
12910 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
12911 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12912 ))),
12913 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
12914 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12915 ))),
12916 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
12917 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12918 ))),
12919 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
12920 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12921 ))),
12922 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
12923 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12924 ))),
12925 "seh_leave_statement" => Ok(Self::SehLeaveStatement(::std::boxed::Box::new(
12926 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12927 ))),
12928 "seh_try_statement" => Ok(Self::SehTryStatement(::std::boxed::Box::new(
12929 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12930 ))),
12931 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
12932 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12933 ))),
12934 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
12935 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12936 ))),
12937 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
12938 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12939 ))),
12940 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
12941 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
12942 ))),
12943 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
12944 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12945 ))),
12946 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12947 }
12948 }
12949}
12950impl ::treesitter_types::Spanned for CaseStatementChildren<'_> {
12951 fn span(&self) -> ::treesitter_types::Span {
12952 match self {
12953 Self::AttributedStatement(inner) => inner.span(),
12954 Self::BreakStatement(inner) => inner.span(),
12955 Self::CoReturnStatement(inner) => inner.span(),
12956 Self::CoYieldStatement(inner) => inner.span(),
12957 Self::CompoundStatement(inner) => inner.span(),
12958 Self::ContinueStatement(inner) => inner.span(),
12959 Self::Declaration(inner) => inner.span(),
12960 Self::DoStatement(inner) => inner.span(),
12961 Self::ExpressionStatement(inner) => inner.span(),
12962 Self::ForRangeLoop(inner) => inner.span(),
12963 Self::ForStatement(inner) => inner.span(),
12964 Self::GotoStatement(inner) => inner.span(),
12965 Self::IfStatement(inner) => inner.span(),
12966 Self::LabeledStatement(inner) => inner.span(),
12967 Self::ReturnStatement(inner) => inner.span(),
12968 Self::SehLeaveStatement(inner) => inner.span(),
12969 Self::SehTryStatement(inner) => inner.span(),
12970 Self::SwitchStatement(inner) => inner.span(),
12971 Self::ThrowStatement(inner) => inner.span(),
12972 Self::TryStatement(inner) => inner.span(),
12973 Self::TypeDefinition(inner) => inner.span(),
12974 Self::WhileStatement(inner) => inner.span(),
12975 }
12976 }
12977}
12978#[derive(Debug, Clone)]
12979pub enum CharLiteralChildren<'tree> {
12980 Character(::std::boxed::Box<Character<'tree>>),
12981 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
12982}
12983impl<'tree> ::treesitter_types::FromNode<'tree> for CharLiteralChildren<'tree> {
12984 #[allow(clippy::collapsible_else_if)]
12985 fn from_node(
12986 node: ::tree_sitter::Node<'tree>,
12987 src: &'tree [u8],
12988 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12989 match node.kind() {
12990 "character" => Ok(Self::Character(::std::boxed::Box::new(
12991 <Character as ::treesitter_types::FromNode>::from_node(node, src)?,
12992 ))),
12993 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
12994 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
12995 ))),
12996 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12997 }
12998 }
12999}
13000impl ::treesitter_types::Spanned for CharLiteralChildren<'_> {
13001 fn span(&self) -> ::treesitter_types::Span {
13002 match self {
13003 Self::Character(inner) => inner.span(),
13004 Self::EscapeSequence(inner) => inner.span(),
13005 }
13006 }
13007}
13008#[derive(Debug, Clone)]
13009pub enum ClassSpecifierName<'tree> {
13010 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
13011 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13012 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13013}
13014impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifierName<'tree> {
13015 #[allow(clippy::collapsible_else_if)]
13016 fn from_node(
13017 node: ::tree_sitter::Node<'tree>,
13018 src: &'tree [u8],
13019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13020 match node.kind() {
13021 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
13022 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13023 ))),
13024 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13025 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13026 ))),
13027 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13028 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13029 ))),
13030 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13031 }
13032 }
13033}
13034impl ::treesitter_types::Spanned for ClassSpecifierName<'_> {
13035 fn span(&self) -> ::treesitter_types::Span {
13036 match self {
13037 Self::QualifiedIdentifier(inner) => inner.span(),
13038 Self::TemplateType(inner) => inner.span(),
13039 Self::TypeIdentifier(inner) => inner.span(),
13040 }
13041 }
13042}
13043#[derive(Debug, Clone)]
13044pub enum ClassSpecifierChildren<'tree> {
13045 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
13046 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13047 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
13048 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
13049 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
13050 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
13051}
13052impl<'tree> ::treesitter_types::FromNode<'tree> for ClassSpecifierChildren<'tree> {
13053 #[allow(clippy::collapsible_else_if)]
13054 fn from_node(
13055 node: ::tree_sitter::Node<'tree>,
13056 src: &'tree [u8],
13057 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13058 match node.kind() {
13059 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
13060 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13061 ))),
13062 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13063 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13064 ))),
13065 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
13066 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13067 ))),
13068 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
13069 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)?,
13070 ))),
13071 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
13072 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13073 ))),
13074 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
13075 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13076 ))),
13077 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13078 }
13079 }
13080}
13081impl ::treesitter_types::Spanned for ClassSpecifierChildren<'_> {
13082 fn span(&self) -> ::treesitter_types::Span {
13083 match self {
13084 Self::AlignasQualifier(inner) => inner.span(),
13085 Self::AttributeDeclaration(inner) => inner.span(),
13086 Self::AttributeSpecifier(inner) => inner.span(),
13087 Self::BaseClassClause(inner) => inner.span(),
13088 Self::MsDeclspecModifier(inner) => inner.span(),
13089 Self::VirtualSpecifier(inner) => inner.span(),
13090 }
13091 }
13092}
13093#[derive(Debug, Clone)]
13094pub enum CoAwaitExpressionOperator {
13095 CoAwait(::treesitter_types::Span),
13096}
13097impl<'tree> ::treesitter_types::FromNode<'tree> for CoAwaitExpressionOperator {
13098 #[allow(clippy::collapsible_else_if)]
13099 fn from_node(
13100 node: ::tree_sitter::Node<'tree>,
13101 _src: &'tree [u8],
13102 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13103 match node.kind() {
13104 "co_await" => Ok(Self::CoAwait(::treesitter_types::Span::from(node))),
13105 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13106 }
13107 }
13108}
13109impl ::treesitter_types::Spanned for CoAwaitExpressionOperator {
13110 fn span(&self) -> ::treesitter_types::Span {
13111 match self {
13112 Self::CoAwait(span) => *span,
13113 }
13114 }
13115}
13116#[derive(Debug, Clone)]
13117pub enum CommaExpressionRight<'tree> {
13118 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
13119 Expression(::std::boxed::Box<Expression<'tree>>),
13120}
13121impl<'tree> ::treesitter_types::FromNode<'tree> for CommaExpressionRight<'tree> {
13122 #[allow(clippy::collapsible_else_if)]
13123 fn from_node(
13124 node: ::tree_sitter::Node<'tree>,
13125 src: &'tree [u8],
13126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13127 match node.kind() {
13128 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
13129 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13130 ))),
13131 _other => {
13132 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13133 Ok(Self::Expression(::std::boxed::Box::new(v)))
13134 } else {
13135 Err(::treesitter_types::ParseError::unexpected_kind(
13136 _other, node,
13137 ))
13138 }
13139 }
13140 }
13141 }
13142}
13143impl ::treesitter_types::Spanned for CommaExpressionRight<'_> {
13144 fn span(&self) -> ::treesitter_types::Span {
13145 match self {
13146 Self::CommaExpression(inner) => inner.span(),
13147 Self::Expression(inner) => inner.span(),
13148 }
13149 }
13150}
13151#[derive(Debug, Clone)]
13152pub enum CompoundLiteralExpressionType<'tree> {
13153 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13154 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
13155 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13156 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
13157 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13158}
13159impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundLiteralExpressionType<'tree> {
13160 #[allow(clippy::collapsible_else_if)]
13161 fn from_node(
13162 node: ::tree_sitter::Node<'tree>,
13163 src: &'tree [u8],
13164 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13165 match node.kind() {
13166 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13167 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
13168 ))),
13169 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
13170 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13171 ))),
13172 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13173 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13174 ))),
13175 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
13176 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)?,
13177 ))),
13178 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13179 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13180 ))),
13181 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13182 }
13183 }
13184}
13185impl ::treesitter_types::Spanned for CompoundLiteralExpressionType<'_> {
13186 fn span(&self) -> ::treesitter_types::Span {
13187 match self {
13188 Self::PrimitiveType(inner) => inner.span(),
13189 Self::QualifiedIdentifier(inner) => inner.span(),
13190 Self::TemplateType(inner) => inner.span(),
13191 Self::TypeDescriptor(inner) => inner.span(),
13192 Self::TypeIdentifier(inner) => inner.span(),
13193 }
13194 }
13195}
13196#[derive(Debug, Clone)]
13197pub enum CompoundRequirementChildren<'tree> {
13198 Expression(::std::boxed::Box<Expression<'tree>>),
13199 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
13200}
13201impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundRequirementChildren<'tree> {
13202 #[allow(clippy::collapsible_else_if)]
13203 fn from_node(
13204 node: ::tree_sitter::Node<'tree>,
13205 src: &'tree [u8],
13206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13207 match node.kind() {
13208 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
13209 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)?,
13210 ))),
13211 _other => {
13212 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13213 Ok(Self::Expression(::std::boxed::Box::new(v)))
13214 } else {
13215 Err(::treesitter_types::ParseError::unexpected_kind(
13216 _other, node,
13217 ))
13218 }
13219 }
13220 }
13221 }
13222}
13223impl ::treesitter_types::Spanned for CompoundRequirementChildren<'_> {
13224 fn span(&self) -> ::treesitter_types::Span {
13225 match self {
13226 Self::Expression(inner) => inner.span(),
13227 Self::TrailingReturnType(inner) => inner.span(),
13228 }
13229 }
13230}
13231#[derive(Debug, Clone)]
13232pub enum CompoundStatementChildren<'tree> {
13233 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
13234 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
13235 Declaration(::std::boxed::Box<Declaration<'tree>>),
13236 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
13237 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
13238 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
13239 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
13240 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
13241 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
13242 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
13243 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
13244 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
13245 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
13246 Statement(::std::boxed::Box<Statement<'tree>>),
13247 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
13248 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
13249 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
13250 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
13251 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
13252 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
13253}
13254impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatementChildren<'tree> {
13255 #[allow(clippy::collapsible_else_if)]
13256 fn from_node(
13257 node: ::tree_sitter::Node<'tree>,
13258 src: &'tree [u8],
13259 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13260 match node.kind() {
13261 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
13262 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13263 ))),
13264 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
13265 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13266 ))),
13267 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
13268 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13269 ))),
13270 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
13271 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13272 ))),
13273 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
13274 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
13275 ))),
13276 "namespace_alias_definition" => {
13277 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
13278 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
13279 node, src,
13280 )?,
13281 )))
13282 }
13283 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
13284 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13285 ))),
13286 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
13287 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
13288 ))),
13289 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
13290 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
13291 ))),
13292 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
13293 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
13294 ))),
13295 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
13296 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
13297 ))),
13298 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
13299 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
13300 ))),
13301 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
13302 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
13303 ))),
13304 "static_assert_declaration" => {
13305 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
13306 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
13307 node, src,
13308 )?,
13309 )))
13310 }
13311 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
13312 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13313 ))),
13314 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
13315 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
13316 ))),
13317 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
13318 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13319 ))),
13320 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
13321 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13322 ))),
13323 _other => {
13324 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
13325 Ok(Self::Statement(::std::boxed::Box::new(v)))
13326 } else {
13327 if let Ok(v) =
13328 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13329 {
13330 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
13331 } else {
13332 Err(::treesitter_types::ParseError::unexpected_kind(
13333 _other, node,
13334 ))
13335 }
13336 }
13337 }
13338 }
13339 }
13340}
13341impl ::treesitter_types::Spanned for CompoundStatementChildren<'_> {
13342 fn span(&self) -> ::treesitter_types::Span {
13343 match self {
13344 Self::AliasDeclaration(inner) => inner.span(),
13345 Self::ConceptDefinition(inner) => inner.span(),
13346 Self::Declaration(inner) => inner.span(),
13347 Self::FunctionDefinition(inner) => inner.span(),
13348 Self::LinkageSpecification(inner) => inner.span(),
13349 Self::NamespaceAliasDefinition(inner) => inner.span(),
13350 Self::NamespaceDefinition(inner) => inner.span(),
13351 Self::PreprocCall(inner) => inner.span(),
13352 Self::PreprocDef(inner) => inner.span(),
13353 Self::PreprocFunctionDef(inner) => inner.span(),
13354 Self::PreprocIf(inner) => inner.span(),
13355 Self::PreprocIfdef(inner) => inner.span(),
13356 Self::PreprocInclude(inner) => inner.span(),
13357 Self::Statement(inner) => inner.span(),
13358 Self::StaticAssertDeclaration(inner) => inner.span(),
13359 Self::TemplateDeclaration(inner) => inner.span(),
13360 Self::TemplateInstantiation(inner) => inner.span(),
13361 Self::TypeDefinition(inner) => inner.span(),
13362 Self::TypeSpecifier(inner) => inner.span(),
13363 Self::UsingDeclaration(inner) => inner.span(),
13364 }
13365 }
13366}
13367#[derive(Debug, Clone)]
13368pub enum ConcatenatedStringChildren<'tree> {
13369 Identifier(::std::boxed::Box<Identifier<'tree>>),
13370 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
13371 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
13372}
13373impl<'tree> ::treesitter_types::FromNode<'tree> for ConcatenatedStringChildren<'tree> {
13374 #[allow(clippy::collapsible_else_if)]
13375 fn from_node(
13376 node: ::tree_sitter::Node<'tree>,
13377 src: &'tree [u8],
13378 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13379 match node.kind() {
13380 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13381 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13382 ))),
13383 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
13384 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
13385 ))),
13386 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
13387 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
13388 ))),
13389 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13390 }
13391 }
13392}
13393impl ::treesitter_types::Spanned for ConcatenatedStringChildren<'_> {
13394 fn span(&self) -> ::treesitter_types::Span {
13395 match self {
13396 Self::Identifier(inner) => inner.span(),
13397 Self::RawStringLiteral(inner) => inner.span(),
13398 Self::StringLiteral(inner) => inner.span(),
13399 }
13400 }
13401}
13402#[derive(Debug, Clone)]
13403pub enum ConditionClauseValue<'tree> {
13404 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
13405 Declaration(::std::boxed::Box<Declaration<'tree>>),
13406 Expression(::std::boxed::Box<Expression<'tree>>),
13407}
13408impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionClauseValue<'tree> {
13409 #[allow(clippy::collapsible_else_if)]
13410 fn from_node(
13411 node: ::tree_sitter::Node<'tree>,
13412 src: &'tree [u8],
13413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13414 match node.kind() {
13415 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
13416 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13417 ))),
13418 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
13419 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13420 ))),
13421 _other => {
13422 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13423 Ok(Self::Expression(::std::boxed::Box::new(v)))
13424 } else {
13425 Err(::treesitter_types::ParseError::unexpected_kind(
13426 _other, node,
13427 ))
13428 }
13429 }
13430 }
13431 }
13432}
13433impl ::treesitter_types::Spanned for ConditionClauseValue<'_> {
13434 fn span(&self) -> ::treesitter_types::Span {
13435 match self {
13436 Self::CommaExpression(inner) => inner.span(),
13437 Self::Declaration(inner) => inner.span(),
13438 Self::Expression(inner) => inner.span(),
13439 }
13440 }
13441}
13442#[derive(Debug, Clone)]
13443pub enum ConditionalExpressionConsequence<'tree> {
13444 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
13445 Expression(::std::boxed::Box<Expression<'tree>>),
13446}
13447impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpressionConsequence<'tree> {
13448 #[allow(clippy::collapsible_else_if)]
13449 fn from_node(
13450 node: ::tree_sitter::Node<'tree>,
13451 src: &'tree [u8],
13452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13453 match node.kind() {
13454 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
13455 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13456 ))),
13457 _other => {
13458 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13459 Ok(Self::Expression(::std::boxed::Box::new(v)))
13460 } else {
13461 Err(::treesitter_types::ParseError::unexpected_kind(
13462 _other, node,
13463 ))
13464 }
13465 }
13466 }
13467 }
13468}
13469impl ::treesitter_types::Spanned for ConditionalExpressionConsequence<'_> {
13470 fn span(&self) -> ::treesitter_types::Span {
13471 match self {
13472 Self::CommaExpression(inner) => inner.span(),
13473 Self::Expression(inner) => inner.span(),
13474 }
13475 }
13476}
13477#[derive(Debug, Clone)]
13478pub enum ConstraintConjunctionLeft<'tree> {
13479 LParen(::treesitter_types::Span),
13480 RParen(::treesitter_types::Span),
13481 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
13482 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
13483 Expression(::std::boxed::Box<Expression<'tree>>),
13484 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13485 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13486}
13487impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionLeft<'tree> {
13488 #[allow(clippy::collapsible_else_if)]
13489 fn from_node(
13490 node: ::tree_sitter::Node<'tree>,
13491 src: &'tree [u8],
13492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13493 match node.kind() {
13494 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
13495 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
13496 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
13497 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13498 ))),
13499 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
13500 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13501 ))),
13502 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13503 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13504 ))),
13505 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13506 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13507 ))),
13508 _other => {
13509 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13510 Ok(Self::Expression(::std::boxed::Box::new(v)))
13511 } else {
13512 Err(::treesitter_types::ParseError::unexpected_kind(
13513 _other, node,
13514 ))
13515 }
13516 }
13517 }
13518 }
13519}
13520impl ::treesitter_types::Spanned for ConstraintConjunctionLeft<'_> {
13521 fn span(&self) -> ::treesitter_types::Span {
13522 match self {
13523 Self::LParen(span) => *span,
13524 Self::RParen(span) => *span,
13525 Self::ConstraintConjunction(inner) => inner.span(),
13526 Self::ConstraintDisjunction(inner) => inner.span(),
13527 Self::Expression(inner) => inner.span(),
13528 Self::TemplateType(inner) => inner.span(),
13529 Self::TypeIdentifier(inner) => inner.span(),
13530 }
13531 }
13532}
13533#[derive(Debug, Clone)]
13534pub enum ConstraintConjunctionOperator {
13535 AmpAmp(::treesitter_types::Span),
13536 And(::treesitter_types::Span),
13537}
13538impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionOperator {
13539 #[allow(clippy::collapsible_else_if)]
13540 fn from_node(
13541 node: ::tree_sitter::Node<'tree>,
13542 _src: &'tree [u8],
13543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13544 match node.kind() {
13545 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
13546 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
13547 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13548 }
13549 }
13550}
13551impl ::treesitter_types::Spanned for ConstraintConjunctionOperator {
13552 fn span(&self) -> ::treesitter_types::Span {
13553 match self {
13554 Self::AmpAmp(span) => *span,
13555 Self::And(span) => *span,
13556 }
13557 }
13558}
13559#[derive(Debug, Clone)]
13560pub enum ConstraintConjunctionRight<'tree> {
13561 LParen(::treesitter_types::Span),
13562 RParen(::treesitter_types::Span),
13563 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
13564 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
13565 Expression(::std::boxed::Box<Expression<'tree>>),
13566 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13567 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13568}
13569impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintConjunctionRight<'tree> {
13570 #[allow(clippy::collapsible_else_if)]
13571 fn from_node(
13572 node: ::tree_sitter::Node<'tree>,
13573 src: &'tree [u8],
13574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13575 match node.kind() {
13576 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
13577 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
13578 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
13579 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13580 ))),
13581 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
13582 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13583 ))),
13584 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13585 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13586 ))),
13587 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13588 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13589 ))),
13590 _other => {
13591 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13592 Ok(Self::Expression(::std::boxed::Box::new(v)))
13593 } else {
13594 Err(::treesitter_types::ParseError::unexpected_kind(
13595 _other, node,
13596 ))
13597 }
13598 }
13599 }
13600 }
13601}
13602impl ::treesitter_types::Spanned for ConstraintConjunctionRight<'_> {
13603 fn span(&self) -> ::treesitter_types::Span {
13604 match self {
13605 Self::LParen(span) => *span,
13606 Self::RParen(span) => *span,
13607 Self::ConstraintConjunction(inner) => inner.span(),
13608 Self::ConstraintDisjunction(inner) => inner.span(),
13609 Self::Expression(inner) => inner.span(),
13610 Self::TemplateType(inner) => inner.span(),
13611 Self::TypeIdentifier(inner) => inner.span(),
13612 }
13613 }
13614}
13615#[derive(Debug, Clone)]
13616pub enum ConstraintDisjunctionLeft<'tree> {
13617 LParen(::treesitter_types::Span),
13618 RParen(::treesitter_types::Span),
13619 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
13620 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
13621 Expression(::std::boxed::Box<Expression<'tree>>),
13622 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13623 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13624}
13625impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionLeft<'tree> {
13626 #[allow(clippy::collapsible_else_if)]
13627 fn from_node(
13628 node: ::tree_sitter::Node<'tree>,
13629 src: &'tree [u8],
13630 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13631 match node.kind() {
13632 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
13633 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
13634 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
13635 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13636 ))),
13637 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
13638 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13639 ))),
13640 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13641 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13642 ))),
13643 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13644 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13645 ))),
13646 _other => {
13647 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13648 Ok(Self::Expression(::std::boxed::Box::new(v)))
13649 } else {
13650 Err(::treesitter_types::ParseError::unexpected_kind(
13651 _other, node,
13652 ))
13653 }
13654 }
13655 }
13656 }
13657}
13658impl ::treesitter_types::Spanned for ConstraintDisjunctionLeft<'_> {
13659 fn span(&self) -> ::treesitter_types::Span {
13660 match self {
13661 Self::LParen(span) => *span,
13662 Self::RParen(span) => *span,
13663 Self::ConstraintConjunction(inner) => inner.span(),
13664 Self::ConstraintDisjunction(inner) => inner.span(),
13665 Self::Expression(inner) => inner.span(),
13666 Self::TemplateType(inner) => inner.span(),
13667 Self::TypeIdentifier(inner) => inner.span(),
13668 }
13669 }
13670}
13671#[derive(Debug, Clone)]
13672pub enum ConstraintDisjunctionOperator {
13673 Or(::treesitter_types::Span),
13674 PipePipe(::treesitter_types::Span),
13675}
13676impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionOperator {
13677 #[allow(clippy::collapsible_else_if)]
13678 fn from_node(
13679 node: ::tree_sitter::Node<'tree>,
13680 _src: &'tree [u8],
13681 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13682 match node.kind() {
13683 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
13684 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
13685 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13686 }
13687 }
13688}
13689impl ::treesitter_types::Spanned for ConstraintDisjunctionOperator {
13690 fn span(&self) -> ::treesitter_types::Span {
13691 match self {
13692 Self::Or(span) => *span,
13693 Self::PipePipe(span) => *span,
13694 }
13695 }
13696}
13697#[derive(Debug, Clone)]
13698pub enum ConstraintDisjunctionRight<'tree> {
13699 LParen(::treesitter_types::Span),
13700 RParen(::treesitter_types::Span),
13701 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
13702 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
13703 Expression(::std::boxed::Box<Expression<'tree>>),
13704 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13705 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
13706}
13707impl<'tree> ::treesitter_types::FromNode<'tree> for ConstraintDisjunctionRight<'tree> {
13708 #[allow(clippy::collapsible_else_if)]
13709 fn from_node(
13710 node: ::tree_sitter::Node<'tree>,
13711 src: &'tree [u8],
13712 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13713 match node.kind() {
13714 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
13715 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
13716 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
13717 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13718 ))),
13719 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
13720 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
13721 ))),
13722 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13723 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13724 ))),
13725 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
13726 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13727 ))),
13728 _other => {
13729 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13730 Ok(Self::Expression(::std::boxed::Box::new(v)))
13731 } else {
13732 Err(::treesitter_types::ParseError::unexpected_kind(
13733 _other, node,
13734 ))
13735 }
13736 }
13737 }
13738 }
13739}
13740impl ::treesitter_types::Spanned for ConstraintDisjunctionRight<'_> {
13741 fn span(&self) -> ::treesitter_types::Span {
13742 match self {
13743 Self::LParen(span) => *span,
13744 Self::RParen(span) => *span,
13745 Self::ConstraintConjunction(inner) => inner.span(),
13746 Self::ConstraintDisjunction(inner) => inner.span(),
13747 Self::Expression(inner) => inner.span(),
13748 Self::TemplateType(inner) => inner.span(),
13749 Self::TypeIdentifier(inner) => inner.span(),
13750 }
13751 }
13752}
13753#[derive(Debug, Clone)]
13754pub enum DeclarationDeclarator<'tree> {
13755 Declarator(::std::boxed::Box<Declarator<'tree>>),
13756 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
13757 InitDeclarator(::std::boxed::Box<InitDeclarator<'tree>>),
13758 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
13759}
13760impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationDeclarator<'tree> {
13761 #[allow(clippy::collapsible_else_if)]
13762 fn from_node(
13763 node: ::tree_sitter::Node<'tree>,
13764 src: &'tree [u8],
13765 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13766 match node.kind() {
13767 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
13768 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13769 ))),
13770 "init_declarator" => Ok(Self::InitDeclarator(::std::boxed::Box::new(
13771 <InitDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
13772 ))),
13773 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
13774 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)?,
13775 ))),
13776 _other => {
13777 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
13778 Ok(Self::Declarator(::std::boxed::Box::new(v)))
13779 } else {
13780 Err(::treesitter_types::ParseError::unexpected_kind(
13781 _other, node,
13782 ))
13783 }
13784 }
13785 }
13786 }
13787}
13788impl ::treesitter_types::Spanned for DeclarationDeclarator<'_> {
13789 fn span(&self) -> ::treesitter_types::Span {
13790 match self {
13791 Self::Declarator(inner) => inner.span(),
13792 Self::GnuAsmExpression(inner) => inner.span(),
13793 Self::InitDeclarator(inner) => inner.span(),
13794 Self::OperatorCast(inner) => inner.span(),
13795 }
13796 }
13797}
13798#[derive(Debug, Clone)]
13799pub enum DeclarationValue<'tree> {
13800 Expression(::std::boxed::Box<Expression<'tree>>),
13801 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
13802}
13803impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationValue<'tree> {
13804 #[allow(clippy::collapsible_else_if)]
13805 fn from_node(
13806 node: ::tree_sitter::Node<'tree>,
13807 src: &'tree [u8],
13808 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13809 match node.kind() {
13810 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
13811 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
13812 ))),
13813 _other => {
13814 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13815 Ok(Self::Expression(::std::boxed::Box::new(v)))
13816 } else {
13817 Err(::treesitter_types::ParseError::unexpected_kind(
13818 _other, node,
13819 ))
13820 }
13821 }
13822 }
13823 }
13824}
13825impl ::treesitter_types::Spanned for DeclarationValue<'_> {
13826 fn span(&self) -> ::treesitter_types::Span {
13827 match self {
13828 Self::Expression(inner) => inner.span(),
13829 Self::InitializerList(inner) => inner.span(),
13830 }
13831 }
13832}
13833#[derive(Debug, Clone)]
13834pub enum DeclarationChildren<'tree> {
13835 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
13836 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
13837 ExplicitFunctionSpecifier(::std::boxed::Box<ExplicitFunctionSpecifier<'tree>>),
13838 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
13839 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
13840 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
13841}
13842impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationChildren<'tree> {
13843 #[allow(clippy::collapsible_else_if)]
13844 fn from_node(
13845 node: ::tree_sitter::Node<'tree>,
13846 src: &'tree [u8],
13847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13848 match node.kind() {
13849 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
13850 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13851 ))),
13852 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
13853 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13854 ))),
13855 "explicit_function_specifier" => {
13856 Ok(Self::ExplicitFunctionSpecifier(::std::boxed::Box::new(
13857 <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(
13858 node, src,
13859 )?,
13860 )))
13861 }
13862 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
13863 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13864 ))),
13865 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
13866 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13867 ))),
13868 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
13869 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13870 ))),
13871 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13872 }
13873 }
13874}
13875impl ::treesitter_types::Spanned for DeclarationChildren<'_> {
13876 fn span(&self) -> ::treesitter_types::Span {
13877 match self {
13878 Self::AttributeDeclaration(inner) => inner.span(),
13879 Self::AttributeSpecifier(inner) => inner.span(),
13880 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
13881 Self::MsDeclspecModifier(inner) => inner.span(),
13882 Self::StorageClassSpecifier(inner) => inner.span(),
13883 Self::TypeQualifier(inner) => inner.span(),
13884 }
13885 }
13886}
13887#[derive(Debug, Clone)]
13888pub enum DeclarationListChildren<'tree> {
13889 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
13890 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
13891 Declaration(::std::boxed::Box<Declaration<'tree>>),
13892 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
13893 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
13894 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
13895 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
13896 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
13897 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
13898 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
13899 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
13900 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
13901 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
13902 Statement(::std::boxed::Box<Statement<'tree>>),
13903 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
13904 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
13905 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
13906 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
13907 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
13908 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
13909}
13910impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationListChildren<'tree> {
13911 #[allow(clippy::collapsible_else_if)]
13912 fn from_node(
13913 node: ::tree_sitter::Node<'tree>,
13914 src: &'tree [u8],
13915 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13916 match node.kind() {
13917 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
13918 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13919 ))),
13920 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
13921 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13922 ))),
13923 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
13924 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13925 ))),
13926 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
13927 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13928 ))),
13929 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
13930 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
13931 ))),
13932 "namespace_alias_definition" => {
13933 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
13934 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
13935 node, src,
13936 )?,
13937 )))
13938 }
13939 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
13940 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13941 ))),
13942 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
13943 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
13944 ))),
13945 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
13946 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
13947 ))),
13948 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
13949 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
13950 ))),
13951 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
13952 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
13953 ))),
13954 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
13955 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
13956 ))),
13957 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
13958 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
13959 ))),
13960 "static_assert_declaration" => {
13961 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
13962 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
13963 node, src,
13964 )?,
13965 )))
13966 }
13967 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
13968 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13969 ))),
13970 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
13971 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
13972 ))),
13973 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
13974 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
13975 ))),
13976 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
13977 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
13978 ))),
13979 _other => {
13980 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
13981 Ok(Self::Statement(::std::boxed::Box::new(v)))
13982 } else {
13983 if let Ok(v) =
13984 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13985 {
13986 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
13987 } else {
13988 Err(::treesitter_types::ParseError::unexpected_kind(
13989 _other, node,
13990 ))
13991 }
13992 }
13993 }
13994 }
13995 }
13996}
13997impl ::treesitter_types::Spanned for DeclarationListChildren<'_> {
13998 fn span(&self) -> ::treesitter_types::Span {
13999 match self {
14000 Self::AliasDeclaration(inner) => inner.span(),
14001 Self::ConceptDefinition(inner) => inner.span(),
14002 Self::Declaration(inner) => inner.span(),
14003 Self::FunctionDefinition(inner) => inner.span(),
14004 Self::LinkageSpecification(inner) => inner.span(),
14005 Self::NamespaceAliasDefinition(inner) => inner.span(),
14006 Self::NamespaceDefinition(inner) => inner.span(),
14007 Self::PreprocCall(inner) => inner.span(),
14008 Self::PreprocDef(inner) => inner.span(),
14009 Self::PreprocFunctionDef(inner) => inner.span(),
14010 Self::PreprocIf(inner) => inner.span(),
14011 Self::PreprocIfdef(inner) => inner.span(),
14012 Self::PreprocInclude(inner) => inner.span(),
14013 Self::Statement(inner) => inner.span(),
14014 Self::StaticAssertDeclaration(inner) => inner.span(),
14015 Self::TemplateDeclaration(inner) => inner.span(),
14016 Self::TemplateInstantiation(inner) => inner.span(),
14017 Self::TypeDefinition(inner) => inner.span(),
14018 Self::TypeSpecifier(inner) => inner.span(),
14019 Self::UsingDeclaration(inner) => inner.span(),
14020 }
14021 }
14022}
14023#[derive(Debug, Clone)]
14024pub enum DecltypeChildren<'tree> {
14025 Auto(::std::boxed::Box<Auto<'tree>>),
14026 Expression(::std::boxed::Box<Expression<'tree>>),
14027}
14028impl<'tree> ::treesitter_types::FromNode<'tree> for DecltypeChildren<'tree> {
14029 #[allow(clippy::collapsible_else_if)]
14030 fn from_node(
14031 node: ::tree_sitter::Node<'tree>,
14032 src: &'tree [u8],
14033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14034 match node.kind() {
14035 "auto" => Ok(Self::Auto(::std::boxed::Box::new(
14036 <Auto as ::treesitter_types::FromNode>::from_node(node, src)?,
14037 ))),
14038 _other => {
14039 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14040 Ok(Self::Expression(::std::boxed::Box::new(v)))
14041 } else {
14042 Err(::treesitter_types::ParseError::unexpected_kind(
14043 _other, node,
14044 ))
14045 }
14046 }
14047 }
14048 }
14049}
14050impl ::treesitter_types::Spanned for DecltypeChildren<'_> {
14051 fn span(&self) -> ::treesitter_types::Span {
14052 match self {
14053 Self::Auto(inner) => inner.span(),
14054 Self::Expression(inner) => inner.span(),
14055 }
14056 }
14057}
14058#[derive(Debug, Clone)]
14059pub enum DependentNameChildren<'tree> {
14060 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
14061 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
14062 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14063}
14064impl<'tree> ::treesitter_types::FromNode<'tree> for DependentNameChildren<'tree> {
14065 #[allow(clippy::collapsible_else_if)]
14066 fn from_node(
14067 node: ::tree_sitter::Node<'tree>,
14068 src: &'tree [u8],
14069 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14070 match node.kind() {
14071 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
14072 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
14073 ))),
14074 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
14075 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
14076 ))),
14077 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14078 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
14079 ))),
14080 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14081 }
14082 }
14083}
14084impl ::treesitter_types::Spanned for DependentNameChildren<'_> {
14085 fn span(&self) -> ::treesitter_types::Span {
14086 match self {
14087 Self::TemplateFunction(inner) => inner.span(),
14088 Self::TemplateMethod(inner) => inner.span(),
14089 Self::TemplateType(inner) => inner.span(),
14090 }
14091 }
14092}
14093#[derive(Debug, Clone)]
14094pub enum EnumSpecifierBase<'tree> {
14095 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
14096 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14097 SizedTypeSpecifier(::std::boxed::Box<SizedTypeSpecifier<'tree>>),
14098 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14099}
14100impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifierBase<'tree> {
14101 #[allow(clippy::collapsible_else_if)]
14102 fn from_node(
14103 node: ::tree_sitter::Node<'tree>,
14104 src: &'tree [u8],
14105 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14106 match node.kind() {
14107 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
14108 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
14109 ))),
14110 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14111 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14112 ))),
14113 "sized_type_specifier" => Ok(Self::SizedTypeSpecifier(::std::boxed::Box::new(
14114 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14115 ))),
14116 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14117 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14118 ))),
14119 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14120 }
14121 }
14122}
14123impl ::treesitter_types::Spanned for EnumSpecifierBase<'_> {
14124 fn span(&self) -> ::treesitter_types::Span {
14125 match self {
14126 Self::PrimitiveType(inner) => inner.span(),
14127 Self::QualifiedIdentifier(inner) => inner.span(),
14128 Self::SizedTypeSpecifier(inner) => inner.span(),
14129 Self::TypeIdentifier(inner) => inner.span(),
14130 }
14131 }
14132}
14133#[derive(Debug, Clone)]
14134pub enum EnumSpecifierName<'tree> {
14135 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14136 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14137 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14138}
14139impl<'tree> ::treesitter_types::FromNode<'tree> for EnumSpecifierName<'tree> {
14140 #[allow(clippy::collapsible_else_if)]
14141 fn from_node(
14142 node: ::tree_sitter::Node<'tree>,
14143 src: &'tree [u8],
14144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14145 match node.kind() {
14146 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14147 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14148 ))),
14149 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14150 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
14151 ))),
14152 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14153 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14154 ))),
14155 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14156 }
14157 }
14158}
14159impl ::treesitter_types::Spanned for EnumSpecifierName<'_> {
14160 fn span(&self) -> ::treesitter_types::Span {
14161 match self {
14162 Self::QualifiedIdentifier(inner) => inner.span(),
14163 Self::TemplateType(inner) => inner.span(),
14164 Self::TypeIdentifier(inner) => inner.span(),
14165 }
14166 }
14167}
14168#[derive(Debug, Clone)]
14169pub enum EnumeratorListChildren<'tree> {
14170 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
14171 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
14172 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14173 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
14174}
14175impl<'tree> ::treesitter_types::FromNode<'tree> for EnumeratorListChildren<'tree> {
14176 #[allow(clippy::collapsible_else_if)]
14177 fn from_node(
14178 node: ::tree_sitter::Node<'tree>,
14179 src: &'tree [u8],
14180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14181 match node.kind() {
14182 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
14183 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
14184 ))),
14185 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
14186 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
14187 ))),
14188 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14189 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
14190 ))),
14191 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
14192 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
14193 ))),
14194 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14195 }
14196 }
14197}
14198impl ::treesitter_types::Spanned for EnumeratorListChildren<'_> {
14199 fn span(&self) -> ::treesitter_types::Span {
14200 match self {
14201 Self::Enumerator(inner) => inner.span(),
14202 Self::PreprocCall(inner) => inner.span(),
14203 Self::PreprocIf(inner) => inner.span(),
14204 Self::PreprocIfdef(inner) => inner.span(),
14205 }
14206 }
14207}
14208#[derive(Debug, Clone)]
14209pub enum ExpressionStatementChildren<'tree> {
14210 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14211 Expression(::std::boxed::Box<Expression<'tree>>),
14212}
14213impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
14214 #[allow(clippy::collapsible_else_if)]
14215 fn from_node(
14216 node: ::tree_sitter::Node<'tree>,
14217 src: &'tree [u8],
14218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14219 match node.kind() {
14220 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14221 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14222 ))),
14223 _other => {
14224 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14225 Ok(Self::Expression(::std::boxed::Box::new(v)))
14226 } else {
14227 Err(::treesitter_types::ParseError::unexpected_kind(
14228 _other, node,
14229 ))
14230 }
14231 }
14232 }
14233 }
14234}
14235impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
14236 fn span(&self) -> ::treesitter_types::Span {
14237 match self {
14238 Self::CommaExpression(inner) => inner.span(),
14239 Self::Expression(inner) => inner.span(),
14240 }
14241 }
14242}
14243#[derive(Debug, Clone)]
14244pub enum FieldDeclarationDefaultValue<'tree> {
14245 Expression(::std::boxed::Box<Expression<'tree>>),
14246 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
14247}
14248impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationDefaultValue<'tree> {
14249 #[allow(clippy::collapsible_else_if)]
14250 fn from_node(
14251 node: ::tree_sitter::Node<'tree>,
14252 src: &'tree [u8],
14253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14254 match node.kind() {
14255 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
14256 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
14257 ))),
14258 _other => {
14259 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14260 Ok(Self::Expression(::std::boxed::Box::new(v)))
14261 } else {
14262 Err(::treesitter_types::ParseError::unexpected_kind(
14263 _other, node,
14264 ))
14265 }
14266 }
14267 }
14268 }
14269}
14270impl ::treesitter_types::Spanned for FieldDeclarationDefaultValue<'_> {
14271 fn span(&self) -> ::treesitter_types::Span {
14272 match self {
14273 Self::Expression(inner) => inner.span(),
14274 Self::InitializerList(inner) => inner.span(),
14275 }
14276 }
14277}
14278#[derive(Debug, Clone)]
14279pub enum FieldDeclarationChildren<'tree> {
14280 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
14281 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
14282 BitfieldClause(::std::boxed::Box<BitfieldClause<'tree>>),
14283 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
14284 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
14285 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
14286}
14287impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationChildren<'tree> {
14288 #[allow(clippy::collapsible_else_if)]
14289 fn from_node(
14290 node: ::tree_sitter::Node<'tree>,
14291 src: &'tree [u8],
14292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14293 match node.kind() {
14294 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
14295 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14296 ))),
14297 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
14298 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14299 ))),
14300 "bitfield_clause" => Ok(Self::BitfieldClause(::std::boxed::Box::new(
14301 <BitfieldClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14302 ))),
14303 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
14304 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14305 ))),
14306 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
14307 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14308 ))),
14309 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
14310 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14311 ))),
14312 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14313 }
14314 }
14315}
14316impl ::treesitter_types::Spanned for FieldDeclarationChildren<'_> {
14317 fn span(&self) -> ::treesitter_types::Span {
14318 match self {
14319 Self::AttributeDeclaration(inner) => inner.span(),
14320 Self::AttributeSpecifier(inner) => inner.span(),
14321 Self::BitfieldClause(inner) => inner.span(),
14322 Self::MsDeclspecModifier(inner) => inner.span(),
14323 Self::StorageClassSpecifier(inner) => inner.span(),
14324 Self::TypeQualifier(inner) => inner.span(),
14325 }
14326 }
14327}
14328#[derive(Debug, Clone)]
14329pub enum FieldDeclarationListChildren<'tree> {
14330 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
14331 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
14332 Declaration(::std::boxed::Box<Declaration<'tree>>),
14333 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
14334 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
14335 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
14336 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
14337 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
14338 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
14339 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
14340 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
14341 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
14342 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
14343 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
14344 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
14345}
14346impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDeclarationListChildren<'tree> {
14347 #[allow(clippy::collapsible_else_if)]
14348 fn from_node(
14349 node: ::tree_sitter::Node<'tree>,
14350 src: &'tree [u8],
14351 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14352 match node.kind() {
14353 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
14354 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14355 ))),
14356 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
14357 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14358 ))),
14359 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
14360 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14361 ))),
14362 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
14363 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14364 ))),
14365 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
14366 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14367 ))),
14368 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
14369 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
14370 ))),
14371 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
14372 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
14373 ))),
14374 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
14375 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
14376 ))),
14377 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
14378 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
14379 ))),
14380 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
14381 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
14382 ))),
14383 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
14384 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
14385 ))),
14386 "static_assert_declaration" => {
14387 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
14388 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
14389 node, src,
14390 )?,
14391 )))
14392 }
14393 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
14394 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14395 ))),
14396 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
14397 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
14398 ))),
14399 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
14400 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14401 ))),
14402 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14403 }
14404 }
14405}
14406impl ::treesitter_types::Spanned for FieldDeclarationListChildren<'_> {
14407 fn span(&self) -> ::treesitter_types::Span {
14408 match self {
14409 Self::AccessSpecifier(inner) => inner.span(),
14410 Self::AliasDeclaration(inner) => inner.span(),
14411 Self::Declaration(inner) => inner.span(),
14412 Self::FieldDeclaration(inner) => inner.span(),
14413 Self::FriendDeclaration(inner) => inner.span(),
14414 Self::FunctionDefinition(inner) => inner.span(),
14415 Self::PreprocCall(inner) => inner.span(),
14416 Self::PreprocDef(inner) => inner.span(),
14417 Self::PreprocFunctionDef(inner) => inner.span(),
14418 Self::PreprocIf(inner) => inner.span(),
14419 Self::PreprocIfdef(inner) => inner.span(),
14420 Self::StaticAssertDeclaration(inner) => inner.span(),
14421 Self::TemplateDeclaration(inner) => inner.span(),
14422 Self::TypeDefinition(inner) => inner.span(),
14423 Self::UsingDeclaration(inner) => inner.span(),
14424 }
14425 }
14426}
14427#[derive(Debug, Clone)]
14428pub enum FieldExpressionField<'tree> {
14429 DependentName(::std::boxed::Box<DependentName<'tree>>),
14430 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
14431 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
14432 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14433 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
14434}
14435impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionField<'tree> {
14436 #[allow(clippy::collapsible_else_if)]
14437 fn from_node(
14438 node: ::tree_sitter::Node<'tree>,
14439 src: &'tree [u8],
14440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14441 match node.kind() {
14442 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
14443 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)?,
14444 ))),
14445 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
14446 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)?,
14447 ))),
14448 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
14449 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14450 ))),
14451 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14452 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14453 ))),
14454 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
14455 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
14456 ))),
14457 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14458 }
14459 }
14460}
14461impl ::treesitter_types::Spanned for FieldExpressionField<'_> {
14462 fn span(&self) -> ::treesitter_types::Span {
14463 match self {
14464 Self::DependentName(inner) => inner.span(),
14465 Self::DestructorName(inner) => inner.span(),
14466 Self::FieldIdentifier(inner) => inner.span(),
14467 Self::QualifiedIdentifier(inner) => inner.span(),
14468 Self::TemplateMethod(inner) => inner.span(),
14469 }
14470 }
14471}
14472#[derive(Debug, Clone)]
14473pub enum FieldExpressionOperator {
14474 Arrow(::treesitter_types::Span),
14475 Dot(::treesitter_types::Span),
14476 DotStar(::treesitter_types::Span),
14477}
14478impl<'tree> ::treesitter_types::FromNode<'tree> for FieldExpressionOperator {
14479 #[allow(clippy::collapsible_else_if)]
14480 fn from_node(
14481 node: ::tree_sitter::Node<'tree>,
14482 _src: &'tree [u8],
14483 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14484 match node.kind() {
14485 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
14486 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
14487 ".*" => Ok(Self::DotStar(::treesitter_types::Span::from(node))),
14488 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14489 }
14490 }
14491}
14492impl ::treesitter_types::Spanned for FieldExpressionOperator {
14493 fn span(&self) -> ::treesitter_types::Span {
14494 match self {
14495 Self::Arrow(span) => *span,
14496 Self::Dot(span) => *span,
14497 Self::DotStar(span) => *span,
14498 }
14499 }
14500}
14501#[derive(Debug, Clone)]
14502pub enum FieldInitializerChildren<'tree> {
14503 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
14504 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
14505 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
14506 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14507 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
14508}
14509impl<'tree> ::treesitter_types::FromNode<'tree> for FieldInitializerChildren<'tree> {
14510 #[allow(clippy::collapsible_else_if)]
14511 fn from_node(
14512 node: ::tree_sitter::Node<'tree>,
14513 src: &'tree [u8],
14514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14515 match node.kind() {
14516 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
14517 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
14518 ))),
14519 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
14520 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14521 ))),
14522 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
14523 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
14524 ))),
14525 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14526 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14527 ))),
14528 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
14529 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
14530 ))),
14531 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14532 }
14533 }
14534}
14535impl ::treesitter_types::Spanned for FieldInitializerChildren<'_> {
14536 fn span(&self) -> ::treesitter_types::Span {
14537 match self {
14538 Self::ArgumentList(inner) => inner.span(),
14539 Self::FieldIdentifier(inner) => inner.span(),
14540 Self::InitializerList(inner) => inner.span(),
14541 Self::QualifiedIdentifier(inner) => inner.span(),
14542 Self::TemplateMethod(inner) => inner.span(),
14543 }
14544 }
14545}
14546#[derive(Debug, Clone)]
14547pub enum FoldExpressionLeft<'tree> {
14548 Ellipsis(::treesitter_types::Span),
14549 Expression(::std::boxed::Box<Expression<'tree>>),
14550}
14551impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionLeft<'tree> {
14552 #[allow(clippy::collapsible_else_if)]
14553 fn from_node(
14554 node: ::tree_sitter::Node<'tree>,
14555 src: &'tree [u8],
14556 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14557 match node.kind() {
14558 "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
14559 _other => {
14560 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14561 Ok(Self::Expression(::std::boxed::Box::new(v)))
14562 } else {
14563 Err(::treesitter_types::ParseError::unexpected_kind(
14564 _other, node,
14565 ))
14566 }
14567 }
14568 }
14569 }
14570}
14571impl ::treesitter_types::Spanned for FoldExpressionLeft<'_> {
14572 fn span(&self) -> ::treesitter_types::Span {
14573 match self {
14574 Self::Ellipsis(span) => *span,
14575 Self::Expression(inner) => inner.span(),
14576 }
14577 }
14578}
14579#[derive(Debug, Clone)]
14580pub enum FoldExpressionOperator {
14581 NotEq(::treesitter_types::Span),
14582 Percent(::treesitter_types::Span),
14583 PercentEq(::treesitter_types::Span),
14584 Amp(::treesitter_types::Span),
14585 AmpAmp(::treesitter_types::Span),
14586 AmpEq(::treesitter_types::Span),
14587 Star(::treesitter_types::Span),
14588 StarEq(::treesitter_types::Span),
14589 Plus(::treesitter_types::Span),
14590 PlusEq(::treesitter_types::Span),
14591 Comma(::treesitter_types::Span),
14592 Minus(::treesitter_types::Span),
14593 MinusEq(::treesitter_types::Span),
14594 MinusGtStar(::treesitter_types::Span),
14595 DotStar(::treesitter_types::Span),
14596 Slash(::treesitter_types::Span),
14597 SlashEq(::treesitter_types::Span),
14598 Lt(::treesitter_types::Span),
14599 Shl(::treesitter_types::Span),
14600 ShlEq(::treesitter_types::Span),
14601 LtEq(::treesitter_types::Span),
14602 Eq(::treesitter_types::Span),
14603 EqEq(::treesitter_types::Span),
14604 Gt(::treesitter_types::Span),
14605 GtEq(::treesitter_types::Span),
14606 Shr(::treesitter_types::Span),
14607 ShrEq(::treesitter_types::Span),
14608 Caret(::treesitter_types::Span),
14609 CaretEq(::treesitter_types::Span),
14610 And(::treesitter_types::Span),
14611 Bitand(::treesitter_types::Span),
14612 Bitor(::treesitter_types::Span),
14613 Or(::treesitter_types::Span),
14614 Xor(::treesitter_types::Span),
14615 Pipe(::treesitter_types::Span),
14616 PipeEq(::treesitter_types::Span),
14617 PipePipe(::treesitter_types::Span),
14618}
14619impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionOperator {
14620 #[allow(clippy::collapsible_else_if)]
14621 fn from_node(
14622 node: ::tree_sitter::Node<'tree>,
14623 _src: &'tree [u8],
14624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14625 match node.kind() {
14626 "!=" | "not_eq" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
14627 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
14628 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
14629 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
14630 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
14631 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
14632 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
14633 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
14634 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
14635 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
14636 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
14637 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
14638 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
14639 "->*" => Ok(Self::MinusGtStar(::treesitter_types::Span::from(node))),
14640 ".*" => Ok(Self::DotStar(::treesitter_types::Span::from(node))),
14641 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
14642 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
14643 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
14644 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
14645 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
14646 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
14647 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
14648 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
14649 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
14650 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
14651 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
14652 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
14653 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
14654 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
14655 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
14656 "bitand" => Ok(Self::Bitand(::treesitter_types::Span::from(node))),
14657 "bitor" => Ok(Self::Bitor(::treesitter_types::Span::from(node))),
14658 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
14659 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
14660 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
14661 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
14662 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
14663 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14664 }
14665 }
14666}
14667impl ::treesitter_types::Spanned for FoldExpressionOperator {
14668 fn span(&self) -> ::treesitter_types::Span {
14669 match self {
14670 Self::NotEq(span) => *span,
14671 Self::Percent(span) => *span,
14672 Self::PercentEq(span) => *span,
14673 Self::Amp(span) => *span,
14674 Self::AmpAmp(span) => *span,
14675 Self::AmpEq(span) => *span,
14676 Self::Star(span) => *span,
14677 Self::StarEq(span) => *span,
14678 Self::Plus(span) => *span,
14679 Self::PlusEq(span) => *span,
14680 Self::Comma(span) => *span,
14681 Self::Minus(span) => *span,
14682 Self::MinusEq(span) => *span,
14683 Self::MinusGtStar(span) => *span,
14684 Self::DotStar(span) => *span,
14685 Self::Slash(span) => *span,
14686 Self::SlashEq(span) => *span,
14687 Self::Lt(span) => *span,
14688 Self::Shl(span) => *span,
14689 Self::ShlEq(span) => *span,
14690 Self::LtEq(span) => *span,
14691 Self::Eq(span) => *span,
14692 Self::EqEq(span) => *span,
14693 Self::Gt(span) => *span,
14694 Self::GtEq(span) => *span,
14695 Self::Shr(span) => *span,
14696 Self::ShrEq(span) => *span,
14697 Self::Caret(span) => *span,
14698 Self::CaretEq(span) => *span,
14699 Self::And(span) => *span,
14700 Self::Bitand(span) => *span,
14701 Self::Bitor(span) => *span,
14702 Self::Or(span) => *span,
14703 Self::Xor(span) => *span,
14704 Self::Pipe(span) => *span,
14705 Self::PipeEq(span) => *span,
14706 Self::PipePipe(span) => *span,
14707 }
14708 }
14709}
14710#[derive(Debug, Clone)]
14711pub enum FoldExpressionRight<'tree> {
14712 Ellipsis(::treesitter_types::Span),
14713 Expression(::std::boxed::Box<Expression<'tree>>),
14714}
14715impl<'tree> ::treesitter_types::FromNode<'tree> for FoldExpressionRight<'tree> {
14716 #[allow(clippy::collapsible_else_if)]
14717 fn from_node(
14718 node: ::tree_sitter::Node<'tree>,
14719 src: &'tree [u8],
14720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14721 match node.kind() {
14722 "..." => Ok(Self::Ellipsis(::treesitter_types::Span::from(node))),
14723 _other => {
14724 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14725 Ok(Self::Expression(::std::boxed::Box::new(v)))
14726 } else {
14727 Err(::treesitter_types::ParseError::unexpected_kind(
14728 _other, node,
14729 ))
14730 }
14731 }
14732 }
14733 }
14734}
14735impl ::treesitter_types::Spanned for FoldExpressionRight<'_> {
14736 fn span(&self) -> ::treesitter_types::Span {
14737 match self {
14738 Self::Ellipsis(span) => *span,
14739 Self::Expression(inner) => inner.span(),
14740 }
14741 }
14742}
14743#[derive(Debug, Clone)]
14744pub enum ForRangeLoopRight<'tree> {
14745 Expression(::std::boxed::Box<Expression<'tree>>),
14746 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
14747}
14748impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoopRight<'tree> {
14749 #[allow(clippy::collapsible_else_if)]
14750 fn from_node(
14751 node: ::tree_sitter::Node<'tree>,
14752 src: &'tree [u8],
14753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14754 match node.kind() {
14755 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
14756 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
14757 ))),
14758 _other => {
14759 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14760 Ok(Self::Expression(::std::boxed::Box::new(v)))
14761 } else {
14762 Err(::treesitter_types::ParseError::unexpected_kind(
14763 _other, node,
14764 ))
14765 }
14766 }
14767 }
14768 }
14769}
14770impl ::treesitter_types::Spanned for ForRangeLoopRight<'_> {
14771 fn span(&self) -> ::treesitter_types::Span {
14772 match self {
14773 Self::Expression(inner) => inner.span(),
14774 Self::InitializerList(inner) => inner.span(),
14775 }
14776 }
14777}
14778#[derive(Debug, Clone)]
14779pub enum ForRangeLoopChildren<'tree> {
14780 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
14781 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
14782 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
14783 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
14784 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
14785}
14786impl<'tree> ::treesitter_types::FromNode<'tree> for ForRangeLoopChildren<'tree> {
14787 #[allow(clippy::collapsible_else_if)]
14788 fn from_node(
14789 node: ::tree_sitter::Node<'tree>,
14790 src: &'tree [u8],
14791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14792 match node.kind() {
14793 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
14794 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14795 ))),
14796 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
14797 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14798 ))),
14799 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
14800 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14801 ))),
14802 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
14803 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14804 ))),
14805 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
14806 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14807 ))),
14808 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14809 }
14810 }
14811}
14812impl ::treesitter_types::Spanned for ForRangeLoopChildren<'_> {
14813 fn span(&self) -> ::treesitter_types::Span {
14814 match self {
14815 Self::AttributeDeclaration(inner) => inner.span(),
14816 Self::AttributeSpecifier(inner) => inner.span(),
14817 Self::MsDeclspecModifier(inner) => inner.span(),
14818 Self::StorageClassSpecifier(inner) => inner.span(),
14819 Self::TypeQualifier(inner) => inner.span(),
14820 }
14821 }
14822}
14823#[derive(Debug, Clone)]
14824pub enum ForStatementCondition<'tree> {
14825 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14826 Expression(::std::boxed::Box<Expression<'tree>>),
14827}
14828impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
14829 #[allow(clippy::collapsible_else_if)]
14830 fn from_node(
14831 node: ::tree_sitter::Node<'tree>,
14832 src: &'tree [u8],
14833 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14834 match node.kind() {
14835 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14836 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14837 ))),
14838 _other => {
14839 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14840 Ok(Self::Expression(::std::boxed::Box::new(v)))
14841 } else {
14842 Err(::treesitter_types::ParseError::unexpected_kind(
14843 _other, node,
14844 ))
14845 }
14846 }
14847 }
14848 }
14849}
14850impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
14851 fn span(&self) -> ::treesitter_types::Span {
14852 match self {
14853 Self::CommaExpression(inner) => inner.span(),
14854 Self::Expression(inner) => inner.span(),
14855 }
14856 }
14857}
14858#[derive(Debug, Clone)]
14859pub enum ForStatementInitializer<'tree> {
14860 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14861 Declaration(::std::boxed::Box<Declaration<'tree>>),
14862 Expression(::std::boxed::Box<Expression<'tree>>),
14863}
14864impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
14865 #[allow(clippy::collapsible_else_if)]
14866 fn from_node(
14867 node: ::tree_sitter::Node<'tree>,
14868 src: &'tree [u8],
14869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14870 match node.kind() {
14871 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14872 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14873 ))),
14874 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
14875 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14876 ))),
14877 _other => {
14878 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14879 Ok(Self::Expression(::std::boxed::Box::new(v)))
14880 } else {
14881 Err(::treesitter_types::ParseError::unexpected_kind(
14882 _other, node,
14883 ))
14884 }
14885 }
14886 }
14887 }
14888}
14889impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
14890 fn span(&self) -> ::treesitter_types::Span {
14891 match self {
14892 Self::CommaExpression(inner) => inner.span(),
14893 Self::Declaration(inner) => inner.span(),
14894 Self::Expression(inner) => inner.span(),
14895 }
14896 }
14897}
14898#[derive(Debug, Clone)]
14899pub enum ForStatementUpdate<'tree> {
14900 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
14901 Expression(::std::boxed::Box<Expression<'tree>>),
14902}
14903impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
14904 #[allow(clippy::collapsible_else_if)]
14905 fn from_node(
14906 node: ::tree_sitter::Node<'tree>,
14907 src: &'tree [u8],
14908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14909 match node.kind() {
14910 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
14911 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14912 ))),
14913 _other => {
14914 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14915 Ok(Self::Expression(::std::boxed::Box::new(v)))
14916 } else {
14917 Err(::treesitter_types::ParseError::unexpected_kind(
14918 _other, node,
14919 ))
14920 }
14921 }
14922 }
14923 }
14924}
14925impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
14926 fn span(&self) -> ::treesitter_types::Span {
14927 match self {
14928 Self::CommaExpression(inner) => inner.span(),
14929 Self::Expression(inner) => inner.span(),
14930 }
14931 }
14932}
14933#[derive(Debug, Clone)]
14934pub enum FriendDeclarationChildren<'tree> {
14935 Declaration(::std::boxed::Box<Declaration<'tree>>),
14936 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
14937 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
14938 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
14939 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
14940}
14941impl<'tree> ::treesitter_types::FromNode<'tree> for FriendDeclarationChildren<'tree> {
14942 #[allow(clippy::collapsible_else_if)]
14943 fn from_node(
14944 node: ::tree_sitter::Node<'tree>,
14945 src: &'tree [u8],
14946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14947 match node.kind() {
14948 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
14949 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
14950 ))),
14951 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
14952 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
14953 ))),
14954 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
14955 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14956 ))),
14957 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
14958 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
14959 ))),
14960 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
14961 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14962 ))),
14963 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14964 }
14965 }
14966}
14967impl ::treesitter_types::Spanned for FriendDeclarationChildren<'_> {
14968 fn span(&self) -> ::treesitter_types::Span {
14969 match self {
14970 Self::Declaration(inner) => inner.span(),
14971 Self::FunctionDefinition(inner) => inner.span(),
14972 Self::QualifiedIdentifier(inner) => inner.span(),
14973 Self::TemplateType(inner) => inner.span(),
14974 Self::TypeIdentifier(inner) => inner.span(),
14975 }
14976 }
14977}
14978#[derive(Debug, Clone)]
14979pub enum FunctionDeclaratorDeclarator<'tree> {
14980 Declarator(::std::boxed::Box<Declarator<'tree>>),
14981 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
14982 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
14983}
14984impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorDeclarator<'tree> {
14985 #[allow(clippy::collapsible_else_if)]
14986 fn from_node(
14987 node: ::tree_sitter::Node<'tree>,
14988 src: &'tree [u8],
14989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14990 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
14991 Ok(Self::Declarator(::std::boxed::Box::new(v)))
14992 } else {
14993 if let Ok(v) = <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src) {
14994 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
14995 } else {
14996 if let Ok(v) =
14997 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
14998 {
14999 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
15000 } else {
15001 Err(::treesitter_types::ParseError::unexpected_kind(
15002 node.kind(),
15003 node,
15004 ))
15005 }
15006 }
15007 }
15008 }
15009}
15010impl ::treesitter_types::Spanned for FunctionDeclaratorDeclarator<'_> {
15011 fn span(&self) -> ::treesitter_types::Span {
15012 match self {
15013 Self::Declarator(inner) => inner.span(),
15014 Self::FieldDeclarator(inner) => inner.span(),
15015 Self::TypeDeclarator(inner) => inner.span(),
15016 }
15017 }
15018}
15019#[derive(Debug, Clone)]
15020pub enum FunctionDeclaratorChildren<'tree> {
15021 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15022 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15023 GnuAsmExpression(::std::boxed::Box<GnuAsmExpression<'tree>>),
15024 Noexcept(::std::boxed::Box<Noexcept<'tree>>),
15025 RefQualifier(::std::boxed::Box<RefQualifier<'tree>>),
15026 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
15027 ThrowSpecifier(::std::boxed::Box<ThrowSpecifier<'tree>>),
15028 TrailingReturnType(::std::boxed::Box<TrailingReturnType<'tree>>),
15029 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15030 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
15031}
15032impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaratorChildren<'tree> {
15033 #[allow(clippy::collapsible_else_if)]
15034 fn from_node(
15035 node: ::tree_sitter::Node<'tree>,
15036 src: &'tree [u8],
15037 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15038 match node.kind() {
15039 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15040 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15041 ))),
15042 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15043 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15044 ))),
15045 "gnu_asm_expression" => Ok(Self::GnuAsmExpression(::std::boxed::Box::new(
15046 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
15047 ))),
15048 "noexcept" => Ok(Self::Noexcept(::std::boxed::Box::new(
15049 <Noexcept as ::treesitter_types::FromNode>::from_node(node, src)?,
15050 ))),
15051 "ref_qualifier" => Ok(Self::RefQualifier(::std::boxed::Box::new(
15052 <RefQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15053 ))),
15054 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
15055 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15056 ))),
15057 "throw_specifier" => Ok(Self::ThrowSpecifier(::std::boxed::Box::new(
15058 <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15059 ))),
15060 "trailing_return_type" => Ok(Self::TrailingReturnType(::std::boxed::Box::new(
15061 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)?,
15062 ))),
15063 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15064 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15065 ))),
15066 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
15067 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15068 ))),
15069 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15070 }
15071 }
15072}
15073impl ::treesitter_types::Spanned for FunctionDeclaratorChildren<'_> {
15074 fn span(&self) -> ::treesitter_types::Span {
15075 match self {
15076 Self::AttributeDeclaration(inner) => inner.span(),
15077 Self::AttributeSpecifier(inner) => inner.span(),
15078 Self::GnuAsmExpression(inner) => inner.span(),
15079 Self::Noexcept(inner) => inner.span(),
15080 Self::RefQualifier(inner) => inner.span(),
15081 Self::RequiresClause(inner) => inner.span(),
15082 Self::ThrowSpecifier(inner) => inner.span(),
15083 Self::TrailingReturnType(inner) => inner.span(),
15084 Self::TypeQualifier(inner) => inner.span(),
15085 Self::VirtualSpecifier(inner) => inner.span(),
15086 }
15087 }
15088}
15089#[derive(Debug, Clone)]
15090pub enum FunctionDefinitionBody<'tree> {
15091 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
15092 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
15093}
15094impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionBody<'tree> {
15095 #[allow(clippy::collapsible_else_if)]
15096 fn from_node(
15097 node: ::tree_sitter::Node<'tree>,
15098 src: &'tree [u8],
15099 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15100 match node.kind() {
15101 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
15102 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
15103 ))),
15104 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
15105 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
15106 ))),
15107 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15108 }
15109 }
15110}
15111impl ::treesitter_types::Spanned for FunctionDefinitionBody<'_> {
15112 fn span(&self) -> ::treesitter_types::Span {
15113 match self {
15114 Self::CompoundStatement(inner) => inner.span(),
15115 Self::TryStatement(inner) => inner.span(),
15116 }
15117 }
15118}
15119#[derive(Debug, Clone)]
15120pub enum FunctionDefinitionDeclarator<'tree> {
15121 Declarator(::std::boxed::Box<Declarator<'tree>>),
15122 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
15123 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
15124}
15125impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionDeclarator<'tree> {
15126 #[allow(clippy::collapsible_else_if)]
15127 fn from_node(
15128 node: ::tree_sitter::Node<'tree>,
15129 src: &'tree [u8],
15130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15131 match node.kind() {
15132 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
15133 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)?,
15134 ))),
15135 _other => {
15136 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
15137 Ok(Self::Declarator(::std::boxed::Box::new(v)))
15138 } else {
15139 if let Ok(v) =
15140 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
15141 {
15142 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
15143 } else {
15144 Err(::treesitter_types::ParseError::unexpected_kind(
15145 _other, node,
15146 ))
15147 }
15148 }
15149 }
15150 }
15151 }
15152}
15153impl ::treesitter_types::Spanned for FunctionDefinitionDeclarator<'_> {
15154 fn span(&self) -> ::treesitter_types::Span {
15155 match self {
15156 Self::Declarator(inner) => inner.span(),
15157 Self::FieldDeclarator(inner) => inner.span(),
15158 Self::OperatorCast(inner) => inner.span(),
15159 }
15160 }
15161}
15162#[derive(Debug, Clone)]
15163pub enum FunctionDefinitionChildren<'tree> {
15164 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15165 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15166 DefaultMethodClause(::std::boxed::Box<DefaultMethodClause<'tree>>),
15167 DeleteMethodClause(::std::boxed::Box<DeleteMethodClause<'tree>>),
15168 ExplicitFunctionSpecifier(::std::boxed::Box<ExplicitFunctionSpecifier<'tree>>),
15169 FieldInitializerList(::std::boxed::Box<FieldInitializerList<'tree>>),
15170 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
15171 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
15172 PureVirtualClause(::std::boxed::Box<PureVirtualClause<'tree>>),
15173 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
15174 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
15175 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15176}
15177impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionChildren<'tree> {
15178 #[allow(clippy::collapsible_else_if)]
15179 fn from_node(
15180 node: ::tree_sitter::Node<'tree>,
15181 src: &'tree [u8],
15182 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15183 match node.kind() {
15184 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15185 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15186 ))),
15187 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15188 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15189 ))),
15190 "default_method_clause" => Ok(Self::DefaultMethodClause(::std::boxed::Box::new(
15191 <DefaultMethodClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15192 ))),
15193 "delete_method_clause" => Ok(Self::DeleteMethodClause(::std::boxed::Box::new(
15194 <DeleteMethodClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15195 ))),
15196 "explicit_function_specifier" => {
15197 Ok(Self::ExplicitFunctionSpecifier(::std::boxed::Box::new(
15198 <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(
15199 node, src,
15200 )?,
15201 )))
15202 }
15203 "field_initializer_list" => Ok(Self::FieldInitializerList(::std::boxed::Box::new(
15204 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
15205 ))),
15206 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
15207 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15208 ))),
15209 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
15210 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15211 ))),
15212 "pure_virtual_clause" => Ok(Self::PureVirtualClause(::std::boxed::Box::new(
15213 <PureVirtualClause as ::treesitter_types::FromNode>::from_node(node, src)?,
15214 ))),
15215 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
15216 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15217 ))),
15218 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
15219 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
15220 ))),
15221 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15222 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15223 ))),
15224 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15225 }
15226 }
15227}
15228impl ::treesitter_types::Spanned for FunctionDefinitionChildren<'_> {
15229 fn span(&self) -> ::treesitter_types::Span {
15230 match self {
15231 Self::AttributeDeclaration(inner) => inner.span(),
15232 Self::AttributeSpecifier(inner) => inner.span(),
15233 Self::DefaultMethodClause(inner) => inner.span(),
15234 Self::DeleteMethodClause(inner) => inner.span(),
15235 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
15236 Self::FieldInitializerList(inner) => inner.span(),
15237 Self::MsCallModifier(inner) => inner.span(),
15238 Self::MsDeclspecModifier(inner) => inner.span(),
15239 Self::PureVirtualClause(inner) => inner.span(),
15240 Self::StorageClassSpecifier(inner) => inner.span(),
15241 Self::TryStatement(inner) => inner.span(),
15242 Self::TypeQualifier(inner) => inner.span(),
15243 }
15244 }
15245}
15246#[derive(Debug, Clone)]
15247pub enum GenericExpressionChildren<'tree> {
15248 Expression(::std::boxed::Box<Expression<'tree>>),
15249 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
15250}
15251impl<'tree> ::treesitter_types::FromNode<'tree> for GenericExpressionChildren<'tree> {
15252 #[allow(clippy::collapsible_else_if)]
15253 fn from_node(
15254 node: ::tree_sitter::Node<'tree>,
15255 src: &'tree [u8],
15256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15257 match node.kind() {
15258 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
15259 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)?,
15260 ))),
15261 _other => {
15262 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15263 Ok(Self::Expression(::std::boxed::Box::new(v)))
15264 } else {
15265 Err(::treesitter_types::ParseError::unexpected_kind(
15266 _other, node,
15267 ))
15268 }
15269 }
15270 }
15271 }
15272}
15273impl ::treesitter_types::Spanned for GenericExpressionChildren<'_> {
15274 fn span(&self) -> ::treesitter_types::Span {
15275 match self {
15276 Self::Expression(inner) => inner.span(),
15277 Self::TypeDescriptor(inner) => inner.span(),
15278 }
15279 }
15280}
15281#[derive(Debug, Clone)]
15282pub enum GnuAsmClobberListRegister<'tree> {
15283 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
15284 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
15285 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
15286}
15287impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmClobberListRegister<'tree> {
15288 #[allow(clippy::collapsible_else_if)]
15289 fn from_node(
15290 node: ::tree_sitter::Node<'tree>,
15291 src: &'tree [u8],
15292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15293 match node.kind() {
15294 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
15295 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)?,
15296 ))),
15297 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
15298 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
15299 ))),
15300 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
15301 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
15302 ))),
15303 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15304 }
15305 }
15306}
15307impl ::treesitter_types::Spanned for GnuAsmClobberListRegister<'_> {
15308 fn span(&self) -> ::treesitter_types::Span {
15309 match self {
15310 Self::ConcatenatedString(inner) => inner.span(),
15311 Self::RawStringLiteral(inner) => inner.span(),
15312 Self::StringLiteral(inner) => inner.span(),
15313 }
15314 }
15315}
15316#[derive(Debug, Clone)]
15317pub enum GnuAsmExpressionAssemblyCode<'tree> {
15318 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
15319 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
15320 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
15321}
15322impl<'tree> ::treesitter_types::FromNode<'tree> for GnuAsmExpressionAssemblyCode<'tree> {
15323 #[allow(clippy::collapsible_else_if)]
15324 fn from_node(
15325 node: ::tree_sitter::Node<'tree>,
15326 src: &'tree [u8],
15327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15328 match node.kind() {
15329 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
15330 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)?,
15331 ))),
15332 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
15333 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
15334 ))),
15335 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
15336 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
15337 ))),
15338 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15339 }
15340 }
15341}
15342impl ::treesitter_types::Spanned for GnuAsmExpressionAssemblyCode<'_> {
15343 fn span(&self) -> ::treesitter_types::Span {
15344 match self {
15345 Self::ConcatenatedString(inner) => inner.span(),
15346 Self::RawStringLiteral(inner) => inner.span(),
15347 Self::StringLiteral(inner) => inner.span(),
15348 }
15349 }
15350}
15351#[derive(Debug, Clone)]
15352pub enum InitDeclaratorValue<'tree> {
15353 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
15354 Expression(::std::boxed::Box<Expression<'tree>>),
15355 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15356}
15357impl<'tree> ::treesitter_types::FromNode<'tree> for InitDeclaratorValue<'tree> {
15358 #[allow(clippy::collapsible_else_if)]
15359 fn from_node(
15360 node: ::tree_sitter::Node<'tree>,
15361 src: &'tree [u8],
15362 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15363 match node.kind() {
15364 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
15365 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
15366 ))),
15367 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15368 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
15369 ))),
15370 _other => {
15371 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15372 Ok(Self::Expression(::std::boxed::Box::new(v)))
15373 } else {
15374 Err(::treesitter_types::ParseError::unexpected_kind(
15375 _other, node,
15376 ))
15377 }
15378 }
15379 }
15380 }
15381}
15382impl ::treesitter_types::Spanned for InitDeclaratorValue<'_> {
15383 fn span(&self) -> ::treesitter_types::Span {
15384 match self {
15385 Self::ArgumentList(inner) => inner.span(),
15386 Self::Expression(inner) => inner.span(),
15387 Self::InitializerList(inner) => inner.span(),
15388 }
15389 }
15390}
15391#[derive(Debug, Clone)]
15392pub enum InitStatementChildren<'tree> {
15393 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
15394 Declaration(::std::boxed::Box<Declaration<'tree>>),
15395 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
15396 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
15397}
15398impl<'tree> ::treesitter_types::FromNode<'tree> for InitStatementChildren<'tree> {
15399 #[allow(clippy::collapsible_else_if)]
15400 fn from_node(
15401 node: ::tree_sitter::Node<'tree>,
15402 src: &'tree [u8],
15403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15404 match node.kind() {
15405 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
15406 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15407 ))),
15408 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15409 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15410 ))),
15411 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
15412 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
15413 ))),
15414 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
15415 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
15416 ))),
15417 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15418 }
15419 }
15420}
15421impl ::treesitter_types::Spanned for InitStatementChildren<'_> {
15422 fn span(&self) -> ::treesitter_types::Span {
15423 match self {
15424 Self::AliasDeclaration(inner) => inner.span(),
15425 Self::Declaration(inner) => inner.span(),
15426 Self::ExpressionStatement(inner) => inner.span(),
15427 Self::TypeDefinition(inner) => inner.span(),
15428 }
15429 }
15430}
15431#[derive(Debug, Clone)]
15432pub enum InitializerListChildren<'tree> {
15433 Expression(::std::boxed::Box<Expression<'tree>>),
15434 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15435 InitializerPair(::std::boxed::Box<InitializerPair<'tree>>),
15436}
15437impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerListChildren<'tree> {
15438 #[allow(clippy::collapsible_else_if)]
15439 fn from_node(
15440 node: ::tree_sitter::Node<'tree>,
15441 src: &'tree [u8],
15442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15443 match node.kind() {
15444 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15445 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
15446 ))),
15447 "initializer_pair" => Ok(Self::InitializerPair(::std::boxed::Box::new(
15448 <InitializerPair as ::treesitter_types::FromNode>::from_node(node, src)?,
15449 ))),
15450 _other => {
15451 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15452 Ok(Self::Expression(::std::boxed::Box::new(v)))
15453 } else {
15454 Err(::treesitter_types::ParseError::unexpected_kind(
15455 _other, node,
15456 ))
15457 }
15458 }
15459 }
15460 }
15461}
15462impl ::treesitter_types::Spanned for InitializerListChildren<'_> {
15463 fn span(&self) -> ::treesitter_types::Span {
15464 match self {
15465 Self::Expression(inner) => inner.span(),
15466 Self::InitializerList(inner) => inner.span(),
15467 Self::InitializerPair(inner) => inner.span(),
15468 }
15469 }
15470}
15471#[derive(Debug, Clone)]
15472pub enum InitializerPairDesignator<'tree> {
15473 FieldDesignator(::std::boxed::Box<FieldDesignator<'tree>>),
15474 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
15475 SubscriptDesignator(::std::boxed::Box<SubscriptDesignator<'tree>>),
15476 SubscriptRangeDesignator(::std::boxed::Box<SubscriptRangeDesignator<'tree>>),
15477}
15478impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairDesignator<'tree> {
15479 #[allow(clippy::collapsible_else_if)]
15480 fn from_node(
15481 node: ::tree_sitter::Node<'tree>,
15482 src: &'tree [u8],
15483 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15484 match node.kind() {
15485 "field_designator" => Ok(Self::FieldDesignator(::std::boxed::Box::new(
15486 <FieldDesignator as ::treesitter_types::FromNode>::from_node(node, src)?,
15487 ))),
15488 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
15489 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15490 ))),
15491 "subscript_designator" => Ok(Self::SubscriptDesignator(::std::boxed::Box::new(
15492 <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(node, src)?,
15493 ))),
15494 "subscript_range_designator" => {
15495 Ok(Self::SubscriptRangeDesignator(::std::boxed::Box::new(
15496 <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(
15497 node, src,
15498 )?,
15499 )))
15500 }
15501 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15502 }
15503 }
15504}
15505impl ::treesitter_types::Spanned for InitializerPairDesignator<'_> {
15506 fn span(&self) -> ::treesitter_types::Span {
15507 match self {
15508 Self::FieldDesignator(inner) => inner.span(),
15509 Self::FieldIdentifier(inner) => inner.span(),
15510 Self::SubscriptDesignator(inner) => inner.span(),
15511 Self::SubscriptRangeDesignator(inner) => inner.span(),
15512 }
15513 }
15514}
15515#[derive(Debug, Clone)]
15516pub enum InitializerPairValue<'tree> {
15517 Expression(::std::boxed::Box<Expression<'tree>>),
15518 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15519}
15520impl<'tree> ::treesitter_types::FromNode<'tree> for InitializerPairValue<'tree> {
15521 #[allow(clippy::collapsible_else_if)]
15522 fn from_node(
15523 node: ::tree_sitter::Node<'tree>,
15524 src: &'tree [u8],
15525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15526 match node.kind() {
15527 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15528 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
15529 ))),
15530 _other => {
15531 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15532 Ok(Self::Expression(::std::boxed::Box::new(v)))
15533 } else {
15534 Err(::treesitter_types::ParseError::unexpected_kind(
15535 _other, node,
15536 ))
15537 }
15538 }
15539 }
15540 }
15541}
15542impl ::treesitter_types::Spanned for InitializerPairValue<'_> {
15543 fn span(&self) -> ::treesitter_types::Span {
15544 match self {
15545 Self::Expression(inner) => inner.span(),
15546 Self::InitializerList(inner) => inner.span(),
15547 }
15548 }
15549}
15550#[derive(Debug, Clone)]
15551pub enum LabeledStatementChildren<'tree> {
15552 Declaration(::std::boxed::Box<Declaration<'tree>>),
15553 Statement(::std::boxed::Box<Statement<'tree>>),
15554}
15555impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatementChildren<'tree> {
15556 #[allow(clippy::collapsible_else_if)]
15557 fn from_node(
15558 node: ::tree_sitter::Node<'tree>,
15559 src: &'tree [u8],
15560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15561 match node.kind() {
15562 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15563 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15564 ))),
15565 _other => {
15566 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
15567 Ok(Self::Statement(::std::boxed::Box::new(v)))
15568 } else {
15569 Err(::treesitter_types::ParseError::unexpected_kind(
15570 _other, node,
15571 ))
15572 }
15573 }
15574 }
15575 }
15576}
15577impl ::treesitter_types::Spanned for LabeledStatementChildren<'_> {
15578 fn span(&self) -> ::treesitter_types::Span {
15579 match self {
15580 Self::Declaration(inner) => inner.span(),
15581 Self::Statement(inner) => inner.span(),
15582 }
15583 }
15584}
15585#[derive(Debug, Clone)]
15586pub enum LambdaCaptureSpecifierChildren<'tree> {
15587 Identifier(::std::boxed::Box<Identifier<'tree>>),
15588 LambdaCaptureInitializer(::std::boxed::Box<LambdaCaptureInitializer<'tree>>),
15589 LambdaDefaultCapture(::std::boxed::Box<LambdaDefaultCapture<'tree>>),
15590 ParameterPackExpansion(::std::boxed::Box<ParameterPackExpansion<'tree>>),
15591 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
15592 This(::std::boxed::Box<This<'tree>>),
15593}
15594impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCaptureSpecifierChildren<'tree> {
15595 #[allow(clippy::collapsible_else_if)]
15596 fn from_node(
15597 node: ::tree_sitter::Node<'tree>,
15598 src: &'tree [u8],
15599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15600 match node.kind() {
15601 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
15602 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15603 ))),
15604 "lambda_capture_initializer" => {
15605 Ok(Self::LambdaCaptureInitializer(::std::boxed::Box::new(
15606 <LambdaCaptureInitializer as ::treesitter_types::FromNode>::from_node(
15607 node, src,
15608 )?,
15609 )))
15610 }
15611 "lambda_default_capture" => Ok(Self::LambdaDefaultCapture(::std::boxed::Box::new(
15612 <LambdaDefaultCapture as ::treesitter_types::FromNode>::from_node(node, src)?,
15613 ))),
15614 "parameter_pack_expansion" => Ok(Self::ParameterPackExpansion(::std::boxed::Box::new(
15615 <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(node, src)?,
15616 ))),
15617 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
15618 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15619 ))),
15620 "this" => Ok(Self::This(::std::boxed::Box::new(
15621 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
15622 ))),
15623 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15624 }
15625 }
15626}
15627impl ::treesitter_types::Spanned for LambdaCaptureSpecifierChildren<'_> {
15628 fn span(&self) -> ::treesitter_types::Span {
15629 match self {
15630 Self::Identifier(inner) => inner.span(),
15631 Self::LambdaCaptureInitializer(inner) => inner.span(),
15632 Self::LambdaDefaultCapture(inner) => inner.span(),
15633 Self::ParameterPackExpansion(inner) => inner.span(),
15634 Self::QualifiedIdentifier(inner) => inner.span(),
15635 Self::This(inner) => inner.span(),
15636 }
15637 }
15638}
15639#[derive(Debug, Clone)]
15640pub enum LinkageSpecificationBody<'tree> {
15641 Declaration(::std::boxed::Box<Declaration<'tree>>),
15642 DeclarationList(::std::boxed::Box<DeclarationList<'tree>>),
15643 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
15644}
15645impl<'tree> ::treesitter_types::FromNode<'tree> for LinkageSpecificationBody<'tree> {
15646 #[allow(clippy::collapsible_else_if)]
15647 fn from_node(
15648 node: ::tree_sitter::Node<'tree>,
15649 src: &'tree [u8],
15650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15651 match node.kind() {
15652 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
15653 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15654 ))),
15655 "declaration_list" => Ok(Self::DeclarationList(::std::boxed::Box::new(
15656 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)?,
15657 ))),
15658 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
15659 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
15660 ))),
15661 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15662 }
15663 }
15664}
15665impl ::treesitter_types::Spanned for LinkageSpecificationBody<'_> {
15666 fn span(&self) -> ::treesitter_types::Span {
15667 match self {
15668 Self::Declaration(inner) => inner.span(),
15669 Self::DeclarationList(inner) => inner.span(),
15670 Self::FunctionDefinition(inner) => inner.span(),
15671 }
15672 }
15673}
15674#[derive(Debug, Clone)]
15675pub enum MsPointerModifierChildren<'tree> {
15676 MsRestrictModifier(::std::boxed::Box<MsRestrictModifier<'tree>>),
15677 MsSignedPtrModifier(::std::boxed::Box<MsSignedPtrModifier<'tree>>),
15678 MsUnalignedPtrModifier(::std::boxed::Box<MsUnalignedPtrModifier<'tree>>),
15679 MsUnsignedPtrModifier(::std::boxed::Box<MsUnsignedPtrModifier<'tree>>),
15680}
15681impl<'tree> ::treesitter_types::FromNode<'tree> for MsPointerModifierChildren<'tree> {
15682 #[allow(clippy::collapsible_else_if)]
15683 fn from_node(
15684 node: ::tree_sitter::Node<'tree>,
15685 src: &'tree [u8],
15686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15687 match node.kind() {
15688 "ms_restrict_modifier" => Ok(Self::MsRestrictModifier(::std::boxed::Box::new(
15689 <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15690 ))),
15691 "ms_signed_ptr_modifier" => Ok(Self::MsSignedPtrModifier(::std::boxed::Box::new(
15692 <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15693 ))),
15694 "ms_unaligned_ptr_modifier" => {
15695 Ok(Self::MsUnalignedPtrModifier(::std::boxed::Box::new(
15696 <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15697 )))
15698 }
15699 "ms_unsigned_ptr_modifier" => Ok(Self::MsUnsignedPtrModifier(::std::boxed::Box::new(
15700 <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15701 ))),
15702 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15703 }
15704 }
15705}
15706impl ::treesitter_types::Spanned for MsPointerModifierChildren<'_> {
15707 fn span(&self) -> ::treesitter_types::Span {
15708 match self {
15709 Self::MsRestrictModifier(inner) => inner.span(),
15710 Self::MsSignedPtrModifier(inner) => inner.span(),
15711 Self::MsUnalignedPtrModifier(inner) => inner.span(),
15712 Self::MsUnsignedPtrModifier(inner) => inner.span(),
15713 }
15714 }
15715}
15716#[derive(Debug, Clone)]
15717pub enum NamespaceAliasDefinitionChildren<'tree> {
15718 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
15719 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
15720}
15721impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceAliasDefinitionChildren<'tree> {
15722 #[allow(clippy::collapsible_else_if)]
15723 fn from_node(
15724 node: ::tree_sitter::Node<'tree>,
15725 src: &'tree [u8],
15726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15727 match node.kind() {
15728 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
15729 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15730 ))),
15731 "nested_namespace_specifier" => {
15732 Ok(Self::NestedNamespaceSpecifier(::std::boxed::Box::new(
15733 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(
15734 node, src,
15735 )?,
15736 )))
15737 }
15738 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15739 }
15740 }
15741}
15742impl ::treesitter_types::Spanned for NamespaceAliasDefinitionChildren<'_> {
15743 fn span(&self) -> ::treesitter_types::Span {
15744 match self {
15745 Self::NamespaceIdentifier(inner) => inner.span(),
15746 Self::NestedNamespaceSpecifier(inner) => inner.span(),
15747 }
15748 }
15749}
15750#[derive(Debug, Clone)]
15751pub enum NamespaceDefinitionName<'tree> {
15752 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
15753 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
15754}
15755impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinitionName<'tree> {
15756 #[allow(clippy::collapsible_else_if)]
15757 fn from_node(
15758 node: ::tree_sitter::Node<'tree>,
15759 src: &'tree [u8],
15760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15761 match node.kind() {
15762 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
15763 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15764 ))),
15765 "nested_namespace_specifier" => {
15766 Ok(Self::NestedNamespaceSpecifier(::std::boxed::Box::new(
15767 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(
15768 node, src,
15769 )?,
15770 )))
15771 }
15772 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15773 }
15774 }
15775}
15776impl ::treesitter_types::Spanned for NamespaceDefinitionName<'_> {
15777 fn span(&self) -> ::treesitter_types::Span {
15778 match self {
15779 Self::NamespaceIdentifier(inner) => inner.span(),
15780 Self::NestedNamespaceSpecifier(inner) => inner.span(),
15781 }
15782 }
15783}
15784#[derive(Debug, Clone)]
15785pub enum NestedNamespaceSpecifierChildren<'tree> {
15786 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
15787 NestedNamespaceSpecifier(::std::boxed::Box<NestedNamespaceSpecifier<'tree>>),
15788}
15789impl<'tree> ::treesitter_types::FromNode<'tree> for NestedNamespaceSpecifierChildren<'tree> {
15790 #[allow(clippy::collapsible_else_if)]
15791 fn from_node(
15792 node: ::tree_sitter::Node<'tree>,
15793 src: &'tree [u8],
15794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15795 match node.kind() {
15796 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
15797 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15798 ))),
15799 "nested_namespace_specifier" => {
15800 Ok(Self::NestedNamespaceSpecifier(::std::boxed::Box::new(
15801 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(
15802 node, src,
15803 )?,
15804 )))
15805 }
15806 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15807 }
15808 }
15809}
15810impl ::treesitter_types::Spanned for NestedNamespaceSpecifierChildren<'_> {
15811 fn span(&self) -> ::treesitter_types::Span {
15812 match self {
15813 Self::NamespaceIdentifier(inner) => inner.span(),
15814 Self::NestedNamespaceSpecifier(inner) => inner.span(),
15815 }
15816 }
15817}
15818#[derive(Debug, Clone)]
15819pub enum NewExpressionArguments<'tree> {
15820 ArgumentList(::std::boxed::Box<ArgumentList<'tree>>),
15821 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
15822}
15823impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpressionArguments<'tree> {
15824 #[allow(clippy::collapsible_else_if)]
15825 fn from_node(
15826 node: ::tree_sitter::Node<'tree>,
15827 src: &'tree [u8],
15828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15829 match node.kind() {
15830 "argument_list" => Ok(Self::ArgumentList(::std::boxed::Box::new(
15831 <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)?,
15832 ))),
15833 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
15834 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
15835 ))),
15836 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15837 }
15838 }
15839}
15840impl ::treesitter_types::Spanned for NewExpressionArguments<'_> {
15841 fn span(&self) -> ::treesitter_types::Span {
15842 match self {
15843 Self::ArgumentList(inner) => inner.span(),
15844 Self::InitializerList(inner) => inner.span(),
15845 }
15846 }
15847}
15848#[derive(Debug, Clone)]
15849pub enum OperatorCastChildren<'tree> {
15850 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15851 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15852 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
15853 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
15854 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15855}
15856impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorCastChildren<'tree> {
15857 #[allow(clippy::collapsible_else_if)]
15858 fn from_node(
15859 node: ::tree_sitter::Node<'tree>,
15860 src: &'tree [u8],
15861 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15862 match node.kind() {
15863 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15864 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15865 ))),
15866 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15867 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15868 ))),
15869 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
15870 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15871 ))),
15872 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
15873 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15874 ))),
15875 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15876 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15877 ))),
15878 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15879 }
15880 }
15881}
15882impl ::treesitter_types::Spanned for OperatorCastChildren<'_> {
15883 fn span(&self) -> ::treesitter_types::Span {
15884 match self {
15885 Self::AttributeDeclaration(inner) => inner.span(),
15886 Self::AttributeSpecifier(inner) => inner.span(),
15887 Self::MsDeclspecModifier(inner) => inner.span(),
15888 Self::StorageClassSpecifier(inner) => inner.span(),
15889 Self::TypeQualifier(inner) => inner.span(),
15890 }
15891 }
15892}
15893#[derive(Debug, Clone)]
15894pub enum OptionalParameterDeclarationDeclarator<'tree> {
15895 Declarator(::std::boxed::Box<Declarator<'tree>>),
15896 AbstractReferenceDeclarator(::std::boxed::Box<AbstractReferenceDeclarator<'tree>>),
15897}
15898impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclarationDeclarator<'tree> {
15899 #[allow(clippy::collapsible_else_if)]
15900 fn from_node(
15901 node: ::tree_sitter::Node<'tree>,
15902 src: &'tree [u8],
15903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15904 match node.kind() {
15905 "abstract_reference_declarator" => {
15906 Ok(Self::AbstractReferenceDeclarator(::std::boxed::Box::new(
15907 <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(
15908 node, src,
15909 )?,
15910 )))
15911 }
15912 _other => {
15913 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
15914 Ok(Self::Declarator(::std::boxed::Box::new(v)))
15915 } else {
15916 Err(::treesitter_types::ParseError::unexpected_kind(
15917 _other, node,
15918 ))
15919 }
15920 }
15921 }
15922 }
15923}
15924impl ::treesitter_types::Spanned for OptionalParameterDeclarationDeclarator<'_> {
15925 fn span(&self) -> ::treesitter_types::Span {
15926 match self {
15927 Self::Declarator(inner) => inner.span(),
15928 Self::AbstractReferenceDeclarator(inner) => inner.span(),
15929 }
15930 }
15931}
15932#[derive(Debug, Clone)]
15933pub enum OptionalParameterDeclarationChildren<'tree> {
15934 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
15935 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
15936 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
15937 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
15938 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
15939}
15940impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterDeclarationChildren<'tree> {
15941 #[allow(clippy::collapsible_else_if)]
15942 fn from_node(
15943 node: ::tree_sitter::Node<'tree>,
15944 src: &'tree [u8],
15945 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15946 match node.kind() {
15947 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
15948 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
15949 ))),
15950 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
15951 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15952 ))),
15953 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
15954 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15955 ))),
15956 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
15957 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15958 ))),
15959 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
15960 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
15961 ))),
15962 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15963 }
15964 }
15965}
15966impl ::treesitter_types::Spanned for OptionalParameterDeclarationChildren<'_> {
15967 fn span(&self) -> ::treesitter_types::Span {
15968 match self {
15969 Self::AttributeDeclaration(inner) => inner.span(),
15970 Self::AttributeSpecifier(inner) => inner.span(),
15971 Self::MsDeclspecModifier(inner) => inner.span(),
15972 Self::StorageClassSpecifier(inner) => inner.span(),
15973 Self::TypeQualifier(inner) => inner.span(),
15974 }
15975 }
15976}
15977#[derive(Debug, Clone)]
15978pub enum ParameterDeclarationDeclarator<'tree> {
15979 AbstractDeclarator(::std::boxed::Box<AbstractDeclarator<'tree>>),
15980 Declarator(::std::boxed::Box<Declarator<'tree>>),
15981}
15982impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationDeclarator<'tree> {
15983 #[allow(clippy::collapsible_else_if)]
15984 fn from_node(
15985 node: ::tree_sitter::Node<'tree>,
15986 src: &'tree [u8],
15987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15988 if let Ok(v) = <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src) {
15989 Ok(Self::AbstractDeclarator(::std::boxed::Box::new(v)))
15990 } else {
15991 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
15992 Ok(Self::Declarator(::std::boxed::Box::new(v)))
15993 } else {
15994 Err(::treesitter_types::ParseError::unexpected_kind(
15995 node.kind(),
15996 node,
15997 ))
15998 }
15999 }
16000 }
16001}
16002impl ::treesitter_types::Spanned for ParameterDeclarationDeclarator<'_> {
16003 fn span(&self) -> ::treesitter_types::Span {
16004 match self {
16005 Self::AbstractDeclarator(inner) => inner.span(),
16006 Self::Declarator(inner) => inner.span(),
16007 }
16008 }
16009}
16010#[derive(Debug, Clone)]
16011pub enum ParameterDeclarationChildren<'tree> {
16012 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
16013 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
16014 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
16015 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
16016 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16017}
16018impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterDeclarationChildren<'tree> {
16019 #[allow(clippy::collapsible_else_if)]
16020 fn from_node(
16021 node: ::tree_sitter::Node<'tree>,
16022 src: &'tree [u8],
16023 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16024 match node.kind() {
16025 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
16026 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16027 ))),
16028 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
16029 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16030 ))),
16031 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
16032 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16033 ))),
16034 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
16035 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16036 ))),
16037 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
16038 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16039 ))),
16040 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16041 }
16042 }
16043}
16044impl ::treesitter_types::Spanned for ParameterDeclarationChildren<'_> {
16045 fn span(&self) -> ::treesitter_types::Span {
16046 match self {
16047 Self::AttributeDeclaration(inner) => inner.span(),
16048 Self::AttributeSpecifier(inner) => inner.span(),
16049 Self::MsDeclspecModifier(inner) => inner.span(),
16050 Self::StorageClassSpecifier(inner) => inner.span(),
16051 Self::TypeQualifier(inner) => inner.span(),
16052 }
16053 }
16054}
16055#[derive(Debug, Clone)]
16056pub enum ParameterListChildren<'tree> {
16057 OptionalParameterDeclaration(::std::boxed::Box<OptionalParameterDeclaration<'tree>>),
16058 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
16059 VariadicParameterDeclaration(::std::boxed::Box<VariadicParameterDeclaration<'tree>>),
16060}
16061impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterListChildren<'tree> {
16062 #[allow(clippy::collapsible_else_if)]
16063 fn from_node(
16064 node: ::tree_sitter::Node<'tree>,
16065 src: &'tree [u8],
16066 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16067 match node.kind() {
16068 "optional_parameter_declaration" => {
16069 Ok(Self::OptionalParameterDeclaration(::std::boxed::Box::new(
16070 <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(
16071 node, src,
16072 )?,
16073 )))
16074 }
16075 "parameter_declaration" => Ok(Self::ParameterDeclaration(::std::boxed::Box::new(
16076 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16077 ))),
16078 "variadic_parameter_declaration" => {
16079 Ok(Self::VariadicParameterDeclaration(::std::boxed::Box::new(
16080 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
16081 node, src,
16082 )?,
16083 )))
16084 }
16085 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16086 }
16087 }
16088}
16089impl ::treesitter_types::Spanned for ParameterListChildren<'_> {
16090 fn span(&self) -> ::treesitter_types::Span {
16091 match self {
16092 Self::OptionalParameterDeclaration(inner) => inner.span(),
16093 Self::ParameterDeclaration(inner) => inner.span(),
16094 Self::VariadicParameterDeclaration(inner) => inner.span(),
16095 }
16096 }
16097}
16098#[derive(Debug, Clone)]
16099pub enum ParameterPackExpansionPattern<'tree> {
16100 Expression(::std::boxed::Box<Expression<'tree>>),
16101 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
16102}
16103impl<'tree> ::treesitter_types::FromNode<'tree> for ParameterPackExpansionPattern<'tree> {
16104 #[allow(clippy::collapsible_else_if)]
16105 fn from_node(
16106 node: ::tree_sitter::Node<'tree>,
16107 src: &'tree [u8],
16108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16109 match node.kind() {
16110 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
16111 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)?,
16112 ))),
16113 _other => {
16114 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
16115 Ok(Self::Expression(::std::boxed::Box::new(v)))
16116 } else {
16117 Err(::treesitter_types::ParseError::unexpected_kind(
16118 _other, node,
16119 ))
16120 }
16121 }
16122 }
16123 }
16124}
16125impl ::treesitter_types::Spanned for ParameterPackExpansionPattern<'_> {
16126 fn span(&self) -> ::treesitter_types::Span {
16127 match self {
16128 Self::Expression(inner) => inner.span(),
16129 Self::TypeDescriptor(inner) => inner.span(),
16130 }
16131 }
16132}
16133#[derive(Debug, Clone)]
16134pub enum ParenthesizedDeclaratorChildren<'tree> {
16135 Declarator(::std::boxed::Box<Declarator<'tree>>),
16136 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
16137 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
16138 MsCallModifier(::std::boxed::Box<MsCallModifier<'tree>>),
16139}
16140impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedDeclaratorChildren<'tree> {
16141 #[allow(clippy::collapsible_else_if)]
16142 fn from_node(
16143 node: ::tree_sitter::Node<'tree>,
16144 src: &'tree [u8],
16145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16146 match node.kind() {
16147 "ms_call_modifier" => Ok(Self::MsCallModifier(::std::boxed::Box::new(
16148 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16149 ))),
16150 _other => {
16151 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
16152 Ok(Self::Declarator(::std::boxed::Box::new(v)))
16153 } else {
16154 if let Ok(v) =
16155 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
16156 {
16157 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
16158 } else {
16159 if let Ok(v) =
16160 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
16161 {
16162 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
16163 } else {
16164 Err(::treesitter_types::ParseError::unexpected_kind(
16165 _other, node,
16166 ))
16167 }
16168 }
16169 }
16170 }
16171 }
16172 }
16173}
16174impl ::treesitter_types::Spanned for ParenthesizedDeclaratorChildren<'_> {
16175 fn span(&self) -> ::treesitter_types::Span {
16176 match self {
16177 Self::Declarator(inner) => inner.span(),
16178 Self::FieldDeclarator(inner) => inner.span(),
16179 Self::TypeDeclarator(inner) => inner.span(),
16180 Self::MsCallModifier(inner) => inner.span(),
16181 }
16182 }
16183}
16184#[derive(Debug, Clone)]
16185pub enum ParenthesizedExpressionChildren<'tree> {
16186 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
16187 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
16188 Expression(::std::boxed::Box<Expression<'tree>>),
16189 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
16190}
16191impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
16192 #[allow(clippy::collapsible_else_if)]
16193 fn from_node(
16194 node: ::tree_sitter::Node<'tree>,
16195 src: &'tree [u8],
16196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16197 match node.kind() {
16198 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
16199 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16200 ))),
16201 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
16202 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
16203 ))),
16204 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
16205 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
16206 ))),
16207 _other => {
16208 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
16209 Ok(Self::Expression(::std::boxed::Box::new(v)))
16210 } else {
16211 Err(::treesitter_types::ParseError::unexpected_kind(
16212 _other, node,
16213 ))
16214 }
16215 }
16216 }
16217 }
16218}
16219impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
16220 fn span(&self) -> ::treesitter_types::Span {
16221 match self {
16222 Self::CommaExpression(inner) => inner.span(),
16223 Self::CompoundStatement(inner) => inner.span(),
16224 Self::Expression(inner) => inner.span(),
16225 Self::PreprocDefined(inner) => inner.span(),
16226 }
16227 }
16228}
16229#[derive(Debug, Clone)]
16230pub enum PlaceholderTypeSpecifierChildren<'tree> {
16231 Auto(::std::boxed::Box<Auto<'tree>>),
16232 Decltype(::std::boxed::Box<Decltype<'tree>>),
16233}
16234impl<'tree> ::treesitter_types::FromNode<'tree> for PlaceholderTypeSpecifierChildren<'tree> {
16235 #[allow(clippy::collapsible_else_if)]
16236 fn from_node(
16237 node: ::tree_sitter::Node<'tree>,
16238 src: &'tree [u8],
16239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16240 match node.kind() {
16241 "auto" => Ok(Self::Auto(::std::boxed::Box::new(
16242 <Auto as ::treesitter_types::FromNode>::from_node(node, src)?,
16243 ))),
16244 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
16245 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)?,
16246 ))),
16247 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16248 }
16249 }
16250}
16251impl ::treesitter_types::Spanned for PlaceholderTypeSpecifierChildren<'_> {
16252 fn span(&self) -> ::treesitter_types::Span {
16253 match self {
16254 Self::Auto(inner) => inner.span(),
16255 Self::Decltype(inner) => inner.span(),
16256 }
16257 }
16258}
16259#[derive(Debug, Clone)]
16260pub enum PointerDeclaratorDeclarator<'tree> {
16261 Declarator(::std::boxed::Box<Declarator<'tree>>),
16262 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
16263 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
16264}
16265impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorDeclarator<'tree> {
16266 #[allow(clippy::collapsible_else_if)]
16267 fn from_node(
16268 node: ::tree_sitter::Node<'tree>,
16269 src: &'tree [u8],
16270 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16271 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
16272 Ok(Self::Declarator(::std::boxed::Box::new(v)))
16273 } else {
16274 if let Ok(v) = <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src) {
16275 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
16276 } else {
16277 if let Ok(v) =
16278 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
16279 {
16280 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
16281 } else {
16282 Err(::treesitter_types::ParseError::unexpected_kind(
16283 node.kind(),
16284 node,
16285 ))
16286 }
16287 }
16288 }
16289 }
16290}
16291impl ::treesitter_types::Spanned for PointerDeclaratorDeclarator<'_> {
16292 fn span(&self) -> ::treesitter_types::Span {
16293 match self {
16294 Self::Declarator(inner) => inner.span(),
16295 Self::FieldDeclarator(inner) => inner.span(),
16296 Self::TypeDeclarator(inner) => inner.span(),
16297 }
16298 }
16299}
16300#[derive(Debug, Clone)]
16301pub enum PointerDeclaratorChildren<'tree> {
16302 MsBasedModifier(::std::boxed::Box<MsBasedModifier<'tree>>),
16303 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
16304 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16305}
16306impl<'tree> ::treesitter_types::FromNode<'tree> for PointerDeclaratorChildren<'tree> {
16307 #[allow(clippy::collapsible_else_if)]
16308 fn from_node(
16309 node: ::tree_sitter::Node<'tree>,
16310 src: &'tree [u8],
16311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16312 match node.kind() {
16313 "ms_based_modifier" => Ok(Self::MsBasedModifier(::std::boxed::Box::new(
16314 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16315 ))),
16316 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
16317 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16318 ))),
16319 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
16320 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16321 ))),
16322 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16323 }
16324 }
16325}
16326impl ::treesitter_types::Spanned for PointerDeclaratorChildren<'_> {
16327 fn span(&self) -> ::treesitter_types::Span {
16328 match self {
16329 Self::MsBasedModifier(inner) => inner.span(),
16330 Self::MsPointerModifier(inner) => inner.span(),
16331 Self::TypeQualifier(inner) => inner.span(),
16332 }
16333 }
16334}
16335#[derive(Debug, Clone)]
16336pub enum PointerExpressionOperator {
16337 Amp(::treesitter_types::Span),
16338 Star(::treesitter_types::Span),
16339}
16340impl<'tree> ::treesitter_types::FromNode<'tree> for PointerExpressionOperator {
16341 #[allow(clippy::collapsible_else_if)]
16342 fn from_node(
16343 node: ::tree_sitter::Node<'tree>,
16344 _src: &'tree [u8],
16345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16346 match node.kind() {
16347 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
16348 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
16349 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16350 }
16351 }
16352}
16353impl ::treesitter_types::Spanned for PointerExpressionOperator {
16354 fn span(&self) -> ::treesitter_types::Span {
16355 match self {
16356 Self::Amp(span) => *span,
16357 Self::Star(span) => *span,
16358 }
16359 }
16360}
16361#[derive(Debug, Clone)]
16362pub enum PointerTypeDeclaratorChildren<'tree> {
16363 MsBasedModifier(::std::boxed::Box<MsBasedModifier<'tree>>),
16364 MsPointerModifier(::std::boxed::Box<MsPointerModifier<'tree>>),
16365 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
16366}
16367impl<'tree> ::treesitter_types::FromNode<'tree> for PointerTypeDeclaratorChildren<'tree> {
16368 #[allow(clippy::collapsible_else_if)]
16369 fn from_node(
16370 node: ::tree_sitter::Node<'tree>,
16371 src: &'tree [u8],
16372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16373 match node.kind() {
16374 "ms_based_modifier" => Ok(Self::MsBasedModifier(::std::boxed::Box::new(
16375 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16376 ))),
16377 "ms_pointer_modifier" => Ok(Self::MsPointerModifier(::std::boxed::Box::new(
16378 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16379 ))),
16380 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
16381 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16382 ))),
16383 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16384 }
16385 }
16386}
16387impl ::treesitter_types::Spanned for PointerTypeDeclaratorChildren<'_> {
16388 fn span(&self) -> ::treesitter_types::Span {
16389 match self {
16390 Self::MsBasedModifier(inner) => inner.span(),
16391 Self::MsPointerModifier(inner) => inner.span(),
16392 Self::TypeQualifier(inner) => inner.span(),
16393 }
16394 }
16395}
16396#[derive(Debug, Clone)]
16397pub enum PreprocElifAlternative<'tree> {
16398 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
16399 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
16400 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
16401}
16402impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifAlternative<'tree> {
16403 #[allow(clippy::collapsible_else_if)]
16404 fn from_node(
16405 node: ::tree_sitter::Node<'tree>,
16406 src: &'tree [u8],
16407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16408 match node.kind() {
16409 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
16410 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
16411 ))),
16412 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
16413 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)?,
16414 ))),
16415 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
16416 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
16417 ))),
16418 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16419 }
16420 }
16421}
16422impl ::treesitter_types::Spanned for PreprocElifAlternative<'_> {
16423 fn span(&self) -> ::treesitter_types::Span {
16424 match self {
16425 Self::PreprocElif(inner) => inner.span(),
16426 Self::PreprocElifdef(inner) => inner.span(),
16427 Self::PreprocElse(inner) => inner.span(),
16428 }
16429 }
16430}
16431#[derive(Debug, Clone)]
16432pub enum PreprocElifCondition<'tree> {
16433 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
16434 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
16435 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
16436 Identifier(::std::boxed::Box<Identifier<'tree>>),
16437 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
16438 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
16439 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
16440 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
16441}
16442impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifCondition<'tree> {
16443 #[allow(clippy::collapsible_else_if)]
16444 fn from_node(
16445 node: ::tree_sitter::Node<'tree>,
16446 src: &'tree [u8],
16447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16448 match node.kind() {
16449 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
16450 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16451 ))),
16452 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
16453 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16454 ))),
16455 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
16456 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16457 ))),
16458 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
16459 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16460 ))),
16461 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
16462 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
16463 ))),
16464 "parenthesized_expression" => {
16465 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
16466 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
16467 node, src,
16468 )?,
16469 )))
16470 }
16471 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
16472 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
16473 ))),
16474 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
16475 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
16476 ))),
16477 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16478 }
16479 }
16480}
16481impl ::treesitter_types::Spanned for PreprocElifCondition<'_> {
16482 fn span(&self) -> ::treesitter_types::Span {
16483 match self {
16484 Self::BinaryExpression(inner) => inner.span(),
16485 Self::CallExpression(inner) => inner.span(),
16486 Self::CharLiteral(inner) => inner.span(),
16487 Self::Identifier(inner) => inner.span(),
16488 Self::NumberLiteral(inner) => inner.span(),
16489 Self::ParenthesizedExpression(inner) => inner.span(),
16490 Self::PreprocDefined(inner) => inner.span(),
16491 Self::UnaryExpression(inner) => inner.span(),
16492 }
16493 }
16494}
16495#[derive(Debug, Clone)]
16496pub enum PreprocElifChildren<'tree> {
16497 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
16498 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
16499 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
16500 Declaration(::std::boxed::Box<Declaration<'tree>>),
16501 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
16502 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
16503 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
16504 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
16505 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
16506 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
16507 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
16508 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
16509 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
16510 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
16511 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
16512 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
16513 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
16514 Statement(::std::boxed::Box<Statement<'tree>>),
16515 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
16516 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
16517 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
16518 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
16519 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
16520 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
16521}
16522impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifChildren<'tree> {
16523 #[allow(clippy::collapsible_else_if)]
16524 fn from_node(
16525 node: ::tree_sitter::Node<'tree>,
16526 src: &'tree [u8],
16527 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16528 match node.kind() {
16529 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
16530 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16531 ))),
16532 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
16533 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16534 ))),
16535 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
16536 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16537 ))),
16538 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16539 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16540 ))),
16541 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
16542 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
16543 ))),
16544 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
16545 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16546 ))),
16547 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
16548 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16549 ))),
16550 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
16551 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16552 ))),
16553 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
16554 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
16555 ))),
16556 "namespace_alias_definition" => {
16557 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
16558 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
16559 node, src,
16560 )?,
16561 )))
16562 }
16563 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
16564 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16565 ))),
16566 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
16567 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
16568 ))),
16569 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
16570 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16571 ))),
16572 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
16573 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16574 ))),
16575 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
16576 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
16577 ))),
16578 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
16579 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
16580 ))),
16581 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
16582 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
16583 ))),
16584 "static_assert_declaration" => {
16585 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
16586 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
16587 node, src,
16588 )?,
16589 )))
16590 }
16591 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
16592 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16593 ))),
16594 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
16595 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
16596 ))),
16597 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
16598 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16599 ))),
16600 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
16601 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16602 ))),
16603 _other => {
16604 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
16605 Ok(Self::Statement(::std::boxed::Box::new(v)))
16606 } else {
16607 if let Ok(v) =
16608 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16609 {
16610 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
16611 } else {
16612 Err(::treesitter_types::ParseError::unexpected_kind(
16613 _other, node,
16614 ))
16615 }
16616 }
16617 }
16618 }
16619 }
16620}
16621impl ::treesitter_types::Spanned for PreprocElifChildren<'_> {
16622 fn span(&self) -> ::treesitter_types::Span {
16623 match self {
16624 Self::AccessSpecifier(inner) => inner.span(),
16625 Self::AliasDeclaration(inner) => inner.span(),
16626 Self::ConceptDefinition(inner) => inner.span(),
16627 Self::Declaration(inner) => inner.span(),
16628 Self::Enumerator(inner) => inner.span(),
16629 Self::FieldDeclaration(inner) => inner.span(),
16630 Self::FriendDeclaration(inner) => inner.span(),
16631 Self::FunctionDefinition(inner) => inner.span(),
16632 Self::LinkageSpecification(inner) => inner.span(),
16633 Self::NamespaceAliasDefinition(inner) => inner.span(),
16634 Self::NamespaceDefinition(inner) => inner.span(),
16635 Self::PreprocCall(inner) => inner.span(),
16636 Self::PreprocDef(inner) => inner.span(),
16637 Self::PreprocFunctionDef(inner) => inner.span(),
16638 Self::PreprocIf(inner) => inner.span(),
16639 Self::PreprocIfdef(inner) => inner.span(),
16640 Self::PreprocInclude(inner) => inner.span(),
16641 Self::Statement(inner) => inner.span(),
16642 Self::StaticAssertDeclaration(inner) => inner.span(),
16643 Self::TemplateDeclaration(inner) => inner.span(),
16644 Self::TemplateInstantiation(inner) => inner.span(),
16645 Self::TypeDefinition(inner) => inner.span(),
16646 Self::TypeSpecifier(inner) => inner.span(),
16647 Self::UsingDeclaration(inner) => inner.span(),
16648 }
16649 }
16650}
16651#[derive(Debug, Clone)]
16652pub enum PreprocElifdefAlternative<'tree> {
16653 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
16654 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
16655 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
16656}
16657impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefAlternative<'tree> {
16658 #[allow(clippy::collapsible_else_if)]
16659 fn from_node(
16660 node: ::tree_sitter::Node<'tree>,
16661 src: &'tree [u8],
16662 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16663 match node.kind() {
16664 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
16665 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
16666 ))),
16667 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
16668 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)?,
16669 ))),
16670 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
16671 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
16672 ))),
16673 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16674 }
16675 }
16676}
16677impl ::treesitter_types::Spanned for PreprocElifdefAlternative<'_> {
16678 fn span(&self) -> ::treesitter_types::Span {
16679 match self {
16680 Self::PreprocElif(inner) => inner.span(),
16681 Self::PreprocElifdef(inner) => inner.span(),
16682 Self::PreprocElse(inner) => inner.span(),
16683 }
16684 }
16685}
16686#[derive(Debug, Clone)]
16687pub enum PreprocElifdefChildren<'tree> {
16688 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
16689 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
16690 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
16691 Declaration(::std::boxed::Box<Declaration<'tree>>),
16692 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
16693 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
16694 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
16695 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
16696 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
16697 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
16698 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
16699 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
16700 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
16701 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
16702 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
16703 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
16704 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
16705 Statement(::std::boxed::Box<Statement<'tree>>),
16706 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
16707 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
16708 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
16709 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
16710 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
16711 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
16712}
16713impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElifdefChildren<'tree> {
16714 #[allow(clippy::collapsible_else_if)]
16715 fn from_node(
16716 node: ::tree_sitter::Node<'tree>,
16717 src: &'tree [u8],
16718 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16719 match node.kind() {
16720 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
16721 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16722 ))),
16723 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
16724 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16725 ))),
16726 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
16727 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16728 ))),
16729 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16730 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16731 ))),
16732 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
16733 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
16734 ))),
16735 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
16736 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16737 ))),
16738 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
16739 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16740 ))),
16741 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
16742 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16743 ))),
16744 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
16745 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
16746 ))),
16747 "namespace_alias_definition" => {
16748 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
16749 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
16750 node, src,
16751 )?,
16752 )))
16753 }
16754 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
16755 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16756 ))),
16757 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
16758 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
16759 ))),
16760 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
16761 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16762 ))),
16763 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
16764 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16765 ))),
16766 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
16767 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
16768 ))),
16769 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
16770 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
16771 ))),
16772 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
16773 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
16774 ))),
16775 "static_assert_declaration" => {
16776 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
16777 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
16778 node, src,
16779 )?,
16780 )))
16781 }
16782 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
16783 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16784 ))),
16785 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
16786 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
16787 ))),
16788 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
16789 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16790 ))),
16791 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
16792 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16793 ))),
16794 _other => {
16795 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
16796 Ok(Self::Statement(::std::boxed::Box::new(v)))
16797 } else {
16798 if let Ok(v) =
16799 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16800 {
16801 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
16802 } else {
16803 Err(::treesitter_types::ParseError::unexpected_kind(
16804 _other, node,
16805 ))
16806 }
16807 }
16808 }
16809 }
16810 }
16811}
16812impl ::treesitter_types::Spanned for PreprocElifdefChildren<'_> {
16813 fn span(&self) -> ::treesitter_types::Span {
16814 match self {
16815 Self::AccessSpecifier(inner) => inner.span(),
16816 Self::AliasDeclaration(inner) => inner.span(),
16817 Self::ConceptDefinition(inner) => inner.span(),
16818 Self::Declaration(inner) => inner.span(),
16819 Self::Enumerator(inner) => inner.span(),
16820 Self::FieldDeclaration(inner) => inner.span(),
16821 Self::FriendDeclaration(inner) => inner.span(),
16822 Self::FunctionDefinition(inner) => inner.span(),
16823 Self::LinkageSpecification(inner) => inner.span(),
16824 Self::NamespaceAliasDefinition(inner) => inner.span(),
16825 Self::NamespaceDefinition(inner) => inner.span(),
16826 Self::PreprocCall(inner) => inner.span(),
16827 Self::PreprocDef(inner) => inner.span(),
16828 Self::PreprocFunctionDef(inner) => inner.span(),
16829 Self::PreprocIf(inner) => inner.span(),
16830 Self::PreprocIfdef(inner) => inner.span(),
16831 Self::PreprocInclude(inner) => inner.span(),
16832 Self::Statement(inner) => inner.span(),
16833 Self::StaticAssertDeclaration(inner) => inner.span(),
16834 Self::TemplateDeclaration(inner) => inner.span(),
16835 Self::TemplateInstantiation(inner) => inner.span(),
16836 Self::TypeDefinition(inner) => inner.span(),
16837 Self::TypeSpecifier(inner) => inner.span(),
16838 Self::UsingDeclaration(inner) => inner.span(),
16839 }
16840 }
16841}
16842#[derive(Debug, Clone)]
16843pub enum PreprocElseChildren<'tree> {
16844 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
16845 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
16846 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
16847 Declaration(::std::boxed::Box<Declaration<'tree>>),
16848 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
16849 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
16850 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
16851 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
16852 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
16853 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
16854 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
16855 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
16856 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
16857 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
16858 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
16859 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
16860 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
16861 Statement(::std::boxed::Box<Statement<'tree>>),
16862 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
16863 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
16864 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
16865 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
16866 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
16867 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
16868}
16869impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocElseChildren<'tree> {
16870 #[allow(clippy::collapsible_else_if)]
16871 fn from_node(
16872 node: ::tree_sitter::Node<'tree>,
16873 src: &'tree [u8],
16874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16875 match node.kind() {
16876 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
16877 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
16878 ))),
16879 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
16880 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16881 ))),
16882 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
16883 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16884 ))),
16885 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
16886 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16887 ))),
16888 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
16889 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
16890 ))),
16891 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
16892 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16893 ))),
16894 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
16895 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16896 ))),
16897 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
16898 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16899 ))),
16900 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
16901 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
16902 ))),
16903 "namespace_alias_definition" => {
16904 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
16905 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
16906 node, src,
16907 )?,
16908 )))
16909 }
16910 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
16911 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16912 ))),
16913 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
16914 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
16915 ))),
16916 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
16917 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16918 ))),
16919 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
16920 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
16921 ))),
16922 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
16923 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
16924 ))),
16925 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
16926 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
16927 ))),
16928 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
16929 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
16930 ))),
16931 "static_assert_declaration" => {
16932 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
16933 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
16934 node, src,
16935 )?,
16936 )))
16937 }
16938 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
16939 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16940 ))),
16941 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
16942 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
16943 ))),
16944 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
16945 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
16946 ))),
16947 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
16948 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
16949 ))),
16950 _other => {
16951 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
16952 Ok(Self::Statement(::std::boxed::Box::new(v)))
16953 } else {
16954 if let Ok(v) =
16955 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
16956 {
16957 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
16958 } else {
16959 Err(::treesitter_types::ParseError::unexpected_kind(
16960 _other, node,
16961 ))
16962 }
16963 }
16964 }
16965 }
16966 }
16967}
16968impl ::treesitter_types::Spanned for PreprocElseChildren<'_> {
16969 fn span(&self) -> ::treesitter_types::Span {
16970 match self {
16971 Self::AccessSpecifier(inner) => inner.span(),
16972 Self::AliasDeclaration(inner) => inner.span(),
16973 Self::ConceptDefinition(inner) => inner.span(),
16974 Self::Declaration(inner) => inner.span(),
16975 Self::Enumerator(inner) => inner.span(),
16976 Self::FieldDeclaration(inner) => inner.span(),
16977 Self::FriendDeclaration(inner) => inner.span(),
16978 Self::FunctionDefinition(inner) => inner.span(),
16979 Self::LinkageSpecification(inner) => inner.span(),
16980 Self::NamespaceAliasDefinition(inner) => inner.span(),
16981 Self::NamespaceDefinition(inner) => inner.span(),
16982 Self::PreprocCall(inner) => inner.span(),
16983 Self::PreprocDef(inner) => inner.span(),
16984 Self::PreprocFunctionDef(inner) => inner.span(),
16985 Self::PreprocIf(inner) => inner.span(),
16986 Self::PreprocIfdef(inner) => inner.span(),
16987 Self::PreprocInclude(inner) => inner.span(),
16988 Self::Statement(inner) => inner.span(),
16989 Self::StaticAssertDeclaration(inner) => inner.span(),
16990 Self::TemplateDeclaration(inner) => inner.span(),
16991 Self::TemplateInstantiation(inner) => inner.span(),
16992 Self::TypeDefinition(inner) => inner.span(),
16993 Self::TypeSpecifier(inner) => inner.span(),
16994 Self::UsingDeclaration(inner) => inner.span(),
16995 }
16996 }
16997}
16998#[derive(Debug, Clone)]
16999pub enum PreprocIfAlternative<'tree> {
17000 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17001 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
17002 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17003}
17004impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfAlternative<'tree> {
17005 #[allow(clippy::collapsible_else_if)]
17006 fn from_node(
17007 node: ::tree_sitter::Node<'tree>,
17008 src: &'tree [u8],
17009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17010 match node.kind() {
17011 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17012 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
17013 ))),
17014 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
17015 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)?,
17016 ))),
17017 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17018 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
17019 ))),
17020 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17021 }
17022 }
17023}
17024impl ::treesitter_types::Spanned for PreprocIfAlternative<'_> {
17025 fn span(&self) -> ::treesitter_types::Span {
17026 match self {
17027 Self::PreprocElif(inner) => inner.span(),
17028 Self::PreprocElifdef(inner) => inner.span(),
17029 Self::PreprocElse(inner) => inner.span(),
17030 }
17031 }
17032}
17033#[derive(Debug, Clone)]
17034pub enum PreprocIfCondition<'tree> {
17035 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
17036 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
17037 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
17038 Identifier(::std::boxed::Box<Identifier<'tree>>),
17039 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
17040 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
17041 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
17042 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
17043}
17044impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfCondition<'tree> {
17045 #[allow(clippy::collapsible_else_if)]
17046 fn from_node(
17047 node: ::tree_sitter::Node<'tree>,
17048 src: &'tree [u8],
17049 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17050 match node.kind() {
17051 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
17052 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17053 ))),
17054 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
17055 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17056 ))),
17057 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
17058 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17059 ))),
17060 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17061 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17062 ))),
17063 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
17064 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17065 ))),
17066 "parenthesized_expression" => {
17067 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
17068 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
17069 node, src,
17070 )?,
17071 )))
17072 }
17073 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
17074 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
17075 ))),
17076 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
17077 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17078 ))),
17079 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17080 }
17081 }
17082}
17083impl ::treesitter_types::Spanned for PreprocIfCondition<'_> {
17084 fn span(&self) -> ::treesitter_types::Span {
17085 match self {
17086 Self::BinaryExpression(inner) => inner.span(),
17087 Self::CallExpression(inner) => inner.span(),
17088 Self::CharLiteral(inner) => inner.span(),
17089 Self::Identifier(inner) => inner.span(),
17090 Self::NumberLiteral(inner) => inner.span(),
17091 Self::ParenthesizedExpression(inner) => inner.span(),
17092 Self::PreprocDefined(inner) => inner.span(),
17093 Self::UnaryExpression(inner) => inner.span(),
17094 }
17095 }
17096}
17097#[derive(Debug, Clone)]
17098pub enum PreprocIfChildren<'tree> {
17099 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
17100 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
17101 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
17102 Declaration(::std::boxed::Box<Declaration<'tree>>),
17103 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
17104 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
17105 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
17106 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
17107 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
17108 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
17109 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
17110 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
17111 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
17112 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
17113 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
17114 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
17115 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
17116 Statement(::std::boxed::Box<Statement<'tree>>),
17117 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
17118 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
17119 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
17120 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
17121 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
17122 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
17123}
17124impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfChildren<'tree> {
17125 #[allow(clippy::collapsible_else_if)]
17126 fn from_node(
17127 node: ::tree_sitter::Node<'tree>,
17128 src: &'tree [u8],
17129 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17130 match node.kind() {
17131 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
17132 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17133 ))),
17134 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
17135 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17136 ))),
17137 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
17138 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17139 ))),
17140 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
17141 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17142 ))),
17143 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
17144 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
17145 ))),
17146 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
17147 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17148 ))),
17149 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
17150 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17151 ))),
17152 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
17153 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17154 ))),
17155 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
17156 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
17157 ))),
17158 "namespace_alias_definition" => {
17159 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
17160 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
17161 node, src,
17162 )?,
17163 )))
17164 }
17165 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
17166 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17167 ))),
17168 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
17169 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
17170 ))),
17171 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
17172 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
17173 ))),
17174 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
17175 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
17176 ))),
17177 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
17178 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
17179 ))),
17180 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
17181 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
17182 ))),
17183 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
17184 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
17185 ))),
17186 "static_assert_declaration" => {
17187 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
17188 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
17189 node, src,
17190 )?,
17191 )))
17192 }
17193 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
17194 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17195 ))),
17196 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
17197 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
17198 ))),
17199 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
17200 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17201 ))),
17202 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
17203 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17204 ))),
17205 _other => {
17206 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
17207 Ok(Self::Statement(::std::boxed::Box::new(v)))
17208 } else {
17209 if let Ok(v) =
17210 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17211 {
17212 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
17213 } else {
17214 Err(::treesitter_types::ParseError::unexpected_kind(
17215 _other, node,
17216 ))
17217 }
17218 }
17219 }
17220 }
17221 }
17222}
17223impl ::treesitter_types::Spanned for PreprocIfChildren<'_> {
17224 fn span(&self) -> ::treesitter_types::Span {
17225 match self {
17226 Self::AccessSpecifier(inner) => inner.span(),
17227 Self::AliasDeclaration(inner) => inner.span(),
17228 Self::ConceptDefinition(inner) => inner.span(),
17229 Self::Declaration(inner) => inner.span(),
17230 Self::Enumerator(inner) => inner.span(),
17231 Self::FieldDeclaration(inner) => inner.span(),
17232 Self::FriendDeclaration(inner) => inner.span(),
17233 Self::FunctionDefinition(inner) => inner.span(),
17234 Self::LinkageSpecification(inner) => inner.span(),
17235 Self::NamespaceAliasDefinition(inner) => inner.span(),
17236 Self::NamespaceDefinition(inner) => inner.span(),
17237 Self::PreprocCall(inner) => inner.span(),
17238 Self::PreprocDef(inner) => inner.span(),
17239 Self::PreprocFunctionDef(inner) => inner.span(),
17240 Self::PreprocIf(inner) => inner.span(),
17241 Self::PreprocIfdef(inner) => inner.span(),
17242 Self::PreprocInclude(inner) => inner.span(),
17243 Self::Statement(inner) => inner.span(),
17244 Self::StaticAssertDeclaration(inner) => inner.span(),
17245 Self::TemplateDeclaration(inner) => inner.span(),
17246 Self::TemplateInstantiation(inner) => inner.span(),
17247 Self::TypeDefinition(inner) => inner.span(),
17248 Self::TypeSpecifier(inner) => inner.span(),
17249 Self::UsingDeclaration(inner) => inner.span(),
17250 }
17251 }
17252}
17253#[derive(Debug, Clone)]
17254pub enum PreprocIfdefAlternative<'tree> {
17255 PreprocElif(::std::boxed::Box<PreprocElif<'tree>>),
17256 PreprocElifdef(::std::boxed::Box<PreprocElifdef<'tree>>),
17257 PreprocElse(::std::boxed::Box<PreprocElse<'tree>>),
17258}
17259impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefAlternative<'tree> {
17260 #[allow(clippy::collapsible_else_if)]
17261 fn from_node(
17262 node: ::tree_sitter::Node<'tree>,
17263 src: &'tree [u8],
17264 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17265 match node.kind() {
17266 "preproc_elif" => Ok(Self::PreprocElif(::std::boxed::Box::new(
17267 <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)?,
17268 ))),
17269 "preproc_elifdef" => Ok(Self::PreprocElifdef(::std::boxed::Box::new(
17270 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)?,
17271 ))),
17272 "preproc_else" => Ok(Self::PreprocElse(::std::boxed::Box::new(
17273 <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)?,
17274 ))),
17275 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17276 }
17277 }
17278}
17279impl ::treesitter_types::Spanned for PreprocIfdefAlternative<'_> {
17280 fn span(&self) -> ::treesitter_types::Span {
17281 match self {
17282 Self::PreprocElif(inner) => inner.span(),
17283 Self::PreprocElifdef(inner) => inner.span(),
17284 Self::PreprocElse(inner) => inner.span(),
17285 }
17286 }
17287}
17288#[derive(Debug, Clone)]
17289pub enum PreprocIfdefChildren<'tree> {
17290 AccessSpecifier(::std::boxed::Box<AccessSpecifier<'tree>>),
17291 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
17292 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
17293 Declaration(::std::boxed::Box<Declaration<'tree>>),
17294 Enumerator(::std::boxed::Box<Enumerator<'tree>>),
17295 FieldDeclaration(::std::boxed::Box<FieldDeclaration<'tree>>),
17296 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
17297 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
17298 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
17299 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
17300 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
17301 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
17302 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
17303 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
17304 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
17305 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
17306 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
17307 Statement(::std::boxed::Box<Statement<'tree>>),
17308 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
17309 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
17310 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
17311 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
17312 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
17313 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
17314}
17315impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIfdefChildren<'tree> {
17316 #[allow(clippy::collapsible_else_if)]
17317 fn from_node(
17318 node: ::tree_sitter::Node<'tree>,
17319 src: &'tree [u8],
17320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17321 match node.kind() {
17322 "access_specifier" => Ok(Self::AccessSpecifier(::std::boxed::Box::new(
17323 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17324 ))),
17325 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
17326 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17327 ))),
17328 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
17329 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17330 ))),
17331 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
17332 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17333 ))),
17334 "enumerator" => Ok(Self::Enumerator(::std::boxed::Box::new(
17335 <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)?,
17336 ))),
17337 "field_declaration" => Ok(Self::FieldDeclaration(::std::boxed::Box::new(
17338 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17339 ))),
17340 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
17341 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17342 ))),
17343 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
17344 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17345 ))),
17346 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
17347 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
17348 ))),
17349 "namespace_alias_definition" => {
17350 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
17351 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
17352 node, src,
17353 )?,
17354 )))
17355 }
17356 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
17357 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17358 ))),
17359 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
17360 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
17361 ))),
17362 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
17363 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
17364 ))),
17365 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
17366 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
17367 ))),
17368 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
17369 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
17370 ))),
17371 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
17372 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
17373 ))),
17374 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
17375 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
17376 ))),
17377 "static_assert_declaration" => {
17378 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
17379 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
17380 node, src,
17381 )?,
17382 )))
17383 }
17384 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
17385 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17386 ))),
17387 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
17388 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
17389 ))),
17390 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
17391 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
17392 ))),
17393 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
17394 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
17395 ))),
17396 _other => {
17397 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
17398 Ok(Self::Statement(::std::boxed::Box::new(v)))
17399 } else {
17400 if let Ok(v) =
17401 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
17402 {
17403 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
17404 } else {
17405 Err(::treesitter_types::ParseError::unexpected_kind(
17406 _other, node,
17407 ))
17408 }
17409 }
17410 }
17411 }
17412 }
17413}
17414impl ::treesitter_types::Spanned for PreprocIfdefChildren<'_> {
17415 fn span(&self) -> ::treesitter_types::Span {
17416 match self {
17417 Self::AccessSpecifier(inner) => inner.span(),
17418 Self::AliasDeclaration(inner) => inner.span(),
17419 Self::ConceptDefinition(inner) => inner.span(),
17420 Self::Declaration(inner) => inner.span(),
17421 Self::Enumerator(inner) => inner.span(),
17422 Self::FieldDeclaration(inner) => inner.span(),
17423 Self::FriendDeclaration(inner) => inner.span(),
17424 Self::FunctionDefinition(inner) => inner.span(),
17425 Self::LinkageSpecification(inner) => inner.span(),
17426 Self::NamespaceAliasDefinition(inner) => inner.span(),
17427 Self::NamespaceDefinition(inner) => inner.span(),
17428 Self::PreprocCall(inner) => inner.span(),
17429 Self::PreprocDef(inner) => inner.span(),
17430 Self::PreprocFunctionDef(inner) => inner.span(),
17431 Self::PreprocIf(inner) => inner.span(),
17432 Self::PreprocIfdef(inner) => inner.span(),
17433 Self::PreprocInclude(inner) => inner.span(),
17434 Self::Statement(inner) => inner.span(),
17435 Self::StaticAssertDeclaration(inner) => inner.span(),
17436 Self::TemplateDeclaration(inner) => inner.span(),
17437 Self::TemplateInstantiation(inner) => inner.span(),
17438 Self::TypeDefinition(inner) => inner.span(),
17439 Self::TypeSpecifier(inner) => inner.span(),
17440 Self::UsingDeclaration(inner) => inner.span(),
17441 }
17442 }
17443}
17444#[derive(Debug, Clone)]
17445pub enum PreprocIncludePath<'tree> {
17446 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
17447 Identifier(::std::boxed::Box<Identifier<'tree>>),
17448 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
17449 SystemLibString(::std::boxed::Box<SystemLibString<'tree>>),
17450}
17451impl<'tree> ::treesitter_types::FromNode<'tree> for PreprocIncludePath<'tree> {
17452 #[allow(clippy::collapsible_else_if)]
17453 fn from_node(
17454 node: ::tree_sitter::Node<'tree>,
17455 src: &'tree [u8],
17456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17457 match node.kind() {
17458 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
17459 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17460 ))),
17461 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17462 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17463 ))),
17464 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
17465 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17466 ))),
17467 "system_lib_string" => Ok(Self::SystemLibString(::std::boxed::Box::new(
17468 <SystemLibString as ::treesitter_types::FromNode>::from_node(node, src)?,
17469 ))),
17470 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17471 }
17472 }
17473}
17474impl ::treesitter_types::Spanned for PreprocIncludePath<'_> {
17475 fn span(&self) -> ::treesitter_types::Span {
17476 match self {
17477 Self::CallExpression(inner) => inner.span(),
17478 Self::Identifier(inner) => inner.span(),
17479 Self::StringLiteral(inner) => inner.span(),
17480 Self::SystemLibString(inner) => inner.span(),
17481 }
17482 }
17483}
17484#[derive(Debug, Clone)]
17485pub enum QualifiedIdentifierName<'tree> {
17486 DependentName(::std::boxed::Box<DependentName<'tree>>),
17487 DestructorName(::std::boxed::Box<DestructorName<'tree>>),
17488 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
17489 Identifier(::std::boxed::Box<Identifier<'tree>>),
17490 OperatorCast(::std::boxed::Box<OperatorCast<'tree>>),
17491 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
17492 PointerTypeDeclarator(::std::boxed::Box<PointerTypeDeclarator<'tree>>),
17493 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
17494 Template(::treesitter_types::Span),
17495 TemplateFunction(::std::boxed::Box<TemplateFunction<'tree>>),
17496 TemplateMethod(::std::boxed::Box<TemplateMethod<'tree>>),
17497 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
17498 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
17499}
17500impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifierName<'tree> {
17501 #[allow(clippy::collapsible_else_if)]
17502 fn from_node(
17503 node: ::tree_sitter::Node<'tree>,
17504 src: &'tree [u8],
17505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17506 match node.kind() {
17507 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
17508 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)?,
17509 ))),
17510 "destructor_name" => Ok(Self::DestructorName(::std::boxed::Box::new(
17511 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)?,
17512 ))),
17513 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
17514 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17515 ))),
17516 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
17517 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17518 ))),
17519 "operator_cast" => Ok(Self::OperatorCast(::std::boxed::Box::new(
17520 <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)?,
17521 ))),
17522 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
17523 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)?,
17524 ))),
17525 "pointer_type_declarator" => Ok(Self::PointerTypeDeclarator(::std::boxed::Box::new(
17526 <PointerTypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
17527 ))),
17528 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
17529 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17530 ))),
17531 "template" => Ok(Self::Template(::treesitter_types::Span::from(node))),
17532 "template_function" => Ok(Self::TemplateFunction(::std::boxed::Box::new(
17533 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
17534 ))),
17535 "template_method" => Ok(Self::TemplateMethod(::std::boxed::Box::new(
17536 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)?,
17537 ))),
17538 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
17539 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
17540 ))),
17541 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
17542 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17543 ))),
17544 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17545 }
17546 }
17547}
17548impl ::treesitter_types::Spanned for QualifiedIdentifierName<'_> {
17549 fn span(&self) -> ::treesitter_types::Span {
17550 match self {
17551 Self::DependentName(inner) => inner.span(),
17552 Self::DestructorName(inner) => inner.span(),
17553 Self::FieldIdentifier(inner) => inner.span(),
17554 Self::Identifier(inner) => inner.span(),
17555 Self::OperatorCast(inner) => inner.span(),
17556 Self::OperatorName(inner) => inner.span(),
17557 Self::PointerTypeDeclarator(inner) => inner.span(),
17558 Self::QualifiedIdentifier(inner) => inner.span(),
17559 Self::Template(span) => *span,
17560 Self::TemplateFunction(inner) => inner.span(),
17561 Self::TemplateMethod(inner) => inner.span(),
17562 Self::TemplateType(inner) => inner.span(),
17563 Self::TypeIdentifier(inner) => inner.span(),
17564 }
17565 }
17566}
17567#[derive(Debug, Clone)]
17568pub enum QualifiedIdentifierScope<'tree> {
17569 Decltype(::std::boxed::Box<Decltype<'tree>>),
17570 DependentName(::std::boxed::Box<DependentName<'tree>>),
17571 NamespaceIdentifier(::std::boxed::Box<NamespaceIdentifier<'tree>>),
17572 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
17573}
17574impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedIdentifierScope<'tree> {
17575 #[allow(clippy::collapsible_else_if)]
17576 fn from_node(
17577 node: ::tree_sitter::Node<'tree>,
17578 src: &'tree [u8],
17579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17580 match node.kind() {
17581 "decltype" => Ok(Self::Decltype(::std::boxed::Box::new(
17582 <Decltype as ::treesitter_types::FromNode>::from_node(node, src)?,
17583 ))),
17584 "dependent_name" => Ok(Self::DependentName(::std::boxed::Box::new(
17585 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)?,
17586 ))),
17587 "namespace_identifier" => Ok(Self::NamespaceIdentifier(::std::boxed::Box::new(
17588 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17589 ))),
17590 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
17591 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
17592 ))),
17593 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17594 }
17595 }
17596}
17597impl ::treesitter_types::Spanned for QualifiedIdentifierScope<'_> {
17598 fn span(&self) -> ::treesitter_types::Span {
17599 match self {
17600 Self::Decltype(inner) => inner.span(),
17601 Self::DependentName(inner) => inner.span(),
17602 Self::NamespaceIdentifier(inner) => inner.span(),
17603 Self::TemplateType(inner) => inner.span(),
17604 }
17605 }
17606}
17607#[derive(Debug, Clone)]
17608pub enum RawStringLiteralChildren<'tree> {
17609 RawStringContent(::std::boxed::Box<RawStringContent<'tree>>),
17610 RawStringDelimiter(::std::boxed::Box<RawStringDelimiter<'tree>>),
17611}
17612impl<'tree> ::treesitter_types::FromNode<'tree> for RawStringLiteralChildren<'tree> {
17613 #[allow(clippy::collapsible_else_if)]
17614 fn from_node(
17615 node: ::tree_sitter::Node<'tree>,
17616 src: &'tree [u8],
17617 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17618 match node.kind() {
17619 "raw_string_content" => Ok(Self::RawStringContent(::std::boxed::Box::new(
17620 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
17621 ))),
17622 "raw_string_delimiter" => Ok(Self::RawStringDelimiter(::std::boxed::Box::new(
17623 <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(node, src)?,
17624 ))),
17625 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17626 }
17627 }
17628}
17629impl ::treesitter_types::Spanned for RawStringLiteralChildren<'_> {
17630 fn span(&self) -> ::treesitter_types::Span {
17631 match self {
17632 Self::RawStringContent(inner) => inner.span(),
17633 Self::RawStringDelimiter(inner) => inner.span(),
17634 }
17635 }
17636}
17637#[derive(Debug, Clone)]
17638pub enum ReferenceDeclaratorChildren<'tree> {
17639 Declarator(::std::boxed::Box<Declarator<'tree>>),
17640 FieldDeclarator(::std::boxed::Box<FieldDeclarator<'tree>>),
17641 TypeDeclarator(::std::boxed::Box<TypeDeclarator<'tree>>),
17642 VariadicDeclarator(::std::boxed::Box<VariadicDeclarator<'tree>>),
17643}
17644impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceDeclaratorChildren<'tree> {
17645 #[allow(clippy::collapsible_else_if)]
17646 fn from_node(
17647 node: ::tree_sitter::Node<'tree>,
17648 src: &'tree [u8],
17649 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17650 match node.kind() {
17651 "variadic_declarator" => Ok(Self::VariadicDeclarator(::std::boxed::Box::new(
17652 <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
17653 ))),
17654 _other => {
17655 if let Ok(v) = <Declarator as ::treesitter_types::FromNode>::from_node(node, src) {
17656 Ok(Self::Declarator(::std::boxed::Box::new(v)))
17657 } else {
17658 if let Ok(v) =
17659 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17660 {
17661 Ok(Self::FieldDeclarator(::std::boxed::Box::new(v)))
17662 } else {
17663 if let Ok(v) =
17664 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
17665 {
17666 Ok(Self::TypeDeclarator(::std::boxed::Box::new(v)))
17667 } else {
17668 Err(::treesitter_types::ParseError::unexpected_kind(
17669 _other, node,
17670 ))
17671 }
17672 }
17673 }
17674 }
17675 }
17676 }
17677}
17678impl ::treesitter_types::Spanned for ReferenceDeclaratorChildren<'_> {
17679 fn span(&self) -> ::treesitter_types::Span {
17680 match self {
17681 Self::Declarator(inner) => inner.span(),
17682 Self::FieldDeclarator(inner) => inner.span(),
17683 Self::TypeDeclarator(inner) => inner.span(),
17684 Self::VariadicDeclarator(inner) => inner.span(),
17685 }
17686 }
17687}
17688#[derive(Debug, Clone)]
17689pub enum RequirementSeqChildren<'tree> {
17690 CompoundRequirement(::std::boxed::Box<CompoundRequirement<'tree>>),
17691 SimpleRequirement(::std::boxed::Box<SimpleRequirement<'tree>>),
17692 TypeRequirement(::std::boxed::Box<TypeRequirement<'tree>>),
17693}
17694impl<'tree> ::treesitter_types::FromNode<'tree> for RequirementSeqChildren<'tree> {
17695 #[allow(clippy::collapsible_else_if)]
17696 fn from_node(
17697 node: ::tree_sitter::Node<'tree>,
17698 src: &'tree [u8],
17699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17700 match node.kind() {
17701 "compound_requirement" => Ok(Self::CompoundRequirement(::std::boxed::Box::new(
17702 <CompoundRequirement as ::treesitter_types::FromNode>::from_node(node, src)?,
17703 ))),
17704 "simple_requirement" => Ok(Self::SimpleRequirement(::std::boxed::Box::new(
17705 <SimpleRequirement as ::treesitter_types::FromNode>::from_node(node, src)?,
17706 ))),
17707 "type_requirement" => Ok(Self::TypeRequirement(::std::boxed::Box::new(
17708 <TypeRequirement as ::treesitter_types::FromNode>::from_node(node, src)?,
17709 ))),
17710 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17711 }
17712 }
17713}
17714impl ::treesitter_types::Spanned for RequirementSeqChildren<'_> {
17715 fn span(&self) -> ::treesitter_types::Span {
17716 match self {
17717 Self::CompoundRequirement(inner) => inner.span(),
17718 Self::SimpleRequirement(inner) => inner.span(),
17719 Self::TypeRequirement(inner) => inner.span(),
17720 }
17721 }
17722}
17723#[derive(Debug, Clone)]
17724pub enum RequiresClauseConstraint<'tree> {
17725 LParen(::treesitter_types::Span),
17726 RParen(::treesitter_types::Span),
17727 ConstraintConjunction(::std::boxed::Box<ConstraintConjunction<'tree>>),
17728 ConstraintDisjunction(::std::boxed::Box<ConstraintDisjunction<'tree>>),
17729 Expression(::std::boxed::Box<Expression<'tree>>),
17730 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
17731 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
17732}
17733impl<'tree> ::treesitter_types::FromNode<'tree> for RequiresClauseConstraint<'tree> {
17734 #[allow(clippy::collapsible_else_if)]
17735 fn from_node(
17736 node: ::tree_sitter::Node<'tree>,
17737 src: &'tree [u8],
17738 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17739 match node.kind() {
17740 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
17741 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
17742 "constraint_conjunction" => Ok(Self::ConstraintConjunction(::std::boxed::Box::new(
17743 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
17744 ))),
17745 "constraint_disjunction" => Ok(Self::ConstraintDisjunction(::std::boxed::Box::new(
17746 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)?,
17747 ))),
17748 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
17749 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
17750 ))),
17751 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
17752 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17753 ))),
17754 _other => {
17755 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17756 Ok(Self::Expression(::std::boxed::Box::new(v)))
17757 } else {
17758 Err(::treesitter_types::ParseError::unexpected_kind(
17759 _other, node,
17760 ))
17761 }
17762 }
17763 }
17764 }
17765}
17766impl ::treesitter_types::Spanned for RequiresClauseConstraint<'_> {
17767 fn span(&self) -> ::treesitter_types::Span {
17768 match self {
17769 Self::LParen(span) => *span,
17770 Self::RParen(span) => *span,
17771 Self::ConstraintConjunction(inner) => inner.span(),
17772 Self::ConstraintDisjunction(inner) => inner.span(),
17773 Self::Expression(inner) => inner.span(),
17774 Self::TemplateType(inner) => inner.span(),
17775 Self::TypeIdentifier(inner) => inner.span(),
17776 }
17777 }
17778}
17779#[derive(Debug, Clone)]
17780pub enum ReturnStatementChildren<'tree> {
17781 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
17782 Expression(::std::boxed::Box<Expression<'tree>>),
17783 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
17784}
17785impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
17786 #[allow(clippy::collapsible_else_if)]
17787 fn from_node(
17788 node: ::tree_sitter::Node<'tree>,
17789 src: &'tree [u8],
17790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17791 match node.kind() {
17792 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
17793 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17794 ))),
17795 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
17796 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
17797 ))),
17798 _other => {
17799 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17800 Ok(Self::Expression(::std::boxed::Box::new(v)))
17801 } else {
17802 Err(::treesitter_types::ParseError::unexpected_kind(
17803 _other, node,
17804 ))
17805 }
17806 }
17807 }
17808 }
17809}
17810impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
17811 fn span(&self) -> ::treesitter_types::Span {
17812 match self {
17813 Self::CommaExpression(inner) => inner.span(),
17814 Self::Expression(inner) => inner.span(),
17815 Self::InitializerList(inner) => inner.span(),
17816 }
17817 }
17818}
17819#[derive(Debug, Clone)]
17820pub enum SehTryStatementChildren<'tree> {
17821 SehExceptClause(::std::boxed::Box<SehExceptClause<'tree>>),
17822 SehFinallyClause(::std::boxed::Box<SehFinallyClause<'tree>>),
17823}
17824impl<'tree> ::treesitter_types::FromNode<'tree> for SehTryStatementChildren<'tree> {
17825 #[allow(clippy::collapsible_else_if)]
17826 fn from_node(
17827 node: ::tree_sitter::Node<'tree>,
17828 src: &'tree [u8],
17829 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17830 match node.kind() {
17831 "seh_except_clause" => Ok(Self::SehExceptClause(::std::boxed::Box::new(
17832 <SehExceptClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17833 ))),
17834 "seh_finally_clause" => Ok(Self::SehFinallyClause(::std::boxed::Box::new(
17835 <SehFinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
17836 ))),
17837 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17838 }
17839 }
17840}
17841impl ::treesitter_types::Spanned for SehTryStatementChildren<'_> {
17842 fn span(&self) -> ::treesitter_types::Span {
17843 match self {
17844 Self::SehExceptClause(inner) => inner.span(),
17845 Self::SehFinallyClause(inner) => inner.span(),
17846 }
17847 }
17848}
17849#[derive(Debug, Clone)]
17850pub enum SimpleRequirementChildren<'tree> {
17851 CommaExpression(::std::boxed::Box<CommaExpression<'tree>>),
17852 Expression(::std::boxed::Box<Expression<'tree>>),
17853}
17854impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleRequirementChildren<'tree> {
17855 #[allow(clippy::collapsible_else_if)]
17856 fn from_node(
17857 node: ::tree_sitter::Node<'tree>,
17858 src: &'tree [u8],
17859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17860 match node.kind() {
17861 "comma_expression" => Ok(Self::CommaExpression(::std::boxed::Box::new(
17862 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
17863 ))),
17864 _other => {
17865 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
17866 Ok(Self::Expression(::std::boxed::Box::new(v)))
17867 } else {
17868 Err(::treesitter_types::ParseError::unexpected_kind(
17869 _other, node,
17870 ))
17871 }
17872 }
17873 }
17874 }
17875}
17876impl ::treesitter_types::Spanned for SimpleRequirementChildren<'_> {
17877 fn span(&self) -> ::treesitter_types::Span {
17878 match self {
17879 Self::CommaExpression(inner) => inner.span(),
17880 Self::Expression(inner) => inner.span(),
17881 }
17882 }
17883}
17884#[derive(Debug, Clone)]
17885pub enum SizedTypeSpecifierType<'tree> {
17886 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
17887 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
17888}
17889impl<'tree> ::treesitter_types::FromNode<'tree> for SizedTypeSpecifierType<'tree> {
17890 #[allow(clippy::collapsible_else_if)]
17891 fn from_node(
17892 node: ::tree_sitter::Node<'tree>,
17893 src: &'tree [u8],
17894 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17895 match node.kind() {
17896 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
17897 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
17898 ))),
17899 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
17900 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17901 ))),
17902 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17903 }
17904 }
17905}
17906impl ::treesitter_types::Spanned for SizedTypeSpecifierType<'_> {
17907 fn span(&self) -> ::treesitter_types::Span {
17908 match self {
17909 Self::PrimitiveType(inner) => inner.span(),
17910 Self::TypeIdentifier(inner) => inner.span(),
17911 }
17912 }
17913}
17914#[derive(Debug, Clone)]
17915pub enum StaticAssertDeclarationMessage<'tree> {
17916 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
17917 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
17918 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
17919}
17920impl<'tree> ::treesitter_types::FromNode<'tree> for StaticAssertDeclarationMessage<'tree> {
17921 #[allow(clippy::collapsible_else_if)]
17922 fn from_node(
17923 node: ::tree_sitter::Node<'tree>,
17924 src: &'tree [u8],
17925 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17926 match node.kind() {
17927 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
17928 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)?,
17929 ))),
17930 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
17931 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17932 ))),
17933 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
17934 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
17935 ))),
17936 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17937 }
17938 }
17939}
17940impl ::treesitter_types::Spanned for StaticAssertDeclarationMessage<'_> {
17941 fn span(&self) -> ::treesitter_types::Span {
17942 match self {
17943 Self::ConcatenatedString(inner) => inner.span(),
17944 Self::RawStringLiteral(inner) => inner.span(),
17945 Self::StringLiteral(inner) => inner.span(),
17946 }
17947 }
17948}
17949#[derive(Debug, Clone)]
17950pub enum StringLiteralChildren<'tree> {
17951 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
17952 StringContent(::std::boxed::Box<StringContent<'tree>>),
17953}
17954impl<'tree> ::treesitter_types::FromNode<'tree> for StringLiteralChildren<'tree> {
17955 #[allow(clippy::collapsible_else_if)]
17956 fn from_node(
17957 node: ::tree_sitter::Node<'tree>,
17958 src: &'tree [u8],
17959 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17960 match node.kind() {
17961 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
17962 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
17963 ))),
17964 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
17965 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
17966 ))),
17967 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
17968 }
17969 }
17970}
17971impl ::treesitter_types::Spanned for StringLiteralChildren<'_> {
17972 fn span(&self) -> ::treesitter_types::Span {
17973 match self {
17974 Self::EscapeSequence(inner) => inner.span(),
17975 Self::StringContent(inner) => inner.span(),
17976 }
17977 }
17978}
17979#[derive(Debug, Clone)]
17980pub enum StructSpecifierName<'tree> {
17981 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
17982 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
17983 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
17984}
17985impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifierName<'tree> {
17986 #[allow(clippy::collapsible_else_if)]
17987 fn from_node(
17988 node: ::tree_sitter::Node<'tree>,
17989 src: &'tree [u8],
17990 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17991 match node.kind() {
17992 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
17993 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
17994 ))),
17995 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
17996 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
17997 ))),
17998 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
17999 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18000 ))),
18001 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18002 }
18003 }
18004}
18005impl ::treesitter_types::Spanned for StructSpecifierName<'_> {
18006 fn span(&self) -> ::treesitter_types::Span {
18007 match self {
18008 Self::QualifiedIdentifier(inner) => inner.span(),
18009 Self::TemplateType(inner) => inner.span(),
18010 Self::TypeIdentifier(inner) => inner.span(),
18011 }
18012 }
18013}
18014#[derive(Debug, Clone)]
18015pub enum StructSpecifierChildren<'tree> {
18016 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
18017 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
18018 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
18019 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
18020 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
18021 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
18022}
18023impl<'tree> ::treesitter_types::FromNode<'tree> for StructSpecifierChildren<'tree> {
18024 #[allow(clippy::collapsible_else_if)]
18025 fn from_node(
18026 node: ::tree_sitter::Node<'tree>,
18027 src: &'tree [u8],
18028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18029 match node.kind() {
18030 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
18031 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18032 ))),
18033 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
18034 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18035 ))),
18036 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
18037 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18038 ))),
18039 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
18040 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)?,
18041 ))),
18042 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
18043 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18044 ))),
18045 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
18046 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18047 ))),
18048 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18049 }
18050 }
18051}
18052impl ::treesitter_types::Spanned for StructSpecifierChildren<'_> {
18053 fn span(&self) -> ::treesitter_types::Span {
18054 match self {
18055 Self::AlignasQualifier(inner) => inner.span(),
18056 Self::AttributeDeclaration(inner) => inner.span(),
18057 Self::AttributeSpecifier(inner) => inner.span(),
18058 Self::BaseClassClause(inner) => inner.span(),
18059 Self::MsDeclspecModifier(inner) => inner.span(),
18060 Self::VirtualSpecifier(inner) => inner.span(),
18061 }
18062 }
18063}
18064#[derive(Debug, Clone)]
18065pub enum SubscriptArgumentListChildren<'tree> {
18066 Expression(::std::boxed::Box<Expression<'tree>>),
18067 InitializerList(::std::boxed::Box<InitializerList<'tree>>),
18068}
18069impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptArgumentListChildren<'tree> {
18070 #[allow(clippy::collapsible_else_if)]
18071 fn from_node(
18072 node: ::tree_sitter::Node<'tree>,
18073 src: &'tree [u8],
18074 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18075 match node.kind() {
18076 "initializer_list" => Ok(Self::InitializerList(::std::boxed::Box::new(
18077 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
18078 ))),
18079 _other => {
18080 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18081 Ok(Self::Expression(::std::boxed::Box::new(v)))
18082 } else {
18083 Err(::treesitter_types::ParseError::unexpected_kind(
18084 _other, node,
18085 ))
18086 }
18087 }
18088 }
18089 }
18090}
18091impl ::treesitter_types::Spanned for SubscriptArgumentListChildren<'_> {
18092 fn span(&self) -> ::treesitter_types::Span {
18093 match self {
18094 Self::Expression(inner) => inner.span(),
18095 Self::InitializerList(inner) => inner.span(),
18096 }
18097 }
18098}
18099#[derive(Debug, Clone)]
18100pub enum TemplateArgumentListChildren<'tree> {
18101 Expression(::std::boxed::Box<Expression<'tree>>),
18102 TypeDescriptor(::std::boxed::Box<TypeDescriptor<'tree>>),
18103}
18104impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateArgumentListChildren<'tree> {
18105 #[allow(clippy::collapsible_else_if)]
18106 fn from_node(
18107 node: ::tree_sitter::Node<'tree>,
18108 src: &'tree [u8],
18109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18110 match node.kind() {
18111 "type_descriptor" => Ok(Self::TypeDescriptor(::std::boxed::Box::new(
18112 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)?,
18113 ))),
18114 _other => {
18115 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18116 Ok(Self::Expression(::std::boxed::Box::new(v)))
18117 } else {
18118 Err(::treesitter_types::ParseError::unexpected_kind(
18119 _other, node,
18120 ))
18121 }
18122 }
18123 }
18124 }
18125}
18126impl ::treesitter_types::Spanned for TemplateArgumentListChildren<'_> {
18127 fn span(&self) -> ::treesitter_types::Span {
18128 match self {
18129 Self::Expression(inner) => inner.span(),
18130 Self::TypeDescriptor(inner) => inner.span(),
18131 }
18132 }
18133}
18134#[derive(Debug, Clone)]
18135pub enum TemplateDeclarationChildren<'tree> {
18136 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
18137 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
18138 Declaration(::std::boxed::Box<Declaration<'tree>>),
18139 FriendDeclaration(::std::boxed::Box<FriendDeclaration<'tree>>),
18140 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
18141 RequiresClause(::std::boxed::Box<RequiresClause<'tree>>),
18142 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
18143 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
18144}
18145impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateDeclarationChildren<'tree> {
18146 #[allow(clippy::collapsible_else_if)]
18147 fn from_node(
18148 node: ::tree_sitter::Node<'tree>,
18149 src: &'tree [u8],
18150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18151 match node.kind() {
18152 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
18153 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18154 ))),
18155 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
18156 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18157 ))),
18158 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
18159 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18160 ))),
18161 "friend_declaration" => Ok(Self::FriendDeclaration(::std::boxed::Box::new(
18162 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18163 ))),
18164 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
18165 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18166 ))),
18167 "requires_clause" => Ok(Self::RequiresClause(::std::boxed::Box::new(
18168 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)?,
18169 ))),
18170 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
18171 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18172 ))),
18173 _other => {
18174 if let Ok(v) = <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18175 {
18176 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18177 } else {
18178 Err(::treesitter_types::ParseError::unexpected_kind(
18179 _other, node,
18180 ))
18181 }
18182 }
18183 }
18184 }
18185}
18186impl ::treesitter_types::Spanned for TemplateDeclarationChildren<'_> {
18187 fn span(&self) -> ::treesitter_types::Span {
18188 match self {
18189 Self::AliasDeclaration(inner) => inner.span(),
18190 Self::ConceptDefinition(inner) => inner.span(),
18191 Self::Declaration(inner) => inner.span(),
18192 Self::FriendDeclaration(inner) => inner.span(),
18193 Self::FunctionDefinition(inner) => inner.span(),
18194 Self::RequiresClause(inner) => inner.span(),
18195 Self::TemplateDeclaration(inner) => inner.span(),
18196 Self::TypeSpecifier(inner) => inner.span(),
18197 }
18198 }
18199}
18200#[derive(Debug, Clone)]
18201pub enum TemplateInstantiationChildren<'tree> {
18202 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
18203 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
18204 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
18205 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
18206 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
18207}
18208impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateInstantiationChildren<'tree> {
18209 #[allow(clippy::collapsible_else_if)]
18210 fn from_node(
18211 node: ::tree_sitter::Node<'tree>,
18212 src: &'tree [u8],
18213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18214 match node.kind() {
18215 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
18216 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18217 ))),
18218 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
18219 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18220 ))),
18221 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
18222 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18223 ))),
18224 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
18225 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18226 ))),
18227 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
18228 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18229 ))),
18230 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18231 }
18232 }
18233}
18234impl ::treesitter_types::Spanned for TemplateInstantiationChildren<'_> {
18235 fn span(&self) -> ::treesitter_types::Span {
18236 match self {
18237 Self::AttributeDeclaration(inner) => inner.span(),
18238 Self::AttributeSpecifier(inner) => inner.span(),
18239 Self::MsDeclspecModifier(inner) => inner.span(),
18240 Self::StorageClassSpecifier(inner) => inner.span(),
18241 Self::TypeQualifier(inner) => inner.span(),
18242 }
18243 }
18244}
18245#[derive(Debug, Clone)]
18246pub enum TemplateMethodName<'tree> {
18247 FieldIdentifier(::std::boxed::Box<FieldIdentifier<'tree>>),
18248 OperatorName(::std::boxed::Box<OperatorName<'tree>>),
18249}
18250impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateMethodName<'tree> {
18251 #[allow(clippy::collapsible_else_if)]
18252 fn from_node(
18253 node: ::tree_sitter::Node<'tree>,
18254 src: &'tree [u8],
18255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18256 match node.kind() {
18257 "field_identifier" => Ok(Self::FieldIdentifier(::std::boxed::Box::new(
18258 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18259 ))),
18260 "operator_name" => Ok(Self::OperatorName(::std::boxed::Box::new(
18261 <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)?,
18262 ))),
18263 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18264 }
18265 }
18266}
18267impl ::treesitter_types::Spanned for TemplateMethodName<'_> {
18268 fn span(&self) -> ::treesitter_types::Span {
18269 match self {
18270 Self::FieldIdentifier(inner) => inner.span(),
18271 Self::OperatorName(inner) => inner.span(),
18272 }
18273 }
18274}
18275#[derive(Debug, Clone)]
18276pub enum TemplateParameterListChildren<'tree> {
18277 OptionalParameterDeclaration(::std::boxed::Box<OptionalParameterDeclaration<'tree>>),
18278 OptionalTypeParameterDeclaration(::std::boxed::Box<OptionalTypeParameterDeclaration<'tree>>),
18279 ParameterDeclaration(::std::boxed::Box<ParameterDeclaration<'tree>>),
18280 TemplateTemplateParameterDeclaration(
18281 ::std::boxed::Box<TemplateTemplateParameterDeclaration<'tree>>,
18282 ),
18283 TypeParameterDeclaration(::std::boxed::Box<TypeParameterDeclaration<'tree>>),
18284 VariadicParameterDeclaration(::std::boxed::Box<VariadicParameterDeclaration<'tree>>),
18285 VariadicTypeParameterDeclaration(::std::boxed::Box<VariadicTypeParameterDeclaration<'tree>>),
18286}
18287impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateParameterListChildren<'tree> {
18288 #[allow(clippy::collapsible_else_if)]
18289 fn from_node(
18290 node: ::tree_sitter::Node<'tree>,
18291 src: &'tree [u8],
18292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18293 match node.kind() {
18294 "optional_parameter_declaration" => {
18295 Ok(
18296 Self::OptionalParameterDeclaration(
18297 ::std::boxed::Box::new(
18298 <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18299 node,
18300 src,
18301 )?,
18302 ),
18303 ),
18304 )
18305 }
18306 "optional_type_parameter_declaration" => {
18307 Ok(
18308 Self::OptionalTypeParameterDeclaration(
18309 ::std::boxed::Box::new(
18310 <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18311 node,
18312 src,
18313 )?,
18314 ),
18315 ),
18316 )
18317 }
18318 "parameter_declaration" => {
18319 Ok(
18320 Self::ParameterDeclaration(
18321 ::std::boxed::Box::new(
18322 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18323 node,
18324 src,
18325 )?,
18326 ),
18327 ),
18328 )
18329 }
18330 "template_template_parameter_declaration" => {
18331 Ok(
18332 Self::TemplateTemplateParameterDeclaration(
18333 ::std::boxed::Box::new(
18334 <TemplateTemplateParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18335 node,
18336 src,
18337 )?,
18338 ),
18339 ),
18340 )
18341 }
18342 "type_parameter_declaration" => {
18343 Ok(
18344 Self::TypeParameterDeclaration(
18345 ::std::boxed::Box::new(
18346 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18347 node,
18348 src,
18349 )?,
18350 ),
18351 ),
18352 )
18353 }
18354 "variadic_parameter_declaration" => {
18355 Ok(
18356 Self::VariadicParameterDeclaration(
18357 ::std::boxed::Box::new(
18358 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18359 node,
18360 src,
18361 )?,
18362 ),
18363 ),
18364 )
18365 }
18366 "variadic_type_parameter_declaration" => {
18367 Ok(
18368 Self::VariadicTypeParameterDeclaration(
18369 ::std::boxed::Box::new(
18370 <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18371 node,
18372 src,
18373 )?,
18374 ),
18375 ),
18376 )
18377 }
18378 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18379 }
18380 }
18381}
18382impl ::treesitter_types::Spanned for TemplateParameterListChildren<'_> {
18383 fn span(&self) -> ::treesitter_types::Span {
18384 match self {
18385 Self::OptionalParameterDeclaration(inner) => inner.span(),
18386 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
18387 Self::ParameterDeclaration(inner) => inner.span(),
18388 Self::TemplateTemplateParameterDeclaration(inner) => inner.span(),
18389 Self::TypeParameterDeclaration(inner) => inner.span(),
18390 Self::VariadicParameterDeclaration(inner) => inner.span(),
18391 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
18392 }
18393 }
18394}
18395#[derive(Debug, Clone)]
18396pub enum TemplateTemplateParameterDeclarationChildren<'tree> {
18397 OptionalTypeParameterDeclaration(::std::boxed::Box<OptionalTypeParameterDeclaration<'tree>>),
18398 TypeParameterDeclaration(::std::boxed::Box<TypeParameterDeclaration<'tree>>),
18399 VariadicTypeParameterDeclaration(::std::boxed::Box<VariadicTypeParameterDeclaration<'tree>>),
18400}
18401impl<'tree> ::treesitter_types::FromNode<'tree>
18402 for TemplateTemplateParameterDeclarationChildren<'tree>
18403{
18404 #[allow(clippy::collapsible_else_if)]
18405 fn from_node(
18406 node: ::tree_sitter::Node<'tree>,
18407 src: &'tree [u8],
18408 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18409 match node.kind() {
18410 "optional_type_parameter_declaration" => Ok(Self::OptionalTypeParameterDeclaration(
18411 ::std::boxed::Box::new(
18412 <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18413 node, src,
18414 )?,
18415 ),
18416 )),
18417 "type_parameter_declaration" => {
18418 Ok(Self::TypeParameterDeclaration(::std::boxed::Box::new(
18419 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18420 node, src,
18421 )?,
18422 )))
18423 }
18424 "variadic_type_parameter_declaration" => Ok(Self::VariadicTypeParameterDeclaration(
18425 ::std::boxed::Box::new(
18426 <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
18427 node, src,
18428 )?,
18429 ),
18430 )),
18431 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18432 }
18433 }
18434}
18435impl ::treesitter_types::Spanned for TemplateTemplateParameterDeclarationChildren<'_> {
18436 fn span(&self) -> ::treesitter_types::Span {
18437 match self {
18438 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
18439 Self::TypeParameterDeclaration(inner) => inner.span(),
18440 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
18441 }
18442 }
18443}
18444#[derive(Debug, Clone)]
18445pub enum TranslationUnitChildren<'tree> {
18446 AliasDeclaration(::std::boxed::Box<AliasDeclaration<'tree>>),
18447 AttributedStatement(::std::boxed::Box<AttributedStatement<'tree>>),
18448 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
18449 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
18450 CoReturnStatement(::std::boxed::Box<CoReturnStatement<'tree>>),
18451 CoYieldStatement(::std::boxed::Box<CoYieldStatement<'tree>>),
18452 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
18453 ConceptDefinition(::std::boxed::Box<ConceptDefinition<'tree>>),
18454 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
18455 Declaration(::std::boxed::Box<Declaration<'tree>>),
18456 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
18457 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
18458 ForRangeLoop(::std::boxed::Box<ForRangeLoop<'tree>>),
18459 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
18460 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
18461 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
18462 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
18463 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
18464 LinkageSpecification(::std::boxed::Box<LinkageSpecification<'tree>>),
18465 NamespaceAliasDefinition(::std::boxed::Box<NamespaceAliasDefinition<'tree>>),
18466 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
18467 PreprocCall(::std::boxed::Box<PreprocCall<'tree>>),
18468 PreprocDef(::std::boxed::Box<PreprocDef<'tree>>),
18469 PreprocFunctionDef(::std::boxed::Box<PreprocFunctionDef<'tree>>),
18470 PreprocIf(::std::boxed::Box<PreprocIf<'tree>>),
18471 PreprocIfdef(::std::boxed::Box<PreprocIfdef<'tree>>),
18472 PreprocInclude(::std::boxed::Box<PreprocInclude<'tree>>),
18473 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
18474 StaticAssertDeclaration(::std::boxed::Box<StaticAssertDeclaration<'tree>>),
18475 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
18476 TemplateDeclaration(::std::boxed::Box<TemplateDeclaration<'tree>>),
18477 TemplateInstantiation(::std::boxed::Box<TemplateInstantiation<'tree>>),
18478 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
18479 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
18480 TypeDefinition(::std::boxed::Box<TypeDefinition<'tree>>),
18481 TypeSpecifier(::std::boxed::Box<TypeSpecifier<'tree>>),
18482 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
18483 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
18484}
18485impl<'tree> ::treesitter_types::FromNode<'tree> for TranslationUnitChildren<'tree> {
18486 #[allow(clippy::collapsible_else_if)]
18487 fn from_node(
18488 node: ::tree_sitter::Node<'tree>,
18489 src: &'tree [u8],
18490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18491 match node.kind() {
18492 "alias_declaration" => Ok(Self::AliasDeclaration(::std::boxed::Box::new(
18493 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18494 ))),
18495 "attributed_statement" => Ok(Self::AttributedStatement(::std::boxed::Box::new(
18496 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18497 ))),
18498 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
18499 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18500 ))),
18501 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
18502 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18503 ))),
18504 "co_return_statement" => Ok(Self::CoReturnStatement(::std::boxed::Box::new(
18505 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18506 ))),
18507 "co_yield_statement" => Ok(Self::CoYieldStatement(::std::boxed::Box::new(
18508 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18509 ))),
18510 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
18511 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18512 ))),
18513 "concept_definition" => Ok(Self::ConceptDefinition(::std::boxed::Box::new(
18514 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18515 ))),
18516 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
18517 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18518 ))),
18519 "declaration" => Ok(Self::Declaration(::std::boxed::Box::new(
18520 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18521 ))),
18522 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
18523 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18524 ))),
18525 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
18526 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18527 ))),
18528 "for_range_loop" => Ok(Self::ForRangeLoop(::std::boxed::Box::new(
18529 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)?,
18530 ))),
18531 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
18532 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18533 ))),
18534 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
18535 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18536 ))),
18537 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
18538 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18539 ))),
18540 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
18541 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18542 ))),
18543 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
18544 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18545 ))),
18546 "linkage_specification" => Ok(Self::LinkageSpecification(::std::boxed::Box::new(
18547 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)?,
18548 ))),
18549 "namespace_alias_definition" => {
18550 Ok(Self::NamespaceAliasDefinition(::std::boxed::Box::new(
18551 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(
18552 node, src,
18553 )?,
18554 )))
18555 }
18556 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
18557 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18558 ))),
18559 "preproc_call" => Ok(Self::PreprocCall(::std::boxed::Box::new(
18560 <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)?,
18561 ))),
18562 "preproc_def" => Ok(Self::PreprocDef(::std::boxed::Box::new(
18563 <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)?,
18564 ))),
18565 "preproc_function_def" => Ok(Self::PreprocFunctionDef(::std::boxed::Box::new(
18566 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)?,
18567 ))),
18568 "preproc_if" => Ok(Self::PreprocIf(::std::boxed::Box::new(
18569 <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)?,
18570 ))),
18571 "preproc_ifdef" => Ok(Self::PreprocIfdef(::std::boxed::Box::new(
18572 <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)?,
18573 ))),
18574 "preproc_include" => Ok(Self::PreprocInclude(::std::boxed::Box::new(
18575 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)?,
18576 ))),
18577 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
18578 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18579 ))),
18580 "static_assert_declaration" => {
18581 Ok(Self::StaticAssertDeclaration(::std::boxed::Box::new(
18582 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(
18583 node, src,
18584 )?,
18585 )))
18586 }
18587 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
18588 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18589 ))),
18590 "template_declaration" => Ok(Self::TemplateDeclaration(::std::boxed::Box::new(
18591 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18592 ))),
18593 "template_instantiation" => Ok(Self::TemplateInstantiation(::std::boxed::Box::new(
18594 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)?,
18595 ))),
18596 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
18597 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18598 ))),
18599 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
18600 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18601 ))),
18602 "type_definition" => Ok(Self::TypeDefinition(::std::boxed::Box::new(
18603 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
18604 ))),
18605 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
18606 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18607 ))),
18608 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
18609 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
18610 ))),
18611 _other => {
18612 if let Ok(v) = <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
18613 {
18614 Ok(Self::TypeSpecifier(::std::boxed::Box::new(v)))
18615 } else {
18616 Err(::treesitter_types::ParseError::unexpected_kind(
18617 _other, node,
18618 ))
18619 }
18620 }
18621 }
18622 }
18623}
18624impl ::treesitter_types::Spanned for TranslationUnitChildren<'_> {
18625 fn span(&self) -> ::treesitter_types::Span {
18626 match self {
18627 Self::AliasDeclaration(inner) => inner.span(),
18628 Self::AttributedStatement(inner) => inner.span(),
18629 Self::BreakStatement(inner) => inner.span(),
18630 Self::CaseStatement(inner) => inner.span(),
18631 Self::CoReturnStatement(inner) => inner.span(),
18632 Self::CoYieldStatement(inner) => inner.span(),
18633 Self::CompoundStatement(inner) => inner.span(),
18634 Self::ConceptDefinition(inner) => inner.span(),
18635 Self::ContinueStatement(inner) => inner.span(),
18636 Self::Declaration(inner) => inner.span(),
18637 Self::DoStatement(inner) => inner.span(),
18638 Self::ExpressionStatement(inner) => inner.span(),
18639 Self::ForRangeLoop(inner) => inner.span(),
18640 Self::ForStatement(inner) => inner.span(),
18641 Self::FunctionDefinition(inner) => inner.span(),
18642 Self::GotoStatement(inner) => inner.span(),
18643 Self::IfStatement(inner) => inner.span(),
18644 Self::LabeledStatement(inner) => inner.span(),
18645 Self::LinkageSpecification(inner) => inner.span(),
18646 Self::NamespaceAliasDefinition(inner) => inner.span(),
18647 Self::NamespaceDefinition(inner) => inner.span(),
18648 Self::PreprocCall(inner) => inner.span(),
18649 Self::PreprocDef(inner) => inner.span(),
18650 Self::PreprocFunctionDef(inner) => inner.span(),
18651 Self::PreprocIf(inner) => inner.span(),
18652 Self::PreprocIfdef(inner) => inner.span(),
18653 Self::PreprocInclude(inner) => inner.span(),
18654 Self::ReturnStatement(inner) => inner.span(),
18655 Self::StaticAssertDeclaration(inner) => inner.span(),
18656 Self::SwitchStatement(inner) => inner.span(),
18657 Self::TemplateDeclaration(inner) => inner.span(),
18658 Self::TemplateInstantiation(inner) => inner.span(),
18659 Self::ThrowStatement(inner) => inner.span(),
18660 Self::TryStatement(inner) => inner.span(),
18661 Self::TypeDefinition(inner) => inner.span(),
18662 Self::TypeSpecifier(inner) => inner.span(),
18663 Self::UsingDeclaration(inner) => inner.span(),
18664 Self::WhileStatement(inner) => inner.span(),
18665 }
18666 }
18667}
18668#[derive(Debug, Clone)]
18669pub enum TryStatementChildren<'tree> {
18670 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
18671 FieldInitializerList(::std::boxed::Box<FieldInitializerList<'tree>>),
18672}
18673impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
18674 #[allow(clippy::collapsible_else_if)]
18675 fn from_node(
18676 node: ::tree_sitter::Node<'tree>,
18677 src: &'tree [u8],
18678 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18679 match node.kind() {
18680 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
18681 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
18682 ))),
18683 "field_initializer_list" => Ok(Self::FieldInitializerList(::std::boxed::Box::new(
18684 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)?,
18685 ))),
18686 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18687 }
18688 }
18689}
18690impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
18691 fn span(&self) -> ::treesitter_types::Span {
18692 match self {
18693 Self::CatchClause(inner) => inner.span(),
18694 Self::FieldInitializerList(inner) => inner.span(),
18695 }
18696 }
18697}
18698#[derive(Debug, Clone)]
18699pub enum TypeDefinitionChildren<'tree> {
18700 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
18701 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
18702}
18703impl<'tree> ::treesitter_types::FromNode<'tree> for TypeDefinitionChildren<'tree> {
18704 #[allow(clippy::collapsible_else_if)]
18705 fn from_node(
18706 node: ::tree_sitter::Node<'tree>,
18707 src: &'tree [u8],
18708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18709 match node.kind() {
18710 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
18711 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18712 ))),
18713 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
18714 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18715 ))),
18716 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18717 }
18718 }
18719}
18720impl ::treesitter_types::Spanned for TypeDefinitionChildren<'_> {
18721 fn span(&self) -> ::treesitter_types::Span {
18722 match self {
18723 Self::AttributeSpecifier(inner) => inner.span(),
18724 Self::TypeQualifier(inner) => inner.span(),
18725 }
18726 }
18727}
18728#[derive(Debug, Clone)]
18729pub enum TypeRequirementChildren<'tree> {
18730 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
18731 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
18732 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
18733}
18734impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRequirementChildren<'tree> {
18735 #[allow(clippy::collapsible_else_if)]
18736 fn from_node(
18737 node: ::tree_sitter::Node<'tree>,
18738 src: &'tree [u8],
18739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18740 match node.kind() {
18741 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
18742 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18743 ))),
18744 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
18745 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
18746 ))),
18747 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
18748 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18749 ))),
18750 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18751 }
18752 }
18753}
18754impl ::treesitter_types::Spanned for TypeRequirementChildren<'_> {
18755 fn span(&self) -> ::treesitter_types::Span {
18756 match self {
18757 Self::QualifiedIdentifier(inner) => inner.span(),
18758 Self::TemplateType(inner) => inner.span(),
18759 Self::TypeIdentifier(inner) => inner.span(),
18760 }
18761 }
18762}
18763#[derive(Debug, Clone)]
18764pub enum UnaryExpressionArgument<'tree> {
18765 Expression(::std::boxed::Box<Expression<'tree>>),
18766 PreprocDefined(::std::boxed::Box<PreprocDefined<'tree>>),
18767}
18768impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
18769 #[allow(clippy::collapsible_else_if)]
18770 fn from_node(
18771 node: ::tree_sitter::Node<'tree>,
18772 src: &'tree [u8],
18773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18774 match node.kind() {
18775 "preproc_defined" => Ok(Self::PreprocDefined(::std::boxed::Box::new(
18776 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)?,
18777 ))),
18778 _other => {
18779 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
18780 Ok(Self::Expression(::std::boxed::Box::new(v)))
18781 } else {
18782 Err(::treesitter_types::ParseError::unexpected_kind(
18783 _other, node,
18784 ))
18785 }
18786 }
18787 }
18788 }
18789}
18790impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
18791 fn span(&self) -> ::treesitter_types::Span {
18792 match self {
18793 Self::Expression(inner) => inner.span(),
18794 Self::PreprocDefined(inner) => inner.span(),
18795 }
18796 }
18797}
18798#[derive(Debug, Clone)]
18799pub enum UnaryExpressionOperator {
18800 Bang(::treesitter_types::Span),
18801 Plus(::treesitter_types::Span),
18802 Minus(::treesitter_types::Span),
18803 Compl(::treesitter_types::Span),
18804 Not(::treesitter_types::Span),
18805 Tilde(::treesitter_types::Span),
18806}
18807impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
18808 #[allow(clippy::collapsible_else_if)]
18809 fn from_node(
18810 node: ::tree_sitter::Node<'tree>,
18811 _src: &'tree [u8],
18812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18813 match node.kind() {
18814 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
18815 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
18816 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
18817 "compl" => Ok(Self::Compl(::treesitter_types::Span::from(node))),
18818 "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
18819 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
18820 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18821 }
18822 }
18823}
18824impl ::treesitter_types::Spanned for UnaryExpressionOperator {
18825 fn span(&self) -> ::treesitter_types::Span {
18826 match self {
18827 Self::Bang(span) => *span,
18828 Self::Plus(span) => *span,
18829 Self::Minus(span) => *span,
18830 Self::Compl(span) => *span,
18831 Self::Not(span) => *span,
18832 Self::Tilde(span) => *span,
18833 }
18834 }
18835}
18836#[derive(Debug, Clone)]
18837pub enum UnionSpecifierName<'tree> {
18838 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
18839 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
18840 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
18841}
18842impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifierName<'tree> {
18843 #[allow(clippy::collapsible_else_if)]
18844 fn from_node(
18845 node: ::tree_sitter::Node<'tree>,
18846 src: &'tree [u8],
18847 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18848 match node.kind() {
18849 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
18850 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18851 ))),
18852 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
18853 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
18854 ))),
18855 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
18856 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18857 ))),
18858 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18859 }
18860 }
18861}
18862impl ::treesitter_types::Spanned for UnionSpecifierName<'_> {
18863 fn span(&self) -> ::treesitter_types::Span {
18864 match self {
18865 Self::QualifiedIdentifier(inner) => inner.span(),
18866 Self::TemplateType(inner) => inner.span(),
18867 Self::TypeIdentifier(inner) => inner.span(),
18868 }
18869 }
18870}
18871#[derive(Debug, Clone)]
18872pub enum UnionSpecifierChildren<'tree> {
18873 AlignasQualifier(::std::boxed::Box<AlignasQualifier<'tree>>),
18874 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
18875 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
18876 BaseClassClause(::std::boxed::Box<BaseClassClause<'tree>>),
18877 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
18878 VirtualSpecifier(::std::boxed::Box<VirtualSpecifier<'tree>>),
18879}
18880impl<'tree> ::treesitter_types::FromNode<'tree> for UnionSpecifierChildren<'tree> {
18881 #[allow(clippy::collapsible_else_if)]
18882 fn from_node(
18883 node: ::tree_sitter::Node<'tree>,
18884 src: &'tree [u8],
18885 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18886 match node.kind() {
18887 "alignas_qualifier" => Ok(Self::AlignasQualifier(::std::boxed::Box::new(
18888 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18889 ))),
18890 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
18891 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
18892 ))),
18893 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
18894 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18895 ))),
18896 "base_class_clause" => Ok(Self::BaseClassClause(::std::boxed::Box::new(
18897 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)?,
18898 ))),
18899 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
18900 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18901 ))),
18902 "virtual_specifier" => Ok(Self::VirtualSpecifier(::std::boxed::Box::new(
18903 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
18904 ))),
18905 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18906 }
18907 }
18908}
18909impl ::treesitter_types::Spanned for UnionSpecifierChildren<'_> {
18910 fn span(&self) -> ::treesitter_types::Span {
18911 match self {
18912 Self::AlignasQualifier(inner) => inner.span(),
18913 Self::AttributeDeclaration(inner) => inner.span(),
18914 Self::AttributeSpecifier(inner) => inner.span(),
18915 Self::BaseClassClause(inner) => inner.span(),
18916 Self::MsDeclspecModifier(inner) => inner.span(),
18917 Self::VirtualSpecifier(inner) => inner.span(),
18918 }
18919 }
18920}
18921#[derive(Debug, Clone)]
18922pub enum UpdateExpressionOperator {
18923 PlusPlus(::treesitter_types::Span),
18924 MinusMinus(::treesitter_types::Span),
18925}
18926impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
18927 #[allow(clippy::collapsible_else_if)]
18928 fn from_node(
18929 node: ::tree_sitter::Node<'tree>,
18930 _src: &'tree [u8],
18931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18932 match node.kind() {
18933 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
18934 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
18935 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18936 }
18937 }
18938}
18939impl ::treesitter_types::Spanned for UpdateExpressionOperator {
18940 fn span(&self) -> ::treesitter_types::Span {
18941 match self {
18942 Self::PlusPlus(span) => *span,
18943 Self::MinusMinus(span) => *span,
18944 }
18945 }
18946}
18947#[derive(Debug, Clone)]
18948pub enum UserDefinedLiteralChildren<'tree> {
18949 CharLiteral(::std::boxed::Box<CharLiteral<'tree>>),
18950 ConcatenatedString(::std::boxed::Box<ConcatenatedString<'tree>>),
18951 LiteralSuffix(::std::boxed::Box<LiteralSuffix<'tree>>),
18952 NumberLiteral(::std::boxed::Box<NumberLiteral<'tree>>),
18953 RawStringLiteral(::std::boxed::Box<RawStringLiteral<'tree>>),
18954 StringLiteral(::std::boxed::Box<StringLiteral<'tree>>),
18955}
18956impl<'tree> ::treesitter_types::FromNode<'tree> for UserDefinedLiteralChildren<'tree> {
18957 #[allow(clippy::collapsible_else_if)]
18958 fn from_node(
18959 node: ::tree_sitter::Node<'tree>,
18960 src: &'tree [u8],
18961 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
18962 match node.kind() {
18963 "char_literal" => Ok(Self::CharLiteral(::std::boxed::Box::new(
18964 <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18965 ))),
18966 "concatenated_string" => Ok(Self::ConcatenatedString(::std::boxed::Box::new(
18967 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)?,
18968 ))),
18969 "literal_suffix" => Ok(Self::LiteralSuffix(::std::boxed::Box::new(
18970 <LiteralSuffix as ::treesitter_types::FromNode>::from_node(node, src)?,
18971 ))),
18972 "number_literal" => Ok(Self::NumberLiteral(::std::boxed::Box::new(
18973 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18974 ))),
18975 "raw_string_literal" => Ok(Self::RawStringLiteral(::std::boxed::Box::new(
18976 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18977 ))),
18978 "string_literal" => Ok(Self::StringLiteral(::std::boxed::Box::new(
18979 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
18980 ))),
18981 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
18982 }
18983 }
18984}
18985impl ::treesitter_types::Spanned for UserDefinedLiteralChildren<'_> {
18986 fn span(&self) -> ::treesitter_types::Span {
18987 match self {
18988 Self::CharLiteral(inner) => inner.span(),
18989 Self::ConcatenatedString(inner) => inner.span(),
18990 Self::LiteralSuffix(inner) => inner.span(),
18991 Self::NumberLiteral(inner) => inner.span(),
18992 Self::RawStringLiteral(inner) => inner.span(),
18993 Self::StringLiteral(inner) => inner.span(),
18994 }
18995 }
18996}
18997#[derive(Debug, Clone)]
18998pub enum UsingDeclarationChildren<'tree> {
18999 Identifier(::std::boxed::Box<Identifier<'tree>>),
19000 QualifiedIdentifier(::std::boxed::Box<QualifiedIdentifier<'tree>>),
19001}
19002impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclarationChildren<'tree> {
19003 #[allow(clippy::collapsible_else_if)]
19004 fn from_node(
19005 node: ::tree_sitter::Node<'tree>,
19006 src: &'tree [u8],
19007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19008 match node.kind() {
19009 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
19010 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19011 ))),
19012 "qualified_identifier" => Ok(Self::QualifiedIdentifier(::std::boxed::Box::new(
19013 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19014 ))),
19015 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19016 }
19017 }
19018}
19019impl ::treesitter_types::Spanned for UsingDeclarationChildren<'_> {
19020 fn span(&self) -> ::treesitter_types::Span {
19021 match self {
19022 Self::Identifier(inner) => inner.span(),
19023 Self::QualifiedIdentifier(inner) => inner.span(),
19024 }
19025 }
19026}
19027#[derive(Debug, Clone)]
19028pub enum VariadicParameterDeclarationDeclarator<'tree> {
19029 ReferenceDeclarator(::std::boxed::Box<ReferenceDeclarator<'tree>>),
19030 VariadicDeclarator(::std::boxed::Box<VariadicDeclarator<'tree>>),
19031}
19032impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclarationDeclarator<'tree> {
19033 #[allow(clippy::collapsible_else_if)]
19034 fn from_node(
19035 node: ::tree_sitter::Node<'tree>,
19036 src: &'tree [u8],
19037 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19038 match node.kind() {
19039 "reference_declarator" => Ok(Self::ReferenceDeclarator(::std::boxed::Box::new(
19040 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
19041 ))),
19042 "variadic_declarator" => Ok(Self::VariadicDeclarator(::std::boxed::Box::new(
19043 <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(node, src)?,
19044 ))),
19045 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19046 }
19047 }
19048}
19049impl ::treesitter_types::Spanned for VariadicParameterDeclarationDeclarator<'_> {
19050 fn span(&self) -> ::treesitter_types::Span {
19051 match self {
19052 Self::ReferenceDeclarator(inner) => inner.span(),
19053 Self::VariadicDeclarator(inner) => inner.span(),
19054 }
19055 }
19056}
19057#[derive(Debug, Clone)]
19058pub enum VariadicParameterDeclarationChildren<'tree> {
19059 AttributeDeclaration(::std::boxed::Box<AttributeDeclaration<'tree>>),
19060 AttributeSpecifier(::std::boxed::Box<AttributeSpecifier<'tree>>),
19061 MsDeclspecModifier(::std::boxed::Box<MsDeclspecModifier<'tree>>),
19062 StorageClassSpecifier(::std::boxed::Box<StorageClassSpecifier<'tree>>),
19063 TypeQualifier(::std::boxed::Box<TypeQualifier<'tree>>),
19064}
19065impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameterDeclarationChildren<'tree> {
19066 #[allow(clippy::collapsible_else_if)]
19067 fn from_node(
19068 node: ::tree_sitter::Node<'tree>,
19069 src: &'tree [u8],
19070 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
19071 match node.kind() {
19072 "attribute_declaration" => Ok(Self::AttributeDeclaration(::std::boxed::Box::new(
19073 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
19074 ))),
19075 "attribute_specifier" => Ok(Self::AttributeSpecifier(::std::boxed::Box::new(
19076 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19077 ))),
19078 "ms_declspec_modifier" => Ok(Self::MsDeclspecModifier(::std::boxed::Box::new(
19079 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19080 ))),
19081 "storage_class_specifier" => Ok(Self::StorageClassSpecifier(::std::boxed::Box::new(
19082 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19083 ))),
19084 "type_qualifier" => Ok(Self::TypeQualifier(::std::boxed::Box::new(
19085 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)?,
19086 ))),
19087 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
19088 }
19089 }
19090}
19091impl ::treesitter_types::Spanned for VariadicParameterDeclarationChildren<'_> {
19092 fn span(&self) -> ::treesitter_types::Span {
19093 match self {
19094 Self::AttributeDeclaration(inner) => inner.span(),
19095 Self::AttributeSpecifier(inner) => inner.span(),
19096 Self::MsDeclspecModifier(inner) => inner.span(),
19097 Self::StorageClassSpecifier(inner) => inner.span(),
19098 Self::TypeQualifier(inner) => inner.span(),
19099 }
19100 }
19101}
19102#[derive(Debug, Clone)]
19103pub enum AnyNode<'tree> {
19104 AbstractDeclarator(AbstractDeclarator<'tree>),
19105 Declarator(Declarator<'tree>),
19106 FieldDeclarator(FieldDeclarator<'tree>),
19107 TypeDeclarator(TypeDeclarator<'tree>),
19108 Expression(Expression<'tree>),
19109 Statement(Statement<'tree>),
19110 TypeSpecifier(TypeSpecifier<'tree>),
19111 AbstractArrayDeclarator(AbstractArrayDeclarator<'tree>),
19112 AbstractFunctionDeclarator(AbstractFunctionDeclarator<'tree>),
19113 AbstractParenthesizedDeclarator(AbstractParenthesizedDeclarator<'tree>),
19114 AbstractPointerDeclarator(AbstractPointerDeclarator<'tree>),
19115 AbstractReferenceDeclarator(AbstractReferenceDeclarator<'tree>),
19116 AccessSpecifier(AccessSpecifier<'tree>),
19117 AliasDeclaration(AliasDeclaration<'tree>),
19118 AlignasQualifier(AlignasQualifier<'tree>),
19119 AlignofExpression(AlignofExpression<'tree>),
19120 ArgumentList(ArgumentList<'tree>),
19121 ArrayDeclarator(ArrayDeclarator<'tree>),
19122 AssignmentExpression(AssignmentExpression<'tree>),
19123 Attribute(Attribute<'tree>),
19124 AttributeDeclaration(AttributeDeclaration<'tree>),
19125 AttributeSpecifier(AttributeSpecifier<'tree>),
19126 AttributedDeclarator(AttributedDeclarator<'tree>),
19127 AttributedStatement(AttributedStatement<'tree>),
19128 BaseClassClause(BaseClassClause<'tree>),
19129 BinaryExpression(BinaryExpression<'tree>),
19130 BitfieldClause(BitfieldClause<'tree>),
19131 BreakStatement(BreakStatement<'tree>),
19132 CallExpression(CallExpression<'tree>),
19133 CaseStatement(CaseStatement<'tree>),
19134 CastExpression(CastExpression<'tree>),
19135 CatchClause(CatchClause<'tree>),
19136 CharLiteral(CharLiteral<'tree>),
19137 ClassSpecifier(ClassSpecifier<'tree>),
19138 CoAwaitExpression(CoAwaitExpression<'tree>),
19139 CoReturnStatement(CoReturnStatement<'tree>),
19140 CoYieldStatement(CoYieldStatement<'tree>),
19141 CommaExpression(CommaExpression<'tree>),
19142 CompoundLiteralExpression(CompoundLiteralExpression<'tree>),
19143 CompoundRequirement(CompoundRequirement<'tree>),
19144 CompoundStatement(CompoundStatement<'tree>),
19145 ConcatenatedString(ConcatenatedString<'tree>),
19146 ConceptDefinition(ConceptDefinition<'tree>),
19147 ConditionClause(ConditionClause<'tree>),
19148 ConditionalExpression(ConditionalExpression<'tree>),
19149 ConstraintConjunction(ConstraintConjunction<'tree>),
19150 ConstraintDisjunction(ConstraintDisjunction<'tree>),
19151 ContinueStatement(ContinueStatement<'tree>),
19152 Declaration(Declaration<'tree>),
19153 DeclarationList(DeclarationList<'tree>),
19154 Decltype(Decltype<'tree>),
19155 DefaultMethodClause(DefaultMethodClause<'tree>),
19156 DeleteExpression(DeleteExpression<'tree>),
19157 DeleteMethodClause(DeleteMethodClause<'tree>),
19158 DependentName(DependentName<'tree>),
19159 DependentType(DependentType<'tree>),
19160 DestructorName(DestructorName<'tree>),
19161 DoStatement(DoStatement<'tree>),
19162 ElseClause(ElseClause<'tree>),
19163 EnumSpecifier(EnumSpecifier<'tree>),
19164 Enumerator(Enumerator<'tree>),
19165 EnumeratorList(EnumeratorList<'tree>),
19166 ExplicitFunctionSpecifier(ExplicitFunctionSpecifier<'tree>),
19167 ExpressionStatement(ExpressionStatement<'tree>),
19168 ExtensionExpression(ExtensionExpression<'tree>),
19169 FieldDeclaration(FieldDeclaration<'tree>),
19170 FieldDeclarationList(FieldDeclarationList<'tree>),
19171 FieldDesignator(FieldDesignator<'tree>),
19172 FieldExpression(FieldExpression<'tree>),
19173 FieldInitializer(FieldInitializer<'tree>),
19174 FieldInitializerList(FieldInitializerList<'tree>),
19175 FoldExpression(FoldExpression<'tree>),
19176 ForRangeLoop(ForRangeLoop<'tree>),
19177 ForStatement(ForStatement<'tree>),
19178 FriendDeclaration(FriendDeclaration<'tree>),
19179 FunctionDeclarator(FunctionDeclarator<'tree>),
19180 FunctionDefinition(FunctionDefinition<'tree>),
19181 GenericExpression(GenericExpression<'tree>),
19182 GnuAsmClobberList(GnuAsmClobberList<'tree>),
19183 GnuAsmExpression(GnuAsmExpression<'tree>),
19184 GnuAsmGotoList(GnuAsmGotoList<'tree>),
19185 GnuAsmInputOperand(GnuAsmInputOperand<'tree>),
19186 GnuAsmInputOperandList(GnuAsmInputOperandList<'tree>),
19187 GnuAsmOutputOperand(GnuAsmOutputOperand<'tree>),
19188 GnuAsmOutputOperandList(GnuAsmOutputOperandList<'tree>),
19189 GnuAsmQualifier(GnuAsmQualifier<'tree>),
19190 GotoStatement(GotoStatement<'tree>),
19191 IfStatement(IfStatement<'tree>),
19192 InitDeclarator(InitDeclarator<'tree>),
19193 InitStatement(InitStatement<'tree>),
19194 InitializerList(InitializerList<'tree>),
19195 InitializerPair(InitializerPair<'tree>),
19196 LabeledStatement(LabeledStatement<'tree>),
19197 LambdaCaptureInitializer(LambdaCaptureInitializer<'tree>),
19198 LambdaCaptureSpecifier(LambdaCaptureSpecifier<'tree>),
19199 LambdaDefaultCapture(LambdaDefaultCapture<'tree>),
19200 LambdaExpression(LambdaExpression<'tree>),
19201 LinkageSpecification(LinkageSpecification<'tree>),
19202 MsBasedModifier(MsBasedModifier<'tree>),
19203 MsCallModifier(MsCallModifier<'tree>),
19204 MsDeclspecModifier(MsDeclspecModifier<'tree>),
19205 MsPointerModifier(MsPointerModifier<'tree>),
19206 MsUnalignedPtrModifier(MsUnalignedPtrModifier<'tree>),
19207 NamespaceAliasDefinition(NamespaceAliasDefinition<'tree>),
19208 NamespaceDefinition(NamespaceDefinition<'tree>),
19209 NestedNamespaceSpecifier(NestedNamespaceSpecifier<'tree>),
19210 NewDeclarator(NewDeclarator<'tree>),
19211 NewExpression(NewExpression<'tree>),
19212 Noexcept(Noexcept<'tree>),
19213 Null(Null<'tree>),
19214 OffsetofExpression(OffsetofExpression<'tree>),
19215 OperatorCast(OperatorCast<'tree>),
19216 OperatorName(OperatorName<'tree>),
19217 OptionalParameterDeclaration(OptionalParameterDeclaration<'tree>),
19218 OptionalTypeParameterDeclaration(OptionalTypeParameterDeclaration<'tree>),
19219 ParameterDeclaration(ParameterDeclaration<'tree>),
19220 ParameterList(ParameterList<'tree>),
19221 ParameterPackExpansion(ParameterPackExpansion<'tree>),
19222 ParenthesizedDeclarator(ParenthesizedDeclarator<'tree>),
19223 ParenthesizedExpression(ParenthesizedExpression<'tree>),
19224 PlaceholderTypeSpecifier(PlaceholderTypeSpecifier<'tree>),
19225 PointerDeclarator(PointerDeclarator<'tree>),
19226 PointerExpression(PointerExpression<'tree>),
19227 PointerTypeDeclarator(PointerTypeDeclarator<'tree>),
19228 PreprocCall(PreprocCall<'tree>),
19229 PreprocDef(PreprocDef<'tree>),
19230 PreprocDefined(PreprocDefined<'tree>),
19231 PreprocElif(PreprocElif<'tree>),
19232 PreprocElifdef(PreprocElifdef<'tree>),
19233 PreprocElse(PreprocElse<'tree>),
19234 PreprocFunctionDef(PreprocFunctionDef<'tree>),
19235 PreprocIf(PreprocIf<'tree>),
19236 PreprocIfdef(PreprocIfdef<'tree>),
19237 PreprocInclude(PreprocInclude<'tree>),
19238 PreprocParams(PreprocParams<'tree>),
19239 PureVirtualClause(PureVirtualClause<'tree>),
19240 QualifiedIdentifier(QualifiedIdentifier<'tree>),
19241 RawStringLiteral(RawStringLiteral<'tree>),
19242 RefQualifier(RefQualifier<'tree>),
19243 ReferenceDeclarator(ReferenceDeclarator<'tree>),
19244 RequirementSeq(RequirementSeq<'tree>),
19245 RequiresClause(RequiresClause<'tree>),
19246 RequiresExpression(RequiresExpression<'tree>),
19247 ReturnStatement(ReturnStatement<'tree>),
19248 SehExceptClause(SehExceptClause<'tree>),
19249 SehFinallyClause(SehFinallyClause<'tree>),
19250 SehLeaveStatement(SehLeaveStatement<'tree>),
19251 SehTryStatement(SehTryStatement<'tree>),
19252 SimpleRequirement(SimpleRequirement<'tree>),
19253 SizedTypeSpecifier(SizedTypeSpecifier<'tree>),
19254 SizeofExpression(SizeofExpression<'tree>),
19255 StaticAssertDeclaration(StaticAssertDeclaration<'tree>),
19256 StorageClassSpecifier(StorageClassSpecifier<'tree>),
19257 StringLiteral(StringLiteral<'tree>),
19258 StructSpecifier(StructSpecifier<'tree>),
19259 StructuredBindingDeclarator(StructuredBindingDeclarator<'tree>),
19260 SubscriptArgumentList(SubscriptArgumentList<'tree>),
19261 SubscriptDesignator(SubscriptDesignator<'tree>),
19262 SubscriptExpression(SubscriptExpression<'tree>),
19263 SubscriptRangeDesignator(SubscriptRangeDesignator<'tree>),
19264 SwitchStatement(SwitchStatement<'tree>),
19265 TemplateArgumentList(TemplateArgumentList<'tree>),
19266 TemplateDeclaration(TemplateDeclaration<'tree>),
19267 TemplateFunction(TemplateFunction<'tree>),
19268 TemplateInstantiation(TemplateInstantiation<'tree>),
19269 TemplateMethod(TemplateMethod<'tree>),
19270 TemplateParameterList(TemplateParameterList<'tree>),
19271 TemplateTemplateParameterDeclaration(TemplateTemplateParameterDeclaration<'tree>),
19272 TemplateType(TemplateType<'tree>),
19273 ThrowSpecifier(ThrowSpecifier<'tree>),
19274 ThrowStatement(ThrowStatement<'tree>),
19275 TrailingReturnType(TrailingReturnType<'tree>),
19276 TranslationUnit(TranslationUnit<'tree>),
19277 TryStatement(TryStatement<'tree>),
19278 TypeDefinition(TypeDefinition<'tree>),
19279 TypeDescriptor(TypeDescriptor<'tree>),
19280 TypeParameterDeclaration(TypeParameterDeclaration<'tree>),
19281 TypeQualifier(TypeQualifier<'tree>),
19282 TypeRequirement(TypeRequirement<'tree>),
19283 UnaryExpression(UnaryExpression<'tree>),
19284 UnionSpecifier(UnionSpecifier<'tree>),
19285 UpdateExpression(UpdateExpression<'tree>),
19286 UserDefinedLiteral(UserDefinedLiteral<'tree>),
19287 UsingDeclaration(UsingDeclaration<'tree>),
19288 VariadicDeclarator(VariadicDeclarator<'tree>),
19289 VariadicParameterDeclaration(VariadicParameterDeclaration<'tree>),
19290 VariadicTypeParameterDeclaration(VariadicTypeParameterDeclaration<'tree>),
19291 VirtualSpecifier(VirtualSpecifier<'tree>),
19292 WhileStatement(WhileStatement<'tree>),
19293 Auto(Auto<'tree>),
19294 Character(Character<'tree>),
19295 Comment(Comment<'tree>),
19296 EscapeSequence(EscapeSequence<'tree>),
19297 False(False<'tree>),
19298 FieldIdentifier(FieldIdentifier<'tree>),
19299 Identifier(Identifier<'tree>),
19300 LiteralSuffix(LiteralSuffix<'tree>),
19301 MsRestrictModifier(MsRestrictModifier<'tree>),
19302 MsSignedPtrModifier(MsSignedPtrModifier<'tree>),
19303 MsUnsignedPtrModifier(MsUnsignedPtrModifier<'tree>),
19304 NamespaceIdentifier(NamespaceIdentifier<'tree>),
19305 NumberLiteral(NumberLiteral<'tree>),
19306 PreprocArg(PreprocArg<'tree>),
19307 PreprocDirective(PreprocDirective<'tree>),
19308 PrimitiveType(PrimitiveType<'tree>),
19309 RawStringContent(RawStringContent<'tree>),
19310 RawStringDelimiter(RawStringDelimiter<'tree>),
19311 StatementIdentifier(StatementIdentifier<'tree>),
19312 StringContent(StringContent<'tree>),
19313 SystemLibString(SystemLibString<'tree>),
19314 This(This<'tree>),
19315 True(True<'tree>),
19316 TypeIdentifier(TypeIdentifier<'tree>),
19317 Unknown(::tree_sitter::Node<'tree>),
19318}
19319impl<'tree> AnyNode<'tree> {
19320 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
19321 match node.kind() {
19322 "_abstract_declarator" => {
19323 <AbstractDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19324 .map(Self::AbstractDeclarator)
19325 .unwrap_or(Self::Unknown(node))
19326 }
19327 "_declarator" => <Declarator as ::treesitter_types::FromNode>::from_node(node, src)
19328 .map(Self::Declarator)
19329 .unwrap_or(Self::Unknown(node)),
19330 "_field_declarator" => {
19331 <FieldDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19332 .map(Self::FieldDeclarator)
19333 .unwrap_or(Self::Unknown(node))
19334 }
19335 "_type_declarator" => {
19336 <TypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19337 .map(Self::TypeDeclarator)
19338 .unwrap_or(Self::Unknown(node))
19339 }
19340 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
19341 .map(Self::Expression)
19342 .unwrap_or(Self::Unknown(node)),
19343 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
19344 .map(Self::Statement)
19345 .unwrap_or(Self::Unknown(node)),
19346 "type_specifier" => {
19347 <TypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19348 .map(Self::TypeSpecifier)
19349 .unwrap_or(Self::Unknown(node))
19350 }
19351 "abstract_array_declarator" => {
19352 <AbstractArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19353 .map(Self::AbstractArrayDeclarator)
19354 .unwrap_or(Self::Unknown(node))
19355 }
19356 "abstract_function_declarator" => {
19357 <AbstractFunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19358 .map(Self::AbstractFunctionDeclarator)
19359 .unwrap_or(Self::Unknown(node))
19360 }
19361 "abstract_parenthesized_declarator" => {
19362 <AbstractParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(
19363 node, src,
19364 )
19365 .map(Self::AbstractParenthesizedDeclarator)
19366 .unwrap_or(Self::Unknown(node))
19367 }
19368 "abstract_pointer_declarator" => {
19369 <AbstractPointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19370 .map(Self::AbstractPointerDeclarator)
19371 .unwrap_or(Self::Unknown(node))
19372 }
19373 "abstract_reference_declarator" => {
19374 <AbstractReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19375 .map(Self::AbstractReferenceDeclarator)
19376 .unwrap_or(Self::Unknown(node))
19377 }
19378 "access_specifier" => {
19379 <AccessSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19380 .map(Self::AccessSpecifier)
19381 .unwrap_or(Self::Unknown(node))
19382 }
19383 "alias_declaration" => {
19384 <AliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19385 .map(Self::AliasDeclaration)
19386 .unwrap_or(Self::Unknown(node))
19387 }
19388 "alignas_qualifier" => {
19389 <AlignasQualifier as ::treesitter_types::FromNode>::from_node(node, src)
19390 .map(Self::AlignasQualifier)
19391 .unwrap_or(Self::Unknown(node))
19392 }
19393 "alignof_expression" => {
19394 <AlignofExpression as ::treesitter_types::FromNode>::from_node(node, src)
19395 .map(Self::AlignofExpression)
19396 .unwrap_or(Self::Unknown(node))
19397 }
19398 "argument_list" => <ArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
19399 .map(Self::ArgumentList)
19400 .unwrap_or(Self::Unknown(node)),
19401 "array_declarator" => {
19402 <ArrayDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19403 .map(Self::ArrayDeclarator)
19404 .unwrap_or(Self::Unknown(node))
19405 }
19406 "assignment_expression" => {
19407 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
19408 .map(Self::AssignmentExpression)
19409 .unwrap_or(Self::Unknown(node))
19410 }
19411 "attribute" => <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
19412 .map(Self::Attribute)
19413 .unwrap_or(Self::Unknown(node)),
19414 "attribute_declaration" => {
19415 <AttributeDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19416 .map(Self::AttributeDeclaration)
19417 .unwrap_or(Self::Unknown(node))
19418 }
19419 "attribute_specifier" => {
19420 <AttributeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19421 .map(Self::AttributeSpecifier)
19422 .unwrap_or(Self::Unknown(node))
19423 }
19424 "attributed_declarator" => {
19425 <AttributedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19426 .map(Self::AttributedDeclarator)
19427 .unwrap_or(Self::Unknown(node))
19428 }
19429 "attributed_statement" => {
19430 <AttributedStatement as ::treesitter_types::FromNode>::from_node(node, src)
19431 .map(Self::AttributedStatement)
19432 .unwrap_or(Self::Unknown(node))
19433 }
19434 "base_class_clause" => {
19435 <BaseClassClause as ::treesitter_types::FromNode>::from_node(node, src)
19436 .map(Self::BaseClassClause)
19437 .unwrap_or(Self::Unknown(node))
19438 }
19439 "binary_expression" => {
19440 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
19441 .map(Self::BinaryExpression)
19442 .unwrap_or(Self::Unknown(node))
19443 }
19444 "bitfield_clause" => {
19445 <BitfieldClause as ::treesitter_types::FromNode>::from_node(node, src)
19446 .map(Self::BitfieldClause)
19447 .unwrap_or(Self::Unknown(node))
19448 }
19449 "break_statement" => {
19450 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
19451 .map(Self::BreakStatement)
19452 .unwrap_or(Self::Unknown(node))
19453 }
19454 "call_expression" => {
19455 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
19456 .map(Self::CallExpression)
19457 .unwrap_or(Self::Unknown(node))
19458 }
19459 "case_statement" => {
19460 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
19461 .map(Self::CaseStatement)
19462 .unwrap_or(Self::Unknown(node))
19463 }
19464 "cast_expression" => {
19465 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
19466 .map(Self::CastExpression)
19467 .unwrap_or(Self::Unknown(node))
19468 }
19469 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
19470 .map(Self::CatchClause)
19471 .unwrap_or(Self::Unknown(node)),
19472 "char_literal" => <CharLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19473 .map(Self::CharLiteral)
19474 .unwrap_or(Self::Unknown(node)),
19475 "class_specifier" => {
19476 <ClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19477 .map(Self::ClassSpecifier)
19478 .unwrap_or(Self::Unknown(node))
19479 }
19480 "co_await_expression" => {
19481 <CoAwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
19482 .map(Self::CoAwaitExpression)
19483 .unwrap_or(Self::Unknown(node))
19484 }
19485 "co_return_statement" => {
19486 <CoReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
19487 .map(Self::CoReturnStatement)
19488 .unwrap_or(Self::Unknown(node))
19489 }
19490 "co_yield_statement" => {
19491 <CoYieldStatement as ::treesitter_types::FromNode>::from_node(node, src)
19492 .map(Self::CoYieldStatement)
19493 .unwrap_or(Self::Unknown(node))
19494 }
19495 "comma_expression" => {
19496 <CommaExpression as ::treesitter_types::FromNode>::from_node(node, src)
19497 .map(Self::CommaExpression)
19498 .unwrap_or(Self::Unknown(node))
19499 }
19500 "compound_literal_expression" => {
19501 <CompoundLiteralExpression as ::treesitter_types::FromNode>::from_node(node, src)
19502 .map(Self::CompoundLiteralExpression)
19503 .unwrap_or(Self::Unknown(node))
19504 }
19505 "compound_requirement" => {
19506 <CompoundRequirement as ::treesitter_types::FromNode>::from_node(node, src)
19507 .map(Self::CompoundRequirement)
19508 .unwrap_or(Self::Unknown(node))
19509 }
19510 "compound_statement" => {
19511 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
19512 .map(Self::CompoundStatement)
19513 .unwrap_or(Self::Unknown(node))
19514 }
19515 "concatenated_string" => {
19516 <ConcatenatedString as ::treesitter_types::FromNode>::from_node(node, src)
19517 .map(Self::ConcatenatedString)
19518 .unwrap_or(Self::Unknown(node))
19519 }
19520 "concept_definition" => {
19521 <ConceptDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19522 .map(Self::ConceptDefinition)
19523 .unwrap_or(Self::Unknown(node))
19524 }
19525 "condition_clause" => {
19526 <ConditionClause as ::treesitter_types::FromNode>::from_node(node, src)
19527 .map(Self::ConditionClause)
19528 .unwrap_or(Self::Unknown(node))
19529 }
19530 "conditional_expression" => {
19531 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
19532 .map(Self::ConditionalExpression)
19533 .unwrap_or(Self::Unknown(node))
19534 }
19535 "constraint_conjunction" => {
19536 <ConstraintConjunction as ::treesitter_types::FromNode>::from_node(node, src)
19537 .map(Self::ConstraintConjunction)
19538 .unwrap_or(Self::Unknown(node))
19539 }
19540 "constraint_disjunction" => {
19541 <ConstraintDisjunction as ::treesitter_types::FromNode>::from_node(node, src)
19542 .map(Self::ConstraintDisjunction)
19543 .unwrap_or(Self::Unknown(node))
19544 }
19545 "continue_statement" => {
19546 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
19547 .map(Self::ContinueStatement)
19548 .unwrap_or(Self::Unknown(node))
19549 }
19550 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
19551 .map(Self::Declaration)
19552 .unwrap_or(Self::Unknown(node)),
19553 "declaration_list" => {
19554 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
19555 .map(Self::DeclarationList)
19556 .unwrap_or(Self::Unknown(node))
19557 }
19558 "decltype" => <Decltype as ::treesitter_types::FromNode>::from_node(node, src)
19559 .map(Self::Decltype)
19560 .unwrap_or(Self::Unknown(node)),
19561 "default_method_clause" => {
19562 <DefaultMethodClause as ::treesitter_types::FromNode>::from_node(node, src)
19563 .map(Self::DefaultMethodClause)
19564 .unwrap_or(Self::Unknown(node))
19565 }
19566 "delete_expression" => {
19567 <DeleteExpression as ::treesitter_types::FromNode>::from_node(node, src)
19568 .map(Self::DeleteExpression)
19569 .unwrap_or(Self::Unknown(node))
19570 }
19571 "delete_method_clause" => {
19572 <DeleteMethodClause as ::treesitter_types::FromNode>::from_node(node, src)
19573 .map(Self::DeleteMethodClause)
19574 .unwrap_or(Self::Unknown(node))
19575 }
19576 "dependent_name" => {
19577 <DependentName as ::treesitter_types::FromNode>::from_node(node, src)
19578 .map(Self::DependentName)
19579 .unwrap_or(Self::Unknown(node))
19580 }
19581 "dependent_type" => {
19582 <DependentType as ::treesitter_types::FromNode>::from_node(node, src)
19583 .map(Self::DependentType)
19584 .unwrap_or(Self::Unknown(node))
19585 }
19586 "destructor_name" => {
19587 <DestructorName as ::treesitter_types::FromNode>::from_node(node, src)
19588 .map(Self::DestructorName)
19589 .unwrap_or(Self::Unknown(node))
19590 }
19591 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
19592 .map(Self::DoStatement)
19593 .unwrap_or(Self::Unknown(node)),
19594 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
19595 .map(Self::ElseClause)
19596 .unwrap_or(Self::Unknown(node)),
19597 "enum_specifier" => {
19598 <EnumSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19599 .map(Self::EnumSpecifier)
19600 .unwrap_or(Self::Unknown(node))
19601 }
19602 "enumerator" => <Enumerator as ::treesitter_types::FromNode>::from_node(node, src)
19603 .map(Self::Enumerator)
19604 .unwrap_or(Self::Unknown(node)),
19605 "enumerator_list" => {
19606 <EnumeratorList as ::treesitter_types::FromNode>::from_node(node, src)
19607 .map(Self::EnumeratorList)
19608 .unwrap_or(Self::Unknown(node))
19609 }
19610 "explicit_function_specifier" => {
19611 <ExplicitFunctionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19612 .map(Self::ExplicitFunctionSpecifier)
19613 .unwrap_or(Self::Unknown(node))
19614 }
19615 "expression_statement" => {
19616 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
19617 .map(Self::ExpressionStatement)
19618 .unwrap_or(Self::Unknown(node))
19619 }
19620 "extension_expression" => {
19621 <ExtensionExpression as ::treesitter_types::FromNode>::from_node(node, src)
19622 .map(Self::ExtensionExpression)
19623 .unwrap_or(Self::Unknown(node))
19624 }
19625 "field_declaration" => {
19626 <FieldDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19627 .map(Self::FieldDeclaration)
19628 .unwrap_or(Self::Unknown(node))
19629 }
19630 "field_declaration_list" => {
19631 <FieldDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
19632 .map(Self::FieldDeclarationList)
19633 .unwrap_or(Self::Unknown(node))
19634 }
19635 "field_designator" => {
19636 <FieldDesignator as ::treesitter_types::FromNode>::from_node(node, src)
19637 .map(Self::FieldDesignator)
19638 .unwrap_or(Self::Unknown(node))
19639 }
19640 "field_expression" => {
19641 <FieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
19642 .map(Self::FieldExpression)
19643 .unwrap_or(Self::Unknown(node))
19644 }
19645 "field_initializer" => {
19646 <FieldInitializer as ::treesitter_types::FromNode>::from_node(node, src)
19647 .map(Self::FieldInitializer)
19648 .unwrap_or(Self::Unknown(node))
19649 }
19650 "field_initializer_list" => {
19651 <FieldInitializerList as ::treesitter_types::FromNode>::from_node(node, src)
19652 .map(Self::FieldInitializerList)
19653 .unwrap_or(Self::Unknown(node))
19654 }
19655 "fold_expression" => {
19656 <FoldExpression as ::treesitter_types::FromNode>::from_node(node, src)
19657 .map(Self::FoldExpression)
19658 .unwrap_or(Self::Unknown(node))
19659 }
19660 "for_range_loop" => {
19661 <ForRangeLoop as ::treesitter_types::FromNode>::from_node(node, src)
19662 .map(Self::ForRangeLoop)
19663 .unwrap_or(Self::Unknown(node))
19664 }
19665 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
19666 .map(Self::ForStatement)
19667 .unwrap_or(Self::Unknown(node)),
19668 "friend_declaration" => {
19669 <FriendDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19670 .map(Self::FriendDeclaration)
19671 .unwrap_or(Self::Unknown(node))
19672 }
19673 "function_declarator" => {
19674 <FunctionDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19675 .map(Self::FunctionDeclarator)
19676 .unwrap_or(Self::Unknown(node))
19677 }
19678 "function_definition" => {
19679 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19680 .map(Self::FunctionDefinition)
19681 .unwrap_or(Self::Unknown(node))
19682 }
19683 "generic_expression" => {
19684 <GenericExpression as ::treesitter_types::FromNode>::from_node(node, src)
19685 .map(Self::GenericExpression)
19686 .unwrap_or(Self::Unknown(node))
19687 }
19688 "gnu_asm_clobber_list" => {
19689 <GnuAsmClobberList as ::treesitter_types::FromNode>::from_node(node, src)
19690 .map(Self::GnuAsmClobberList)
19691 .unwrap_or(Self::Unknown(node))
19692 }
19693 "gnu_asm_expression" => {
19694 <GnuAsmExpression as ::treesitter_types::FromNode>::from_node(node, src)
19695 .map(Self::GnuAsmExpression)
19696 .unwrap_or(Self::Unknown(node))
19697 }
19698 "gnu_asm_goto_list" => {
19699 <GnuAsmGotoList as ::treesitter_types::FromNode>::from_node(node, src)
19700 .map(Self::GnuAsmGotoList)
19701 .unwrap_or(Self::Unknown(node))
19702 }
19703 "gnu_asm_input_operand" => {
19704 <GnuAsmInputOperand as ::treesitter_types::FromNode>::from_node(node, src)
19705 .map(Self::GnuAsmInputOperand)
19706 .unwrap_or(Self::Unknown(node))
19707 }
19708 "gnu_asm_input_operand_list" => {
19709 <GnuAsmInputOperandList as ::treesitter_types::FromNode>::from_node(node, src)
19710 .map(Self::GnuAsmInputOperandList)
19711 .unwrap_or(Self::Unknown(node))
19712 }
19713 "gnu_asm_output_operand" => {
19714 <GnuAsmOutputOperand as ::treesitter_types::FromNode>::from_node(node, src)
19715 .map(Self::GnuAsmOutputOperand)
19716 .unwrap_or(Self::Unknown(node))
19717 }
19718 "gnu_asm_output_operand_list" => {
19719 <GnuAsmOutputOperandList as ::treesitter_types::FromNode>::from_node(node, src)
19720 .map(Self::GnuAsmOutputOperandList)
19721 .unwrap_or(Self::Unknown(node))
19722 }
19723 "gnu_asm_qualifier" => {
19724 <GnuAsmQualifier as ::treesitter_types::FromNode>::from_node(node, src)
19725 .map(Self::GnuAsmQualifier)
19726 .unwrap_or(Self::Unknown(node))
19727 }
19728 "goto_statement" => {
19729 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
19730 .map(Self::GotoStatement)
19731 .unwrap_or(Self::Unknown(node))
19732 }
19733 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
19734 .map(Self::IfStatement)
19735 .unwrap_or(Self::Unknown(node)),
19736 "init_declarator" => {
19737 <InitDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19738 .map(Self::InitDeclarator)
19739 .unwrap_or(Self::Unknown(node))
19740 }
19741 "init_statement" => {
19742 <InitStatement as ::treesitter_types::FromNode>::from_node(node, src)
19743 .map(Self::InitStatement)
19744 .unwrap_or(Self::Unknown(node))
19745 }
19746 "initializer_list" => {
19747 <InitializerList as ::treesitter_types::FromNode>::from_node(node, src)
19748 .map(Self::InitializerList)
19749 .unwrap_or(Self::Unknown(node))
19750 }
19751 "initializer_pair" => {
19752 <InitializerPair as ::treesitter_types::FromNode>::from_node(node, src)
19753 .map(Self::InitializerPair)
19754 .unwrap_or(Self::Unknown(node))
19755 }
19756 "labeled_statement" => {
19757 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
19758 .map(Self::LabeledStatement)
19759 .unwrap_or(Self::Unknown(node))
19760 }
19761 "lambda_capture_initializer" => {
19762 <LambdaCaptureInitializer as ::treesitter_types::FromNode>::from_node(node, src)
19763 .map(Self::LambdaCaptureInitializer)
19764 .unwrap_or(Self::Unknown(node))
19765 }
19766 "lambda_capture_specifier" => {
19767 <LambdaCaptureSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19768 .map(Self::LambdaCaptureSpecifier)
19769 .unwrap_or(Self::Unknown(node))
19770 }
19771 "lambda_default_capture" => {
19772 <LambdaDefaultCapture as ::treesitter_types::FromNode>::from_node(node, src)
19773 .map(Self::LambdaDefaultCapture)
19774 .unwrap_or(Self::Unknown(node))
19775 }
19776 "lambda_expression" => {
19777 <LambdaExpression as ::treesitter_types::FromNode>::from_node(node, src)
19778 .map(Self::LambdaExpression)
19779 .unwrap_or(Self::Unknown(node))
19780 }
19781 "linkage_specification" => {
19782 <LinkageSpecification as ::treesitter_types::FromNode>::from_node(node, src)
19783 .map(Self::LinkageSpecification)
19784 .unwrap_or(Self::Unknown(node))
19785 }
19786 "ms_based_modifier" => {
19787 <MsBasedModifier as ::treesitter_types::FromNode>::from_node(node, src)
19788 .map(Self::MsBasedModifier)
19789 .unwrap_or(Self::Unknown(node))
19790 }
19791 "ms_call_modifier" => {
19792 <MsCallModifier as ::treesitter_types::FromNode>::from_node(node, src)
19793 .map(Self::MsCallModifier)
19794 .unwrap_or(Self::Unknown(node))
19795 }
19796 "ms_declspec_modifier" => {
19797 <MsDeclspecModifier as ::treesitter_types::FromNode>::from_node(node, src)
19798 .map(Self::MsDeclspecModifier)
19799 .unwrap_or(Self::Unknown(node))
19800 }
19801 "ms_pointer_modifier" => {
19802 <MsPointerModifier as ::treesitter_types::FromNode>::from_node(node, src)
19803 .map(Self::MsPointerModifier)
19804 .unwrap_or(Self::Unknown(node))
19805 }
19806 "ms_unaligned_ptr_modifier" => {
19807 <MsUnalignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
19808 .map(Self::MsUnalignedPtrModifier)
19809 .unwrap_or(Self::Unknown(node))
19810 }
19811 "namespace_alias_definition" => {
19812 <NamespaceAliasDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19813 .map(Self::NamespaceAliasDefinition)
19814 .unwrap_or(Self::Unknown(node))
19815 }
19816 "namespace_definition" => {
19817 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
19818 .map(Self::NamespaceDefinition)
19819 .unwrap_or(Self::Unknown(node))
19820 }
19821 "nested_namespace_specifier" => {
19822 <NestedNamespaceSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19823 .map(Self::NestedNamespaceSpecifier)
19824 .unwrap_or(Self::Unknown(node))
19825 }
19826 "new_declarator" => {
19827 <NewDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19828 .map(Self::NewDeclarator)
19829 .unwrap_or(Self::Unknown(node))
19830 }
19831 "new_expression" => {
19832 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
19833 .map(Self::NewExpression)
19834 .unwrap_or(Self::Unknown(node))
19835 }
19836 "noexcept" => <Noexcept as ::treesitter_types::FromNode>::from_node(node, src)
19837 .map(Self::Noexcept)
19838 .unwrap_or(Self::Unknown(node)),
19839 "null" => <Null as ::treesitter_types::FromNode>::from_node(node, src)
19840 .map(Self::Null)
19841 .unwrap_or(Self::Unknown(node)),
19842 "offsetof_expression" => {
19843 <OffsetofExpression as ::treesitter_types::FromNode>::from_node(node, src)
19844 .map(Self::OffsetofExpression)
19845 .unwrap_or(Self::Unknown(node))
19846 }
19847 "operator_cast" => <OperatorCast as ::treesitter_types::FromNode>::from_node(node, src)
19848 .map(Self::OperatorCast)
19849 .unwrap_or(Self::Unknown(node)),
19850 "operator_name" => <OperatorName as ::treesitter_types::FromNode>::from_node(node, src)
19851 .map(Self::OperatorName)
19852 .unwrap_or(Self::Unknown(node)),
19853 "optional_parameter_declaration" => {
19854 <OptionalParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19855 .map(Self::OptionalParameterDeclaration)
19856 .unwrap_or(Self::Unknown(node))
19857 }
19858 "optional_type_parameter_declaration" => {
19859 <OptionalTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
19860 node, src,
19861 )
19862 .map(Self::OptionalTypeParameterDeclaration)
19863 .unwrap_or(Self::Unknown(node))
19864 }
19865 "parameter_declaration" => {
19866 <ParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
19867 .map(Self::ParameterDeclaration)
19868 .unwrap_or(Self::Unknown(node))
19869 }
19870 "parameter_list" => {
19871 <ParameterList as ::treesitter_types::FromNode>::from_node(node, src)
19872 .map(Self::ParameterList)
19873 .unwrap_or(Self::Unknown(node))
19874 }
19875 "parameter_pack_expansion" => {
19876 <ParameterPackExpansion as ::treesitter_types::FromNode>::from_node(node, src)
19877 .map(Self::ParameterPackExpansion)
19878 .unwrap_or(Self::Unknown(node))
19879 }
19880 "parenthesized_declarator" => {
19881 <ParenthesizedDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19882 .map(Self::ParenthesizedDeclarator)
19883 .unwrap_or(Self::Unknown(node))
19884 }
19885 "parenthesized_expression" => {
19886 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
19887 .map(Self::ParenthesizedExpression)
19888 .unwrap_or(Self::Unknown(node))
19889 }
19890 "placeholder_type_specifier" => {
19891 <PlaceholderTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
19892 .map(Self::PlaceholderTypeSpecifier)
19893 .unwrap_or(Self::Unknown(node))
19894 }
19895 "pointer_declarator" => {
19896 <PointerDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19897 .map(Self::PointerDeclarator)
19898 .unwrap_or(Self::Unknown(node))
19899 }
19900 "pointer_expression" => {
19901 <PointerExpression as ::treesitter_types::FromNode>::from_node(node, src)
19902 .map(Self::PointerExpression)
19903 .unwrap_or(Self::Unknown(node))
19904 }
19905 "pointer_type_declarator" => {
19906 <PointerTypeDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19907 .map(Self::PointerTypeDeclarator)
19908 .unwrap_or(Self::Unknown(node))
19909 }
19910 "preproc_call" => <PreprocCall as ::treesitter_types::FromNode>::from_node(node, src)
19911 .map(Self::PreprocCall)
19912 .unwrap_or(Self::Unknown(node)),
19913 "preproc_def" => <PreprocDef as ::treesitter_types::FromNode>::from_node(node, src)
19914 .map(Self::PreprocDef)
19915 .unwrap_or(Self::Unknown(node)),
19916 "preproc_defined" => {
19917 <PreprocDefined as ::treesitter_types::FromNode>::from_node(node, src)
19918 .map(Self::PreprocDefined)
19919 .unwrap_or(Self::Unknown(node))
19920 }
19921 "preproc_elif" => <PreprocElif as ::treesitter_types::FromNode>::from_node(node, src)
19922 .map(Self::PreprocElif)
19923 .unwrap_or(Self::Unknown(node)),
19924 "preproc_elifdef" => {
19925 <PreprocElifdef as ::treesitter_types::FromNode>::from_node(node, src)
19926 .map(Self::PreprocElifdef)
19927 .unwrap_or(Self::Unknown(node))
19928 }
19929 "preproc_else" => <PreprocElse as ::treesitter_types::FromNode>::from_node(node, src)
19930 .map(Self::PreprocElse)
19931 .unwrap_or(Self::Unknown(node)),
19932 "preproc_function_def" => {
19933 <PreprocFunctionDef as ::treesitter_types::FromNode>::from_node(node, src)
19934 .map(Self::PreprocFunctionDef)
19935 .unwrap_or(Self::Unknown(node))
19936 }
19937 "preproc_if" => <PreprocIf as ::treesitter_types::FromNode>::from_node(node, src)
19938 .map(Self::PreprocIf)
19939 .unwrap_or(Self::Unknown(node)),
19940 "preproc_ifdef" => <PreprocIfdef as ::treesitter_types::FromNode>::from_node(node, src)
19941 .map(Self::PreprocIfdef)
19942 .unwrap_or(Self::Unknown(node)),
19943 "preproc_include" => {
19944 <PreprocInclude as ::treesitter_types::FromNode>::from_node(node, src)
19945 .map(Self::PreprocInclude)
19946 .unwrap_or(Self::Unknown(node))
19947 }
19948 "preproc_params" => {
19949 <PreprocParams as ::treesitter_types::FromNode>::from_node(node, src)
19950 .map(Self::PreprocParams)
19951 .unwrap_or(Self::Unknown(node))
19952 }
19953 "pure_virtual_clause" => {
19954 <PureVirtualClause as ::treesitter_types::FromNode>::from_node(node, src)
19955 .map(Self::PureVirtualClause)
19956 .unwrap_or(Self::Unknown(node))
19957 }
19958 "qualified_identifier" => {
19959 <QualifiedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
19960 .map(Self::QualifiedIdentifier)
19961 .unwrap_or(Self::Unknown(node))
19962 }
19963 "raw_string_literal" => {
19964 <RawStringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
19965 .map(Self::RawStringLiteral)
19966 .unwrap_or(Self::Unknown(node))
19967 }
19968 "ref_qualifier" => <RefQualifier as ::treesitter_types::FromNode>::from_node(node, src)
19969 .map(Self::RefQualifier)
19970 .unwrap_or(Self::Unknown(node)),
19971 "reference_declarator" => {
19972 <ReferenceDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
19973 .map(Self::ReferenceDeclarator)
19974 .unwrap_or(Self::Unknown(node))
19975 }
19976 "requirement_seq" => {
19977 <RequirementSeq as ::treesitter_types::FromNode>::from_node(node, src)
19978 .map(Self::RequirementSeq)
19979 .unwrap_or(Self::Unknown(node))
19980 }
19981 "requires_clause" => {
19982 <RequiresClause as ::treesitter_types::FromNode>::from_node(node, src)
19983 .map(Self::RequiresClause)
19984 .unwrap_or(Self::Unknown(node))
19985 }
19986 "requires_expression" => {
19987 <RequiresExpression as ::treesitter_types::FromNode>::from_node(node, src)
19988 .map(Self::RequiresExpression)
19989 .unwrap_or(Self::Unknown(node))
19990 }
19991 "return_statement" => {
19992 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
19993 .map(Self::ReturnStatement)
19994 .unwrap_or(Self::Unknown(node))
19995 }
19996 "seh_except_clause" => {
19997 <SehExceptClause as ::treesitter_types::FromNode>::from_node(node, src)
19998 .map(Self::SehExceptClause)
19999 .unwrap_or(Self::Unknown(node))
20000 }
20001 "seh_finally_clause" => {
20002 <SehFinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
20003 .map(Self::SehFinallyClause)
20004 .unwrap_or(Self::Unknown(node))
20005 }
20006 "seh_leave_statement" => {
20007 <SehLeaveStatement as ::treesitter_types::FromNode>::from_node(node, src)
20008 .map(Self::SehLeaveStatement)
20009 .unwrap_or(Self::Unknown(node))
20010 }
20011 "seh_try_statement" => {
20012 <SehTryStatement as ::treesitter_types::FromNode>::from_node(node, src)
20013 .map(Self::SehTryStatement)
20014 .unwrap_or(Self::Unknown(node))
20015 }
20016 "simple_requirement" => {
20017 <SimpleRequirement as ::treesitter_types::FromNode>::from_node(node, src)
20018 .map(Self::SimpleRequirement)
20019 .unwrap_or(Self::Unknown(node))
20020 }
20021 "sized_type_specifier" => {
20022 <SizedTypeSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20023 .map(Self::SizedTypeSpecifier)
20024 .unwrap_or(Self::Unknown(node))
20025 }
20026 "sizeof_expression" => {
20027 <SizeofExpression as ::treesitter_types::FromNode>::from_node(node, src)
20028 .map(Self::SizeofExpression)
20029 .unwrap_or(Self::Unknown(node))
20030 }
20031 "static_assert_declaration" => {
20032 <StaticAssertDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20033 .map(Self::StaticAssertDeclaration)
20034 .unwrap_or(Self::Unknown(node))
20035 }
20036 "storage_class_specifier" => {
20037 <StorageClassSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20038 .map(Self::StorageClassSpecifier)
20039 .unwrap_or(Self::Unknown(node))
20040 }
20041 "string_literal" => {
20042 <StringLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20043 .map(Self::StringLiteral)
20044 .unwrap_or(Self::Unknown(node))
20045 }
20046 "struct_specifier" => {
20047 <StructSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20048 .map(Self::StructSpecifier)
20049 .unwrap_or(Self::Unknown(node))
20050 }
20051 "structured_binding_declarator" => {
20052 <StructuredBindingDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
20053 .map(Self::StructuredBindingDeclarator)
20054 .unwrap_or(Self::Unknown(node))
20055 }
20056 "subscript_argument_list" => {
20057 <SubscriptArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20058 .map(Self::SubscriptArgumentList)
20059 .unwrap_or(Self::Unknown(node))
20060 }
20061 "subscript_designator" => {
20062 <SubscriptDesignator as ::treesitter_types::FromNode>::from_node(node, src)
20063 .map(Self::SubscriptDesignator)
20064 .unwrap_or(Self::Unknown(node))
20065 }
20066 "subscript_expression" => {
20067 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
20068 .map(Self::SubscriptExpression)
20069 .unwrap_or(Self::Unknown(node))
20070 }
20071 "subscript_range_designator" => {
20072 <SubscriptRangeDesignator as ::treesitter_types::FromNode>::from_node(node, src)
20073 .map(Self::SubscriptRangeDesignator)
20074 .unwrap_or(Self::Unknown(node))
20075 }
20076 "switch_statement" => {
20077 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
20078 .map(Self::SwitchStatement)
20079 .unwrap_or(Self::Unknown(node))
20080 }
20081 "template_argument_list" => {
20082 <TemplateArgumentList as ::treesitter_types::FromNode>::from_node(node, src)
20083 .map(Self::TemplateArgumentList)
20084 .unwrap_or(Self::Unknown(node))
20085 }
20086 "template_declaration" => {
20087 <TemplateDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20088 .map(Self::TemplateDeclaration)
20089 .unwrap_or(Self::Unknown(node))
20090 }
20091 "template_function" => {
20092 <TemplateFunction as ::treesitter_types::FromNode>::from_node(node, src)
20093 .map(Self::TemplateFunction)
20094 .unwrap_or(Self::Unknown(node))
20095 }
20096 "template_instantiation" => {
20097 <TemplateInstantiation as ::treesitter_types::FromNode>::from_node(node, src)
20098 .map(Self::TemplateInstantiation)
20099 .unwrap_or(Self::Unknown(node))
20100 }
20101 "template_method" => {
20102 <TemplateMethod as ::treesitter_types::FromNode>::from_node(node, src)
20103 .map(Self::TemplateMethod)
20104 .unwrap_or(Self::Unknown(node))
20105 }
20106 "template_parameter_list" => {
20107 <TemplateParameterList as ::treesitter_types::FromNode>::from_node(node, src)
20108 .map(Self::TemplateParameterList)
20109 .unwrap_or(Self::Unknown(node))
20110 }
20111 "template_template_parameter_declaration" => {
20112 <TemplateTemplateParameterDeclaration as ::treesitter_types::FromNode>::from_node(
20113 node, src,
20114 )
20115 .map(Self::TemplateTemplateParameterDeclaration)
20116 .unwrap_or(Self::Unknown(node))
20117 }
20118 "template_type" => <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
20119 .map(Self::TemplateType)
20120 .unwrap_or(Self::Unknown(node)),
20121 "throw_specifier" => {
20122 <ThrowSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20123 .map(Self::ThrowSpecifier)
20124 .unwrap_or(Self::Unknown(node))
20125 }
20126 "throw_statement" => {
20127 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
20128 .map(Self::ThrowStatement)
20129 .unwrap_or(Self::Unknown(node))
20130 }
20131 "trailing_return_type" => {
20132 <TrailingReturnType as ::treesitter_types::FromNode>::from_node(node, src)
20133 .map(Self::TrailingReturnType)
20134 .unwrap_or(Self::Unknown(node))
20135 }
20136 "translation_unit" => {
20137 <TranslationUnit as ::treesitter_types::FromNode>::from_node(node, src)
20138 .map(Self::TranslationUnit)
20139 .unwrap_or(Self::Unknown(node))
20140 }
20141 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
20142 .map(Self::TryStatement)
20143 .unwrap_or(Self::Unknown(node)),
20144 "type_definition" => {
20145 <TypeDefinition as ::treesitter_types::FromNode>::from_node(node, src)
20146 .map(Self::TypeDefinition)
20147 .unwrap_or(Self::Unknown(node))
20148 }
20149 "type_descriptor" => {
20150 <TypeDescriptor as ::treesitter_types::FromNode>::from_node(node, src)
20151 .map(Self::TypeDescriptor)
20152 .unwrap_or(Self::Unknown(node))
20153 }
20154 "type_parameter_declaration" => {
20155 <TypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20156 .map(Self::TypeParameterDeclaration)
20157 .unwrap_or(Self::Unknown(node))
20158 }
20159 "type_qualifier" => {
20160 <TypeQualifier as ::treesitter_types::FromNode>::from_node(node, src)
20161 .map(Self::TypeQualifier)
20162 .unwrap_or(Self::Unknown(node))
20163 }
20164 "type_requirement" => {
20165 <TypeRequirement as ::treesitter_types::FromNode>::from_node(node, src)
20166 .map(Self::TypeRequirement)
20167 .unwrap_or(Self::Unknown(node))
20168 }
20169 "unary_expression" => {
20170 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
20171 .map(Self::UnaryExpression)
20172 .unwrap_or(Self::Unknown(node))
20173 }
20174 "union_specifier" => {
20175 <UnionSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20176 .map(Self::UnionSpecifier)
20177 .unwrap_or(Self::Unknown(node))
20178 }
20179 "update_expression" => {
20180 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
20181 .map(Self::UpdateExpression)
20182 .unwrap_or(Self::Unknown(node))
20183 }
20184 "user_defined_literal" => {
20185 <UserDefinedLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20186 .map(Self::UserDefinedLiteral)
20187 .unwrap_or(Self::Unknown(node))
20188 }
20189 "using_declaration" => {
20190 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20191 .map(Self::UsingDeclaration)
20192 .unwrap_or(Self::Unknown(node))
20193 }
20194 "variadic_declarator" => {
20195 <VariadicDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
20196 .map(Self::VariadicDeclarator)
20197 .unwrap_or(Self::Unknown(node))
20198 }
20199 "variadic_parameter_declaration" => {
20200 <VariadicParameterDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
20201 .map(Self::VariadicParameterDeclaration)
20202 .unwrap_or(Self::Unknown(node))
20203 }
20204 "variadic_type_parameter_declaration" => {
20205 <VariadicTypeParameterDeclaration as ::treesitter_types::FromNode>::from_node(
20206 node, src,
20207 )
20208 .map(Self::VariadicTypeParameterDeclaration)
20209 .unwrap_or(Self::Unknown(node))
20210 }
20211 "virtual_specifier" => {
20212 <VirtualSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
20213 .map(Self::VirtualSpecifier)
20214 .unwrap_or(Self::Unknown(node))
20215 }
20216 "while_statement" => {
20217 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
20218 .map(Self::WhileStatement)
20219 .unwrap_or(Self::Unknown(node))
20220 }
20221 "auto" => <Auto as ::treesitter_types::FromNode>::from_node(node, src)
20222 .map(Self::Auto)
20223 .unwrap_or(Self::Unknown(node)),
20224 "character" => <Character as ::treesitter_types::FromNode>::from_node(node, src)
20225 .map(Self::Character)
20226 .unwrap_or(Self::Unknown(node)),
20227 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
20228 .map(Self::Comment)
20229 .unwrap_or(Self::Unknown(node)),
20230 "escape_sequence" => {
20231 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
20232 .map(Self::EscapeSequence)
20233 .unwrap_or(Self::Unknown(node))
20234 }
20235 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
20236 .map(Self::False)
20237 .unwrap_or(Self::Unknown(node)),
20238 "field_identifier" => {
20239 <FieldIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20240 .map(Self::FieldIdentifier)
20241 .unwrap_or(Self::Unknown(node))
20242 }
20243 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
20244 .map(Self::Identifier)
20245 .unwrap_or(Self::Unknown(node)),
20246 "literal_suffix" => {
20247 <LiteralSuffix as ::treesitter_types::FromNode>::from_node(node, src)
20248 .map(Self::LiteralSuffix)
20249 .unwrap_or(Self::Unknown(node))
20250 }
20251 "ms_restrict_modifier" => {
20252 <MsRestrictModifier as ::treesitter_types::FromNode>::from_node(node, src)
20253 .map(Self::MsRestrictModifier)
20254 .unwrap_or(Self::Unknown(node))
20255 }
20256 "ms_signed_ptr_modifier" => {
20257 <MsSignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
20258 .map(Self::MsSignedPtrModifier)
20259 .unwrap_or(Self::Unknown(node))
20260 }
20261 "ms_unsigned_ptr_modifier" => {
20262 <MsUnsignedPtrModifier as ::treesitter_types::FromNode>::from_node(node, src)
20263 .map(Self::MsUnsignedPtrModifier)
20264 .unwrap_or(Self::Unknown(node))
20265 }
20266 "namespace_identifier" => {
20267 <NamespaceIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20268 .map(Self::NamespaceIdentifier)
20269 .unwrap_or(Self::Unknown(node))
20270 }
20271 "number_literal" => {
20272 <NumberLiteral as ::treesitter_types::FromNode>::from_node(node, src)
20273 .map(Self::NumberLiteral)
20274 .unwrap_or(Self::Unknown(node))
20275 }
20276 "preproc_arg" => <PreprocArg as ::treesitter_types::FromNode>::from_node(node, src)
20277 .map(Self::PreprocArg)
20278 .unwrap_or(Self::Unknown(node)),
20279 "preproc_directive" => {
20280 <PreprocDirective as ::treesitter_types::FromNode>::from_node(node, src)
20281 .map(Self::PreprocDirective)
20282 .unwrap_or(Self::Unknown(node))
20283 }
20284 "primitive_type" => {
20285 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
20286 .map(Self::PrimitiveType)
20287 .unwrap_or(Self::Unknown(node))
20288 }
20289 "raw_string_content" => {
20290 <RawStringContent as ::treesitter_types::FromNode>::from_node(node, src)
20291 .map(Self::RawStringContent)
20292 .unwrap_or(Self::Unknown(node))
20293 }
20294 "raw_string_delimiter" => {
20295 <RawStringDelimiter as ::treesitter_types::FromNode>::from_node(node, src)
20296 .map(Self::RawStringDelimiter)
20297 .unwrap_or(Self::Unknown(node))
20298 }
20299 "statement_identifier" => {
20300 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20301 .map(Self::StatementIdentifier)
20302 .unwrap_or(Self::Unknown(node))
20303 }
20304 "string_content" => {
20305 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
20306 .map(Self::StringContent)
20307 .unwrap_or(Self::Unknown(node))
20308 }
20309 "system_lib_string" => {
20310 <SystemLibString as ::treesitter_types::FromNode>::from_node(node, src)
20311 .map(Self::SystemLibString)
20312 .unwrap_or(Self::Unknown(node))
20313 }
20314 "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
20315 .map(Self::This)
20316 .unwrap_or(Self::Unknown(node)),
20317 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
20318 .map(Self::True)
20319 .unwrap_or(Self::Unknown(node)),
20320 "type_identifier" => {
20321 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
20322 .map(Self::TypeIdentifier)
20323 .unwrap_or(Self::Unknown(node))
20324 }
20325 _ => Self::Unknown(node),
20326 }
20327 }
20328}
20329impl ::treesitter_types::Spanned for AnyNode<'_> {
20330 fn span(&self) -> ::treesitter_types::Span {
20331 match self {
20332 Self::AbstractDeclarator(inner) => inner.span(),
20333 Self::Declarator(inner) => inner.span(),
20334 Self::FieldDeclarator(inner) => inner.span(),
20335 Self::TypeDeclarator(inner) => inner.span(),
20336 Self::Expression(inner) => inner.span(),
20337 Self::Statement(inner) => inner.span(),
20338 Self::TypeSpecifier(inner) => inner.span(),
20339 Self::AbstractArrayDeclarator(inner) => inner.span(),
20340 Self::AbstractFunctionDeclarator(inner) => inner.span(),
20341 Self::AbstractParenthesizedDeclarator(inner) => inner.span(),
20342 Self::AbstractPointerDeclarator(inner) => inner.span(),
20343 Self::AbstractReferenceDeclarator(inner) => inner.span(),
20344 Self::AccessSpecifier(inner) => inner.span(),
20345 Self::AliasDeclaration(inner) => inner.span(),
20346 Self::AlignasQualifier(inner) => inner.span(),
20347 Self::AlignofExpression(inner) => inner.span(),
20348 Self::ArgumentList(inner) => inner.span(),
20349 Self::ArrayDeclarator(inner) => inner.span(),
20350 Self::AssignmentExpression(inner) => inner.span(),
20351 Self::Attribute(inner) => inner.span(),
20352 Self::AttributeDeclaration(inner) => inner.span(),
20353 Self::AttributeSpecifier(inner) => inner.span(),
20354 Self::AttributedDeclarator(inner) => inner.span(),
20355 Self::AttributedStatement(inner) => inner.span(),
20356 Self::BaseClassClause(inner) => inner.span(),
20357 Self::BinaryExpression(inner) => inner.span(),
20358 Self::BitfieldClause(inner) => inner.span(),
20359 Self::BreakStatement(inner) => inner.span(),
20360 Self::CallExpression(inner) => inner.span(),
20361 Self::CaseStatement(inner) => inner.span(),
20362 Self::CastExpression(inner) => inner.span(),
20363 Self::CatchClause(inner) => inner.span(),
20364 Self::CharLiteral(inner) => inner.span(),
20365 Self::ClassSpecifier(inner) => inner.span(),
20366 Self::CoAwaitExpression(inner) => inner.span(),
20367 Self::CoReturnStatement(inner) => inner.span(),
20368 Self::CoYieldStatement(inner) => inner.span(),
20369 Self::CommaExpression(inner) => inner.span(),
20370 Self::CompoundLiteralExpression(inner) => inner.span(),
20371 Self::CompoundRequirement(inner) => inner.span(),
20372 Self::CompoundStatement(inner) => inner.span(),
20373 Self::ConcatenatedString(inner) => inner.span(),
20374 Self::ConceptDefinition(inner) => inner.span(),
20375 Self::ConditionClause(inner) => inner.span(),
20376 Self::ConditionalExpression(inner) => inner.span(),
20377 Self::ConstraintConjunction(inner) => inner.span(),
20378 Self::ConstraintDisjunction(inner) => inner.span(),
20379 Self::ContinueStatement(inner) => inner.span(),
20380 Self::Declaration(inner) => inner.span(),
20381 Self::DeclarationList(inner) => inner.span(),
20382 Self::Decltype(inner) => inner.span(),
20383 Self::DefaultMethodClause(inner) => inner.span(),
20384 Self::DeleteExpression(inner) => inner.span(),
20385 Self::DeleteMethodClause(inner) => inner.span(),
20386 Self::DependentName(inner) => inner.span(),
20387 Self::DependentType(inner) => inner.span(),
20388 Self::DestructorName(inner) => inner.span(),
20389 Self::DoStatement(inner) => inner.span(),
20390 Self::ElseClause(inner) => inner.span(),
20391 Self::EnumSpecifier(inner) => inner.span(),
20392 Self::Enumerator(inner) => inner.span(),
20393 Self::EnumeratorList(inner) => inner.span(),
20394 Self::ExplicitFunctionSpecifier(inner) => inner.span(),
20395 Self::ExpressionStatement(inner) => inner.span(),
20396 Self::ExtensionExpression(inner) => inner.span(),
20397 Self::FieldDeclaration(inner) => inner.span(),
20398 Self::FieldDeclarationList(inner) => inner.span(),
20399 Self::FieldDesignator(inner) => inner.span(),
20400 Self::FieldExpression(inner) => inner.span(),
20401 Self::FieldInitializer(inner) => inner.span(),
20402 Self::FieldInitializerList(inner) => inner.span(),
20403 Self::FoldExpression(inner) => inner.span(),
20404 Self::ForRangeLoop(inner) => inner.span(),
20405 Self::ForStatement(inner) => inner.span(),
20406 Self::FriendDeclaration(inner) => inner.span(),
20407 Self::FunctionDeclarator(inner) => inner.span(),
20408 Self::FunctionDefinition(inner) => inner.span(),
20409 Self::GenericExpression(inner) => inner.span(),
20410 Self::GnuAsmClobberList(inner) => inner.span(),
20411 Self::GnuAsmExpression(inner) => inner.span(),
20412 Self::GnuAsmGotoList(inner) => inner.span(),
20413 Self::GnuAsmInputOperand(inner) => inner.span(),
20414 Self::GnuAsmInputOperandList(inner) => inner.span(),
20415 Self::GnuAsmOutputOperand(inner) => inner.span(),
20416 Self::GnuAsmOutputOperandList(inner) => inner.span(),
20417 Self::GnuAsmQualifier(inner) => inner.span(),
20418 Self::GotoStatement(inner) => inner.span(),
20419 Self::IfStatement(inner) => inner.span(),
20420 Self::InitDeclarator(inner) => inner.span(),
20421 Self::InitStatement(inner) => inner.span(),
20422 Self::InitializerList(inner) => inner.span(),
20423 Self::InitializerPair(inner) => inner.span(),
20424 Self::LabeledStatement(inner) => inner.span(),
20425 Self::LambdaCaptureInitializer(inner) => inner.span(),
20426 Self::LambdaCaptureSpecifier(inner) => inner.span(),
20427 Self::LambdaDefaultCapture(inner) => inner.span(),
20428 Self::LambdaExpression(inner) => inner.span(),
20429 Self::LinkageSpecification(inner) => inner.span(),
20430 Self::MsBasedModifier(inner) => inner.span(),
20431 Self::MsCallModifier(inner) => inner.span(),
20432 Self::MsDeclspecModifier(inner) => inner.span(),
20433 Self::MsPointerModifier(inner) => inner.span(),
20434 Self::MsUnalignedPtrModifier(inner) => inner.span(),
20435 Self::NamespaceAliasDefinition(inner) => inner.span(),
20436 Self::NamespaceDefinition(inner) => inner.span(),
20437 Self::NestedNamespaceSpecifier(inner) => inner.span(),
20438 Self::NewDeclarator(inner) => inner.span(),
20439 Self::NewExpression(inner) => inner.span(),
20440 Self::Noexcept(inner) => inner.span(),
20441 Self::Null(inner) => inner.span(),
20442 Self::OffsetofExpression(inner) => inner.span(),
20443 Self::OperatorCast(inner) => inner.span(),
20444 Self::OperatorName(inner) => inner.span(),
20445 Self::OptionalParameterDeclaration(inner) => inner.span(),
20446 Self::OptionalTypeParameterDeclaration(inner) => inner.span(),
20447 Self::ParameterDeclaration(inner) => inner.span(),
20448 Self::ParameterList(inner) => inner.span(),
20449 Self::ParameterPackExpansion(inner) => inner.span(),
20450 Self::ParenthesizedDeclarator(inner) => inner.span(),
20451 Self::ParenthesizedExpression(inner) => inner.span(),
20452 Self::PlaceholderTypeSpecifier(inner) => inner.span(),
20453 Self::PointerDeclarator(inner) => inner.span(),
20454 Self::PointerExpression(inner) => inner.span(),
20455 Self::PointerTypeDeclarator(inner) => inner.span(),
20456 Self::PreprocCall(inner) => inner.span(),
20457 Self::PreprocDef(inner) => inner.span(),
20458 Self::PreprocDefined(inner) => inner.span(),
20459 Self::PreprocElif(inner) => inner.span(),
20460 Self::PreprocElifdef(inner) => inner.span(),
20461 Self::PreprocElse(inner) => inner.span(),
20462 Self::PreprocFunctionDef(inner) => inner.span(),
20463 Self::PreprocIf(inner) => inner.span(),
20464 Self::PreprocIfdef(inner) => inner.span(),
20465 Self::PreprocInclude(inner) => inner.span(),
20466 Self::PreprocParams(inner) => inner.span(),
20467 Self::PureVirtualClause(inner) => inner.span(),
20468 Self::QualifiedIdentifier(inner) => inner.span(),
20469 Self::RawStringLiteral(inner) => inner.span(),
20470 Self::RefQualifier(inner) => inner.span(),
20471 Self::ReferenceDeclarator(inner) => inner.span(),
20472 Self::RequirementSeq(inner) => inner.span(),
20473 Self::RequiresClause(inner) => inner.span(),
20474 Self::RequiresExpression(inner) => inner.span(),
20475 Self::ReturnStatement(inner) => inner.span(),
20476 Self::SehExceptClause(inner) => inner.span(),
20477 Self::SehFinallyClause(inner) => inner.span(),
20478 Self::SehLeaveStatement(inner) => inner.span(),
20479 Self::SehTryStatement(inner) => inner.span(),
20480 Self::SimpleRequirement(inner) => inner.span(),
20481 Self::SizedTypeSpecifier(inner) => inner.span(),
20482 Self::SizeofExpression(inner) => inner.span(),
20483 Self::StaticAssertDeclaration(inner) => inner.span(),
20484 Self::StorageClassSpecifier(inner) => inner.span(),
20485 Self::StringLiteral(inner) => inner.span(),
20486 Self::StructSpecifier(inner) => inner.span(),
20487 Self::StructuredBindingDeclarator(inner) => inner.span(),
20488 Self::SubscriptArgumentList(inner) => inner.span(),
20489 Self::SubscriptDesignator(inner) => inner.span(),
20490 Self::SubscriptExpression(inner) => inner.span(),
20491 Self::SubscriptRangeDesignator(inner) => inner.span(),
20492 Self::SwitchStatement(inner) => inner.span(),
20493 Self::TemplateArgumentList(inner) => inner.span(),
20494 Self::TemplateDeclaration(inner) => inner.span(),
20495 Self::TemplateFunction(inner) => inner.span(),
20496 Self::TemplateInstantiation(inner) => inner.span(),
20497 Self::TemplateMethod(inner) => inner.span(),
20498 Self::TemplateParameterList(inner) => inner.span(),
20499 Self::TemplateTemplateParameterDeclaration(inner) => inner.span(),
20500 Self::TemplateType(inner) => inner.span(),
20501 Self::ThrowSpecifier(inner) => inner.span(),
20502 Self::ThrowStatement(inner) => inner.span(),
20503 Self::TrailingReturnType(inner) => inner.span(),
20504 Self::TranslationUnit(inner) => inner.span(),
20505 Self::TryStatement(inner) => inner.span(),
20506 Self::TypeDefinition(inner) => inner.span(),
20507 Self::TypeDescriptor(inner) => inner.span(),
20508 Self::TypeParameterDeclaration(inner) => inner.span(),
20509 Self::TypeQualifier(inner) => inner.span(),
20510 Self::TypeRequirement(inner) => inner.span(),
20511 Self::UnaryExpression(inner) => inner.span(),
20512 Self::UnionSpecifier(inner) => inner.span(),
20513 Self::UpdateExpression(inner) => inner.span(),
20514 Self::UserDefinedLiteral(inner) => inner.span(),
20515 Self::UsingDeclaration(inner) => inner.span(),
20516 Self::VariadicDeclarator(inner) => inner.span(),
20517 Self::VariadicParameterDeclaration(inner) => inner.span(),
20518 Self::VariadicTypeParameterDeclaration(inner) => inner.span(),
20519 Self::VirtualSpecifier(inner) => inner.span(),
20520 Self::WhileStatement(inner) => inner.span(),
20521 Self::Auto(inner) => inner.span(),
20522 Self::Character(inner) => inner.span(),
20523 Self::Comment(inner) => inner.span(),
20524 Self::EscapeSequence(inner) => inner.span(),
20525 Self::False(inner) => inner.span(),
20526 Self::FieldIdentifier(inner) => inner.span(),
20527 Self::Identifier(inner) => inner.span(),
20528 Self::LiteralSuffix(inner) => inner.span(),
20529 Self::MsRestrictModifier(inner) => inner.span(),
20530 Self::MsSignedPtrModifier(inner) => inner.span(),
20531 Self::MsUnsignedPtrModifier(inner) => inner.span(),
20532 Self::NamespaceIdentifier(inner) => inner.span(),
20533 Self::NumberLiteral(inner) => inner.span(),
20534 Self::PreprocArg(inner) => inner.span(),
20535 Self::PreprocDirective(inner) => inner.span(),
20536 Self::PrimitiveType(inner) => inner.span(),
20537 Self::RawStringContent(inner) => inner.span(),
20538 Self::RawStringDelimiter(inner) => inner.span(),
20539 Self::StatementIdentifier(inner) => inner.span(),
20540 Self::StringContent(inner) => inner.span(),
20541 Self::SystemLibString(inner) => inner.span(),
20542 Self::This(inner) => inner.span(),
20543 Self::True(inner) => inner.span(),
20544 Self::TypeIdentifier(inner) => inner.span(),
20545 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
20546 }
20547 }
20548}