1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Expression<'tree> {
3 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
4 AugmentedAssignmentExpression(::std::boxed::Box<AugmentedAssignmentExpression<'tree>>),
5 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
6 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
7 CloneExpression(::std::boxed::Box<CloneExpression<'tree>>),
8 ConditionalExpression(::std::boxed::Box<ConditionalExpression<'tree>>),
9 ErrorSuppressionExpression(::std::boxed::Box<ErrorSuppressionExpression<'tree>>),
10 IncludeExpression(::std::boxed::Box<IncludeExpression<'tree>>),
11 IncludeOnceExpression(::std::boxed::Box<IncludeOnceExpression<'tree>>),
12 MatchExpression(::std::boxed::Box<MatchExpression<'tree>>),
13 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
14 ReferenceAssignmentExpression(::std::boxed::Box<ReferenceAssignmentExpression<'tree>>),
15 RequireExpression(::std::boxed::Box<RequireExpression<'tree>>),
16 RequireOnceExpression(::std::boxed::Box<RequireOnceExpression<'tree>>),
17 UnaryOpExpression(::std::boxed::Box<UnaryOpExpression<'tree>>),
18 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
19}
20impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
21 #[allow(clippy::collapsible_else_if)]
22 fn from_node(
23 node: ::treesitter_types::tree_sitter::Node<'tree>,
24 src: &'tree [u8],
25 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
26 match node.kind() {
27 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
28 ::treesitter_types::runtime::maybe_grow_stack(|| {
29 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
30 })?,
31 ))),
32 "augmented_assignment_expression" => Ok(Self::AugmentedAssignmentExpression(
33 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
34 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
35 node, src,
36 )
37 })?),
38 )),
39 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
40 ::treesitter_types::runtime::maybe_grow_stack(|| {
41 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
42 })?,
43 ))),
44 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
45 ::treesitter_types::runtime::maybe_grow_stack(|| {
46 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
47 })?,
48 ))),
49 "clone_expression" => Ok(Self::CloneExpression(::std::boxed::Box::new(
50 ::treesitter_types::runtime::maybe_grow_stack(|| {
51 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)
52 })?,
53 ))),
54 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
55 ::treesitter_types::runtime::maybe_grow_stack(|| {
56 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
57 })?,
58 ))),
59 "error_suppression_expression" => Ok(Self::ErrorSuppressionExpression(
60 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
61 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(
62 node, src,
63 )
64 })?),
65 )),
66 "include_expression" => Ok(Self::IncludeExpression(::std::boxed::Box::new(
67 ::treesitter_types::runtime::maybe_grow_stack(|| {
68 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)
69 })?,
70 ))),
71 "include_once_expression" => Ok(Self::IncludeOnceExpression(::std::boxed::Box::new(
72 ::treesitter_types::runtime::maybe_grow_stack(|| {
73 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
74 })?,
75 ))),
76 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
77 ::treesitter_types::runtime::maybe_grow_stack(|| {
78 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
79 })?,
80 ))),
81 "reference_assignment_expression" => Ok(Self::ReferenceAssignmentExpression(
82 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
83 <ReferenceAssignmentExpression as ::treesitter_types::FromNode>::from_node(
84 node, src,
85 )
86 })?),
87 )),
88 "require_expression" => Ok(Self::RequireExpression(::std::boxed::Box::new(
89 ::treesitter_types::runtime::maybe_grow_stack(|| {
90 <RequireExpression as ::treesitter_types::FromNode>::from_node(node, src)
91 })?,
92 ))),
93 "require_once_expression" => Ok(Self::RequireOnceExpression(::std::boxed::Box::new(
94 ::treesitter_types::runtime::maybe_grow_stack(|| {
95 <RequireOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
96 })?,
97 ))),
98 "unary_op_expression" => Ok(Self::UnaryOpExpression(::std::boxed::Box::new(
99 ::treesitter_types::runtime::maybe_grow_stack(|| {
100 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)
101 })?,
102 ))),
103 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
104 ::treesitter_types::runtime::maybe_grow_stack(|| {
105 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
106 })?,
107 ))),
108 _other => {
109 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
110 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
111 }) {
112 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
113 } else {
114 Err(::treesitter_types::ParseError::unexpected_kind(
115 _other, node,
116 ))
117 }
118 }
119 }
120 }
121}
122impl ::treesitter_types::Spanned for Expression<'_> {
123 fn span(&self) -> ::treesitter_types::Span {
124 match self {
125 Self::AssignmentExpression(inner) => inner.span(),
126 Self::AugmentedAssignmentExpression(inner) => inner.span(),
127 Self::BinaryExpression(inner) => inner.span(),
128 Self::CastExpression(inner) => inner.span(),
129 Self::CloneExpression(inner) => inner.span(),
130 Self::ConditionalExpression(inner) => inner.span(),
131 Self::ErrorSuppressionExpression(inner) => inner.span(),
132 Self::IncludeExpression(inner) => inner.span(),
133 Self::IncludeOnceExpression(inner) => inner.span(),
134 Self::MatchExpression(inner) => inner.span(),
135 Self::PrimaryExpression(inner) => inner.span(),
136 Self::ReferenceAssignmentExpression(inner) => inner.span(),
137 Self::RequireExpression(inner) => inner.span(),
138 Self::RequireOnceExpression(inner) => inner.span(),
139 Self::UnaryOpExpression(inner) => inner.span(),
140 Self::YieldExpression(inner) => inner.span(),
141 }
142 }
143}
144#[derive(Debug, Clone, PartialEq, Eq)]
145pub enum Literal<'tree> {
146 Boolean(::std::boxed::Box<Boolean<'tree>>),
147 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
148 Float(::std::boxed::Box<Float<'tree>>),
149 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
150 Integer(::std::boxed::Box<Integer<'tree>>),
151 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
152 Null(::std::boxed::Box<Null<'tree>>),
153 String(::std::boxed::Box<String<'tree>>),
154}
155impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
156 #[allow(clippy::collapsible_else_if)]
157 fn from_node(
158 node: ::treesitter_types::tree_sitter::Node<'tree>,
159 src: &'tree [u8],
160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
161 match node.kind() {
162 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
163 ::treesitter_types::runtime::maybe_grow_stack(|| {
164 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
165 })?,
166 ))),
167 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
168 ::treesitter_types::runtime::maybe_grow_stack(|| {
169 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
170 })?,
171 ))),
172 "float" => Ok(Self::Float(::std::boxed::Box::new(
173 ::treesitter_types::runtime::maybe_grow_stack(|| {
174 <Float as ::treesitter_types::FromNode>::from_node(node, src)
175 })?,
176 ))),
177 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
178 ::treesitter_types::runtime::maybe_grow_stack(|| {
179 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
180 })?,
181 ))),
182 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
183 ::treesitter_types::runtime::maybe_grow_stack(|| {
184 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
185 })?,
186 ))),
187 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
188 ::treesitter_types::runtime::maybe_grow_stack(|| {
189 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
190 })?,
191 ))),
192 "null" => Ok(Self::Null(::std::boxed::Box::new(
193 ::treesitter_types::runtime::maybe_grow_stack(|| {
194 <Null as ::treesitter_types::FromNode>::from_node(node, src)
195 })?,
196 ))),
197 "string" => Ok(Self::String(::std::boxed::Box::new(
198 ::treesitter_types::runtime::maybe_grow_stack(|| {
199 <String as ::treesitter_types::FromNode>::from_node(node, src)
200 })?,
201 ))),
202 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
203 }
204 }
205}
206impl ::treesitter_types::Spanned for Literal<'_> {
207 fn span(&self) -> ::treesitter_types::Span {
208 match self {
209 Self::Boolean(inner) => inner.span(),
210 Self::EncapsedString(inner) => inner.span(),
211 Self::Float(inner) => inner.span(),
212 Self::Heredoc(inner) => inner.span(),
213 Self::Integer(inner) => inner.span(),
214 Self::Nowdoc(inner) => inner.span(),
215 Self::Null(inner) => inner.span(),
216 Self::String(inner) => inner.span(),
217 }
218 }
219}
220#[derive(Debug, Clone, PartialEq, Eq)]
221pub enum PrimaryExpression<'tree> {
222 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
223 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
224 ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
225 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
226 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
227 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
228 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
229 Literal(::std::boxed::Box<Literal<'tree>>),
230 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
231 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
232 Name(::std::boxed::Box<Name<'tree>>),
233 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
234 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
235 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
236 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
237 PrintIntrinsic(::std::boxed::Box<PrintIntrinsic<'tree>>),
238 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
239 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
240 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
241 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
242 ShellCommandExpression(::std::boxed::Box<ShellCommandExpression<'tree>>),
243 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
244 ThrowExpression(::std::boxed::Box<ThrowExpression<'tree>>),
245 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
246 VariableName(::std::boxed::Box<VariableName<'tree>>),
247}
248impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
249 #[allow(clippy::collapsible_else_if)]
250 fn from_node(
251 node: ::treesitter_types::tree_sitter::Node<'tree>,
252 src: &'tree [u8],
253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
254 match node.kind() {
255 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
256 ::treesitter_types::runtime::maybe_grow_stack(|| {
257 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)
258 })?,
259 ))),
260 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
261 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
262 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
263 })?),
264 )),
265 "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
266 ::treesitter_types::runtime::maybe_grow_stack(|| {
267 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
268 })?,
269 ))),
270 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
271 ::treesitter_types::runtime::maybe_grow_stack(|| {
272 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
273 })?,
274 ))),
275 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
276 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
277 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
278 node, src,
279 )
280 })?),
281 )),
282 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
283 ::treesitter_types::runtime::maybe_grow_stack(|| {
284 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
285 })?,
286 ))),
287 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
288 ::treesitter_types::runtime::maybe_grow_stack(|| {
289 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
290 })?,
291 ))),
292 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
293 ::treesitter_types::runtime::maybe_grow_stack(|| {
294 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
295 })?,
296 ))),
297 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
298 ::treesitter_types::runtime::maybe_grow_stack(|| {
299 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
300 })?,
301 ))),
302 "name" => Ok(Self::Name(::std::boxed::Box::new(
303 ::treesitter_types::runtime::maybe_grow_stack(|| {
304 <Name as ::treesitter_types::FromNode>::from_node(node, src)
305 })?,
306 ))),
307 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
308 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
309 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
310 node, src,
311 )
312 })?),
313 )),
314 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
315 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
316 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
317 node, src,
318 )
319 })?),
320 )),
321 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
322 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
323 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
324 })?),
325 )),
326 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
327 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
328 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
329 })?),
330 )),
331 "print_intrinsic" => Ok(Self::PrintIntrinsic(::std::boxed::Box::new(
332 ::treesitter_types::runtime::maybe_grow_stack(|| {
333 <PrintIntrinsic as ::treesitter_types::FromNode>::from_node(node, src)
334 })?,
335 ))),
336 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
337 ::treesitter_types::runtime::maybe_grow_stack(|| {
338 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
339 })?,
340 ))),
341 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
342 ::treesitter_types::runtime::maybe_grow_stack(|| {
343 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
344 })?,
345 ))),
346 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
347 ::treesitter_types::runtime::maybe_grow_stack(|| {
348 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
349 })?,
350 ))),
351 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
352 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
353 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
354 node, src,
355 )
356 })?),
357 )),
358 "shell_command_expression" => Ok(Self::ShellCommandExpression(::std::boxed::Box::new(
359 ::treesitter_types::runtime::maybe_grow_stack(|| {
360 <ShellCommandExpression as ::treesitter_types::FromNode>::from_node(node, src)
361 })?,
362 ))),
363 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
364 ::treesitter_types::runtime::maybe_grow_stack(|| {
365 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
366 })?,
367 ))),
368 "throw_expression" => Ok(Self::ThrowExpression(::std::boxed::Box::new(
369 ::treesitter_types::runtime::maybe_grow_stack(|| {
370 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
371 })?,
372 ))),
373 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
374 ::treesitter_types::runtime::maybe_grow_stack(|| {
375 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
376 })?,
377 ))),
378 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
379 ::treesitter_types::runtime::maybe_grow_stack(|| {
380 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
381 })?,
382 ))),
383 _other => {
384 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
385 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
386 }) {
387 Ok(Self::Literal(::std::boxed::Box::new(v)))
388 } else {
389 Err(::treesitter_types::ParseError::unexpected_kind(
390 _other, node,
391 ))
392 }
393 }
394 }
395 }
396}
397impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
398 fn span(&self) -> ::treesitter_types::Span {
399 match self {
400 Self::AnonymousFunction(inner) => inner.span(),
401 Self::ArrayCreationExpression(inner) => inner.span(),
402 Self::ArrowFunction(inner) => inner.span(),
403 Self::CastExpression(inner) => inner.span(),
404 Self::ClassConstantAccessExpression(inner) => inner.span(),
405 Self::DynamicVariableName(inner) => inner.span(),
406 Self::FunctionCallExpression(inner) => inner.span(),
407 Self::Literal(inner) => inner.span(),
408 Self::MemberAccessExpression(inner) => inner.span(),
409 Self::MemberCallExpression(inner) => inner.span(),
410 Self::Name(inner) => inner.span(),
411 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
412 Self::NullsafeMemberCallExpression(inner) => inner.span(),
413 Self::ObjectCreationExpression(inner) => inner.span(),
414 Self::ParenthesizedExpression(inner) => inner.span(),
415 Self::PrintIntrinsic(inner) => inner.span(),
416 Self::QualifiedName(inner) => inner.span(),
417 Self::RelativeName(inner) => inner.span(),
418 Self::ScopedCallExpression(inner) => inner.span(),
419 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
420 Self::ShellCommandExpression(inner) => inner.span(),
421 Self::SubscriptExpression(inner) => inner.span(),
422 Self::ThrowExpression(inner) => inner.span(),
423 Self::UpdateExpression(inner) => inner.span(),
424 Self::VariableName(inner) => inner.span(),
425 }
426 }
427}
428#[derive(Debug, Clone, PartialEq, Eq)]
429pub enum Statement<'tree> {
430 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
431 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
432 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
433 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
434 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
435 DeclareStatement(::std::boxed::Box<DeclareStatement<'tree>>),
436 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
437 EchoStatement(::std::boxed::Box<EchoStatement<'tree>>),
438 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
439 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
440 ExitStatement(::std::boxed::Box<ExitStatement<'tree>>),
441 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
442 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
443 ForeachStatement(::std::boxed::Box<ForeachStatement<'tree>>),
444 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
445 FunctionStaticDeclaration(::std::boxed::Box<FunctionStaticDeclaration<'tree>>),
446 GlobalDeclaration(::std::boxed::Box<GlobalDeclaration<'tree>>),
447 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
448 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
449 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
450 NamedLabelStatement(::std::boxed::Box<NamedLabelStatement<'tree>>),
451 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
452 NamespaceUseDeclaration(::std::boxed::Box<NamespaceUseDeclaration<'tree>>),
453 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
454 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
455 TraitDeclaration(::std::boxed::Box<TraitDeclaration<'tree>>),
456 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
457 UnsetStatement(::std::boxed::Box<UnsetStatement<'tree>>),
458 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
459}
460impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
461 #[allow(clippy::collapsible_else_if)]
462 fn from_node(
463 node: ::treesitter_types::tree_sitter::Node<'tree>,
464 src: &'tree [u8],
465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
466 match node.kind() {
467 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
468 ::treesitter_types::runtime::maybe_grow_stack(|| {
469 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
470 })?,
471 ))),
472 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
473 ::treesitter_types::runtime::maybe_grow_stack(|| {
474 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
475 })?,
476 ))),
477 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
478 ::treesitter_types::runtime::maybe_grow_stack(|| {
479 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
480 })?,
481 ))),
482 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
483 ::treesitter_types::runtime::maybe_grow_stack(|| {
484 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
485 })?,
486 ))),
487 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
488 ::treesitter_types::runtime::maybe_grow_stack(|| {
489 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
490 })?,
491 ))),
492 "declare_statement" => Ok(Self::DeclareStatement(::std::boxed::Box::new(
493 ::treesitter_types::runtime::maybe_grow_stack(|| {
494 <DeclareStatement as ::treesitter_types::FromNode>::from_node(node, src)
495 })?,
496 ))),
497 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
498 ::treesitter_types::runtime::maybe_grow_stack(|| {
499 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
500 })?,
501 ))),
502 "echo_statement" => Ok(Self::EchoStatement(::std::boxed::Box::new(
503 ::treesitter_types::runtime::maybe_grow_stack(|| {
504 <EchoStatement as ::treesitter_types::FromNode>::from_node(node, src)
505 })?,
506 ))),
507 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
508 ::treesitter_types::runtime::maybe_grow_stack(|| {
509 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
510 })?,
511 ))),
512 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
513 ::treesitter_types::runtime::maybe_grow_stack(|| {
514 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
515 })?,
516 ))),
517 "exit_statement" => Ok(Self::ExitStatement(::std::boxed::Box::new(
518 ::treesitter_types::runtime::maybe_grow_stack(|| {
519 <ExitStatement as ::treesitter_types::FromNode>::from_node(node, src)
520 })?,
521 ))),
522 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
523 ::treesitter_types::runtime::maybe_grow_stack(|| {
524 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
525 })?,
526 ))),
527 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
528 ::treesitter_types::runtime::maybe_grow_stack(|| {
529 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
530 })?,
531 ))),
532 "foreach_statement" => Ok(Self::ForeachStatement(::std::boxed::Box::new(
533 ::treesitter_types::runtime::maybe_grow_stack(|| {
534 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
535 })?,
536 ))),
537 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
538 ::treesitter_types::runtime::maybe_grow_stack(|| {
539 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
540 })?,
541 ))),
542 "function_static_declaration" => Ok(Self::FunctionStaticDeclaration(
543 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
544 <FunctionStaticDeclaration as ::treesitter_types::FromNode>::from_node(
545 node, src,
546 )
547 })?),
548 )),
549 "global_declaration" => Ok(Self::GlobalDeclaration(::std::boxed::Box::new(
550 ::treesitter_types::runtime::maybe_grow_stack(|| {
551 <GlobalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
552 })?,
553 ))),
554 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
555 ::treesitter_types::runtime::maybe_grow_stack(|| {
556 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
557 })?,
558 ))),
559 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
560 ::treesitter_types::runtime::maybe_grow_stack(|| {
561 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
562 })?,
563 ))),
564 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
565 ::treesitter_types::runtime::maybe_grow_stack(|| {
566 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
567 })?,
568 ))),
569 "named_label_statement" => Ok(Self::NamedLabelStatement(::std::boxed::Box::new(
570 ::treesitter_types::runtime::maybe_grow_stack(|| {
571 <NamedLabelStatement as ::treesitter_types::FromNode>::from_node(node, src)
572 })?,
573 ))),
574 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
575 ::treesitter_types::runtime::maybe_grow_stack(|| {
576 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
577 })?,
578 ))),
579 "namespace_use_declaration" => Ok(Self::NamespaceUseDeclaration(
580 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
581 <NamespaceUseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
582 })?),
583 )),
584 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
585 ::treesitter_types::runtime::maybe_grow_stack(|| {
586 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
587 })?,
588 ))),
589 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
590 ::treesitter_types::runtime::maybe_grow_stack(|| {
591 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
592 })?,
593 ))),
594 "trait_declaration" => Ok(Self::TraitDeclaration(::std::boxed::Box::new(
595 ::treesitter_types::runtime::maybe_grow_stack(|| {
596 <TraitDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
597 })?,
598 ))),
599 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
600 ::treesitter_types::runtime::maybe_grow_stack(|| {
601 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
602 })?,
603 ))),
604 "unset_statement" => Ok(Self::UnsetStatement(::std::boxed::Box::new(
605 ::treesitter_types::runtime::maybe_grow_stack(|| {
606 <UnsetStatement as ::treesitter_types::FromNode>::from_node(node, src)
607 })?,
608 ))),
609 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
610 ::treesitter_types::runtime::maybe_grow_stack(|| {
611 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
612 })?,
613 ))),
614 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
615 }
616 }
617}
618impl ::treesitter_types::Spanned for Statement<'_> {
619 fn span(&self) -> ::treesitter_types::Span {
620 match self {
621 Self::BreakStatement(inner) => inner.span(),
622 Self::ClassDeclaration(inner) => inner.span(),
623 Self::CompoundStatement(inner) => inner.span(),
624 Self::ConstDeclaration(inner) => inner.span(),
625 Self::ContinueStatement(inner) => inner.span(),
626 Self::DeclareStatement(inner) => inner.span(),
627 Self::DoStatement(inner) => inner.span(),
628 Self::EchoStatement(inner) => inner.span(),
629 Self::EmptyStatement(inner) => inner.span(),
630 Self::EnumDeclaration(inner) => inner.span(),
631 Self::ExitStatement(inner) => inner.span(),
632 Self::ExpressionStatement(inner) => inner.span(),
633 Self::ForStatement(inner) => inner.span(),
634 Self::ForeachStatement(inner) => inner.span(),
635 Self::FunctionDefinition(inner) => inner.span(),
636 Self::FunctionStaticDeclaration(inner) => inner.span(),
637 Self::GlobalDeclaration(inner) => inner.span(),
638 Self::GotoStatement(inner) => inner.span(),
639 Self::IfStatement(inner) => inner.span(),
640 Self::InterfaceDeclaration(inner) => inner.span(),
641 Self::NamedLabelStatement(inner) => inner.span(),
642 Self::NamespaceDefinition(inner) => inner.span(),
643 Self::NamespaceUseDeclaration(inner) => inner.span(),
644 Self::ReturnStatement(inner) => inner.span(),
645 Self::SwitchStatement(inner) => inner.span(),
646 Self::TraitDeclaration(inner) => inner.span(),
647 Self::TryStatement(inner) => inner.span(),
648 Self::UnsetStatement(inner) => inner.span(),
649 Self::WhileStatement(inner) => inner.span(),
650 }
651 }
652}
653#[derive(Debug, Clone, PartialEq, Eq)]
654pub enum Type<'tree> {
655 DisjunctiveNormalFormType(::std::boxed::Box<DisjunctiveNormalFormType<'tree>>),
656 IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
657 NamedType(::std::boxed::Box<NamedType<'tree>>),
658 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
659 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
660 UnionType(::std::boxed::Box<UnionType<'tree>>),
661}
662impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
663 #[allow(clippy::collapsible_else_if)]
664 fn from_node(
665 node: ::treesitter_types::tree_sitter::Node<'tree>,
666 src: &'tree [u8],
667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
668 match node.kind() {
669 "disjunctive_normal_form_type" => Ok(Self::DisjunctiveNormalFormType(
670 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
671 <DisjunctiveNormalFormType as ::treesitter_types::FromNode>::from_node(
672 node, src,
673 )
674 })?),
675 )),
676 "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
677 ::treesitter_types::runtime::maybe_grow_stack(|| {
678 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
679 })?,
680 ))),
681 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
682 ::treesitter_types::runtime::maybe_grow_stack(|| {
683 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
684 })?,
685 ))),
686 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
687 ::treesitter_types::runtime::maybe_grow_stack(|| {
688 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
689 })?,
690 ))),
691 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
692 ::treesitter_types::runtime::maybe_grow_stack(|| {
693 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
694 })?,
695 ))),
696 "union_type" => Ok(Self::UnionType(::std::boxed::Box::new(
697 ::treesitter_types::runtime::maybe_grow_stack(|| {
698 <UnionType as ::treesitter_types::FromNode>::from_node(node, src)
699 })?,
700 ))),
701 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
702 }
703 }
704}
705impl ::treesitter_types::Spanned for Type<'_> {
706 fn span(&self) -> ::treesitter_types::Span {
707 match self {
708 Self::DisjunctiveNormalFormType(inner) => inner.span(),
709 Self::IntersectionType(inner) => inner.span(),
710 Self::NamedType(inner) => inner.span(),
711 Self::OptionalType(inner) => inner.span(),
712 Self::PrimitiveType(inner) => inner.span(),
713 Self::UnionType(inner) => inner.span(),
714 }
715 }
716}
717#[derive(Debug, Clone, PartialEq, Eq)]
718pub struct AbstractModifier<'tree> {
719 pub span: ::treesitter_types::Span,
720 text: &'tree str,
721}
722impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractModifier<'tree> {
723 fn from_node(
724 node: ::treesitter_types::tree_sitter::Node<'tree>,
725 src: &'tree [u8],
726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
727 debug_assert_eq!(node.kind(), "abstract_modifier");
728 Ok(Self {
729 span: ::treesitter_types::Span::from(node),
730 text: node.utf8_text(src)?,
731 })
732 }
733}
734impl<'tree> ::treesitter_types::LeafNode<'tree> for AbstractModifier<'tree> {
735 fn text(&self) -> &'tree str {
736 self.text
737 }
738}
739impl ::treesitter_types::Spanned for AbstractModifier<'_> {
740 fn span(&self) -> ::treesitter_types::Span {
741 self.span
742 }
743}
744#[derive(Debug, Clone, PartialEq, Eq)]
745pub struct AnonymousClass<'tree> {
746 pub span: ::treesitter_types::Span,
747 pub attributes: ::core::option::Option<AttributeList<'tree>>,
748 pub body: DeclarationList<'tree>,
749 pub children: ::std::vec::Vec<AnonymousClassChildren<'tree>>,
750}
751impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousClass<'tree> {
752 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
753 fn from_node(
754 node: ::treesitter_types::tree_sitter::Node<'tree>,
755 src: &'tree [u8],
756 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
757 debug_assert_eq!(node.kind(), "anonymous_class");
758 Ok(Self {
759 span: ::treesitter_types::Span::from(node),
760 attributes: match node.child_by_field_name("attributes") {
761 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
762 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
763 })?),
764 None => None,
765 },
766 body: {
767 let child = node
768 .child_by_field_name("body")
769 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
770 ::treesitter_types::runtime::maybe_grow_stack(|| {
771 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
772 })?
773 },
774 children: {
775 #[allow(clippy::suspicious_else_formatting)]
776 let non_field_children = {
777 let mut cursor = node.walk();
778 let mut result = ::std::vec::Vec::new();
779 if cursor.goto_first_child() {
780 loop {
781 if cursor.field_name().is_none()
782 && cursor.node().is_named()
783 && !cursor.node().is_extra()
784 {
785 result.push(cursor.node());
786 }
787 if !cursor.goto_next_sibling() {
788 break;
789 }
790 }
791 }
792 result
793 };
794 let mut items = ::std::vec::Vec::new();
795 for child in non_field_children {
796 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
797 <AnonymousClassChildren as ::treesitter_types::FromNode>::from_node(
798 child, src,
799 )
800 })?);
801 }
802 items
803 },
804 })
805 }
806}
807impl ::treesitter_types::Spanned for AnonymousClass<'_> {
808 fn span(&self) -> ::treesitter_types::Span {
809 self.span
810 }
811}
812#[derive(Debug, Clone, PartialEq, Eq)]
813pub struct AnonymousFunction<'tree> {
814 pub span: ::treesitter_types::Span,
815 pub attributes: ::core::option::Option<AttributeList<'tree>>,
816 pub body: CompoundStatement<'tree>,
817 pub parameters: FormalParameters<'tree>,
818 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
819 pub return_type: ::core::option::Option<AnonymousFunctionReturnType<'tree>>,
820 pub static_modifier: ::core::option::Option<StaticModifier<'tree>>,
821 pub children: ::core::option::Option<AnonymousFunctionUseClause<'tree>>,
822}
823impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunction<'tree> {
824 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
825 fn from_node(
826 node: ::treesitter_types::tree_sitter::Node<'tree>,
827 src: &'tree [u8],
828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
829 debug_assert_eq!(node.kind(), "anonymous_function");
830 Ok(Self {
831 span: ::treesitter_types::Span::from(node),
832 attributes: match node.child_by_field_name("attributes") {
833 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
834 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
835 })?),
836 None => None,
837 },
838 body: {
839 let child = node
840 .child_by_field_name("body")
841 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
842 ::treesitter_types::runtime::maybe_grow_stack(|| {
843 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
844 })?
845 },
846 parameters: {
847 let child = node.child_by_field_name("parameters").ok_or_else(|| {
848 ::treesitter_types::ParseError::missing_field("parameters", node)
849 })?;
850 ::treesitter_types::runtime::maybe_grow_stack(|| {
851 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
852 })?
853 },
854 reference_modifier: match node.child_by_field_name("reference_modifier") {
855 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
856 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
857 })?),
858 None => None,
859 },
860 return_type: match node.child_by_field_name("return_type") {
861 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
862 <AnonymousFunctionReturnType as ::treesitter_types::FromNode>::from_node(
863 child, src,
864 )
865 })?),
866 None => None,
867 },
868 static_modifier: match node.child_by_field_name("static_modifier") {
869 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
870 <StaticModifier as ::treesitter_types::FromNode>::from_node(child, src)
871 })?),
872 None => None,
873 },
874 children: {
875 #[allow(clippy::suspicious_else_formatting)]
876 let non_field_children = {
877 let mut cursor = node.walk();
878 let mut result = ::std::vec::Vec::new();
879 if cursor.goto_first_child() {
880 loop {
881 if cursor.field_name().is_none()
882 && cursor.node().is_named()
883 && !cursor.node().is_extra()
884 {
885 result.push(cursor.node());
886 }
887 if !cursor.goto_next_sibling() {
888 break;
889 }
890 }
891 }
892 result
893 };
894 match non_field_children.first() {
895 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
896 <AnonymousFunctionUseClause as ::treesitter_types::FromNode>::from_node(
897 child, src,
898 )
899 })?),
900 None => None,
901 }
902 },
903 })
904 }
905}
906impl ::treesitter_types::Spanned for AnonymousFunction<'_> {
907 fn span(&self) -> ::treesitter_types::Span {
908 self.span
909 }
910}
911#[derive(Debug, Clone, PartialEq, Eq)]
912pub struct AnonymousFunctionUseClause<'tree> {
913 pub span: ::treesitter_types::Span,
914 pub children: ::std::vec::Vec<AnonymousFunctionUseClauseChildren<'tree>>,
915}
916impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionUseClause<'tree> {
917 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
918 fn from_node(
919 node: ::treesitter_types::tree_sitter::Node<'tree>,
920 src: &'tree [u8],
921 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
922 debug_assert_eq!(node.kind(), "anonymous_function_use_clause");
923 Ok(Self {
924 span: ::treesitter_types::Span::from(node),
925 children: {
926 #[allow(clippy::suspicious_else_formatting)]
927 let non_field_children = {
928 let mut cursor = node.walk();
929 let mut result = ::std::vec::Vec::new();
930 if cursor.goto_first_child() {
931 loop {
932 if cursor.field_name().is_none()
933 && cursor.node().is_named()
934 && !cursor.node().is_extra()
935 {
936 result.push(cursor.node());
937 }
938 if !cursor.goto_next_sibling() {
939 break;
940 }
941 }
942 }
943 result
944 };
945 let mut items = ::std::vec::Vec::new();
946 for child in non_field_children {
947 items
948 .push(
949 ::treesitter_types::runtime::maybe_grow_stack(|| <AnonymousFunctionUseClauseChildren as ::treesitter_types::FromNode>::from_node(
950 child,
951 src,
952 ))?,
953 );
954 }
955 items
956 },
957 })
958 }
959}
960impl ::treesitter_types::Spanned for AnonymousFunctionUseClause<'_> {
961 fn span(&self) -> ::treesitter_types::Span {
962 self.span
963 }
964}
965#[derive(Debug, Clone, PartialEq, Eq)]
966pub struct Argument<'tree> {
967 pub span: ::treesitter_types::Span,
968 pub name: ::core::option::Option<Name<'tree>>,
969 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
970 pub children: ArgumentChildren<'tree>,
971}
972impl<'tree> ::treesitter_types::FromNode<'tree> for Argument<'tree> {
973 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
974 fn from_node(
975 node: ::treesitter_types::tree_sitter::Node<'tree>,
976 src: &'tree [u8],
977 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
978 debug_assert_eq!(node.kind(), "argument");
979 Ok(Self {
980 span: ::treesitter_types::Span::from(node),
981 name: match node.child_by_field_name("name") {
982 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
983 <Name as ::treesitter_types::FromNode>::from_node(child, src)
984 })?),
985 None => None,
986 },
987 reference_modifier: match node.child_by_field_name("reference_modifier") {
988 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
989 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
990 })?),
991 None => None,
992 },
993 children: {
994 #[allow(clippy::suspicious_else_formatting)]
995 let non_field_children = {
996 let mut cursor = node.walk();
997 let mut result = ::std::vec::Vec::new();
998 if cursor.goto_first_child() {
999 loop {
1000 if cursor.field_name().is_none()
1001 && cursor.node().is_named()
1002 && !cursor.node().is_extra()
1003 {
1004 result.push(cursor.node());
1005 }
1006 if !cursor.goto_next_sibling() {
1007 break;
1008 }
1009 }
1010 }
1011 result
1012 };
1013 let child = if let Some(&c) = non_field_children.first() {
1014 c
1015 } else {
1016 let mut fallback_cursor = node.walk();
1017 let mut fallback_child = None;
1018 if fallback_cursor.goto_first_child() {
1019 loop {
1020 if fallback_cursor.field_name().is_none()
1021 && !fallback_cursor.node().is_extra()
1022 {
1023 let candidate = fallback_cursor.node();
1024 #[allow(clippy::needless_question_mark)]
1025 if (|| -> ::core::result::Result<
1026 _,
1027 ::treesitter_types::ParseError,
1028 > {
1029 let child = candidate;
1030 Ok(
1031 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1032 child,
1033 src,
1034 ))?,
1035 )
1036 })()
1037 .is_ok()
1038 {
1039 fallback_child = Some(candidate);
1040 break;
1041 }
1042 }
1043 if !fallback_cursor.goto_next_sibling() {
1044 break;
1045 }
1046 }
1047 }
1048 if fallback_child.is_none() {
1049 let mut cursor2 = node.walk();
1050 if cursor2.goto_first_child() {
1051 loop {
1052 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1053 let candidate = cursor2.node();
1054 #[allow(clippy::needless_question_mark)]
1055 if (|| -> ::core::result::Result<
1056 _,
1057 ::treesitter_types::ParseError,
1058 > {
1059 let child = candidate;
1060 Ok(
1061 ::treesitter_types::runtime::maybe_grow_stack(|| <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
1062 child,
1063 src,
1064 ))?,
1065 )
1066 })()
1067 .is_ok()
1068 {
1069 fallback_child = Some(candidate);
1070 break;
1071 }
1072 }
1073 if !cursor2.goto_next_sibling() {
1074 break;
1075 }
1076 }
1077 }
1078 }
1079 fallback_child.ok_or_else(|| {
1080 ::treesitter_types::ParseError::missing_field("children", node)
1081 })?
1082 };
1083 ::treesitter_types::runtime::maybe_grow_stack(|| {
1084 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(child, src)
1085 })?
1086 },
1087 })
1088 }
1089}
1090impl ::treesitter_types::Spanned for Argument<'_> {
1091 fn span(&self) -> ::treesitter_types::Span {
1092 self.span
1093 }
1094}
1095#[derive(Debug, Clone, PartialEq, Eq)]
1096pub struct Arguments<'tree> {
1097 pub span: ::treesitter_types::Span,
1098 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
1099}
1100impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
1101 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1102 fn from_node(
1103 node: ::treesitter_types::tree_sitter::Node<'tree>,
1104 src: &'tree [u8],
1105 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1106 debug_assert_eq!(node.kind(), "arguments");
1107 Ok(Self {
1108 span: ::treesitter_types::Span::from(node),
1109 children: {
1110 #[allow(clippy::suspicious_else_formatting)]
1111 let non_field_children = {
1112 let mut cursor = node.walk();
1113 let mut result = ::std::vec::Vec::new();
1114 if cursor.goto_first_child() {
1115 loop {
1116 if cursor.field_name().is_none()
1117 && cursor.node().is_named()
1118 && !cursor.node().is_extra()
1119 {
1120 result.push(cursor.node());
1121 }
1122 if !cursor.goto_next_sibling() {
1123 break;
1124 }
1125 }
1126 }
1127 result
1128 };
1129 let mut items = ::std::vec::Vec::new();
1130 for child in non_field_children {
1131 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1132 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)
1133 })?);
1134 }
1135 items
1136 },
1137 })
1138 }
1139}
1140impl ::treesitter_types::Spanned for Arguments<'_> {
1141 fn span(&self) -> ::treesitter_types::Span {
1142 self.span
1143 }
1144}
1145#[derive(Debug, Clone, PartialEq, Eq)]
1146pub struct ArrayCreationExpression<'tree> {
1147 pub span: ::treesitter_types::Span,
1148 pub children: ::std::vec::Vec<ArrayElementInitializer<'tree>>,
1149}
1150impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1151 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1152 fn from_node(
1153 node: ::treesitter_types::tree_sitter::Node<'tree>,
1154 src: &'tree [u8],
1155 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1156 debug_assert_eq!(node.kind(), "array_creation_expression");
1157 Ok(Self {
1158 span: ::treesitter_types::Span::from(node),
1159 children: {
1160 #[allow(clippy::suspicious_else_formatting)]
1161 let non_field_children = {
1162 let mut cursor = node.walk();
1163 let mut result = ::std::vec::Vec::new();
1164 if cursor.goto_first_child() {
1165 loop {
1166 if cursor.field_name().is_none()
1167 && cursor.node().is_named()
1168 && !cursor.node().is_extra()
1169 {
1170 result.push(cursor.node());
1171 }
1172 if !cursor.goto_next_sibling() {
1173 break;
1174 }
1175 }
1176 }
1177 result
1178 };
1179 let mut items = ::std::vec::Vec::new();
1180 for child in non_field_children {
1181 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1182 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(
1183 child, src,
1184 )
1185 })?);
1186 }
1187 items
1188 },
1189 })
1190 }
1191}
1192impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1193 fn span(&self) -> ::treesitter_types::Span {
1194 self.span
1195 }
1196}
1197#[derive(Debug, Clone, PartialEq, Eq)]
1198pub struct ArrayElementInitializer<'tree> {
1199 pub span: ::treesitter_types::Span,
1200 pub children: ::std::vec::Vec<ArrayElementInitializerChildren<'tree>>,
1201}
1202impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayElementInitializer<'tree> {
1203 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1204 fn from_node(
1205 node: ::treesitter_types::tree_sitter::Node<'tree>,
1206 src: &'tree [u8],
1207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1208 debug_assert_eq!(node.kind(), "array_element_initializer");
1209 Ok(Self {
1210 span: ::treesitter_types::Span::from(node),
1211 children: {
1212 #[allow(clippy::suspicious_else_formatting)]
1213 let non_field_children = {
1214 let mut cursor = node.walk();
1215 let mut result = ::std::vec::Vec::new();
1216 if cursor.goto_first_child() {
1217 loop {
1218 if cursor.field_name().is_none()
1219 && cursor.node().is_named()
1220 && !cursor.node().is_extra()
1221 {
1222 result.push(cursor.node());
1223 }
1224 if !cursor.goto_next_sibling() {
1225 break;
1226 }
1227 }
1228 }
1229 result
1230 };
1231 let mut items = ::std::vec::Vec::new();
1232 for child in non_field_children {
1233 items
1234 .push(
1235 ::treesitter_types::runtime::maybe_grow_stack(|| <ArrayElementInitializerChildren as ::treesitter_types::FromNode>::from_node(
1236 child,
1237 src,
1238 ))?,
1239 );
1240 }
1241 items
1242 },
1243 })
1244 }
1245}
1246impl ::treesitter_types::Spanned for ArrayElementInitializer<'_> {
1247 fn span(&self) -> ::treesitter_types::Span {
1248 self.span
1249 }
1250}
1251#[derive(Debug, Clone, PartialEq, Eq)]
1252pub struct ArrowFunction<'tree> {
1253 pub span: ::treesitter_types::Span,
1254 pub attributes: ::core::option::Option<AttributeList<'tree>>,
1255 pub body: Expression<'tree>,
1256 pub parameters: FormalParameters<'tree>,
1257 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
1258 pub return_type: ::core::option::Option<ArrowFunctionReturnType<'tree>>,
1259 pub static_modifier: ::core::option::Option<StaticModifier<'tree>>,
1260}
1261impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
1262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1263 fn from_node(
1264 node: ::treesitter_types::tree_sitter::Node<'tree>,
1265 src: &'tree [u8],
1266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1267 debug_assert_eq!(node.kind(), "arrow_function");
1268 Ok(Self {
1269 span: ::treesitter_types::Span::from(node),
1270 attributes: match node.child_by_field_name("attributes") {
1271 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1272 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
1273 })?),
1274 None => None,
1275 },
1276 body: {
1277 let child = node
1278 .child_by_field_name("body")
1279 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1280 ::treesitter_types::runtime::maybe_grow_stack(|| {
1281 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1282 })?
1283 },
1284 parameters: {
1285 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1286 ::treesitter_types::ParseError::missing_field("parameters", node)
1287 })?;
1288 ::treesitter_types::runtime::maybe_grow_stack(|| {
1289 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
1290 })?
1291 },
1292 reference_modifier: match node.child_by_field_name("reference_modifier") {
1293 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1294 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
1295 })?),
1296 None => None,
1297 },
1298 return_type: match node.child_by_field_name("return_type") {
1299 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1300 <ArrowFunctionReturnType as ::treesitter_types::FromNode>::from_node(child, src)
1301 })?),
1302 None => None,
1303 },
1304 static_modifier: match node.child_by_field_name("static_modifier") {
1305 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1306 <StaticModifier as ::treesitter_types::FromNode>::from_node(child, src)
1307 })?),
1308 None => None,
1309 },
1310 })
1311 }
1312}
1313impl ::treesitter_types::Spanned for ArrowFunction<'_> {
1314 fn span(&self) -> ::treesitter_types::Span {
1315 self.span
1316 }
1317}
1318#[derive(Debug, Clone, PartialEq, Eq)]
1319pub struct AssignmentExpression<'tree> {
1320 pub span: ::treesitter_types::Span,
1321 pub left: AssignmentExpressionLeft<'tree>,
1322 pub right: Expression<'tree>,
1323}
1324impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1325 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1326 fn from_node(
1327 node: ::treesitter_types::tree_sitter::Node<'tree>,
1328 src: &'tree [u8],
1329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1330 debug_assert_eq!(node.kind(), "assignment_expression");
1331 Ok(Self {
1332 span: ::treesitter_types::Span::from(node),
1333 left: {
1334 let child = node
1335 .child_by_field_name("left")
1336 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1337 ::treesitter_types::runtime::maybe_grow_stack(|| {
1338 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1339 child, src,
1340 )
1341 })?
1342 },
1343 right: {
1344 let child = node
1345 .child_by_field_name("right")
1346 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1347 ::treesitter_types::runtime::maybe_grow_stack(|| {
1348 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1349 })?
1350 },
1351 })
1352 }
1353}
1354impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1355 fn span(&self) -> ::treesitter_types::Span {
1356 self.span
1357 }
1358}
1359#[derive(Debug, Clone, PartialEq, Eq)]
1360pub struct Attribute<'tree> {
1361 pub span: ::treesitter_types::Span,
1362 pub parameters: ::core::option::Option<Arguments<'tree>>,
1363 pub children: AttributeChildren<'tree>,
1364}
1365impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1366 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1367 fn from_node(
1368 node: ::treesitter_types::tree_sitter::Node<'tree>,
1369 src: &'tree [u8],
1370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1371 debug_assert_eq!(node.kind(), "attribute");
1372 Ok(Self {
1373 span: ::treesitter_types::Span::from(node),
1374 parameters: match node.child_by_field_name("parameters") {
1375 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1376 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
1377 })?),
1378 None => None,
1379 },
1380 children: {
1381 #[allow(clippy::suspicious_else_formatting)]
1382 let non_field_children = {
1383 let mut cursor = node.walk();
1384 let mut result = ::std::vec::Vec::new();
1385 if cursor.goto_first_child() {
1386 loop {
1387 if cursor.field_name().is_none()
1388 && cursor.node().is_named()
1389 && !cursor.node().is_extra()
1390 {
1391 result.push(cursor.node());
1392 }
1393 if !cursor.goto_next_sibling() {
1394 break;
1395 }
1396 }
1397 }
1398 result
1399 };
1400 let child = if let Some(&c) = non_field_children.first() {
1401 c
1402 } else {
1403 let mut fallback_cursor = node.walk();
1404 let mut fallback_child = None;
1405 if fallback_cursor.goto_first_child() {
1406 loop {
1407 if fallback_cursor.field_name().is_none()
1408 && !fallback_cursor.node().is_extra()
1409 {
1410 let candidate = fallback_cursor.node();
1411 #[allow(clippy::needless_question_mark)]
1412 if (|| -> ::core::result::Result<
1413 _,
1414 ::treesitter_types::ParseError,
1415 > {
1416 let child = candidate;
1417 Ok(
1418 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1419 child,
1420 src,
1421 ))?,
1422 )
1423 })()
1424 .is_ok()
1425 {
1426 fallback_child = Some(candidate);
1427 break;
1428 }
1429 }
1430 if !fallback_cursor.goto_next_sibling() {
1431 break;
1432 }
1433 }
1434 }
1435 if fallback_child.is_none() {
1436 let mut cursor2 = node.walk();
1437 if cursor2.goto_first_child() {
1438 loop {
1439 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1440 let candidate = cursor2.node();
1441 #[allow(clippy::needless_question_mark)]
1442 if (|| -> ::core::result::Result<
1443 _,
1444 ::treesitter_types::ParseError,
1445 > {
1446 let child = candidate;
1447 Ok(
1448 ::treesitter_types::runtime::maybe_grow_stack(|| <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1449 child,
1450 src,
1451 ))?,
1452 )
1453 })()
1454 .is_ok()
1455 {
1456 fallback_child = Some(candidate);
1457 break;
1458 }
1459 }
1460 if !cursor2.goto_next_sibling() {
1461 break;
1462 }
1463 }
1464 }
1465 }
1466 fallback_child.ok_or_else(|| {
1467 ::treesitter_types::ParseError::missing_field("children", node)
1468 })?
1469 };
1470 ::treesitter_types::runtime::maybe_grow_stack(|| {
1471 <AttributeChildren as ::treesitter_types::FromNode>::from_node(child, src)
1472 })?
1473 },
1474 })
1475 }
1476}
1477impl ::treesitter_types::Spanned for Attribute<'_> {
1478 fn span(&self) -> ::treesitter_types::Span {
1479 self.span
1480 }
1481}
1482#[derive(Debug, Clone, PartialEq, Eq)]
1483pub struct AttributeGroup<'tree> {
1484 pub span: ::treesitter_types::Span,
1485 pub children: ::std::vec::Vec<Attribute<'tree>>,
1486}
1487impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeGroup<'tree> {
1488 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1489 fn from_node(
1490 node: ::treesitter_types::tree_sitter::Node<'tree>,
1491 src: &'tree [u8],
1492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1493 debug_assert_eq!(node.kind(), "attribute_group");
1494 Ok(Self {
1495 span: ::treesitter_types::Span::from(node),
1496 children: {
1497 #[allow(clippy::suspicious_else_formatting)]
1498 let non_field_children = {
1499 let mut cursor = node.walk();
1500 let mut result = ::std::vec::Vec::new();
1501 if cursor.goto_first_child() {
1502 loop {
1503 if cursor.field_name().is_none()
1504 && cursor.node().is_named()
1505 && !cursor.node().is_extra()
1506 {
1507 result.push(cursor.node());
1508 }
1509 if !cursor.goto_next_sibling() {
1510 break;
1511 }
1512 }
1513 }
1514 result
1515 };
1516 let mut items = ::std::vec::Vec::new();
1517 for child in non_field_children {
1518 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1519 <Attribute as ::treesitter_types::FromNode>::from_node(child, src)
1520 })?);
1521 }
1522 items
1523 },
1524 })
1525 }
1526}
1527impl ::treesitter_types::Spanned for AttributeGroup<'_> {
1528 fn span(&self) -> ::treesitter_types::Span {
1529 self.span
1530 }
1531}
1532#[derive(Debug, Clone, PartialEq, Eq)]
1533pub struct AttributeList<'tree> {
1534 pub span: ::treesitter_types::Span,
1535 pub children: ::std::vec::Vec<AttributeGroup<'tree>>,
1536}
1537impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeList<'tree> {
1538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1539 fn from_node(
1540 node: ::treesitter_types::tree_sitter::Node<'tree>,
1541 src: &'tree [u8],
1542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1543 debug_assert_eq!(node.kind(), "attribute_list");
1544 Ok(Self {
1545 span: ::treesitter_types::Span::from(node),
1546 children: {
1547 #[allow(clippy::suspicious_else_formatting)]
1548 let non_field_children = {
1549 let mut cursor = node.walk();
1550 let mut result = ::std::vec::Vec::new();
1551 if cursor.goto_first_child() {
1552 loop {
1553 if cursor.field_name().is_none()
1554 && cursor.node().is_named()
1555 && !cursor.node().is_extra()
1556 {
1557 result.push(cursor.node());
1558 }
1559 if !cursor.goto_next_sibling() {
1560 break;
1561 }
1562 }
1563 }
1564 result
1565 };
1566 let mut items = ::std::vec::Vec::new();
1567 for child in non_field_children {
1568 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1569 <AttributeGroup as ::treesitter_types::FromNode>::from_node(child, src)
1570 })?);
1571 }
1572 items
1573 },
1574 })
1575 }
1576}
1577impl ::treesitter_types::Spanned for AttributeList<'_> {
1578 fn span(&self) -> ::treesitter_types::Span {
1579 self.span
1580 }
1581}
1582#[derive(Debug, Clone, PartialEq, Eq)]
1583pub struct AugmentedAssignmentExpression<'tree> {
1584 pub span: ::treesitter_types::Span,
1585 pub left: AugmentedAssignmentExpressionLeft<'tree>,
1586 pub operator: AugmentedAssignmentExpressionOperator,
1587 pub right: Expression<'tree>,
1588}
1589impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
1590 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1591 fn from_node(
1592 node: ::treesitter_types::tree_sitter::Node<'tree>,
1593 src: &'tree [u8],
1594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1595 debug_assert_eq!(node.kind(), "augmented_assignment_expression");
1596 Ok(Self {
1597 span: ::treesitter_types::Span::from(node),
1598 left: {
1599 let child = node
1600 .child_by_field_name("left")
1601 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1602 ::treesitter_types::runtime::maybe_grow_stack(|| {
1603 <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1604 child, src,
1605 )
1606 })?
1607 },
1608 operator: {
1609 let child = node.child_by_field_name("operator").ok_or_else(|| {
1610 ::treesitter_types::ParseError::missing_field("operator", node)
1611 })?;
1612 ::treesitter_types::runtime::maybe_grow_stack(|| {
1613 <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1614 child,
1615 src,
1616 )
1617 })?
1618 },
1619 right: {
1620 let child = node
1621 .child_by_field_name("right")
1622 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1623 ::treesitter_types::runtime::maybe_grow_stack(|| {
1624 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1625 })?
1626 },
1627 })
1628 }
1629}
1630impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
1631 fn span(&self) -> ::treesitter_types::Span {
1632 self.span
1633 }
1634}
1635#[derive(Debug, Clone, PartialEq, Eq)]
1636pub struct BaseClause<'tree> {
1637 pub span: ::treesitter_types::Span,
1638 pub children: ::std::vec::Vec<BaseClauseChildren<'tree>>,
1639}
1640impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClause<'tree> {
1641 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1642 fn from_node(
1643 node: ::treesitter_types::tree_sitter::Node<'tree>,
1644 src: &'tree [u8],
1645 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1646 debug_assert_eq!(node.kind(), "base_clause");
1647 Ok(Self {
1648 span: ::treesitter_types::Span::from(node),
1649 children: {
1650 #[allow(clippy::suspicious_else_formatting)]
1651 let non_field_children = {
1652 let mut cursor = node.walk();
1653 let mut result = ::std::vec::Vec::new();
1654 if cursor.goto_first_child() {
1655 loop {
1656 if cursor.field_name().is_none()
1657 && cursor.node().is_named()
1658 && !cursor.node().is_extra()
1659 {
1660 result.push(cursor.node());
1661 }
1662 if !cursor.goto_next_sibling() {
1663 break;
1664 }
1665 }
1666 }
1667 result
1668 };
1669 let mut items = ::std::vec::Vec::new();
1670 for child in non_field_children {
1671 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1672 <BaseClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
1673 })?);
1674 }
1675 items
1676 },
1677 })
1678 }
1679}
1680impl ::treesitter_types::Spanned for BaseClause<'_> {
1681 fn span(&self) -> ::treesitter_types::Span {
1682 self.span
1683 }
1684}
1685#[derive(Debug, Clone, PartialEq, Eq)]
1686pub struct BinaryExpression<'tree> {
1687 pub span: ::treesitter_types::Span,
1688 pub left: Expression<'tree>,
1689 pub operator: BinaryExpressionOperator,
1690 pub right: BinaryExpressionRight<'tree>,
1691}
1692impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1693 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1694 fn from_node(
1695 node: ::treesitter_types::tree_sitter::Node<'tree>,
1696 src: &'tree [u8],
1697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1698 debug_assert_eq!(node.kind(), "binary_expression");
1699 Ok(Self {
1700 span: ::treesitter_types::Span::from(node),
1701 left: {
1702 let child = node
1703 .child_by_field_name("left")
1704 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1705 ::treesitter_types::runtime::maybe_grow_stack(|| {
1706 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1707 })?
1708 },
1709 operator: {
1710 let child = node.child_by_field_name("operator").ok_or_else(|| {
1711 ::treesitter_types::ParseError::missing_field("operator", node)
1712 })?;
1713 ::treesitter_types::runtime::maybe_grow_stack(|| {
1714 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(
1715 child, src,
1716 )
1717 })?
1718 },
1719 right: {
1720 let child = node
1721 .child_by_field_name("right")
1722 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1723 ::treesitter_types::runtime::maybe_grow_stack(|| {
1724 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)
1725 })?
1726 },
1727 })
1728 }
1729}
1730impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1731 fn span(&self) -> ::treesitter_types::Span {
1732 self.span
1733 }
1734}
1735#[derive(Debug, Clone, PartialEq, Eq)]
1736pub struct Boolean<'tree> {
1737 pub span: ::treesitter_types::Span,
1738 text: &'tree str,
1739}
1740impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
1741 fn from_node(
1742 node: ::treesitter_types::tree_sitter::Node<'tree>,
1743 src: &'tree [u8],
1744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1745 debug_assert_eq!(node.kind(), "boolean");
1746 Ok(Self {
1747 span: ::treesitter_types::Span::from(node),
1748 text: node.utf8_text(src)?,
1749 })
1750 }
1751}
1752impl<'tree> ::treesitter_types::LeafNode<'tree> for Boolean<'tree> {
1753 fn text(&self) -> &'tree str {
1754 self.text
1755 }
1756}
1757impl ::treesitter_types::Spanned for Boolean<'_> {
1758 fn span(&self) -> ::treesitter_types::Span {
1759 self.span
1760 }
1761}
1762#[derive(Debug, Clone, PartialEq, Eq)]
1763pub struct BreakStatement<'tree> {
1764 pub span: ::treesitter_types::Span,
1765 pub children: ::core::option::Option<Expression<'tree>>,
1766}
1767impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1768 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1769 fn from_node(
1770 node: ::treesitter_types::tree_sitter::Node<'tree>,
1771 src: &'tree [u8],
1772 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1773 debug_assert_eq!(node.kind(), "break_statement");
1774 Ok(Self {
1775 span: ::treesitter_types::Span::from(node),
1776 children: {
1777 #[allow(clippy::suspicious_else_formatting)]
1778 let non_field_children = {
1779 let mut cursor = node.walk();
1780 let mut result = ::std::vec::Vec::new();
1781 if cursor.goto_first_child() {
1782 loop {
1783 if cursor.field_name().is_none()
1784 && cursor.node().is_named()
1785 && !cursor.node().is_extra()
1786 {
1787 result.push(cursor.node());
1788 }
1789 if !cursor.goto_next_sibling() {
1790 break;
1791 }
1792 }
1793 }
1794 result
1795 };
1796 match non_field_children.first() {
1797 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1798 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1799 })?),
1800 None => None,
1801 }
1802 },
1803 })
1804 }
1805}
1806impl ::treesitter_types::Spanned for BreakStatement<'_> {
1807 fn span(&self) -> ::treesitter_types::Span {
1808 self.span
1809 }
1810}
1811#[derive(Debug, Clone, PartialEq, Eq)]
1812pub struct ByRef<'tree> {
1813 pub span: ::treesitter_types::Span,
1814 pub children: ByRefChildren<'tree>,
1815}
1816impl<'tree> ::treesitter_types::FromNode<'tree> for ByRef<'tree> {
1817 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1818 fn from_node(
1819 node: ::treesitter_types::tree_sitter::Node<'tree>,
1820 src: &'tree [u8],
1821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1822 debug_assert_eq!(node.kind(), "by_ref");
1823 Ok(Self {
1824 span: ::treesitter_types::Span::from(node),
1825 children: {
1826 #[allow(clippy::suspicious_else_formatting)]
1827 let non_field_children = {
1828 let mut cursor = node.walk();
1829 let mut result = ::std::vec::Vec::new();
1830 if cursor.goto_first_child() {
1831 loop {
1832 if cursor.field_name().is_none()
1833 && cursor.node().is_named()
1834 && !cursor.node().is_extra()
1835 {
1836 result.push(cursor.node());
1837 }
1838 if !cursor.goto_next_sibling() {
1839 break;
1840 }
1841 }
1842 }
1843 result
1844 };
1845 let child = if let Some(&c) = non_field_children.first() {
1846 c
1847 } else {
1848 let mut fallback_cursor = node.walk();
1849 let mut fallback_child = None;
1850 if fallback_cursor.goto_first_child() {
1851 loop {
1852 if fallback_cursor.field_name().is_none()
1853 && !fallback_cursor.node().is_extra()
1854 {
1855 let candidate = fallback_cursor.node();
1856 #[allow(clippy::needless_question_mark)]
1857 if (|| -> ::core::result::Result<
1858 _,
1859 ::treesitter_types::ParseError,
1860 > {
1861 let child = candidate;
1862 Ok(
1863 ::treesitter_types::runtime::maybe_grow_stack(|| <ByRefChildren as ::treesitter_types::FromNode>::from_node(
1864 child,
1865 src,
1866 ))?,
1867 )
1868 })()
1869 .is_ok()
1870 {
1871 fallback_child = Some(candidate);
1872 break;
1873 }
1874 }
1875 if !fallback_cursor.goto_next_sibling() {
1876 break;
1877 }
1878 }
1879 }
1880 if fallback_child.is_none() {
1881 let mut cursor2 = node.walk();
1882 if cursor2.goto_first_child() {
1883 loop {
1884 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1885 let candidate = cursor2.node();
1886 #[allow(clippy::needless_question_mark)]
1887 if (|| -> ::core::result::Result<
1888 _,
1889 ::treesitter_types::ParseError,
1890 > {
1891 let child = candidate;
1892 Ok(
1893 ::treesitter_types::runtime::maybe_grow_stack(|| <ByRefChildren as ::treesitter_types::FromNode>::from_node(
1894 child,
1895 src,
1896 ))?,
1897 )
1898 })()
1899 .is_ok()
1900 {
1901 fallback_child = Some(candidate);
1902 break;
1903 }
1904 }
1905 if !cursor2.goto_next_sibling() {
1906 break;
1907 }
1908 }
1909 }
1910 }
1911 fallback_child.ok_or_else(|| {
1912 ::treesitter_types::ParseError::missing_field("children", node)
1913 })?
1914 };
1915 ::treesitter_types::runtime::maybe_grow_stack(|| {
1916 <ByRefChildren as ::treesitter_types::FromNode>::from_node(child, src)
1917 })?
1918 },
1919 })
1920 }
1921}
1922impl ::treesitter_types::Spanned for ByRef<'_> {
1923 fn span(&self) -> ::treesitter_types::Span {
1924 self.span
1925 }
1926}
1927#[derive(Debug, Clone, PartialEq, Eq)]
1928pub struct CaseStatement<'tree> {
1929 pub span: ::treesitter_types::Span,
1930 pub value: Expression<'tree>,
1931 pub children: ::std::vec::Vec<Statement<'tree>>,
1932}
1933impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatement<'tree> {
1934 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1935 fn from_node(
1936 node: ::treesitter_types::tree_sitter::Node<'tree>,
1937 src: &'tree [u8],
1938 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1939 debug_assert_eq!(node.kind(), "case_statement");
1940 Ok(Self {
1941 span: ::treesitter_types::Span::from(node),
1942 value: {
1943 let child = node
1944 .child_by_field_name("value")
1945 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1946 ::treesitter_types::runtime::maybe_grow_stack(|| {
1947 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
1948 })?
1949 },
1950 children: {
1951 #[allow(clippy::suspicious_else_formatting)]
1952 let non_field_children = {
1953 let mut cursor = node.walk();
1954 let mut result = ::std::vec::Vec::new();
1955 if cursor.goto_first_child() {
1956 loop {
1957 if cursor.field_name().is_none()
1958 && cursor.node().is_named()
1959 && !cursor.node().is_extra()
1960 {
1961 result.push(cursor.node());
1962 }
1963 if !cursor.goto_next_sibling() {
1964 break;
1965 }
1966 }
1967 }
1968 result
1969 };
1970 let mut items = ::std::vec::Vec::new();
1971 for child in non_field_children {
1972 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1973 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
1974 })?);
1975 }
1976 items
1977 },
1978 })
1979 }
1980}
1981impl ::treesitter_types::Spanned for CaseStatement<'_> {
1982 fn span(&self) -> ::treesitter_types::Span {
1983 self.span
1984 }
1985}
1986#[derive(Debug, Clone, PartialEq, Eq)]
1987pub struct CastExpression<'tree> {
1988 pub span: ::treesitter_types::Span,
1989 pub r#type: CastType<'tree>,
1990 pub value: CastExpressionValue<'tree>,
1991}
1992impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
1993 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1994 fn from_node(
1995 node: ::treesitter_types::tree_sitter::Node<'tree>,
1996 src: &'tree [u8],
1997 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1998 debug_assert_eq!(node.kind(), "cast_expression");
1999 Ok(Self {
2000 span: ::treesitter_types::Span::from(node),
2001 r#type: {
2002 let child = node
2003 .child_by_field_name("type")
2004 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2005 ::treesitter_types::runtime::maybe_grow_stack(|| {
2006 <CastType as ::treesitter_types::FromNode>::from_node(child, src)
2007 })?
2008 },
2009 value: {
2010 let child = node
2011 .child_by_field_name("value")
2012 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2013 ::treesitter_types::runtime::maybe_grow_stack(|| {
2014 <CastExpressionValue as ::treesitter_types::FromNode>::from_node(child, src)
2015 })?
2016 },
2017 })
2018 }
2019}
2020impl ::treesitter_types::Spanned for CastExpression<'_> {
2021 fn span(&self) -> ::treesitter_types::Span {
2022 self.span
2023 }
2024}
2025#[derive(Debug, Clone, PartialEq, Eq)]
2026pub struct CastType<'tree> {
2027 pub span: ::treesitter_types::Span,
2028 text: &'tree str,
2029}
2030impl<'tree> ::treesitter_types::FromNode<'tree> for CastType<'tree> {
2031 fn from_node(
2032 node: ::treesitter_types::tree_sitter::Node<'tree>,
2033 src: &'tree [u8],
2034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2035 debug_assert_eq!(node.kind(), "cast_type");
2036 Ok(Self {
2037 span: ::treesitter_types::Span::from(node),
2038 text: node.utf8_text(src)?,
2039 })
2040 }
2041}
2042impl<'tree> ::treesitter_types::LeafNode<'tree> for CastType<'tree> {
2043 fn text(&self) -> &'tree str {
2044 self.text
2045 }
2046}
2047impl ::treesitter_types::Spanned for CastType<'_> {
2048 fn span(&self) -> ::treesitter_types::Span {
2049 self.span
2050 }
2051}
2052#[derive(Debug, Clone, PartialEq, Eq)]
2053pub struct CatchClause<'tree> {
2054 pub span: ::treesitter_types::Span,
2055 pub body: CompoundStatement<'tree>,
2056 pub name: ::core::option::Option<VariableName<'tree>>,
2057 pub r#type: TypeList<'tree>,
2058}
2059impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
2060 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2061 fn from_node(
2062 node: ::treesitter_types::tree_sitter::Node<'tree>,
2063 src: &'tree [u8],
2064 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2065 debug_assert_eq!(node.kind(), "catch_clause");
2066 Ok(Self {
2067 span: ::treesitter_types::Span::from(node),
2068 body: {
2069 let child = node
2070 .child_by_field_name("body")
2071 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2072 ::treesitter_types::runtime::maybe_grow_stack(|| {
2073 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
2074 })?
2075 },
2076 name: match node.child_by_field_name("name") {
2077 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2078 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)
2079 })?),
2080 None => None,
2081 },
2082 r#type: {
2083 let child = node
2084 .child_by_field_name("type")
2085 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2086 ::treesitter_types::runtime::maybe_grow_stack(|| {
2087 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)
2088 })?
2089 },
2090 })
2091 }
2092}
2093impl ::treesitter_types::Spanned for CatchClause<'_> {
2094 fn span(&self) -> ::treesitter_types::Span {
2095 self.span
2096 }
2097}
2098#[derive(Debug, Clone, PartialEq, Eq)]
2099pub struct ClassConstantAccessExpression<'tree> {
2100 pub span: ::treesitter_types::Span,
2101 pub children: ::std::vec::Vec<ClassConstantAccessExpressionChildren<'tree>>,
2102}
2103impl<'tree> ::treesitter_types::FromNode<'tree> for ClassConstantAccessExpression<'tree> {
2104 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2105 fn from_node(
2106 node: ::treesitter_types::tree_sitter::Node<'tree>,
2107 src: &'tree [u8],
2108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2109 debug_assert_eq!(node.kind(), "class_constant_access_expression");
2110 Ok(Self {
2111 span: ::treesitter_types::Span::from(node),
2112 children: {
2113 #[allow(clippy::suspicious_else_formatting)]
2114 let non_field_children = {
2115 let mut cursor = node.walk();
2116 let mut result = ::std::vec::Vec::new();
2117 if cursor.goto_first_child() {
2118 loop {
2119 if cursor.field_name().is_none()
2120 && cursor.node().is_named()
2121 && !cursor.node().is_extra()
2122 {
2123 result.push(cursor.node());
2124 }
2125 if !cursor.goto_next_sibling() {
2126 break;
2127 }
2128 }
2129 }
2130 result
2131 };
2132 let mut items = ::std::vec::Vec::new();
2133 for child in non_field_children {
2134 items
2135 .push(
2136 ::treesitter_types::runtime::maybe_grow_stack(|| <ClassConstantAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
2137 child,
2138 src,
2139 ))?,
2140 );
2141 }
2142 items
2143 },
2144 })
2145 }
2146}
2147impl ::treesitter_types::Spanned for ClassConstantAccessExpression<'_> {
2148 fn span(&self) -> ::treesitter_types::Span {
2149 self.span
2150 }
2151}
2152#[derive(Debug, Clone, PartialEq, Eq)]
2153pub struct ClassDeclaration<'tree> {
2154 pub span: ::treesitter_types::Span,
2155 pub attributes: ::core::option::Option<AttributeList<'tree>>,
2156 pub body: DeclarationList<'tree>,
2157 pub name: Name<'tree>,
2158 pub children: ::std::vec::Vec<ClassDeclarationChildren<'tree>>,
2159}
2160impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
2161 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2162 fn from_node(
2163 node: ::treesitter_types::tree_sitter::Node<'tree>,
2164 src: &'tree [u8],
2165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2166 debug_assert_eq!(node.kind(), "class_declaration");
2167 Ok(Self {
2168 span: ::treesitter_types::Span::from(node),
2169 attributes: match node.child_by_field_name("attributes") {
2170 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2171 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
2172 })?),
2173 None => None,
2174 },
2175 body: {
2176 let child = node
2177 .child_by_field_name("body")
2178 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2179 ::treesitter_types::runtime::maybe_grow_stack(|| {
2180 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
2181 })?
2182 },
2183 name: {
2184 let child = node
2185 .child_by_field_name("name")
2186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2187 ::treesitter_types::runtime::maybe_grow_stack(|| {
2188 <Name as ::treesitter_types::FromNode>::from_node(child, src)
2189 })?
2190 },
2191 children: {
2192 #[allow(clippy::suspicious_else_formatting)]
2193 let non_field_children = {
2194 let mut cursor = node.walk();
2195 let mut result = ::std::vec::Vec::new();
2196 if cursor.goto_first_child() {
2197 loop {
2198 if cursor.field_name().is_none()
2199 && cursor.node().is_named()
2200 && !cursor.node().is_extra()
2201 {
2202 result.push(cursor.node());
2203 }
2204 if !cursor.goto_next_sibling() {
2205 break;
2206 }
2207 }
2208 }
2209 result
2210 };
2211 let mut items = ::std::vec::Vec::new();
2212 for child in non_field_children {
2213 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2214 <ClassDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2215 child, src,
2216 )
2217 })?);
2218 }
2219 items
2220 },
2221 })
2222 }
2223}
2224impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
2225 fn span(&self) -> ::treesitter_types::Span {
2226 self.span
2227 }
2228}
2229#[derive(Debug, Clone, PartialEq, Eq)]
2230pub struct ClassInterfaceClause<'tree> {
2231 pub span: ::treesitter_types::Span,
2232 pub children: ::std::vec::Vec<ClassInterfaceClauseChildren<'tree>>,
2233}
2234impl<'tree> ::treesitter_types::FromNode<'tree> for ClassInterfaceClause<'tree> {
2235 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2236 fn from_node(
2237 node: ::treesitter_types::tree_sitter::Node<'tree>,
2238 src: &'tree [u8],
2239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2240 debug_assert_eq!(node.kind(), "class_interface_clause");
2241 Ok(Self {
2242 span: ::treesitter_types::Span::from(node),
2243 children: {
2244 #[allow(clippy::suspicious_else_formatting)]
2245 let non_field_children = {
2246 let mut cursor = node.walk();
2247 let mut result = ::std::vec::Vec::new();
2248 if cursor.goto_first_child() {
2249 loop {
2250 if cursor.field_name().is_none()
2251 && cursor.node().is_named()
2252 && !cursor.node().is_extra()
2253 {
2254 result.push(cursor.node());
2255 }
2256 if !cursor.goto_next_sibling() {
2257 break;
2258 }
2259 }
2260 }
2261 result
2262 };
2263 let mut items = ::std::vec::Vec::new();
2264 for child in non_field_children {
2265 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2266 <ClassInterfaceClauseChildren as ::treesitter_types::FromNode>::from_node(
2267 child, src,
2268 )
2269 })?);
2270 }
2271 items
2272 },
2273 })
2274 }
2275}
2276impl ::treesitter_types::Spanned for ClassInterfaceClause<'_> {
2277 fn span(&self) -> ::treesitter_types::Span {
2278 self.span
2279 }
2280}
2281#[derive(Debug, Clone, PartialEq, Eq)]
2282pub struct CloneExpression<'tree> {
2283 pub span: ::treesitter_types::Span,
2284 pub children: PrimaryExpression<'tree>,
2285}
2286impl<'tree> ::treesitter_types::FromNode<'tree> for CloneExpression<'tree> {
2287 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2288 fn from_node(
2289 node: ::treesitter_types::tree_sitter::Node<'tree>,
2290 src: &'tree [u8],
2291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2292 debug_assert_eq!(node.kind(), "clone_expression");
2293 Ok(Self {
2294 span: ::treesitter_types::Span::from(node),
2295 children: {
2296 #[allow(clippy::suspicious_else_formatting)]
2297 let non_field_children = {
2298 let mut cursor = node.walk();
2299 let mut result = ::std::vec::Vec::new();
2300 if cursor.goto_first_child() {
2301 loop {
2302 if cursor.field_name().is_none()
2303 && cursor.node().is_named()
2304 && !cursor.node().is_extra()
2305 {
2306 result.push(cursor.node());
2307 }
2308 if !cursor.goto_next_sibling() {
2309 break;
2310 }
2311 }
2312 }
2313 result
2314 };
2315 let child = if let Some(&c) = non_field_children.first() {
2316 c
2317 } else {
2318 let mut fallback_cursor = node.walk();
2319 let mut fallback_child = None;
2320 if fallback_cursor.goto_first_child() {
2321 loop {
2322 if fallback_cursor.field_name().is_none()
2323 && !fallback_cursor.node().is_extra()
2324 {
2325 let candidate = fallback_cursor.node();
2326 #[allow(clippy::needless_question_mark)]
2327 if (|| -> ::core::result::Result<
2328 _,
2329 ::treesitter_types::ParseError,
2330 > {
2331 let child = candidate;
2332 Ok(
2333 ::treesitter_types::runtime::maybe_grow_stack(|| <PrimaryExpression as ::treesitter_types::FromNode>::from_node(
2334 child,
2335 src,
2336 ))?,
2337 )
2338 })()
2339 .is_ok()
2340 {
2341 fallback_child = Some(candidate);
2342 break;
2343 }
2344 }
2345 if !fallback_cursor.goto_next_sibling() {
2346 break;
2347 }
2348 }
2349 }
2350 if fallback_child.is_none() {
2351 let mut cursor2 = node.walk();
2352 if cursor2.goto_first_child() {
2353 loop {
2354 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2355 let candidate = cursor2.node();
2356 #[allow(clippy::needless_question_mark)]
2357 if (|| -> ::core::result::Result<
2358 _,
2359 ::treesitter_types::ParseError,
2360 > {
2361 let child = candidate;
2362 Ok(
2363 ::treesitter_types::runtime::maybe_grow_stack(|| <PrimaryExpression as ::treesitter_types::FromNode>::from_node(
2364 child,
2365 src,
2366 ))?,
2367 )
2368 })()
2369 .is_ok()
2370 {
2371 fallback_child = Some(candidate);
2372 break;
2373 }
2374 }
2375 if !cursor2.goto_next_sibling() {
2376 break;
2377 }
2378 }
2379 }
2380 }
2381 fallback_child.ok_or_else(|| {
2382 ::treesitter_types::ParseError::missing_field("children", node)
2383 })?
2384 };
2385 ::treesitter_types::runtime::maybe_grow_stack(|| {
2386 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)
2387 })?
2388 },
2389 })
2390 }
2391}
2392impl ::treesitter_types::Spanned for CloneExpression<'_> {
2393 fn span(&self) -> ::treesitter_types::Span {
2394 self.span
2395 }
2396}
2397#[derive(Debug, Clone, PartialEq, Eq)]
2398pub struct ColonBlock<'tree> {
2399 pub span: ::treesitter_types::Span,
2400 pub children: ::std::vec::Vec<Statement<'tree>>,
2401}
2402impl<'tree> ::treesitter_types::FromNode<'tree> for ColonBlock<'tree> {
2403 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2404 fn from_node(
2405 node: ::treesitter_types::tree_sitter::Node<'tree>,
2406 src: &'tree [u8],
2407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2408 debug_assert_eq!(node.kind(), "colon_block");
2409 Ok(Self {
2410 span: ::treesitter_types::Span::from(node),
2411 children: {
2412 #[allow(clippy::suspicious_else_formatting)]
2413 let non_field_children = {
2414 let mut cursor = node.walk();
2415 let mut result = ::std::vec::Vec::new();
2416 if cursor.goto_first_child() {
2417 loop {
2418 if cursor.field_name().is_none()
2419 && cursor.node().is_named()
2420 && !cursor.node().is_extra()
2421 {
2422 result.push(cursor.node());
2423 }
2424 if !cursor.goto_next_sibling() {
2425 break;
2426 }
2427 }
2428 }
2429 result
2430 };
2431 let mut items = ::std::vec::Vec::new();
2432 for child in non_field_children {
2433 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2434 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2435 })?);
2436 }
2437 items
2438 },
2439 })
2440 }
2441}
2442impl ::treesitter_types::Spanned for ColonBlock<'_> {
2443 fn span(&self) -> ::treesitter_types::Span {
2444 self.span
2445 }
2446}
2447#[derive(Debug, Clone, PartialEq, Eq)]
2448pub struct CompoundStatement<'tree> {
2449 pub span: ::treesitter_types::Span,
2450 pub children: ::std::vec::Vec<Statement<'tree>>,
2451}
2452impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatement<'tree> {
2453 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2454 fn from_node(
2455 node: ::treesitter_types::tree_sitter::Node<'tree>,
2456 src: &'tree [u8],
2457 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2458 debug_assert_eq!(node.kind(), "compound_statement");
2459 Ok(Self {
2460 span: ::treesitter_types::Span::from(node),
2461 children: {
2462 #[allow(clippy::suspicious_else_formatting)]
2463 let non_field_children = {
2464 let mut cursor = node.walk();
2465 let mut result = ::std::vec::Vec::new();
2466 if cursor.goto_first_child() {
2467 loop {
2468 if cursor.field_name().is_none()
2469 && cursor.node().is_named()
2470 && !cursor.node().is_extra()
2471 {
2472 result.push(cursor.node());
2473 }
2474 if !cursor.goto_next_sibling() {
2475 break;
2476 }
2477 }
2478 }
2479 result
2480 };
2481 let mut items = ::std::vec::Vec::new();
2482 for child in non_field_children {
2483 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2484 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2485 })?);
2486 }
2487 items
2488 },
2489 })
2490 }
2491}
2492impl ::treesitter_types::Spanned for CompoundStatement<'_> {
2493 fn span(&self) -> ::treesitter_types::Span {
2494 self.span
2495 }
2496}
2497#[derive(Debug, Clone, PartialEq, Eq)]
2498pub struct ConditionalExpression<'tree> {
2499 pub span: ::treesitter_types::Span,
2500 pub alternative: Expression<'tree>,
2501 pub body: ::core::option::Option<Expression<'tree>>,
2502 pub condition: Expression<'tree>,
2503}
2504impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
2505 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2506 fn from_node(
2507 node: ::treesitter_types::tree_sitter::Node<'tree>,
2508 src: &'tree [u8],
2509 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2510 debug_assert_eq!(node.kind(), "conditional_expression");
2511 Ok(Self {
2512 span: ::treesitter_types::Span::from(node),
2513 alternative: {
2514 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2515 ::treesitter_types::ParseError::missing_field("alternative", node)
2516 })?;
2517 ::treesitter_types::runtime::maybe_grow_stack(|| {
2518 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2519 })?
2520 },
2521 body: match node.child_by_field_name("body") {
2522 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2523 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2524 })?),
2525 None => None,
2526 },
2527 condition: {
2528 let child = node.child_by_field_name("condition").ok_or_else(|| {
2529 ::treesitter_types::ParseError::missing_field("condition", node)
2530 })?;
2531 ::treesitter_types::runtime::maybe_grow_stack(|| {
2532 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2533 })?
2534 },
2535 })
2536 }
2537}
2538impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
2539 fn span(&self) -> ::treesitter_types::Span {
2540 self.span
2541 }
2542}
2543#[derive(Debug, Clone, PartialEq, Eq)]
2544pub struct ConstDeclaration<'tree> {
2545 pub span: ::treesitter_types::Span,
2546 pub attributes: ::core::option::Option<AttributeList<'tree>>,
2547 pub r#type: ::core::option::Option<Type<'tree>>,
2548 pub children: ::std::vec::Vec<ConstDeclarationChildren<'tree>>,
2549}
2550impl<'tree> ::treesitter_types::FromNode<'tree> for ConstDeclaration<'tree> {
2551 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2552 fn from_node(
2553 node: ::treesitter_types::tree_sitter::Node<'tree>,
2554 src: &'tree [u8],
2555 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2556 debug_assert_eq!(node.kind(), "const_declaration");
2557 Ok(Self {
2558 span: ::treesitter_types::Span::from(node),
2559 attributes: match node.child_by_field_name("attributes") {
2560 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2561 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
2562 })?),
2563 None => None,
2564 },
2565 r#type: match node.child_by_field_name("type") {
2566 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2567 <Type as ::treesitter_types::FromNode>::from_node(child, src)
2568 })?),
2569 None => None,
2570 },
2571 children: {
2572 #[allow(clippy::suspicious_else_formatting)]
2573 let non_field_children = {
2574 let mut cursor = node.walk();
2575 let mut result = ::std::vec::Vec::new();
2576 if cursor.goto_first_child() {
2577 loop {
2578 if cursor.field_name().is_none()
2579 && cursor.node().is_named()
2580 && !cursor.node().is_extra()
2581 {
2582 result.push(cursor.node());
2583 }
2584 if !cursor.goto_next_sibling() {
2585 break;
2586 }
2587 }
2588 }
2589 result
2590 };
2591 let mut items = ::std::vec::Vec::new();
2592 for child in non_field_children {
2593 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2594 <ConstDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2595 child, src,
2596 )
2597 })?);
2598 }
2599 items
2600 },
2601 })
2602 }
2603}
2604impl ::treesitter_types::Spanned for ConstDeclaration<'_> {
2605 fn span(&self) -> ::treesitter_types::Span {
2606 self.span
2607 }
2608}
2609#[derive(Debug, Clone, PartialEq, Eq)]
2610pub struct ConstElement<'tree> {
2611 pub span: ::treesitter_types::Span,
2612 pub children: ::std::vec::Vec<ConstElementChildren<'tree>>,
2613}
2614impl<'tree> ::treesitter_types::FromNode<'tree> for ConstElement<'tree> {
2615 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2616 fn from_node(
2617 node: ::treesitter_types::tree_sitter::Node<'tree>,
2618 src: &'tree [u8],
2619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2620 debug_assert_eq!(node.kind(), "const_element");
2621 Ok(Self {
2622 span: ::treesitter_types::Span::from(node),
2623 children: {
2624 #[allow(clippy::suspicious_else_formatting)]
2625 let non_field_children = {
2626 let mut cursor = node.walk();
2627 let mut result = ::std::vec::Vec::new();
2628 if cursor.goto_first_child() {
2629 loop {
2630 if cursor.field_name().is_none()
2631 && cursor.node().is_named()
2632 && !cursor.node().is_extra()
2633 {
2634 result.push(cursor.node());
2635 }
2636 if !cursor.goto_next_sibling() {
2637 break;
2638 }
2639 }
2640 }
2641 result
2642 };
2643 let mut items = ::std::vec::Vec::new();
2644 for child in non_field_children {
2645 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2646 <ConstElementChildren as ::treesitter_types::FromNode>::from_node(
2647 child, src,
2648 )
2649 })?);
2650 }
2651 items
2652 },
2653 })
2654 }
2655}
2656impl ::treesitter_types::Spanned for ConstElement<'_> {
2657 fn span(&self) -> ::treesitter_types::Span {
2658 self.span
2659 }
2660}
2661#[derive(Debug, Clone, PartialEq, Eq)]
2662pub struct ContinueStatement<'tree> {
2663 pub span: ::treesitter_types::Span,
2664 pub children: ::core::option::Option<Expression<'tree>>,
2665}
2666impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2667 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2668 fn from_node(
2669 node: ::treesitter_types::tree_sitter::Node<'tree>,
2670 src: &'tree [u8],
2671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2672 debug_assert_eq!(node.kind(), "continue_statement");
2673 Ok(Self {
2674 span: ::treesitter_types::Span::from(node),
2675 children: {
2676 #[allow(clippy::suspicious_else_formatting)]
2677 let non_field_children = {
2678 let mut cursor = node.walk();
2679 let mut result = ::std::vec::Vec::new();
2680 if cursor.goto_first_child() {
2681 loop {
2682 if cursor.field_name().is_none()
2683 && cursor.node().is_named()
2684 && !cursor.node().is_extra()
2685 {
2686 result.push(cursor.node());
2687 }
2688 if !cursor.goto_next_sibling() {
2689 break;
2690 }
2691 }
2692 }
2693 result
2694 };
2695 match non_field_children.first() {
2696 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2697 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
2698 })?),
2699 None => None,
2700 }
2701 },
2702 })
2703 }
2704}
2705impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2706 fn span(&self) -> ::treesitter_types::Span {
2707 self.span
2708 }
2709}
2710#[derive(Debug, Clone, PartialEq, Eq)]
2711pub struct DeclarationList<'tree> {
2712 pub span: ::treesitter_types::Span,
2713 pub children: ::std::vec::Vec<DeclarationListChildren<'tree>>,
2714}
2715impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2716 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2717 fn from_node(
2718 node: ::treesitter_types::tree_sitter::Node<'tree>,
2719 src: &'tree [u8],
2720 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2721 debug_assert_eq!(node.kind(), "declaration_list");
2722 Ok(Self {
2723 span: ::treesitter_types::Span::from(node),
2724 children: {
2725 #[allow(clippy::suspicious_else_formatting)]
2726 let non_field_children = {
2727 let mut cursor = node.walk();
2728 let mut result = ::std::vec::Vec::new();
2729 if cursor.goto_first_child() {
2730 loop {
2731 if cursor.field_name().is_none()
2732 && cursor.node().is_named()
2733 && !cursor.node().is_extra()
2734 {
2735 result.push(cursor.node());
2736 }
2737 if !cursor.goto_next_sibling() {
2738 break;
2739 }
2740 }
2741 }
2742 result
2743 };
2744 let mut items = ::std::vec::Vec::new();
2745 for child in non_field_children {
2746 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2747 <DeclarationListChildren as ::treesitter_types::FromNode>::from_node(
2748 child, src,
2749 )
2750 })?);
2751 }
2752 items
2753 },
2754 })
2755 }
2756}
2757impl ::treesitter_types::Spanned for DeclarationList<'_> {
2758 fn span(&self) -> ::treesitter_types::Span {
2759 self.span
2760 }
2761}
2762#[derive(Debug, Clone, PartialEq, Eq)]
2763pub struct DeclareDirective<'tree> {
2764 pub span: ::treesitter_types::Span,
2765 pub children: Literal<'tree>,
2766}
2767impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareDirective<'tree> {
2768 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2769 fn from_node(
2770 node: ::treesitter_types::tree_sitter::Node<'tree>,
2771 src: &'tree [u8],
2772 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2773 debug_assert_eq!(node.kind(), "declare_directive");
2774 Ok(Self {
2775 span: ::treesitter_types::Span::from(node),
2776 children: {
2777 #[allow(clippy::suspicious_else_formatting)]
2778 let non_field_children = {
2779 let mut cursor = node.walk();
2780 let mut result = ::std::vec::Vec::new();
2781 if cursor.goto_first_child() {
2782 loop {
2783 if cursor.field_name().is_none()
2784 && cursor.node().is_named()
2785 && !cursor.node().is_extra()
2786 {
2787 result.push(cursor.node());
2788 }
2789 if !cursor.goto_next_sibling() {
2790 break;
2791 }
2792 }
2793 }
2794 result
2795 };
2796 let child = if let Some(&c) = non_field_children.first() {
2797 c
2798 } else {
2799 let mut fallback_cursor = node.walk();
2800 let mut fallback_child = None;
2801 if fallback_cursor.goto_first_child() {
2802 loop {
2803 if fallback_cursor.field_name().is_none()
2804 && !fallback_cursor.node().is_extra()
2805 {
2806 let candidate = fallback_cursor.node();
2807 #[allow(clippy::needless_question_mark)]
2808 if (|| -> ::core::result::Result<
2809 _,
2810 ::treesitter_types::ParseError,
2811 > {
2812 let child = candidate;
2813 Ok(
2814 ::treesitter_types::runtime::maybe_grow_stack(|| <Literal as ::treesitter_types::FromNode>::from_node(
2815 child,
2816 src,
2817 ))?,
2818 )
2819 })()
2820 .is_ok()
2821 {
2822 fallback_child = Some(candidate);
2823 break;
2824 }
2825 }
2826 if !fallback_cursor.goto_next_sibling() {
2827 break;
2828 }
2829 }
2830 }
2831 if fallback_child.is_none() {
2832 let mut cursor2 = node.walk();
2833 if cursor2.goto_first_child() {
2834 loop {
2835 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2836 let candidate = cursor2.node();
2837 #[allow(clippy::needless_question_mark)]
2838 if (|| -> ::core::result::Result<
2839 _,
2840 ::treesitter_types::ParseError,
2841 > {
2842 let child = candidate;
2843 Ok(
2844 ::treesitter_types::runtime::maybe_grow_stack(|| <Literal as ::treesitter_types::FromNode>::from_node(
2845 child,
2846 src,
2847 ))?,
2848 )
2849 })()
2850 .is_ok()
2851 {
2852 fallback_child = Some(candidate);
2853 break;
2854 }
2855 }
2856 if !cursor2.goto_next_sibling() {
2857 break;
2858 }
2859 }
2860 }
2861 }
2862 fallback_child.ok_or_else(|| {
2863 ::treesitter_types::ParseError::missing_field("children", node)
2864 })?
2865 };
2866 ::treesitter_types::runtime::maybe_grow_stack(|| {
2867 <Literal as ::treesitter_types::FromNode>::from_node(child, src)
2868 })?
2869 },
2870 })
2871 }
2872}
2873impl ::treesitter_types::Spanned for DeclareDirective<'_> {
2874 fn span(&self) -> ::treesitter_types::Span {
2875 self.span
2876 }
2877}
2878#[derive(Debug, Clone, PartialEq, Eq)]
2879pub struct DeclareStatement<'tree> {
2880 pub span: ::treesitter_types::Span,
2881 pub children: ::std::vec::Vec<DeclareStatementChildren<'tree>>,
2882}
2883impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareStatement<'tree> {
2884 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2885 fn from_node(
2886 node: ::treesitter_types::tree_sitter::Node<'tree>,
2887 src: &'tree [u8],
2888 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2889 debug_assert_eq!(node.kind(), "declare_statement");
2890 Ok(Self {
2891 span: ::treesitter_types::Span::from(node),
2892 children: {
2893 #[allow(clippy::suspicious_else_formatting)]
2894 let non_field_children = {
2895 let mut cursor = node.walk();
2896 let mut result = ::std::vec::Vec::new();
2897 if cursor.goto_first_child() {
2898 loop {
2899 if cursor.field_name().is_none()
2900 && cursor.node().is_named()
2901 && !cursor.node().is_extra()
2902 {
2903 result.push(cursor.node());
2904 }
2905 if !cursor.goto_next_sibling() {
2906 break;
2907 }
2908 }
2909 }
2910 result
2911 };
2912 let mut items = ::std::vec::Vec::new();
2913 for child in non_field_children {
2914 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2915 <DeclareStatementChildren as ::treesitter_types::FromNode>::from_node(
2916 child, src,
2917 )
2918 })?);
2919 }
2920 items
2921 },
2922 })
2923 }
2924}
2925impl ::treesitter_types::Spanned for DeclareStatement<'_> {
2926 fn span(&self) -> ::treesitter_types::Span {
2927 self.span
2928 }
2929}
2930#[derive(Debug, Clone, PartialEq, Eq)]
2931pub struct DefaultStatement<'tree> {
2932 pub span: ::treesitter_types::Span,
2933 pub children: ::std::vec::Vec<Statement<'tree>>,
2934}
2935impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultStatement<'tree> {
2936 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2937 fn from_node(
2938 node: ::treesitter_types::tree_sitter::Node<'tree>,
2939 src: &'tree [u8],
2940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2941 debug_assert_eq!(node.kind(), "default_statement");
2942 Ok(Self {
2943 span: ::treesitter_types::Span::from(node),
2944 children: {
2945 #[allow(clippy::suspicious_else_formatting)]
2946 let non_field_children = {
2947 let mut cursor = node.walk();
2948 let mut result = ::std::vec::Vec::new();
2949 if cursor.goto_first_child() {
2950 loop {
2951 if cursor.field_name().is_none()
2952 && cursor.node().is_named()
2953 && !cursor.node().is_extra()
2954 {
2955 result.push(cursor.node());
2956 }
2957 if !cursor.goto_next_sibling() {
2958 break;
2959 }
2960 }
2961 }
2962 result
2963 };
2964 let mut items = ::std::vec::Vec::new();
2965 for child in non_field_children {
2966 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2967 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
2968 })?);
2969 }
2970 items
2971 },
2972 })
2973 }
2974}
2975impl ::treesitter_types::Spanned for DefaultStatement<'_> {
2976 fn span(&self) -> ::treesitter_types::Span {
2977 self.span
2978 }
2979}
2980#[derive(Debug, Clone, PartialEq, Eq)]
2981pub struct DisjunctiveNormalFormType<'tree> {
2982 pub span: ::treesitter_types::Span,
2983 pub children: ::std::vec::Vec<DisjunctiveNormalFormTypeChildren<'tree>>,
2984}
2985impl<'tree> ::treesitter_types::FromNode<'tree> for DisjunctiveNormalFormType<'tree> {
2986 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2987 fn from_node(
2988 node: ::treesitter_types::tree_sitter::Node<'tree>,
2989 src: &'tree [u8],
2990 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2991 debug_assert_eq!(node.kind(), "disjunctive_normal_form_type");
2992 Ok(Self {
2993 span: ::treesitter_types::Span::from(node),
2994 children: {
2995 #[allow(clippy::suspicious_else_formatting)]
2996 let non_field_children = {
2997 let mut cursor = node.walk();
2998 let mut result = ::std::vec::Vec::new();
2999 if cursor.goto_first_child() {
3000 loop {
3001 if cursor.field_name().is_none()
3002 && cursor.node().is_named()
3003 && !cursor.node().is_extra()
3004 {
3005 result.push(cursor.node());
3006 }
3007 if !cursor.goto_next_sibling() {
3008 break;
3009 }
3010 }
3011 }
3012 result
3013 };
3014 let mut items = ::std::vec::Vec::new();
3015 for child in non_field_children {
3016 items
3017 .push(
3018 ::treesitter_types::runtime::maybe_grow_stack(|| <DisjunctiveNormalFormTypeChildren as ::treesitter_types::FromNode>::from_node(
3019 child,
3020 src,
3021 ))?,
3022 );
3023 }
3024 items
3025 },
3026 })
3027 }
3028}
3029impl ::treesitter_types::Spanned for DisjunctiveNormalFormType<'_> {
3030 fn span(&self) -> ::treesitter_types::Span {
3031 self.span
3032 }
3033}
3034#[derive(Debug, Clone, PartialEq, Eq)]
3035pub struct DoStatement<'tree> {
3036 pub span: ::treesitter_types::Span,
3037 pub body: Statement<'tree>,
3038 pub condition: ParenthesizedExpression<'tree>,
3039}
3040impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
3041 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3042 fn from_node(
3043 node: ::treesitter_types::tree_sitter::Node<'tree>,
3044 src: &'tree [u8],
3045 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3046 debug_assert_eq!(node.kind(), "do_statement");
3047 Ok(Self {
3048 span: ::treesitter_types::Span::from(node),
3049 body: {
3050 let child = node
3051 .child_by_field_name("body")
3052 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3053 ::treesitter_types::runtime::maybe_grow_stack(|| {
3054 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3055 })?
3056 },
3057 condition: {
3058 let child = node.child_by_field_name("condition").ok_or_else(|| {
3059 ::treesitter_types::ParseError::missing_field("condition", node)
3060 })?;
3061 ::treesitter_types::runtime::maybe_grow_stack(|| {
3062 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
3063 })?
3064 },
3065 })
3066 }
3067}
3068impl ::treesitter_types::Spanned for DoStatement<'_> {
3069 fn span(&self) -> ::treesitter_types::Span {
3070 self.span
3071 }
3072}
3073#[derive(Debug, Clone, PartialEq, Eq)]
3074pub struct DynamicVariableName<'tree> {
3075 pub span: ::treesitter_types::Span,
3076 pub children: DynamicVariableNameChildren<'tree>,
3077}
3078impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicVariableName<'tree> {
3079 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3080 fn from_node(
3081 node: ::treesitter_types::tree_sitter::Node<'tree>,
3082 src: &'tree [u8],
3083 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3084 debug_assert_eq!(node.kind(), "dynamic_variable_name");
3085 Ok(Self {
3086 span: ::treesitter_types::Span::from(node),
3087 children: {
3088 #[allow(clippy::suspicious_else_formatting)]
3089 let non_field_children = {
3090 let mut cursor = node.walk();
3091 let mut result = ::std::vec::Vec::new();
3092 if cursor.goto_first_child() {
3093 loop {
3094 if cursor.field_name().is_none()
3095 && cursor.node().is_named()
3096 && !cursor.node().is_extra()
3097 {
3098 result.push(cursor.node());
3099 }
3100 if !cursor.goto_next_sibling() {
3101 break;
3102 }
3103 }
3104 }
3105 result
3106 };
3107 let child = if let Some(&c) = non_field_children.first() {
3108 c
3109 } else {
3110 let mut fallback_cursor = node.walk();
3111 let mut fallback_child = None;
3112 if fallback_cursor.goto_first_child() {
3113 loop {
3114 if fallback_cursor.field_name().is_none()
3115 && !fallback_cursor.node().is_extra()
3116 {
3117 let candidate = fallback_cursor.node();
3118 #[allow(clippy::needless_question_mark)]
3119 if (|| -> ::core::result::Result<
3120 _,
3121 ::treesitter_types::ParseError,
3122 > {
3123 let child = candidate;
3124 Ok(
3125 ::treesitter_types::runtime::maybe_grow_stack(|| <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
3126 child,
3127 src,
3128 ))?,
3129 )
3130 })()
3131 .is_ok()
3132 {
3133 fallback_child = Some(candidate);
3134 break;
3135 }
3136 }
3137 if !fallback_cursor.goto_next_sibling() {
3138 break;
3139 }
3140 }
3141 }
3142 if fallback_child.is_none() {
3143 let mut cursor2 = node.walk();
3144 if cursor2.goto_first_child() {
3145 loop {
3146 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3147 let candidate = cursor2.node();
3148 #[allow(clippy::needless_question_mark)]
3149 if (|| -> ::core::result::Result<
3150 _,
3151 ::treesitter_types::ParseError,
3152 > {
3153 let child = candidate;
3154 Ok(
3155 ::treesitter_types::runtime::maybe_grow_stack(|| <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
3156 child,
3157 src,
3158 ))?,
3159 )
3160 })()
3161 .is_ok()
3162 {
3163 fallback_child = Some(candidate);
3164 break;
3165 }
3166 }
3167 if !cursor2.goto_next_sibling() {
3168 break;
3169 }
3170 }
3171 }
3172 }
3173 fallback_child.ok_or_else(|| {
3174 ::treesitter_types::ParseError::missing_field("children", node)
3175 })?
3176 };
3177 ::treesitter_types::runtime::maybe_grow_stack(|| {
3178 <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
3179 child, src,
3180 )
3181 })?
3182 },
3183 })
3184 }
3185}
3186impl ::treesitter_types::Spanned for DynamicVariableName<'_> {
3187 fn span(&self) -> ::treesitter_types::Span {
3188 self.span
3189 }
3190}
3191#[derive(Debug, Clone, PartialEq, Eq)]
3192pub struct EchoStatement<'tree> {
3193 pub span: ::treesitter_types::Span,
3194 pub children: EchoStatementChildren<'tree>,
3195}
3196impl<'tree> ::treesitter_types::FromNode<'tree> for EchoStatement<'tree> {
3197 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3198 fn from_node(
3199 node: ::treesitter_types::tree_sitter::Node<'tree>,
3200 src: &'tree [u8],
3201 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3202 debug_assert_eq!(node.kind(), "echo_statement");
3203 Ok(Self {
3204 span: ::treesitter_types::Span::from(node),
3205 children: {
3206 #[allow(clippy::suspicious_else_formatting)]
3207 let non_field_children = {
3208 let mut cursor = node.walk();
3209 let mut result = ::std::vec::Vec::new();
3210 if cursor.goto_first_child() {
3211 loop {
3212 if cursor.field_name().is_none()
3213 && cursor.node().is_named()
3214 && !cursor.node().is_extra()
3215 {
3216 result.push(cursor.node());
3217 }
3218 if !cursor.goto_next_sibling() {
3219 break;
3220 }
3221 }
3222 }
3223 result
3224 };
3225 let child = if let Some(&c) = non_field_children.first() {
3226 c
3227 } else {
3228 let mut fallback_cursor = node.walk();
3229 let mut fallback_child = None;
3230 if fallback_cursor.goto_first_child() {
3231 loop {
3232 if fallback_cursor.field_name().is_none()
3233 && !fallback_cursor.node().is_extra()
3234 {
3235 let candidate = fallback_cursor.node();
3236 #[allow(clippy::needless_question_mark)]
3237 if (|| -> ::core::result::Result<
3238 _,
3239 ::treesitter_types::ParseError,
3240 > {
3241 let child = candidate;
3242 Ok(
3243 ::treesitter_types::runtime::maybe_grow_stack(|| <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(
3244 child,
3245 src,
3246 ))?,
3247 )
3248 })()
3249 .is_ok()
3250 {
3251 fallback_child = Some(candidate);
3252 break;
3253 }
3254 }
3255 if !fallback_cursor.goto_next_sibling() {
3256 break;
3257 }
3258 }
3259 }
3260 if fallback_child.is_none() {
3261 let mut cursor2 = node.walk();
3262 if cursor2.goto_first_child() {
3263 loop {
3264 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3265 let candidate = cursor2.node();
3266 #[allow(clippy::needless_question_mark)]
3267 if (|| -> ::core::result::Result<
3268 _,
3269 ::treesitter_types::ParseError,
3270 > {
3271 let child = candidate;
3272 Ok(
3273 ::treesitter_types::runtime::maybe_grow_stack(|| <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(
3274 child,
3275 src,
3276 ))?,
3277 )
3278 })()
3279 .is_ok()
3280 {
3281 fallback_child = Some(candidate);
3282 break;
3283 }
3284 }
3285 if !cursor2.goto_next_sibling() {
3286 break;
3287 }
3288 }
3289 }
3290 }
3291 fallback_child.ok_or_else(|| {
3292 ::treesitter_types::ParseError::missing_field("children", node)
3293 })?
3294 };
3295 ::treesitter_types::runtime::maybe_grow_stack(|| {
3296 <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)
3297 })?
3298 },
3299 })
3300 }
3301}
3302impl ::treesitter_types::Spanned for EchoStatement<'_> {
3303 fn span(&self) -> ::treesitter_types::Span {
3304 self.span
3305 }
3306}
3307#[derive(Debug, Clone, PartialEq, Eq)]
3308pub struct ElseClause<'tree> {
3309 pub span: ::treesitter_types::Span,
3310 pub body: ElseClauseBody<'tree>,
3311}
3312impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
3313 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3314 fn from_node(
3315 node: ::treesitter_types::tree_sitter::Node<'tree>,
3316 src: &'tree [u8],
3317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3318 debug_assert_eq!(node.kind(), "else_clause");
3319 Ok(Self {
3320 span: ::treesitter_types::Span::from(node),
3321 body: {
3322 let child = node
3323 .child_by_field_name("body")
3324 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3325 ::treesitter_types::runtime::maybe_grow_stack(|| {
3326 <ElseClauseBody as ::treesitter_types::FromNode>::from_node(child, src)
3327 })?
3328 },
3329 })
3330 }
3331}
3332impl ::treesitter_types::Spanned for ElseClause<'_> {
3333 fn span(&self) -> ::treesitter_types::Span {
3334 self.span
3335 }
3336}
3337#[derive(Debug, Clone, PartialEq, Eq)]
3338pub struct ElseIfClause<'tree> {
3339 pub span: ::treesitter_types::Span,
3340 pub body: ElseIfClauseBody<'tree>,
3341 pub condition: ParenthesizedExpression<'tree>,
3342}
3343impl<'tree> ::treesitter_types::FromNode<'tree> for ElseIfClause<'tree> {
3344 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3345 fn from_node(
3346 node: ::treesitter_types::tree_sitter::Node<'tree>,
3347 src: &'tree [u8],
3348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3349 debug_assert_eq!(node.kind(), "else_if_clause");
3350 Ok(Self {
3351 span: ::treesitter_types::Span::from(node),
3352 body: {
3353 let child = node
3354 .child_by_field_name("body")
3355 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3356 ::treesitter_types::runtime::maybe_grow_stack(|| {
3357 <ElseIfClauseBody as ::treesitter_types::FromNode>::from_node(child, src)
3358 })?
3359 },
3360 condition: {
3361 let child = node.child_by_field_name("condition").ok_or_else(|| {
3362 ::treesitter_types::ParseError::missing_field("condition", node)
3363 })?;
3364 ::treesitter_types::runtime::maybe_grow_stack(|| {
3365 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
3366 })?
3367 },
3368 })
3369 }
3370}
3371impl ::treesitter_types::Spanned for ElseIfClause<'_> {
3372 fn span(&self) -> ::treesitter_types::Span {
3373 self.span
3374 }
3375}
3376#[derive(Debug, Clone, PartialEq, Eq)]
3377pub struct EmptyStatement<'tree> {
3378 pub span: ::treesitter_types::Span,
3379 text: &'tree str,
3380}
3381impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
3382 fn from_node(
3383 node: ::treesitter_types::tree_sitter::Node<'tree>,
3384 src: &'tree [u8],
3385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3386 debug_assert_eq!(node.kind(), "empty_statement");
3387 Ok(Self {
3388 span: ::treesitter_types::Span::from(node),
3389 text: node.utf8_text(src)?,
3390 })
3391 }
3392}
3393impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
3394 fn text(&self) -> &'tree str {
3395 self.text
3396 }
3397}
3398impl ::treesitter_types::Spanned for EmptyStatement<'_> {
3399 fn span(&self) -> ::treesitter_types::Span {
3400 self.span
3401 }
3402}
3403#[derive(Debug, Clone, PartialEq, Eq)]
3404pub struct EncapsedString<'tree> {
3405 pub span: ::treesitter_types::Span,
3406 pub children: ::std::vec::Vec<EncapsedStringChildren<'tree>>,
3407}
3408impl<'tree> ::treesitter_types::FromNode<'tree> for EncapsedString<'tree> {
3409 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3410 fn from_node(
3411 node: ::treesitter_types::tree_sitter::Node<'tree>,
3412 src: &'tree [u8],
3413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3414 debug_assert_eq!(node.kind(), "encapsed_string");
3415 Ok(Self {
3416 span: ::treesitter_types::Span::from(node),
3417 children: {
3418 #[allow(clippy::suspicious_else_formatting)]
3419 let non_field_children = {
3420 let mut cursor = node.walk();
3421 let mut result = ::std::vec::Vec::new();
3422 if cursor.goto_first_child() {
3423 loop {
3424 if cursor.field_name().is_none()
3425 && cursor.node().is_named()
3426 && !cursor.node().is_extra()
3427 {
3428 result.push(cursor.node());
3429 }
3430 if !cursor.goto_next_sibling() {
3431 break;
3432 }
3433 }
3434 }
3435 result
3436 };
3437 let mut items = ::std::vec::Vec::new();
3438 for child in non_field_children {
3439 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3440 <EncapsedStringChildren as ::treesitter_types::FromNode>::from_node(
3441 child, src,
3442 )
3443 })?);
3444 }
3445 items
3446 },
3447 })
3448 }
3449}
3450impl ::treesitter_types::Spanned for EncapsedString<'_> {
3451 fn span(&self) -> ::treesitter_types::Span {
3452 self.span
3453 }
3454}
3455#[derive(Debug, Clone, PartialEq, Eq)]
3456pub struct EnumCase<'tree> {
3457 pub span: ::treesitter_types::Span,
3458 pub attributes: ::core::option::Option<AttributeList<'tree>>,
3459 pub name: Name<'tree>,
3460 pub value: ::core::option::Option<Expression<'tree>>,
3461}
3462impl<'tree> ::treesitter_types::FromNode<'tree> for EnumCase<'tree> {
3463 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3464 fn from_node(
3465 node: ::treesitter_types::tree_sitter::Node<'tree>,
3466 src: &'tree [u8],
3467 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3468 debug_assert_eq!(node.kind(), "enum_case");
3469 Ok(Self {
3470 span: ::treesitter_types::Span::from(node),
3471 attributes: match node.child_by_field_name("attributes") {
3472 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3473 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
3474 })?),
3475 None => None,
3476 },
3477 name: {
3478 let child = node
3479 .child_by_field_name("name")
3480 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3481 ::treesitter_types::runtime::maybe_grow_stack(|| {
3482 <Name as ::treesitter_types::FromNode>::from_node(child, src)
3483 })?
3484 },
3485 value: match node.child_by_field_name("value") {
3486 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3487 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3488 })?),
3489 None => None,
3490 },
3491 })
3492 }
3493}
3494impl ::treesitter_types::Spanned for EnumCase<'_> {
3495 fn span(&self) -> ::treesitter_types::Span {
3496 self.span
3497 }
3498}
3499#[derive(Debug, Clone, PartialEq, Eq)]
3500pub struct EnumDeclaration<'tree> {
3501 pub span: ::treesitter_types::Span,
3502 pub attributes: ::core::option::Option<AttributeList<'tree>>,
3503 pub body: EnumDeclarationList<'tree>,
3504 pub name: Name<'tree>,
3505 pub children: ::std::vec::Vec<EnumDeclarationChildren<'tree>>,
3506}
3507impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
3508 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3509 fn from_node(
3510 node: ::treesitter_types::tree_sitter::Node<'tree>,
3511 src: &'tree [u8],
3512 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3513 debug_assert_eq!(node.kind(), "enum_declaration");
3514 Ok(Self {
3515 span: ::treesitter_types::Span::from(node),
3516 attributes: match node.child_by_field_name("attributes") {
3517 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3518 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
3519 })?),
3520 None => None,
3521 },
3522 body: {
3523 let child = node
3524 .child_by_field_name("body")
3525 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3526 ::treesitter_types::runtime::maybe_grow_stack(|| {
3527 <EnumDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
3528 })?
3529 },
3530 name: {
3531 let child = node
3532 .child_by_field_name("name")
3533 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3534 ::treesitter_types::runtime::maybe_grow_stack(|| {
3535 <Name as ::treesitter_types::FromNode>::from_node(child, src)
3536 })?
3537 },
3538 children: {
3539 #[allow(clippy::suspicious_else_formatting)]
3540 let non_field_children = {
3541 let mut cursor = node.walk();
3542 let mut result = ::std::vec::Vec::new();
3543 if cursor.goto_first_child() {
3544 loop {
3545 if cursor.field_name().is_none()
3546 && cursor.node().is_named()
3547 && !cursor.node().is_extra()
3548 {
3549 result.push(cursor.node());
3550 }
3551 if !cursor.goto_next_sibling() {
3552 break;
3553 }
3554 }
3555 }
3556 result
3557 };
3558 let mut items = ::std::vec::Vec::new();
3559 for child in non_field_children {
3560 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3561 <EnumDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3562 child, src,
3563 )
3564 })?);
3565 }
3566 items
3567 },
3568 })
3569 }
3570}
3571impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
3572 fn span(&self) -> ::treesitter_types::Span {
3573 self.span
3574 }
3575}
3576#[derive(Debug, Clone, PartialEq, Eq)]
3577pub struct EnumDeclarationList<'tree> {
3578 pub span: ::treesitter_types::Span,
3579 pub children: ::std::vec::Vec<EnumDeclarationListChildren<'tree>>,
3580}
3581impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationList<'tree> {
3582 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3583 fn from_node(
3584 node: ::treesitter_types::tree_sitter::Node<'tree>,
3585 src: &'tree [u8],
3586 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3587 debug_assert_eq!(node.kind(), "enum_declaration_list");
3588 Ok(Self {
3589 span: ::treesitter_types::Span::from(node),
3590 children: {
3591 #[allow(clippy::suspicious_else_formatting)]
3592 let non_field_children = {
3593 let mut cursor = node.walk();
3594 let mut result = ::std::vec::Vec::new();
3595 if cursor.goto_first_child() {
3596 loop {
3597 if cursor.field_name().is_none()
3598 && cursor.node().is_named()
3599 && !cursor.node().is_extra()
3600 {
3601 result.push(cursor.node());
3602 }
3603 if !cursor.goto_next_sibling() {
3604 break;
3605 }
3606 }
3607 }
3608 result
3609 };
3610 let mut items = ::std::vec::Vec::new();
3611 for child in non_field_children {
3612 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3613 <EnumDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3614 child, src,
3615 )
3616 })?);
3617 }
3618 items
3619 },
3620 })
3621 }
3622}
3623impl ::treesitter_types::Spanned for EnumDeclarationList<'_> {
3624 fn span(&self) -> ::treesitter_types::Span {
3625 self.span
3626 }
3627}
3628#[derive(Debug, Clone, PartialEq, Eq)]
3629pub struct ErrorSuppressionExpression<'tree> {
3630 pub span: ::treesitter_types::Span,
3631 pub children: Expression<'tree>,
3632}
3633impl<'tree> ::treesitter_types::FromNode<'tree> for ErrorSuppressionExpression<'tree> {
3634 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3635 fn from_node(
3636 node: ::treesitter_types::tree_sitter::Node<'tree>,
3637 src: &'tree [u8],
3638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3639 debug_assert_eq!(node.kind(), "error_suppression_expression");
3640 Ok(Self {
3641 span: ::treesitter_types::Span::from(node),
3642 children: {
3643 #[allow(clippy::suspicious_else_formatting)]
3644 let non_field_children = {
3645 let mut cursor = node.walk();
3646 let mut result = ::std::vec::Vec::new();
3647 if cursor.goto_first_child() {
3648 loop {
3649 if cursor.field_name().is_none()
3650 && cursor.node().is_named()
3651 && !cursor.node().is_extra()
3652 {
3653 result.push(cursor.node());
3654 }
3655 if !cursor.goto_next_sibling() {
3656 break;
3657 }
3658 }
3659 }
3660 result
3661 };
3662 let child = if let Some(&c) = non_field_children.first() {
3663 c
3664 } else {
3665 let mut fallback_cursor = node.walk();
3666 let mut fallback_child = None;
3667 if fallback_cursor.goto_first_child() {
3668 loop {
3669 if fallback_cursor.field_name().is_none()
3670 && !fallback_cursor.node().is_extra()
3671 {
3672 let candidate = fallback_cursor.node();
3673 #[allow(clippy::needless_question_mark)]
3674 if (|| -> ::core::result::Result<
3675 _,
3676 ::treesitter_types::ParseError,
3677 > {
3678 let child = candidate;
3679 Ok(
3680 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3681 child,
3682 src,
3683 ))?,
3684 )
3685 })()
3686 .is_ok()
3687 {
3688 fallback_child = Some(candidate);
3689 break;
3690 }
3691 }
3692 if !fallback_cursor.goto_next_sibling() {
3693 break;
3694 }
3695 }
3696 }
3697 if fallback_child.is_none() {
3698 let mut cursor2 = node.walk();
3699 if cursor2.goto_first_child() {
3700 loop {
3701 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3702 let candidate = cursor2.node();
3703 #[allow(clippy::needless_question_mark)]
3704 if (|| -> ::core::result::Result<
3705 _,
3706 ::treesitter_types::ParseError,
3707 > {
3708 let child = candidate;
3709 Ok(
3710 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3711 child,
3712 src,
3713 ))?,
3714 )
3715 })()
3716 .is_ok()
3717 {
3718 fallback_child = Some(candidate);
3719 break;
3720 }
3721 }
3722 if !cursor2.goto_next_sibling() {
3723 break;
3724 }
3725 }
3726 }
3727 }
3728 fallback_child.ok_or_else(|| {
3729 ::treesitter_types::ParseError::missing_field("children", node)
3730 })?
3731 };
3732 ::treesitter_types::runtime::maybe_grow_stack(|| {
3733 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3734 })?
3735 },
3736 })
3737 }
3738}
3739impl ::treesitter_types::Spanned for ErrorSuppressionExpression<'_> {
3740 fn span(&self) -> ::treesitter_types::Span {
3741 self.span
3742 }
3743}
3744#[derive(Debug, Clone, PartialEq, Eq)]
3745pub struct ExitStatement<'tree> {
3746 pub span: ::treesitter_types::Span,
3747 pub children: ::core::option::Option<Expression<'tree>>,
3748}
3749impl<'tree> ::treesitter_types::FromNode<'tree> for ExitStatement<'tree> {
3750 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3751 fn from_node(
3752 node: ::treesitter_types::tree_sitter::Node<'tree>,
3753 src: &'tree [u8],
3754 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3755 debug_assert_eq!(node.kind(), "exit_statement");
3756 Ok(Self {
3757 span: ::treesitter_types::Span::from(node),
3758 children: {
3759 #[allow(clippy::suspicious_else_formatting)]
3760 let non_field_children = {
3761 let mut cursor = node.walk();
3762 let mut result = ::std::vec::Vec::new();
3763 if cursor.goto_first_child() {
3764 loop {
3765 if cursor.field_name().is_none()
3766 && cursor.node().is_named()
3767 && !cursor.node().is_extra()
3768 {
3769 result.push(cursor.node());
3770 }
3771 if !cursor.goto_next_sibling() {
3772 break;
3773 }
3774 }
3775 }
3776 result
3777 };
3778 match non_field_children.first() {
3779 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3780 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3781 })?),
3782 None => None,
3783 }
3784 },
3785 })
3786 }
3787}
3788impl ::treesitter_types::Spanned for ExitStatement<'_> {
3789 fn span(&self) -> ::treesitter_types::Span {
3790 self.span
3791 }
3792}
3793#[derive(Debug, Clone, PartialEq, Eq)]
3794pub struct ExpressionStatement<'tree> {
3795 pub span: ::treesitter_types::Span,
3796 pub children: Expression<'tree>,
3797}
3798impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3799 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3800 fn from_node(
3801 node: ::treesitter_types::tree_sitter::Node<'tree>,
3802 src: &'tree [u8],
3803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3804 debug_assert_eq!(node.kind(), "expression_statement");
3805 Ok(Self {
3806 span: ::treesitter_types::Span::from(node),
3807 children: {
3808 #[allow(clippy::suspicious_else_formatting)]
3809 let non_field_children = {
3810 let mut cursor = node.walk();
3811 let mut result = ::std::vec::Vec::new();
3812 if cursor.goto_first_child() {
3813 loop {
3814 if cursor.field_name().is_none()
3815 && cursor.node().is_named()
3816 && !cursor.node().is_extra()
3817 {
3818 result.push(cursor.node());
3819 }
3820 if !cursor.goto_next_sibling() {
3821 break;
3822 }
3823 }
3824 }
3825 result
3826 };
3827 let child = if let Some(&c) = non_field_children.first() {
3828 c
3829 } else {
3830 let mut fallback_cursor = node.walk();
3831 let mut fallback_child = None;
3832 if fallback_cursor.goto_first_child() {
3833 loop {
3834 if fallback_cursor.field_name().is_none()
3835 && !fallback_cursor.node().is_extra()
3836 {
3837 let candidate = fallback_cursor.node();
3838 #[allow(clippy::needless_question_mark)]
3839 if (|| -> ::core::result::Result<
3840 _,
3841 ::treesitter_types::ParseError,
3842 > {
3843 let child = candidate;
3844 Ok(
3845 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3846 child,
3847 src,
3848 ))?,
3849 )
3850 })()
3851 .is_ok()
3852 {
3853 fallback_child = Some(candidate);
3854 break;
3855 }
3856 }
3857 if !fallback_cursor.goto_next_sibling() {
3858 break;
3859 }
3860 }
3861 }
3862 if fallback_child.is_none() {
3863 let mut cursor2 = node.walk();
3864 if cursor2.goto_first_child() {
3865 loop {
3866 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3867 let candidate = cursor2.node();
3868 #[allow(clippy::needless_question_mark)]
3869 if (|| -> ::core::result::Result<
3870 _,
3871 ::treesitter_types::ParseError,
3872 > {
3873 let child = candidate;
3874 Ok(
3875 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
3876 child,
3877 src,
3878 ))?,
3879 )
3880 })()
3881 .is_ok()
3882 {
3883 fallback_child = Some(candidate);
3884 break;
3885 }
3886 }
3887 if !cursor2.goto_next_sibling() {
3888 break;
3889 }
3890 }
3891 }
3892 }
3893 fallback_child.ok_or_else(|| {
3894 ::treesitter_types::ParseError::missing_field("children", node)
3895 })?
3896 };
3897 ::treesitter_types::runtime::maybe_grow_stack(|| {
3898 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
3899 })?
3900 },
3901 })
3902 }
3903}
3904impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3905 fn span(&self) -> ::treesitter_types::Span {
3906 self.span
3907 }
3908}
3909#[derive(Debug, Clone, PartialEq, Eq)]
3910pub struct FinalModifier<'tree> {
3911 pub span: ::treesitter_types::Span,
3912 text: &'tree str,
3913}
3914impl<'tree> ::treesitter_types::FromNode<'tree> for FinalModifier<'tree> {
3915 fn from_node(
3916 node: ::treesitter_types::tree_sitter::Node<'tree>,
3917 src: &'tree [u8],
3918 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3919 debug_assert_eq!(node.kind(), "final_modifier");
3920 Ok(Self {
3921 span: ::treesitter_types::Span::from(node),
3922 text: node.utf8_text(src)?,
3923 })
3924 }
3925}
3926impl<'tree> ::treesitter_types::LeafNode<'tree> for FinalModifier<'tree> {
3927 fn text(&self) -> &'tree str {
3928 self.text
3929 }
3930}
3931impl ::treesitter_types::Spanned for FinalModifier<'_> {
3932 fn span(&self) -> ::treesitter_types::Span {
3933 self.span
3934 }
3935}
3936#[derive(Debug, Clone, PartialEq, Eq)]
3937pub struct FinallyClause<'tree> {
3938 pub span: ::treesitter_types::Span,
3939 pub body: CompoundStatement<'tree>,
3940}
3941impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3942 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3943 fn from_node(
3944 node: ::treesitter_types::tree_sitter::Node<'tree>,
3945 src: &'tree [u8],
3946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3947 debug_assert_eq!(node.kind(), "finally_clause");
3948 Ok(Self {
3949 span: ::treesitter_types::Span::from(node),
3950 body: {
3951 let child = node
3952 .child_by_field_name("body")
3953 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3954 ::treesitter_types::runtime::maybe_grow_stack(|| {
3955 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
3956 })?
3957 },
3958 })
3959 }
3960}
3961impl ::treesitter_types::Spanned for FinallyClause<'_> {
3962 fn span(&self) -> ::treesitter_types::Span {
3963 self.span
3964 }
3965}
3966#[derive(Debug, Clone, PartialEq, Eq)]
3967pub struct ForStatement<'tree> {
3968 pub span: ::treesitter_types::Span,
3969 pub body: ::std::vec::Vec<Statement<'tree>>,
3970 pub condition: ::core::option::Option<ForStatementCondition<'tree>>,
3971 pub initialize: ::core::option::Option<ForStatementInitialize<'tree>>,
3972 pub update: ::core::option::Option<ForStatementUpdate<'tree>>,
3973}
3974impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3975 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3976 fn from_node(
3977 node: ::treesitter_types::tree_sitter::Node<'tree>,
3978 src: &'tree [u8],
3979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3980 debug_assert_eq!(node.kind(), "for_statement");
3981 Ok(Self {
3982 span: ::treesitter_types::Span::from(node),
3983 body: {
3984 let mut cursor = node.walk();
3985 let mut items = ::std::vec::Vec::new();
3986 for child in node.children_by_field_name("body", &mut cursor) {
3987 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3988 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3989 })?);
3990 }
3991 items
3992 },
3993 condition: match node.child_by_field_name("condition") {
3994 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3995 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(child, src)
3996 })?),
3997 None => None,
3998 },
3999 initialize: match node.child_by_field_name("initialize") {
4000 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4001 <ForStatementInitialize as ::treesitter_types::FromNode>::from_node(child, src)
4002 })?),
4003 None => None,
4004 },
4005 update: match node.child_by_field_name("update") {
4006 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4007 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)
4008 })?),
4009 None => None,
4010 },
4011 })
4012 }
4013}
4014impl ::treesitter_types::Spanned for ForStatement<'_> {
4015 fn span(&self) -> ::treesitter_types::Span {
4016 self.span
4017 }
4018}
4019#[derive(Debug, Clone, PartialEq, Eq)]
4020pub struct ForeachStatement<'tree> {
4021 pub span: ::treesitter_types::Span,
4022 pub body: ::core::option::Option<ForeachStatementBody<'tree>>,
4023 pub children: ::std::vec::Vec<ForeachStatementChildren<'tree>>,
4024}
4025impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatement<'tree> {
4026 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4027 fn from_node(
4028 node: ::treesitter_types::tree_sitter::Node<'tree>,
4029 src: &'tree [u8],
4030 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4031 debug_assert_eq!(node.kind(), "foreach_statement");
4032 Ok(Self {
4033 span: ::treesitter_types::Span::from(node),
4034 body: match node.child_by_field_name("body") {
4035 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4036 <ForeachStatementBody as ::treesitter_types::FromNode>::from_node(child, src)
4037 })?),
4038 None => None,
4039 },
4040 children: {
4041 #[allow(clippy::suspicious_else_formatting)]
4042 let non_field_children = {
4043 let mut cursor = node.walk();
4044 let mut result = ::std::vec::Vec::new();
4045 if cursor.goto_first_child() {
4046 loop {
4047 if cursor.field_name().is_none()
4048 && cursor.node().is_named()
4049 && !cursor.node().is_extra()
4050 {
4051 result.push(cursor.node());
4052 }
4053 if !cursor.goto_next_sibling() {
4054 break;
4055 }
4056 }
4057 }
4058 result
4059 };
4060 let mut items = ::std::vec::Vec::new();
4061 for child in non_field_children {
4062 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4063 <ForeachStatementChildren as ::treesitter_types::FromNode>::from_node(
4064 child, src,
4065 )
4066 })?);
4067 }
4068 items
4069 },
4070 })
4071 }
4072}
4073impl ::treesitter_types::Spanned for ForeachStatement<'_> {
4074 fn span(&self) -> ::treesitter_types::Span {
4075 self.span
4076 }
4077}
4078#[derive(Debug, Clone, PartialEq, Eq)]
4079pub struct FormalParameters<'tree> {
4080 pub span: ::treesitter_types::Span,
4081 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
4082}
4083impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
4084 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4085 fn from_node(
4086 node: ::treesitter_types::tree_sitter::Node<'tree>,
4087 src: &'tree [u8],
4088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4089 debug_assert_eq!(node.kind(), "formal_parameters");
4090 Ok(Self {
4091 span: ::treesitter_types::Span::from(node),
4092 children: {
4093 #[allow(clippy::suspicious_else_formatting)]
4094 let non_field_children = {
4095 let mut cursor = node.walk();
4096 let mut result = ::std::vec::Vec::new();
4097 if cursor.goto_first_child() {
4098 loop {
4099 if cursor.field_name().is_none()
4100 && cursor.node().is_named()
4101 && !cursor.node().is_extra()
4102 {
4103 result.push(cursor.node());
4104 }
4105 if !cursor.goto_next_sibling() {
4106 break;
4107 }
4108 }
4109 }
4110 result
4111 };
4112 let mut items = ::std::vec::Vec::new();
4113 for child in non_field_children {
4114 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4115 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
4116 child, src,
4117 )
4118 })?);
4119 }
4120 items
4121 },
4122 })
4123 }
4124}
4125impl ::treesitter_types::Spanned for FormalParameters<'_> {
4126 fn span(&self) -> ::treesitter_types::Span {
4127 self.span
4128 }
4129}
4130#[derive(Debug, Clone, PartialEq, Eq)]
4131pub struct FunctionCallExpression<'tree> {
4132 pub span: ::treesitter_types::Span,
4133 pub arguments: Arguments<'tree>,
4134 pub function: FunctionCallExpressionFunction<'tree>,
4135}
4136impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCallExpression<'tree> {
4137 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4138 fn from_node(
4139 node: ::treesitter_types::tree_sitter::Node<'tree>,
4140 src: &'tree [u8],
4141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4142 debug_assert_eq!(node.kind(), "function_call_expression");
4143 Ok(Self {
4144 span: ::treesitter_types::Span::from(node),
4145 arguments: {
4146 let child = node.child_by_field_name("arguments").ok_or_else(|| {
4147 ::treesitter_types::ParseError::missing_field("arguments", node)
4148 })?;
4149 ::treesitter_types::runtime::maybe_grow_stack(|| {
4150 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
4151 })?
4152 },
4153 function: {
4154 let child = node.child_by_field_name("function").ok_or_else(|| {
4155 ::treesitter_types::ParseError::missing_field("function", node)
4156 })?;
4157 ::treesitter_types::runtime::maybe_grow_stack(|| {
4158 <FunctionCallExpressionFunction as ::treesitter_types::FromNode>::from_node(
4159 child, src,
4160 )
4161 })?
4162 },
4163 })
4164 }
4165}
4166impl ::treesitter_types::Spanned for FunctionCallExpression<'_> {
4167 fn span(&self) -> ::treesitter_types::Span {
4168 self.span
4169 }
4170}
4171#[derive(Debug, Clone, PartialEq, Eq)]
4172pub struct FunctionDefinition<'tree> {
4173 pub span: ::treesitter_types::Span,
4174 pub attributes: ::core::option::Option<AttributeList<'tree>>,
4175 pub body: CompoundStatement<'tree>,
4176 pub name: Name<'tree>,
4177 pub parameters: FormalParameters<'tree>,
4178 pub return_type: ::core::option::Option<FunctionDefinitionReturnType<'tree>>,
4179 pub children: ::core::option::Option<ReferenceModifier<'tree>>,
4180}
4181impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
4182 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4183 fn from_node(
4184 node: ::treesitter_types::tree_sitter::Node<'tree>,
4185 src: &'tree [u8],
4186 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4187 debug_assert_eq!(node.kind(), "function_definition");
4188 Ok(Self {
4189 span: ::treesitter_types::Span::from(node),
4190 attributes: match node.child_by_field_name("attributes") {
4191 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4192 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
4193 })?),
4194 None => None,
4195 },
4196 body: {
4197 let child = node
4198 .child_by_field_name("body")
4199 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4200 ::treesitter_types::runtime::maybe_grow_stack(|| {
4201 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
4202 })?
4203 },
4204 name: {
4205 let child = node
4206 .child_by_field_name("name")
4207 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4208 ::treesitter_types::runtime::maybe_grow_stack(|| {
4209 <Name as ::treesitter_types::FromNode>::from_node(child, src)
4210 })?
4211 },
4212 parameters: {
4213 let child = node.child_by_field_name("parameters").ok_or_else(|| {
4214 ::treesitter_types::ParseError::missing_field("parameters", node)
4215 })?;
4216 ::treesitter_types::runtime::maybe_grow_stack(|| {
4217 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
4218 })?
4219 },
4220 return_type: match node.child_by_field_name("return_type") {
4221 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4222 <FunctionDefinitionReturnType as ::treesitter_types::FromNode>::from_node(
4223 child, src,
4224 )
4225 })?),
4226 None => None,
4227 },
4228 children: {
4229 #[allow(clippy::suspicious_else_formatting)]
4230 let non_field_children = {
4231 let mut cursor = node.walk();
4232 let mut result = ::std::vec::Vec::new();
4233 if cursor.goto_first_child() {
4234 loop {
4235 if cursor.field_name().is_none()
4236 && cursor.node().is_named()
4237 && !cursor.node().is_extra()
4238 {
4239 result.push(cursor.node());
4240 }
4241 if !cursor.goto_next_sibling() {
4242 break;
4243 }
4244 }
4245 }
4246 result
4247 };
4248 match non_field_children.first() {
4249 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4250 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
4251 })?),
4252 None => None,
4253 }
4254 },
4255 })
4256 }
4257}
4258impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
4259 fn span(&self) -> ::treesitter_types::Span {
4260 self.span
4261 }
4262}
4263#[derive(Debug, Clone, PartialEq, Eq)]
4264pub struct FunctionStaticDeclaration<'tree> {
4265 pub span: ::treesitter_types::Span,
4266 pub children: ::std::vec::Vec<StaticVariableDeclaration<'tree>>,
4267}
4268impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionStaticDeclaration<'tree> {
4269 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4270 fn from_node(
4271 node: ::treesitter_types::tree_sitter::Node<'tree>,
4272 src: &'tree [u8],
4273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4274 debug_assert_eq!(node.kind(), "function_static_declaration");
4275 Ok(Self {
4276 span: ::treesitter_types::Span::from(node),
4277 children: {
4278 #[allow(clippy::suspicious_else_formatting)]
4279 let non_field_children = {
4280 let mut cursor = node.walk();
4281 let mut result = ::std::vec::Vec::new();
4282 if cursor.goto_first_child() {
4283 loop {
4284 if cursor.field_name().is_none()
4285 && cursor.node().is_named()
4286 && !cursor.node().is_extra()
4287 {
4288 result.push(cursor.node());
4289 }
4290 if !cursor.goto_next_sibling() {
4291 break;
4292 }
4293 }
4294 }
4295 result
4296 };
4297 let mut items = ::std::vec::Vec::new();
4298 for child in non_field_children {
4299 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4300 <StaticVariableDeclaration as ::treesitter_types::FromNode>::from_node(
4301 child, src,
4302 )
4303 })?);
4304 }
4305 items
4306 },
4307 })
4308 }
4309}
4310impl ::treesitter_types::Spanned for FunctionStaticDeclaration<'_> {
4311 fn span(&self) -> ::treesitter_types::Span {
4312 self.span
4313 }
4314}
4315#[derive(Debug, Clone, PartialEq, Eq)]
4316pub struct GlobalDeclaration<'tree> {
4317 pub span: ::treesitter_types::Span,
4318 pub children: ::std::vec::Vec<GlobalDeclarationChildren<'tree>>,
4319}
4320impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalDeclaration<'tree> {
4321 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4322 fn from_node(
4323 node: ::treesitter_types::tree_sitter::Node<'tree>,
4324 src: &'tree [u8],
4325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4326 debug_assert_eq!(node.kind(), "global_declaration");
4327 Ok(Self {
4328 span: ::treesitter_types::Span::from(node),
4329 children: {
4330 #[allow(clippy::suspicious_else_formatting)]
4331 let non_field_children = {
4332 let mut cursor = node.walk();
4333 let mut result = ::std::vec::Vec::new();
4334 if cursor.goto_first_child() {
4335 loop {
4336 if cursor.field_name().is_none()
4337 && cursor.node().is_named()
4338 && !cursor.node().is_extra()
4339 {
4340 result.push(cursor.node());
4341 }
4342 if !cursor.goto_next_sibling() {
4343 break;
4344 }
4345 }
4346 }
4347 result
4348 };
4349 let mut items = ::std::vec::Vec::new();
4350 for child in non_field_children {
4351 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4352 <GlobalDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4353 child, src,
4354 )
4355 })?);
4356 }
4357 items
4358 },
4359 })
4360 }
4361}
4362impl ::treesitter_types::Spanned for GlobalDeclaration<'_> {
4363 fn span(&self) -> ::treesitter_types::Span {
4364 self.span
4365 }
4366}
4367#[derive(Debug, Clone, PartialEq, Eq)]
4368pub struct GotoStatement<'tree> {
4369 pub span: ::treesitter_types::Span,
4370 pub children: Name<'tree>,
4371}
4372impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
4373 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4374 fn from_node(
4375 node: ::treesitter_types::tree_sitter::Node<'tree>,
4376 src: &'tree [u8],
4377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4378 debug_assert_eq!(node.kind(), "goto_statement");
4379 Ok(Self {
4380 span: ::treesitter_types::Span::from(node),
4381 children: {
4382 #[allow(clippy::suspicious_else_formatting)]
4383 let non_field_children = {
4384 let mut cursor = node.walk();
4385 let mut result = ::std::vec::Vec::new();
4386 if cursor.goto_first_child() {
4387 loop {
4388 if cursor.field_name().is_none()
4389 && cursor.node().is_named()
4390 && !cursor.node().is_extra()
4391 {
4392 result.push(cursor.node());
4393 }
4394 if !cursor.goto_next_sibling() {
4395 break;
4396 }
4397 }
4398 }
4399 result
4400 };
4401 let child = if let Some(&c) = non_field_children.first() {
4402 c
4403 } else {
4404 let mut fallback_cursor = node.walk();
4405 let mut fallback_child = None;
4406 if fallback_cursor.goto_first_child() {
4407 loop {
4408 if fallback_cursor.field_name().is_none()
4409 && !fallback_cursor.node().is_extra()
4410 {
4411 let candidate = fallback_cursor.node();
4412 #[allow(clippy::needless_question_mark)]
4413 if (|| -> ::core::result::Result<
4414 _,
4415 ::treesitter_types::ParseError,
4416 > {
4417 let child = candidate;
4418 Ok(
4419 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
4420 child,
4421 src,
4422 ))?,
4423 )
4424 })()
4425 .is_ok()
4426 {
4427 fallback_child = Some(candidate);
4428 break;
4429 }
4430 }
4431 if !fallback_cursor.goto_next_sibling() {
4432 break;
4433 }
4434 }
4435 }
4436 if fallback_child.is_none() {
4437 let mut cursor2 = node.walk();
4438 if cursor2.goto_first_child() {
4439 loop {
4440 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4441 let candidate = cursor2.node();
4442 #[allow(clippy::needless_question_mark)]
4443 if (|| -> ::core::result::Result<
4444 _,
4445 ::treesitter_types::ParseError,
4446 > {
4447 let child = candidate;
4448 Ok(
4449 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
4450 child,
4451 src,
4452 ))?,
4453 )
4454 })()
4455 .is_ok()
4456 {
4457 fallback_child = Some(candidate);
4458 break;
4459 }
4460 }
4461 if !cursor2.goto_next_sibling() {
4462 break;
4463 }
4464 }
4465 }
4466 }
4467 fallback_child.ok_or_else(|| {
4468 ::treesitter_types::ParseError::missing_field("children", node)
4469 })?
4470 };
4471 ::treesitter_types::runtime::maybe_grow_stack(|| {
4472 <Name as ::treesitter_types::FromNode>::from_node(child, src)
4473 })?
4474 },
4475 })
4476 }
4477}
4478impl ::treesitter_types::Spanned for GotoStatement<'_> {
4479 fn span(&self) -> ::treesitter_types::Span {
4480 self.span
4481 }
4482}
4483#[derive(Debug, Clone, PartialEq, Eq)]
4484pub struct Heredoc<'tree> {
4485 pub span: ::treesitter_types::Span,
4486 pub end_tag: HeredocEnd<'tree>,
4487 pub identifier: HeredocStart<'tree>,
4488 pub value: ::core::option::Option<HeredocBody<'tree>>,
4489}
4490impl<'tree> ::treesitter_types::FromNode<'tree> for Heredoc<'tree> {
4491 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4492 fn from_node(
4493 node: ::treesitter_types::tree_sitter::Node<'tree>,
4494 src: &'tree [u8],
4495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4496 debug_assert_eq!(node.kind(), "heredoc");
4497 Ok(Self {
4498 span: ::treesitter_types::Span::from(node),
4499 end_tag: {
4500 let child = node.child_by_field_name("end_tag").ok_or_else(|| {
4501 ::treesitter_types::ParseError::missing_field("end_tag", node)
4502 })?;
4503 ::treesitter_types::runtime::maybe_grow_stack(|| {
4504 <HeredocEnd as ::treesitter_types::FromNode>::from_node(child, src)
4505 })?
4506 },
4507 identifier: {
4508 let child = node.child_by_field_name("identifier").ok_or_else(|| {
4509 ::treesitter_types::ParseError::missing_field("identifier", node)
4510 })?;
4511 ::treesitter_types::runtime::maybe_grow_stack(|| {
4512 <HeredocStart as ::treesitter_types::FromNode>::from_node(child, src)
4513 })?
4514 },
4515 value: match node.child_by_field_name("value") {
4516 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4517 <HeredocBody as ::treesitter_types::FromNode>::from_node(child, src)
4518 })?),
4519 None => None,
4520 },
4521 })
4522 }
4523}
4524impl ::treesitter_types::Spanned for Heredoc<'_> {
4525 fn span(&self) -> ::treesitter_types::Span {
4526 self.span
4527 }
4528}
4529#[derive(Debug, Clone, PartialEq, Eq)]
4530pub struct HeredocBody<'tree> {
4531 pub span: ::treesitter_types::Span,
4532 pub children: ::std::vec::Vec<HeredocBodyChildren<'tree>>,
4533}
4534impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBody<'tree> {
4535 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4536 fn from_node(
4537 node: ::treesitter_types::tree_sitter::Node<'tree>,
4538 src: &'tree [u8],
4539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4540 debug_assert_eq!(node.kind(), "heredoc_body");
4541 Ok(Self {
4542 span: ::treesitter_types::Span::from(node),
4543 children: {
4544 #[allow(clippy::suspicious_else_formatting)]
4545 let non_field_children = {
4546 let mut cursor = node.walk();
4547 let mut result = ::std::vec::Vec::new();
4548 if cursor.goto_first_child() {
4549 loop {
4550 if cursor.field_name().is_none()
4551 && cursor.node().is_named()
4552 && !cursor.node().is_extra()
4553 {
4554 result.push(cursor.node());
4555 }
4556 if !cursor.goto_next_sibling() {
4557 break;
4558 }
4559 }
4560 }
4561 result
4562 };
4563 let mut items = ::std::vec::Vec::new();
4564 for child in non_field_children {
4565 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4566 <HeredocBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)
4567 })?);
4568 }
4569 items
4570 },
4571 })
4572 }
4573}
4574impl ::treesitter_types::Spanned for HeredocBody<'_> {
4575 fn span(&self) -> ::treesitter_types::Span {
4576 self.span
4577 }
4578}
4579#[derive(Debug, Clone, PartialEq, Eq)]
4580pub struct IfStatement<'tree> {
4581 pub span: ::treesitter_types::Span,
4582 pub alternative: ::std::vec::Vec<IfStatementAlternative<'tree>>,
4583 pub body: IfStatementBody<'tree>,
4584 pub condition: ParenthesizedExpression<'tree>,
4585}
4586impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
4587 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4588 fn from_node(
4589 node: ::treesitter_types::tree_sitter::Node<'tree>,
4590 src: &'tree [u8],
4591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4592 debug_assert_eq!(node.kind(), "if_statement");
4593 Ok(Self {
4594 span: ::treesitter_types::Span::from(node),
4595 alternative: {
4596 let mut cursor = node.walk();
4597 let mut items = ::std::vec::Vec::new();
4598 for child in node.children_by_field_name("alternative", &mut cursor) {
4599 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4600 <IfStatementAlternative as ::treesitter_types::FromNode>::from_node(
4601 child, src,
4602 )
4603 })?);
4604 }
4605 items
4606 },
4607 body: {
4608 let child = node
4609 .child_by_field_name("body")
4610 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4611 ::treesitter_types::runtime::maybe_grow_stack(|| {
4612 <IfStatementBody as ::treesitter_types::FromNode>::from_node(child, src)
4613 })?
4614 },
4615 condition: {
4616 let child = node.child_by_field_name("condition").ok_or_else(|| {
4617 ::treesitter_types::ParseError::missing_field("condition", node)
4618 })?;
4619 ::treesitter_types::runtime::maybe_grow_stack(|| {
4620 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
4621 })?
4622 },
4623 })
4624 }
4625}
4626impl ::treesitter_types::Spanned for IfStatement<'_> {
4627 fn span(&self) -> ::treesitter_types::Span {
4628 self.span
4629 }
4630}
4631#[derive(Debug, Clone, PartialEq, Eq)]
4632pub struct IncludeExpression<'tree> {
4633 pub span: ::treesitter_types::Span,
4634 pub children: Expression<'tree>,
4635}
4636impl<'tree> ::treesitter_types::FromNode<'tree> for IncludeExpression<'tree> {
4637 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4638 fn from_node(
4639 node: ::treesitter_types::tree_sitter::Node<'tree>,
4640 src: &'tree [u8],
4641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4642 debug_assert_eq!(node.kind(), "include_expression");
4643 Ok(Self {
4644 span: ::treesitter_types::Span::from(node),
4645 children: {
4646 #[allow(clippy::suspicious_else_formatting)]
4647 let non_field_children = {
4648 let mut cursor = node.walk();
4649 let mut result = ::std::vec::Vec::new();
4650 if cursor.goto_first_child() {
4651 loop {
4652 if cursor.field_name().is_none()
4653 && cursor.node().is_named()
4654 && !cursor.node().is_extra()
4655 {
4656 result.push(cursor.node());
4657 }
4658 if !cursor.goto_next_sibling() {
4659 break;
4660 }
4661 }
4662 }
4663 result
4664 };
4665 let child = if let Some(&c) = non_field_children.first() {
4666 c
4667 } else {
4668 let mut fallback_cursor = node.walk();
4669 let mut fallback_child = None;
4670 if fallback_cursor.goto_first_child() {
4671 loop {
4672 if fallback_cursor.field_name().is_none()
4673 && !fallback_cursor.node().is_extra()
4674 {
4675 let candidate = fallback_cursor.node();
4676 #[allow(clippy::needless_question_mark)]
4677 if (|| -> ::core::result::Result<
4678 _,
4679 ::treesitter_types::ParseError,
4680 > {
4681 let child = candidate;
4682 Ok(
4683 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4684 child,
4685 src,
4686 ))?,
4687 )
4688 })()
4689 .is_ok()
4690 {
4691 fallback_child = Some(candidate);
4692 break;
4693 }
4694 }
4695 if !fallback_cursor.goto_next_sibling() {
4696 break;
4697 }
4698 }
4699 }
4700 if fallback_child.is_none() {
4701 let mut cursor2 = node.walk();
4702 if cursor2.goto_first_child() {
4703 loop {
4704 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4705 let candidate = cursor2.node();
4706 #[allow(clippy::needless_question_mark)]
4707 if (|| -> ::core::result::Result<
4708 _,
4709 ::treesitter_types::ParseError,
4710 > {
4711 let child = candidate;
4712 Ok(
4713 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4714 child,
4715 src,
4716 ))?,
4717 )
4718 })()
4719 .is_ok()
4720 {
4721 fallback_child = Some(candidate);
4722 break;
4723 }
4724 }
4725 if !cursor2.goto_next_sibling() {
4726 break;
4727 }
4728 }
4729 }
4730 }
4731 fallback_child.ok_or_else(|| {
4732 ::treesitter_types::ParseError::missing_field("children", node)
4733 })?
4734 };
4735 ::treesitter_types::runtime::maybe_grow_stack(|| {
4736 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4737 })?
4738 },
4739 })
4740 }
4741}
4742impl ::treesitter_types::Spanned for IncludeExpression<'_> {
4743 fn span(&self) -> ::treesitter_types::Span {
4744 self.span
4745 }
4746}
4747#[derive(Debug, Clone, PartialEq, Eq)]
4748pub struct IncludeOnceExpression<'tree> {
4749 pub span: ::treesitter_types::Span,
4750 pub children: Expression<'tree>,
4751}
4752impl<'tree> ::treesitter_types::FromNode<'tree> for IncludeOnceExpression<'tree> {
4753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4754 fn from_node(
4755 node: ::treesitter_types::tree_sitter::Node<'tree>,
4756 src: &'tree [u8],
4757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4758 debug_assert_eq!(node.kind(), "include_once_expression");
4759 Ok(Self {
4760 span: ::treesitter_types::Span::from(node),
4761 children: {
4762 #[allow(clippy::suspicious_else_formatting)]
4763 let non_field_children = {
4764 let mut cursor = node.walk();
4765 let mut result = ::std::vec::Vec::new();
4766 if cursor.goto_first_child() {
4767 loop {
4768 if cursor.field_name().is_none()
4769 && cursor.node().is_named()
4770 && !cursor.node().is_extra()
4771 {
4772 result.push(cursor.node());
4773 }
4774 if !cursor.goto_next_sibling() {
4775 break;
4776 }
4777 }
4778 }
4779 result
4780 };
4781 let child = if let Some(&c) = non_field_children.first() {
4782 c
4783 } else {
4784 let mut fallback_cursor = node.walk();
4785 let mut fallback_child = None;
4786 if fallback_cursor.goto_first_child() {
4787 loop {
4788 if fallback_cursor.field_name().is_none()
4789 && !fallback_cursor.node().is_extra()
4790 {
4791 let candidate = fallback_cursor.node();
4792 #[allow(clippy::needless_question_mark)]
4793 if (|| -> ::core::result::Result<
4794 _,
4795 ::treesitter_types::ParseError,
4796 > {
4797 let child = candidate;
4798 Ok(
4799 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4800 child,
4801 src,
4802 ))?,
4803 )
4804 })()
4805 .is_ok()
4806 {
4807 fallback_child = Some(candidate);
4808 break;
4809 }
4810 }
4811 if !fallback_cursor.goto_next_sibling() {
4812 break;
4813 }
4814 }
4815 }
4816 if fallback_child.is_none() {
4817 let mut cursor2 = node.walk();
4818 if cursor2.goto_first_child() {
4819 loop {
4820 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4821 let candidate = cursor2.node();
4822 #[allow(clippy::needless_question_mark)]
4823 if (|| -> ::core::result::Result<
4824 _,
4825 ::treesitter_types::ParseError,
4826 > {
4827 let child = candidate;
4828 Ok(
4829 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
4830 child,
4831 src,
4832 ))?,
4833 )
4834 })()
4835 .is_ok()
4836 {
4837 fallback_child = Some(candidate);
4838 break;
4839 }
4840 }
4841 if !cursor2.goto_next_sibling() {
4842 break;
4843 }
4844 }
4845 }
4846 }
4847 fallback_child.ok_or_else(|| {
4848 ::treesitter_types::ParseError::missing_field("children", node)
4849 })?
4850 };
4851 ::treesitter_types::runtime::maybe_grow_stack(|| {
4852 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
4853 })?
4854 },
4855 })
4856 }
4857}
4858impl ::treesitter_types::Spanned for IncludeOnceExpression<'_> {
4859 fn span(&self) -> ::treesitter_types::Span {
4860 self.span
4861 }
4862}
4863#[derive(Debug, Clone, PartialEq, Eq)]
4864pub struct InterfaceDeclaration<'tree> {
4865 pub span: ::treesitter_types::Span,
4866 pub attributes: ::core::option::Option<AttributeList<'tree>>,
4867 pub body: DeclarationList<'tree>,
4868 pub name: Name<'tree>,
4869 pub children: ::core::option::Option<BaseClause<'tree>>,
4870}
4871impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
4872 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4873 fn from_node(
4874 node: ::treesitter_types::tree_sitter::Node<'tree>,
4875 src: &'tree [u8],
4876 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4877 debug_assert_eq!(node.kind(), "interface_declaration");
4878 Ok(Self {
4879 span: ::treesitter_types::Span::from(node),
4880 attributes: match node.child_by_field_name("attributes") {
4881 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4882 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
4883 })?),
4884 None => None,
4885 },
4886 body: {
4887 let child = node
4888 .child_by_field_name("body")
4889 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4890 ::treesitter_types::runtime::maybe_grow_stack(|| {
4891 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
4892 })?
4893 },
4894 name: {
4895 let child = node
4896 .child_by_field_name("name")
4897 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4898 ::treesitter_types::runtime::maybe_grow_stack(|| {
4899 <Name as ::treesitter_types::FromNode>::from_node(child, src)
4900 })?
4901 },
4902 children: {
4903 #[allow(clippy::suspicious_else_formatting)]
4904 let non_field_children = {
4905 let mut cursor = node.walk();
4906 let mut result = ::std::vec::Vec::new();
4907 if cursor.goto_first_child() {
4908 loop {
4909 if cursor.field_name().is_none()
4910 && cursor.node().is_named()
4911 && !cursor.node().is_extra()
4912 {
4913 result.push(cursor.node());
4914 }
4915 if !cursor.goto_next_sibling() {
4916 break;
4917 }
4918 }
4919 }
4920 result
4921 };
4922 match non_field_children.first() {
4923 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4924 <BaseClause as ::treesitter_types::FromNode>::from_node(child, src)
4925 })?),
4926 None => None,
4927 }
4928 },
4929 })
4930 }
4931}
4932impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
4933 fn span(&self) -> ::treesitter_types::Span {
4934 self.span
4935 }
4936}
4937#[derive(Debug, Clone, PartialEq, Eq)]
4938pub struct IntersectionType<'tree> {
4939 pub span: ::treesitter_types::Span,
4940 pub children: ::std::vec::Vec<IntersectionTypeChildren<'tree>>,
4941}
4942impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionType<'tree> {
4943 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4944 fn from_node(
4945 node: ::treesitter_types::tree_sitter::Node<'tree>,
4946 src: &'tree [u8],
4947 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4948 debug_assert_eq!(node.kind(), "intersection_type");
4949 Ok(Self {
4950 span: ::treesitter_types::Span::from(node),
4951 children: {
4952 #[allow(clippy::suspicious_else_formatting)]
4953 let non_field_children = {
4954 let mut cursor = node.walk();
4955 let mut result = ::std::vec::Vec::new();
4956 if cursor.goto_first_child() {
4957 loop {
4958 if cursor.field_name().is_none()
4959 && cursor.node().is_named()
4960 && !cursor.node().is_extra()
4961 {
4962 result.push(cursor.node());
4963 }
4964 if !cursor.goto_next_sibling() {
4965 break;
4966 }
4967 }
4968 }
4969 result
4970 };
4971 let mut items = ::std::vec::Vec::new();
4972 for child in non_field_children {
4973 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4974 <IntersectionTypeChildren as ::treesitter_types::FromNode>::from_node(
4975 child, src,
4976 )
4977 })?);
4978 }
4979 items
4980 },
4981 })
4982 }
4983}
4984impl ::treesitter_types::Spanned for IntersectionType<'_> {
4985 fn span(&self) -> ::treesitter_types::Span {
4986 self.span
4987 }
4988}
4989#[derive(Debug, Clone, PartialEq, Eq)]
4990pub struct ListLiteral<'tree> {
4991 pub span: ::treesitter_types::Span,
4992 pub children: ::std::vec::Vec<ListLiteralChildren<'tree>>,
4993}
4994impl<'tree> ::treesitter_types::FromNode<'tree> for ListLiteral<'tree> {
4995 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4996 fn from_node(
4997 node: ::treesitter_types::tree_sitter::Node<'tree>,
4998 src: &'tree [u8],
4999 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5000 debug_assert_eq!(node.kind(), "list_literal");
5001 Ok(Self {
5002 span: ::treesitter_types::Span::from(node),
5003 children: {
5004 #[allow(clippy::suspicious_else_formatting)]
5005 let non_field_children = {
5006 let mut cursor = node.walk();
5007 let mut result = ::std::vec::Vec::new();
5008 if cursor.goto_first_child() {
5009 loop {
5010 if cursor.field_name().is_none()
5011 && cursor.node().is_named()
5012 && !cursor.node().is_extra()
5013 {
5014 result.push(cursor.node());
5015 }
5016 if !cursor.goto_next_sibling() {
5017 break;
5018 }
5019 }
5020 }
5021 result
5022 };
5023 let mut items = ::std::vec::Vec::new();
5024 for child in non_field_children {
5025 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5026 <ListLiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)
5027 })?);
5028 }
5029 items
5030 },
5031 })
5032 }
5033}
5034impl ::treesitter_types::Spanned for ListLiteral<'_> {
5035 fn span(&self) -> ::treesitter_types::Span {
5036 self.span
5037 }
5038}
5039#[derive(Debug, Clone, PartialEq, Eq)]
5040pub struct MatchBlock<'tree> {
5041 pub span: ::treesitter_types::Span,
5042 pub children: ::std::vec::Vec<MatchBlockChildren<'tree>>,
5043}
5044impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlock<'tree> {
5045 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5046 fn from_node(
5047 node: ::treesitter_types::tree_sitter::Node<'tree>,
5048 src: &'tree [u8],
5049 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5050 debug_assert_eq!(node.kind(), "match_block");
5051 Ok(Self {
5052 span: ::treesitter_types::Span::from(node),
5053 children: {
5054 #[allow(clippy::suspicious_else_formatting)]
5055 let non_field_children = {
5056 let mut cursor = node.walk();
5057 let mut result = ::std::vec::Vec::new();
5058 if cursor.goto_first_child() {
5059 loop {
5060 if cursor.field_name().is_none()
5061 && cursor.node().is_named()
5062 && !cursor.node().is_extra()
5063 {
5064 result.push(cursor.node());
5065 }
5066 if !cursor.goto_next_sibling() {
5067 break;
5068 }
5069 }
5070 }
5071 result
5072 };
5073 let mut items = ::std::vec::Vec::new();
5074 for child in non_field_children {
5075 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5076 <MatchBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
5077 })?);
5078 }
5079 items
5080 },
5081 })
5082 }
5083}
5084impl ::treesitter_types::Spanned for MatchBlock<'_> {
5085 fn span(&self) -> ::treesitter_types::Span {
5086 self.span
5087 }
5088}
5089#[derive(Debug, Clone, PartialEq, Eq)]
5090pub struct MatchConditionList<'tree> {
5091 pub span: ::treesitter_types::Span,
5092 pub children: ::std::vec::Vec<Expression<'tree>>,
5093}
5094impl<'tree> ::treesitter_types::FromNode<'tree> for MatchConditionList<'tree> {
5095 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5096 fn from_node(
5097 node: ::treesitter_types::tree_sitter::Node<'tree>,
5098 src: &'tree [u8],
5099 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5100 debug_assert_eq!(node.kind(), "match_condition_list");
5101 Ok(Self {
5102 span: ::treesitter_types::Span::from(node),
5103 children: {
5104 #[allow(clippy::suspicious_else_formatting)]
5105 let non_field_children = {
5106 let mut cursor = node.walk();
5107 let mut result = ::std::vec::Vec::new();
5108 if cursor.goto_first_child() {
5109 loop {
5110 if cursor.field_name().is_none()
5111 && cursor.node().is_named()
5112 && !cursor.node().is_extra()
5113 {
5114 result.push(cursor.node());
5115 }
5116 if !cursor.goto_next_sibling() {
5117 break;
5118 }
5119 }
5120 }
5121 result
5122 };
5123 let mut items = ::std::vec::Vec::new();
5124 for child in non_field_children {
5125 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5126 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5127 })?);
5128 }
5129 items
5130 },
5131 })
5132 }
5133}
5134impl ::treesitter_types::Spanned for MatchConditionList<'_> {
5135 fn span(&self) -> ::treesitter_types::Span {
5136 self.span
5137 }
5138}
5139#[derive(Debug, Clone, PartialEq, Eq)]
5140pub struct MatchConditionalExpression<'tree> {
5141 pub span: ::treesitter_types::Span,
5142 pub conditional_expressions: MatchConditionList<'tree>,
5143 pub return_expression: Expression<'tree>,
5144}
5145impl<'tree> ::treesitter_types::FromNode<'tree> for MatchConditionalExpression<'tree> {
5146 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5147 fn from_node(
5148 node: ::treesitter_types::tree_sitter::Node<'tree>,
5149 src: &'tree [u8],
5150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5151 debug_assert_eq!(node.kind(), "match_conditional_expression");
5152 Ok(Self {
5153 span: ::treesitter_types::Span::from(node),
5154 conditional_expressions: {
5155 let child = node
5156 .child_by_field_name("conditional_expressions")
5157 .ok_or_else(|| {
5158 ::treesitter_types::ParseError::missing_field(
5159 "conditional_expressions",
5160 node,
5161 )
5162 })?;
5163 ::treesitter_types::runtime::maybe_grow_stack(|| {
5164 <MatchConditionList as ::treesitter_types::FromNode>::from_node(child, src)
5165 })?
5166 },
5167 return_expression: {
5168 let child = node
5169 .child_by_field_name("return_expression")
5170 .ok_or_else(|| {
5171 ::treesitter_types::ParseError::missing_field("return_expression", node)
5172 })?;
5173 ::treesitter_types::runtime::maybe_grow_stack(|| {
5174 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5175 })?
5176 },
5177 })
5178 }
5179}
5180impl ::treesitter_types::Spanned for MatchConditionalExpression<'_> {
5181 fn span(&self) -> ::treesitter_types::Span {
5182 self.span
5183 }
5184}
5185#[derive(Debug, Clone, PartialEq, Eq)]
5186pub struct MatchDefaultExpression<'tree> {
5187 pub span: ::treesitter_types::Span,
5188 pub return_expression: Expression<'tree>,
5189}
5190impl<'tree> ::treesitter_types::FromNode<'tree> for MatchDefaultExpression<'tree> {
5191 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5192 fn from_node(
5193 node: ::treesitter_types::tree_sitter::Node<'tree>,
5194 src: &'tree [u8],
5195 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5196 debug_assert_eq!(node.kind(), "match_default_expression");
5197 Ok(Self {
5198 span: ::treesitter_types::Span::from(node),
5199 return_expression: {
5200 let child = node
5201 .child_by_field_name("return_expression")
5202 .ok_or_else(|| {
5203 ::treesitter_types::ParseError::missing_field("return_expression", node)
5204 })?;
5205 ::treesitter_types::runtime::maybe_grow_stack(|| {
5206 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
5207 })?
5208 },
5209 })
5210 }
5211}
5212impl ::treesitter_types::Spanned for MatchDefaultExpression<'_> {
5213 fn span(&self) -> ::treesitter_types::Span {
5214 self.span
5215 }
5216}
5217#[derive(Debug, Clone, PartialEq, Eq)]
5218pub struct MatchExpression<'tree> {
5219 pub span: ::treesitter_types::Span,
5220 pub body: MatchBlock<'tree>,
5221 pub condition: ParenthesizedExpression<'tree>,
5222}
5223impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
5224 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5225 fn from_node(
5226 node: ::treesitter_types::tree_sitter::Node<'tree>,
5227 src: &'tree [u8],
5228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5229 debug_assert_eq!(node.kind(), "match_expression");
5230 Ok(Self {
5231 span: ::treesitter_types::Span::from(node),
5232 body: {
5233 let child = node
5234 .child_by_field_name("body")
5235 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5236 ::treesitter_types::runtime::maybe_grow_stack(|| {
5237 <MatchBlock as ::treesitter_types::FromNode>::from_node(child, src)
5238 })?
5239 },
5240 condition: {
5241 let child = node.child_by_field_name("condition").ok_or_else(|| {
5242 ::treesitter_types::ParseError::missing_field("condition", node)
5243 })?;
5244 ::treesitter_types::runtime::maybe_grow_stack(|| {
5245 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
5246 })?
5247 },
5248 })
5249 }
5250}
5251impl ::treesitter_types::Spanned for MatchExpression<'_> {
5252 fn span(&self) -> ::treesitter_types::Span {
5253 self.span
5254 }
5255}
5256#[derive(Debug, Clone, PartialEq, Eq)]
5257pub struct MemberAccessExpression<'tree> {
5258 pub span: ::treesitter_types::Span,
5259 pub name: MemberAccessExpressionName<'tree>,
5260 pub object: MemberAccessExpressionObject<'tree>,
5261}
5262impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpression<'tree> {
5263 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5264 fn from_node(
5265 node: ::treesitter_types::tree_sitter::Node<'tree>,
5266 src: &'tree [u8],
5267 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5268 debug_assert_eq!(node.kind(), "member_access_expression");
5269 Ok(Self {
5270 span: ::treesitter_types::Span::from(node),
5271 name: {
5272 let child = node
5273 .child_by_field_name("name")
5274 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5275 ::treesitter_types::runtime::maybe_grow_stack(|| {
5276 <MemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(
5277 child, src,
5278 )
5279 })?
5280 },
5281 object: {
5282 let child = node
5283 .child_by_field_name("object")
5284 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5285 ::treesitter_types::runtime::maybe_grow_stack(|| {
5286 <MemberAccessExpressionObject as ::treesitter_types::FromNode>::from_node(
5287 child, src,
5288 )
5289 })?
5290 },
5291 })
5292 }
5293}
5294impl ::treesitter_types::Spanned for MemberAccessExpression<'_> {
5295 fn span(&self) -> ::treesitter_types::Span {
5296 self.span
5297 }
5298}
5299#[derive(Debug, Clone, PartialEq, Eq)]
5300pub struct MemberCallExpression<'tree> {
5301 pub span: ::treesitter_types::Span,
5302 pub arguments: Arguments<'tree>,
5303 pub name: MemberCallExpressionName<'tree>,
5304 pub object: MemberCallExpressionObject<'tree>,
5305}
5306impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpression<'tree> {
5307 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5308 fn from_node(
5309 node: ::treesitter_types::tree_sitter::Node<'tree>,
5310 src: &'tree [u8],
5311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5312 debug_assert_eq!(node.kind(), "member_call_expression");
5313 Ok(Self {
5314 span: ::treesitter_types::Span::from(node),
5315 arguments: {
5316 let child = node.child_by_field_name("arguments").ok_or_else(|| {
5317 ::treesitter_types::ParseError::missing_field("arguments", node)
5318 })?;
5319 ::treesitter_types::runtime::maybe_grow_stack(|| {
5320 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
5321 })?
5322 },
5323 name: {
5324 let child = node
5325 .child_by_field_name("name")
5326 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5327 ::treesitter_types::runtime::maybe_grow_stack(|| {
5328 <MemberCallExpressionName as ::treesitter_types::FromNode>::from_node(
5329 child, src,
5330 )
5331 })?
5332 },
5333 object: {
5334 let child = node
5335 .child_by_field_name("object")
5336 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5337 ::treesitter_types::runtime::maybe_grow_stack(|| {
5338 <MemberCallExpressionObject as ::treesitter_types::FromNode>::from_node(
5339 child, src,
5340 )
5341 })?
5342 },
5343 })
5344 }
5345}
5346impl ::treesitter_types::Spanned for MemberCallExpression<'_> {
5347 fn span(&self) -> ::treesitter_types::Span {
5348 self.span
5349 }
5350}
5351#[derive(Debug, Clone, PartialEq, Eq)]
5352pub struct MethodDeclaration<'tree> {
5353 pub span: ::treesitter_types::Span,
5354 pub attributes: ::core::option::Option<AttributeList<'tree>>,
5355 pub body: ::core::option::Option<CompoundStatement<'tree>>,
5356 pub name: Name<'tree>,
5357 pub parameters: FormalParameters<'tree>,
5358 pub return_type: ::core::option::Option<MethodDeclarationReturnType<'tree>>,
5359 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
5360}
5361impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
5362 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5363 fn from_node(
5364 node: ::treesitter_types::tree_sitter::Node<'tree>,
5365 src: &'tree [u8],
5366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5367 debug_assert_eq!(node.kind(), "method_declaration");
5368 Ok(Self {
5369 span: ::treesitter_types::Span::from(node),
5370 attributes: match node.child_by_field_name("attributes") {
5371 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5372 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
5373 })?),
5374 None => None,
5375 },
5376 body: match node.child_by_field_name("body") {
5377 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5378 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
5379 })?),
5380 None => None,
5381 },
5382 name: {
5383 let child = node
5384 .child_by_field_name("name")
5385 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5386 ::treesitter_types::runtime::maybe_grow_stack(|| {
5387 <Name as ::treesitter_types::FromNode>::from_node(child, src)
5388 })?
5389 },
5390 parameters: {
5391 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5392 ::treesitter_types::ParseError::missing_field("parameters", node)
5393 })?;
5394 ::treesitter_types::runtime::maybe_grow_stack(|| {
5395 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
5396 })?
5397 },
5398 return_type: match node.child_by_field_name("return_type") {
5399 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5400 <MethodDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
5401 child, src,
5402 )
5403 })?),
5404 None => None,
5405 },
5406 children: {
5407 #[allow(clippy::suspicious_else_formatting)]
5408 let non_field_children = {
5409 let mut cursor = node.walk();
5410 let mut result = ::std::vec::Vec::new();
5411 if cursor.goto_first_child() {
5412 loop {
5413 if cursor.field_name().is_none()
5414 && cursor.node().is_named()
5415 && !cursor.node().is_extra()
5416 {
5417 result.push(cursor.node());
5418 }
5419 if !cursor.goto_next_sibling() {
5420 break;
5421 }
5422 }
5423 }
5424 result
5425 };
5426 let mut items = ::std::vec::Vec::new();
5427 for child in non_field_children {
5428 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5429 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5430 child, src,
5431 )
5432 })?);
5433 }
5434 items
5435 },
5436 })
5437 }
5438}
5439impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
5440 fn span(&self) -> ::treesitter_types::Span {
5441 self.span
5442 }
5443}
5444#[derive(Debug, Clone, PartialEq, Eq)]
5445pub struct Name<'tree> {
5446 pub span: ::treesitter_types::Span,
5447 text: &'tree str,
5448}
5449impl<'tree> ::treesitter_types::FromNode<'tree> for Name<'tree> {
5450 fn from_node(
5451 node: ::treesitter_types::tree_sitter::Node<'tree>,
5452 src: &'tree [u8],
5453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5454 debug_assert_eq!(node.kind(), "name");
5455 Ok(Self {
5456 span: ::treesitter_types::Span::from(node),
5457 text: node.utf8_text(src)?,
5458 })
5459 }
5460}
5461impl<'tree> ::treesitter_types::LeafNode<'tree> for Name<'tree> {
5462 fn text(&self) -> &'tree str {
5463 self.text
5464 }
5465}
5466impl ::treesitter_types::Spanned for Name<'_> {
5467 fn span(&self) -> ::treesitter_types::Span {
5468 self.span
5469 }
5470}
5471#[derive(Debug, Clone, PartialEq, Eq)]
5472pub struct NamedLabelStatement<'tree> {
5473 pub span: ::treesitter_types::Span,
5474 pub children: Name<'tree>,
5475}
5476impl<'tree> ::treesitter_types::FromNode<'tree> for NamedLabelStatement<'tree> {
5477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5478 fn from_node(
5479 node: ::treesitter_types::tree_sitter::Node<'tree>,
5480 src: &'tree [u8],
5481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5482 debug_assert_eq!(node.kind(), "named_label_statement");
5483 Ok(Self {
5484 span: ::treesitter_types::Span::from(node),
5485 children: {
5486 #[allow(clippy::suspicious_else_formatting)]
5487 let non_field_children = {
5488 let mut cursor = node.walk();
5489 let mut result = ::std::vec::Vec::new();
5490 if cursor.goto_first_child() {
5491 loop {
5492 if cursor.field_name().is_none()
5493 && cursor.node().is_named()
5494 && !cursor.node().is_extra()
5495 {
5496 result.push(cursor.node());
5497 }
5498 if !cursor.goto_next_sibling() {
5499 break;
5500 }
5501 }
5502 }
5503 result
5504 };
5505 let child = if let Some(&c) = non_field_children.first() {
5506 c
5507 } else {
5508 let mut fallback_cursor = node.walk();
5509 let mut fallback_child = None;
5510 if fallback_cursor.goto_first_child() {
5511 loop {
5512 if fallback_cursor.field_name().is_none()
5513 && !fallback_cursor.node().is_extra()
5514 {
5515 let candidate = fallback_cursor.node();
5516 #[allow(clippy::needless_question_mark)]
5517 if (|| -> ::core::result::Result<
5518 _,
5519 ::treesitter_types::ParseError,
5520 > {
5521 let child = candidate;
5522 Ok(
5523 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
5524 child,
5525 src,
5526 ))?,
5527 )
5528 })()
5529 .is_ok()
5530 {
5531 fallback_child = Some(candidate);
5532 break;
5533 }
5534 }
5535 if !fallback_cursor.goto_next_sibling() {
5536 break;
5537 }
5538 }
5539 }
5540 if fallback_child.is_none() {
5541 let mut cursor2 = node.walk();
5542 if cursor2.goto_first_child() {
5543 loop {
5544 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5545 let candidate = cursor2.node();
5546 #[allow(clippy::needless_question_mark)]
5547 if (|| -> ::core::result::Result<
5548 _,
5549 ::treesitter_types::ParseError,
5550 > {
5551 let child = candidate;
5552 Ok(
5553 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
5554 child,
5555 src,
5556 ))?,
5557 )
5558 })()
5559 .is_ok()
5560 {
5561 fallback_child = Some(candidate);
5562 break;
5563 }
5564 }
5565 if !cursor2.goto_next_sibling() {
5566 break;
5567 }
5568 }
5569 }
5570 }
5571 fallback_child.ok_or_else(|| {
5572 ::treesitter_types::ParseError::missing_field("children", node)
5573 })?
5574 };
5575 ::treesitter_types::runtime::maybe_grow_stack(|| {
5576 <Name as ::treesitter_types::FromNode>::from_node(child, src)
5577 })?
5578 },
5579 })
5580 }
5581}
5582impl ::treesitter_types::Spanned for NamedLabelStatement<'_> {
5583 fn span(&self) -> ::treesitter_types::Span {
5584 self.span
5585 }
5586}
5587#[derive(Debug, Clone, PartialEq, Eq)]
5588pub struct NamedType<'tree> {
5589 pub span: ::treesitter_types::Span,
5590 pub children: NamedTypeChildren<'tree>,
5591}
5592impl<'tree> ::treesitter_types::FromNode<'tree> for NamedType<'tree> {
5593 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5594 fn from_node(
5595 node: ::treesitter_types::tree_sitter::Node<'tree>,
5596 src: &'tree [u8],
5597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5598 debug_assert_eq!(node.kind(), "named_type");
5599 Ok(Self {
5600 span: ::treesitter_types::Span::from(node),
5601 children: {
5602 #[allow(clippy::suspicious_else_formatting)]
5603 let non_field_children = {
5604 let mut cursor = node.walk();
5605 let mut result = ::std::vec::Vec::new();
5606 if cursor.goto_first_child() {
5607 loop {
5608 if cursor.field_name().is_none()
5609 && cursor.node().is_named()
5610 && !cursor.node().is_extra()
5611 {
5612 result.push(cursor.node());
5613 }
5614 if !cursor.goto_next_sibling() {
5615 break;
5616 }
5617 }
5618 }
5619 result
5620 };
5621 let child = if let Some(&c) = non_field_children.first() {
5622 c
5623 } else {
5624 let mut fallback_cursor = node.walk();
5625 let mut fallback_child = None;
5626 if fallback_cursor.goto_first_child() {
5627 loop {
5628 if fallback_cursor.field_name().is_none()
5629 && !fallback_cursor.node().is_extra()
5630 {
5631 let candidate = fallback_cursor.node();
5632 #[allow(clippy::needless_question_mark)]
5633 if (|| -> ::core::result::Result<
5634 _,
5635 ::treesitter_types::ParseError,
5636 > {
5637 let child = candidate;
5638 Ok(
5639 ::treesitter_types::runtime::maybe_grow_stack(|| <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(
5640 child,
5641 src,
5642 ))?,
5643 )
5644 })()
5645 .is_ok()
5646 {
5647 fallback_child = Some(candidate);
5648 break;
5649 }
5650 }
5651 if !fallback_cursor.goto_next_sibling() {
5652 break;
5653 }
5654 }
5655 }
5656 if fallback_child.is_none() {
5657 let mut cursor2 = node.walk();
5658 if cursor2.goto_first_child() {
5659 loop {
5660 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5661 let candidate = cursor2.node();
5662 #[allow(clippy::needless_question_mark)]
5663 if (|| -> ::core::result::Result<
5664 _,
5665 ::treesitter_types::ParseError,
5666 > {
5667 let child = candidate;
5668 Ok(
5669 ::treesitter_types::runtime::maybe_grow_stack(|| <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(
5670 child,
5671 src,
5672 ))?,
5673 )
5674 })()
5675 .is_ok()
5676 {
5677 fallback_child = Some(candidate);
5678 break;
5679 }
5680 }
5681 if !cursor2.goto_next_sibling() {
5682 break;
5683 }
5684 }
5685 }
5686 }
5687 fallback_child.ok_or_else(|| {
5688 ::treesitter_types::ParseError::missing_field("children", node)
5689 })?
5690 };
5691 ::treesitter_types::runtime::maybe_grow_stack(|| {
5692 <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
5693 })?
5694 },
5695 })
5696 }
5697}
5698impl ::treesitter_types::Spanned for NamedType<'_> {
5699 fn span(&self) -> ::treesitter_types::Span {
5700 self.span
5701 }
5702}
5703#[derive(Debug, Clone, PartialEq, Eq)]
5704pub struct NamespaceDefinition<'tree> {
5705 pub span: ::treesitter_types::Span,
5706 pub body: ::core::option::Option<CompoundStatement<'tree>>,
5707 pub name: ::core::option::Option<NamespaceName<'tree>>,
5708}
5709impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinition<'tree> {
5710 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5711 fn from_node(
5712 node: ::treesitter_types::tree_sitter::Node<'tree>,
5713 src: &'tree [u8],
5714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5715 debug_assert_eq!(node.kind(), "namespace_definition");
5716 Ok(Self {
5717 span: ::treesitter_types::Span::from(node),
5718 body: match node.child_by_field_name("body") {
5719 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5720 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
5721 })?),
5722 None => None,
5723 },
5724 name: match node.child_by_field_name("name") {
5725 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5726 <NamespaceName as ::treesitter_types::FromNode>::from_node(child, src)
5727 })?),
5728 None => None,
5729 },
5730 })
5731 }
5732}
5733impl ::treesitter_types::Spanned for NamespaceDefinition<'_> {
5734 fn span(&self) -> ::treesitter_types::Span {
5735 self.span
5736 }
5737}
5738#[derive(Debug, Clone, PartialEq, Eq)]
5739pub struct NamespaceName<'tree> {
5740 pub span: ::treesitter_types::Span,
5741 pub children: ::std::vec::Vec<Name<'tree>>,
5742}
5743impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceName<'tree> {
5744 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5745 fn from_node(
5746 node: ::treesitter_types::tree_sitter::Node<'tree>,
5747 src: &'tree [u8],
5748 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5749 debug_assert_eq!(node.kind(), "namespace_name");
5750 Ok(Self {
5751 span: ::treesitter_types::Span::from(node),
5752 children: {
5753 #[allow(clippy::suspicious_else_formatting)]
5754 let non_field_children = {
5755 let mut cursor = node.walk();
5756 let mut result = ::std::vec::Vec::new();
5757 if cursor.goto_first_child() {
5758 loop {
5759 if cursor.field_name().is_none()
5760 && cursor.node().is_named()
5761 && !cursor.node().is_extra()
5762 {
5763 result.push(cursor.node());
5764 }
5765 if !cursor.goto_next_sibling() {
5766 break;
5767 }
5768 }
5769 }
5770 result
5771 };
5772 let mut items = ::std::vec::Vec::new();
5773 for child in non_field_children {
5774 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5775 <Name as ::treesitter_types::FromNode>::from_node(child, src)
5776 })?);
5777 }
5778 items
5779 },
5780 })
5781 }
5782}
5783impl ::treesitter_types::Spanned for NamespaceName<'_> {
5784 fn span(&self) -> ::treesitter_types::Span {
5785 self.span
5786 }
5787}
5788#[derive(Debug, Clone, PartialEq, Eq)]
5789pub struct NamespaceUseClause<'tree> {
5790 pub span: ::treesitter_types::Span,
5791 pub alias: ::core::option::Option<Name<'tree>>,
5792 pub r#type: ::core::option::Option<NamespaceUseClauseType>,
5793 pub children: NamespaceUseClauseChildren<'tree>,
5794}
5795impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClause<'tree> {
5796 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5797 fn from_node(
5798 node: ::treesitter_types::tree_sitter::Node<'tree>,
5799 src: &'tree [u8],
5800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5801 debug_assert_eq!(node.kind(), "namespace_use_clause");
5802 Ok(Self {
5803 span: ::treesitter_types::Span::from(node),
5804 alias: match node.child_by_field_name("alias") {
5805 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5806 <Name as ::treesitter_types::FromNode>::from_node(child, src)
5807 })?),
5808 None => None,
5809 },
5810 r#type: match node.child_by_field_name("type") {
5811 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5812 <NamespaceUseClauseType as ::treesitter_types::FromNode>::from_node(child, src)
5813 })?),
5814 None => None,
5815 },
5816 children: {
5817 #[allow(clippy::suspicious_else_formatting)]
5818 let non_field_children = {
5819 let mut cursor = node.walk();
5820 let mut result = ::std::vec::Vec::new();
5821 if cursor.goto_first_child() {
5822 loop {
5823 if cursor.field_name().is_none()
5824 && cursor.node().is_named()
5825 && !cursor.node().is_extra()
5826 {
5827 result.push(cursor.node());
5828 }
5829 if !cursor.goto_next_sibling() {
5830 break;
5831 }
5832 }
5833 }
5834 result
5835 };
5836 let child = if let Some(&c) = non_field_children.first() {
5837 c
5838 } else {
5839 let mut fallback_cursor = node.walk();
5840 let mut fallback_child = None;
5841 if fallback_cursor.goto_first_child() {
5842 loop {
5843 if fallback_cursor.field_name().is_none()
5844 && !fallback_cursor.node().is_extra()
5845 {
5846 let candidate = fallback_cursor.node();
5847 #[allow(clippy::needless_question_mark)]
5848 if (|| -> ::core::result::Result<
5849 _,
5850 ::treesitter_types::ParseError,
5851 > {
5852 let child = candidate;
5853 Ok(
5854 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(
5855 child,
5856 src,
5857 ))?,
5858 )
5859 })()
5860 .is_ok()
5861 {
5862 fallback_child = Some(candidate);
5863 break;
5864 }
5865 }
5866 if !fallback_cursor.goto_next_sibling() {
5867 break;
5868 }
5869 }
5870 }
5871 if fallback_child.is_none() {
5872 let mut cursor2 = node.walk();
5873 if cursor2.goto_first_child() {
5874 loop {
5875 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5876 let candidate = cursor2.node();
5877 #[allow(clippy::needless_question_mark)]
5878 if (|| -> ::core::result::Result<
5879 _,
5880 ::treesitter_types::ParseError,
5881 > {
5882 let child = candidate;
5883 Ok(
5884 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(
5885 child,
5886 src,
5887 ))?,
5888 )
5889 })()
5890 .is_ok()
5891 {
5892 fallback_child = Some(candidate);
5893 break;
5894 }
5895 }
5896 if !cursor2.goto_next_sibling() {
5897 break;
5898 }
5899 }
5900 }
5901 }
5902 fallback_child.ok_or_else(|| {
5903 ::treesitter_types::ParseError::missing_field("children", node)
5904 })?
5905 };
5906 ::treesitter_types::runtime::maybe_grow_stack(|| {
5907 <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(
5908 child, src,
5909 )
5910 })?
5911 },
5912 })
5913 }
5914}
5915impl ::treesitter_types::Spanned for NamespaceUseClause<'_> {
5916 fn span(&self) -> ::treesitter_types::Span {
5917 self.span
5918 }
5919}
5920#[derive(Debug, Clone, PartialEq, Eq)]
5921pub struct NamespaceUseDeclaration<'tree> {
5922 pub span: ::treesitter_types::Span,
5923 pub body: ::core::option::Option<NamespaceUseGroup<'tree>>,
5924 pub r#type: ::core::option::Option<NamespaceUseDeclarationType>,
5925 pub children: ::std::vec::Vec<NamespaceUseDeclarationChildren<'tree>>,
5926}
5927impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclaration<'tree> {
5928 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5929 fn from_node(
5930 node: ::treesitter_types::tree_sitter::Node<'tree>,
5931 src: &'tree [u8],
5932 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5933 debug_assert_eq!(node.kind(), "namespace_use_declaration");
5934 Ok(Self {
5935 span: ::treesitter_types::Span::from(node),
5936 body: match node.child_by_field_name("body") {
5937 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5938 <NamespaceUseGroup as ::treesitter_types::FromNode>::from_node(child, src)
5939 })?),
5940 None => None,
5941 },
5942 r#type: match node.child_by_field_name("type") {
5943 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5944 <NamespaceUseDeclarationType as ::treesitter_types::FromNode>::from_node(
5945 child, src,
5946 )
5947 })?),
5948 None => None,
5949 },
5950 children: {
5951 #[allow(clippy::suspicious_else_formatting)]
5952 let non_field_children = {
5953 let mut cursor = node.walk();
5954 let mut result = ::std::vec::Vec::new();
5955 if cursor.goto_first_child() {
5956 loop {
5957 if cursor.field_name().is_none()
5958 && cursor.node().is_named()
5959 && !cursor.node().is_extra()
5960 {
5961 result.push(cursor.node());
5962 }
5963 if !cursor.goto_next_sibling() {
5964 break;
5965 }
5966 }
5967 }
5968 result
5969 };
5970 let mut items = ::std::vec::Vec::new();
5971 for child in non_field_children {
5972 items
5973 .push(
5974 ::treesitter_types::runtime::maybe_grow_stack(|| <NamespaceUseDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5975 child,
5976 src,
5977 ))?,
5978 );
5979 }
5980 items
5981 },
5982 })
5983 }
5984}
5985impl ::treesitter_types::Spanned for NamespaceUseDeclaration<'_> {
5986 fn span(&self) -> ::treesitter_types::Span {
5987 self.span
5988 }
5989}
5990#[derive(Debug, Clone, PartialEq, Eq)]
5991pub struct NamespaceUseGroup<'tree> {
5992 pub span: ::treesitter_types::Span,
5993 pub children: ::std::vec::Vec<NamespaceUseClause<'tree>>,
5994}
5995impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseGroup<'tree> {
5996 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5997 fn from_node(
5998 node: ::treesitter_types::tree_sitter::Node<'tree>,
5999 src: &'tree [u8],
6000 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6001 debug_assert_eq!(node.kind(), "namespace_use_group");
6002 Ok(Self {
6003 span: ::treesitter_types::Span::from(node),
6004 children: {
6005 #[allow(clippy::suspicious_else_formatting)]
6006 let non_field_children = {
6007 let mut cursor = node.walk();
6008 let mut result = ::std::vec::Vec::new();
6009 if cursor.goto_first_child() {
6010 loop {
6011 if cursor.field_name().is_none()
6012 && cursor.node().is_named()
6013 && !cursor.node().is_extra()
6014 {
6015 result.push(cursor.node());
6016 }
6017 if !cursor.goto_next_sibling() {
6018 break;
6019 }
6020 }
6021 }
6022 result
6023 };
6024 let mut items = ::std::vec::Vec::new();
6025 for child in non_field_children {
6026 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6027 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(child, src)
6028 })?);
6029 }
6030 items
6031 },
6032 })
6033 }
6034}
6035impl ::treesitter_types::Spanned for NamespaceUseGroup<'_> {
6036 fn span(&self) -> ::treesitter_types::Span {
6037 self.span
6038 }
6039}
6040#[derive(Debug, Clone, PartialEq, Eq)]
6041pub struct Nowdoc<'tree> {
6042 pub span: ::treesitter_types::Span,
6043 pub end_tag: HeredocEnd<'tree>,
6044 pub identifier: HeredocStart<'tree>,
6045 pub value: ::core::option::Option<NowdocBody<'tree>>,
6046}
6047impl<'tree> ::treesitter_types::FromNode<'tree> for Nowdoc<'tree> {
6048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6049 fn from_node(
6050 node: ::treesitter_types::tree_sitter::Node<'tree>,
6051 src: &'tree [u8],
6052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6053 debug_assert_eq!(node.kind(), "nowdoc");
6054 Ok(Self {
6055 span: ::treesitter_types::Span::from(node),
6056 end_tag: {
6057 let child = node.child_by_field_name("end_tag").ok_or_else(|| {
6058 ::treesitter_types::ParseError::missing_field("end_tag", node)
6059 })?;
6060 ::treesitter_types::runtime::maybe_grow_stack(|| {
6061 <HeredocEnd as ::treesitter_types::FromNode>::from_node(child, src)
6062 })?
6063 },
6064 identifier: {
6065 let child = node.child_by_field_name("identifier").ok_or_else(|| {
6066 ::treesitter_types::ParseError::missing_field("identifier", node)
6067 })?;
6068 ::treesitter_types::runtime::maybe_grow_stack(|| {
6069 <HeredocStart as ::treesitter_types::FromNode>::from_node(child, src)
6070 })?
6071 },
6072 value: match node.child_by_field_name("value") {
6073 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6074 <NowdocBody as ::treesitter_types::FromNode>::from_node(child, src)
6075 })?),
6076 None => None,
6077 },
6078 })
6079 }
6080}
6081impl ::treesitter_types::Spanned for Nowdoc<'_> {
6082 fn span(&self) -> ::treesitter_types::Span {
6083 self.span
6084 }
6085}
6086#[derive(Debug, Clone, PartialEq, Eq)]
6087pub struct NowdocBody<'tree> {
6088 pub span: ::treesitter_types::Span,
6089 pub children: ::std::vec::Vec<NowdocString<'tree>>,
6090}
6091impl<'tree> ::treesitter_types::FromNode<'tree> for NowdocBody<'tree> {
6092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6093 fn from_node(
6094 node: ::treesitter_types::tree_sitter::Node<'tree>,
6095 src: &'tree [u8],
6096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6097 debug_assert_eq!(node.kind(), "nowdoc_body");
6098 Ok(Self {
6099 span: ::treesitter_types::Span::from(node),
6100 children: {
6101 #[allow(clippy::suspicious_else_formatting)]
6102 let non_field_children = {
6103 let mut cursor = node.walk();
6104 let mut result = ::std::vec::Vec::new();
6105 if cursor.goto_first_child() {
6106 loop {
6107 if cursor.field_name().is_none()
6108 && cursor.node().is_named()
6109 && !cursor.node().is_extra()
6110 {
6111 result.push(cursor.node());
6112 }
6113 if !cursor.goto_next_sibling() {
6114 break;
6115 }
6116 }
6117 }
6118 result
6119 };
6120 let mut items = ::std::vec::Vec::new();
6121 for child in non_field_children {
6122 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6123 <NowdocString as ::treesitter_types::FromNode>::from_node(child, src)
6124 })?);
6125 }
6126 items
6127 },
6128 })
6129 }
6130}
6131impl ::treesitter_types::Spanned for NowdocBody<'_> {
6132 fn span(&self) -> ::treesitter_types::Span {
6133 self.span
6134 }
6135}
6136#[derive(Debug, Clone, PartialEq, Eq)]
6137pub struct Null<'tree> {
6138 pub span: ::treesitter_types::Span,
6139 text: &'tree str,
6140}
6141impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
6142 fn from_node(
6143 node: ::treesitter_types::tree_sitter::Node<'tree>,
6144 src: &'tree [u8],
6145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6146 debug_assert_eq!(node.kind(), "null");
6147 Ok(Self {
6148 span: ::treesitter_types::Span::from(node),
6149 text: node.utf8_text(src)?,
6150 })
6151 }
6152}
6153impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
6154 fn text(&self) -> &'tree str {
6155 self.text
6156 }
6157}
6158impl ::treesitter_types::Spanned for Null<'_> {
6159 fn span(&self) -> ::treesitter_types::Span {
6160 self.span
6161 }
6162}
6163#[derive(Debug, Clone, PartialEq, Eq)]
6164pub struct NullsafeMemberAccessExpression<'tree> {
6165 pub span: ::treesitter_types::Span,
6166 pub name: NullsafeMemberAccessExpressionName<'tree>,
6167 pub object: NullsafeMemberAccessExpressionObject<'tree>,
6168}
6169impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpression<'tree> {
6170 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6171 fn from_node(
6172 node: ::treesitter_types::tree_sitter::Node<'tree>,
6173 src: &'tree [u8],
6174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6175 debug_assert_eq!(node.kind(), "nullsafe_member_access_expression");
6176 Ok(Self {
6177 span: ::treesitter_types::Span::from(node),
6178 name: {
6179 let child = node
6180 .child_by_field_name("name")
6181 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6182 ::treesitter_types::runtime::maybe_grow_stack(|| {
6183 <NullsafeMemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(
6184 child, src,
6185 )
6186 })?
6187 },
6188 object: {
6189 let child = node
6190 .child_by_field_name("object")
6191 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
6192 ::treesitter_types::runtime::maybe_grow_stack(|| {
6193 <NullsafeMemberAccessExpressionObject as ::treesitter_types::FromNode>::from_node(
6194 child,
6195 src,
6196 )
6197 })?
6198 },
6199 })
6200 }
6201}
6202impl ::treesitter_types::Spanned for NullsafeMemberAccessExpression<'_> {
6203 fn span(&self) -> ::treesitter_types::Span {
6204 self.span
6205 }
6206}
6207#[derive(Debug, Clone, PartialEq, Eq)]
6208pub struct NullsafeMemberCallExpression<'tree> {
6209 pub span: ::treesitter_types::Span,
6210 pub arguments: Arguments<'tree>,
6211 pub name: NullsafeMemberCallExpressionName<'tree>,
6212 pub object: NullsafeMemberCallExpressionObject<'tree>,
6213}
6214impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpression<'tree> {
6215 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6216 fn from_node(
6217 node: ::treesitter_types::tree_sitter::Node<'tree>,
6218 src: &'tree [u8],
6219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6220 debug_assert_eq!(node.kind(), "nullsafe_member_call_expression");
6221 Ok(Self {
6222 span: ::treesitter_types::Span::from(node),
6223 arguments: {
6224 let child = node.child_by_field_name("arguments").ok_or_else(|| {
6225 ::treesitter_types::ParseError::missing_field("arguments", node)
6226 })?;
6227 ::treesitter_types::runtime::maybe_grow_stack(|| {
6228 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
6229 })?
6230 },
6231 name: {
6232 let child = node
6233 .child_by_field_name("name")
6234 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6235 ::treesitter_types::runtime::maybe_grow_stack(|| {
6236 <NullsafeMemberCallExpressionName as ::treesitter_types::FromNode>::from_node(
6237 child, src,
6238 )
6239 })?
6240 },
6241 object: {
6242 let child = node
6243 .child_by_field_name("object")
6244 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
6245 ::treesitter_types::runtime::maybe_grow_stack(|| {
6246 <NullsafeMemberCallExpressionObject as ::treesitter_types::FromNode>::from_node(
6247 child, src,
6248 )
6249 })?
6250 },
6251 })
6252 }
6253}
6254impl ::treesitter_types::Spanned for NullsafeMemberCallExpression<'_> {
6255 fn span(&self) -> ::treesitter_types::Span {
6256 self.span
6257 }
6258}
6259#[derive(Debug, Clone, PartialEq, Eq)]
6260pub struct ObjectCreationExpression<'tree> {
6261 pub span: ::treesitter_types::Span,
6262 pub children: ::std::vec::Vec<ObjectCreationExpressionChildren<'tree>>,
6263}
6264impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
6265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6266 fn from_node(
6267 node: ::treesitter_types::tree_sitter::Node<'tree>,
6268 src: &'tree [u8],
6269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6270 debug_assert_eq!(node.kind(), "object_creation_expression");
6271 Ok(Self {
6272 span: ::treesitter_types::Span::from(node),
6273 children: {
6274 #[allow(clippy::suspicious_else_formatting)]
6275 let non_field_children = {
6276 let mut cursor = node.walk();
6277 let mut result = ::std::vec::Vec::new();
6278 if cursor.goto_first_child() {
6279 loop {
6280 if cursor.field_name().is_none()
6281 && cursor.node().is_named()
6282 && !cursor.node().is_extra()
6283 {
6284 result.push(cursor.node());
6285 }
6286 if !cursor.goto_next_sibling() {
6287 break;
6288 }
6289 }
6290 }
6291 result
6292 };
6293 let mut items = ::std::vec::Vec::new();
6294 for child in non_field_children {
6295 items
6296 .push(
6297 ::treesitter_types::runtime::maybe_grow_stack(|| <ObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
6298 child,
6299 src,
6300 ))?,
6301 );
6302 }
6303 items
6304 },
6305 })
6306 }
6307}
6308impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
6309 fn span(&self) -> ::treesitter_types::Span {
6310 self.span
6311 }
6312}
6313#[derive(Debug, Clone, PartialEq, Eq)]
6314pub struct OptionalType<'tree> {
6315 pub span: ::treesitter_types::Span,
6316 pub children: OptionalTypeChildren<'tree>,
6317}
6318impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalType<'tree> {
6319 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6320 fn from_node(
6321 node: ::treesitter_types::tree_sitter::Node<'tree>,
6322 src: &'tree [u8],
6323 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6324 debug_assert_eq!(node.kind(), "optional_type");
6325 Ok(Self {
6326 span: ::treesitter_types::Span::from(node),
6327 children: {
6328 #[allow(clippy::suspicious_else_formatting)]
6329 let non_field_children = {
6330 let mut cursor = node.walk();
6331 let mut result = ::std::vec::Vec::new();
6332 if cursor.goto_first_child() {
6333 loop {
6334 if cursor.field_name().is_none()
6335 && cursor.node().is_named()
6336 && !cursor.node().is_extra()
6337 {
6338 result.push(cursor.node());
6339 }
6340 if !cursor.goto_next_sibling() {
6341 break;
6342 }
6343 }
6344 }
6345 result
6346 };
6347 let child = if let Some(&c) = non_field_children.first() {
6348 c
6349 } else {
6350 let mut fallback_cursor = node.walk();
6351 let mut fallback_child = None;
6352 if fallback_cursor.goto_first_child() {
6353 loop {
6354 if fallback_cursor.field_name().is_none()
6355 && !fallback_cursor.node().is_extra()
6356 {
6357 let candidate = fallback_cursor.node();
6358 #[allow(clippy::needless_question_mark)]
6359 if (|| -> ::core::result::Result<
6360 _,
6361 ::treesitter_types::ParseError,
6362 > {
6363 let child = candidate;
6364 Ok(
6365 ::treesitter_types::runtime::maybe_grow_stack(|| <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(
6366 child,
6367 src,
6368 ))?,
6369 )
6370 })()
6371 .is_ok()
6372 {
6373 fallback_child = Some(candidate);
6374 break;
6375 }
6376 }
6377 if !fallback_cursor.goto_next_sibling() {
6378 break;
6379 }
6380 }
6381 }
6382 if fallback_child.is_none() {
6383 let mut cursor2 = node.walk();
6384 if cursor2.goto_first_child() {
6385 loop {
6386 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6387 let candidate = cursor2.node();
6388 #[allow(clippy::needless_question_mark)]
6389 if (|| -> ::core::result::Result<
6390 _,
6391 ::treesitter_types::ParseError,
6392 > {
6393 let child = candidate;
6394 Ok(
6395 ::treesitter_types::runtime::maybe_grow_stack(|| <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(
6396 child,
6397 src,
6398 ))?,
6399 )
6400 })()
6401 .is_ok()
6402 {
6403 fallback_child = Some(candidate);
6404 break;
6405 }
6406 }
6407 if !cursor2.goto_next_sibling() {
6408 break;
6409 }
6410 }
6411 }
6412 }
6413 fallback_child.ok_or_else(|| {
6414 ::treesitter_types::ParseError::missing_field("children", node)
6415 })?
6416 };
6417 ::treesitter_types::runtime::maybe_grow_stack(|| {
6418 <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
6419 })?
6420 },
6421 })
6422 }
6423}
6424impl ::treesitter_types::Spanned for OptionalType<'_> {
6425 fn span(&self) -> ::treesitter_types::Span {
6426 self.span
6427 }
6428}
6429#[derive(Debug, Clone, PartialEq, Eq)]
6430pub struct Pair<'tree> {
6431 pub span: ::treesitter_types::Span,
6432 pub children: ::std::vec::Vec<PairChildren<'tree>>,
6433}
6434impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
6435 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6436 fn from_node(
6437 node: ::treesitter_types::tree_sitter::Node<'tree>,
6438 src: &'tree [u8],
6439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6440 debug_assert_eq!(node.kind(), "pair");
6441 Ok(Self {
6442 span: ::treesitter_types::Span::from(node),
6443 children: {
6444 #[allow(clippy::suspicious_else_formatting)]
6445 let non_field_children = {
6446 let mut cursor = node.walk();
6447 let mut result = ::std::vec::Vec::new();
6448 if cursor.goto_first_child() {
6449 loop {
6450 if cursor.field_name().is_none()
6451 && cursor.node().is_named()
6452 && !cursor.node().is_extra()
6453 {
6454 result.push(cursor.node());
6455 }
6456 if !cursor.goto_next_sibling() {
6457 break;
6458 }
6459 }
6460 }
6461 result
6462 };
6463 let mut items = ::std::vec::Vec::new();
6464 for child in non_field_children {
6465 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6466 <PairChildren as ::treesitter_types::FromNode>::from_node(child, src)
6467 })?);
6468 }
6469 items
6470 },
6471 })
6472 }
6473}
6474impl ::treesitter_types::Spanned for Pair<'_> {
6475 fn span(&self) -> ::treesitter_types::Span {
6476 self.span
6477 }
6478}
6479#[derive(Debug, Clone, PartialEq, Eq)]
6480pub struct ParenthesizedExpression<'tree> {
6481 pub span: ::treesitter_types::Span,
6482 pub children: Expression<'tree>,
6483}
6484impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
6485 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6486 fn from_node(
6487 node: ::treesitter_types::tree_sitter::Node<'tree>,
6488 src: &'tree [u8],
6489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6490 debug_assert_eq!(node.kind(), "parenthesized_expression");
6491 Ok(Self {
6492 span: ::treesitter_types::Span::from(node),
6493 children: {
6494 #[allow(clippy::suspicious_else_formatting)]
6495 let non_field_children = {
6496 let mut cursor = node.walk();
6497 let mut result = ::std::vec::Vec::new();
6498 if cursor.goto_first_child() {
6499 loop {
6500 if cursor.field_name().is_none()
6501 && cursor.node().is_named()
6502 && !cursor.node().is_extra()
6503 {
6504 result.push(cursor.node());
6505 }
6506 if !cursor.goto_next_sibling() {
6507 break;
6508 }
6509 }
6510 }
6511 result
6512 };
6513 let child = if let Some(&c) = non_field_children.first() {
6514 c
6515 } else {
6516 let mut fallback_cursor = node.walk();
6517 let mut fallback_child = None;
6518 if fallback_cursor.goto_first_child() {
6519 loop {
6520 if fallback_cursor.field_name().is_none()
6521 && !fallback_cursor.node().is_extra()
6522 {
6523 let candidate = fallback_cursor.node();
6524 #[allow(clippy::needless_question_mark)]
6525 if (|| -> ::core::result::Result<
6526 _,
6527 ::treesitter_types::ParseError,
6528 > {
6529 let child = candidate;
6530 Ok(
6531 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6532 child,
6533 src,
6534 ))?,
6535 )
6536 })()
6537 .is_ok()
6538 {
6539 fallback_child = Some(candidate);
6540 break;
6541 }
6542 }
6543 if !fallback_cursor.goto_next_sibling() {
6544 break;
6545 }
6546 }
6547 }
6548 if fallback_child.is_none() {
6549 let mut cursor2 = node.walk();
6550 if cursor2.goto_first_child() {
6551 loop {
6552 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6553 let candidate = cursor2.node();
6554 #[allow(clippy::needless_question_mark)]
6555 if (|| -> ::core::result::Result<
6556 _,
6557 ::treesitter_types::ParseError,
6558 > {
6559 let child = candidate;
6560 Ok(
6561 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6562 child,
6563 src,
6564 ))?,
6565 )
6566 })()
6567 .is_ok()
6568 {
6569 fallback_child = Some(candidate);
6570 break;
6571 }
6572 }
6573 if !cursor2.goto_next_sibling() {
6574 break;
6575 }
6576 }
6577 }
6578 }
6579 fallback_child.ok_or_else(|| {
6580 ::treesitter_types::ParseError::missing_field("children", node)
6581 })?
6582 };
6583 ::treesitter_types::runtime::maybe_grow_stack(|| {
6584 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6585 })?
6586 },
6587 })
6588 }
6589}
6590impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
6591 fn span(&self) -> ::treesitter_types::Span {
6592 self.span
6593 }
6594}
6595#[derive(Debug, Clone, PartialEq, Eq)]
6596pub struct PrimitiveType<'tree> {
6597 pub span: ::treesitter_types::Span,
6598 text: &'tree str,
6599}
6600impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
6601 fn from_node(
6602 node: ::treesitter_types::tree_sitter::Node<'tree>,
6603 src: &'tree [u8],
6604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6605 debug_assert_eq!(node.kind(), "primitive_type");
6606 Ok(Self {
6607 span: ::treesitter_types::Span::from(node),
6608 text: node.utf8_text(src)?,
6609 })
6610 }
6611}
6612impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
6613 fn text(&self) -> &'tree str {
6614 self.text
6615 }
6616}
6617impl ::treesitter_types::Spanned for PrimitiveType<'_> {
6618 fn span(&self) -> ::treesitter_types::Span {
6619 self.span
6620 }
6621}
6622#[derive(Debug, Clone, PartialEq, Eq)]
6623pub struct PrintIntrinsic<'tree> {
6624 pub span: ::treesitter_types::Span,
6625 pub children: Expression<'tree>,
6626}
6627impl<'tree> ::treesitter_types::FromNode<'tree> for PrintIntrinsic<'tree> {
6628 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6629 fn from_node(
6630 node: ::treesitter_types::tree_sitter::Node<'tree>,
6631 src: &'tree [u8],
6632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6633 debug_assert_eq!(node.kind(), "print_intrinsic");
6634 Ok(Self {
6635 span: ::treesitter_types::Span::from(node),
6636 children: {
6637 #[allow(clippy::suspicious_else_formatting)]
6638 let non_field_children = {
6639 let mut cursor = node.walk();
6640 let mut result = ::std::vec::Vec::new();
6641 if cursor.goto_first_child() {
6642 loop {
6643 if cursor.field_name().is_none()
6644 && cursor.node().is_named()
6645 && !cursor.node().is_extra()
6646 {
6647 result.push(cursor.node());
6648 }
6649 if !cursor.goto_next_sibling() {
6650 break;
6651 }
6652 }
6653 }
6654 result
6655 };
6656 let child = if let Some(&c) = non_field_children.first() {
6657 c
6658 } else {
6659 let mut fallback_cursor = node.walk();
6660 let mut fallback_child = None;
6661 if fallback_cursor.goto_first_child() {
6662 loop {
6663 if fallback_cursor.field_name().is_none()
6664 && !fallback_cursor.node().is_extra()
6665 {
6666 let candidate = fallback_cursor.node();
6667 #[allow(clippy::needless_question_mark)]
6668 if (|| -> ::core::result::Result<
6669 _,
6670 ::treesitter_types::ParseError,
6671 > {
6672 let child = candidate;
6673 Ok(
6674 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6675 child,
6676 src,
6677 ))?,
6678 )
6679 })()
6680 .is_ok()
6681 {
6682 fallback_child = Some(candidate);
6683 break;
6684 }
6685 }
6686 if !fallback_cursor.goto_next_sibling() {
6687 break;
6688 }
6689 }
6690 }
6691 if fallback_child.is_none() {
6692 let mut cursor2 = node.walk();
6693 if cursor2.goto_first_child() {
6694 loop {
6695 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6696 let candidate = cursor2.node();
6697 #[allow(clippy::needless_question_mark)]
6698 if (|| -> ::core::result::Result<
6699 _,
6700 ::treesitter_types::ParseError,
6701 > {
6702 let child = candidate;
6703 Ok(
6704 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
6705 child,
6706 src,
6707 ))?,
6708 )
6709 })()
6710 .is_ok()
6711 {
6712 fallback_child = Some(candidate);
6713 break;
6714 }
6715 }
6716 if !cursor2.goto_next_sibling() {
6717 break;
6718 }
6719 }
6720 }
6721 }
6722 fallback_child.ok_or_else(|| {
6723 ::treesitter_types::ParseError::missing_field("children", node)
6724 })?
6725 };
6726 ::treesitter_types::runtime::maybe_grow_stack(|| {
6727 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6728 })?
6729 },
6730 })
6731 }
6732}
6733impl ::treesitter_types::Spanned for PrintIntrinsic<'_> {
6734 fn span(&self) -> ::treesitter_types::Span {
6735 self.span
6736 }
6737}
6738#[derive(Debug, Clone, PartialEq, Eq)]
6739pub struct Program<'tree> {
6740 pub span: ::treesitter_types::Span,
6741 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
6742}
6743impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
6744 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6745 fn from_node(
6746 node: ::treesitter_types::tree_sitter::Node<'tree>,
6747 src: &'tree [u8],
6748 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6749 debug_assert_eq!(node.kind(), "program");
6750 Ok(Self {
6751 span: ::treesitter_types::Span::from(node),
6752 children: {
6753 #[allow(clippy::suspicious_else_formatting)]
6754 let non_field_children = {
6755 let mut cursor = node.walk();
6756 let mut result = ::std::vec::Vec::new();
6757 if cursor.goto_first_child() {
6758 loop {
6759 if cursor.field_name().is_none()
6760 && cursor.node().is_named()
6761 && !cursor.node().is_extra()
6762 {
6763 result.push(cursor.node());
6764 }
6765 if !cursor.goto_next_sibling() {
6766 break;
6767 }
6768 }
6769 }
6770 result
6771 };
6772 let mut items = ::std::vec::Vec::new();
6773 for child in non_field_children {
6774 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6775 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)
6776 })?);
6777 }
6778 items
6779 },
6780 })
6781 }
6782}
6783impl ::treesitter_types::Spanned for Program<'_> {
6784 fn span(&self) -> ::treesitter_types::Span {
6785 self.span
6786 }
6787}
6788#[derive(Debug, Clone, PartialEq, Eq)]
6789pub struct PropertyDeclaration<'tree> {
6790 pub span: ::treesitter_types::Span,
6791 pub attributes: ::core::option::Option<AttributeList<'tree>>,
6792 pub r#type: ::core::option::Option<Type<'tree>>,
6793 pub children: ::std::vec::Vec<PropertyDeclarationChildren<'tree>>,
6794}
6795impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclaration<'tree> {
6796 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6797 fn from_node(
6798 node: ::treesitter_types::tree_sitter::Node<'tree>,
6799 src: &'tree [u8],
6800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6801 debug_assert_eq!(node.kind(), "property_declaration");
6802 Ok(Self {
6803 span: ::treesitter_types::Span::from(node),
6804 attributes: match node.child_by_field_name("attributes") {
6805 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6806 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
6807 })?),
6808 None => None,
6809 },
6810 r#type: match node.child_by_field_name("type") {
6811 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6812 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6813 })?),
6814 None => None,
6815 },
6816 children: {
6817 #[allow(clippy::suspicious_else_formatting)]
6818 let non_field_children = {
6819 let mut cursor = node.walk();
6820 let mut result = ::std::vec::Vec::new();
6821 if cursor.goto_first_child() {
6822 loop {
6823 if cursor.field_name().is_none()
6824 && cursor.node().is_named()
6825 && !cursor.node().is_extra()
6826 {
6827 result.push(cursor.node());
6828 }
6829 if !cursor.goto_next_sibling() {
6830 break;
6831 }
6832 }
6833 }
6834 result
6835 };
6836 let mut items = ::std::vec::Vec::new();
6837 for child in non_field_children {
6838 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6839 <PropertyDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6840 child, src,
6841 )
6842 })?);
6843 }
6844 items
6845 },
6846 })
6847 }
6848}
6849impl ::treesitter_types::Spanned for PropertyDeclaration<'_> {
6850 fn span(&self) -> ::treesitter_types::Span {
6851 self.span
6852 }
6853}
6854#[derive(Debug, Clone, PartialEq, Eq)]
6855pub struct PropertyElement<'tree> {
6856 pub span: ::treesitter_types::Span,
6857 pub default_value: ::core::option::Option<Expression<'tree>>,
6858 pub name: VariableName<'tree>,
6859}
6860impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyElement<'tree> {
6861 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6862 fn from_node(
6863 node: ::treesitter_types::tree_sitter::Node<'tree>,
6864 src: &'tree [u8],
6865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6866 debug_assert_eq!(node.kind(), "property_element");
6867 Ok(Self {
6868 span: ::treesitter_types::Span::from(node),
6869 default_value: match node.child_by_field_name("default_value") {
6870 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6871 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6872 })?),
6873 None => None,
6874 },
6875 name: {
6876 let child = node
6877 .child_by_field_name("name")
6878 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6879 ::treesitter_types::runtime::maybe_grow_stack(|| {
6880 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)
6881 })?
6882 },
6883 })
6884 }
6885}
6886impl ::treesitter_types::Spanned for PropertyElement<'_> {
6887 fn span(&self) -> ::treesitter_types::Span {
6888 self.span
6889 }
6890}
6891#[derive(Debug, Clone, PartialEq, Eq)]
6892pub struct PropertyHook<'tree> {
6893 pub span: ::treesitter_types::Span,
6894 pub attributes: ::core::option::Option<AttributeList<'tree>>,
6895 pub body: ::core::option::Option<PropertyHookBody<'tree>>,
6896 pub r#final: ::core::option::Option<FinalModifier<'tree>>,
6897 pub parameters: ::core::option::Option<FormalParameters<'tree>>,
6898 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
6899 pub children: Name<'tree>,
6900}
6901impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHook<'tree> {
6902 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6903 fn from_node(
6904 node: ::treesitter_types::tree_sitter::Node<'tree>,
6905 src: &'tree [u8],
6906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6907 debug_assert_eq!(node.kind(), "property_hook");
6908 Ok(Self {
6909 span: ::treesitter_types::Span::from(node),
6910 attributes: match node.child_by_field_name("attributes") {
6911 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6912 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
6913 })?),
6914 None => None,
6915 },
6916 body: match node.child_by_field_name("body") {
6917 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6918 <PropertyHookBody as ::treesitter_types::FromNode>::from_node(child, src)
6919 })?),
6920 None => None,
6921 },
6922 r#final: match node.child_by_field_name("final") {
6923 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6924 <FinalModifier as ::treesitter_types::FromNode>::from_node(child, src)
6925 })?),
6926 None => None,
6927 },
6928 parameters: match node.child_by_field_name("parameters") {
6929 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6930 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)
6931 })?),
6932 None => None,
6933 },
6934 reference_modifier: match node.child_by_field_name("reference_modifier") {
6935 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6936 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
6937 })?),
6938 None => None,
6939 },
6940 children: {
6941 #[allow(clippy::suspicious_else_formatting)]
6942 let non_field_children = {
6943 let mut cursor = node.walk();
6944 let mut result = ::std::vec::Vec::new();
6945 if cursor.goto_first_child() {
6946 loop {
6947 if cursor.field_name().is_none()
6948 && cursor.node().is_named()
6949 && !cursor.node().is_extra()
6950 {
6951 result.push(cursor.node());
6952 }
6953 if !cursor.goto_next_sibling() {
6954 break;
6955 }
6956 }
6957 }
6958 result
6959 };
6960 let child = if let Some(&c) = non_field_children.first() {
6961 c
6962 } else {
6963 let mut fallback_cursor = node.walk();
6964 let mut fallback_child = None;
6965 if fallback_cursor.goto_first_child() {
6966 loop {
6967 if fallback_cursor.field_name().is_none()
6968 && !fallback_cursor.node().is_extra()
6969 {
6970 let candidate = fallback_cursor.node();
6971 #[allow(clippy::needless_question_mark)]
6972 if (|| -> ::core::result::Result<
6973 _,
6974 ::treesitter_types::ParseError,
6975 > {
6976 let child = candidate;
6977 Ok(
6978 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
6979 child,
6980 src,
6981 ))?,
6982 )
6983 })()
6984 .is_ok()
6985 {
6986 fallback_child = Some(candidate);
6987 break;
6988 }
6989 }
6990 if !fallback_cursor.goto_next_sibling() {
6991 break;
6992 }
6993 }
6994 }
6995 if fallback_child.is_none() {
6996 let mut cursor2 = node.walk();
6997 if cursor2.goto_first_child() {
6998 loop {
6999 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7000 let candidate = cursor2.node();
7001 #[allow(clippy::needless_question_mark)]
7002 if (|| -> ::core::result::Result<
7003 _,
7004 ::treesitter_types::ParseError,
7005 > {
7006 let child = candidate;
7007 Ok(
7008 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
7009 child,
7010 src,
7011 ))?,
7012 )
7013 })()
7014 .is_ok()
7015 {
7016 fallback_child = Some(candidate);
7017 break;
7018 }
7019 }
7020 if !cursor2.goto_next_sibling() {
7021 break;
7022 }
7023 }
7024 }
7025 }
7026 fallback_child.ok_or_else(|| {
7027 ::treesitter_types::ParseError::missing_field("children", node)
7028 })?
7029 };
7030 ::treesitter_types::runtime::maybe_grow_stack(|| {
7031 <Name as ::treesitter_types::FromNode>::from_node(child, src)
7032 })?
7033 },
7034 })
7035 }
7036}
7037impl ::treesitter_types::Spanned for PropertyHook<'_> {
7038 fn span(&self) -> ::treesitter_types::Span {
7039 self.span
7040 }
7041}
7042#[derive(Debug, Clone, PartialEq, Eq)]
7043pub struct PropertyHookList<'tree> {
7044 pub span: ::treesitter_types::Span,
7045 pub children: ::std::vec::Vec<PropertyHook<'tree>>,
7046}
7047impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHookList<'tree> {
7048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7049 fn from_node(
7050 node: ::treesitter_types::tree_sitter::Node<'tree>,
7051 src: &'tree [u8],
7052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7053 debug_assert_eq!(node.kind(), "property_hook_list");
7054 Ok(Self {
7055 span: ::treesitter_types::Span::from(node),
7056 children: {
7057 #[allow(clippy::suspicious_else_formatting)]
7058 let non_field_children = {
7059 let mut cursor = node.walk();
7060 let mut result = ::std::vec::Vec::new();
7061 if cursor.goto_first_child() {
7062 loop {
7063 if cursor.field_name().is_none()
7064 && cursor.node().is_named()
7065 && !cursor.node().is_extra()
7066 {
7067 result.push(cursor.node());
7068 }
7069 if !cursor.goto_next_sibling() {
7070 break;
7071 }
7072 }
7073 }
7074 result
7075 };
7076 let mut items = ::std::vec::Vec::new();
7077 for child in non_field_children {
7078 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7079 <PropertyHook as ::treesitter_types::FromNode>::from_node(child, src)
7080 })?);
7081 }
7082 items
7083 },
7084 })
7085 }
7086}
7087impl ::treesitter_types::Spanned for PropertyHookList<'_> {
7088 fn span(&self) -> ::treesitter_types::Span {
7089 self.span
7090 }
7091}
7092#[derive(Debug, Clone, PartialEq, Eq)]
7093pub struct PropertyPromotionParameter<'tree> {
7094 pub span: ::treesitter_types::Span,
7095 pub attributes: ::core::option::Option<AttributeList<'tree>>,
7096 pub default_value: ::core::option::Option<Expression<'tree>>,
7097 pub name: PropertyPromotionParameterName<'tree>,
7098 pub readonly: ::core::option::Option<ReadonlyModifier<'tree>>,
7099 pub r#type: ::core::option::Option<Type<'tree>>,
7100 pub visibility: VisibilityModifier<'tree>,
7101 pub children: ::core::option::Option<PropertyHookList<'tree>>,
7102}
7103impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPromotionParameter<'tree> {
7104 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7105 fn from_node(
7106 node: ::treesitter_types::tree_sitter::Node<'tree>,
7107 src: &'tree [u8],
7108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7109 debug_assert_eq!(node.kind(), "property_promotion_parameter");
7110 Ok(Self {
7111 span: ::treesitter_types::Span::from(node),
7112 attributes: match node.child_by_field_name("attributes") {
7113 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7114 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
7115 })?),
7116 None => None,
7117 },
7118 default_value: match node.child_by_field_name("default_value") {
7119 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7120 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7121 })?),
7122 None => None,
7123 },
7124 name: {
7125 let child = node
7126 .child_by_field_name("name")
7127 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7128 ::treesitter_types::runtime::maybe_grow_stack(|| {
7129 <PropertyPromotionParameterName as ::treesitter_types::FromNode>::from_node(
7130 child, src,
7131 )
7132 })?
7133 },
7134 readonly: match node.child_by_field_name("readonly") {
7135 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7136 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(child, src)
7137 })?),
7138 None => None,
7139 },
7140 r#type: match node.child_by_field_name("type") {
7141 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7142 <Type as ::treesitter_types::FromNode>::from_node(child, src)
7143 })?),
7144 None => None,
7145 },
7146 visibility: {
7147 let child = node.child_by_field_name("visibility").ok_or_else(|| {
7148 ::treesitter_types::ParseError::missing_field("visibility", node)
7149 })?;
7150 ::treesitter_types::runtime::maybe_grow_stack(|| {
7151 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)
7152 })?
7153 },
7154 children: {
7155 #[allow(clippy::suspicious_else_formatting)]
7156 let non_field_children = {
7157 let mut cursor = node.walk();
7158 let mut result = ::std::vec::Vec::new();
7159 if cursor.goto_first_child() {
7160 loop {
7161 if cursor.field_name().is_none()
7162 && cursor.node().is_named()
7163 && !cursor.node().is_extra()
7164 {
7165 result.push(cursor.node());
7166 }
7167 if !cursor.goto_next_sibling() {
7168 break;
7169 }
7170 }
7171 }
7172 result
7173 };
7174 match non_field_children.first() {
7175 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7176 <PropertyHookList as ::treesitter_types::FromNode>::from_node(child, src)
7177 })?),
7178 None => None,
7179 }
7180 },
7181 })
7182 }
7183}
7184impl ::treesitter_types::Spanned for PropertyPromotionParameter<'_> {
7185 fn span(&self) -> ::treesitter_types::Span {
7186 self.span
7187 }
7188}
7189#[derive(Debug, Clone, PartialEq, Eq)]
7190pub struct QualifiedName<'tree> {
7191 pub span: ::treesitter_types::Span,
7192 pub prefix: ::std::vec::Vec<QualifiedNamePrefix<'tree>>,
7193 pub children: Name<'tree>,
7194}
7195impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedName<'tree> {
7196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7197 fn from_node(
7198 node: ::treesitter_types::tree_sitter::Node<'tree>,
7199 src: &'tree [u8],
7200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7201 debug_assert_eq!(node.kind(), "qualified_name");
7202 Ok(Self {
7203 span: ::treesitter_types::Span::from(node),
7204 prefix: {
7205 let mut cursor = node.walk();
7206 let mut items = ::std::vec::Vec::new();
7207 for child in node.children_by_field_name("prefix", &mut cursor) {
7208 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7209 <QualifiedNamePrefix as ::treesitter_types::FromNode>::from_node(child, src)
7210 })?);
7211 }
7212 items
7213 },
7214 children: {
7215 #[allow(clippy::suspicious_else_formatting)]
7216 let non_field_children = {
7217 let mut cursor = node.walk();
7218 let mut result = ::std::vec::Vec::new();
7219 if cursor.goto_first_child() {
7220 loop {
7221 if cursor.field_name().is_none()
7222 && cursor.node().is_named()
7223 && !cursor.node().is_extra()
7224 {
7225 result.push(cursor.node());
7226 }
7227 if !cursor.goto_next_sibling() {
7228 break;
7229 }
7230 }
7231 }
7232 result
7233 };
7234 let child = if let Some(&c) = non_field_children.first() {
7235 c
7236 } else {
7237 let mut fallback_cursor = node.walk();
7238 let mut fallback_child = None;
7239 if fallback_cursor.goto_first_child() {
7240 loop {
7241 if fallback_cursor.field_name().is_none()
7242 && !fallback_cursor.node().is_extra()
7243 {
7244 let candidate = fallback_cursor.node();
7245 #[allow(clippy::needless_question_mark)]
7246 if (|| -> ::core::result::Result<
7247 _,
7248 ::treesitter_types::ParseError,
7249 > {
7250 let child = candidate;
7251 Ok(
7252 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
7253 child,
7254 src,
7255 ))?,
7256 )
7257 })()
7258 .is_ok()
7259 {
7260 fallback_child = Some(candidate);
7261 break;
7262 }
7263 }
7264 if !fallback_cursor.goto_next_sibling() {
7265 break;
7266 }
7267 }
7268 }
7269 if fallback_child.is_none() {
7270 let mut cursor2 = node.walk();
7271 if cursor2.goto_first_child() {
7272 loop {
7273 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7274 let candidate = cursor2.node();
7275 #[allow(clippy::needless_question_mark)]
7276 if (|| -> ::core::result::Result<
7277 _,
7278 ::treesitter_types::ParseError,
7279 > {
7280 let child = candidate;
7281 Ok(
7282 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
7283 child,
7284 src,
7285 ))?,
7286 )
7287 })()
7288 .is_ok()
7289 {
7290 fallback_child = Some(candidate);
7291 break;
7292 }
7293 }
7294 if !cursor2.goto_next_sibling() {
7295 break;
7296 }
7297 }
7298 }
7299 }
7300 fallback_child.ok_or_else(|| {
7301 ::treesitter_types::ParseError::missing_field("children", node)
7302 })?
7303 };
7304 ::treesitter_types::runtime::maybe_grow_stack(|| {
7305 <Name as ::treesitter_types::FromNode>::from_node(child, src)
7306 })?
7307 },
7308 })
7309 }
7310}
7311impl ::treesitter_types::Spanned for QualifiedName<'_> {
7312 fn span(&self) -> ::treesitter_types::Span {
7313 self.span
7314 }
7315}
7316#[derive(Debug, Clone, PartialEq, Eq)]
7317pub struct ReadonlyModifier<'tree> {
7318 pub span: ::treesitter_types::Span,
7319 text: &'tree str,
7320}
7321impl<'tree> ::treesitter_types::FromNode<'tree> for ReadonlyModifier<'tree> {
7322 fn from_node(
7323 node: ::treesitter_types::tree_sitter::Node<'tree>,
7324 src: &'tree [u8],
7325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7326 debug_assert_eq!(node.kind(), "readonly_modifier");
7327 Ok(Self {
7328 span: ::treesitter_types::Span::from(node),
7329 text: node.utf8_text(src)?,
7330 })
7331 }
7332}
7333impl<'tree> ::treesitter_types::LeafNode<'tree> for ReadonlyModifier<'tree> {
7334 fn text(&self) -> &'tree str {
7335 self.text
7336 }
7337}
7338impl ::treesitter_types::Spanned for ReadonlyModifier<'_> {
7339 fn span(&self) -> ::treesitter_types::Span {
7340 self.span
7341 }
7342}
7343#[derive(Debug, Clone, PartialEq, Eq)]
7344pub struct ReferenceAssignmentExpression<'tree> {
7345 pub span: ::treesitter_types::Span,
7346 pub left: ReferenceAssignmentExpressionLeft<'tree>,
7347 pub right: Expression<'tree>,
7348}
7349impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceAssignmentExpression<'tree> {
7350 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7351 fn from_node(
7352 node: ::treesitter_types::tree_sitter::Node<'tree>,
7353 src: &'tree [u8],
7354 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7355 debug_assert_eq!(node.kind(), "reference_assignment_expression");
7356 Ok(Self {
7357 span: ::treesitter_types::Span::from(node),
7358 left: {
7359 let child = node
7360 .child_by_field_name("left")
7361 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
7362 ::treesitter_types::runtime::maybe_grow_stack(|| {
7363 <ReferenceAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
7364 child, src,
7365 )
7366 })?
7367 },
7368 right: {
7369 let child = node
7370 .child_by_field_name("right")
7371 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
7372 ::treesitter_types::runtime::maybe_grow_stack(|| {
7373 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7374 })?
7375 },
7376 })
7377 }
7378}
7379impl ::treesitter_types::Spanned for ReferenceAssignmentExpression<'_> {
7380 fn span(&self) -> ::treesitter_types::Span {
7381 self.span
7382 }
7383}
7384#[derive(Debug, Clone, PartialEq, Eq)]
7385pub struct ReferenceModifier<'tree> {
7386 pub span: ::treesitter_types::Span,
7387 text: &'tree str,
7388}
7389impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceModifier<'tree> {
7390 fn from_node(
7391 node: ::treesitter_types::tree_sitter::Node<'tree>,
7392 src: &'tree [u8],
7393 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7394 debug_assert_eq!(node.kind(), "reference_modifier");
7395 Ok(Self {
7396 span: ::treesitter_types::Span::from(node),
7397 text: node.utf8_text(src)?,
7398 })
7399 }
7400}
7401impl<'tree> ::treesitter_types::LeafNode<'tree> for ReferenceModifier<'tree> {
7402 fn text(&self) -> &'tree str {
7403 self.text
7404 }
7405}
7406impl ::treesitter_types::Spanned for ReferenceModifier<'_> {
7407 fn span(&self) -> ::treesitter_types::Span {
7408 self.span
7409 }
7410}
7411#[derive(Debug, Clone, PartialEq, Eq)]
7412pub struct RelativeName<'tree> {
7413 pub span: ::treesitter_types::Span,
7414 pub prefix: ::std::vec::Vec<RelativeNamePrefix<'tree>>,
7415 pub children: Name<'tree>,
7416}
7417impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeName<'tree> {
7418 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7419 fn from_node(
7420 node: ::treesitter_types::tree_sitter::Node<'tree>,
7421 src: &'tree [u8],
7422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7423 debug_assert_eq!(node.kind(), "relative_name");
7424 Ok(Self {
7425 span: ::treesitter_types::Span::from(node),
7426 prefix: {
7427 let mut cursor = node.walk();
7428 let mut items = ::std::vec::Vec::new();
7429 for child in node.children_by_field_name("prefix", &mut cursor) {
7430 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7431 <RelativeNamePrefix as ::treesitter_types::FromNode>::from_node(child, src)
7432 })?);
7433 }
7434 items
7435 },
7436 children: {
7437 #[allow(clippy::suspicious_else_formatting)]
7438 let non_field_children = {
7439 let mut cursor = node.walk();
7440 let mut result = ::std::vec::Vec::new();
7441 if cursor.goto_first_child() {
7442 loop {
7443 if cursor.field_name().is_none()
7444 && cursor.node().is_named()
7445 && !cursor.node().is_extra()
7446 {
7447 result.push(cursor.node());
7448 }
7449 if !cursor.goto_next_sibling() {
7450 break;
7451 }
7452 }
7453 }
7454 result
7455 };
7456 let child = if let Some(&c) = non_field_children.first() {
7457 c
7458 } else {
7459 let mut fallback_cursor = node.walk();
7460 let mut fallback_child = None;
7461 if fallback_cursor.goto_first_child() {
7462 loop {
7463 if fallback_cursor.field_name().is_none()
7464 && !fallback_cursor.node().is_extra()
7465 {
7466 let candidate = fallback_cursor.node();
7467 #[allow(clippy::needless_question_mark)]
7468 if (|| -> ::core::result::Result<
7469 _,
7470 ::treesitter_types::ParseError,
7471 > {
7472 let child = candidate;
7473 Ok(
7474 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
7475 child,
7476 src,
7477 ))?,
7478 )
7479 })()
7480 .is_ok()
7481 {
7482 fallback_child = Some(candidate);
7483 break;
7484 }
7485 }
7486 if !fallback_cursor.goto_next_sibling() {
7487 break;
7488 }
7489 }
7490 }
7491 if fallback_child.is_none() {
7492 let mut cursor2 = node.walk();
7493 if cursor2.goto_first_child() {
7494 loop {
7495 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7496 let candidate = cursor2.node();
7497 #[allow(clippy::needless_question_mark)]
7498 if (|| -> ::core::result::Result<
7499 _,
7500 ::treesitter_types::ParseError,
7501 > {
7502 let child = candidate;
7503 Ok(
7504 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
7505 child,
7506 src,
7507 ))?,
7508 )
7509 })()
7510 .is_ok()
7511 {
7512 fallback_child = Some(candidate);
7513 break;
7514 }
7515 }
7516 if !cursor2.goto_next_sibling() {
7517 break;
7518 }
7519 }
7520 }
7521 }
7522 fallback_child.ok_or_else(|| {
7523 ::treesitter_types::ParseError::missing_field("children", node)
7524 })?
7525 };
7526 ::treesitter_types::runtime::maybe_grow_stack(|| {
7527 <Name as ::treesitter_types::FromNode>::from_node(child, src)
7528 })?
7529 },
7530 })
7531 }
7532}
7533impl ::treesitter_types::Spanned for RelativeName<'_> {
7534 fn span(&self) -> ::treesitter_types::Span {
7535 self.span
7536 }
7537}
7538#[derive(Debug, Clone, PartialEq, Eq)]
7539pub struct RelativeScope<'tree> {
7540 pub span: ::treesitter_types::Span,
7541 text: &'tree str,
7542}
7543impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeScope<'tree> {
7544 fn from_node(
7545 node: ::treesitter_types::tree_sitter::Node<'tree>,
7546 src: &'tree [u8],
7547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7548 debug_assert_eq!(node.kind(), "relative_scope");
7549 Ok(Self {
7550 span: ::treesitter_types::Span::from(node),
7551 text: node.utf8_text(src)?,
7552 })
7553 }
7554}
7555impl<'tree> ::treesitter_types::LeafNode<'tree> for RelativeScope<'tree> {
7556 fn text(&self) -> &'tree str {
7557 self.text
7558 }
7559}
7560impl ::treesitter_types::Spanned for RelativeScope<'_> {
7561 fn span(&self) -> ::treesitter_types::Span {
7562 self.span
7563 }
7564}
7565#[derive(Debug, Clone, PartialEq, Eq)]
7566pub struct RequireExpression<'tree> {
7567 pub span: ::treesitter_types::Span,
7568 pub children: Expression<'tree>,
7569}
7570impl<'tree> ::treesitter_types::FromNode<'tree> for RequireExpression<'tree> {
7571 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7572 fn from_node(
7573 node: ::treesitter_types::tree_sitter::Node<'tree>,
7574 src: &'tree [u8],
7575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7576 debug_assert_eq!(node.kind(), "require_expression");
7577 Ok(Self {
7578 span: ::treesitter_types::Span::from(node),
7579 children: {
7580 #[allow(clippy::suspicious_else_formatting)]
7581 let non_field_children = {
7582 let mut cursor = node.walk();
7583 let mut result = ::std::vec::Vec::new();
7584 if cursor.goto_first_child() {
7585 loop {
7586 if cursor.field_name().is_none()
7587 && cursor.node().is_named()
7588 && !cursor.node().is_extra()
7589 {
7590 result.push(cursor.node());
7591 }
7592 if !cursor.goto_next_sibling() {
7593 break;
7594 }
7595 }
7596 }
7597 result
7598 };
7599 let child = if let Some(&c) = non_field_children.first() {
7600 c
7601 } else {
7602 let mut fallback_cursor = node.walk();
7603 let mut fallback_child = None;
7604 if fallback_cursor.goto_first_child() {
7605 loop {
7606 if fallback_cursor.field_name().is_none()
7607 && !fallback_cursor.node().is_extra()
7608 {
7609 let candidate = fallback_cursor.node();
7610 #[allow(clippy::needless_question_mark)]
7611 if (|| -> ::core::result::Result<
7612 _,
7613 ::treesitter_types::ParseError,
7614 > {
7615 let child = candidate;
7616 Ok(
7617 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7618 child,
7619 src,
7620 ))?,
7621 )
7622 })()
7623 .is_ok()
7624 {
7625 fallback_child = Some(candidate);
7626 break;
7627 }
7628 }
7629 if !fallback_cursor.goto_next_sibling() {
7630 break;
7631 }
7632 }
7633 }
7634 if fallback_child.is_none() {
7635 let mut cursor2 = node.walk();
7636 if cursor2.goto_first_child() {
7637 loop {
7638 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7639 let candidate = cursor2.node();
7640 #[allow(clippy::needless_question_mark)]
7641 if (|| -> ::core::result::Result<
7642 _,
7643 ::treesitter_types::ParseError,
7644 > {
7645 let child = candidate;
7646 Ok(
7647 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7648 child,
7649 src,
7650 ))?,
7651 )
7652 })()
7653 .is_ok()
7654 {
7655 fallback_child = Some(candidate);
7656 break;
7657 }
7658 }
7659 if !cursor2.goto_next_sibling() {
7660 break;
7661 }
7662 }
7663 }
7664 }
7665 fallback_child.ok_or_else(|| {
7666 ::treesitter_types::ParseError::missing_field("children", node)
7667 })?
7668 };
7669 ::treesitter_types::runtime::maybe_grow_stack(|| {
7670 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7671 })?
7672 },
7673 })
7674 }
7675}
7676impl ::treesitter_types::Spanned for RequireExpression<'_> {
7677 fn span(&self) -> ::treesitter_types::Span {
7678 self.span
7679 }
7680}
7681#[derive(Debug, Clone, PartialEq, Eq)]
7682pub struct RequireOnceExpression<'tree> {
7683 pub span: ::treesitter_types::Span,
7684 pub children: Expression<'tree>,
7685}
7686impl<'tree> ::treesitter_types::FromNode<'tree> for RequireOnceExpression<'tree> {
7687 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7688 fn from_node(
7689 node: ::treesitter_types::tree_sitter::Node<'tree>,
7690 src: &'tree [u8],
7691 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7692 debug_assert_eq!(node.kind(), "require_once_expression");
7693 Ok(Self {
7694 span: ::treesitter_types::Span::from(node),
7695 children: {
7696 #[allow(clippy::suspicious_else_formatting)]
7697 let non_field_children = {
7698 let mut cursor = node.walk();
7699 let mut result = ::std::vec::Vec::new();
7700 if cursor.goto_first_child() {
7701 loop {
7702 if cursor.field_name().is_none()
7703 && cursor.node().is_named()
7704 && !cursor.node().is_extra()
7705 {
7706 result.push(cursor.node());
7707 }
7708 if !cursor.goto_next_sibling() {
7709 break;
7710 }
7711 }
7712 }
7713 result
7714 };
7715 let child = if let Some(&c) = non_field_children.first() {
7716 c
7717 } else {
7718 let mut fallback_cursor = node.walk();
7719 let mut fallback_child = None;
7720 if fallback_cursor.goto_first_child() {
7721 loop {
7722 if fallback_cursor.field_name().is_none()
7723 && !fallback_cursor.node().is_extra()
7724 {
7725 let candidate = fallback_cursor.node();
7726 #[allow(clippy::needless_question_mark)]
7727 if (|| -> ::core::result::Result<
7728 _,
7729 ::treesitter_types::ParseError,
7730 > {
7731 let child = candidate;
7732 Ok(
7733 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7734 child,
7735 src,
7736 ))?,
7737 )
7738 })()
7739 .is_ok()
7740 {
7741 fallback_child = Some(candidate);
7742 break;
7743 }
7744 }
7745 if !fallback_cursor.goto_next_sibling() {
7746 break;
7747 }
7748 }
7749 }
7750 if fallback_child.is_none() {
7751 let mut cursor2 = node.walk();
7752 if cursor2.goto_first_child() {
7753 loop {
7754 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7755 let candidate = cursor2.node();
7756 #[allow(clippy::needless_question_mark)]
7757 if (|| -> ::core::result::Result<
7758 _,
7759 ::treesitter_types::ParseError,
7760 > {
7761 let child = candidate;
7762 Ok(
7763 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
7764 child,
7765 src,
7766 ))?,
7767 )
7768 })()
7769 .is_ok()
7770 {
7771 fallback_child = Some(candidate);
7772 break;
7773 }
7774 }
7775 if !cursor2.goto_next_sibling() {
7776 break;
7777 }
7778 }
7779 }
7780 }
7781 fallback_child.ok_or_else(|| {
7782 ::treesitter_types::ParseError::missing_field("children", node)
7783 })?
7784 };
7785 ::treesitter_types::runtime::maybe_grow_stack(|| {
7786 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7787 })?
7788 },
7789 })
7790 }
7791}
7792impl ::treesitter_types::Spanned for RequireOnceExpression<'_> {
7793 fn span(&self) -> ::treesitter_types::Span {
7794 self.span
7795 }
7796}
7797#[derive(Debug, Clone, PartialEq, Eq)]
7798pub struct ReturnStatement<'tree> {
7799 pub span: ::treesitter_types::Span,
7800 pub children: ::core::option::Option<Expression<'tree>>,
7801}
7802impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
7803 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7804 fn from_node(
7805 node: ::treesitter_types::tree_sitter::Node<'tree>,
7806 src: &'tree [u8],
7807 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7808 debug_assert_eq!(node.kind(), "return_statement");
7809 Ok(Self {
7810 span: ::treesitter_types::Span::from(node),
7811 children: {
7812 #[allow(clippy::suspicious_else_formatting)]
7813 let non_field_children = {
7814 let mut cursor = node.walk();
7815 let mut result = ::std::vec::Vec::new();
7816 if cursor.goto_first_child() {
7817 loop {
7818 if cursor.field_name().is_none()
7819 && cursor.node().is_named()
7820 && !cursor.node().is_extra()
7821 {
7822 result.push(cursor.node());
7823 }
7824 if !cursor.goto_next_sibling() {
7825 break;
7826 }
7827 }
7828 }
7829 result
7830 };
7831 match non_field_children.first() {
7832 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7833 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7834 })?),
7835 None => None,
7836 }
7837 },
7838 })
7839 }
7840}
7841impl ::treesitter_types::Spanned for ReturnStatement<'_> {
7842 fn span(&self) -> ::treesitter_types::Span {
7843 self.span
7844 }
7845}
7846#[derive(Debug, Clone, PartialEq, Eq)]
7847pub struct ScopedCallExpression<'tree> {
7848 pub span: ::treesitter_types::Span,
7849 pub arguments: Arguments<'tree>,
7850 pub name: ScopedCallExpressionName<'tree>,
7851 pub scope: ScopedCallExpressionScope<'tree>,
7852}
7853impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpression<'tree> {
7854 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7855 fn from_node(
7856 node: ::treesitter_types::tree_sitter::Node<'tree>,
7857 src: &'tree [u8],
7858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7859 debug_assert_eq!(node.kind(), "scoped_call_expression");
7860 Ok(Self {
7861 span: ::treesitter_types::Span::from(node),
7862 arguments: {
7863 let child = node.child_by_field_name("arguments").ok_or_else(|| {
7864 ::treesitter_types::ParseError::missing_field("arguments", node)
7865 })?;
7866 ::treesitter_types::runtime::maybe_grow_stack(|| {
7867 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)
7868 })?
7869 },
7870 name: {
7871 let child = node
7872 .child_by_field_name("name")
7873 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7874 ::treesitter_types::runtime::maybe_grow_stack(|| {
7875 <ScopedCallExpressionName as ::treesitter_types::FromNode>::from_node(
7876 child, src,
7877 )
7878 })?
7879 },
7880 scope: {
7881 let child = node
7882 .child_by_field_name("scope")
7883 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
7884 ::treesitter_types::runtime::maybe_grow_stack(|| {
7885 <ScopedCallExpressionScope as ::treesitter_types::FromNode>::from_node(
7886 child, src,
7887 )
7888 })?
7889 },
7890 })
7891 }
7892}
7893impl ::treesitter_types::Spanned for ScopedCallExpression<'_> {
7894 fn span(&self) -> ::treesitter_types::Span {
7895 self.span
7896 }
7897}
7898#[derive(Debug, Clone, PartialEq, Eq)]
7899pub struct ScopedPropertyAccessExpression<'tree> {
7900 pub span: ::treesitter_types::Span,
7901 pub name: ScopedPropertyAccessExpressionName<'tree>,
7902 pub scope: ScopedPropertyAccessExpressionScope<'tree>,
7903}
7904impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpression<'tree> {
7905 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7906 fn from_node(
7907 node: ::treesitter_types::tree_sitter::Node<'tree>,
7908 src: &'tree [u8],
7909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7910 debug_assert_eq!(node.kind(), "scoped_property_access_expression");
7911 Ok(Self {
7912 span: ::treesitter_types::Span::from(node),
7913 name: {
7914 let child = node
7915 .child_by_field_name("name")
7916 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7917 ::treesitter_types::runtime::maybe_grow_stack(|| {
7918 <ScopedPropertyAccessExpressionName as ::treesitter_types::FromNode>::from_node(
7919 child, src,
7920 )
7921 })?
7922 },
7923 scope: {
7924 let child = node
7925 .child_by_field_name("scope")
7926 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
7927 ::treesitter_types::runtime::maybe_grow_stack(|| {
7928 <ScopedPropertyAccessExpressionScope as ::treesitter_types::FromNode>::from_node(
7929 child, src,
7930 )
7931 })?
7932 },
7933 })
7934 }
7935}
7936impl ::treesitter_types::Spanned for ScopedPropertyAccessExpression<'_> {
7937 fn span(&self) -> ::treesitter_types::Span {
7938 self.span
7939 }
7940}
7941#[derive(Debug, Clone, PartialEq, Eq)]
7942pub struct SequenceExpression<'tree> {
7943 pub span: ::treesitter_types::Span,
7944 pub children: ::std::vec::Vec<SequenceExpressionChildren<'tree>>,
7945}
7946impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
7947 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7948 fn from_node(
7949 node: ::treesitter_types::tree_sitter::Node<'tree>,
7950 src: &'tree [u8],
7951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7952 debug_assert_eq!(node.kind(), "sequence_expression");
7953 Ok(Self {
7954 span: ::treesitter_types::Span::from(node),
7955 children: {
7956 #[allow(clippy::suspicious_else_formatting)]
7957 let non_field_children = {
7958 let mut cursor = node.walk();
7959 let mut result = ::std::vec::Vec::new();
7960 if cursor.goto_first_child() {
7961 loop {
7962 if cursor.field_name().is_none()
7963 && cursor.node().is_named()
7964 && !cursor.node().is_extra()
7965 {
7966 result.push(cursor.node());
7967 }
7968 if !cursor.goto_next_sibling() {
7969 break;
7970 }
7971 }
7972 }
7973 result
7974 };
7975 let mut items = ::std::vec::Vec::new();
7976 for child in non_field_children {
7977 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7978 <SequenceExpressionChildren as ::treesitter_types::FromNode>::from_node(
7979 child, src,
7980 )
7981 })?);
7982 }
7983 items
7984 },
7985 })
7986 }
7987}
7988impl ::treesitter_types::Spanned for SequenceExpression<'_> {
7989 fn span(&self) -> ::treesitter_types::Span {
7990 self.span
7991 }
7992}
7993#[derive(Debug, Clone, PartialEq, Eq)]
7994pub struct ShellCommandExpression<'tree> {
7995 pub span: ::treesitter_types::Span,
7996 pub children: ::std::vec::Vec<ShellCommandExpressionChildren<'tree>>,
7997}
7998impl<'tree> ::treesitter_types::FromNode<'tree> for ShellCommandExpression<'tree> {
7999 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8000 fn from_node(
8001 node: ::treesitter_types::tree_sitter::Node<'tree>,
8002 src: &'tree [u8],
8003 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8004 debug_assert_eq!(node.kind(), "shell_command_expression");
8005 Ok(Self {
8006 span: ::treesitter_types::Span::from(node),
8007 children: {
8008 #[allow(clippy::suspicious_else_formatting)]
8009 let non_field_children = {
8010 let mut cursor = node.walk();
8011 let mut result = ::std::vec::Vec::new();
8012 if cursor.goto_first_child() {
8013 loop {
8014 if cursor.field_name().is_none()
8015 && cursor.node().is_named()
8016 && !cursor.node().is_extra()
8017 {
8018 result.push(cursor.node());
8019 }
8020 if !cursor.goto_next_sibling() {
8021 break;
8022 }
8023 }
8024 }
8025 result
8026 };
8027 let mut items = ::std::vec::Vec::new();
8028 for child in non_field_children {
8029 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8030 <ShellCommandExpressionChildren as ::treesitter_types::FromNode>::from_node(
8031 child, src,
8032 )
8033 })?);
8034 }
8035 items
8036 },
8037 })
8038 }
8039}
8040impl ::treesitter_types::Spanned for ShellCommandExpression<'_> {
8041 fn span(&self) -> ::treesitter_types::Span {
8042 self.span
8043 }
8044}
8045#[derive(Debug, Clone, PartialEq, Eq)]
8046pub struct SimpleParameter<'tree> {
8047 pub span: ::treesitter_types::Span,
8048 pub attributes: ::core::option::Option<AttributeList<'tree>>,
8049 pub default_value: ::core::option::Option<Expression<'tree>>,
8050 pub name: VariableName<'tree>,
8051 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
8052 pub r#type: ::core::option::Option<Type<'tree>>,
8053}
8054impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleParameter<'tree> {
8055 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8056 fn from_node(
8057 node: ::treesitter_types::tree_sitter::Node<'tree>,
8058 src: &'tree [u8],
8059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8060 debug_assert_eq!(node.kind(), "simple_parameter");
8061 Ok(Self {
8062 span: ::treesitter_types::Span::from(node),
8063 attributes: match node.child_by_field_name("attributes") {
8064 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8065 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
8066 })?),
8067 None => None,
8068 },
8069 default_value: match node.child_by_field_name("default_value") {
8070 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8071 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8072 })?),
8073 None => None,
8074 },
8075 name: {
8076 let child = node
8077 .child_by_field_name("name")
8078 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8079 ::treesitter_types::runtime::maybe_grow_stack(|| {
8080 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)
8081 })?
8082 },
8083 reference_modifier: match node.child_by_field_name("reference_modifier") {
8084 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8085 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
8086 })?),
8087 None => None,
8088 },
8089 r#type: match node.child_by_field_name("type") {
8090 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8091 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8092 })?),
8093 None => None,
8094 },
8095 })
8096 }
8097}
8098impl ::treesitter_types::Spanned for SimpleParameter<'_> {
8099 fn span(&self) -> ::treesitter_types::Span {
8100 self.span
8101 }
8102}
8103#[derive(Debug, Clone, PartialEq, Eq)]
8104pub struct StaticModifier<'tree> {
8105 pub span: ::treesitter_types::Span,
8106 text: &'tree str,
8107}
8108impl<'tree> ::treesitter_types::FromNode<'tree> for StaticModifier<'tree> {
8109 fn from_node(
8110 node: ::treesitter_types::tree_sitter::Node<'tree>,
8111 src: &'tree [u8],
8112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8113 debug_assert_eq!(node.kind(), "static_modifier");
8114 Ok(Self {
8115 span: ::treesitter_types::Span::from(node),
8116 text: node.utf8_text(src)?,
8117 })
8118 }
8119}
8120impl<'tree> ::treesitter_types::LeafNode<'tree> for StaticModifier<'tree> {
8121 fn text(&self) -> &'tree str {
8122 self.text
8123 }
8124}
8125impl ::treesitter_types::Spanned for StaticModifier<'_> {
8126 fn span(&self) -> ::treesitter_types::Span {
8127 self.span
8128 }
8129}
8130#[derive(Debug, Clone, PartialEq, Eq)]
8131pub struct StaticVariableDeclaration<'tree> {
8132 pub span: ::treesitter_types::Span,
8133 pub name: VariableName<'tree>,
8134 pub value: ::core::option::Option<Expression<'tree>>,
8135}
8136impl<'tree> ::treesitter_types::FromNode<'tree> for StaticVariableDeclaration<'tree> {
8137 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8138 fn from_node(
8139 node: ::treesitter_types::tree_sitter::Node<'tree>,
8140 src: &'tree [u8],
8141 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8142 debug_assert_eq!(node.kind(), "static_variable_declaration");
8143 Ok(Self {
8144 span: ::treesitter_types::Span::from(node),
8145 name: {
8146 let child = node
8147 .child_by_field_name("name")
8148 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8149 ::treesitter_types::runtime::maybe_grow_stack(|| {
8150 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)
8151 })?
8152 },
8153 value: match node.child_by_field_name("value") {
8154 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8155 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8156 })?),
8157 None => None,
8158 },
8159 })
8160 }
8161}
8162impl ::treesitter_types::Spanned for StaticVariableDeclaration<'_> {
8163 fn span(&self) -> ::treesitter_types::Span {
8164 self.span
8165 }
8166}
8167#[derive(Debug, Clone, PartialEq, Eq)]
8168pub struct String<'tree> {
8169 pub span: ::treesitter_types::Span,
8170 pub children: ::std::vec::Vec<StringChildren<'tree>>,
8171}
8172impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
8173 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8174 fn from_node(
8175 node: ::treesitter_types::tree_sitter::Node<'tree>,
8176 src: &'tree [u8],
8177 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8178 debug_assert_eq!(node.kind(), "string");
8179 Ok(Self {
8180 span: ::treesitter_types::Span::from(node),
8181 children: {
8182 #[allow(clippy::suspicious_else_formatting)]
8183 let non_field_children = {
8184 let mut cursor = node.walk();
8185 let mut result = ::std::vec::Vec::new();
8186 if cursor.goto_first_child() {
8187 loop {
8188 if cursor.field_name().is_none()
8189 && cursor.node().is_named()
8190 && !cursor.node().is_extra()
8191 {
8192 result.push(cursor.node());
8193 }
8194 if !cursor.goto_next_sibling() {
8195 break;
8196 }
8197 }
8198 }
8199 result
8200 };
8201 let mut items = ::std::vec::Vec::new();
8202 for child in non_field_children {
8203 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8204 <StringChildren as ::treesitter_types::FromNode>::from_node(child, src)
8205 })?);
8206 }
8207 items
8208 },
8209 })
8210 }
8211}
8212impl ::treesitter_types::Spanned for String<'_> {
8213 fn span(&self) -> ::treesitter_types::Span {
8214 self.span
8215 }
8216}
8217#[derive(Debug, Clone, PartialEq, Eq)]
8218pub struct StringContent<'tree> {
8219 pub span: ::treesitter_types::Span,
8220 text: &'tree str,
8221}
8222impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
8223 fn from_node(
8224 node: ::treesitter_types::tree_sitter::Node<'tree>,
8225 src: &'tree [u8],
8226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8227 debug_assert_eq!(node.kind(), "string_content");
8228 Ok(Self {
8229 span: ::treesitter_types::Span::from(node),
8230 text: node.utf8_text(src)?,
8231 })
8232 }
8233}
8234impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
8235 fn text(&self) -> &'tree str {
8236 self.text
8237 }
8238}
8239impl ::treesitter_types::Spanned for StringContent<'_> {
8240 fn span(&self) -> ::treesitter_types::Span {
8241 self.span
8242 }
8243}
8244#[derive(Debug, Clone, PartialEq, Eq)]
8245pub struct SubscriptExpression<'tree> {
8246 pub span: ::treesitter_types::Span,
8247 pub children: ::std::vec::Vec<SubscriptExpressionChildren<'tree>>,
8248}
8249impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
8250 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8251 fn from_node(
8252 node: ::treesitter_types::tree_sitter::Node<'tree>,
8253 src: &'tree [u8],
8254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8255 debug_assert_eq!(node.kind(), "subscript_expression");
8256 Ok(Self {
8257 span: ::treesitter_types::Span::from(node),
8258 children: {
8259 #[allow(clippy::suspicious_else_formatting)]
8260 let non_field_children = {
8261 let mut cursor = node.walk();
8262 let mut result = ::std::vec::Vec::new();
8263 if cursor.goto_first_child() {
8264 loop {
8265 if cursor.field_name().is_none()
8266 && cursor.node().is_named()
8267 && !cursor.node().is_extra()
8268 {
8269 result.push(cursor.node());
8270 }
8271 if !cursor.goto_next_sibling() {
8272 break;
8273 }
8274 }
8275 }
8276 result
8277 };
8278 let mut items = ::std::vec::Vec::new();
8279 for child in non_field_children {
8280 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8281 <SubscriptExpressionChildren as ::treesitter_types::FromNode>::from_node(
8282 child, src,
8283 )
8284 })?);
8285 }
8286 items
8287 },
8288 })
8289 }
8290}
8291impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
8292 fn span(&self) -> ::treesitter_types::Span {
8293 self.span
8294 }
8295}
8296#[derive(Debug, Clone, PartialEq, Eq)]
8297pub struct SwitchBlock<'tree> {
8298 pub span: ::treesitter_types::Span,
8299 pub children: ::std::vec::Vec<SwitchBlockChildren<'tree>>,
8300}
8301impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlock<'tree> {
8302 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8303 fn from_node(
8304 node: ::treesitter_types::tree_sitter::Node<'tree>,
8305 src: &'tree [u8],
8306 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8307 debug_assert_eq!(node.kind(), "switch_block");
8308 Ok(Self {
8309 span: ::treesitter_types::Span::from(node),
8310 children: {
8311 #[allow(clippy::suspicious_else_formatting)]
8312 let non_field_children = {
8313 let mut cursor = node.walk();
8314 let mut result = ::std::vec::Vec::new();
8315 if cursor.goto_first_child() {
8316 loop {
8317 if cursor.field_name().is_none()
8318 && cursor.node().is_named()
8319 && !cursor.node().is_extra()
8320 {
8321 result.push(cursor.node());
8322 }
8323 if !cursor.goto_next_sibling() {
8324 break;
8325 }
8326 }
8327 }
8328 result
8329 };
8330 let mut items = ::std::vec::Vec::new();
8331 for child in non_field_children {
8332 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8333 <SwitchBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)
8334 })?);
8335 }
8336 items
8337 },
8338 })
8339 }
8340}
8341impl ::treesitter_types::Spanned for SwitchBlock<'_> {
8342 fn span(&self) -> ::treesitter_types::Span {
8343 self.span
8344 }
8345}
8346#[derive(Debug, Clone, PartialEq, Eq)]
8347pub struct SwitchStatement<'tree> {
8348 pub span: ::treesitter_types::Span,
8349 pub body: SwitchBlock<'tree>,
8350 pub condition: ParenthesizedExpression<'tree>,
8351}
8352impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
8353 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8354 fn from_node(
8355 node: ::treesitter_types::tree_sitter::Node<'tree>,
8356 src: &'tree [u8],
8357 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8358 debug_assert_eq!(node.kind(), "switch_statement");
8359 Ok(Self {
8360 span: ::treesitter_types::Span::from(node),
8361 body: {
8362 let child = node
8363 .child_by_field_name("body")
8364 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8365 ::treesitter_types::runtime::maybe_grow_stack(|| {
8366 <SwitchBlock as ::treesitter_types::FromNode>::from_node(child, src)
8367 })?
8368 },
8369 condition: {
8370 let child = node.child_by_field_name("condition").ok_or_else(|| {
8371 ::treesitter_types::ParseError::missing_field("condition", node)
8372 })?;
8373 ::treesitter_types::runtime::maybe_grow_stack(|| {
8374 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
8375 })?
8376 },
8377 })
8378 }
8379}
8380impl ::treesitter_types::Spanned for SwitchStatement<'_> {
8381 fn span(&self) -> ::treesitter_types::Span {
8382 self.span
8383 }
8384}
8385#[derive(Debug, Clone, PartialEq, Eq)]
8386pub struct Text<'tree> {
8387 pub span: ::treesitter_types::Span,
8388 text: &'tree str,
8389}
8390impl<'tree> ::treesitter_types::FromNode<'tree> for Text<'tree> {
8391 fn from_node(
8392 node: ::treesitter_types::tree_sitter::Node<'tree>,
8393 src: &'tree [u8],
8394 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8395 debug_assert_eq!(node.kind(), "text");
8396 Ok(Self {
8397 span: ::treesitter_types::Span::from(node),
8398 text: node.utf8_text(src)?,
8399 })
8400 }
8401}
8402impl<'tree> ::treesitter_types::LeafNode<'tree> for Text<'tree> {
8403 fn text(&self) -> &'tree str {
8404 self.text
8405 }
8406}
8407impl ::treesitter_types::Spanned for Text<'_> {
8408 fn span(&self) -> ::treesitter_types::Span {
8409 self.span
8410 }
8411}
8412#[derive(Debug, Clone, PartialEq, Eq)]
8413pub struct TextInterpolation<'tree> {
8414 pub span: ::treesitter_types::Span,
8415 pub children: ::std::vec::Vec<TextInterpolationChildren<'tree>>,
8416}
8417impl<'tree> ::treesitter_types::FromNode<'tree> for TextInterpolation<'tree> {
8418 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8419 fn from_node(
8420 node: ::treesitter_types::tree_sitter::Node<'tree>,
8421 src: &'tree [u8],
8422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8423 debug_assert_eq!(node.kind(), "text_interpolation");
8424 Ok(Self {
8425 span: ::treesitter_types::Span::from(node),
8426 children: {
8427 #[allow(clippy::suspicious_else_formatting)]
8428 let non_field_children = {
8429 let mut cursor = node.walk();
8430 let mut result = ::std::vec::Vec::new();
8431 if cursor.goto_first_child() {
8432 loop {
8433 if cursor.field_name().is_none()
8434 && cursor.node().is_named()
8435 && !cursor.node().is_extra()
8436 {
8437 result.push(cursor.node());
8438 }
8439 if !cursor.goto_next_sibling() {
8440 break;
8441 }
8442 }
8443 }
8444 result
8445 };
8446 let mut items = ::std::vec::Vec::new();
8447 for child in non_field_children {
8448 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8449 <TextInterpolationChildren as ::treesitter_types::FromNode>::from_node(
8450 child, src,
8451 )
8452 })?);
8453 }
8454 items
8455 },
8456 })
8457 }
8458}
8459impl ::treesitter_types::Spanned for TextInterpolation<'_> {
8460 fn span(&self) -> ::treesitter_types::Span {
8461 self.span
8462 }
8463}
8464#[derive(Debug, Clone, PartialEq, Eq)]
8465pub struct ThrowExpression<'tree> {
8466 pub span: ::treesitter_types::Span,
8467 pub children: Expression<'tree>,
8468}
8469impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowExpression<'tree> {
8470 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8471 fn from_node(
8472 node: ::treesitter_types::tree_sitter::Node<'tree>,
8473 src: &'tree [u8],
8474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8475 debug_assert_eq!(node.kind(), "throw_expression");
8476 Ok(Self {
8477 span: ::treesitter_types::Span::from(node),
8478 children: {
8479 #[allow(clippy::suspicious_else_formatting)]
8480 let non_field_children = {
8481 let mut cursor = node.walk();
8482 let mut result = ::std::vec::Vec::new();
8483 if cursor.goto_first_child() {
8484 loop {
8485 if cursor.field_name().is_none()
8486 && cursor.node().is_named()
8487 && !cursor.node().is_extra()
8488 {
8489 result.push(cursor.node());
8490 }
8491 if !cursor.goto_next_sibling() {
8492 break;
8493 }
8494 }
8495 }
8496 result
8497 };
8498 let child = if let Some(&c) = non_field_children.first() {
8499 c
8500 } else {
8501 let mut fallback_cursor = node.walk();
8502 let mut fallback_child = None;
8503 if fallback_cursor.goto_first_child() {
8504 loop {
8505 if fallback_cursor.field_name().is_none()
8506 && !fallback_cursor.node().is_extra()
8507 {
8508 let candidate = fallback_cursor.node();
8509 #[allow(clippy::needless_question_mark)]
8510 if (|| -> ::core::result::Result<
8511 _,
8512 ::treesitter_types::ParseError,
8513 > {
8514 let child = candidate;
8515 Ok(
8516 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8517 child,
8518 src,
8519 ))?,
8520 )
8521 })()
8522 .is_ok()
8523 {
8524 fallback_child = Some(candidate);
8525 break;
8526 }
8527 }
8528 if !fallback_cursor.goto_next_sibling() {
8529 break;
8530 }
8531 }
8532 }
8533 if fallback_child.is_none() {
8534 let mut cursor2 = node.walk();
8535 if cursor2.goto_first_child() {
8536 loop {
8537 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8538 let candidate = cursor2.node();
8539 #[allow(clippy::needless_question_mark)]
8540 if (|| -> ::core::result::Result<
8541 _,
8542 ::treesitter_types::ParseError,
8543 > {
8544 let child = candidate;
8545 Ok(
8546 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
8547 child,
8548 src,
8549 ))?,
8550 )
8551 })()
8552 .is_ok()
8553 {
8554 fallback_child = Some(candidate);
8555 break;
8556 }
8557 }
8558 if !cursor2.goto_next_sibling() {
8559 break;
8560 }
8561 }
8562 }
8563 }
8564 fallback_child.ok_or_else(|| {
8565 ::treesitter_types::ParseError::missing_field("children", node)
8566 })?
8567 };
8568 ::treesitter_types::runtime::maybe_grow_stack(|| {
8569 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8570 })?
8571 },
8572 })
8573 }
8574}
8575impl ::treesitter_types::Spanned for ThrowExpression<'_> {
8576 fn span(&self) -> ::treesitter_types::Span {
8577 self.span
8578 }
8579}
8580#[derive(Debug, Clone, PartialEq, Eq)]
8581pub struct TraitDeclaration<'tree> {
8582 pub span: ::treesitter_types::Span,
8583 pub attributes: ::core::option::Option<AttributeList<'tree>>,
8584 pub body: DeclarationList<'tree>,
8585 pub name: Name<'tree>,
8586}
8587impl<'tree> ::treesitter_types::FromNode<'tree> for TraitDeclaration<'tree> {
8588 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8589 fn from_node(
8590 node: ::treesitter_types::tree_sitter::Node<'tree>,
8591 src: &'tree [u8],
8592 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8593 debug_assert_eq!(node.kind(), "trait_declaration");
8594 Ok(Self {
8595 span: ::treesitter_types::Span::from(node),
8596 attributes: match node.child_by_field_name("attributes") {
8597 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8598 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
8599 })?),
8600 None => None,
8601 },
8602 body: {
8603 let child = node
8604 .child_by_field_name("body")
8605 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8606 ::treesitter_types::runtime::maybe_grow_stack(|| {
8607 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)
8608 })?
8609 },
8610 name: {
8611 let child = node
8612 .child_by_field_name("name")
8613 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8614 ::treesitter_types::runtime::maybe_grow_stack(|| {
8615 <Name as ::treesitter_types::FromNode>::from_node(child, src)
8616 })?
8617 },
8618 })
8619 }
8620}
8621impl ::treesitter_types::Spanned for TraitDeclaration<'_> {
8622 fn span(&self) -> ::treesitter_types::Span {
8623 self.span
8624 }
8625}
8626#[derive(Debug, Clone, PartialEq, Eq)]
8627pub struct TryStatement<'tree> {
8628 pub span: ::treesitter_types::Span,
8629 pub body: CompoundStatement<'tree>,
8630 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
8631}
8632impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
8633 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8634 fn from_node(
8635 node: ::treesitter_types::tree_sitter::Node<'tree>,
8636 src: &'tree [u8],
8637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8638 debug_assert_eq!(node.kind(), "try_statement");
8639 Ok(Self {
8640 span: ::treesitter_types::Span::from(node),
8641 body: {
8642 let child = node
8643 .child_by_field_name("body")
8644 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8645 ::treesitter_types::runtime::maybe_grow_stack(|| {
8646 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)
8647 })?
8648 },
8649 children: {
8650 #[allow(clippy::suspicious_else_formatting)]
8651 let non_field_children = {
8652 let mut cursor = node.walk();
8653 let mut result = ::std::vec::Vec::new();
8654 if cursor.goto_first_child() {
8655 loop {
8656 if cursor.field_name().is_none()
8657 && cursor.node().is_named()
8658 && !cursor.node().is_extra()
8659 {
8660 result.push(cursor.node());
8661 }
8662 if !cursor.goto_next_sibling() {
8663 break;
8664 }
8665 }
8666 }
8667 result
8668 };
8669 let mut items = ::std::vec::Vec::new();
8670 for child in non_field_children {
8671 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8672 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
8673 child, src,
8674 )
8675 })?);
8676 }
8677 items
8678 },
8679 })
8680 }
8681}
8682impl ::treesitter_types::Spanned for TryStatement<'_> {
8683 fn span(&self) -> ::treesitter_types::Span {
8684 self.span
8685 }
8686}
8687#[derive(Debug, Clone, PartialEq, Eq)]
8688pub struct TypeList<'tree> {
8689 pub span: ::treesitter_types::Span,
8690 pub children: ::std::vec::Vec<NamedType<'tree>>,
8691}
8692impl<'tree> ::treesitter_types::FromNode<'tree> for TypeList<'tree> {
8693 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8694 fn from_node(
8695 node: ::treesitter_types::tree_sitter::Node<'tree>,
8696 src: &'tree [u8],
8697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8698 debug_assert_eq!(node.kind(), "type_list");
8699 Ok(Self {
8700 span: ::treesitter_types::Span::from(node),
8701 children: {
8702 #[allow(clippy::suspicious_else_formatting)]
8703 let non_field_children = {
8704 let mut cursor = node.walk();
8705 let mut result = ::std::vec::Vec::new();
8706 if cursor.goto_first_child() {
8707 loop {
8708 if cursor.field_name().is_none()
8709 && cursor.node().is_named()
8710 && !cursor.node().is_extra()
8711 {
8712 result.push(cursor.node());
8713 }
8714 if !cursor.goto_next_sibling() {
8715 break;
8716 }
8717 }
8718 }
8719 result
8720 };
8721 let mut items = ::std::vec::Vec::new();
8722 for child in non_field_children {
8723 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8724 <NamedType as ::treesitter_types::FromNode>::from_node(child, src)
8725 })?);
8726 }
8727 items
8728 },
8729 })
8730 }
8731}
8732impl ::treesitter_types::Spanned for TypeList<'_> {
8733 fn span(&self) -> ::treesitter_types::Span {
8734 self.span
8735 }
8736}
8737#[derive(Debug, Clone, PartialEq, Eq)]
8738pub struct UnaryOpExpression<'tree> {
8739 pub span: ::treesitter_types::Span,
8740 pub argument: ::core::option::Option<Expression<'tree>>,
8741 pub operator: ::core::option::Option<UnaryOpExpressionOperator>,
8742 pub children: ::core::option::Option<Integer<'tree>>,
8743}
8744impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOpExpression<'tree> {
8745 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8746 fn from_node(
8747 node: ::treesitter_types::tree_sitter::Node<'tree>,
8748 src: &'tree [u8],
8749 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8750 debug_assert_eq!(node.kind(), "unary_op_expression");
8751 Ok(Self {
8752 span: ::treesitter_types::Span::from(node),
8753 argument: match node.child_by_field_name("argument") {
8754 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8755 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8756 })?),
8757 None => None,
8758 },
8759 operator: match node.child_by_field_name("operator") {
8760 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8761 <UnaryOpExpressionOperator as ::treesitter_types::FromNode>::from_node(
8762 child, src,
8763 )
8764 })?),
8765 None => None,
8766 },
8767 children: {
8768 #[allow(clippy::suspicious_else_formatting)]
8769 let non_field_children = {
8770 let mut cursor = node.walk();
8771 let mut result = ::std::vec::Vec::new();
8772 if cursor.goto_first_child() {
8773 loop {
8774 if cursor.field_name().is_none()
8775 && cursor.node().is_named()
8776 && !cursor.node().is_extra()
8777 {
8778 result.push(cursor.node());
8779 }
8780 if !cursor.goto_next_sibling() {
8781 break;
8782 }
8783 }
8784 }
8785 result
8786 };
8787 match non_field_children.first() {
8788 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8789 <Integer as ::treesitter_types::FromNode>::from_node(child, src)
8790 })?),
8791 None => None,
8792 }
8793 },
8794 })
8795 }
8796}
8797impl ::treesitter_types::Spanned for UnaryOpExpression<'_> {
8798 fn span(&self) -> ::treesitter_types::Span {
8799 self.span
8800 }
8801}
8802#[derive(Debug, Clone, PartialEq, Eq)]
8803pub struct UnionType<'tree> {
8804 pub span: ::treesitter_types::Span,
8805 pub children: ::std::vec::Vec<UnionTypeChildren<'tree>>,
8806}
8807impl<'tree> ::treesitter_types::FromNode<'tree> for UnionType<'tree> {
8808 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8809 fn from_node(
8810 node: ::treesitter_types::tree_sitter::Node<'tree>,
8811 src: &'tree [u8],
8812 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8813 debug_assert_eq!(node.kind(), "union_type");
8814 Ok(Self {
8815 span: ::treesitter_types::Span::from(node),
8816 children: {
8817 #[allow(clippy::suspicious_else_formatting)]
8818 let non_field_children = {
8819 let mut cursor = node.walk();
8820 let mut result = ::std::vec::Vec::new();
8821 if cursor.goto_first_child() {
8822 loop {
8823 if cursor.field_name().is_none()
8824 && cursor.node().is_named()
8825 && !cursor.node().is_extra()
8826 {
8827 result.push(cursor.node());
8828 }
8829 if !cursor.goto_next_sibling() {
8830 break;
8831 }
8832 }
8833 }
8834 result
8835 };
8836 let mut items = ::std::vec::Vec::new();
8837 for child in non_field_children {
8838 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8839 <UnionTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
8840 })?);
8841 }
8842 items
8843 },
8844 })
8845 }
8846}
8847impl ::treesitter_types::Spanned for UnionType<'_> {
8848 fn span(&self) -> ::treesitter_types::Span {
8849 self.span
8850 }
8851}
8852#[derive(Debug, Clone, PartialEq, Eq)]
8853pub struct UnsetStatement<'tree> {
8854 pub span: ::treesitter_types::Span,
8855 pub children: ::std::vec::Vec<UnsetStatementChildren<'tree>>,
8856}
8857impl<'tree> ::treesitter_types::FromNode<'tree> for UnsetStatement<'tree> {
8858 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8859 fn from_node(
8860 node: ::treesitter_types::tree_sitter::Node<'tree>,
8861 src: &'tree [u8],
8862 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8863 debug_assert_eq!(node.kind(), "unset_statement");
8864 Ok(Self {
8865 span: ::treesitter_types::Span::from(node),
8866 children: {
8867 #[allow(clippy::suspicious_else_formatting)]
8868 let non_field_children = {
8869 let mut cursor = node.walk();
8870 let mut result = ::std::vec::Vec::new();
8871 if cursor.goto_first_child() {
8872 loop {
8873 if cursor.field_name().is_none()
8874 && cursor.node().is_named()
8875 && !cursor.node().is_extra()
8876 {
8877 result.push(cursor.node());
8878 }
8879 if !cursor.goto_next_sibling() {
8880 break;
8881 }
8882 }
8883 }
8884 result
8885 };
8886 let mut items = ::std::vec::Vec::new();
8887 for child in non_field_children {
8888 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8889 <UnsetStatementChildren as ::treesitter_types::FromNode>::from_node(
8890 child, src,
8891 )
8892 })?);
8893 }
8894 items
8895 },
8896 })
8897 }
8898}
8899impl ::treesitter_types::Spanned for UnsetStatement<'_> {
8900 fn span(&self) -> ::treesitter_types::Span {
8901 self.span
8902 }
8903}
8904#[derive(Debug, Clone, PartialEq, Eq)]
8905pub struct UpdateExpression<'tree> {
8906 pub span: ::treesitter_types::Span,
8907 pub argument: UpdateExpressionArgument<'tree>,
8908 pub operator: UpdateExpressionOperator,
8909}
8910impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
8911 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8912 fn from_node(
8913 node: ::treesitter_types::tree_sitter::Node<'tree>,
8914 src: &'tree [u8],
8915 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8916 debug_assert_eq!(node.kind(), "update_expression");
8917 Ok(Self {
8918 span: ::treesitter_types::Span::from(node),
8919 argument: {
8920 let child = node.child_by_field_name("argument").ok_or_else(|| {
8921 ::treesitter_types::ParseError::missing_field("argument", node)
8922 })?;
8923 ::treesitter_types::runtime::maybe_grow_stack(|| {
8924 <UpdateExpressionArgument as ::treesitter_types::FromNode>::from_node(
8925 child, src,
8926 )
8927 })?
8928 },
8929 operator: {
8930 let child = node.child_by_field_name("operator").ok_or_else(|| {
8931 ::treesitter_types::ParseError::missing_field("operator", node)
8932 })?;
8933 ::treesitter_types::runtime::maybe_grow_stack(|| {
8934 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(
8935 child, src,
8936 )
8937 })?
8938 },
8939 })
8940 }
8941}
8942impl ::treesitter_types::Spanned for UpdateExpression<'_> {
8943 fn span(&self) -> ::treesitter_types::Span {
8944 self.span
8945 }
8946}
8947#[derive(Debug, Clone, PartialEq, Eq)]
8948pub struct UseAsClause<'tree> {
8949 pub span: ::treesitter_types::Span,
8950 pub children: ::std::vec::Vec<UseAsClauseChildren<'tree>>,
8951}
8952impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClause<'tree> {
8953 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8954 fn from_node(
8955 node: ::treesitter_types::tree_sitter::Node<'tree>,
8956 src: &'tree [u8],
8957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8958 debug_assert_eq!(node.kind(), "use_as_clause");
8959 Ok(Self {
8960 span: ::treesitter_types::Span::from(node),
8961 children: {
8962 #[allow(clippy::suspicious_else_formatting)]
8963 let non_field_children = {
8964 let mut cursor = node.walk();
8965 let mut result = ::std::vec::Vec::new();
8966 if cursor.goto_first_child() {
8967 loop {
8968 if cursor.field_name().is_none()
8969 && cursor.node().is_named()
8970 && !cursor.node().is_extra()
8971 {
8972 result.push(cursor.node());
8973 }
8974 if !cursor.goto_next_sibling() {
8975 break;
8976 }
8977 }
8978 }
8979 result
8980 };
8981 let mut items = ::std::vec::Vec::new();
8982 for child in non_field_children {
8983 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8984 <UseAsClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)
8985 })?);
8986 }
8987 items
8988 },
8989 })
8990 }
8991}
8992impl ::treesitter_types::Spanned for UseAsClause<'_> {
8993 fn span(&self) -> ::treesitter_types::Span {
8994 self.span
8995 }
8996}
8997#[derive(Debug, Clone, PartialEq, Eq)]
8998pub struct UseDeclaration<'tree> {
8999 pub span: ::treesitter_types::Span,
9000 pub children: ::std::vec::Vec<UseDeclarationChildren<'tree>>,
9001}
9002impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclaration<'tree> {
9003 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9004 fn from_node(
9005 node: ::treesitter_types::tree_sitter::Node<'tree>,
9006 src: &'tree [u8],
9007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9008 debug_assert_eq!(node.kind(), "use_declaration");
9009 Ok(Self {
9010 span: ::treesitter_types::Span::from(node),
9011 children: {
9012 #[allow(clippy::suspicious_else_formatting)]
9013 let non_field_children = {
9014 let mut cursor = node.walk();
9015 let mut result = ::std::vec::Vec::new();
9016 if cursor.goto_first_child() {
9017 loop {
9018 if cursor.field_name().is_none()
9019 && cursor.node().is_named()
9020 && !cursor.node().is_extra()
9021 {
9022 result.push(cursor.node());
9023 }
9024 if !cursor.goto_next_sibling() {
9025 break;
9026 }
9027 }
9028 }
9029 result
9030 };
9031 let mut items = ::std::vec::Vec::new();
9032 for child in non_field_children {
9033 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9034 <UseDeclarationChildren as ::treesitter_types::FromNode>::from_node(
9035 child, src,
9036 )
9037 })?);
9038 }
9039 items
9040 },
9041 })
9042 }
9043}
9044impl ::treesitter_types::Spanned for UseDeclaration<'_> {
9045 fn span(&self) -> ::treesitter_types::Span {
9046 self.span
9047 }
9048}
9049#[derive(Debug, Clone, PartialEq, Eq)]
9050pub struct UseInsteadOfClause<'tree> {
9051 pub span: ::treesitter_types::Span,
9052 pub children: ::std::vec::Vec<UseInsteadOfClauseChildren<'tree>>,
9053}
9054impl<'tree> ::treesitter_types::FromNode<'tree> for UseInsteadOfClause<'tree> {
9055 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9056 fn from_node(
9057 node: ::treesitter_types::tree_sitter::Node<'tree>,
9058 src: &'tree [u8],
9059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9060 debug_assert_eq!(node.kind(), "use_instead_of_clause");
9061 Ok(Self {
9062 span: ::treesitter_types::Span::from(node),
9063 children: {
9064 #[allow(clippy::suspicious_else_formatting)]
9065 let non_field_children = {
9066 let mut cursor = node.walk();
9067 let mut result = ::std::vec::Vec::new();
9068 if cursor.goto_first_child() {
9069 loop {
9070 if cursor.field_name().is_none()
9071 && cursor.node().is_named()
9072 && !cursor.node().is_extra()
9073 {
9074 result.push(cursor.node());
9075 }
9076 if !cursor.goto_next_sibling() {
9077 break;
9078 }
9079 }
9080 }
9081 result
9082 };
9083 let mut items = ::std::vec::Vec::new();
9084 for child in non_field_children {
9085 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9086 <UseInsteadOfClauseChildren as ::treesitter_types::FromNode>::from_node(
9087 child, src,
9088 )
9089 })?);
9090 }
9091 items
9092 },
9093 })
9094 }
9095}
9096impl ::treesitter_types::Spanned for UseInsteadOfClause<'_> {
9097 fn span(&self) -> ::treesitter_types::Span {
9098 self.span
9099 }
9100}
9101#[derive(Debug, Clone, PartialEq, Eq)]
9102pub struct UseList<'tree> {
9103 pub span: ::treesitter_types::Span,
9104 pub children: ::std::vec::Vec<UseListChildren<'tree>>,
9105}
9106impl<'tree> ::treesitter_types::FromNode<'tree> for UseList<'tree> {
9107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9108 fn from_node(
9109 node: ::treesitter_types::tree_sitter::Node<'tree>,
9110 src: &'tree [u8],
9111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9112 debug_assert_eq!(node.kind(), "use_list");
9113 Ok(Self {
9114 span: ::treesitter_types::Span::from(node),
9115 children: {
9116 #[allow(clippy::suspicious_else_formatting)]
9117 let non_field_children = {
9118 let mut cursor = node.walk();
9119 let mut result = ::std::vec::Vec::new();
9120 if cursor.goto_first_child() {
9121 loop {
9122 if cursor.field_name().is_none()
9123 && cursor.node().is_named()
9124 && !cursor.node().is_extra()
9125 {
9126 result.push(cursor.node());
9127 }
9128 if !cursor.goto_next_sibling() {
9129 break;
9130 }
9131 }
9132 }
9133 result
9134 };
9135 let mut items = ::std::vec::Vec::new();
9136 for child in non_field_children {
9137 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9138 <UseListChildren as ::treesitter_types::FromNode>::from_node(child, src)
9139 })?);
9140 }
9141 items
9142 },
9143 })
9144 }
9145}
9146impl ::treesitter_types::Spanned for UseList<'_> {
9147 fn span(&self) -> ::treesitter_types::Span {
9148 self.span
9149 }
9150}
9151#[derive(Debug, Clone, PartialEq, Eq)]
9152pub struct VariableName<'tree> {
9153 pub span: ::treesitter_types::Span,
9154 pub children: Name<'tree>,
9155}
9156impl<'tree> ::treesitter_types::FromNode<'tree> for VariableName<'tree> {
9157 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9158 fn from_node(
9159 node: ::treesitter_types::tree_sitter::Node<'tree>,
9160 src: &'tree [u8],
9161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9162 debug_assert_eq!(node.kind(), "variable_name");
9163 Ok(Self {
9164 span: ::treesitter_types::Span::from(node),
9165 children: {
9166 #[allow(clippy::suspicious_else_formatting)]
9167 let non_field_children = {
9168 let mut cursor = node.walk();
9169 let mut result = ::std::vec::Vec::new();
9170 if cursor.goto_first_child() {
9171 loop {
9172 if cursor.field_name().is_none()
9173 && cursor.node().is_named()
9174 && !cursor.node().is_extra()
9175 {
9176 result.push(cursor.node());
9177 }
9178 if !cursor.goto_next_sibling() {
9179 break;
9180 }
9181 }
9182 }
9183 result
9184 };
9185 let child = if let Some(&c) = non_field_children.first() {
9186 c
9187 } else {
9188 let mut fallback_cursor = node.walk();
9189 let mut fallback_child = None;
9190 if fallback_cursor.goto_first_child() {
9191 loop {
9192 if fallback_cursor.field_name().is_none()
9193 && !fallback_cursor.node().is_extra()
9194 {
9195 let candidate = fallback_cursor.node();
9196 #[allow(clippy::needless_question_mark)]
9197 if (|| -> ::core::result::Result<
9198 _,
9199 ::treesitter_types::ParseError,
9200 > {
9201 let child = candidate;
9202 Ok(
9203 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
9204 child,
9205 src,
9206 ))?,
9207 )
9208 })()
9209 .is_ok()
9210 {
9211 fallback_child = Some(candidate);
9212 break;
9213 }
9214 }
9215 if !fallback_cursor.goto_next_sibling() {
9216 break;
9217 }
9218 }
9219 }
9220 if fallback_child.is_none() {
9221 let mut cursor2 = node.walk();
9222 if cursor2.goto_first_child() {
9223 loop {
9224 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9225 let candidate = cursor2.node();
9226 #[allow(clippy::needless_question_mark)]
9227 if (|| -> ::core::result::Result<
9228 _,
9229 ::treesitter_types::ParseError,
9230 > {
9231 let child = candidate;
9232 Ok(
9233 ::treesitter_types::runtime::maybe_grow_stack(|| <Name as ::treesitter_types::FromNode>::from_node(
9234 child,
9235 src,
9236 ))?,
9237 )
9238 })()
9239 .is_ok()
9240 {
9241 fallback_child = Some(candidate);
9242 break;
9243 }
9244 }
9245 if !cursor2.goto_next_sibling() {
9246 break;
9247 }
9248 }
9249 }
9250 }
9251 fallback_child.ok_or_else(|| {
9252 ::treesitter_types::ParseError::missing_field("children", node)
9253 })?
9254 };
9255 ::treesitter_types::runtime::maybe_grow_stack(|| {
9256 <Name as ::treesitter_types::FromNode>::from_node(child, src)
9257 })?
9258 },
9259 })
9260 }
9261}
9262impl ::treesitter_types::Spanned for VariableName<'_> {
9263 fn span(&self) -> ::treesitter_types::Span {
9264 self.span
9265 }
9266}
9267#[derive(Debug, Clone, PartialEq, Eq)]
9268pub struct VariadicParameter<'tree> {
9269 pub span: ::treesitter_types::Span,
9270 pub attributes: ::core::option::Option<AttributeList<'tree>>,
9271 pub name: VariableName<'tree>,
9272 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
9273 pub r#type: ::core::option::Option<Type<'tree>>,
9274}
9275impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
9276 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9277 fn from_node(
9278 node: ::treesitter_types::tree_sitter::Node<'tree>,
9279 src: &'tree [u8],
9280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9281 debug_assert_eq!(node.kind(), "variadic_parameter");
9282 Ok(Self {
9283 span: ::treesitter_types::Span::from(node),
9284 attributes: match node.child_by_field_name("attributes") {
9285 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9286 <AttributeList as ::treesitter_types::FromNode>::from_node(child, src)
9287 })?),
9288 None => None,
9289 },
9290 name: {
9291 let child = node
9292 .child_by_field_name("name")
9293 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
9294 ::treesitter_types::runtime::maybe_grow_stack(|| {
9295 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)
9296 })?
9297 },
9298 reference_modifier: match node.child_by_field_name("reference_modifier") {
9299 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9300 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)
9301 })?),
9302 None => None,
9303 },
9304 r#type: match node.child_by_field_name("type") {
9305 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9306 <Type as ::treesitter_types::FromNode>::from_node(child, src)
9307 })?),
9308 None => None,
9309 },
9310 })
9311 }
9312}
9313impl ::treesitter_types::Spanned for VariadicParameter<'_> {
9314 fn span(&self) -> ::treesitter_types::Span {
9315 self.span
9316 }
9317}
9318#[derive(Debug, Clone, PartialEq, Eq)]
9319pub struct VariadicPlaceholder<'tree> {
9320 pub span: ::treesitter_types::Span,
9321 text: &'tree str,
9322}
9323impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicPlaceholder<'tree> {
9324 fn from_node(
9325 node: ::treesitter_types::tree_sitter::Node<'tree>,
9326 src: &'tree [u8],
9327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9328 debug_assert_eq!(node.kind(), "variadic_placeholder");
9329 Ok(Self {
9330 span: ::treesitter_types::Span::from(node),
9331 text: node.utf8_text(src)?,
9332 })
9333 }
9334}
9335impl<'tree> ::treesitter_types::LeafNode<'tree> for VariadicPlaceholder<'tree> {
9336 fn text(&self) -> &'tree str {
9337 self.text
9338 }
9339}
9340impl ::treesitter_types::Spanned for VariadicPlaceholder<'_> {
9341 fn span(&self) -> ::treesitter_types::Span {
9342 self.span
9343 }
9344}
9345#[derive(Debug, Clone, PartialEq, Eq)]
9346pub struct VariadicUnpacking<'tree> {
9347 pub span: ::treesitter_types::Span,
9348 pub children: Expression<'tree>,
9349}
9350impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicUnpacking<'tree> {
9351 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9352 fn from_node(
9353 node: ::treesitter_types::tree_sitter::Node<'tree>,
9354 src: &'tree [u8],
9355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9356 debug_assert_eq!(node.kind(), "variadic_unpacking");
9357 Ok(Self {
9358 span: ::treesitter_types::Span::from(node),
9359 children: {
9360 #[allow(clippy::suspicious_else_formatting)]
9361 let non_field_children = {
9362 let mut cursor = node.walk();
9363 let mut result = ::std::vec::Vec::new();
9364 if cursor.goto_first_child() {
9365 loop {
9366 if cursor.field_name().is_none()
9367 && cursor.node().is_named()
9368 && !cursor.node().is_extra()
9369 {
9370 result.push(cursor.node());
9371 }
9372 if !cursor.goto_next_sibling() {
9373 break;
9374 }
9375 }
9376 }
9377 result
9378 };
9379 let child = if let Some(&c) = non_field_children.first() {
9380 c
9381 } else {
9382 let mut fallback_cursor = node.walk();
9383 let mut fallback_child = None;
9384 if fallback_cursor.goto_first_child() {
9385 loop {
9386 if fallback_cursor.field_name().is_none()
9387 && !fallback_cursor.node().is_extra()
9388 {
9389 let candidate = fallback_cursor.node();
9390 #[allow(clippy::needless_question_mark)]
9391 if (|| -> ::core::result::Result<
9392 _,
9393 ::treesitter_types::ParseError,
9394 > {
9395 let child = candidate;
9396 Ok(
9397 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9398 child,
9399 src,
9400 ))?,
9401 )
9402 })()
9403 .is_ok()
9404 {
9405 fallback_child = Some(candidate);
9406 break;
9407 }
9408 }
9409 if !fallback_cursor.goto_next_sibling() {
9410 break;
9411 }
9412 }
9413 }
9414 if fallback_child.is_none() {
9415 let mut cursor2 = node.walk();
9416 if cursor2.goto_first_child() {
9417 loop {
9418 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9419 let candidate = cursor2.node();
9420 #[allow(clippy::needless_question_mark)]
9421 if (|| -> ::core::result::Result<
9422 _,
9423 ::treesitter_types::ParseError,
9424 > {
9425 let child = candidate;
9426 Ok(
9427 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9428 child,
9429 src,
9430 ))?,
9431 )
9432 })()
9433 .is_ok()
9434 {
9435 fallback_child = Some(candidate);
9436 break;
9437 }
9438 }
9439 if !cursor2.goto_next_sibling() {
9440 break;
9441 }
9442 }
9443 }
9444 }
9445 fallback_child.ok_or_else(|| {
9446 ::treesitter_types::ParseError::missing_field("children", node)
9447 })?
9448 };
9449 ::treesitter_types::runtime::maybe_grow_stack(|| {
9450 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9451 })?
9452 },
9453 })
9454 }
9455}
9456impl ::treesitter_types::Spanned for VariadicUnpacking<'_> {
9457 fn span(&self) -> ::treesitter_types::Span {
9458 self.span
9459 }
9460}
9461#[derive(Debug, Clone, PartialEq, Eq)]
9462pub struct VisibilityModifier<'tree> {
9463 pub span: ::treesitter_types::Span,
9464 pub children: ::core::option::Option<Operation<'tree>>,
9465}
9466impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifier<'tree> {
9467 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9468 fn from_node(
9469 node: ::treesitter_types::tree_sitter::Node<'tree>,
9470 src: &'tree [u8],
9471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9472 debug_assert_eq!(node.kind(), "visibility_modifier");
9473 Ok(Self {
9474 span: ::treesitter_types::Span::from(node),
9475 children: {
9476 #[allow(clippy::suspicious_else_formatting)]
9477 let non_field_children = {
9478 let mut cursor = node.walk();
9479 let mut result = ::std::vec::Vec::new();
9480 if cursor.goto_first_child() {
9481 loop {
9482 if cursor.field_name().is_none()
9483 && cursor.node().is_named()
9484 && !cursor.node().is_extra()
9485 {
9486 result.push(cursor.node());
9487 }
9488 if !cursor.goto_next_sibling() {
9489 break;
9490 }
9491 }
9492 }
9493 result
9494 };
9495 match non_field_children.first() {
9496 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9497 <Operation as ::treesitter_types::FromNode>::from_node(child, src)
9498 })?),
9499 None => None,
9500 }
9501 },
9502 })
9503 }
9504}
9505impl ::treesitter_types::Spanned for VisibilityModifier<'_> {
9506 fn span(&self) -> ::treesitter_types::Span {
9507 self.span
9508 }
9509}
9510#[derive(Debug, Clone, PartialEq, Eq)]
9511pub struct WhileStatement<'tree> {
9512 pub span: ::treesitter_types::Span,
9513 pub body: WhileStatementBody<'tree>,
9514 pub condition: ParenthesizedExpression<'tree>,
9515}
9516impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
9517 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9518 fn from_node(
9519 node: ::treesitter_types::tree_sitter::Node<'tree>,
9520 src: &'tree [u8],
9521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9522 debug_assert_eq!(node.kind(), "while_statement");
9523 Ok(Self {
9524 span: ::treesitter_types::Span::from(node),
9525 body: {
9526 let child = node
9527 .child_by_field_name("body")
9528 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9529 ::treesitter_types::runtime::maybe_grow_stack(|| {
9530 <WhileStatementBody as ::treesitter_types::FromNode>::from_node(child, src)
9531 })?
9532 },
9533 condition: {
9534 let child = node.child_by_field_name("condition").ok_or_else(|| {
9535 ::treesitter_types::ParseError::missing_field("condition", node)
9536 })?;
9537 ::treesitter_types::runtime::maybe_grow_stack(|| {
9538 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)
9539 })?
9540 },
9541 })
9542 }
9543}
9544impl ::treesitter_types::Spanned for WhileStatement<'_> {
9545 fn span(&self) -> ::treesitter_types::Span {
9546 self.span
9547 }
9548}
9549#[derive(Debug, Clone, PartialEq, Eq)]
9550pub struct YieldExpression<'tree> {
9551 pub span: ::treesitter_types::Span,
9552 pub children: ::core::option::Option<YieldExpressionChildren<'tree>>,
9553}
9554impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
9555 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9556 fn from_node(
9557 node: ::treesitter_types::tree_sitter::Node<'tree>,
9558 src: &'tree [u8],
9559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9560 debug_assert_eq!(node.kind(), "yield_expression");
9561 Ok(Self {
9562 span: ::treesitter_types::Span::from(node),
9563 children: {
9564 #[allow(clippy::suspicious_else_formatting)]
9565 let non_field_children = {
9566 let mut cursor = node.walk();
9567 let mut result = ::std::vec::Vec::new();
9568 if cursor.goto_first_child() {
9569 loop {
9570 if cursor.field_name().is_none()
9571 && cursor.node().is_named()
9572 && !cursor.node().is_extra()
9573 {
9574 result.push(cursor.node());
9575 }
9576 if !cursor.goto_next_sibling() {
9577 break;
9578 }
9579 }
9580 }
9581 result
9582 };
9583 match non_field_children.first() {
9584 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9585 <YieldExpressionChildren as ::treesitter_types::FromNode>::from_node(
9586 child, src,
9587 )
9588 })?),
9589 None => None,
9590 }
9591 },
9592 })
9593 }
9594}
9595impl ::treesitter_types::Spanned for YieldExpression<'_> {
9596 fn span(&self) -> ::treesitter_types::Span {
9597 self.span
9598 }
9599}
9600#[derive(Debug, Clone, PartialEq, Eq)]
9601pub struct BottomType<'tree> {
9602 pub span: ::treesitter_types::Span,
9603 text: &'tree str,
9604}
9605impl<'tree> ::treesitter_types::FromNode<'tree> for BottomType<'tree> {
9606 fn from_node(
9607 node: ::treesitter_types::tree_sitter::Node<'tree>,
9608 src: &'tree [u8],
9609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9610 debug_assert_eq!(node.kind(), "bottom_type");
9611 Ok(Self {
9612 span: ::treesitter_types::Span::from(node),
9613 text: node.utf8_text(src)?,
9614 })
9615 }
9616}
9617impl<'tree> ::treesitter_types::LeafNode<'tree> for BottomType<'tree> {
9618 fn text(&self) -> &'tree str {
9619 self.text
9620 }
9621}
9622impl ::treesitter_types::Spanned for BottomType<'_> {
9623 fn span(&self) -> ::treesitter_types::Span {
9624 self.span
9625 }
9626}
9627#[derive(Debug, Clone, PartialEq, Eq)]
9628pub struct Comment<'tree> {
9629 pub span: ::treesitter_types::Span,
9630 text: &'tree str,
9631}
9632impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
9633 fn from_node(
9634 node: ::treesitter_types::tree_sitter::Node<'tree>,
9635 src: &'tree [u8],
9636 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9637 debug_assert_eq!(node.kind(), "comment");
9638 Ok(Self {
9639 span: ::treesitter_types::Span::from(node),
9640 text: node.utf8_text(src)?,
9641 })
9642 }
9643}
9644impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
9645 fn text(&self) -> &'tree str {
9646 self.text
9647 }
9648}
9649impl ::treesitter_types::Spanned for Comment<'_> {
9650 fn span(&self) -> ::treesitter_types::Span {
9651 self.span
9652 }
9653}
9654#[derive(Debug, Clone, PartialEq, Eq)]
9655pub struct EscapeSequence<'tree> {
9656 pub span: ::treesitter_types::Span,
9657 text: &'tree str,
9658}
9659impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
9660 fn from_node(
9661 node: ::treesitter_types::tree_sitter::Node<'tree>,
9662 src: &'tree [u8],
9663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9664 debug_assert_eq!(node.kind(), "escape_sequence");
9665 Ok(Self {
9666 span: ::treesitter_types::Span::from(node),
9667 text: node.utf8_text(src)?,
9668 })
9669 }
9670}
9671impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
9672 fn text(&self) -> &'tree str {
9673 self.text
9674 }
9675}
9676impl ::treesitter_types::Spanned for EscapeSequence<'_> {
9677 fn span(&self) -> ::treesitter_types::Span {
9678 self.span
9679 }
9680}
9681#[derive(Debug, Clone, PartialEq, Eq)]
9682pub struct Float<'tree> {
9683 pub span: ::treesitter_types::Span,
9684 text: &'tree str,
9685}
9686impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
9687 fn from_node(
9688 node: ::treesitter_types::tree_sitter::Node<'tree>,
9689 src: &'tree [u8],
9690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9691 debug_assert_eq!(node.kind(), "float");
9692 Ok(Self {
9693 span: ::treesitter_types::Span::from(node),
9694 text: node.utf8_text(src)?,
9695 })
9696 }
9697}
9698impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
9699 fn text(&self) -> &'tree str {
9700 self.text
9701 }
9702}
9703impl ::treesitter_types::Spanned for Float<'_> {
9704 fn span(&self) -> ::treesitter_types::Span {
9705 self.span
9706 }
9707}
9708#[derive(Debug, Clone, PartialEq, Eq)]
9709pub struct HeredocEnd<'tree> {
9710 pub span: ::treesitter_types::Span,
9711 text: &'tree str,
9712}
9713impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocEnd<'tree> {
9714 fn from_node(
9715 node: ::treesitter_types::tree_sitter::Node<'tree>,
9716 src: &'tree [u8],
9717 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9718 debug_assert_eq!(node.kind(), "heredoc_end");
9719 Ok(Self {
9720 span: ::treesitter_types::Span::from(node),
9721 text: node.utf8_text(src)?,
9722 })
9723 }
9724}
9725impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocEnd<'tree> {
9726 fn text(&self) -> &'tree str {
9727 self.text
9728 }
9729}
9730impl ::treesitter_types::Spanned for HeredocEnd<'_> {
9731 fn span(&self) -> ::treesitter_types::Span {
9732 self.span
9733 }
9734}
9735#[derive(Debug, Clone, PartialEq, Eq)]
9736pub struct HeredocStart<'tree> {
9737 pub span: ::treesitter_types::Span,
9738 text: &'tree str,
9739}
9740impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocStart<'tree> {
9741 fn from_node(
9742 node: ::treesitter_types::tree_sitter::Node<'tree>,
9743 src: &'tree [u8],
9744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9745 debug_assert_eq!(node.kind(), "heredoc_start");
9746 Ok(Self {
9747 span: ::treesitter_types::Span::from(node),
9748 text: node.utf8_text(src)?,
9749 })
9750 }
9751}
9752impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocStart<'tree> {
9753 fn text(&self) -> &'tree str {
9754 self.text
9755 }
9756}
9757impl ::treesitter_types::Spanned for HeredocStart<'_> {
9758 fn span(&self) -> ::treesitter_types::Span {
9759 self.span
9760 }
9761}
9762#[derive(Debug, Clone, PartialEq, Eq)]
9763pub struct Integer<'tree> {
9764 pub span: ::treesitter_types::Span,
9765 text: &'tree str,
9766}
9767impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
9768 fn from_node(
9769 node: ::treesitter_types::tree_sitter::Node<'tree>,
9770 src: &'tree [u8],
9771 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9772 debug_assert_eq!(node.kind(), "integer");
9773 Ok(Self {
9774 span: ::treesitter_types::Span::from(node),
9775 text: node.utf8_text(src)?,
9776 })
9777 }
9778}
9779impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
9780 fn text(&self) -> &'tree str {
9781 self.text
9782 }
9783}
9784impl ::treesitter_types::Spanned for Integer<'_> {
9785 fn span(&self) -> ::treesitter_types::Span {
9786 self.span
9787 }
9788}
9789#[derive(Debug, Clone, PartialEq, Eq)]
9790pub struct NowdocString<'tree> {
9791 pub span: ::treesitter_types::Span,
9792 text: &'tree str,
9793}
9794impl<'tree> ::treesitter_types::FromNode<'tree> for NowdocString<'tree> {
9795 fn from_node(
9796 node: ::treesitter_types::tree_sitter::Node<'tree>,
9797 src: &'tree [u8],
9798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9799 debug_assert_eq!(node.kind(), "nowdoc_string");
9800 Ok(Self {
9801 span: ::treesitter_types::Span::from(node),
9802 text: node.utf8_text(src)?,
9803 })
9804 }
9805}
9806impl<'tree> ::treesitter_types::LeafNode<'tree> for NowdocString<'tree> {
9807 fn text(&self) -> &'tree str {
9808 self.text
9809 }
9810}
9811impl ::treesitter_types::Spanned for NowdocString<'_> {
9812 fn span(&self) -> ::treesitter_types::Span {
9813 self.span
9814 }
9815}
9816#[derive(Debug, Clone, PartialEq, Eq)]
9817pub struct Operation<'tree> {
9818 pub span: ::treesitter_types::Span,
9819 text: &'tree str,
9820}
9821impl<'tree> ::treesitter_types::FromNode<'tree> for Operation<'tree> {
9822 fn from_node(
9823 node: ::treesitter_types::tree_sitter::Node<'tree>,
9824 src: &'tree [u8],
9825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9826 debug_assert_eq!(node.kind(), "operation");
9827 Ok(Self {
9828 span: ::treesitter_types::Span::from(node),
9829 text: node.utf8_text(src)?,
9830 })
9831 }
9832}
9833impl<'tree> ::treesitter_types::LeafNode<'tree> for Operation<'tree> {
9834 fn text(&self) -> &'tree str {
9835 self.text
9836 }
9837}
9838impl ::treesitter_types::Spanned for Operation<'_> {
9839 fn span(&self) -> ::treesitter_types::Span {
9840 self.span
9841 }
9842}
9843#[derive(Debug, Clone, PartialEq, Eq)]
9844pub struct PhpEndTag<'tree> {
9845 pub span: ::treesitter_types::Span,
9846 text: &'tree str,
9847}
9848impl<'tree> ::treesitter_types::FromNode<'tree> for PhpEndTag<'tree> {
9849 fn from_node(
9850 node: ::treesitter_types::tree_sitter::Node<'tree>,
9851 src: &'tree [u8],
9852 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9853 debug_assert_eq!(node.kind(), "php_end_tag");
9854 Ok(Self {
9855 span: ::treesitter_types::Span::from(node),
9856 text: node.utf8_text(src)?,
9857 })
9858 }
9859}
9860impl<'tree> ::treesitter_types::LeafNode<'tree> for PhpEndTag<'tree> {
9861 fn text(&self) -> &'tree str {
9862 self.text
9863 }
9864}
9865impl ::treesitter_types::Spanned for PhpEndTag<'_> {
9866 fn span(&self) -> ::treesitter_types::Span {
9867 self.span
9868 }
9869}
9870#[derive(Debug, Clone, PartialEq, Eq)]
9871pub struct PhpTag<'tree> {
9872 pub span: ::treesitter_types::Span,
9873 text: &'tree str,
9874}
9875impl<'tree> ::treesitter_types::FromNode<'tree> for PhpTag<'tree> {
9876 fn from_node(
9877 node: ::treesitter_types::tree_sitter::Node<'tree>,
9878 src: &'tree [u8],
9879 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9880 debug_assert_eq!(node.kind(), "php_tag");
9881 Ok(Self {
9882 span: ::treesitter_types::Span::from(node),
9883 text: node.utf8_text(src)?,
9884 })
9885 }
9886}
9887impl<'tree> ::treesitter_types::LeafNode<'tree> for PhpTag<'tree> {
9888 fn text(&self) -> &'tree str {
9889 self.text
9890 }
9891}
9892impl ::treesitter_types::Spanned for PhpTag<'_> {
9893 fn span(&self) -> ::treesitter_types::Span {
9894 self.span
9895 }
9896}
9897#[derive(Debug, Clone, PartialEq, Eq)]
9898pub struct VarModifier<'tree> {
9899 pub span: ::treesitter_types::Span,
9900 text: &'tree str,
9901}
9902impl<'tree> ::treesitter_types::FromNode<'tree> for VarModifier<'tree> {
9903 fn from_node(
9904 node: ::treesitter_types::tree_sitter::Node<'tree>,
9905 src: &'tree [u8],
9906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9907 debug_assert_eq!(node.kind(), "var_modifier");
9908 Ok(Self {
9909 span: ::treesitter_types::Span::from(node),
9910 text: node.utf8_text(src)?,
9911 })
9912 }
9913}
9914impl<'tree> ::treesitter_types::LeafNode<'tree> for VarModifier<'tree> {
9915 fn text(&self) -> &'tree str {
9916 self.text
9917 }
9918}
9919impl ::treesitter_types::Spanned for VarModifier<'_> {
9920 fn span(&self) -> ::treesitter_types::Span {
9921 self.span
9922 }
9923}
9924#[derive(Debug, Clone, PartialEq, Eq)]
9925pub enum AnonymousClassChildren<'tree> {
9926 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
9927 Arguments(::std::boxed::Box<Arguments<'tree>>),
9928 BaseClause(::std::boxed::Box<BaseClause<'tree>>),
9929 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
9930 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
9931 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
9932 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
9933 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
9934 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
9935}
9936impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousClassChildren<'tree> {
9937 #[allow(clippy::collapsible_else_if)]
9938 fn from_node(
9939 node: ::treesitter_types::tree_sitter::Node<'tree>,
9940 src: &'tree [u8],
9941 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9942 match node.kind() {
9943 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
9944 ::treesitter_types::runtime::maybe_grow_stack(|| {
9945 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
9946 })?,
9947 ))),
9948 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
9949 ::treesitter_types::runtime::maybe_grow_stack(|| {
9950 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
9951 })?,
9952 ))),
9953 "base_clause" => Ok(Self::BaseClause(::std::boxed::Box::new(
9954 ::treesitter_types::runtime::maybe_grow_stack(|| {
9955 <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)
9956 })?,
9957 ))),
9958 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
9959 ::treesitter_types::runtime::maybe_grow_stack(|| {
9960 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)
9961 })?,
9962 ))),
9963 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
9964 ::treesitter_types::runtime::maybe_grow_stack(|| {
9965 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
9966 })?,
9967 ))),
9968 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
9969 ::treesitter_types::runtime::maybe_grow_stack(|| {
9970 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
9971 })?,
9972 ))),
9973 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
9974 ::treesitter_types::runtime::maybe_grow_stack(|| {
9975 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
9976 })?,
9977 ))),
9978 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
9979 ::treesitter_types::runtime::maybe_grow_stack(|| {
9980 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
9981 })?,
9982 ))),
9983 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
9984 ::treesitter_types::runtime::maybe_grow_stack(|| {
9985 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
9986 })?,
9987 ))),
9988 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9989 }
9990 }
9991}
9992impl ::treesitter_types::Spanned for AnonymousClassChildren<'_> {
9993 fn span(&self) -> ::treesitter_types::Span {
9994 match self {
9995 Self::AbstractModifier(inner) => inner.span(),
9996 Self::Arguments(inner) => inner.span(),
9997 Self::BaseClause(inner) => inner.span(),
9998 Self::ClassInterfaceClause(inner) => inner.span(),
9999 Self::FinalModifier(inner) => inner.span(),
10000 Self::ReadonlyModifier(inner) => inner.span(),
10001 Self::StaticModifier(inner) => inner.span(),
10002 Self::VarModifier(inner) => inner.span(),
10003 Self::VisibilityModifier(inner) => inner.span(),
10004 }
10005 }
10006}
10007#[derive(Debug, Clone, PartialEq, Eq)]
10008pub enum AnonymousFunctionReturnType<'tree> {
10009 BottomType(::std::boxed::Box<BottomType<'tree>>),
10010 Type(::std::boxed::Box<Type<'tree>>),
10011}
10012impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionReturnType<'tree> {
10013 #[allow(clippy::collapsible_else_if)]
10014 fn from_node(
10015 node: ::treesitter_types::tree_sitter::Node<'tree>,
10016 src: &'tree [u8],
10017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10018 match node.kind() {
10019 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
10020 ::treesitter_types::runtime::maybe_grow_stack(|| {
10021 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
10022 })?,
10023 ))),
10024 _other => {
10025 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10026 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10027 }) {
10028 Ok(Self::Type(::std::boxed::Box::new(v)))
10029 } else {
10030 Err(::treesitter_types::ParseError::unexpected_kind(
10031 _other, node,
10032 ))
10033 }
10034 }
10035 }
10036 }
10037}
10038impl ::treesitter_types::Spanned for AnonymousFunctionReturnType<'_> {
10039 fn span(&self) -> ::treesitter_types::Span {
10040 match self {
10041 Self::BottomType(inner) => inner.span(),
10042 Self::Type(inner) => inner.span(),
10043 }
10044 }
10045}
10046#[derive(Debug, Clone, PartialEq, Eq)]
10047pub enum AnonymousFunctionUseClauseChildren<'tree> {
10048 ByRef(::std::boxed::Box<ByRef<'tree>>),
10049 VariableName(::std::boxed::Box<VariableName<'tree>>),
10050}
10051impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionUseClauseChildren<'tree> {
10052 #[allow(clippy::collapsible_else_if)]
10053 fn from_node(
10054 node: ::treesitter_types::tree_sitter::Node<'tree>,
10055 src: &'tree [u8],
10056 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10057 match node.kind() {
10058 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
10059 ::treesitter_types::runtime::maybe_grow_stack(|| {
10060 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
10061 })?,
10062 ))),
10063 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10064 ::treesitter_types::runtime::maybe_grow_stack(|| {
10065 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
10066 })?,
10067 ))),
10068 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10069 }
10070 }
10071}
10072impl ::treesitter_types::Spanned for AnonymousFunctionUseClauseChildren<'_> {
10073 fn span(&self) -> ::treesitter_types::Span {
10074 match self {
10075 Self::ByRef(inner) => inner.span(),
10076 Self::VariableName(inner) => inner.span(),
10077 }
10078 }
10079}
10080#[derive(Debug, Clone, PartialEq, Eq)]
10081pub enum ArgumentChildren<'tree> {
10082 Expression(::std::boxed::Box<Expression<'tree>>),
10083 Name(::std::boxed::Box<Name<'tree>>),
10084 VariadicUnpacking(::std::boxed::Box<VariadicUnpacking<'tree>>),
10085}
10086impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentChildren<'tree> {
10087 #[allow(clippy::collapsible_else_if)]
10088 fn from_node(
10089 node: ::treesitter_types::tree_sitter::Node<'tree>,
10090 src: &'tree [u8],
10091 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10092 match node.kind() {
10093 "name" => Ok(Self::Name(::std::boxed::Box::new(
10094 ::treesitter_types::runtime::maybe_grow_stack(|| {
10095 <Name as ::treesitter_types::FromNode>::from_node(node, src)
10096 })?,
10097 ))),
10098 "variadic_unpacking" => Ok(Self::VariadicUnpacking(::std::boxed::Box::new(
10099 ::treesitter_types::runtime::maybe_grow_stack(|| {
10100 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)
10101 })?,
10102 ))),
10103 _other => {
10104 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10105 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10106 }) {
10107 Ok(Self::Expression(::std::boxed::Box::new(v)))
10108 } else {
10109 Err(::treesitter_types::ParseError::unexpected_kind(
10110 _other, node,
10111 ))
10112 }
10113 }
10114 }
10115 }
10116}
10117impl ::treesitter_types::Spanned for ArgumentChildren<'_> {
10118 fn span(&self) -> ::treesitter_types::Span {
10119 match self {
10120 Self::Expression(inner) => inner.span(),
10121 Self::Name(inner) => inner.span(),
10122 Self::VariadicUnpacking(inner) => inner.span(),
10123 }
10124 }
10125}
10126#[derive(Debug, Clone, PartialEq, Eq)]
10127pub enum ArgumentsChildren<'tree> {
10128 Argument(::std::boxed::Box<Argument<'tree>>),
10129 VariadicPlaceholder(::std::boxed::Box<VariadicPlaceholder<'tree>>),
10130}
10131impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
10132 #[allow(clippy::collapsible_else_if)]
10133 fn from_node(
10134 node: ::treesitter_types::tree_sitter::Node<'tree>,
10135 src: &'tree [u8],
10136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10137 match node.kind() {
10138 "argument" => Ok(Self::Argument(::std::boxed::Box::new(
10139 ::treesitter_types::runtime::maybe_grow_stack(|| {
10140 <Argument as ::treesitter_types::FromNode>::from_node(node, src)
10141 })?,
10142 ))),
10143 "variadic_placeholder" => Ok(Self::VariadicPlaceholder(::std::boxed::Box::new(
10144 ::treesitter_types::runtime::maybe_grow_stack(|| {
10145 <VariadicPlaceholder as ::treesitter_types::FromNode>::from_node(node, src)
10146 })?,
10147 ))),
10148 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10149 }
10150 }
10151}
10152impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
10153 fn span(&self) -> ::treesitter_types::Span {
10154 match self {
10155 Self::Argument(inner) => inner.span(),
10156 Self::VariadicPlaceholder(inner) => inner.span(),
10157 }
10158 }
10159}
10160#[derive(Debug, Clone, PartialEq, Eq)]
10161pub enum ArrayElementInitializerChildren<'tree> {
10162 ByRef(::std::boxed::Box<ByRef<'tree>>),
10163 Expression(::std::boxed::Box<Expression<'tree>>),
10164 VariadicUnpacking(::std::boxed::Box<VariadicUnpacking<'tree>>),
10165}
10166impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayElementInitializerChildren<'tree> {
10167 #[allow(clippy::collapsible_else_if)]
10168 fn from_node(
10169 node: ::treesitter_types::tree_sitter::Node<'tree>,
10170 src: &'tree [u8],
10171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10172 match node.kind() {
10173 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
10174 ::treesitter_types::runtime::maybe_grow_stack(|| {
10175 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
10176 })?,
10177 ))),
10178 "variadic_unpacking" => Ok(Self::VariadicUnpacking(::std::boxed::Box::new(
10179 ::treesitter_types::runtime::maybe_grow_stack(|| {
10180 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)
10181 })?,
10182 ))),
10183 _other => {
10184 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10185 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10186 }) {
10187 Ok(Self::Expression(::std::boxed::Box::new(v)))
10188 } else {
10189 Err(::treesitter_types::ParseError::unexpected_kind(
10190 _other, node,
10191 ))
10192 }
10193 }
10194 }
10195 }
10196}
10197impl ::treesitter_types::Spanned for ArrayElementInitializerChildren<'_> {
10198 fn span(&self) -> ::treesitter_types::Span {
10199 match self {
10200 Self::ByRef(inner) => inner.span(),
10201 Self::Expression(inner) => inner.span(),
10202 Self::VariadicUnpacking(inner) => inner.span(),
10203 }
10204 }
10205}
10206#[derive(Debug, Clone, PartialEq, Eq)]
10207pub enum ArrowFunctionReturnType<'tree> {
10208 BottomType(::std::boxed::Box<BottomType<'tree>>),
10209 Type(::std::boxed::Box<Type<'tree>>),
10210}
10211impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionReturnType<'tree> {
10212 #[allow(clippy::collapsible_else_if)]
10213 fn from_node(
10214 node: ::treesitter_types::tree_sitter::Node<'tree>,
10215 src: &'tree [u8],
10216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10217 match node.kind() {
10218 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
10219 ::treesitter_types::runtime::maybe_grow_stack(|| {
10220 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
10221 })?,
10222 ))),
10223 _other => {
10224 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10225 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10226 }) {
10227 Ok(Self::Type(::std::boxed::Box::new(v)))
10228 } else {
10229 Err(::treesitter_types::ParseError::unexpected_kind(
10230 _other, node,
10231 ))
10232 }
10233 }
10234 }
10235 }
10236}
10237impl ::treesitter_types::Spanned for ArrowFunctionReturnType<'_> {
10238 fn span(&self) -> ::treesitter_types::Span {
10239 match self {
10240 Self::BottomType(inner) => inner.span(),
10241 Self::Type(inner) => inner.span(),
10242 }
10243 }
10244}
10245#[derive(Debug, Clone, PartialEq, Eq)]
10246pub enum AssignmentExpressionLeft<'tree> {
10247 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10248 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10249 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10250 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
10251 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10252 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
10253 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10254 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
10255 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
10256 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10257 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10258 VariableName(::std::boxed::Box<VariableName<'tree>>),
10259}
10260impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
10261 #[allow(clippy::collapsible_else_if)]
10262 fn from_node(
10263 node: ::treesitter_types::tree_sitter::Node<'tree>,
10264 src: &'tree [u8],
10265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10266 match node.kind() {
10267 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10268 ::treesitter_types::runtime::maybe_grow_stack(|| {
10269 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
10270 })?,
10271 ))),
10272 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10273 ::treesitter_types::runtime::maybe_grow_stack(|| {
10274 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
10275 })?,
10276 ))),
10277 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10278 ::treesitter_types::runtime::maybe_grow_stack(|| {
10279 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10280 })?,
10281 ))),
10282 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
10283 ::treesitter_types::runtime::maybe_grow_stack(|| {
10284 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
10285 })?,
10286 ))),
10287 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10288 ::treesitter_types::runtime::maybe_grow_stack(|| {
10289 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
10290 })?,
10291 ))),
10292 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10293 ::treesitter_types::runtime::maybe_grow_stack(|| {
10294 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10295 })?,
10296 ))),
10297 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10298 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10299 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10300 node, src,
10301 )
10302 })?),
10303 )),
10304 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
10305 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10306 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10307 node, src,
10308 )
10309 })?),
10310 )),
10311 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10312 ::treesitter_types::runtime::maybe_grow_stack(|| {
10313 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10314 })?,
10315 ))),
10316 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10317 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10318 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10319 node, src,
10320 )
10321 })?),
10322 )),
10323 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10324 ::treesitter_types::runtime::maybe_grow_stack(|| {
10325 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
10326 })?,
10327 ))),
10328 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10329 ::treesitter_types::runtime::maybe_grow_stack(|| {
10330 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
10331 })?,
10332 ))),
10333 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10334 }
10335 }
10336}
10337impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
10338 fn span(&self) -> ::treesitter_types::Span {
10339 match self {
10340 Self::CastExpression(inner) => inner.span(),
10341 Self::DynamicVariableName(inner) => inner.span(),
10342 Self::FunctionCallExpression(inner) => inner.span(),
10343 Self::ListLiteral(inner) => inner.span(),
10344 Self::MemberAccessExpression(inner) => inner.span(),
10345 Self::MemberCallExpression(inner) => inner.span(),
10346 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10347 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10348 Self::ScopedCallExpression(inner) => inner.span(),
10349 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10350 Self::SubscriptExpression(inner) => inner.span(),
10351 Self::VariableName(inner) => inner.span(),
10352 }
10353 }
10354}
10355#[derive(Debug, Clone, PartialEq, Eq)]
10356pub enum AttributeChildren<'tree> {
10357 Name(::std::boxed::Box<Name<'tree>>),
10358 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10359 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10360}
10361impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeChildren<'tree> {
10362 #[allow(clippy::collapsible_else_if)]
10363 fn from_node(
10364 node: ::treesitter_types::tree_sitter::Node<'tree>,
10365 src: &'tree [u8],
10366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10367 match node.kind() {
10368 "name" => Ok(Self::Name(::std::boxed::Box::new(
10369 ::treesitter_types::runtime::maybe_grow_stack(|| {
10370 <Name as ::treesitter_types::FromNode>::from_node(node, src)
10371 })?,
10372 ))),
10373 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10374 ::treesitter_types::runtime::maybe_grow_stack(|| {
10375 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
10376 })?,
10377 ))),
10378 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10379 ::treesitter_types::runtime::maybe_grow_stack(|| {
10380 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
10381 })?,
10382 ))),
10383 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10384 }
10385 }
10386}
10387impl ::treesitter_types::Spanned for AttributeChildren<'_> {
10388 fn span(&self) -> ::treesitter_types::Span {
10389 match self {
10390 Self::Name(inner) => inner.span(),
10391 Self::QualifiedName(inner) => inner.span(),
10392 Self::RelativeName(inner) => inner.span(),
10393 }
10394 }
10395}
10396#[derive(Debug, Clone, PartialEq, Eq)]
10397pub enum AugmentedAssignmentExpressionLeft<'tree> {
10398 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10399 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10400 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10401 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10402 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
10403 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10404 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
10405 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
10406 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10407 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10408 VariableName(::std::boxed::Box<VariableName<'tree>>),
10409}
10410impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
10411 #[allow(clippy::collapsible_else_if)]
10412 fn from_node(
10413 node: ::treesitter_types::tree_sitter::Node<'tree>,
10414 src: &'tree [u8],
10415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10416 match node.kind() {
10417 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10418 ::treesitter_types::runtime::maybe_grow_stack(|| {
10419 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
10420 })?,
10421 ))),
10422 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10423 ::treesitter_types::runtime::maybe_grow_stack(|| {
10424 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
10425 })?,
10426 ))),
10427 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10428 ::treesitter_types::runtime::maybe_grow_stack(|| {
10429 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10430 })?,
10431 ))),
10432 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10433 ::treesitter_types::runtime::maybe_grow_stack(|| {
10434 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
10435 })?,
10436 ))),
10437 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10438 ::treesitter_types::runtime::maybe_grow_stack(|| {
10439 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10440 })?,
10441 ))),
10442 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10443 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10444 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10445 node, src,
10446 )
10447 })?),
10448 )),
10449 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
10450 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10451 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10452 node, src,
10453 )
10454 })?),
10455 )),
10456 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10457 ::treesitter_types::runtime::maybe_grow_stack(|| {
10458 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10459 })?,
10460 ))),
10461 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10462 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10463 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10464 node, src,
10465 )
10466 })?),
10467 )),
10468 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10469 ::treesitter_types::runtime::maybe_grow_stack(|| {
10470 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
10471 })?,
10472 ))),
10473 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10474 ::treesitter_types::runtime::maybe_grow_stack(|| {
10475 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
10476 })?,
10477 ))),
10478 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10479 }
10480 }
10481}
10482impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
10483 fn span(&self) -> ::treesitter_types::Span {
10484 match self {
10485 Self::CastExpression(inner) => inner.span(),
10486 Self::DynamicVariableName(inner) => inner.span(),
10487 Self::FunctionCallExpression(inner) => inner.span(),
10488 Self::MemberAccessExpression(inner) => inner.span(),
10489 Self::MemberCallExpression(inner) => inner.span(),
10490 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10491 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10492 Self::ScopedCallExpression(inner) => inner.span(),
10493 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10494 Self::SubscriptExpression(inner) => inner.span(),
10495 Self::VariableName(inner) => inner.span(),
10496 }
10497 }
10498}
10499#[derive(Debug, Clone, PartialEq, Eq)]
10500pub enum AugmentedAssignmentExpressionOperator {
10501 PercentEq(::treesitter_types::Span),
10502 AmpEq(::treesitter_types::Span),
10503 StarStarEq(::treesitter_types::Span),
10504 StarEq(::treesitter_types::Span),
10505 PlusEq(::treesitter_types::Span),
10506 MinusEq(::treesitter_types::Span),
10507 DotEq(::treesitter_types::Span),
10508 SlashEq(::treesitter_types::Span),
10509 ShlEq(::treesitter_types::Span),
10510 ShrEq(::treesitter_types::Span),
10511 QuestionQuestionEq(::treesitter_types::Span),
10512 CaretEq(::treesitter_types::Span),
10513 PipeEq(::treesitter_types::Span),
10514}
10515impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
10516 #[allow(clippy::collapsible_else_if)]
10517 fn from_node(
10518 node: ::treesitter_types::tree_sitter::Node<'tree>,
10519 _src: &'tree [u8],
10520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10521 match node.kind() {
10522 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
10523 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
10524 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
10525 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
10526 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
10527 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
10528 ".=" => Ok(Self::DotEq(::treesitter_types::Span::from(node))),
10529 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
10530 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
10531 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
10532 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
10533 node,
10534 ))),
10535 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
10536 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
10537 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10538 }
10539 }
10540}
10541impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
10542 fn span(&self) -> ::treesitter_types::Span {
10543 match self {
10544 Self::PercentEq(span) => *span,
10545 Self::AmpEq(span) => *span,
10546 Self::StarStarEq(span) => *span,
10547 Self::StarEq(span) => *span,
10548 Self::PlusEq(span) => *span,
10549 Self::MinusEq(span) => *span,
10550 Self::DotEq(span) => *span,
10551 Self::SlashEq(span) => *span,
10552 Self::ShlEq(span) => *span,
10553 Self::ShrEq(span) => *span,
10554 Self::QuestionQuestionEq(span) => *span,
10555 Self::CaretEq(span) => *span,
10556 Self::PipeEq(span) => *span,
10557 }
10558 }
10559}
10560#[derive(Debug, Clone, PartialEq, Eq)]
10561pub enum BaseClauseChildren<'tree> {
10562 Name(::std::boxed::Box<Name<'tree>>),
10563 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10564 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10565}
10566impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClauseChildren<'tree> {
10567 #[allow(clippy::collapsible_else_if)]
10568 fn from_node(
10569 node: ::treesitter_types::tree_sitter::Node<'tree>,
10570 src: &'tree [u8],
10571 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10572 match node.kind() {
10573 "name" => Ok(Self::Name(::std::boxed::Box::new(
10574 ::treesitter_types::runtime::maybe_grow_stack(|| {
10575 <Name as ::treesitter_types::FromNode>::from_node(node, src)
10576 })?,
10577 ))),
10578 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10579 ::treesitter_types::runtime::maybe_grow_stack(|| {
10580 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
10581 })?,
10582 ))),
10583 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10584 ::treesitter_types::runtime::maybe_grow_stack(|| {
10585 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
10586 })?,
10587 ))),
10588 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10589 }
10590 }
10591}
10592impl ::treesitter_types::Spanned for BaseClauseChildren<'_> {
10593 fn span(&self) -> ::treesitter_types::Span {
10594 match self {
10595 Self::Name(inner) => inner.span(),
10596 Self::QualifiedName(inner) => inner.span(),
10597 Self::RelativeName(inner) => inner.span(),
10598 }
10599 }
10600}
10601#[derive(Debug, Clone, PartialEq, Eq)]
10602pub enum BinaryExpressionOperator {
10603 NotEq(::treesitter_types::Span),
10604 BangEqEq(::treesitter_types::Span),
10605 Percent(::treesitter_types::Span),
10606 Amp(::treesitter_types::Span),
10607 AmpAmp(::treesitter_types::Span),
10608 Star(::treesitter_types::Span),
10609 StarStar(::treesitter_types::Span),
10610 Plus(::treesitter_types::Span),
10611 Minus(::treesitter_types::Span),
10612 Dot(::treesitter_types::Span),
10613 Slash(::treesitter_types::Span),
10614 Lt(::treesitter_types::Span),
10615 Shl(::treesitter_types::Span),
10616 LtEq(::treesitter_types::Span),
10617 LtEqGt(::treesitter_types::Span),
10618 LtGt(::treesitter_types::Span),
10619 EqEq(::treesitter_types::Span),
10620 EqEqEq(::treesitter_types::Span),
10621 Gt(::treesitter_types::Span),
10622 GtEq(::treesitter_types::Span),
10623 Shr(::treesitter_types::Span),
10624 QuestionQuestion(::treesitter_types::Span),
10625 Caret(::treesitter_types::Span),
10626 And(::treesitter_types::Span),
10627 Instanceof(::treesitter_types::Span),
10628 Or(::treesitter_types::Span),
10629 Xor(::treesitter_types::Span),
10630 Pipe(::treesitter_types::Span),
10631 PipeGt(::treesitter_types::Span),
10632 PipePipe(::treesitter_types::Span),
10633}
10634impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
10635 #[allow(clippy::collapsible_else_if)]
10636 fn from_node(
10637 node: ::treesitter_types::tree_sitter::Node<'tree>,
10638 _src: &'tree [u8],
10639 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10640 match node.kind() {
10641 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
10642 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
10643 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
10644 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
10645 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
10646 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
10647 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
10648 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10649 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10650 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
10651 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
10652 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
10653 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
10654 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
10655 "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
10656 "<>" => Ok(Self::LtGt(::treesitter_types::Span::from(node))),
10657 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
10658 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
10659 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
10660 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
10661 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
10662 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
10663 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
10664 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
10665 "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
10666 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
10667 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
10668 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
10669 "|>" => Ok(Self::PipeGt(::treesitter_types::Span::from(node))),
10670 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
10671 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10672 }
10673 }
10674}
10675impl ::treesitter_types::Spanned for BinaryExpressionOperator {
10676 fn span(&self) -> ::treesitter_types::Span {
10677 match self {
10678 Self::NotEq(span) => *span,
10679 Self::BangEqEq(span) => *span,
10680 Self::Percent(span) => *span,
10681 Self::Amp(span) => *span,
10682 Self::AmpAmp(span) => *span,
10683 Self::Star(span) => *span,
10684 Self::StarStar(span) => *span,
10685 Self::Plus(span) => *span,
10686 Self::Minus(span) => *span,
10687 Self::Dot(span) => *span,
10688 Self::Slash(span) => *span,
10689 Self::Lt(span) => *span,
10690 Self::Shl(span) => *span,
10691 Self::LtEq(span) => *span,
10692 Self::LtEqGt(span) => *span,
10693 Self::LtGt(span) => *span,
10694 Self::EqEq(span) => *span,
10695 Self::EqEqEq(span) => *span,
10696 Self::Gt(span) => *span,
10697 Self::GtEq(span) => *span,
10698 Self::Shr(span) => *span,
10699 Self::QuestionQuestion(span) => *span,
10700 Self::Caret(span) => *span,
10701 Self::And(span) => *span,
10702 Self::Instanceof(span) => *span,
10703 Self::Or(span) => *span,
10704 Self::Xor(span) => *span,
10705 Self::Pipe(span) => *span,
10706 Self::PipeGt(span) => *span,
10707 Self::PipePipe(span) => *span,
10708 }
10709 }
10710}
10711#[derive(Debug, Clone, PartialEq, Eq)]
10712pub enum BinaryExpressionRight<'tree> {
10713 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10714 Expression(::std::boxed::Box<Expression<'tree>>),
10715 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10716 Name(::std::boxed::Box<Name<'tree>>),
10717 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10718 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10719 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10720 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10721 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10722 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10723 VariableName(::std::boxed::Box<VariableName<'tree>>),
10724}
10725impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
10726 #[allow(clippy::collapsible_else_if)]
10727 fn from_node(
10728 node: ::treesitter_types::tree_sitter::Node<'tree>,
10729 src: &'tree [u8],
10730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10731 match node.kind() {
10732 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10733 ::treesitter_types::runtime::maybe_grow_stack(|| {
10734 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
10735 })?,
10736 ))),
10737 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10738 ::treesitter_types::runtime::maybe_grow_stack(|| {
10739 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
10740 })?,
10741 ))),
10742 "name" => Ok(Self::Name(::std::boxed::Box::new(
10743 ::treesitter_types::runtime::maybe_grow_stack(|| {
10744 <Name as ::treesitter_types::FromNode>::from_node(node, src)
10745 })?,
10746 ))),
10747 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10748 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10749 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10750 node, src,
10751 )
10752 })?),
10753 )),
10754 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
10755 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10756 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
10757 })?),
10758 )),
10759 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10760 ::treesitter_types::runtime::maybe_grow_stack(|| {
10761 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
10762 })?,
10763 ))),
10764 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10765 ::treesitter_types::runtime::maybe_grow_stack(|| {
10766 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
10767 })?,
10768 ))),
10769 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10770 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10771 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10772 node, src,
10773 )
10774 })?),
10775 )),
10776 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10777 ::treesitter_types::runtime::maybe_grow_stack(|| {
10778 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
10779 })?,
10780 ))),
10781 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10782 ::treesitter_types::runtime::maybe_grow_stack(|| {
10783 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
10784 })?,
10785 ))),
10786 _other => {
10787 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10788 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10789 }) {
10790 Ok(Self::Expression(::std::boxed::Box::new(v)))
10791 } else {
10792 Err(::treesitter_types::ParseError::unexpected_kind(
10793 _other, node,
10794 ))
10795 }
10796 }
10797 }
10798 }
10799}
10800impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
10801 fn span(&self) -> ::treesitter_types::Span {
10802 match self {
10803 Self::DynamicVariableName(inner) => inner.span(),
10804 Self::Expression(inner) => inner.span(),
10805 Self::MemberAccessExpression(inner) => inner.span(),
10806 Self::Name(inner) => inner.span(),
10807 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10808 Self::ParenthesizedExpression(inner) => inner.span(),
10809 Self::QualifiedName(inner) => inner.span(),
10810 Self::RelativeName(inner) => inner.span(),
10811 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10812 Self::SubscriptExpression(inner) => inner.span(),
10813 Self::VariableName(inner) => inner.span(),
10814 }
10815 }
10816}
10817#[derive(Debug, Clone, PartialEq, Eq)]
10818pub enum ByRefChildren<'tree> {
10819 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10820 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10821 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10822 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10823 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
10824 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10825 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
10826 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
10827 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10828 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10829 VariableName(::std::boxed::Box<VariableName<'tree>>),
10830}
10831impl<'tree> ::treesitter_types::FromNode<'tree> for ByRefChildren<'tree> {
10832 #[allow(clippy::collapsible_else_if)]
10833 fn from_node(
10834 node: ::treesitter_types::tree_sitter::Node<'tree>,
10835 src: &'tree [u8],
10836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10837 match node.kind() {
10838 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10839 ::treesitter_types::runtime::maybe_grow_stack(|| {
10840 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
10841 })?,
10842 ))),
10843 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10844 ::treesitter_types::runtime::maybe_grow_stack(|| {
10845 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
10846 })?,
10847 ))),
10848 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10849 ::treesitter_types::runtime::maybe_grow_stack(|| {
10850 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10851 })?,
10852 ))),
10853 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10854 ::treesitter_types::runtime::maybe_grow_stack(|| {
10855 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
10856 })?,
10857 ))),
10858 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10859 ::treesitter_types::runtime::maybe_grow_stack(|| {
10860 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10861 })?,
10862 ))),
10863 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10864 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10865 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10866 node, src,
10867 )
10868 })?),
10869 )),
10870 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
10871 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10872 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10873 node, src,
10874 )
10875 })?),
10876 )),
10877 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10878 ::treesitter_types::runtime::maybe_grow_stack(|| {
10879 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
10880 })?,
10881 ))),
10882 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10883 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10884 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10885 node, src,
10886 )
10887 })?),
10888 )),
10889 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10890 ::treesitter_types::runtime::maybe_grow_stack(|| {
10891 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
10892 })?,
10893 ))),
10894 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10895 ::treesitter_types::runtime::maybe_grow_stack(|| {
10896 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
10897 })?,
10898 ))),
10899 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10900 }
10901 }
10902}
10903impl ::treesitter_types::Spanned for ByRefChildren<'_> {
10904 fn span(&self) -> ::treesitter_types::Span {
10905 match self {
10906 Self::CastExpression(inner) => inner.span(),
10907 Self::DynamicVariableName(inner) => inner.span(),
10908 Self::FunctionCallExpression(inner) => inner.span(),
10909 Self::MemberAccessExpression(inner) => inner.span(),
10910 Self::MemberCallExpression(inner) => inner.span(),
10911 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10912 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10913 Self::ScopedCallExpression(inner) => inner.span(),
10914 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10915 Self::SubscriptExpression(inner) => inner.span(),
10916 Self::VariableName(inner) => inner.span(),
10917 }
10918 }
10919}
10920#[derive(Debug, Clone, PartialEq, Eq)]
10921pub enum CastExpressionValue<'tree> {
10922 CloneExpression(::std::boxed::Box<CloneExpression<'tree>>),
10923 ErrorSuppressionExpression(::std::boxed::Box<ErrorSuppressionExpression<'tree>>),
10924 IncludeExpression(::std::boxed::Box<IncludeExpression<'tree>>),
10925 IncludeOnceExpression(::std::boxed::Box<IncludeOnceExpression<'tree>>),
10926 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10927 UnaryOpExpression(::std::boxed::Box<UnaryOpExpression<'tree>>),
10928}
10929impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpressionValue<'tree> {
10930 #[allow(clippy::collapsible_else_if)]
10931 fn from_node(
10932 node: ::treesitter_types::tree_sitter::Node<'tree>,
10933 src: &'tree [u8],
10934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10935 match node.kind() {
10936 "clone_expression" => Ok(Self::CloneExpression(::std::boxed::Box::new(
10937 ::treesitter_types::runtime::maybe_grow_stack(|| {
10938 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)
10939 })?,
10940 ))),
10941 "error_suppression_expression" => Ok(Self::ErrorSuppressionExpression(
10942 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
10943 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(
10944 node, src,
10945 )
10946 })?),
10947 )),
10948 "include_expression" => Ok(Self::IncludeExpression(::std::boxed::Box::new(
10949 ::treesitter_types::runtime::maybe_grow_stack(|| {
10950 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)
10951 })?,
10952 ))),
10953 "include_once_expression" => Ok(Self::IncludeOnceExpression(::std::boxed::Box::new(
10954 ::treesitter_types::runtime::maybe_grow_stack(|| {
10955 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
10956 })?,
10957 ))),
10958 "unary_op_expression" => Ok(Self::UnaryOpExpression(::std::boxed::Box::new(
10959 ::treesitter_types::runtime::maybe_grow_stack(|| {
10960 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)
10961 })?,
10962 ))),
10963 _other => {
10964 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10965 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10966 }) {
10967 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10968 } else {
10969 Err(::treesitter_types::ParseError::unexpected_kind(
10970 _other, node,
10971 ))
10972 }
10973 }
10974 }
10975 }
10976}
10977impl ::treesitter_types::Spanned for CastExpressionValue<'_> {
10978 fn span(&self) -> ::treesitter_types::Span {
10979 match self {
10980 Self::CloneExpression(inner) => inner.span(),
10981 Self::ErrorSuppressionExpression(inner) => inner.span(),
10982 Self::IncludeExpression(inner) => inner.span(),
10983 Self::IncludeOnceExpression(inner) => inner.span(),
10984 Self::PrimaryExpression(inner) => inner.span(),
10985 Self::UnaryOpExpression(inner) => inner.span(),
10986 }
10987 }
10988}
10989#[derive(Debug, Clone, PartialEq, Eq)]
10990pub enum ClassConstantAccessExpressionChildren<'tree> {
10991 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
10992 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10993 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
10994 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10995 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
10996 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10997 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
10998 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10999 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
11000 Name(::std::boxed::Box<Name<'tree>>),
11001 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
11002 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
11003 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
11004 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
11005 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
11006 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
11007 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
11008 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
11009 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
11010 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
11011 String(::std::boxed::Box<String<'tree>>),
11012 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11013 VariableName(::std::boxed::Box<VariableName<'tree>>),
11014}
11015impl<'tree> ::treesitter_types::FromNode<'tree> for ClassConstantAccessExpressionChildren<'tree> {
11016 #[allow(clippy::collapsible_else_if)]
11017 fn from_node(
11018 node: ::treesitter_types::tree_sitter::Node<'tree>,
11019 src: &'tree [u8],
11020 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11021 match node.kind() {
11022 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
11023 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11024 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
11025 })?),
11026 )),
11027 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
11028 ::treesitter_types::runtime::maybe_grow_stack(|| {
11029 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
11030 })?,
11031 ))),
11032 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
11033 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11034 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
11035 node, src,
11036 )
11037 })?),
11038 )),
11039 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11040 ::treesitter_types::runtime::maybe_grow_stack(|| {
11041 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
11042 })?,
11043 ))),
11044 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
11045 ::treesitter_types::runtime::maybe_grow_stack(|| {
11046 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
11047 })?,
11048 ))),
11049 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
11050 ::treesitter_types::runtime::maybe_grow_stack(|| {
11051 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
11052 })?,
11053 ))),
11054 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
11055 ::treesitter_types::runtime::maybe_grow_stack(|| {
11056 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
11057 })?,
11058 ))),
11059 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
11060 ::treesitter_types::runtime::maybe_grow_stack(|| {
11061 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
11062 })?,
11063 ))),
11064 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
11065 ::treesitter_types::runtime::maybe_grow_stack(|| {
11066 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
11067 })?,
11068 ))),
11069 "name" => Ok(Self::Name(::std::boxed::Box::new(
11070 ::treesitter_types::runtime::maybe_grow_stack(|| {
11071 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11072 })?,
11073 ))),
11074 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
11075 ::treesitter_types::runtime::maybe_grow_stack(|| {
11076 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
11077 })?,
11078 ))),
11079 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
11080 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11081 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
11082 node, src,
11083 )
11084 })?),
11085 )),
11086 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
11087 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11088 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
11089 node, src,
11090 )
11091 })?),
11092 )),
11093 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
11094 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11095 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
11096 })?),
11097 )),
11098 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
11099 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11100 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
11101 })?),
11102 )),
11103 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
11104 ::treesitter_types::runtime::maybe_grow_stack(|| {
11105 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
11106 })?,
11107 ))),
11108 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
11109 ::treesitter_types::runtime::maybe_grow_stack(|| {
11110 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
11111 })?,
11112 ))),
11113 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
11114 ::treesitter_types::runtime::maybe_grow_stack(|| {
11115 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)
11116 })?,
11117 ))),
11118 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
11119 ::treesitter_types::runtime::maybe_grow_stack(|| {
11120 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
11121 })?,
11122 ))),
11123 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
11124 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
11125 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
11126 node, src,
11127 )
11128 })?),
11129 )),
11130 "string" => Ok(Self::String(::std::boxed::Box::new(
11131 ::treesitter_types::runtime::maybe_grow_stack(|| {
11132 <String as ::treesitter_types::FromNode>::from_node(node, src)
11133 })?,
11134 ))),
11135 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11136 ::treesitter_types::runtime::maybe_grow_stack(|| {
11137 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
11138 })?,
11139 ))),
11140 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11141 ::treesitter_types::runtime::maybe_grow_stack(|| {
11142 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
11143 })?,
11144 ))),
11145 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11146 }
11147 }
11148}
11149impl ::treesitter_types::Spanned for ClassConstantAccessExpressionChildren<'_> {
11150 fn span(&self) -> ::treesitter_types::Span {
11151 match self {
11152 Self::ArrayCreationExpression(inner) => inner.span(),
11153 Self::CastExpression(inner) => inner.span(),
11154 Self::ClassConstantAccessExpression(inner) => inner.span(),
11155 Self::DynamicVariableName(inner) => inner.span(),
11156 Self::EncapsedString(inner) => inner.span(),
11157 Self::FunctionCallExpression(inner) => inner.span(),
11158 Self::Heredoc(inner) => inner.span(),
11159 Self::MemberAccessExpression(inner) => inner.span(),
11160 Self::MemberCallExpression(inner) => inner.span(),
11161 Self::Name(inner) => inner.span(),
11162 Self::Nowdoc(inner) => inner.span(),
11163 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
11164 Self::NullsafeMemberCallExpression(inner) => inner.span(),
11165 Self::ObjectCreationExpression(inner) => inner.span(),
11166 Self::ParenthesizedExpression(inner) => inner.span(),
11167 Self::QualifiedName(inner) => inner.span(),
11168 Self::RelativeName(inner) => inner.span(),
11169 Self::RelativeScope(inner) => inner.span(),
11170 Self::ScopedCallExpression(inner) => inner.span(),
11171 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
11172 Self::String(inner) => inner.span(),
11173 Self::SubscriptExpression(inner) => inner.span(),
11174 Self::VariableName(inner) => inner.span(),
11175 }
11176 }
11177}
11178#[derive(Debug, Clone, PartialEq, Eq)]
11179pub enum ClassDeclarationChildren<'tree> {
11180 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
11181 BaseClause(::std::boxed::Box<BaseClause<'tree>>),
11182 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
11183 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
11184 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
11185 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
11186 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
11187 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11188}
11189impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarationChildren<'tree> {
11190 #[allow(clippy::collapsible_else_if)]
11191 fn from_node(
11192 node: ::treesitter_types::tree_sitter::Node<'tree>,
11193 src: &'tree [u8],
11194 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11195 match node.kind() {
11196 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
11197 ::treesitter_types::runtime::maybe_grow_stack(|| {
11198 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
11199 })?,
11200 ))),
11201 "base_clause" => Ok(Self::BaseClause(::std::boxed::Box::new(
11202 ::treesitter_types::runtime::maybe_grow_stack(|| {
11203 <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)
11204 })?,
11205 ))),
11206 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
11207 ::treesitter_types::runtime::maybe_grow_stack(|| {
11208 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)
11209 })?,
11210 ))),
11211 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
11212 ::treesitter_types::runtime::maybe_grow_stack(|| {
11213 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
11214 })?,
11215 ))),
11216 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
11217 ::treesitter_types::runtime::maybe_grow_stack(|| {
11218 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
11219 })?,
11220 ))),
11221 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
11222 ::treesitter_types::runtime::maybe_grow_stack(|| {
11223 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
11224 })?,
11225 ))),
11226 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
11227 ::treesitter_types::runtime::maybe_grow_stack(|| {
11228 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
11229 })?,
11230 ))),
11231 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11232 ::treesitter_types::runtime::maybe_grow_stack(|| {
11233 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11234 })?,
11235 ))),
11236 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11237 }
11238 }
11239}
11240impl ::treesitter_types::Spanned for ClassDeclarationChildren<'_> {
11241 fn span(&self) -> ::treesitter_types::Span {
11242 match self {
11243 Self::AbstractModifier(inner) => inner.span(),
11244 Self::BaseClause(inner) => inner.span(),
11245 Self::ClassInterfaceClause(inner) => inner.span(),
11246 Self::FinalModifier(inner) => inner.span(),
11247 Self::ReadonlyModifier(inner) => inner.span(),
11248 Self::StaticModifier(inner) => inner.span(),
11249 Self::VarModifier(inner) => inner.span(),
11250 Self::VisibilityModifier(inner) => inner.span(),
11251 }
11252 }
11253}
11254#[derive(Debug, Clone, PartialEq, Eq)]
11255pub enum ClassInterfaceClauseChildren<'tree> {
11256 Name(::std::boxed::Box<Name<'tree>>),
11257 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
11258 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
11259}
11260impl<'tree> ::treesitter_types::FromNode<'tree> for ClassInterfaceClauseChildren<'tree> {
11261 #[allow(clippy::collapsible_else_if)]
11262 fn from_node(
11263 node: ::treesitter_types::tree_sitter::Node<'tree>,
11264 src: &'tree [u8],
11265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11266 match node.kind() {
11267 "name" => Ok(Self::Name(::std::boxed::Box::new(
11268 ::treesitter_types::runtime::maybe_grow_stack(|| {
11269 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11270 })?,
11271 ))),
11272 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
11273 ::treesitter_types::runtime::maybe_grow_stack(|| {
11274 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
11275 })?,
11276 ))),
11277 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
11278 ::treesitter_types::runtime::maybe_grow_stack(|| {
11279 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
11280 })?,
11281 ))),
11282 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11283 }
11284 }
11285}
11286impl ::treesitter_types::Spanned for ClassInterfaceClauseChildren<'_> {
11287 fn span(&self) -> ::treesitter_types::Span {
11288 match self {
11289 Self::Name(inner) => inner.span(),
11290 Self::QualifiedName(inner) => inner.span(),
11291 Self::RelativeName(inner) => inner.span(),
11292 }
11293 }
11294}
11295#[derive(Debug, Clone, PartialEq, Eq)]
11296pub enum ConstDeclarationChildren<'tree> {
11297 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
11298 ConstElement(::std::boxed::Box<ConstElement<'tree>>),
11299 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
11300 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
11301 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
11302 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
11303 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
11304}
11305impl<'tree> ::treesitter_types::FromNode<'tree> for ConstDeclarationChildren<'tree> {
11306 #[allow(clippy::collapsible_else_if)]
11307 fn from_node(
11308 node: ::treesitter_types::tree_sitter::Node<'tree>,
11309 src: &'tree [u8],
11310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11311 match node.kind() {
11312 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
11313 ::treesitter_types::runtime::maybe_grow_stack(|| {
11314 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
11315 })?,
11316 ))),
11317 "const_element" => Ok(Self::ConstElement(::std::boxed::Box::new(
11318 ::treesitter_types::runtime::maybe_grow_stack(|| {
11319 <ConstElement as ::treesitter_types::FromNode>::from_node(node, src)
11320 })?,
11321 ))),
11322 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
11323 ::treesitter_types::runtime::maybe_grow_stack(|| {
11324 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
11325 })?,
11326 ))),
11327 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
11328 ::treesitter_types::runtime::maybe_grow_stack(|| {
11329 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
11330 })?,
11331 ))),
11332 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
11333 ::treesitter_types::runtime::maybe_grow_stack(|| {
11334 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
11335 })?,
11336 ))),
11337 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
11338 ::treesitter_types::runtime::maybe_grow_stack(|| {
11339 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
11340 })?,
11341 ))),
11342 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
11343 ::treesitter_types::runtime::maybe_grow_stack(|| {
11344 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
11345 })?,
11346 ))),
11347 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11348 }
11349 }
11350}
11351impl ::treesitter_types::Spanned for ConstDeclarationChildren<'_> {
11352 fn span(&self) -> ::treesitter_types::Span {
11353 match self {
11354 Self::AbstractModifier(inner) => inner.span(),
11355 Self::ConstElement(inner) => inner.span(),
11356 Self::FinalModifier(inner) => inner.span(),
11357 Self::ReadonlyModifier(inner) => inner.span(),
11358 Self::StaticModifier(inner) => inner.span(),
11359 Self::VarModifier(inner) => inner.span(),
11360 Self::VisibilityModifier(inner) => inner.span(),
11361 }
11362 }
11363}
11364#[derive(Debug, Clone, PartialEq, Eq)]
11365pub enum ConstElementChildren<'tree> {
11366 Expression(::std::boxed::Box<Expression<'tree>>),
11367 Name(::std::boxed::Box<Name<'tree>>),
11368}
11369impl<'tree> ::treesitter_types::FromNode<'tree> for ConstElementChildren<'tree> {
11370 #[allow(clippy::collapsible_else_if)]
11371 fn from_node(
11372 node: ::treesitter_types::tree_sitter::Node<'tree>,
11373 src: &'tree [u8],
11374 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11375 match node.kind() {
11376 "name" => Ok(Self::Name(::std::boxed::Box::new(
11377 ::treesitter_types::runtime::maybe_grow_stack(|| {
11378 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11379 })?,
11380 ))),
11381 _other => {
11382 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11383 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11384 }) {
11385 Ok(Self::Expression(::std::boxed::Box::new(v)))
11386 } else {
11387 Err(::treesitter_types::ParseError::unexpected_kind(
11388 _other, node,
11389 ))
11390 }
11391 }
11392 }
11393 }
11394}
11395impl ::treesitter_types::Spanned for ConstElementChildren<'_> {
11396 fn span(&self) -> ::treesitter_types::Span {
11397 match self {
11398 Self::Expression(inner) => inner.span(),
11399 Self::Name(inner) => inner.span(),
11400 }
11401 }
11402}
11403#[derive(Debug, Clone, PartialEq, Eq)]
11404pub enum DeclarationListChildren<'tree> {
11405 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
11406 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
11407 PropertyDeclaration(::std::boxed::Box<PropertyDeclaration<'tree>>),
11408 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
11409}
11410impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationListChildren<'tree> {
11411 #[allow(clippy::collapsible_else_if)]
11412 fn from_node(
11413 node: ::treesitter_types::tree_sitter::Node<'tree>,
11414 src: &'tree [u8],
11415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11416 match node.kind() {
11417 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
11418 ::treesitter_types::runtime::maybe_grow_stack(|| {
11419 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11420 })?,
11421 ))),
11422 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
11423 ::treesitter_types::runtime::maybe_grow_stack(|| {
11424 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11425 })?,
11426 ))),
11427 "property_declaration" => Ok(Self::PropertyDeclaration(::std::boxed::Box::new(
11428 ::treesitter_types::runtime::maybe_grow_stack(|| {
11429 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11430 })?,
11431 ))),
11432 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
11433 ::treesitter_types::runtime::maybe_grow_stack(|| {
11434 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11435 })?,
11436 ))),
11437 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11438 }
11439 }
11440}
11441impl ::treesitter_types::Spanned for DeclarationListChildren<'_> {
11442 fn span(&self) -> ::treesitter_types::Span {
11443 match self {
11444 Self::ConstDeclaration(inner) => inner.span(),
11445 Self::MethodDeclaration(inner) => inner.span(),
11446 Self::PropertyDeclaration(inner) => inner.span(),
11447 Self::UseDeclaration(inner) => inner.span(),
11448 }
11449 }
11450}
11451#[derive(Debug, Clone, PartialEq, Eq)]
11452pub enum DeclareStatementChildren<'tree> {
11453 DeclareDirective(::std::boxed::Box<DeclareDirective<'tree>>),
11454 Statement(::std::boxed::Box<Statement<'tree>>),
11455}
11456impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareStatementChildren<'tree> {
11457 #[allow(clippy::collapsible_else_if)]
11458 fn from_node(
11459 node: ::treesitter_types::tree_sitter::Node<'tree>,
11460 src: &'tree [u8],
11461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11462 match node.kind() {
11463 "declare_directive" => Ok(Self::DeclareDirective(::std::boxed::Box::new(
11464 ::treesitter_types::runtime::maybe_grow_stack(|| {
11465 <DeclareDirective as ::treesitter_types::FromNode>::from_node(node, src)
11466 })?,
11467 ))),
11468 _other => {
11469 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11470 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11471 }) {
11472 Ok(Self::Statement(::std::boxed::Box::new(v)))
11473 } else {
11474 Err(::treesitter_types::ParseError::unexpected_kind(
11475 _other, node,
11476 ))
11477 }
11478 }
11479 }
11480 }
11481}
11482impl ::treesitter_types::Spanned for DeclareStatementChildren<'_> {
11483 fn span(&self) -> ::treesitter_types::Span {
11484 match self {
11485 Self::DeclareDirective(inner) => inner.span(),
11486 Self::Statement(inner) => inner.span(),
11487 }
11488 }
11489}
11490#[derive(Debug, Clone, PartialEq, Eq)]
11491pub enum DisjunctiveNormalFormTypeChildren<'tree> {
11492 IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
11493 NamedType(::std::boxed::Box<NamedType<'tree>>),
11494 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
11495 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11496}
11497impl<'tree> ::treesitter_types::FromNode<'tree> for DisjunctiveNormalFormTypeChildren<'tree> {
11498 #[allow(clippy::collapsible_else_if)]
11499 fn from_node(
11500 node: ::treesitter_types::tree_sitter::Node<'tree>,
11501 src: &'tree [u8],
11502 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11503 match node.kind() {
11504 "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
11505 ::treesitter_types::runtime::maybe_grow_stack(|| {
11506 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
11507 })?,
11508 ))),
11509 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
11510 ::treesitter_types::runtime::maybe_grow_stack(|| {
11511 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
11512 })?,
11513 ))),
11514 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
11515 ::treesitter_types::runtime::maybe_grow_stack(|| {
11516 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
11517 })?,
11518 ))),
11519 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11520 ::treesitter_types::runtime::maybe_grow_stack(|| {
11521 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
11522 })?,
11523 ))),
11524 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11525 }
11526 }
11527}
11528impl ::treesitter_types::Spanned for DisjunctiveNormalFormTypeChildren<'_> {
11529 fn span(&self) -> ::treesitter_types::Span {
11530 match self {
11531 Self::IntersectionType(inner) => inner.span(),
11532 Self::NamedType(inner) => inner.span(),
11533 Self::OptionalType(inner) => inner.span(),
11534 Self::PrimitiveType(inner) => inner.span(),
11535 }
11536 }
11537}
11538#[derive(Debug, Clone, PartialEq, Eq)]
11539pub enum DynamicVariableNameChildren<'tree> {
11540 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11541 Expression(::std::boxed::Box<Expression<'tree>>),
11542 VariableName(::std::boxed::Box<VariableName<'tree>>),
11543}
11544impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicVariableNameChildren<'tree> {
11545 #[allow(clippy::collapsible_else_if)]
11546 fn from_node(
11547 node: ::treesitter_types::tree_sitter::Node<'tree>,
11548 src: &'tree [u8],
11549 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11550 match node.kind() {
11551 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11552 ::treesitter_types::runtime::maybe_grow_stack(|| {
11553 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
11554 })?,
11555 ))),
11556 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11557 ::treesitter_types::runtime::maybe_grow_stack(|| {
11558 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
11559 })?,
11560 ))),
11561 _other => {
11562 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11563 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11564 }) {
11565 Ok(Self::Expression(::std::boxed::Box::new(v)))
11566 } else {
11567 Err(::treesitter_types::ParseError::unexpected_kind(
11568 _other, node,
11569 ))
11570 }
11571 }
11572 }
11573 }
11574}
11575impl ::treesitter_types::Spanned for DynamicVariableNameChildren<'_> {
11576 fn span(&self) -> ::treesitter_types::Span {
11577 match self {
11578 Self::DynamicVariableName(inner) => inner.span(),
11579 Self::Expression(inner) => inner.span(),
11580 Self::VariableName(inner) => inner.span(),
11581 }
11582 }
11583}
11584#[derive(Debug, Clone, PartialEq, Eq)]
11585pub enum EchoStatementChildren<'tree> {
11586 Expression(::std::boxed::Box<Expression<'tree>>),
11587 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11588}
11589impl<'tree> ::treesitter_types::FromNode<'tree> for EchoStatementChildren<'tree> {
11590 #[allow(clippy::collapsible_else_if)]
11591 fn from_node(
11592 node: ::treesitter_types::tree_sitter::Node<'tree>,
11593 src: &'tree [u8],
11594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11595 match node.kind() {
11596 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11597 ::treesitter_types::runtime::maybe_grow_stack(|| {
11598 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
11599 })?,
11600 ))),
11601 _other => {
11602 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11603 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11604 }) {
11605 Ok(Self::Expression(::std::boxed::Box::new(v)))
11606 } else {
11607 Err(::treesitter_types::ParseError::unexpected_kind(
11608 _other, node,
11609 ))
11610 }
11611 }
11612 }
11613 }
11614}
11615impl ::treesitter_types::Spanned for EchoStatementChildren<'_> {
11616 fn span(&self) -> ::treesitter_types::Span {
11617 match self {
11618 Self::Expression(inner) => inner.span(),
11619 Self::SequenceExpression(inner) => inner.span(),
11620 }
11621 }
11622}
11623#[derive(Debug, Clone, PartialEq, Eq)]
11624pub enum ElseClauseBody<'tree> {
11625 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11626 Statement(::std::boxed::Box<Statement<'tree>>),
11627}
11628impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClauseBody<'tree> {
11629 #[allow(clippy::collapsible_else_if)]
11630 fn from_node(
11631 node: ::treesitter_types::tree_sitter::Node<'tree>,
11632 src: &'tree [u8],
11633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11634 match node.kind() {
11635 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11636 ::treesitter_types::runtime::maybe_grow_stack(|| {
11637 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
11638 })?,
11639 ))),
11640 _other => {
11641 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11642 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11643 }) {
11644 Ok(Self::Statement(::std::boxed::Box::new(v)))
11645 } else {
11646 Err(::treesitter_types::ParseError::unexpected_kind(
11647 _other, node,
11648 ))
11649 }
11650 }
11651 }
11652 }
11653}
11654impl ::treesitter_types::Spanned for ElseClauseBody<'_> {
11655 fn span(&self) -> ::treesitter_types::Span {
11656 match self {
11657 Self::ColonBlock(inner) => inner.span(),
11658 Self::Statement(inner) => inner.span(),
11659 }
11660 }
11661}
11662#[derive(Debug, Clone, PartialEq, Eq)]
11663pub enum ElseIfClauseBody<'tree> {
11664 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11665 Statement(::std::boxed::Box<Statement<'tree>>),
11666}
11667impl<'tree> ::treesitter_types::FromNode<'tree> for ElseIfClauseBody<'tree> {
11668 #[allow(clippy::collapsible_else_if)]
11669 fn from_node(
11670 node: ::treesitter_types::tree_sitter::Node<'tree>,
11671 src: &'tree [u8],
11672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11673 match node.kind() {
11674 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11675 ::treesitter_types::runtime::maybe_grow_stack(|| {
11676 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
11677 })?,
11678 ))),
11679 _other => {
11680 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11681 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11682 }) {
11683 Ok(Self::Statement(::std::boxed::Box::new(v)))
11684 } else {
11685 Err(::treesitter_types::ParseError::unexpected_kind(
11686 _other, node,
11687 ))
11688 }
11689 }
11690 }
11691 }
11692}
11693impl ::treesitter_types::Spanned for ElseIfClauseBody<'_> {
11694 fn span(&self) -> ::treesitter_types::Span {
11695 match self {
11696 Self::ColonBlock(inner) => inner.span(),
11697 Self::Statement(inner) => inner.span(),
11698 }
11699 }
11700}
11701#[derive(Debug, Clone, PartialEq, Eq)]
11702pub enum EncapsedStringChildren<'tree> {
11703 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11704 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11705 Expression(::std::boxed::Box<Expression<'tree>>),
11706 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
11707 StringContent(::std::boxed::Box<StringContent<'tree>>),
11708 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11709 VariableName(::std::boxed::Box<VariableName<'tree>>),
11710}
11711impl<'tree> ::treesitter_types::FromNode<'tree> for EncapsedStringChildren<'tree> {
11712 #[allow(clippy::collapsible_else_if)]
11713 fn from_node(
11714 node: ::treesitter_types::tree_sitter::Node<'tree>,
11715 src: &'tree [u8],
11716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11717 match node.kind() {
11718 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11719 ::treesitter_types::runtime::maybe_grow_stack(|| {
11720 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
11721 })?,
11722 ))),
11723 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11724 ::treesitter_types::runtime::maybe_grow_stack(|| {
11725 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
11726 })?,
11727 ))),
11728 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
11729 ::treesitter_types::runtime::maybe_grow_stack(|| {
11730 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
11731 })?,
11732 ))),
11733 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
11734 ::treesitter_types::runtime::maybe_grow_stack(|| {
11735 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
11736 })?,
11737 ))),
11738 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11739 ::treesitter_types::runtime::maybe_grow_stack(|| {
11740 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
11741 })?,
11742 ))),
11743 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11744 ::treesitter_types::runtime::maybe_grow_stack(|| {
11745 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
11746 })?,
11747 ))),
11748 _other => {
11749 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11750 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11751 }) {
11752 Ok(Self::Expression(::std::boxed::Box::new(v)))
11753 } else {
11754 Err(::treesitter_types::ParseError::unexpected_kind(
11755 _other, node,
11756 ))
11757 }
11758 }
11759 }
11760 }
11761}
11762impl ::treesitter_types::Spanned for EncapsedStringChildren<'_> {
11763 fn span(&self) -> ::treesitter_types::Span {
11764 match self {
11765 Self::DynamicVariableName(inner) => inner.span(),
11766 Self::EscapeSequence(inner) => inner.span(),
11767 Self::Expression(inner) => inner.span(),
11768 Self::MemberAccessExpression(inner) => inner.span(),
11769 Self::StringContent(inner) => inner.span(),
11770 Self::SubscriptExpression(inner) => inner.span(),
11771 Self::VariableName(inner) => inner.span(),
11772 }
11773 }
11774}
11775#[derive(Debug, Clone, PartialEq, Eq)]
11776pub enum EnumDeclarationChildren<'tree> {
11777 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
11778 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11779}
11780impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationChildren<'tree> {
11781 #[allow(clippy::collapsible_else_if)]
11782 fn from_node(
11783 node: ::treesitter_types::tree_sitter::Node<'tree>,
11784 src: &'tree [u8],
11785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11786 match node.kind() {
11787 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
11788 ::treesitter_types::runtime::maybe_grow_stack(|| {
11789 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)
11790 })?,
11791 ))),
11792 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11793 ::treesitter_types::runtime::maybe_grow_stack(|| {
11794 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
11795 })?,
11796 ))),
11797 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11798 }
11799 }
11800}
11801impl ::treesitter_types::Spanned for EnumDeclarationChildren<'_> {
11802 fn span(&self) -> ::treesitter_types::Span {
11803 match self {
11804 Self::ClassInterfaceClause(inner) => inner.span(),
11805 Self::PrimitiveType(inner) => inner.span(),
11806 }
11807 }
11808}
11809#[derive(Debug, Clone, PartialEq, Eq)]
11810pub enum EnumDeclarationListChildren<'tree> {
11811 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
11812 EnumCase(::std::boxed::Box<EnumCase<'tree>>),
11813 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
11814 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
11815}
11816impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationListChildren<'tree> {
11817 #[allow(clippy::collapsible_else_if)]
11818 fn from_node(
11819 node: ::treesitter_types::tree_sitter::Node<'tree>,
11820 src: &'tree [u8],
11821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11822 match node.kind() {
11823 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
11824 ::treesitter_types::runtime::maybe_grow_stack(|| {
11825 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11826 })?,
11827 ))),
11828 "enum_case" => Ok(Self::EnumCase(::std::boxed::Box::new(
11829 ::treesitter_types::runtime::maybe_grow_stack(|| {
11830 <EnumCase as ::treesitter_types::FromNode>::from_node(node, src)
11831 })?,
11832 ))),
11833 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
11834 ::treesitter_types::runtime::maybe_grow_stack(|| {
11835 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11836 })?,
11837 ))),
11838 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
11839 ::treesitter_types::runtime::maybe_grow_stack(|| {
11840 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
11841 })?,
11842 ))),
11843 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11844 }
11845 }
11846}
11847impl ::treesitter_types::Spanned for EnumDeclarationListChildren<'_> {
11848 fn span(&self) -> ::treesitter_types::Span {
11849 match self {
11850 Self::ConstDeclaration(inner) => inner.span(),
11851 Self::EnumCase(inner) => inner.span(),
11852 Self::MethodDeclaration(inner) => inner.span(),
11853 Self::UseDeclaration(inner) => inner.span(),
11854 }
11855 }
11856}
11857#[derive(Debug, Clone, PartialEq, Eq)]
11858pub enum ForStatementCondition<'tree> {
11859 Expression(::std::boxed::Box<Expression<'tree>>),
11860 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11861}
11862impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
11863 #[allow(clippy::collapsible_else_if)]
11864 fn from_node(
11865 node: ::treesitter_types::tree_sitter::Node<'tree>,
11866 src: &'tree [u8],
11867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11868 match node.kind() {
11869 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11870 ::treesitter_types::runtime::maybe_grow_stack(|| {
11871 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
11872 })?,
11873 ))),
11874 _other => {
11875 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11876 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11877 }) {
11878 Ok(Self::Expression(::std::boxed::Box::new(v)))
11879 } else {
11880 Err(::treesitter_types::ParseError::unexpected_kind(
11881 _other, node,
11882 ))
11883 }
11884 }
11885 }
11886 }
11887}
11888impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
11889 fn span(&self) -> ::treesitter_types::Span {
11890 match self {
11891 Self::Expression(inner) => inner.span(),
11892 Self::SequenceExpression(inner) => inner.span(),
11893 }
11894 }
11895}
11896#[derive(Debug, Clone, PartialEq, Eq)]
11897pub enum ForStatementInitialize<'tree> {
11898 Expression(::std::boxed::Box<Expression<'tree>>),
11899 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11900}
11901impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitialize<'tree> {
11902 #[allow(clippy::collapsible_else_if)]
11903 fn from_node(
11904 node: ::treesitter_types::tree_sitter::Node<'tree>,
11905 src: &'tree [u8],
11906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11907 match node.kind() {
11908 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11909 ::treesitter_types::runtime::maybe_grow_stack(|| {
11910 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
11911 })?,
11912 ))),
11913 _other => {
11914 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11915 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11916 }) {
11917 Ok(Self::Expression(::std::boxed::Box::new(v)))
11918 } else {
11919 Err(::treesitter_types::ParseError::unexpected_kind(
11920 _other, node,
11921 ))
11922 }
11923 }
11924 }
11925 }
11926}
11927impl ::treesitter_types::Spanned for ForStatementInitialize<'_> {
11928 fn span(&self) -> ::treesitter_types::Span {
11929 match self {
11930 Self::Expression(inner) => inner.span(),
11931 Self::SequenceExpression(inner) => inner.span(),
11932 }
11933 }
11934}
11935#[derive(Debug, Clone, PartialEq, Eq)]
11936pub enum ForStatementUpdate<'tree> {
11937 Expression(::std::boxed::Box<Expression<'tree>>),
11938 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11939}
11940impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
11941 #[allow(clippy::collapsible_else_if)]
11942 fn from_node(
11943 node: ::treesitter_types::tree_sitter::Node<'tree>,
11944 src: &'tree [u8],
11945 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11946 match node.kind() {
11947 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11948 ::treesitter_types::runtime::maybe_grow_stack(|| {
11949 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
11950 })?,
11951 ))),
11952 _other => {
11953 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11954 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11955 }) {
11956 Ok(Self::Expression(::std::boxed::Box::new(v)))
11957 } else {
11958 Err(::treesitter_types::ParseError::unexpected_kind(
11959 _other, node,
11960 ))
11961 }
11962 }
11963 }
11964 }
11965}
11966impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
11967 fn span(&self) -> ::treesitter_types::Span {
11968 match self {
11969 Self::Expression(inner) => inner.span(),
11970 Self::SequenceExpression(inner) => inner.span(),
11971 }
11972 }
11973}
11974#[derive(Debug, Clone, PartialEq, Eq)]
11975pub enum ForeachStatementBody<'tree> {
11976 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11977 Statement(::std::boxed::Box<Statement<'tree>>),
11978}
11979impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementBody<'tree> {
11980 #[allow(clippy::collapsible_else_if)]
11981 fn from_node(
11982 node: ::treesitter_types::tree_sitter::Node<'tree>,
11983 src: &'tree [u8],
11984 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11985 match node.kind() {
11986 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11987 ::treesitter_types::runtime::maybe_grow_stack(|| {
11988 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
11989 })?,
11990 ))),
11991 _other => {
11992 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11993 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
11994 }) {
11995 Ok(Self::Statement(::std::boxed::Box::new(v)))
11996 } else {
11997 Err(::treesitter_types::ParseError::unexpected_kind(
11998 _other, node,
11999 ))
12000 }
12001 }
12002 }
12003 }
12004}
12005impl ::treesitter_types::Spanned for ForeachStatementBody<'_> {
12006 fn span(&self) -> ::treesitter_types::Span {
12007 match self {
12008 Self::ColonBlock(inner) => inner.span(),
12009 Self::Statement(inner) => inner.span(),
12010 }
12011 }
12012}
12013#[derive(Debug, Clone, PartialEq, Eq)]
12014pub enum ForeachStatementChildren<'tree> {
12015 ByRef(::std::boxed::Box<ByRef<'tree>>),
12016 Expression(::std::boxed::Box<Expression<'tree>>),
12017 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
12018 Pair(::std::boxed::Box<Pair<'tree>>),
12019}
12020impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementChildren<'tree> {
12021 #[allow(clippy::collapsible_else_if)]
12022 fn from_node(
12023 node: ::treesitter_types::tree_sitter::Node<'tree>,
12024 src: &'tree [u8],
12025 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12026 match node.kind() {
12027 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
12028 ::treesitter_types::runtime::maybe_grow_stack(|| {
12029 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
12030 })?,
12031 ))),
12032 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
12033 ::treesitter_types::runtime::maybe_grow_stack(|| {
12034 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12035 })?,
12036 ))),
12037 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
12038 ::treesitter_types::runtime::maybe_grow_stack(|| {
12039 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
12040 })?,
12041 ))),
12042 _other => {
12043 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12044 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12045 }) {
12046 Ok(Self::Expression(::std::boxed::Box::new(v)))
12047 } else {
12048 Err(::treesitter_types::ParseError::unexpected_kind(
12049 _other, node,
12050 ))
12051 }
12052 }
12053 }
12054 }
12055}
12056impl ::treesitter_types::Spanned for ForeachStatementChildren<'_> {
12057 fn span(&self) -> ::treesitter_types::Span {
12058 match self {
12059 Self::ByRef(inner) => inner.span(),
12060 Self::Expression(inner) => inner.span(),
12061 Self::ListLiteral(inner) => inner.span(),
12062 Self::Pair(inner) => inner.span(),
12063 }
12064 }
12065}
12066#[derive(Debug, Clone, PartialEq, Eq)]
12067pub enum FormalParametersChildren<'tree> {
12068 PropertyPromotionParameter(::std::boxed::Box<PropertyPromotionParameter<'tree>>),
12069 SimpleParameter(::std::boxed::Box<SimpleParameter<'tree>>),
12070 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
12071}
12072impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
12073 #[allow(clippy::collapsible_else_if)]
12074 fn from_node(
12075 node: ::treesitter_types::tree_sitter::Node<'tree>,
12076 src: &'tree [u8],
12077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12078 match node.kind() {
12079 "property_promotion_parameter" => Ok(Self::PropertyPromotionParameter(
12080 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12081 <PropertyPromotionParameter as ::treesitter_types::FromNode>::from_node(
12082 node, src,
12083 )
12084 })?),
12085 )),
12086 "simple_parameter" => Ok(Self::SimpleParameter(::std::boxed::Box::new(
12087 ::treesitter_types::runtime::maybe_grow_stack(|| {
12088 <SimpleParameter as ::treesitter_types::FromNode>::from_node(node, src)
12089 })?,
12090 ))),
12091 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
12092 ::treesitter_types::runtime::maybe_grow_stack(|| {
12093 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
12094 })?,
12095 ))),
12096 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12097 }
12098 }
12099}
12100impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
12101 fn span(&self) -> ::treesitter_types::Span {
12102 match self {
12103 Self::PropertyPromotionParameter(inner) => inner.span(),
12104 Self::SimpleParameter(inner) => inner.span(),
12105 Self::VariadicParameter(inner) => inner.span(),
12106 }
12107 }
12108}
12109#[derive(Debug, Clone, PartialEq, Eq)]
12110pub enum FunctionCallExpressionFunction<'tree> {
12111 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12112 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12113 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12114 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12115 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12116 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12117 Name(::std::boxed::Box<Name<'tree>>),
12118 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12119 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12120 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12121 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12122 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12123 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12124 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12125 String(::std::boxed::Box<String<'tree>>),
12126 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12127 VariableName(::std::boxed::Box<VariableName<'tree>>),
12128}
12129impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCallExpressionFunction<'tree> {
12130 #[allow(clippy::collapsible_else_if)]
12131 fn from_node(
12132 node: ::treesitter_types::tree_sitter::Node<'tree>,
12133 src: &'tree [u8],
12134 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12135 match node.kind() {
12136 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
12137 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12138 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12139 })?),
12140 )),
12141 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12142 ::treesitter_types::runtime::maybe_grow_stack(|| {
12143 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12144 })?,
12145 ))),
12146 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12147 ::treesitter_types::runtime::maybe_grow_stack(|| {
12148 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
12149 })?,
12150 ))),
12151 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12152 ::treesitter_types::runtime::maybe_grow_stack(|| {
12153 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12154 })?,
12155 ))),
12156 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12157 ::treesitter_types::runtime::maybe_grow_stack(|| {
12158 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
12159 })?,
12160 ))),
12161 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12162 ::treesitter_types::runtime::maybe_grow_stack(|| {
12163 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12164 })?,
12165 ))),
12166 "name" => Ok(Self::Name(::std::boxed::Box::new(
12167 ::treesitter_types::runtime::maybe_grow_stack(|| {
12168 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12169 })?,
12170 ))),
12171 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12172 ::treesitter_types::runtime::maybe_grow_stack(|| {
12173 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
12174 })?,
12175 ))),
12176 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
12177 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12178 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12179 node, src,
12180 )
12181 })?),
12182 )),
12183 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
12184 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12185 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12186 })?),
12187 )),
12188 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
12189 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12190 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
12191 })?),
12192 )),
12193 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12194 ::treesitter_types::runtime::maybe_grow_stack(|| {
12195 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
12196 })?,
12197 ))),
12198 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12199 ::treesitter_types::runtime::maybe_grow_stack(|| {
12200 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
12201 })?,
12202 ))),
12203 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12204 ::treesitter_types::runtime::maybe_grow_stack(|| {
12205 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12206 })?,
12207 ))),
12208 "string" => Ok(Self::String(::std::boxed::Box::new(
12209 ::treesitter_types::runtime::maybe_grow_stack(|| {
12210 <String as ::treesitter_types::FromNode>::from_node(node, src)
12211 })?,
12212 ))),
12213 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12214 ::treesitter_types::runtime::maybe_grow_stack(|| {
12215 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
12216 })?,
12217 ))),
12218 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12219 ::treesitter_types::runtime::maybe_grow_stack(|| {
12220 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12221 })?,
12222 ))),
12223 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12224 }
12225 }
12226}
12227impl ::treesitter_types::Spanned for FunctionCallExpressionFunction<'_> {
12228 fn span(&self) -> ::treesitter_types::Span {
12229 match self {
12230 Self::ArrayCreationExpression(inner) => inner.span(),
12231 Self::DynamicVariableName(inner) => inner.span(),
12232 Self::EncapsedString(inner) => inner.span(),
12233 Self::FunctionCallExpression(inner) => inner.span(),
12234 Self::Heredoc(inner) => inner.span(),
12235 Self::MemberCallExpression(inner) => inner.span(),
12236 Self::Name(inner) => inner.span(),
12237 Self::Nowdoc(inner) => inner.span(),
12238 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12239 Self::ObjectCreationExpression(inner) => inner.span(),
12240 Self::ParenthesizedExpression(inner) => inner.span(),
12241 Self::QualifiedName(inner) => inner.span(),
12242 Self::RelativeName(inner) => inner.span(),
12243 Self::ScopedCallExpression(inner) => inner.span(),
12244 Self::String(inner) => inner.span(),
12245 Self::SubscriptExpression(inner) => inner.span(),
12246 Self::VariableName(inner) => inner.span(),
12247 }
12248 }
12249}
12250#[derive(Debug, Clone, PartialEq, Eq)]
12251pub enum FunctionDefinitionReturnType<'tree> {
12252 BottomType(::std::boxed::Box<BottomType<'tree>>),
12253 Type(::std::boxed::Box<Type<'tree>>),
12254}
12255impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionReturnType<'tree> {
12256 #[allow(clippy::collapsible_else_if)]
12257 fn from_node(
12258 node: ::treesitter_types::tree_sitter::Node<'tree>,
12259 src: &'tree [u8],
12260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12261 match node.kind() {
12262 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
12263 ::treesitter_types::runtime::maybe_grow_stack(|| {
12264 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
12265 })?,
12266 ))),
12267 _other => {
12268 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12269 <Type as ::treesitter_types::FromNode>::from_node(node, src)
12270 }) {
12271 Ok(Self::Type(::std::boxed::Box::new(v)))
12272 } else {
12273 Err(::treesitter_types::ParseError::unexpected_kind(
12274 _other, node,
12275 ))
12276 }
12277 }
12278 }
12279 }
12280}
12281impl ::treesitter_types::Spanned for FunctionDefinitionReturnType<'_> {
12282 fn span(&self) -> ::treesitter_types::Span {
12283 match self {
12284 Self::BottomType(inner) => inner.span(),
12285 Self::Type(inner) => inner.span(),
12286 }
12287 }
12288}
12289#[derive(Debug, Clone, PartialEq, Eq)]
12290pub enum GlobalDeclarationChildren<'tree> {
12291 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12292 VariableName(::std::boxed::Box<VariableName<'tree>>),
12293}
12294impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalDeclarationChildren<'tree> {
12295 #[allow(clippy::collapsible_else_if)]
12296 fn from_node(
12297 node: ::treesitter_types::tree_sitter::Node<'tree>,
12298 src: &'tree [u8],
12299 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12300 match node.kind() {
12301 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12302 ::treesitter_types::runtime::maybe_grow_stack(|| {
12303 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12304 })?,
12305 ))),
12306 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12307 ::treesitter_types::runtime::maybe_grow_stack(|| {
12308 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12309 })?,
12310 ))),
12311 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12312 }
12313 }
12314}
12315impl ::treesitter_types::Spanned for GlobalDeclarationChildren<'_> {
12316 fn span(&self) -> ::treesitter_types::Span {
12317 match self {
12318 Self::DynamicVariableName(inner) => inner.span(),
12319 Self::VariableName(inner) => inner.span(),
12320 }
12321 }
12322}
12323#[derive(Debug, Clone, PartialEq, Eq)]
12324pub enum HeredocBodyChildren<'tree> {
12325 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12326 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
12327 Expression(::std::boxed::Box<Expression<'tree>>),
12328 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12329 StringContent(::std::boxed::Box<StringContent<'tree>>),
12330 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12331 VariableName(::std::boxed::Box<VariableName<'tree>>),
12332}
12333impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBodyChildren<'tree> {
12334 #[allow(clippy::collapsible_else_if)]
12335 fn from_node(
12336 node: ::treesitter_types::tree_sitter::Node<'tree>,
12337 src: &'tree [u8],
12338 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12339 match node.kind() {
12340 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12341 ::treesitter_types::runtime::maybe_grow_stack(|| {
12342 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12343 })?,
12344 ))),
12345 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
12346 ::treesitter_types::runtime::maybe_grow_stack(|| {
12347 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
12348 })?,
12349 ))),
12350 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12351 ::treesitter_types::runtime::maybe_grow_stack(|| {
12352 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
12353 })?,
12354 ))),
12355 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
12356 ::treesitter_types::runtime::maybe_grow_stack(|| {
12357 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
12358 })?,
12359 ))),
12360 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12361 ::treesitter_types::runtime::maybe_grow_stack(|| {
12362 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
12363 })?,
12364 ))),
12365 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12366 ::treesitter_types::runtime::maybe_grow_stack(|| {
12367 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12368 })?,
12369 ))),
12370 _other => {
12371 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12372 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12373 }) {
12374 Ok(Self::Expression(::std::boxed::Box::new(v)))
12375 } else {
12376 Err(::treesitter_types::ParseError::unexpected_kind(
12377 _other, node,
12378 ))
12379 }
12380 }
12381 }
12382 }
12383}
12384impl ::treesitter_types::Spanned for HeredocBodyChildren<'_> {
12385 fn span(&self) -> ::treesitter_types::Span {
12386 match self {
12387 Self::DynamicVariableName(inner) => inner.span(),
12388 Self::EscapeSequence(inner) => inner.span(),
12389 Self::Expression(inner) => inner.span(),
12390 Self::MemberAccessExpression(inner) => inner.span(),
12391 Self::StringContent(inner) => inner.span(),
12392 Self::SubscriptExpression(inner) => inner.span(),
12393 Self::VariableName(inner) => inner.span(),
12394 }
12395 }
12396}
12397#[derive(Debug, Clone, PartialEq, Eq)]
12398pub enum IfStatementAlternative<'tree> {
12399 ElseClause(::std::boxed::Box<ElseClause<'tree>>),
12400 ElseIfClause(::std::boxed::Box<ElseIfClause<'tree>>),
12401}
12402impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementAlternative<'tree> {
12403 #[allow(clippy::collapsible_else_if)]
12404 fn from_node(
12405 node: ::treesitter_types::tree_sitter::Node<'tree>,
12406 src: &'tree [u8],
12407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12408 match node.kind() {
12409 "else_clause" => Ok(Self::ElseClause(::std::boxed::Box::new(
12410 ::treesitter_types::runtime::maybe_grow_stack(|| {
12411 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
12412 })?,
12413 ))),
12414 "else_if_clause" => Ok(Self::ElseIfClause(::std::boxed::Box::new(
12415 ::treesitter_types::runtime::maybe_grow_stack(|| {
12416 <ElseIfClause as ::treesitter_types::FromNode>::from_node(node, src)
12417 })?,
12418 ))),
12419 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12420 }
12421 }
12422}
12423impl ::treesitter_types::Spanned for IfStatementAlternative<'_> {
12424 fn span(&self) -> ::treesitter_types::Span {
12425 match self {
12426 Self::ElseClause(inner) => inner.span(),
12427 Self::ElseIfClause(inner) => inner.span(),
12428 }
12429 }
12430}
12431#[derive(Debug, Clone, PartialEq, Eq)]
12432pub enum IfStatementBody<'tree> {
12433 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
12434 Statement(::std::boxed::Box<Statement<'tree>>),
12435}
12436impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementBody<'tree> {
12437 #[allow(clippy::collapsible_else_if)]
12438 fn from_node(
12439 node: ::treesitter_types::tree_sitter::Node<'tree>,
12440 src: &'tree [u8],
12441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12442 match node.kind() {
12443 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
12444 ::treesitter_types::runtime::maybe_grow_stack(|| {
12445 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
12446 })?,
12447 ))),
12448 _other => {
12449 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12450 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
12451 }) {
12452 Ok(Self::Statement(::std::boxed::Box::new(v)))
12453 } else {
12454 Err(::treesitter_types::ParseError::unexpected_kind(
12455 _other, node,
12456 ))
12457 }
12458 }
12459 }
12460 }
12461}
12462impl ::treesitter_types::Spanned for IfStatementBody<'_> {
12463 fn span(&self) -> ::treesitter_types::Span {
12464 match self {
12465 Self::ColonBlock(inner) => inner.span(),
12466 Self::Statement(inner) => inner.span(),
12467 }
12468 }
12469}
12470#[derive(Debug, Clone, PartialEq, Eq)]
12471pub enum IntersectionTypeChildren<'tree> {
12472 NamedType(::std::boxed::Box<NamedType<'tree>>),
12473 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
12474 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
12475}
12476impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionTypeChildren<'tree> {
12477 #[allow(clippy::collapsible_else_if)]
12478 fn from_node(
12479 node: ::treesitter_types::tree_sitter::Node<'tree>,
12480 src: &'tree [u8],
12481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12482 match node.kind() {
12483 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
12484 ::treesitter_types::runtime::maybe_grow_stack(|| {
12485 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
12486 })?,
12487 ))),
12488 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
12489 ::treesitter_types::runtime::maybe_grow_stack(|| {
12490 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
12491 })?,
12492 ))),
12493 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
12494 ::treesitter_types::runtime::maybe_grow_stack(|| {
12495 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
12496 })?,
12497 ))),
12498 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12499 }
12500 }
12501}
12502impl ::treesitter_types::Spanned for IntersectionTypeChildren<'_> {
12503 fn span(&self) -> ::treesitter_types::Span {
12504 match self {
12505 Self::NamedType(inner) => inner.span(),
12506 Self::OptionalType(inner) => inner.span(),
12507 Self::PrimitiveType(inner) => inner.span(),
12508 }
12509 }
12510}
12511#[derive(Debug, Clone, PartialEq, Eq)]
12512pub enum ListLiteralChildren<'tree> {
12513 ByRef(::std::boxed::Box<ByRef<'tree>>),
12514 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12515 Expression(::std::boxed::Box<Expression<'tree>>),
12516 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12517 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
12518 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12519 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12520 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12521 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12522 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12523 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12524 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12525 VariableName(::std::boxed::Box<VariableName<'tree>>),
12526}
12527impl<'tree> ::treesitter_types::FromNode<'tree> for ListLiteralChildren<'tree> {
12528 #[allow(clippy::collapsible_else_if)]
12529 fn from_node(
12530 node: ::treesitter_types::tree_sitter::Node<'tree>,
12531 src: &'tree [u8],
12532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12533 match node.kind() {
12534 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
12535 ::treesitter_types::runtime::maybe_grow_stack(|| {
12536 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
12537 })?,
12538 ))),
12539 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12540 ::treesitter_types::runtime::maybe_grow_stack(|| {
12541 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12542 })?,
12543 ))),
12544 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12545 ::treesitter_types::runtime::maybe_grow_stack(|| {
12546 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12547 })?,
12548 ))),
12549 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
12550 ::treesitter_types::runtime::maybe_grow_stack(|| {
12551 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
12552 })?,
12553 ))),
12554 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12555 ::treesitter_types::runtime::maybe_grow_stack(|| {
12556 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
12557 })?,
12558 ))),
12559 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12560 ::treesitter_types::runtime::maybe_grow_stack(|| {
12561 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12562 })?,
12563 ))),
12564 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12565 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12566 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12567 node, src,
12568 )
12569 })?),
12570 )),
12571 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
12572 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12573 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12574 node, src,
12575 )
12576 })?),
12577 )),
12578 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12579 ::treesitter_types::runtime::maybe_grow_stack(|| {
12580 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12581 })?,
12582 ))),
12583 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12584 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12585 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12586 node, src,
12587 )
12588 })?),
12589 )),
12590 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12591 ::treesitter_types::runtime::maybe_grow_stack(|| {
12592 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
12593 })?,
12594 ))),
12595 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12596 ::treesitter_types::runtime::maybe_grow_stack(|| {
12597 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12598 })?,
12599 ))),
12600 _other => {
12601 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12602 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12603 }) {
12604 Ok(Self::Expression(::std::boxed::Box::new(v)))
12605 } else {
12606 Err(::treesitter_types::ParseError::unexpected_kind(
12607 _other, node,
12608 ))
12609 }
12610 }
12611 }
12612 }
12613}
12614impl ::treesitter_types::Spanned for ListLiteralChildren<'_> {
12615 fn span(&self) -> ::treesitter_types::Span {
12616 match self {
12617 Self::ByRef(inner) => inner.span(),
12618 Self::DynamicVariableName(inner) => inner.span(),
12619 Self::Expression(inner) => inner.span(),
12620 Self::FunctionCallExpression(inner) => inner.span(),
12621 Self::ListLiteral(inner) => inner.span(),
12622 Self::MemberAccessExpression(inner) => inner.span(),
12623 Self::MemberCallExpression(inner) => inner.span(),
12624 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12625 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12626 Self::ScopedCallExpression(inner) => inner.span(),
12627 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
12628 Self::SubscriptExpression(inner) => inner.span(),
12629 Self::VariableName(inner) => inner.span(),
12630 }
12631 }
12632}
12633#[derive(Debug, Clone, PartialEq, Eq)]
12634pub enum MatchBlockChildren<'tree> {
12635 MatchConditionalExpression(::std::boxed::Box<MatchConditionalExpression<'tree>>),
12636 MatchDefaultExpression(::std::boxed::Box<MatchDefaultExpression<'tree>>),
12637}
12638impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlockChildren<'tree> {
12639 #[allow(clippy::collapsible_else_if)]
12640 fn from_node(
12641 node: ::treesitter_types::tree_sitter::Node<'tree>,
12642 src: &'tree [u8],
12643 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12644 match node.kind() {
12645 "match_conditional_expression" => Ok(Self::MatchConditionalExpression(
12646 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12647 <MatchConditionalExpression as ::treesitter_types::FromNode>::from_node(
12648 node, src,
12649 )
12650 })?),
12651 )),
12652 "match_default_expression" => Ok(Self::MatchDefaultExpression(::std::boxed::Box::new(
12653 ::treesitter_types::runtime::maybe_grow_stack(|| {
12654 <MatchDefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
12655 })?,
12656 ))),
12657 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12658 }
12659 }
12660}
12661impl ::treesitter_types::Spanned for MatchBlockChildren<'_> {
12662 fn span(&self) -> ::treesitter_types::Span {
12663 match self {
12664 Self::MatchConditionalExpression(inner) => inner.span(),
12665 Self::MatchDefaultExpression(inner) => inner.span(),
12666 }
12667 }
12668}
12669#[derive(Debug, Clone, PartialEq, Eq)]
12670pub enum MemberAccessExpressionName<'tree> {
12671 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12672 Expression(::std::boxed::Box<Expression<'tree>>),
12673 Name(::std::boxed::Box<Name<'tree>>),
12674 VariableName(::std::boxed::Box<VariableName<'tree>>),
12675}
12676impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionName<'tree> {
12677 #[allow(clippy::collapsible_else_if)]
12678 fn from_node(
12679 node: ::treesitter_types::tree_sitter::Node<'tree>,
12680 src: &'tree [u8],
12681 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12682 match node.kind() {
12683 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12684 ::treesitter_types::runtime::maybe_grow_stack(|| {
12685 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12686 })?,
12687 ))),
12688 "name" => Ok(Self::Name(::std::boxed::Box::new(
12689 ::treesitter_types::runtime::maybe_grow_stack(|| {
12690 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12691 })?,
12692 ))),
12693 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12694 ::treesitter_types::runtime::maybe_grow_stack(|| {
12695 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12696 })?,
12697 ))),
12698 _other => {
12699 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12700 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12701 }) {
12702 Ok(Self::Expression(::std::boxed::Box::new(v)))
12703 } else {
12704 Err(::treesitter_types::ParseError::unexpected_kind(
12705 _other, node,
12706 ))
12707 }
12708 }
12709 }
12710 }
12711}
12712impl ::treesitter_types::Spanned for MemberAccessExpressionName<'_> {
12713 fn span(&self) -> ::treesitter_types::Span {
12714 match self {
12715 Self::DynamicVariableName(inner) => inner.span(),
12716 Self::Expression(inner) => inner.span(),
12717 Self::Name(inner) => inner.span(),
12718 Self::VariableName(inner) => inner.span(),
12719 }
12720 }
12721}
12722#[derive(Debug, Clone, PartialEq, Eq)]
12723pub enum MemberAccessExpressionObject<'tree> {
12724 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12725 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12726 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12727 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12728 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12729 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12730 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12731 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12732 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12733 Name(::std::boxed::Box<Name<'tree>>),
12734 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12735 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12736 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12737 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12738 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12739 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12740 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12741 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12742 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12743 String(::std::boxed::Box<String<'tree>>),
12744 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12745 VariableName(::std::boxed::Box<VariableName<'tree>>),
12746}
12747impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionObject<'tree> {
12748 #[allow(clippy::collapsible_else_if)]
12749 fn from_node(
12750 node: ::treesitter_types::tree_sitter::Node<'tree>,
12751 src: &'tree [u8],
12752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12753 match node.kind() {
12754 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
12755 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12756 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12757 })?),
12758 )),
12759 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12760 ::treesitter_types::runtime::maybe_grow_stack(|| {
12761 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
12762 })?,
12763 ))),
12764 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
12765 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12766 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
12767 node, src,
12768 )
12769 })?),
12770 )),
12771 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12772 ::treesitter_types::runtime::maybe_grow_stack(|| {
12773 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12774 })?,
12775 ))),
12776 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12777 ::treesitter_types::runtime::maybe_grow_stack(|| {
12778 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
12779 })?,
12780 ))),
12781 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12782 ::treesitter_types::runtime::maybe_grow_stack(|| {
12783 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12784 })?,
12785 ))),
12786 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12787 ::treesitter_types::runtime::maybe_grow_stack(|| {
12788 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
12789 })?,
12790 ))),
12791 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12792 ::treesitter_types::runtime::maybe_grow_stack(|| {
12793 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
12794 })?,
12795 ))),
12796 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12797 ::treesitter_types::runtime::maybe_grow_stack(|| {
12798 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12799 })?,
12800 ))),
12801 "name" => Ok(Self::Name(::std::boxed::Box::new(
12802 ::treesitter_types::runtime::maybe_grow_stack(|| {
12803 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12804 })?,
12805 ))),
12806 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12807 ::treesitter_types::runtime::maybe_grow_stack(|| {
12808 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
12809 })?,
12810 ))),
12811 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12812 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12813 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12814 node, src,
12815 )
12816 })?),
12817 )),
12818 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
12819 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12820 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12821 node, src,
12822 )
12823 })?),
12824 )),
12825 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
12826 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12827 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12828 })?),
12829 )),
12830 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
12831 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12832 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
12833 })?),
12834 )),
12835 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12836 ::treesitter_types::runtime::maybe_grow_stack(|| {
12837 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
12838 })?,
12839 ))),
12840 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12841 ::treesitter_types::runtime::maybe_grow_stack(|| {
12842 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
12843 })?,
12844 ))),
12845 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12846 ::treesitter_types::runtime::maybe_grow_stack(|| {
12847 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
12848 })?,
12849 ))),
12850 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12851 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12852 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12853 node, src,
12854 )
12855 })?),
12856 )),
12857 "string" => Ok(Self::String(::std::boxed::Box::new(
12858 ::treesitter_types::runtime::maybe_grow_stack(|| {
12859 <String as ::treesitter_types::FromNode>::from_node(node, src)
12860 })?,
12861 ))),
12862 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12863 ::treesitter_types::runtime::maybe_grow_stack(|| {
12864 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
12865 })?,
12866 ))),
12867 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12868 ::treesitter_types::runtime::maybe_grow_stack(|| {
12869 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12870 })?,
12871 ))),
12872 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12873 }
12874 }
12875}
12876impl ::treesitter_types::Spanned for MemberAccessExpressionObject<'_> {
12877 fn span(&self) -> ::treesitter_types::Span {
12878 match self {
12879 Self::ArrayCreationExpression(inner) => inner.span(),
12880 Self::CastExpression(inner) => inner.span(),
12881 Self::ClassConstantAccessExpression(inner) => inner.span(),
12882 Self::DynamicVariableName(inner) => inner.span(),
12883 Self::EncapsedString(inner) => inner.span(),
12884 Self::FunctionCallExpression(inner) => inner.span(),
12885 Self::Heredoc(inner) => inner.span(),
12886 Self::MemberAccessExpression(inner) => inner.span(),
12887 Self::MemberCallExpression(inner) => inner.span(),
12888 Self::Name(inner) => inner.span(),
12889 Self::Nowdoc(inner) => inner.span(),
12890 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12891 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12892 Self::ObjectCreationExpression(inner) => inner.span(),
12893 Self::ParenthesizedExpression(inner) => inner.span(),
12894 Self::QualifiedName(inner) => inner.span(),
12895 Self::RelativeName(inner) => inner.span(),
12896 Self::ScopedCallExpression(inner) => inner.span(),
12897 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
12898 Self::String(inner) => inner.span(),
12899 Self::SubscriptExpression(inner) => inner.span(),
12900 Self::VariableName(inner) => inner.span(),
12901 }
12902 }
12903}
12904#[derive(Debug, Clone, PartialEq, Eq)]
12905pub enum MemberCallExpressionName<'tree> {
12906 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12907 Expression(::std::boxed::Box<Expression<'tree>>),
12908 Name(::std::boxed::Box<Name<'tree>>),
12909 VariableName(::std::boxed::Box<VariableName<'tree>>),
12910}
12911impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpressionName<'tree> {
12912 #[allow(clippy::collapsible_else_if)]
12913 fn from_node(
12914 node: ::treesitter_types::tree_sitter::Node<'tree>,
12915 src: &'tree [u8],
12916 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12917 match node.kind() {
12918 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12919 ::treesitter_types::runtime::maybe_grow_stack(|| {
12920 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
12921 })?,
12922 ))),
12923 "name" => Ok(Self::Name(::std::boxed::Box::new(
12924 ::treesitter_types::runtime::maybe_grow_stack(|| {
12925 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12926 })?,
12927 ))),
12928 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12929 ::treesitter_types::runtime::maybe_grow_stack(|| {
12930 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
12931 })?,
12932 ))),
12933 _other => {
12934 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12935 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12936 }) {
12937 Ok(Self::Expression(::std::boxed::Box::new(v)))
12938 } else {
12939 Err(::treesitter_types::ParseError::unexpected_kind(
12940 _other, node,
12941 ))
12942 }
12943 }
12944 }
12945 }
12946}
12947impl ::treesitter_types::Spanned for MemberCallExpressionName<'_> {
12948 fn span(&self) -> ::treesitter_types::Span {
12949 match self {
12950 Self::DynamicVariableName(inner) => inner.span(),
12951 Self::Expression(inner) => inner.span(),
12952 Self::Name(inner) => inner.span(),
12953 Self::VariableName(inner) => inner.span(),
12954 }
12955 }
12956}
12957#[derive(Debug, Clone, PartialEq, Eq)]
12958pub enum MemberCallExpressionObject<'tree> {
12959 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12960 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12961 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12962 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12963 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12964 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12965 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12966 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12967 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12968 Name(::std::boxed::Box<Name<'tree>>),
12969 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12970 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12971 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12972 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12973 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12974 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12975 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12976 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12977 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12978 String(::std::boxed::Box<String<'tree>>),
12979 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12980 VariableName(::std::boxed::Box<VariableName<'tree>>),
12981}
12982impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpressionObject<'tree> {
12983 #[allow(clippy::collapsible_else_if)]
12984 fn from_node(
12985 node: ::treesitter_types::tree_sitter::Node<'tree>,
12986 src: &'tree [u8],
12987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12988 match node.kind() {
12989 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
12990 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
12991 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
12992 })?),
12993 )),
12994 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12995 ::treesitter_types::runtime::maybe_grow_stack(|| {
12996 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
12997 })?,
12998 ))),
12999 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
13000 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13001 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
13002 node, src,
13003 )
13004 })?),
13005 )),
13006 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13007 ::treesitter_types::runtime::maybe_grow_stack(|| {
13008 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13009 })?,
13010 ))),
13011 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
13012 ::treesitter_types::runtime::maybe_grow_stack(|| {
13013 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
13014 })?,
13015 ))),
13016 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13017 ::treesitter_types::runtime::maybe_grow_stack(|| {
13018 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13019 })?,
13020 ))),
13021 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
13022 ::treesitter_types::runtime::maybe_grow_stack(|| {
13023 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
13024 })?,
13025 ))),
13026 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13027 ::treesitter_types::runtime::maybe_grow_stack(|| {
13028 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
13029 })?,
13030 ))),
13031 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13032 ::treesitter_types::runtime::maybe_grow_stack(|| {
13033 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13034 })?,
13035 ))),
13036 "name" => Ok(Self::Name(::std::boxed::Box::new(
13037 ::treesitter_types::runtime::maybe_grow_stack(|| {
13038 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13039 })?,
13040 ))),
13041 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
13042 ::treesitter_types::runtime::maybe_grow_stack(|| {
13043 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
13044 })?,
13045 ))),
13046 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13047 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13048 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13049 node, src,
13050 )
13051 })?),
13052 )),
13053 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
13054 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13055 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13056 node, src,
13057 )
13058 })?),
13059 )),
13060 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
13061 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13062 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
13063 })?),
13064 )),
13065 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
13066 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13067 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13068 })?),
13069 )),
13070 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13071 ::treesitter_types::runtime::maybe_grow_stack(|| {
13072 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13073 })?,
13074 ))),
13075 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13076 ::treesitter_types::runtime::maybe_grow_stack(|| {
13077 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
13078 })?,
13079 ))),
13080 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13081 ::treesitter_types::runtime::maybe_grow_stack(|| {
13082 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13083 })?,
13084 ))),
13085 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13086 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13087 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13088 node, src,
13089 )
13090 })?),
13091 )),
13092 "string" => Ok(Self::String(::std::boxed::Box::new(
13093 ::treesitter_types::runtime::maybe_grow_stack(|| {
13094 <String as ::treesitter_types::FromNode>::from_node(node, src)
13095 })?,
13096 ))),
13097 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13098 ::treesitter_types::runtime::maybe_grow_stack(|| {
13099 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
13100 })?,
13101 ))),
13102 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13103 ::treesitter_types::runtime::maybe_grow_stack(|| {
13104 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13105 })?,
13106 ))),
13107 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13108 }
13109 }
13110}
13111impl ::treesitter_types::Spanned for MemberCallExpressionObject<'_> {
13112 fn span(&self) -> ::treesitter_types::Span {
13113 match self {
13114 Self::ArrayCreationExpression(inner) => inner.span(),
13115 Self::CastExpression(inner) => inner.span(),
13116 Self::ClassConstantAccessExpression(inner) => inner.span(),
13117 Self::DynamicVariableName(inner) => inner.span(),
13118 Self::EncapsedString(inner) => inner.span(),
13119 Self::FunctionCallExpression(inner) => inner.span(),
13120 Self::Heredoc(inner) => inner.span(),
13121 Self::MemberAccessExpression(inner) => inner.span(),
13122 Self::MemberCallExpression(inner) => inner.span(),
13123 Self::Name(inner) => inner.span(),
13124 Self::Nowdoc(inner) => inner.span(),
13125 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13126 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13127 Self::ObjectCreationExpression(inner) => inner.span(),
13128 Self::ParenthesizedExpression(inner) => inner.span(),
13129 Self::QualifiedName(inner) => inner.span(),
13130 Self::RelativeName(inner) => inner.span(),
13131 Self::ScopedCallExpression(inner) => inner.span(),
13132 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13133 Self::String(inner) => inner.span(),
13134 Self::SubscriptExpression(inner) => inner.span(),
13135 Self::VariableName(inner) => inner.span(),
13136 }
13137 }
13138}
13139#[derive(Debug, Clone, PartialEq, Eq)]
13140pub enum MethodDeclarationReturnType<'tree> {
13141 BottomType(::std::boxed::Box<BottomType<'tree>>),
13142 Type(::std::boxed::Box<Type<'tree>>),
13143}
13144impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationReturnType<'tree> {
13145 #[allow(clippy::collapsible_else_if)]
13146 fn from_node(
13147 node: ::treesitter_types::tree_sitter::Node<'tree>,
13148 src: &'tree [u8],
13149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13150 match node.kind() {
13151 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
13152 ::treesitter_types::runtime::maybe_grow_stack(|| {
13153 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
13154 })?,
13155 ))),
13156 _other => {
13157 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13158 <Type as ::treesitter_types::FromNode>::from_node(node, src)
13159 }) {
13160 Ok(Self::Type(::std::boxed::Box::new(v)))
13161 } else {
13162 Err(::treesitter_types::ParseError::unexpected_kind(
13163 _other, node,
13164 ))
13165 }
13166 }
13167 }
13168 }
13169}
13170impl ::treesitter_types::Spanned for MethodDeclarationReturnType<'_> {
13171 fn span(&self) -> ::treesitter_types::Span {
13172 match self {
13173 Self::BottomType(inner) => inner.span(),
13174 Self::Type(inner) => inner.span(),
13175 }
13176 }
13177}
13178#[derive(Debug, Clone, PartialEq, Eq)]
13179pub enum MethodDeclarationChildren<'tree> {
13180 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
13181 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
13182 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
13183 ReferenceModifier(::std::boxed::Box<ReferenceModifier<'tree>>),
13184 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
13185 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
13186 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13187}
13188impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
13189 #[allow(clippy::collapsible_else_if)]
13190 fn from_node(
13191 node: ::treesitter_types::tree_sitter::Node<'tree>,
13192 src: &'tree [u8],
13193 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13194 match node.kind() {
13195 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
13196 ::treesitter_types::runtime::maybe_grow_stack(|| {
13197 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
13198 })?,
13199 ))),
13200 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
13201 ::treesitter_types::runtime::maybe_grow_stack(|| {
13202 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
13203 })?,
13204 ))),
13205 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
13206 ::treesitter_types::runtime::maybe_grow_stack(|| {
13207 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
13208 })?,
13209 ))),
13210 "reference_modifier" => Ok(Self::ReferenceModifier(::std::boxed::Box::new(
13211 ::treesitter_types::runtime::maybe_grow_stack(|| {
13212 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(node, src)
13213 })?,
13214 ))),
13215 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
13216 ::treesitter_types::runtime::maybe_grow_stack(|| {
13217 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
13218 })?,
13219 ))),
13220 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
13221 ::treesitter_types::runtime::maybe_grow_stack(|| {
13222 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
13223 })?,
13224 ))),
13225 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13226 ::treesitter_types::runtime::maybe_grow_stack(|| {
13227 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13228 })?,
13229 ))),
13230 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13231 }
13232 }
13233}
13234impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
13235 fn span(&self) -> ::treesitter_types::Span {
13236 match self {
13237 Self::AbstractModifier(inner) => inner.span(),
13238 Self::FinalModifier(inner) => inner.span(),
13239 Self::ReadonlyModifier(inner) => inner.span(),
13240 Self::ReferenceModifier(inner) => inner.span(),
13241 Self::StaticModifier(inner) => inner.span(),
13242 Self::VarModifier(inner) => inner.span(),
13243 Self::VisibilityModifier(inner) => inner.span(),
13244 }
13245 }
13246}
13247#[derive(Debug, Clone, PartialEq, Eq)]
13248pub enum NamedTypeChildren<'tree> {
13249 Name(::std::boxed::Box<Name<'tree>>),
13250 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13251 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13252}
13253impl<'tree> ::treesitter_types::FromNode<'tree> for NamedTypeChildren<'tree> {
13254 #[allow(clippy::collapsible_else_if)]
13255 fn from_node(
13256 node: ::treesitter_types::tree_sitter::Node<'tree>,
13257 src: &'tree [u8],
13258 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13259 match node.kind() {
13260 "name" => Ok(Self::Name(::std::boxed::Box::new(
13261 ::treesitter_types::runtime::maybe_grow_stack(|| {
13262 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13263 })?,
13264 ))),
13265 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13266 ::treesitter_types::runtime::maybe_grow_stack(|| {
13267 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13268 })?,
13269 ))),
13270 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13271 ::treesitter_types::runtime::maybe_grow_stack(|| {
13272 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
13273 })?,
13274 ))),
13275 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13276 }
13277 }
13278}
13279impl ::treesitter_types::Spanned for NamedTypeChildren<'_> {
13280 fn span(&self) -> ::treesitter_types::Span {
13281 match self {
13282 Self::Name(inner) => inner.span(),
13283 Self::QualifiedName(inner) => inner.span(),
13284 Self::RelativeName(inner) => inner.span(),
13285 }
13286 }
13287}
13288#[derive(Debug, Clone, PartialEq, Eq)]
13289pub enum NamespaceUseClauseType {
13290 Const(::treesitter_types::Span),
13291 Function(::treesitter_types::Span),
13292}
13293impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClauseType {
13294 #[allow(clippy::collapsible_else_if)]
13295 fn from_node(
13296 node: ::treesitter_types::tree_sitter::Node<'tree>,
13297 _src: &'tree [u8],
13298 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13299 match node.kind() {
13300 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
13301 "function" => Ok(Self::Function(::treesitter_types::Span::from(node))),
13302 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13303 }
13304 }
13305}
13306impl ::treesitter_types::Spanned for NamespaceUseClauseType {
13307 fn span(&self) -> ::treesitter_types::Span {
13308 match self {
13309 Self::Const(span) => *span,
13310 Self::Function(span) => *span,
13311 }
13312 }
13313}
13314#[derive(Debug, Clone, PartialEq, Eq)]
13315pub enum NamespaceUseClauseChildren<'tree> {
13316 Name(::std::boxed::Box<Name<'tree>>),
13317 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13318}
13319impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClauseChildren<'tree> {
13320 #[allow(clippy::collapsible_else_if)]
13321 fn from_node(
13322 node: ::treesitter_types::tree_sitter::Node<'tree>,
13323 src: &'tree [u8],
13324 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13325 match node.kind() {
13326 "name" => Ok(Self::Name(::std::boxed::Box::new(
13327 ::treesitter_types::runtime::maybe_grow_stack(|| {
13328 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13329 })?,
13330 ))),
13331 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13332 ::treesitter_types::runtime::maybe_grow_stack(|| {
13333 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13334 })?,
13335 ))),
13336 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13337 }
13338 }
13339}
13340impl ::treesitter_types::Spanned for NamespaceUseClauseChildren<'_> {
13341 fn span(&self) -> ::treesitter_types::Span {
13342 match self {
13343 Self::Name(inner) => inner.span(),
13344 Self::QualifiedName(inner) => inner.span(),
13345 }
13346 }
13347}
13348#[derive(Debug, Clone, PartialEq, Eq)]
13349pub enum NamespaceUseDeclarationType {
13350 Const(::treesitter_types::Span),
13351 Function(::treesitter_types::Span),
13352}
13353impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclarationType {
13354 #[allow(clippy::collapsible_else_if)]
13355 fn from_node(
13356 node: ::treesitter_types::tree_sitter::Node<'tree>,
13357 _src: &'tree [u8],
13358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13359 match node.kind() {
13360 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
13361 "function" => Ok(Self::Function(::treesitter_types::Span::from(node))),
13362 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13363 }
13364 }
13365}
13366impl ::treesitter_types::Spanned for NamespaceUseDeclarationType {
13367 fn span(&self) -> ::treesitter_types::Span {
13368 match self {
13369 Self::Const(span) => *span,
13370 Self::Function(span) => *span,
13371 }
13372 }
13373}
13374#[derive(Debug, Clone, PartialEq, Eq)]
13375pub enum NamespaceUseDeclarationChildren<'tree> {
13376 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
13377 NamespaceUseClause(::std::boxed::Box<NamespaceUseClause<'tree>>),
13378}
13379impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclarationChildren<'tree> {
13380 #[allow(clippy::collapsible_else_if)]
13381 fn from_node(
13382 node: ::treesitter_types::tree_sitter::Node<'tree>,
13383 src: &'tree [u8],
13384 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13385 match node.kind() {
13386 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
13387 ::treesitter_types::runtime::maybe_grow_stack(|| {
13388 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
13389 })?,
13390 ))),
13391 "namespace_use_clause" => Ok(Self::NamespaceUseClause(::std::boxed::Box::new(
13392 ::treesitter_types::runtime::maybe_grow_stack(|| {
13393 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(node, src)
13394 })?,
13395 ))),
13396 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13397 }
13398 }
13399}
13400impl ::treesitter_types::Spanned for NamespaceUseDeclarationChildren<'_> {
13401 fn span(&self) -> ::treesitter_types::Span {
13402 match self {
13403 Self::NamespaceName(inner) => inner.span(),
13404 Self::NamespaceUseClause(inner) => inner.span(),
13405 }
13406 }
13407}
13408#[derive(Debug, Clone, PartialEq, Eq)]
13409pub enum NullsafeMemberAccessExpressionName<'tree> {
13410 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13411 Expression(::std::boxed::Box<Expression<'tree>>),
13412 Name(::std::boxed::Box<Name<'tree>>),
13413 VariableName(::std::boxed::Box<VariableName<'tree>>),
13414}
13415impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpressionName<'tree> {
13416 #[allow(clippy::collapsible_else_if)]
13417 fn from_node(
13418 node: ::treesitter_types::tree_sitter::Node<'tree>,
13419 src: &'tree [u8],
13420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13421 match node.kind() {
13422 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13423 ::treesitter_types::runtime::maybe_grow_stack(|| {
13424 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13425 })?,
13426 ))),
13427 "name" => Ok(Self::Name(::std::boxed::Box::new(
13428 ::treesitter_types::runtime::maybe_grow_stack(|| {
13429 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13430 })?,
13431 ))),
13432 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13433 ::treesitter_types::runtime::maybe_grow_stack(|| {
13434 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13435 })?,
13436 ))),
13437 _other => {
13438 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13439 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13440 }) {
13441 Ok(Self::Expression(::std::boxed::Box::new(v)))
13442 } else {
13443 Err(::treesitter_types::ParseError::unexpected_kind(
13444 _other, node,
13445 ))
13446 }
13447 }
13448 }
13449 }
13450}
13451impl ::treesitter_types::Spanned for NullsafeMemberAccessExpressionName<'_> {
13452 fn span(&self) -> ::treesitter_types::Span {
13453 match self {
13454 Self::DynamicVariableName(inner) => inner.span(),
13455 Self::Expression(inner) => inner.span(),
13456 Self::Name(inner) => inner.span(),
13457 Self::VariableName(inner) => inner.span(),
13458 }
13459 }
13460}
13461#[derive(Debug, Clone, PartialEq, Eq)]
13462pub enum NullsafeMemberAccessExpressionObject<'tree> {
13463 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
13464 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
13465 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
13466 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13467 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
13468 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
13469 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
13470 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13471 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
13472 Name(::std::boxed::Box<Name<'tree>>),
13473 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
13474 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13475 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
13476 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
13477 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13478 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13479 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13480 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
13481 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13482 String(::std::boxed::Box<String<'tree>>),
13483 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13484 VariableName(::std::boxed::Box<VariableName<'tree>>),
13485}
13486impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpressionObject<'tree> {
13487 #[allow(clippy::collapsible_else_if)]
13488 fn from_node(
13489 node: ::treesitter_types::tree_sitter::Node<'tree>,
13490 src: &'tree [u8],
13491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13492 match node.kind() {
13493 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
13494 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13495 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
13496 })?),
13497 )),
13498 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
13499 ::treesitter_types::runtime::maybe_grow_stack(|| {
13500 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
13501 })?,
13502 ))),
13503 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
13504 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13505 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
13506 node, src,
13507 )
13508 })?),
13509 )),
13510 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13511 ::treesitter_types::runtime::maybe_grow_stack(|| {
13512 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13513 })?,
13514 ))),
13515 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
13516 ::treesitter_types::runtime::maybe_grow_stack(|| {
13517 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
13518 })?,
13519 ))),
13520 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13521 ::treesitter_types::runtime::maybe_grow_stack(|| {
13522 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13523 })?,
13524 ))),
13525 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
13526 ::treesitter_types::runtime::maybe_grow_stack(|| {
13527 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
13528 })?,
13529 ))),
13530 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13531 ::treesitter_types::runtime::maybe_grow_stack(|| {
13532 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
13533 })?,
13534 ))),
13535 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13536 ::treesitter_types::runtime::maybe_grow_stack(|| {
13537 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13538 })?,
13539 ))),
13540 "name" => Ok(Self::Name(::std::boxed::Box::new(
13541 ::treesitter_types::runtime::maybe_grow_stack(|| {
13542 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13543 })?,
13544 ))),
13545 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
13546 ::treesitter_types::runtime::maybe_grow_stack(|| {
13547 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
13548 })?,
13549 ))),
13550 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13551 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13552 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13553 node, src,
13554 )
13555 })?),
13556 )),
13557 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
13558 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13559 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13560 node, src,
13561 )
13562 })?),
13563 )),
13564 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
13565 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13566 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
13567 })?),
13568 )),
13569 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
13570 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13571 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13572 })?),
13573 )),
13574 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13575 ::treesitter_types::runtime::maybe_grow_stack(|| {
13576 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13577 })?,
13578 ))),
13579 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13580 ::treesitter_types::runtime::maybe_grow_stack(|| {
13581 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
13582 })?,
13583 ))),
13584 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13585 ::treesitter_types::runtime::maybe_grow_stack(|| {
13586 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13587 })?,
13588 ))),
13589 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13590 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13591 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13592 node, src,
13593 )
13594 })?),
13595 )),
13596 "string" => Ok(Self::String(::std::boxed::Box::new(
13597 ::treesitter_types::runtime::maybe_grow_stack(|| {
13598 <String as ::treesitter_types::FromNode>::from_node(node, src)
13599 })?,
13600 ))),
13601 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13602 ::treesitter_types::runtime::maybe_grow_stack(|| {
13603 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
13604 })?,
13605 ))),
13606 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13607 ::treesitter_types::runtime::maybe_grow_stack(|| {
13608 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13609 })?,
13610 ))),
13611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13612 }
13613 }
13614}
13615impl ::treesitter_types::Spanned for NullsafeMemberAccessExpressionObject<'_> {
13616 fn span(&self) -> ::treesitter_types::Span {
13617 match self {
13618 Self::ArrayCreationExpression(inner) => inner.span(),
13619 Self::CastExpression(inner) => inner.span(),
13620 Self::ClassConstantAccessExpression(inner) => inner.span(),
13621 Self::DynamicVariableName(inner) => inner.span(),
13622 Self::EncapsedString(inner) => inner.span(),
13623 Self::FunctionCallExpression(inner) => inner.span(),
13624 Self::Heredoc(inner) => inner.span(),
13625 Self::MemberAccessExpression(inner) => inner.span(),
13626 Self::MemberCallExpression(inner) => inner.span(),
13627 Self::Name(inner) => inner.span(),
13628 Self::Nowdoc(inner) => inner.span(),
13629 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13630 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13631 Self::ObjectCreationExpression(inner) => inner.span(),
13632 Self::ParenthesizedExpression(inner) => inner.span(),
13633 Self::QualifiedName(inner) => inner.span(),
13634 Self::RelativeName(inner) => inner.span(),
13635 Self::ScopedCallExpression(inner) => inner.span(),
13636 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13637 Self::String(inner) => inner.span(),
13638 Self::SubscriptExpression(inner) => inner.span(),
13639 Self::VariableName(inner) => inner.span(),
13640 }
13641 }
13642}
13643#[derive(Debug, Clone, PartialEq, Eq)]
13644pub enum NullsafeMemberCallExpressionName<'tree> {
13645 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13646 Expression(::std::boxed::Box<Expression<'tree>>),
13647 Name(::std::boxed::Box<Name<'tree>>),
13648 VariableName(::std::boxed::Box<VariableName<'tree>>),
13649}
13650impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpressionName<'tree> {
13651 #[allow(clippy::collapsible_else_if)]
13652 fn from_node(
13653 node: ::treesitter_types::tree_sitter::Node<'tree>,
13654 src: &'tree [u8],
13655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13656 match node.kind() {
13657 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13658 ::treesitter_types::runtime::maybe_grow_stack(|| {
13659 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13660 })?,
13661 ))),
13662 "name" => Ok(Self::Name(::std::boxed::Box::new(
13663 ::treesitter_types::runtime::maybe_grow_stack(|| {
13664 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13665 })?,
13666 ))),
13667 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13668 ::treesitter_types::runtime::maybe_grow_stack(|| {
13669 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13670 })?,
13671 ))),
13672 _other => {
13673 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13674 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13675 }) {
13676 Ok(Self::Expression(::std::boxed::Box::new(v)))
13677 } else {
13678 Err(::treesitter_types::ParseError::unexpected_kind(
13679 _other, node,
13680 ))
13681 }
13682 }
13683 }
13684 }
13685}
13686impl ::treesitter_types::Spanned for NullsafeMemberCallExpressionName<'_> {
13687 fn span(&self) -> ::treesitter_types::Span {
13688 match self {
13689 Self::DynamicVariableName(inner) => inner.span(),
13690 Self::Expression(inner) => inner.span(),
13691 Self::Name(inner) => inner.span(),
13692 Self::VariableName(inner) => inner.span(),
13693 }
13694 }
13695}
13696#[derive(Debug, Clone, PartialEq, Eq)]
13697pub enum NullsafeMemberCallExpressionObject<'tree> {
13698 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
13699 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
13700 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
13701 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13702 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
13703 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
13704 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
13705 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13706 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
13707 Name(::std::boxed::Box<Name<'tree>>),
13708 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
13709 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13710 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
13711 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
13712 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13713 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13714 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13715 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
13716 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13717 String(::std::boxed::Box<String<'tree>>),
13718 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13719 VariableName(::std::boxed::Box<VariableName<'tree>>),
13720}
13721impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpressionObject<'tree> {
13722 #[allow(clippy::collapsible_else_if)]
13723 fn from_node(
13724 node: ::treesitter_types::tree_sitter::Node<'tree>,
13725 src: &'tree [u8],
13726 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13727 match node.kind() {
13728 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
13729 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13730 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
13731 })?),
13732 )),
13733 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
13734 ::treesitter_types::runtime::maybe_grow_stack(|| {
13735 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
13736 })?,
13737 ))),
13738 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
13739 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13740 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
13741 node, src,
13742 )
13743 })?),
13744 )),
13745 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13746 ::treesitter_types::runtime::maybe_grow_stack(|| {
13747 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13748 })?,
13749 ))),
13750 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
13751 ::treesitter_types::runtime::maybe_grow_stack(|| {
13752 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
13753 })?,
13754 ))),
13755 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13756 ::treesitter_types::runtime::maybe_grow_stack(|| {
13757 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13758 })?,
13759 ))),
13760 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
13761 ::treesitter_types::runtime::maybe_grow_stack(|| {
13762 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
13763 })?,
13764 ))),
13765 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13766 ::treesitter_types::runtime::maybe_grow_stack(|| {
13767 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
13768 })?,
13769 ))),
13770 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13771 ::treesitter_types::runtime::maybe_grow_stack(|| {
13772 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13773 })?,
13774 ))),
13775 "name" => Ok(Self::Name(::std::boxed::Box::new(
13776 ::treesitter_types::runtime::maybe_grow_stack(|| {
13777 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13778 })?,
13779 ))),
13780 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
13781 ::treesitter_types::runtime::maybe_grow_stack(|| {
13782 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
13783 })?,
13784 ))),
13785 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13786 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13787 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13788 node, src,
13789 )
13790 })?),
13791 )),
13792 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
13793 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13794 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13795 node, src,
13796 )
13797 })?),
13798 )),
13799 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
13800 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13801 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
13802 })?),
13803 )),
13804 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
13805 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13806 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13807 })?),
13808 )),
13809 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13810 ::treesitter_types::runtime::maybe_grow_stack(|| {
13811 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13812 })?,
13813 ))),
13814 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13815 ::treesitter_types::runtime::maybe_grow_stack(|| {
13816 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
13817 })?,
13818 ))),
13819 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13820 ::treesitter_types::runtime::maybe_grow_stack(|| {
13821 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13822 })?,
13823 ))),
13824 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13825 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13826 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13827 node, src,
13828 )
13829 })?),
13830 )),
13831 "string" => Ok(Self::String(::std::boxed::Box::new(
13832 ::treesitter_types::runtime::maybe_grow_stack(|| {
13833 <String as ::treesitter_types::FromNode>::from_node(node, src)
13834 })?,
13835 ))),
13836 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13837 ::treesitter_types::runtime::maybe_grow_stack(|| {
13838 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
13839 })?,
13840 ))),
13841 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13842 ::treesitter_types::runtime::maybe_grow_stack(|| {
13843 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13844 })?,
13845 ))),
13846 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13847 }
13848 }
13849}
13850impl ::treesitter_types::Spanned for NullsafeMemberCallExpressionObject<'_> {
13851 fn span(&self) -> ::treesitter_types::Span {
13852 match self {
13853 Self::ArrayCreationExpression(inner) => inner.span(),
13854 Self::CastExpression(inner) => inner.span(),
13855 Self::ClassConstantAccessExpression(inner) => inner.span(),
13856 Self::DynamicVariableName(inner) => inner.span(),
13857 Self::EncapsedString(inner) => inner.span(),
13858 Self::FunctionCallExpression(inner) => inner.span(),
13859 Self::Heredoc(inner) => inner.span(),
13860 Self::MemberAccessExpression(inner) => inner.span(),
13861 Self::MemberCallExpression(inner) => inner.span(),
13862 Self::Name(inner) => inner.span(),
13863 Self::Nowdoc(inner) => inner.span(),
13864 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13865 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13866 Self::ObjectCreationExpression(inner) => inner.span(),
13867 Self::ParenthesizedExpression(inner) => inner.span(),
13868 Self::QualifiedName(inner) => inner.span(),
13869 Self::RelativeName(inner) => inner.span(),
13870 Self::ScopedCallExpression(inner) => inner.span(),
13871 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13872 Self::String(inner) => inner.span(),
13873 Self::SubscriptExpression(inner) => inner.span(),
13874 Self::VariableName(inner) => inner.span(),
13875 }
13876 }
13877}
13878#[derive(Debug, Clone, PartialEq, Eq)]
13879pub enum ObjectCreationExpressionChildren<'tree> {
13880 AnonymousClass(::std::boxed::Box<AnonymousClass<'tree>>),
13881 Arguments(::std::boxed::Box<Arguments<'tree>>),
13882 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13883 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13884 Name(::std::boxed::Box<Name<'tree>>),
13885 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13886 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13887 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13888 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13889 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13890 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13891 VariableName(::std::boxed::Box<VariableName<'tree>>),
13892}
13893impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpressionChildren<'tree> {
13894 #[allow(clippy::collapsible_else_if)]
13895 fn from_node(
13896 node: ::treesitter_types::tree_sitter::Node<'tree>,
13897 src: &'tree [u8],
13898 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13899 match node.kind() {
13900 "anonymous_class" => Ok(Self::AnonymousClass(::std::boxed::Box::new(
13901 ::treesitter_types::runtime::maybe_grow_stack(|| {
13902 <AnonymousClass as ::treesitter_types::FromNode>::from_node(node, src)
13903 })?,
13904 ))),
13905 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
13906 ::treesitter_types::runtime::maybe_grow_stack(|| {
13907 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
13908 })?,
13909 ))),
13910 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13911 ::treesitter_types::runtime::maybe_grow_stack(|| {
13912 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
13913 })?,
13914 ))),
13915 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13916 ::treesitter_types::runtime::maybe_grow_stack(|| {
13917 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
13918 })?,
13919 ))),
13920 "name" => Ok(Self::Name(::std::boxed::Box::new(
13921 ::treesitter_types::runtime::maybe_grow_stack(|| {
13922 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13923 })?,
13924 ))),
13925 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13926 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13927 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13928 node, src,
13929 )
13930 })?),
13931 )),
13932 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
13933 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13934 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
13935 })?),
13936 )),
13937 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13938 ::treesitter_types::runtime::maybe_grow_stack(|| {
13939 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
13940 })?,
13941 ))),
13942 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13943 ::treesitter_types::runtime::maybe_grow_stack(|| {
13944 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
13945 })?,
13946 ))),
13947 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13948 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
13949 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13950 node, src,
13951 )
13952 })?),
13953 )),
13954 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13955 ::treesitter_types::runtime::maybe_grow_stack(|| {
13956 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
13957 })?,
13958 ))),
13959 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13960 ::treesitter_types::runtime::maybe_grow_stack(|| {
13961 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
13962 })?,
13963 ))),
13964 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13965 }
13966 }
13967}
13968impl ::treesitter_types::Spanned for ObjectCreationExpressionChildren<'_> {
13969 fn span(&self) -> ::treesitter_types::Span {
13970 match self {
13971 Self::AnonymousClass(inner) => inner.span(),
13972 Self::Arguments(inner) => inner.span(),
13973 Self::DynamicVariableName(inner) => inner.span(),
13974 Self::MemberAccessExpression(inner) => inner.span(),
13975 Self::Name(inner) => inner.span(),
13976 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13977 Self::ParenthesizedExpression(inner) => inner.span(),
13978 Self::QualifiedName(inner) => inner.span(),
13979 Self::RelativeName(inner) => inner.span(),
13980 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13981 Self::SubscriptExpression(inner) => inner.span(),
13982 Self::VariableName(inner) => inner.span(),
13983 }
13984 }
13985}
13986#[derive(Debug, Clone, PartialEq, Eq)]
13987pub enum OptionalTypeChildren<'tree> {
13988 NamedType(::std::boxed::Box<NamedType<'tree>>),
13989 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13990}
13991impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalTypeChildren<'tree> {
13992 #[allow(clippy::collapsible_else_if)]
13993 fn from_node(
13994 node: ::treesitter_types::tree_sitter::Node<'tree>,
13995 src: &'tree [u8],
13996 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13997 match node.kind() {
13998 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
13999 ::treesitter_types::runtime::maybe_grow_stack(|| {
14000 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
14001 })?,
14002 ))),
14003 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
14004 ::treesitter_types::runtime::maybe_grow_stack(|| {
14005 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
14006 })?,
14007 ))),
14008 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14009 }
14010 }
14011}
14012impl ::treesitter_types::Spanned for OptionalTypeChildren<'_> {
14013 fn span(&self) -> ::treesitter_types::Span {
14014 match self {
14015 Self::NamedType(inner) => inner.span(),
14016 Self::PrimitiveType(inner) => inner.span(),
14017 }
14018 }
14019}
14020#[derive(Debug, Clone, PartialEq, Eq)]
14021pub enum PairChildren<'tree> {
14022 ByRef(::std::boxed::Box<ByRef<'tree>>),
14023 Expression(::std::boxed::Box<Expression<'tree>>),
14024 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
14025}
14026impl<'tree> ::treesitter_types::FromNode<'tree> for PairChildren<'tree> {
14027 #[allow(clippy::collapsible_else_if)]
14028 fn from_node(
14029 node: ::treesitter_types::tree_sitter::Node<'tree>,
14030 src: &'tree [u8],
14031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14032 match node.kind() {
14033 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
14034 ::treesitter_types::runtime::maybe_grow_stack(|| {
14035 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
14036 })?,
14037 ))),
14038 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
14039 ::treesitter_types::runtime::maybe_grow_stack(|| {
14040 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14041 })?,
14042 ))),
14043 _other => {
14044 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14045 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14046 }) {
14047 Ok(Self::Expression(::std::boxed::Box::new(v)))
14048 } else {
14049 Err(::treesitter_types::ParseError::unexpected_kind(
14050 _other, node,
14051 ))
14052 }
14053 }
14054 }
14055 }
14056}
14057impl ::treesitter_types::Spanned for PairChildren<'_> {
14058 fn span(&self) -> ::treesitter_types::Span {
14059 match self {
14060 Self::ByRef(inner) => inner.span(),
14061 Self::Expression(inner) => inner.span(),
14062 Self::ListLiteral(inner) => inner.span(),
14063 }
14064 }
14065}
14066#[derive(Debug, Clone, PartialEq, Eq)]
14067pub enum ProgramChildren<'tree> {
14068 PhpTag(::std::boxed::Box<PhpTag<'tree>>),
14069 Statement(::std::boxed::Box<Statement<'tree>>),
14070 Text(::std::boxed::Box<Text<'tree>>),
14071}
14072impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
14073 #[allow(clippy::collapsible_else_if)]
14074 fn from_node(
14075 node: ::treesitter_types::tree_sitter::Node<'tree>,
14076 src: &'tree [u8],
14077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14078 match node.kind() {
14079 "php_tag" => Ok(Self::PhpTag(::std::boxed::Box::new(
14080 ::treesitter_types::runtime::maybe_grow_stack(|| {
14081 <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)
14082 })?,
14083 ))),
14084 "text" => Ok(Self::Text(::std::boxed::Box::new(
14085 ::treesitter_types::runtime::maybe_grow_stack(|| {
14086 <Text as ::treesitter_types::FromNode>::from_node(node, src)
14087 })?,
14088 ))),
14089 _other => {
14090 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14091 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
14092 }) {
14093 Ok(Self::Statement(::std::boxed::Box::new(v)))
14094 } else {
14095 Err(::treesitter_types::ParseError::unexpected_kind(
14096 _other, node,
14097 ))
14098 }
14099 }
14100 }
14101 }
14102}
14103impl ::treesitter_types::Spanned for ProgramChildren<'_> {
14104 fn span(&self) -> ::treesitter_types::Span {
14105 match self {
14106 Self::PhpTag(inner) => inner.span(),
14107 Self::Statement(inner) => inner.span(),
14108 Self::Text(inner) => inner.span(),
14109 }
14110 }
14111}
14112#[derive(Debug, Clone, PartialEq, Eq)]
14113pub enum PropertyDeclarationChildren<'tree> {
14114 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
14115 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
14116 PropertyElement(::std::boxed::Box<PropertyElement<'tree>>),
14117 PropertyHookList(::std::boxed::Box<PropertyHookList<'tree>>),
14118 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
14119 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
14120 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
14121 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
14122}
14123impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationChildren<'tree> {
14124 #[allow(clippy::collapsible_else_if)]
14125 fn from_node(
14126 node: ::treesitter_types::tree_sitter::Node<'tree>,
14127 src: &'tree [u8],
14128 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14129 match node.kind() {
14130 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
14131 ::treesitter_types::runtime::maybe_grow_stack(|| {
14132 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
14133 })?,
14134 ))),
14135 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
14136 ::treesitter_types::runtime::maybe_grow_stack(|| {
14137 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
14138 })?,
14139 ))),
14140 "property_element" => Ok(Self::PropertyElement(::std::boxed::Box::new(
14141 ::treesitter_types::runtime::maybe_grow_stack(|| {
14142 <PropertyElement as ::treesitter_types::FromNode>::from_node(node, src)
14143 })?,
14144 ))),
14145 "property_hook_list" => Ok(Self::PropertyHookList(::std::boxed::Box::new(
14146 ::treesitter_types::runtime::maybe_grow_stack(|| {
14147 <PropertyHookList as ::treesitter_types::FromNode>::from_node(node, src)
14148 })?,
14149 ))),
14150 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
14151 ::treesitter_types::runtime::maybe_grow_stack(|| {
14152 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
14153 })?,
14154 ))),
14155 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
14156 ::treesitter_types::runtime::maybe_grow_stack(|| {
14157 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
14158 })?,
14159 ))),
14160 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
14161 ::treesitter_types::runtime::maybe_grow_stack(|| {
14162 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
14163 })?,
14164 ))),
14165 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
14166 ::treesitter_types::runtime::maybe_grow_stack(|| {
14167 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
14168 })?,
14169 ))),
14170 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14171 }
14172 }
14173}
14174impl ::treesitter_types::Spanned for PropertyDeclarationChildren<'_> {
14175 fn span(&self) -> ::treesitter_types::Span {
14176 match self {
14177 Self::AbstractModifier(inner) => inner.span(),
14178 Self::FinalModifier(inner) => inner.span(),
14179 Self::PropertyElement(inner) => inner.span(),
14180 Self::PropertyHookList(inner) => inner.span(),
14181 Self::ReadonlyModifier(inner) => inner.span(),
14182 Self::StaticModifier(inner) => inner.span(),
14183 Self::VarModifier(inner) => inner.span(),
14184 Self::VisibilityModifier(inner) => inner.span(),
14185 }
14186 }
14187}
14188#[derive(Debug, Clone, PartialEq, Eq)]
14189pub enum PropertyHookBody<'tree> {
14190 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
14191 Expression(::std::boxed::Box<Expression<'tree>>),
14192}
14193impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHookBody<'tree> {
14194 #[allow(clippy::collapsible_else_if)]
14195 fn from_node(
14196 node: ::treesitter_types::tree_sitter::Node<'tree>,
14197 src: &'tree [u8],
14198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14199 match node.kind() {
14200 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
14201 ::treesitter_types::runtime::maybe_grow_stack(|| {
14202 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
14203 })?,
14204 ))),
14205 _other => {
14206 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14207 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14208 }) {
14209 Ok(Self::Expression(::std::boxed::Box::new(v)))
14210 } else {
14211 Err(::treesitter_types::ParseError::unexpected_kind(
14212 _other, node,
14213 ))
14214 }
14215 }
14216 }
14217 }
14218}
14219impl ::treesitter_types::Spanned for PropertyHookBody<'_> {
14220 fn span(&self) -> ::treesitter_types::Span {
14221 match self {
14222 Self::CompoundStatement(inner) => inner.span(),
14223 Self::Expression(inner) => inner.span(),
14224 }
14225 }
14226}
14227#[derive(Debug, Clone, PartialEq, Eq)]
14228pub enum PropertyPromotionParameterName<'tree> {
14229 ByRef(::std::boxed::Box<ByRef<'tree>>),
14230 VariableName(::std::boxed::Box<VariableName<'tree>>),
14231}
14232impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPromotionParameterName<'tree> {
14233 #[allow(clippy::collapsible_else_if)]
14234 fn from_node(
14235 node: ::treesitter_types::tree_sitter::Node<'tree>,
14236 src: &'tree [u8],
14237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14238 match node.kind() {
14239 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
14240 ::treesitter_types::runtime::maybe_grow_stack(|| {
14241 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
14242 })?,
14243 ))),
14244 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14245 ::treesitter_types::runtime::maybe_grow_stack(|| {
14246 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14247 })?,
14248 ))),
14249 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14250 }
14251 }
14252}
14253impl ::treesitter_types::Spanned for PropertyPromotionParameterName<'_> {
14254 fn span(&self) -> ::treesitter_types::Span {
14255 match self {
14256 Self::ByRef(inner) => inner.span(),
14257 Self::VariableName(inner) => inner.span(),
14258 }
14259 }
14260}
14261#[derive(Debug, Clone, PartialEq, Eq)]
14262pub enum QualifiedNamePrefix<'tree> {
14263 Backslash(::treesitter_types::Span),
14264 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
14265}
14266impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNamePrefix<'tree> {
14267 #[allow(clippy::collapsible_else_if)]
14268 fn from_node(
14269 node: ::treesitter_types::tree_sitter::Node<'tree>,
14270 src: &'tree [u8],
14271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14272 match node.kind() {
14273 "\\" => Ok(Self::Backslash(::treesitter_types::Span::from(node))),
14274 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
14275 ::treesitter_types::runtime::maybe_grow_stack(|| {
14276 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
14277 })?,
14278 ))),
14279 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14280 }
14281 }
14282}
14283impl ::treesitter_types::Spanned for QualifiedNamePrefix<'_> {
14284 fn span(&self) -> ::treesitter_types::Span {
14285 match self {
14286 Self::Backslash(span) => *span,
14287 Self::NamespaceName(inner) => inner.span(),
14288 }
14289 }
14290}
14291#[derive(Debug, Clone, PartialEq, Eq)]
14292pub enum ReferenceAssignmentExpressionLeft<'tree> {
14293 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14294 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14295 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14296 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
14297 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14298 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14299 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14300 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14301 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14302 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14303 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14304 VariableName(::std::boxed::Box<VariableName<'tree>>),
14305}
14306impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceAssignmentExpressionLeft<'tree> {
14307 #[allow(clippy::collapsible_else_if)]
14308 fn from_node(
14309 node: ::treesitter_types::tree_sitter::Node<'tree>,
14310 src: &'tree [u8],
14311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14312 match node.kind() {
14313 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14314 ::treesitter_types::runtime::maybe_grow_stack(|| {
14315 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
14316 })?,
14317 ))),
14318 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14319 ::treesitter_types::runtime::maybe_grow_stack(|| {
14320 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14321 })?,
14322 ))),
14323 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14324 ::treesitter_types::runtime::maybe_grow_stack(|| {
14325 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14326 })?,
14327 ))),
14328 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
14329 ::treesitter_types::runtime::maybe_grow_stack(|| {
14330 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
14331 })?,
14332 ))),
14333 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14334 ::treesitter_types::runtime::maybe_grow_stack(|| {
14335 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
14336 })?,
14337 ))),
14338 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14339 ::treesitter_types::runtime::maybe_grow_stack(|| {
14340 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14341 })?,
14342 ))),
14343 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14344 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14345 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14346 node, src,
14347 )
14348 })?),
14349 )),
14350 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
14351 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14352 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14353 node, src,
14354 )
14355 })?),
14356 )),
14357 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14358 ::treesitter_types::runtime::maybe_grow_stack(|| {
14359 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14360 })?,
14361 ))),
14362 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14363 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14364 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14365 node, src,
14366 )
14367 })?),
14368 )),
14369 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14370 ::treesitter_types::runtime::maybe_grow_stack(|| {
14371 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
14372 })?,
14373 ))),
14374 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14375 ::treesitter_types::runtime::maybe_grow_stack(|| {
14376 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14377 })?,
14378 ))),
14379 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14380 }
14381 }
14382}
14383impl ::treesitter_types::Spanned for ReferenceAssignmentExpressionLeft<'_> {
14384 fn span(&self) -> ::treesitter_types::Span {
14385 match self {
14386 Self::CastExpression(inner) => inner.span(),
14387 Self::DynamicVariableName(inner) => inner.span(),
14388 Self::FunctionCallExpression(inner) => inner.span(),
14389 Self::ListLiteral(inner) => inner.span(),
14390 Self::MemberAccessExpression(inner) => inner.span(),
14391 Self::MemberCallExpression(inner) => inner.span(),
14392 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14393 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14394 Self::ScopedCallExpression(inner) => inner.span(),
14395 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14396 Self::SubscriptExpression(inner) => inner.span(),
14397 Self::VariableName(inner) => inner.span(),
14398 }
14399 }
14400}
14401#[derive(Debug, Clone, PartialEq, Eq)]
14402pub enum RelativeNamePrefix<'tree> {
14403 Backslash(::treesitter_types::Span),
14404 Namespace(::treesitter_types::Span),
14405 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
14406}
14407impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeNamePrefix<'tree> {
14408 #[allow(clippy::collapsible_else_if)]
14409 fn from_node(
14410 node: ::treesitter_types::tree_sitter::Node<'tree>,
14411 src: &'tree [u8],
14412 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14413 match node.kind() {
14414 "\\" => Ok(Self::Backslash(::treesitter_types::Span::from(node))),
14415 "namespace" => Ok(Self::Namespace(::treesitter_types::Span::from(node))),
14416 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
14417 ::treesitter_types::runtime::maybe_grow_stack(|| {
14418 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
14419 })?,
14420 ))),
14421 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14422 }
14423 }
14424}
14425impl ::treesitter_types::Spanned for RelativeNamePrefix<'_> {
14426 fn span(&self) -> ::treesitter_types::Span {
14427 match self {
14428 Self::Backslash(span) => *span,
14429 Self::Namespace(span) => *span,
14430 Self::NamespaceName(inner) => inner.span(),
14431 }
14432 }
14433}
14434#[derive(Debug, Clone, PartialEq, Eq)]
14435pub enum ScopedCallExpressionName<'tree> {
14436 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14437 Expression(::std::boxed::Box<Expression<'tree>>),
14438 Name(::std::boxed::Box<Name<'tree>>),
14439 VariableName(::std::boxed::Box<VariableName<'tree>>),
14440}
14441impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpressionName<'tree> {
14442 #[allow(clippy::collapsible_else_if)]
14443 fn from_node(
14444 node: ::treesitter_types::tree_sitter::Node<'tree>,
14445 src: &'tree [u8],
14446 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14447 match node.kind() {
14448 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14449 ::treesitter_types::runtime::maybe_grow_stack(|| {
14450 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14451 })?,
14452 ))),
14453 "name" => Ok(Self::Name(::std::boxed::Box::new(
14454 ::treesitter_types::runtime::maybe_grow_stack(|| {
14455 <Name as ::treesitter_types::FromNode>::from_node(node, src)
14456 })?,
14457 ))),
14458 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14459 ::treesitter_types::runtime::maybe_grow_stack(|| {
14460 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14461 })?,
14462 ))),
14463 _other => {
14464 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14465 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14466 }) {
14467 Ok(Self::Expression(::std::boxed::Box::new(v)))
14468 } else {
14469 Err(::treesitter_types::ParseError::unexpected_kind(
14470 _other, node,
14471 ))
14472 }
14473 }
14474 }
14475 }
14476}
14477impl ::treesitter_types::Spanned for ScopedCallExpressionName<'_> {
14478 fn span(&self) -> ::treesitter_types::Span {
14479 match self {
14480 Self::DynamicVariableName(inner) => inner.span(),
14481 Self::Expression(inner) => inner.span(),
14482 Self::Name(inner) => inner.span(),
14483 Self::VariableName(inner) => inner.span(),
14484 }
14485 }
14486}
14487#[derive(Debug, Clone, PartialEq, Eq)]
14488pub enum ScopedCallExpressionScope<'tree> {
14489 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
14490 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14491 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
14492 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14493 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
14494 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14495 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
14496 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14497 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14498 Name(::std::boxed::Box<Name<'tree>>),
14499 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
14500 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14501 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14502 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
14503 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14504 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14505 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
14506 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
14507 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14508 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14509 String(::std::boxed::Box<String<'tree>>),
14510 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14511 VariableName(::std::boxed::Box<VariableName<'tree>>),
14512}
14513impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpressionScope<'tree> {
14514 #[allow(clippy::collapsible_else_if)]
14515 fn from_node(
14516 node: ::treesitter_types::tree_sitter::Node<'tree>,
14517 src: &'tree [u8],
14518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14519 match node.kind() {
14520 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
14521 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14522 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14523 })?),
14524 )),
14525 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14526 ::treesitter_types::runtime::maybe_grow_stack(|| {
14527 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
14528 })?,
14529 ))),
14530 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
14531 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14532 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
14533 node, src,
14534 )
14535 })?),
14536 )),
14537 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14538 ::treesitter_types::runtime::maybe_grow_stack(|| {
14539 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14540 })?,
14541 ))),
14542 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
14543 ::treesitter_types::runtime::maybe_grow_stack(|| {
14544 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
14545 })?,
14546 ))),
14547 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14548 ::treesitter_types::runtime::maybe_grow_stack(|| {
14549 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14550 })?,
14551 ))),
14552 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
14553 ::treesitter_types::runtime::maybe_grow_stack(|| {
14554 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
14555 })?,
14556 ))),
14557 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14558 ::treesitter_types::runtime::maybe_grow_stack(|| {
14559 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
14560 })?,
14561 ))),
14562 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14563 ::treesitter_types::runtime::maybe_grow_stack(|| {
14564 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14565 })?,
14566 ))),
14567 "name" => Ok(Self::Name(::std::boxed::Box::new(
14568 ::treesitter_types::runtime::maybe_grow_stack(|| {
14569 <Name as ::treesitter_types::FromNode>::from_node(node, src)
14570 })?,
14571 ))),
14572 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
14573 ::treesitter_types::runtime::maybe_grow_stack(|| {
14574 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
14575 })?,
14576 ))),
14577 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14578 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14579 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14580 node, src,
14581 )
14582 })?),
14583 )),
14584 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
14585 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14586 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14587 node, src,
14588 )
14589 })?),
14590 )),
14591 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
14592 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14593 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14594 })?),
14595 )),
14596 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
14597 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14598 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14599 })?),
14600 )),
14601 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14602 ::treesitter_types::runtime::maybe_grow_stack(|| {
14603 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14604 })?,
14605 ))),
14606 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
14607 ::treesitter_types::runtime::maybe_grow_stack(|| {
14608 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
14609 })?,
14610 ))),
14611 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
14612 ::treesitter_types::runtime::maybe_grow_stack(|| {
14613 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)
14614 })?,
14615 ))),
14616 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14617 ::treesitter_types::runtime::maybe_grow_stack(|| {
14618 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14619 })?,
14620 ))),
14621 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14622 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14623 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14624 node, src,
14625 )
14626 })?),
14627 )),
14628 "string" => Ok(Self::String(::std::boxed::Box::new(
14629 ::treesitter_types::runtime::maybe_grow_stack(|| {
14630 <String as ::treesitter_types::FromNode>::from_node(node, src)
14631 })?,
14632 ))),
14633 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14634 ::treesitter_types::runtime::maybe_grow_stack(|| {
14635 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
14636 })?,
14637 ))),
14638 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14639 ::treesitter_types::runtime::maybe_grow_stack(|| {
14640 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14641 })?,
14642 ))),
14643 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14644 }
14645 }
14646}
14647impl ::treesitter_types::Spanned for ScopedCallExpressionScope<'_> {
14648 fn span(&self) -> ::treesitter_types::Span {
14649 match self {
14650 Self::ArrayCreationExpression(inner) => inner.span(),
14651 Self::CastExpression(inner) => inner.span(),
14652 Self::ClassConstantAccessExpression(inner) => inner.span(),
14653 Self::DynamicVariableName(inner) => inner.span(),
14654 Self::EncapsedString(inner) => inner.span(),
14655 Self::FunctionCallExpression(inner) => inner.span(),
14656 Self::Heredoc(inner) => inner.span(),
14657 Self::MemberAccessExpression(inner) => inner.span(),
14658 Self::MemberCallExpression(inner) => inner.span(),
14659 Self::Name(inner) => inner.span(),
14660 Self::Nowdoc(inner) => inner.span(),
14661 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14662 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14663 Self::ObjectCreationExpression(inner) => inner.span(),
14664 Self::ParenthesizedExpression(inner) => inner.span(),
14665 Self::QualifiedName(inner) => inner.span(),
14666 Self::RelativeName(inner) => inner.span(),
14667 Self::RelativeScope(inner) => inner.span(),
14668 Self::ScopedCallExpression(inner) => inner.span(),
14669 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14670 Self::String(inner) => inner.span(),
14671 Self::SubscriptExpression(inner) => inner.span(),
14672 Self::VariableName(inner) => inner.span(),
14673 }
14674 }
14675}
14676#[derive(Debug, Clone, PartialEq, Eq)]
14677pub enum ScopedPropertyAccessExpressionName<'tree> {
14678 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14679 VariableName(::std::boxed::Box<VariableName<'tree>>),
14680}
14681impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpressionName<'tree> {
14682 #[allow(clippy::collapsible_else_if)]
14683 fn from_node(
14684 node: ::treesitter_types::tree_sitter::Node<'tree>,
14685 src: &'tree [u8],
14686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14687 match node.kind() {
14688 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14689 ::treesitter_types::runtime::maybe_grow_stack(|| {
14690 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14691 })?,
14692 ))),
14693 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14694 ::treesitter_types::runtime::maybe_grow_stack(|| {
14695 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14696 })?,
14697 ))),
14698 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14699 }
14700 }
14701}
14702impl ::treesitter_types::Spanned for ScopedPropertyAccessExpressionName<'_> {
14703 fn span(&self) -> ::treesitter_types::Span {
14704 match self {
14705 Self::DynamicVariableName(inner) => inner.span(),
14706 Self::VariableName(inner) => inner.span(),
14707 }
14708 }
14709}
14710#[derive(Debug, Clone, PartialEq, Eq)]
14711pub enum ScopedPropertyAccessExpressionScope<'tree> {
14712 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
14713 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14714 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
14715 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14716 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
14717 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14718 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
14719 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14720 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14721 Name(::std::boxed::Box<Name<'tree>>),
14722 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
14723 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14724 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14725 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
14726 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14727 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14728 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
14729 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
14730 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14731 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14732 String(::std::boxed::Box<String<'tree>>),
14733 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14734 VariableName(::std::boxed::Box<VariableName<'tree>>),
14735}
14736impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpressionScope<'tree> {
14737 #[allow(clippy::collapsible_else_if)]
14738 fn from_node(
14739 node: ::treesitter_types::tree_sitter::Node<'tree>,
14740 src: &'tree [u8],
14741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14742 match node.kind() {
14743 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
14744 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14745 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14746 })?),
14747 )),
14748 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14749 ::treesitter_types::runtime::maybe_grow_stack(|| {
14750 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
14751 })?,
14752 ))),
14753 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
14754 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14755 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
14756 node, src,
14757 )
14758 })?),
14759 )),
14760 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14761 ::treesitter_types::runtime::maybe_grow_stack(|| {
14762 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14763 })?,
14764 ))),
14765 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
14766 ::treesitter_types::runtime::maybe_grow_stack(|| {
14767 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
14768 })?,
14769 ))),
14770 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14771 ::treesitter_types::runtime::maybe_grow_stack(|| {
14772 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14773 })?,
14774 ))),
14775 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
14776 ::treesitter_types::runtime::maybe_grow_stack(|| {
14777 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
14778 })?,
14779 ))),
14780 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14781 ::treesitter_types::runtime::maybe_grow_stack(|| {
14782 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
14783 })?,
14784 ))),
14785 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14786 ::treesitter_types::runtime::maybe_grow_stack(|| {
14787 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14788 })?,
14789 ))),
14790 "name" => Ok(Self::Name(::std::boxed::Box::new(
14791 ::treesitter_types::runtime::maybe_grow_stack(|| {
14792 <Name as ::treesitter_types::FromNode>::from_node(node, src)
14793 })?,
14794 ))),
14795 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
14796 ::treesitter_types::runtime::maybe_grow_stack(|| {
14797 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
14798 })?,
14799 ))),
14800 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14801 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14802 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14803 node, src,
14804 )
14805 })?),
14806 )),
14807 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
14808 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14809 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14810 node, src,
14811 )
14812 })?),
14813 )),
14814 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
14815 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14816 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14817 })?),
14818 )),
14819 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
14820 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14821 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14822 })?),
14823 )),
14824 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14825 ::treesitter_types::runtime::maybe_grow_stack(|| {
14826 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
14827 })?,
14828 ))),
14829 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
14830 ::treesitter_types::runtime::maybe_grow_stack(|| {
14831 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
14832 })?,
14833 ))),
14834 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
14835 ::treesitter_types::runtime::maybe_grow_stack(|| {
14836 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)
14837 })?,
14838 ))),
14839 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14840 ::treesitter_types::runtime::maybe_grow_stack(|| {
14841 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
14842 })?,
14843 ))),
14844 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14845 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
14846 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14847 node, src,
14848 )
14849 })?),
14850 )),
14851 "string" => Ok(Self::String(::std::boxed::Box::new(
14852 ::treesitter_types::runtime::maybe_grow_stack(|| {
14853 <String as ::treesitter_types::FromNode>::from_node(node, src)
14854 })?,
14855 ))),
14856 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14857 ::treesitter_types::runtime::maybe_grow_stack(|| {
14858 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
14859 })?,
14860 ))),
14861 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14862 ::treesitter_types::runtime::maybe_grow_stack(|| {
14863 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14864 })?,
14865 ))),
14866 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14867 }
14868 }
14869}
14870impl ::treesitter_types::Spanned for ScopedPropertyAccessExpressionScope<'_> {
14871 fn span(&self) -> ::treesitter_types::Span {
14872 match self {
14873 Self::ArrayCreationExpression(inner) => inner.span(),
14874 Self::CastExpression(inner) => inner.span(),
14875 Self::ClassConstantAccessExpression(inner) => inner.span(),
14876 Self::DynamicVariableName(inner) => inner.span(),
14877 Self::EncapsedString(inner) => inner.span(),
14878 Self::FunctionCallExpression(inner) => inner.span(),
14879 Self::Heredoc(inner) => inner.span(),
14880 Self::MemberAccessExpression(inner) => inner.span(),
14881 Self::MemberCallExpression(inner) => inner.span(),
14882 Self::Name(inner) => inner.span(),
14883 Self::Nowdoc(inner) => inner.span(),
14884 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14885 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14886 Self::ObjectCreationExpression(inner) => inner.span(),
14887 Self::ParenthesizedExpression(inner) => inner.span(),
14888 Self::QualifiedName(inner) => inner.span(),
14889 Self::RelativeName(inner) => inner.span(),
14890 Self::RelativeScope(inner) => inner.span(),
14891 Self::ScopedCallExpression(inner) => inner.span(),
14892 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14893 Self::String(inner) => inner.span(),
14894 Self::SubscriptExpression(inner) => inner.span(),
14895 Self::VariableName(inner) => inner.span(),
14896 }
14897 }
14898}
14899#[derive(Debug, Clone, PartialEq, Eq)]
14900pub enum SequenceExpressionChildren<'tree> {
14901 Expression(::std::boxed::Box<Expression<'tree>>),
14902 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
14903}
14904impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpressionChildren<'tree> {
14905 #[allow(clippy::collapsible_else_if)]
14906 fn from_node(
14907 node: ::treesitter_types::tree_sitter::Node<'tree>,
14908 src: &'tree [u8],
14909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14910 match node.kind() {
14911 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
14912 ::treesitter_types::runtime::maybe_grow_stack(|| {
14913 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
14914 })?,
14915 ))),
14916 _other => {
14917 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14918 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14919 }) {
14920 Ok(Self::Expression(::std::boxed::Box::new(v)))
14921 } else {
14922 Err(::treesitter_types::ParseError::unexpected_kind(
14923 _other, node,
14924 ))
14925 }
14926 }
14927 }
14928 }
14929}
14930impl ::treesitter_types::Spanned for SequenceExpressionChildren<'_> {
14931 fn span(&self) -> ::treesitter_types::Span {
14932 match self {
14933 Self::Expression(inner) => inner.span(),
14934 Self::SequenceExpression(inner) => inner.span(),
14935 }
14936 }
14937}
14938#[derive(Debug, Clone, PartialEq, Eq)]
14939pub enum ShellCommandExpressionChildren<'tree> {
14940 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14941 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
14942 Expression(::std::boxed::Box<Expression<'tree>>),
14943 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14944 StringContent(::std::boxed::Box<StringContent<'tree>>),
14945 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14946 VariableName(::std::boxed::Box<VariableName<'tree>>),
14947}
14948impl<'tree> ::treesitter_types::FromNode<'tree> for ShellCommandExpressionChildren<'tree> {
14949 #[allow(clippy::collapsible_else_if)]
14950 fn from_node(
14951 node: ::treesitter_types::tree_sitter::Node<'tree>,
14952 src: &'tree [u8],
14953 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14954 match node.kind() {
14955 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14956 ::treesitter_types::runtime::maybe_grow_stack(|| {
14957 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
14958 })?,
14959 ))),
14960 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
14961 ::treesitter_types::runtime::maybe_grow_stack(|| {
14962 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
14963 })?,
14964 ))),
14965 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14966 ::treesitter_types::runtime::maybe_grow_stack(|| {
14967 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
14968 })?,
14969 ))),
14970 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
14971 ::treesitter_types::runtime::maybe_grow_stack(|| {
14972 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
14973 })?,
14974 ))),
14975 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14976 ::treesitter_types::runtime::maybe_grow_stack(|| {
14977 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
14978 })?,
14979 ))),
14980 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14981 ::treesitter_types::runtime::maybe_grow_stack(|| {
14982 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
14983 })?,
14984 ))),
14985 _other => {
14986 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14987 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14988 }) {
14989 Ok(Self::Expression(::std::boxed::Box::new(v)))
14990 } else {
14991 Err(::treesitter_types::ParseError::unexpected_kind(
14992 _other, node,
14993 ))
14994 }
14995 }
14996 }
14997 }
14998}
14999impl ::treesitter_types::Spanned for ShellCommandExpressionChildren<'_> {
15000 fn span(&self) -> ::treesitter_types::Span {
15001 match self {
15002 Self::DynamicVariableName(inner) => inner.span(),
15003 Self::EscapeSequence(inner) => inner.span(),
15004 Self::Expression(inner) => inner.span(),
15005 Self::MemberAccessExpression(inner) => inner.span(),
15006 Self::StringContent(inner) => inner.span(),
15007 Self::SubscriptExpression(inner) => inner.span(),
15008 Self::VariableName(inner) => inner.span(),
15009 }
15010 }
15011}
15012#[derive(Debug, Clone, PartialEq, Eq)]
15013pub enum StringChildren<'tree> {
15014 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
15015 StringContent(::std::boxed::Box<StringContent<'tree>>),
15016}
15017impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
15018 #[allow(clippy::collapsible_else_if)]
15019 fn from_node(
15020 node: ::treesitter_types::tree_sitter::Node<'tree>,
15021 src: &'tree [u8],
15022 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15023 match node.kind() {
15024 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
15025 ::treesitter_types::runtime::maybe_grow_stack(|| {
15026 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
15027 })?,
15028 ))),
15029 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
15030 ::treesitter_types::runtime::maybe_grow_stack(|| {
15031 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
15032 })?,
15033 ))),
15034 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15035 }
15036 }
15037}
15038impl ::treesitter_types::Spanned for StringChildren<'_> {
15039 fn span(&self) -> ::treesitter_types::Span {
15040 match self {
15041 Self::EscapeSequence(inner) => inner.span(),
15042 Self::StringContent(inner) => inner.span(),
15043 }
15044 }
15045}
15046#[derive(Debug, Clone, PartialEq, Eq)]
15047pub enum SubscriptExpressionChildren<'tree> {
15048 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
15049 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
15050 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
15051 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
15052 Expression(::std::boxed::Box<Expression<'tree>>),
15053 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
15054 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
15055 Integer(::std::boxed::Box<Integer<'tree>>),
15056 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
15057 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
15058 Name(::std::boxed::Box<Name<'tree>>),
15059 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
15060 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
15061 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
15062 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
15063 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
15064 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15065 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
15066 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
15067 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
15068 String(::std::boxed::Box<String<'tree>>),
15069 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
15070 VariableName(::std::boxed::Box<VariableName<'tree>>),
15071}
15072impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionChildren<'tree> {
15073 #[allow(clippy::collapsible_else_if)]
15074 fn from_node(
15075 node: ::treesitter_types::tree_sitter::Node<'tree>,
15076 src: &'tree [u8],
15077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15078 match node.kind() {
15079 "array_creation_expression" => Ok(Self::ArrayCreationExpression(
15080 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15081 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15082 })?),
15083 )),
15084 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
15085 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15086 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
15087 node, src,
15088 )
15089 })?),
15090 )),
15091 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
15092 ::treesitter_types::runtime::maybe_grow_stack(|| {
15093 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
15094 })?,
15095 ))),
15096 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
15097 ::treesitter_types::runtime::maybe_grow_stack(|| {
15098 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
15099 })?,
15100 ))),
15101 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
15102 ::treesitter_types::runtime::maybe_grow_stack(|| {
15103 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15104 })?,
15105 ))),
15106 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
15107 ::treesitter_types::runtime::maybe_grow_stack(|| {
15108 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
15109 })?,
15110 ))),
15111 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
15112 ::treesitter_types::runtime::maybe_grow_stack(|| {
15113 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
15114 })?,
15115 ))),
15116 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
15117 ::treesitter_types::runtime::maybe_grow_stack(|| {
15118 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15119 })?,
15120 ))),
15121 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
15122 ::treesitter_types::runtime::maybe_grow_stack(|| {
15123 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15124 })?,
15125 ))),
15126 "name" => Ok(Self::Name(::std::boxed::Box::new(
15127 ::treesitter_types::runtime::maybe_grow_stack(|| {
15128 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15129 })?,
15130 ))),
15131 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
15132 ::treesitter_types::runtime::maybe_grow_stack(|| {
15133 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
15134 })?,
15135 ))),
15136 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
15137 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15138 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
15139 node, src,
15140 )
15141 })?),
15142 )),
15143 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
15144 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15145 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
15146 node, src,
15147 )
15148 })?),
15149 )),
15150 "object_creation_expression" => Ok(Self::ObjectCreationExpression(
15151 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15152 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15153 })?),
15154 )),
15155 "parenthesized_expression" => Ok(Self::ParenthesizedExpression(
15156 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15157 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15158 })?),
15159 )),
15160 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15161 ::treesitter_types::runtime::maybe_grow_stack(|| {
15162 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15163 })?,
15164 ))),
15165 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
15166 ::treesitter_types::runtime::maybe_grow_stack(|| {
15167 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
15168 })?,
15169 ))),
15170 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
15171 ::treesitter_types::runtime::maybe_grow_stack(|| {
15172 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15173 })?,
15174 ))),
15175 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
15176 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15177 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
15178 node, src,
15179 )
15180 })?),
15181 )),
15182 "string" => Ok(Self::String(::std::boxed::Box::new(
15183 ::treesitter_types::runtime::maybe_grow_stack(|| {
15184 <String as ::treesitter_types::FromNode>::from_node(node, src)
15185 })?,
15186 ))),
15187 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
15188 ::treesitter_types::runtime::maybe_grow_stack(|| {
15189 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
15190 })?,
15191 ))),
15192 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
15193 ::treesitter_types::runtime::maybe_grow_stack(|| {
15194 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
15195 })?,
15196 ))),
15197 _other => {
15198 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15199 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15200 }) {
15201 Ok(Self::Expression(::std::boxed::Box::new(v)))
15202 } else {
15203 Err(::treesitter_types::ParseError::unexpected_kind(
15204 _other, node,
15205 ))
15206 }
15207 }
15208 }
15209 }
15210}
15211impl ::treesitter_types::Spanned for SubscriptExpressionChildren<'_> {
15212 fn span(&self) -> ::treesitter_types::Span {
15213 match self {
15214 Self::ArrayCreationExpression(inner) => inner.span(),
15215 Self::ClassConstantAccessExpression(inner) => inner.span(),
15216 Self::DynamicVariableName(inner) => inner.span(),
15217 Self::EncapsedString(inner) => inner.span(),
15218 Self::Expression(inner) => inner.span(),
15219 Self::FunctionCallExpression(inner) => inner.span(),
15220 Self::Heredoc(inner) => inner.span(),
15221 Self::Integer(inner) => inner.span(),
15222 Self::MemberAccessExpression(inner) => inner.span(),
15223 Self::MemberCallExpression(inner) => inner.span(),
15224 Self::Name(inner) => inner.span(),
15225 Self::Nowdoc(inner) => inner.span(),
15226 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
15227 Self::NullsafeMemberCallExpression(inner) => inner.span(),
15228 Self::ObjectCreationExpression(inner) => inner.span(),
15229 Self::ParenthesizedExpression(inner) => inner.span(),
15230 Self::QualifiedName(inner) => inner.span(),
15231 Self::RelativeName(inner) => inner.span(),
15232 Self::ScopedCallExpression(inner) => inner.span(),
15233 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
15234 Self::String(inner) => inner.span(),
15235 Self::SubscriptExpression(inner) => inner.span(),
15236 Self::VariableName(inner) => inner.span(),
15237 }
15238 }
15239}
15240#[derive(Debug, Clone, PartialEq, Eq)]
15241pub enum SwitchBlockChildren<'tree> {
15242 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
15243 DefaultStatement(::std::boxed::Box<DefaultStatement<'tree>>),
15244}
15245impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockChildren<'tree> {
15246 #[allow(clippy::collapsible_else_if)]
15247 fn from_node(
15248 node: ::treesitter_types::tree_sitter::Node<'tree>,
15249 src: &'tree [u8],
15250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15251 match node.kind() {
15252 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
15253 ::treesitter_types::runtime::maybe_grow_stack(|| {
15254 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
15255 })?,
15256 ))),
15257 "default_statement" => Ok(Self::DefaultStatement(::std::boxed::Box::new(
15258 ::treesitter_types::runtime::maybe_grow_stack(|| {
15259 <DefaultStatement as ::treesitter_types::FromNode>::from_node(node, src)
15260 })?,
15261 ))),
15262 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15263 }
15264 }
15265}
15266impl ::treesitter_types::Spanned for SwitchBlockChildren<'_> {
15267 fn span(&self) -> ::treesitter_types::Span {
15268 match self {
15269 Self::CaseStatement(inner) => inner.span(),
15270 Self::DefaultStatement(inner) => inner.span(),
15271 }
15272 }
15273}
15274#[derive(Debug, Clone, PartialEq, Eq)]
15275pub enum TextInterpolationChildren<'tree> {
15276 PhpEndTag(::std::boxed::Box<PhpEndTag<'tree>>),
15277 PhpTag(::std::boxed::Box<PhpTag<'tree>>),
15278 Text(::std::boxed::Box<Text<'tree>>),
15279}
15280impl<'tree> ::treesitter_types::FromNode<'tree> for TextInterpolationChildren<'tree> {
15281 #[allow(clippy::collapsible_else_if)]
15282 fn from_node(
15283 node: ::treesitter_types::tree_sitter::Node<'tree>,
15284 src: &'tree [u8],
15285 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15286 match node.kind() {
15287 "php_end_tag" => Ok(Self::PhpEndTag(::std::boxed::Box::new(
15288 ::treesitter_types::runtime::maybe_grow_stack(|| {
15289 <PhpEndTag as ::treesitter_types::FromNode>::from_node(node, src)
15290 })?,
15291 ))),
15292 "php_tag" => Ok(Self::PhpTag(::std::boxed::Box::new(
15293 ::treesitter_types::runtime::maybe_grow_stack(|| {
15294 <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)
15295 })?,
15296 ))),
15297 "text" => Ok(Self::Text(::std::boxed::Box::new(
15298 ::treesitter_types::runtime::maybe_grow_stack(|| {
15299 <Text as ::treesitter_types::FromNode>::from_node(node, src)
15300 })?,
15301 ))),
15302 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15303 }
15304 }
15305}
15306impl ::treesitter_types::Spanned for TextInterpolationChildren<'_> {
15307 fn span(&self) -> ::treesitter_types::Span {
15308 match self {
15309 Self::PhpEndTag(inner) => inner.span(),
15310 Self::PhpTag(inner) => inner.span(),
15311 Self::Text(inner) => inner.span(),
15312 }
15313 }
15314}
15315#[derive(Debug, Clone, PartialEq, Eq)]
15316pub enum TryStatementChildren<'tree> {
15317 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
15318 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
15319}
15320impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
15321 #[allow(clippy::collapsible_else_if)]
15322 fn from_node(
15323 node: ::treesitter_types::tree_sitter::Node<'tree>,
15324 src: &'tree [u8],
15325 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15326 match node.kind() {
15327 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
15328 ::treesitter_types::runtime::maybe_grow_stack(|| {
15329 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
15330 })?,
15331 ))),
15332 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
15333 ::treesitter_types::runtime::maybe_grow_stack(|| {
15334 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
15335 })?,
15336 ))),
15337 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15338 }
15339 }
15340}
15341impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
15342 fn span(&self) -> ::treesitter_types::Span {
15343 match self {
15344 Self::CatchClause(inner) => inner.span(),
15345 Self::FinallyClause(inner) => inner.span(),
15346 }
15347 }
15348}
15349#[derive(Debug, Clone, PartialEq, Eq)]
15350pub enum UnaryOpExpressionOperator {
15351 Bang(::treesitter_types::Span),
15352 Plus(::treesitter_types::Span),
15353 Minus(::treesitter_types::Span),
15354 Tilde(::treesitter_types::Span),
15355}
15356impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOpExpressionOperator {
15357 #[allow(clippy::collapsible_else_if)]
15358 fn from_node(
15359 node: ::treesitter_types::tree_sitter::Node<'tree>,
15360 _src: &'tree [u8],
15361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15362 match node.kind() {
15363 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
15364 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
15365 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
15366 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
15367 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15368 }
15369 }
15370}
15371impl ::treesitter_types::Spanned for UnaryOpExpressionOperator {
15372 fn span(&self) -> ::treesitter_types::Span {
15373 match self {
15374 Self::Bang(span) => *span,
15375 Self::Plus(span) => *span,
15376 Self::Minus(span) => *span,
15377 Self::Tilde(span) => *span,
15378 }
15379 }
15380}
15381#[derive(Debug, Clone, PartialEq, Eq)]
15382pub enum UnionTypeChildren<'tree> {
15383 NamedType(::std::boxed::Box<NamedType<'tree>>),
15384 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
15385 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
15386}
15387impl<'tree> ::treesitter_types::FromNode<'tree> for UnionTypeChildren<'tree> {
15388 #[allow(clippy::collapsible_else_if)]
15389 fn from_node(
15390 node: ::treesitter_types::tree_sitter::Node<'tree>,
15391 src: &'tree [u8],
15392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15393 match node.kind() {
15394 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
15395 ::treesitter_types::runtime::maybe_grow_stack(|| {
15396 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
15397 })?,
15398 ))),
15399 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
15400 ::treesitter_types::runtime::maybe_grow_stack(|| {
15401 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
15402 })?,
15403 ))),
15404 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
15405 ::treesitter_types::runtime::maybe_grow_stack(|| {
15406 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
15407 })?,
15408 ))),
15409 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15410 }
15411 }
15412}
15413impl ::treesitter_types::Spanned for UnionTypeChildren<'_> {
15414 fn span(&self) -> ::treesitter_types::Span {
15415 match self {
15416 Self::NamedType(inner) => inner.span(),
15417 Self::OptionalType(inner) => inner.span(),
15418 Self::PrimitiveType(inner) => inner.span(),
15419 }
15420 }
15421}
15422#[derive(Debug, Clone, PartialEq, Eq)]
15423pub enum UnsetStatementChildren<'tree> {
15424 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
15425 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
15426 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
15427 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
15428 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
15429 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
15430 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
15431 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
15432 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
15433 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
15434 VariableName(::std::boxed::Box<VariableName<'tree>>),
15435}
15436impl<'tree> ::treesitter_types::FromNode<'tree> for UnsetStatementChildren<'tree> {
15437 #[allow(clippy::collapsible_else_if)]
15438 fn from_node(
15439 node: ::treesitter_types::tree_sitter::Node<'tree>,
15440 src: &'tree [u8],
15441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15442 match node.kind() {
15443 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
15444 ::treesitter_types::runtime::maybe_grow_stack(|| {
15445 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15446 })?,
15447 ))),
15448 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
15449 ::treesitter_types::runtime::maybe_grow_stack(|| {
15450 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
15451 })?,
15452 ))),
15453 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
15454 ::treesitter_types::runtime::maybe_grow_stack(|| {
15455 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15456 })?,
15457 ))),
15458 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
15459 ::treesitter_types::runtime::maybe_grow_stack(|| {
15460 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15461 })?,
15462 ))),
15463 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
15464 ::treesitter_types::runtime::maybe_grow_stack(|| {
15465 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15466 })?,
15467 ))),
15468 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
15469 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15470 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
15471 node, src,
15472 )
15473 })?),
15474 )),
15475 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
15476 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15477 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
15478 node, src,
15479 )
15480 })?),
15481 )),
15482 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
15483 ::treesitter_types::runtime::maybe_grow_stack(|| {
15484 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15485 })?,
15486 ))),
15487 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
15488 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15489 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
15490 node, src,
15491 )
15492 })?),
15493 )),
15494 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
15495 ::treesitter_types::runtime::maybe_grow_stack(|| {
15496 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
15497 })?,
15498 ))),
15499 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
15500 ::treesitter_types::runtime::maybe_grow_stack(|| {
15501 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
15502 })?,
15503 ))),
15504 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15505 }
15506 }
15507}
15508impl ::treesitter_types::Spanned for UnsetStatementChildren<'_> {
15509 fn span(&self) -> ::treesitter_types::Span {
15510 match self {
15511 Self::CastExpression(inner) => inner.span(),
15512 Self::DynamicVariableName(inner) => inner.span(),
15513 Self::FunctionCallExpression(inner) => inner.span(),
15514 Self::MemberAccessExpression(inner) => inner.span(),
15515 Self::MemberCallExpression(inner) => inner.span(),
15516 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
15517 Self::NullsafeMemberCallExpression(inner) => inner.span(),
15518 Self::ScopedCallExpression(inner) => inner.span(),
15519 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
15520 Self::SubscriptExpression(inner) => inner.span(),
15521 Self::VariableName(inner) => inner.span(),
15522 }
15523 }
15524}
15525#[derive(Debug, Clone, PartialEq, Eq)]
15526pub enum UpdateExpressionArgument<'tree> {
15527 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
15528 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
15529 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
15530 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
15531 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
15532 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
15533 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
15534 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
15535 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
15536 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
15537 VariableName(::std::boxed::Box<VariableName<'tree>>),
15538}
15539impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionArgument<'tree> {
15540 #[allow(clippy::collapsible_else_if)]
15541 fn from_node(
15542 node: ::treesitter_types::tree_sitter::Node<'tree>,
15543 src: &'tree [u8],
15544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15545 match node.kind() {
15546 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
15547 ::treesitter_types::runtime::maybe_grow_stack(|| {
15548 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15549 })?,
15550 ))),
15551 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
15552 ::treesitter_types::runtime::maybe_grow_stack(|| {
15553 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
15554 })?,
15555 ))),
15556 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
15557 ::treesitter_types::runtime::maybe_grow_stack(|| {
15558 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15559 })?,
15560 ))),
15561 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
15562 ::treesitter_types::runtime::maybe_grow_stack(|| {
15563 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15564 })?,
15565 ))),
15566 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
15567 ::treesitter_types::runtime::maybe_grow_stack(|| {
15568 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15569 })?,
15570 ))),
15571 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
15572 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15573 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
15574 node, src,
15575 )
15576 })?),
15577 )),
15578 "nullsafe_member_call_expression" => Ok(Self::NullsafeMemberCallExpression(
15579 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15580 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
15581 node, src,
15582 )
15583 })?),
15584 )),
15585 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
15586 ::treesitter_types::runtime::maybe_grow_stack(|| {
15587 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15588 })?,
15589 ))),
15590 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
15591 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15592 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
15593 node, src,
15594 )
15595 })?),
15596 )),
15597 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
15598 ::treesitter_types::runtime::maybe_grow_stack(|| {
15599 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
15600 })?,
15601 ))),
15602 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
15603 ::treesitter_types::runtime::maybe_grow_stack(|| {
15604 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
15605 })?,
15606 ))),
15607 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15608 }
15609 }
15610}
15611impl ::treesitter_types::Spanned for UpdateExpressionArgument<'_> {
15612 fn span(&self) -> ::treesitter_types::Span {
15613 match self {
15614 Self::CastExpression(inner) => inner.span(),
15615 Self::DynamicVariableName(inner) => inner.span(),
15616 Self::FunctionCallExpression(inner) => inner.span(),
15617 Self::MemberAccessExpression(inner) => inner.span(),
15618 Self::MemberCallExpression(inner) => inner.span(),
15619 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
15620 Self::NullsafeMemberCallExpression(inner) => inner.span(),
15621 Self::ScopedCallExpression(inner) => inner.span(),
15622 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
15623 Self::SubscriptExpression(inner) => inner.span(),
15624 Self::VariableName(inner) => inner.span(),
15625 }
15626 }
15627}
15628#[derive(Debug, Clone, PartialEq, Eq)]
15629pub enum UpdateExpressionOperator {
15630 PlusPlus(::treesitter_types::Span),
15631 MinusMinus(::treesitter_types::Span),
15632}
15633impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
15634 #[allow(clippy::collapsible_else_if)]
15635 fn from_node(
15636 node: ::treesitter_types::tree_sitter::Node<'tree>,
15637 _src: &'tree [u8],
15638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15639 match node.kind() {
15640 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
15641 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
15642 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15643 }
15644 }
15645}
15646impl ::treesitter_types::Spanned for UpdateExpressionOperator {
15647 fn span(&self) -> ::treesitter_types::Span {
15648 match self {
15649 Self::PlusPlus(span) => *span,
15650 Self::MinusMinus(span) => *span,
15651 }
15652 }
15653}
15654#[derive(Debug, Clone, PartialEq, Eq)]
15655pub enum UseAsClauseChildren<'tree> {
15656 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
15657 Name(::std::boxed::Box<Name<'tree>>),
15658 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
15659}
15660impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClauseChildren<'tree> {
15661 #[allow(clippy::collapsible_else_if)]
15662 fn from_node(
15663 node: ::treesitter_types::tree_sitter::Node<'tree>,
15664 src: &'tree [u8],
15665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15666 match node.kind() {
15667 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
15668 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15669 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
15670 node, src,
15671 )
15672 })?),
15673 )),
15674 "name" => Ok(Self::Name(::std::boxed::Box::new(
15675 ::treesitter_types::runtime::maybe_grow_stack(|| {
15676 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15677 })?,
15678 ))),
15679 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
15680 ::treesitter_types::runtime::maybe_grow_stack(|| {
15681 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
15682 })?,
15683 ))),
15684 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15685 }
15686 }
15687}
15688impl ::treesitter_types::Spanned for UseAsClauseChildren<'_> {
15689 fn span(&self) -> ::treesitter_types::Span {
15690 match self {
15691 Self::ClassConstantAccessExpression(inner) => inner.span(),
15692 Self::Name(inner) => inner.span(),
15693 Self::VisibilityModifier(inner) => inner.span(),
15694 }
15695 }
15696}
15697#[derive(Debug, Clone, PartialEq, Eq)]
15698pub enum UseDeclarationChildren<'tree> {
15699 Name(::std::boxed::Box<Name<'tree>>),
15700 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
15701 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
15702 UseList(::std::boxed::Box<UseList<'tree>>),
15703}
15704impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclarationChildren<'tree> {
15705 #[allow(clippy::collapsible_else_if)]
15706 fn from_node(
15707 node: ::treesitter_types::tree_sitter::Node<'tree>,
15708 src: &'tree [u8],
15709 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15710 match node.kind() {
15711 "name" => Ok(Self::Name(::std::boxed::Box::new(
15712 ::treesitter_types::runtime::maybe_grow_stack(|| {
15713 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15714 })?,
15715 ))),
15716 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
15717 ::treesitter_types::runtime::maybe_grow_stack(|| {
15718 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15719 })?,
15720 ))),
15721 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
15722 ::treesitter_types::runtime::maybe_grow_stack(|| {
15723 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
15724 })?,
15725 ))),
15726 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
15727 ::treesitter_types::runtime::maybe_grow_stack(|| {
15728 <UseList as ::treesitter_types::FromNode>::from_node(node, src)
15729 })?,
15730 ))),
15731 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15732 }
15733 }
15734}
15735impl ::treesitter_types::Spanned for UseDeclarationChildren<'_> {
15736 fn span(&self) -> ::treesitter_types::Span {
15737 match self {
15738 Self::Name(inner) => inner.span(),
15739 Self::QualifiedName(inner) => inner.span(),
15740 Self::RelativeName(inner) => inner.span(),
15741 Self::UseList(inner) => inner.span(),
15742 }
15743 }
15744}
15745#[derive(Debug, Clone, PartialEq, Eq)]
15746pub enum UseInsteadOfClauseChildren<'tree> {
15747 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
15748 Name(::std::boxed::Box<Name<'tree>>),
15749}
15750impl<'tree> ::treesitter_types::FromNode<'tree> for UseInsteadOfClauseChildren<'tree> {
15751 #[allow(clippy::collapsible_else_if)]
15752 fn from_node(
15753 node: ::treesitter_types::tree_sitter::Node<'tree>,
15754 src: &'tree [u8],
15755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15756 match node.kind() {
15757 "class_constant_access_expression" => Ok(Self::ClassConstantAccessExpression(
15758 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15759 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
15760 node, src,
15761 )
15762 })?),
15763 )),
15764 "name" => Ok(Self::Name(::std::boxed::Box::new(
15765 ::treesitter_types::runtime::maybe_grow_stack(|| {
15766 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15767 })?,
15768 ))),
15769 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15770 }
15771 }
15772}
15773impl ::treesitter_types::Spanned for UseInsteadOfClauseChildren<'_> {
15774 fn span(&self) -> ::treesitter_types::Span {
15775 match self {
15776 Self::ClassConstantAccessExpression(inner) => inner.span(),
15777 Self::Name(inner) => inner.span(),
15778 }
15779 }
15780}
15781#[derive(Debug, Clone, PartialEq, Eq)]
15782pub enum UseListChildren<'tree> {
15783 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
15784 UseInsteadOfClause(::std::boxed::Box<UseInsteadOfClause<'tree>>),
15785}
15786impl<'tree> ::treesitter_types::FromNode<'tree> for UseListChildren<'tree> {
15787 #[allow(clippy::collapsible_else_if)]
15788 fn from_node(
15789 node: ::treesitter_types::tree_sitter::Node<'tree>,
15790 src: &'tree [u8],
15791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15792 match node.kind() {
15793 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
15794 ::treesitter_types::runtime::maybe_grow_stack(|| {
15795 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
15796 })?,
15797 ))),
15798 "use_instead_of_clause" => Ok(Self::UseInsteadOfClause(::std::boxed::Box::new(
15799 ::treesitter_types::runtime::maybe_grow_stack(|| {
15800 <UseInsteadOfClause as ::treesitter_types::FromNode>::from_node(node, src)
15801 })?,
15802 ))),
15803 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15804 }
15805 }
15806}
15807impl ::treesitter_types::Spanned for UseListChildren<'_> {
15808 fn span(&self) -> ::treesitter_types::Span {
15809 match self {
15810 Self::UseAsClause(inner) => inner.span(),
15811 Self::UseInsteadOfClause(inner) => inner.span(),
15812 }
15813 }
15814}
15815#[derive(Debug, Clone, PartialEq, Eq)]
15816pub enum WhileStatementBody<'tree> {
15817 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
15818 Statement(::std::boxed::Box<Statement<'tree>>),
15819}
15820impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatementBody<'tree> {
15821 #[allow(clippy::collapsible_else_if)]
15822 fn from_node(
15823 node: ::treesitter_types::tree_sitter::Node<'tree>,
15824 src: &'tree [u8],
15825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15826 match node.kind() {
15827 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
15828 ::treesitter_types::runtime::maybe_grow_stack(|| {
15829 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
15830 })?,
15831 ))),
15832 _other => {
15833 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15834 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
15835 }) {
15836 Ok(Self::Statement(::std::boxed::Box::new(v)))
15837 } else {
15838 Err(::treesitter_types::ParseError::unexpected_kind(
15839 _other, node,
15840 ))
15841 }
15842 }
15843 }
15844 }
15845}
15846impl ::treesitter_types::Spanned for WhileStatementBody<'_> {
15847 fn span(&self) -> ::treesitter_types::Span {
15848 match self {
15849 Self::ColonBlock(inner) => inner.span(),
15850 Self::Statement(inner) => inner.span(),
15851 }
15852 }
15853}
15854#[derive(Debug, Clone, PartialEq, Eq)]
15855pub enum YieldExpressionChildren<'tree> {
15856 ArrayElementInitializer(::std::boxed::Box<ArrayElementInitializer<'tree>>),
15857 Expression(::std::boxed::Box<Expression<'tree>>),
15858}
15859impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpressionChildren<'tree> {
15860 #[allow(clippy::collapsible_else_if)]
15861 fn from_node(
15862 node: ::treesitter_types::tree_sitter::Node<'tree>,
15863 src: &'tree [u8],
15864 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15865 match node.kind() {
15866 "array_element_initializer" => Ok(Self::ArrayElementInitializer(
15867 ::std::boxed::Box::new(::treesitter_types::runtime::maybe_grow_stack(|| {
15868 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(node, src)
15869 })?),
15870 )),
15871 _other => {
15872 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15873 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15874 }) {
15875 Ok(Self::Expression(::std::boxed::Box::new(v)))
15876 } else {
15877 Err(::treesitter_types::ParseError::unexpected_kind(
15878 _other, node,
15879 ))
15880 }
15881 }
15882 }
15883 }
15884}
15885impl ::treesitter_types::Spanned for YieldExpressionChildren<'_> {
15886 fn span(&self) -> ::treesitter_types::Span {
15887 match self {
15888 Self::ArrayElementInitializer(inner) => inner.span(),
15889 Self::Expression(inner) => inner.span(),
15890 }
15891 }
15892}
15893#[derive(Debug, Clone, PartialEq, Eq)]
15894pub enum AnyNode<'tree> {
15895 Expression(Expression<'tree>),
15896 Literal(Literal<'tree>),
15897 PrimaryExpression(PrimaryExpression<'tree>),
15898 Statement(Statement<'tree>),
15899 Type(Type<'tree>),
15900 AbstractModifier(AbstractModifier<'tree>),
15901 AnonymousClass(AnonymousClass<'tree>),
15902 AnonymousFunction(AnonymousFunction<'tree>),
15903 AnonymousFunctionUseClause(AnonymousFunctionUseClause<'tree>),
15904 Argument(Argument<'tree>),
15905 Arguments(Arguments<'tree>),
15906 ArrayCreationExpression(ArrayCreationExpression<'tree>),
15907 ArrayElementInitializer(ArrayElementInitializer<'tree>),
15908 ArrowFunction(ArrowFunction<'tree>),
15909 AssignmentExpression(AssignmentExpression<'tree>),
15910 Attribute(Attribute<'tree>),
15911 AttributeGroup(AttributeGroup<'tree>),
15912 AttributeList(AttributeList<'tree>),
15913 AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
15914 BaseClause(BaseClause<'tree>),
15915 BinaryExpression(BinaryExpression<'tree>),
15916 Boolean(Boolean<'tree>),
15917 BreakStatement(BreakStatement<'tree>),
15918 ByRef(ByRef<'tree>),
15919 CaseStatement(CaseStatement<'tree>),
15920 CastExpression(CastExpression<'tree>),
15921 CastType(CastType<'tree>),
15922 CatchClause(CatchClause<'tree>),
15923 ClassConstantAccessExpression(ClassConstantAccessExpression<'tree>),
15924 ClassDeclaration(ClassDeclaration<'tree>),
15925 ClassInterfaceClause(ClassInterfaceClause<'tree>),
15926 CloneExpression(CloneExpression<'tree>),
15927 ColonBlock(ColonBlock<'tree>),
15928 CompoundStatement(CompoundStatement<'tree>),
15929 ConditionalExpression(ConditionalExpression<'tree>),
15930 ConstDeclaration(ConstDeclaration<'tree>),
15931 ConstElement(ConstElement<'tree>),
15932 ContinueStatement(ContinueStatement<'tree>),
15933 DeclarationList(DeclarationList<'tree>),
15934 DeclareDirective(DeclareDirective<'tree>),
15935 DeclareStatement(DeclareStatement<'tree>),
15936 DefaultStatement(DefaultStatement<'tree>),
15937 DisjunctiveNormalFormType(DisjunctiveNormalFormType<'tree>),
15938 DoStatement(DoStatement<'tree>),
15939 DynamicVariableName(DynamicVariableName<'tree>),
15940 EchoStatement(EchoStatement<'tree>),
15941 ElseClause(ElseClause<'tree>),
15942 ElseIfClause(ElseIfClause<'tree>),
15943 EmptyStatement(EmptyStatement<'tree>),
15944 EncapsedString(EncapsedString<'tree>),
15945 EnumCase(EnumCase<'tree>),
15946 EnumDeclaration(EnumDeclaration<'tree>),
15947 EnumDeclarationList(EnumDeclarationList<'tree>),
15948 ErrorSuppressionExpression(ErrorSuppressionExpression<'tree>),
15949 ExitStatement(ExitStatement<'tree>),
15950 ExpressionStatement(ExpressionStatement<'tree>),
15951 FinalModifier(FinalModifier<'tree>),
15952 FinallyClause(FinallyClause<'tree>),
15953 ForStatement(ForStatement<'tree>),
15954 ForeachStatement(ForeachStatement<'tree>),
15955 FormalParameters(FormalParameters<'tree>),
15956 FunctionCallExpression(FunctionCallExpression<'tree>),
15957 FunctionDefinition(FunctionDefinition<'tree>),
15958 FunctionStaticDeclaration(FunctionStaticDeclaration<'tree>),
15959 GlobalDeclaration(GlobalDeclaration<'tree>),
15960 GotoStatement(GotoStatement<'tree>),
15961 Heredoc(Heredoc<'tree>),
15962 HeredocBody(HeredocBody<'tree>),
15963 IfStatement(IfStatement<'tree>),
15964 IncludeExpression(IncludeExpression<'tree>),
15965 IncludeOnceExpression(IncludeOnceExpression<'tree>),
15966 InterfaceDeclaration(InterfaceDeclaration<'tree>),
15967 IntersectionType(IntersectionType<'tree>),
15968 ListLiteral(ListLiteral<'tree>),
15969 MatchBlock(MatchBlock<'tree>),
15970 MatchConditionList(MatchConditionList<'tree>),
15971 MatchConditionalExpression(MatchConditionalExpression<'tree>),
15972 MatchDefaultExpression(MatchDefaultExpression<'tree>),
15973 MatchExpression(MatchExpression<'tree>),
15974 MemberAccessExpression(MemberAccessExpression<'tree>),
15975 MemberCallExpression(MemberCallExpression<'tree>),
15976 MethodDeclaration(MethodDeclaration<'tree>),
15977 Name(Name<'tree>),
15978 NamedLabelStatement(NamedLabelStatement<'tree>),
15979 NamedType(NamedType<'tree>),
15980 NamespaceDefinition(NamespaceDefinition<'tree>),
15981 NamespaceName(NamespaceName<'tree>),
15982 NamespaceUseClause(NamespaceUseClause<'tree>),
15983 NamespaceUseDeclaration(NamespaceUseDeclaration<'tree>),
15984 NamespaceUseGroup(NamespaceUseGroup<'tree>),
15985 Nowdoc(Nowdoc<'tree>),
15986 NowdocBody(NowdocBody<'tree>),
15987 Null(Null<'tree>),
15988 NullsafeMemberAccessExpression(NullsafeMemberAccessExpression<'tree>),
15989 NullsafeMemberCallExpression(NullsafeMemberCallExpression<'tree>),
15990 ObjectCreationExpression(ObjectCreationExpression<'tree>),
15991 OptionalType(OptionalType<'tree>),
15992 Pair(Pair<'tree>),
15993 ParenthesizedExpression(ParenthesizedExpression<'tree>),
15994 PrimitiveType(PrimitiveType<'tree>),
15995 PrintIntrinsic(PrintIntrinsic<'tree>),
15996 Program(Program<'tree>),
15997 PropertyDeclaration(PropertyDeclaration<'tree>),
15998 PropertyElement(PropertyElement<'tree>),
15999 PropertyHook(PropertyHook<'tree>),
16000 PropertyHookList(PropertyHookList<'tree>),
16001 PropertyPromotionParameter(PropertyPromotionParameter<'tree>),
16002 QualifiedName(QualifiedName<'tree>),
16003 ReadonlyModifier(ReadonlyModifier<'tree>),
16004 ReferenceAssignmentExpression(ReferenceAssignmentExpression<'tree>),
16005 ReferenceModifier(ReferenceModifier<'tree>),
16006 RelativeName(RelativeName<'tree>),
16007 RelativeScope(RelativeScope<'tree>),
16008 RequireExpression(RequireExpression<'tree>),
16009 RequireOnceExpression(RequireOnceExpression<'tree>),
16010 ReturnStatement(ReturnStatement<'tree>),
16011 ScopedCallExpression(ScopedCallExpression<'tree>),
16012 ScopedPropertyAccessExpression(ScopedPropertyAccessExpression<'tree>),
16013 SequenceExpression(SequenceExpression<'tree>),
16014 ShellCommandExpression(ShellCommandExpression<'tree>),
16015 SimpleParameter(SimpleParameter<'tree>),
16016 StaticModifier(StaticModifier<'tree>),
16017 StaticVariableDeclaration(StaticVariableDeclaration<'tree>),
16018 String(String<'tree>),
16019 StringContent(StringContent<'tree>),
16020 SubscriptExpression(SubscriptExpression<'tree>),
16021 SwitchBlock(SwitchBlock<'tree>),
16022 SwitchStatement(SwitchStatement<'tree>),
16023 Text(Text<'tree>),
16024 TextInterpolation(TextInterpolation<'tree>),
16025 ThrowExpression(ThrowExpression<'tree>),
16026 TraitDeclaration(TraitDeclaration<'tree>),
16027 TryStatement(TryStatement<'tree>),
16028 TypeList(TypeList<'tree>),
16029 UnaryOpExpression(UnaryOpExpression<'tree>),
16030 UnionType(UnionType<'tree>),
16031 UnsetStatement(UnsetStatement<'tree>),
16032 UpdateExpression(UpdateExpression<'tree>),
16033 UseAsClause(UseAsClause<'tree>),
16034 UseDeclaration(UseDeclaration<'tree>),
16035 UseInsteadOfClause(UseInsteadOfClause<'tree>),
16036 UseList(UseList<'tree>),
16037 VariableName(VariableName<'tree>),
16038 VariadicParameter(VariadicParameter<'tree>),
16039 VariadicPlaceholder(VariadicPlaceholder<'tree>),
16040 VariadicUnpacking(VariadicUnpacking<'tree>),
16041 VisibilityModifier(VisibilityModifier<'tree>),
16042 WhileStatement(WhileStatement<'tree>),
16043 YieldExpression(YieldExpression<'tree>),
16044 BottomType(BottomType<'tree>),
16045 Comment(Comment<'tree>),
16046 EscapeSequence(EscapeSequence<'tree>),
16047 Float(Float<'tree>),
16048 HeredocEnd(HeredocEnd<'tree>),
16049 HeredocStart(HeredocStart<'tree>),
16050 Integer(Integer<'tree>),
16051 NowdocString(NowdocString<'tree>),
16052 Operation(Operation<'tree>),
16053 PhpEndTag(PhpEndTag<'tree>),
16054 PhpTag(PhpTag<'tree>),
16055 VarModifier(VarModifier<'tree>),
16056 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
16057}
16058impl<'tree> AnyNode<'tree> {
16059 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
16060 match node.kind() {
16061 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16062 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16063 })
16064 .map(Self::Expression)
16065 .unwrap_or(Self::Unknown(node)),
16066 "literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16067 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
16068 })
16069 .map(Self::Literal)
16070 .unwrap_or(Self::Unknown(node)),
16071 "primary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16072 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
16073 })
16074 .map(Self::PrimaryExpression)
16075 .unwrap_or(Self::Unknown(node)),
16076 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16077 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16078 })
16079 .map(Self::Statement)
16080 .unwrap_or(Self::Unknown(node)),
16081 "type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16082 <Type as ::treesitter_types::FromNode>::from_node(node, src)
16083 })
16084 .map(Self::Type)
16085 .unwrap_or(Self::Unknown(node)),
16086 "abstract_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16087 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
16088 })
16089 .map(Self::AbstractModifier)
16090 .unwrap_or(Self::Unknown(node)),
16091 "anonymous_class" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16092 <AnonymousClass as ::treesitter_types::FromNode>::from_node(node, src)
16093 })
16094 .map(Self::AnonymousClass)
16095 .unwrap_or(Self::Unknown(node)),
16096 "anonymous_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16097 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)
16098 })
16099 .map(Self::AnonymousFunction)
16100 .unwrap_or(Self::Unknown(node)),
16101 "anonymous_function_use_clause" => {
16102 ::treesitter_types::runtime::maybe_grow_stack(|| {
16103 <AnonymousFunctionUseClause as ::treesitter_types::FromNode>::from_node(
16104 node, src,
16105 )
16106 })
16107 .map(Self::AnonymousFunctionUseClause)
16108 .unwrap_or(Self::Unknown(node))
16109 }
16110 "argument" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16111 <Argument as ::treesitter_types::FromNode>::from_node(node, src)
16112 })
16113 .map(Self::Argument)
16114 .unwrap_or(Self::Unknown(node)),
16115 "arguments" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16116 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
16117 })
16118 .map(Self::Arguments)
16119 .unwrap_or(Self::Unknown(node)),
16120 "array_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16121 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
16122 })
16123 .map(Self::ArrayCreationExpression)
16124 .unwrap_or(Self::Unknown(node)),
16125 "array_element_initializer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16126 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(node, src)
16127 })
16128 .map(Self::ArrayElementInitializer)
16129 .unwrap_or(Self::Unknown(node)),
16130 "arrow_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16131 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
16132 })
16133 .map(Self::ArrowFunction)
16134 .unwrap_or(Self::Unknown(node)),
16135 "assignment_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16136 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
16137 })
16138 .map(Self::AssignmentExpression)
16139 .unwrap_or(Self::Unknown(node)),
16140 "attribute" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16141 <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
16142 })
16143 .map(Self::Attribute)
16144 .unwrap_or(Self::Unknown(node)),
16145 "attribute_group" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16146 <AttributeGroup as ::treesitter_types::FromNode>::from_node(node, src)
16147 })
16148 .map(Self::AttributeGroup)
16149 .unwrap_or(Self::Unknown(node)),
16150 "attribute_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16151 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
16152 })
16153 .map(Self::AttributeList)
16154 .unwrap_or(Self::Unknown(node)),
16155 "augmented_assignment_expression" => {
16156 ::treesitter_types::runtime::maybe_grow_stack(|| {
16157 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
16158 node, src,
16159 )
16160 })
16161 .map(Self::AugmentedAssignmentExpression)
16162 .unwrap_or(Self::Unknown(node))
16163 }
16164 "base_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16165 <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)
16166 })
16167 .map(Self::BaseClause)
16168 .unwrap_or(Self::Unknown(node)),
16169 "binary_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16170 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
16171 })
16172 .map(Self::BinaryExpression)
16173 .unwrap_or(Self::Unknown(node)),
16174 "boolean" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16175 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
16176 })
16177 .map(Self::Boolean)
16178 .unwrap_or(Self::Unknown(node)),
16179 "break_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16180 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
16181 })
16182 .map(Self::BreakStatement)
16183 .unwrap_or(Self::Unknown(node)),
16184 "by_ref" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16185 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
16186 })
16187 .map(Self::ByRef)
16188 .unwrap_or(Self::Unknown(node)),
16189 "case_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16190 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
16191 })
16192 .map(Self::CaseStatement)
16193 .unwrap_or(Self::Unknown(node)),
16194 "cast_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16195 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
16196 })
16197 .map(Self::CastExpression)
16198 .unwrap_or(Self::Unknown(node)),
16199 "cast_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16200 <CastType as ::treesitter_types::FromNode>::from_node(node, src)
16201 })
16202 .map(Self::CastType)
16203 .unwrap_or(Self::Unknown(node)),
16204 "catch_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16205 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
16206 })
16207 .map(Self::CatchClause)
16208 .unwrap_or(Self::Unknown(node)),
16209 "class_constant_access_expression" => {
16210 ::treesitter_types::runtime::maybe_grow_stack(|| {
16211 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
16212 node, src,
16213 )
16214 })
16215 .map(Self::ClassConstantAccessExpression)
16216 .unwrap_or(Self::Unknown(node))
16217 }
16218 "class_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16219 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16220 })
16221 .map(Self::ClassDeclaration)
16222 .unwrap_or(Self::Unknown(node)),
16223 "class_interface_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16224 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)
16225 })
16226 .map(Self::ClassInterfaceClause)
16227 .unwrap_or(Self::Unknown(node)),
16228 "clone_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16229 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)
16230 })
16231 .map(Self::CloneExpression)
16232 .unwrap_or(Self::Unknown(node)),
16233 "colon_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16234 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
16235 })
16236 .map(Self::ColonBlock)
16237 .unwrap_or(Self::Unknown(node)),
16238 "compound_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16239 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
16240 })
16241 .map(Self::CompoundStatement)
16242 .unwrap_or(Self::Unknown(node)),
16243 "conditional_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16244 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
16245 })
16246 .map(Self::ConditionalExpression)
16247 .unwrap_or(Self::Unknown(node)),
16248 "const_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16249 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16250 })
16251 .map(Self::ConstDeclaration)
16252 .unwrap_or(Self::Unknown(node)),
16253 "const_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16254 <ConstElement as ::treesitter_types::FromNode>::from_node(node, src)
16255 })
16256 .map(Self::ConstElement)
16257 .unwrap_or(Self::Unknown(node)),
16258 "continue_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16259 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
16260 })
16261 .map(Self::ContinueStatement)
16262 .unwrap_or(Self::Unknown(node)),
16263 "declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16264 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
16265 })
16266 .map(Self::DeclarationList)
16267 .unwrap_or(Self::Unknown(node)),
16268 "declare_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16269 <DeclareDirective as ::treesitter_types::FromNode>::from_node(node, src)
16270 })
16271 .map(Self::DeclareDirective)
16272 .unwrap_or(Self::Unknown(node)),
16273 "declare_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16274 <DeclareStatement as ::treesitter_types::FromNode>::from_node(node, src)
16275 })
16276 .map(Self::DeclareStatement)
16277 .unwrap_or(Self::Unknown(node)),
16278 "default_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16279 <DefaultStatement as ::treesitter_types::FromNode>::from_node(node, src)
16280 })
16281 .map(Self::DefaultStatement)
16282 .unwrap_or(Self::Unknown(node)),
16283 "disjunctive_normal_form_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16284 <DisjunctiveNormalFormType as ::treesitter_types::FromNode>::from_node(node, src)
16285 })
16286 .map(Self::DisjunctiveNormalFormType)
16287 .unwrap_or(Self::Unknown(node)),
16288 "do_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16289 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
16290 })
16291 .map(Self::DoStatement)
16292 .unwrap_or(Self::Unknown(node)),
16293 "dynamic_variable_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16294 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
16295 })
16296 .map(Self::DynamicVariableName)
16297 .unwrap_or(Self::Unknown(node)),
16298 "echo_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16299 <EchoStatement as ::treesitter_types::FromNode>::from_node(node, src)
16300 })
16301 .map(Self::EchoStatement)
16302 .unwrap_or(Self::Unknown(node)),
16303 "else_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16304 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
16305 })
16306 .map(Self::ElseClause)
16307 .unwrap_or(Self::Unknown(node)),
16308 "else_if_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16309 <ElseIfClause as ::treesitter_types::FromNode>::from_node(node, src)
16310 })
16311 .map(Self::ElseIfClause)
16312 .unwrap_or(Self::Unknown(node)),
16313 "empty_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16314 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
16315 })
16316 .map(Self::EmptyStatement)
16317 .unwrap_or(Self::Unknown(node)),
16318 "encapsed_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16319 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
16320 })
16321 .map(Self::EncapsedString)
16322 .unwrap_or(Self::Unknown(node)),
16323 "enum_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16324 <EnumCase as ::treesitter_types::FromNode>::from_node(node, src)
16325 })
16326 .map(Self::EnumCase)
16327 .unwrap_or(Self::Unknown(node)),
16328 "enum_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16329 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16330 })
16331 .map(Self::EnumDeclaration)
16332 .unwrap_or(Self::Unknown(node)),
16333 "enum_declaration_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16334 <EnumDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
16335 })
16336 .map(Self::EnumDeclarationList)
16337 .unwrap_or(Self::Unknown(node)),
16338 "error_suppression_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16339 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(node, src)
16340 })
16341 .map(Self::ErrorSuppressionExpression)
16342 .unwrap_or(Self::Unknown(node)),
16343 "exit_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16344 <ExitStatement as ::treesitter_types::FromNode>::from_node(node, src)
16345 })
16346 .map(Self::ExitStatement)
16347 .unwrap_or(Self::Unknown(node)),
16348 "expression_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16349 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
16350 })
16351 .map(Self::ExpressionStatement)
16352 .unwrap_or(Self::Unknown(node)),
16353 "final_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16354 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
16355 })
16356 .map(Self::FinalModifier)
16357 .unwrap_or(Self::Unknown(node)),
16358 "finally_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16359 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
16360 })
16361 .map(Self::FinallyClause)
16362 .unwrap_or(Self::Unknown(node)),
16363 "for_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16364 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
16365 })
16366 .map(Self::ForStatement)
16367 .unwrap_or(Self::Unknown(node)),
16368 "foreach_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16369 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
16370 })
16371 .map(Self::ForeachStatement)
16372 .unwrap_or(Self::Unknown(node)),
16373 "formal_parameters" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16374 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
16375 })
16376 .map(Self::FormalParameters)
16377 .unwrap_or(Self::Unknown(node)),
16378 "function_call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16379 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
16380 })
16381 .map(Self::FunctionCallExpression)
16382 .unwrap_or(Self::Unknown(node)),
16383 "function_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16384 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
16385 })
16386 .map(Self::FunctionDefinition)
16387 .unwrap_or(Self::Unknown(node)),
16388 "function_static_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16389 <FunctionStaticDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16390 })
16391 .map(Self::FunctionStaticDeclaration)
16392 .unwrap_or(Self::Unknown(node)),
16393 "global_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16394 <GlobalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16395 })
16396 .map(Self::GlobalDeclaration)
16397 .unwrap_or(Self::Unknown(node)),
16398 "goto_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16399 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
16400 })
16401 .map(Self::GotoStatement)
16402 .unwrap_or(Self::Unknown(node)),
16403 "heredoc" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16404 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
16405 })
16406 .map(Self::Heredoc)
16407 .unwrap_or(Self::Unknown(node)),
16408 "heredoc_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16409 <HeredocBody as ::treesitter_types::FromNode>::from_node(node, src)
16410 })
16411 .map(Self::HeredocBody)
16412 .unwrap_or(Self::Unknown(node)),
16413 "if_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16414 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
16415 })
16416 .map(Self::IfStatement)
16417 .unwrap_or(Self::Unknown(node)),
16418 "include_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16419 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)
16420 })
16421 .map(Self::IncludeExpression)
16422 .unwrap_or(Self::Unknown(node)),
16423 "include_once_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16424 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
16425 })
16426 .map(Self::IncludeOnceExpression)
16427 .unwrap_or(Self::Unknown(node)),
16428 "interface_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16429 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16430 })
16431 .map(Self::InterfaceDeclaration)
16432 .unwrap_or(Self::Unknown(node)),
16433 "intersection_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16434 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
16435 })
16436 .map(Self::IntersectionType)
16437 .unwrap_or(Self::Unknown(node)),
16438 "list_literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16439 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
16440 })
16441 .map(Self::ListLiteral)
16442 .unwrap_or(Self::Unknown(node)),
16443 "match_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16444 <MatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
16445 })
16446 .map(Self::MatchBlock)
16447 .unwrap_or(Self::Unknown(node)),
16448 "match_condition_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16449 <MatchConditionList as ::treesitter_types::FromNode>::from_node(node, src)
16450 })
16451 .map(Self::MatchConditionList)
16452 .unwrap_or(Self::Unknown(node)),
16453 "match_conditional_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16454 <MatchConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
16455 })
16456 .map(Self::MatchConditionalExpression)
16457 .unwrap_or(Self::Unknown(node)),
16458 "match_default_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16459 <MatchDefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
16460 })
16461 .map(Self::MatchDefaultExpression)
16462 .unwrap_or(Self::Unknown(node)),
16463 "match_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16464 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
16465 })
16466 .map(Self::MatchExpression)
16467 .unwrap_or(Self::Unknown(node)),
16468 "member_access_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16469 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
16470 })
16471 .map(Self::MemberAccessExpression)
16472 .unwrap_or(Self::Unknown(node)),
16473 "member_call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16474 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
16475 })
16476 .map(Self::MemberCallExpression)
16477 .unwrap_or(Self::Unknown(node)),
16478 "method_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16479 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16480 })
16481 .map(Self::MethodDeclaration)
16482 .unwrap_or(Self::Unknown(node)),
16483 "name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16484 <Name as ::treesitter_types::FromNode>::from_node(node, src)
16485 })
16486 .map(Self::Name)
16487 .unwrap_or(Self::Unknown(node)),
16488 "named_label_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16489 <NamedLabelStatement as ::treesitter_types::FromNode>::from_node(node, src)
16490 })
16491 .map(Self::NamedLabelStatement)
16492 .unwrap_or(Self::Unknown(node)),
16493 "named_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16494 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
16495 })
16496 .map(Self::NamedType)
16497 .unwrap_or(Self::Unknown(node)),
16498 "namespace_definition" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16499 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
16500 })
16501 .map(Self::NamespaceDefinition)
16502 .unwrap_or(Self::Unknown(node)),
16503 "namespace_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16504 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
16505 })
16506 .map(Self::NamespaceName)
16507 .unwrap_or(Self::Unknown(node)),
16508 "namespace_use_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16509 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(node, src)
16510 })
16511 .map(Self::NamespaceUseClause)
16512 .unwrap_or(Self::Unknown(node)),
16513 "namespace_use_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16514 <NamespaceUseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16515 })
16516 .map(Self::NamespaceUseDeclaration)
16517 .unwrap_or(Self::Unknown(node)),
16518 "namespace_use_group" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16519 <NamespaceUseGroup as ::treesitter_types::FromNode>::from_node(node, src)
16520 })
16521 .map(Self::NamespaceUseGroup)
16522 .unwrap_or(Self::Unknown(node)),
16523 "nowdoc" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16524 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
16525 })
16526 .map(Self::Nowdoc)
16527 .unwrap_or(Self::Unknown(node)),
16528 "nowdoc_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16529 <NowdocBody as ::treesitter_types::FromNode>::from_node(node, src)
16530 })
16531 .map(Self::NowdocBody)
16532 .unwrap_or(Self::Unknown(node)),
16533 "null" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16534 <Null as ::treesitter_types::FromNode>::from_node(node, src)
16535 })
16536 .map(Self::Null)
16537 .unwrap_or(Self::Unknown(node)),
16538 "nullsafe_member_access_expression" => {
16539 ::treesitter_types::runtime::maybe_grow_stack(|| {
16540 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
16541 node, src,
16542 )
16543 })
16544 .map(Self::NullsafeMemberAccessExpression)
16545 .unwrap_or(Self::Unknown(node))
16546 }
16547 "nullsafe_member_call_expression" => {
16548 ::treesitter_types::runtime::maybe_grow_stack(|| {
16549 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
16550 node, src,
16551 )
16552 })
16553 .map(Self::NullsafeMemberCallExpression)
16554 .unwrap_or(Self::Unknown(node))
16555 }
16556 "object_creation_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16557 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
16558 })
16559 .map(Self::ObjectCreationExpression)
16560 .unwrap_or(Self::Unknown(node)),
16561 "optional_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16562 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
16563 })
16564 .map(Self::OptionalType)
16565 .unwrap_or(Self::Unknown(node)),
16566 "pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16567 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
16568 })
16569 .map(Self::Pair)
16570 .unwrap_or(Self::Unknown(node)),
16571 "parenthesized_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16572 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
16573 })
16574 .map(Self::ParenthesizedExpression)
16575 .unwrap_or(Self::Unknown(node)),
16576 "primitive_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16577 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
16578 })
16579 .map(Self::PrimitiveType)
16580 .unwrap_or(Self::Unknown(node)),
16581 "print_intrinsic" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16582 <PrintIntrinsic as ::treesitter_types::FromNode>::from_node(node, src)
16583 })
16584 .map(Self::PrintIntrinsic)
16585 .unwrap_or(Self::Unknown(node)),
16586 "program" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16587 <Program as ::treesitter_types::FromNode>::from_node(node, src)
16588 })
16589 .map(Self::Program)
16590 .unwrap_or(Self::Unknown(node)),
16591 "property_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16592 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16593 })
16594 .map(Self::PropertyDeclaration)
16595 .unwrap_or(Self::Unknown(node)),
16596 "property_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16597 <PropertyElement as ::treesitter_types::FromNode>::from_node(node, src)
16598 })
16599 .map(Self::PropertyElement)
16600 .unwrap_or(Self::Unknown(node)),
16601 "property_hook" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16602 <PropertyHook as ::treesitter_types::FromNode>::from_node(node, src)
16603 })
16604 .map(Self::PropertyHook)
16605 .unwrap_or(Self::Unknown(node)),
16606 "property_hook_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16607 <PropertyHookList as ::treesitter_types::FromNode>::from_node(node, src)
16608 })
16609 .map(Self::PropertyHookList)
16610 .unwrap_or(Self::Unknown(node)),
16611 "property_promotion_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16612 <PropertyPromotionParameter as ::treesitter_types::FromNode>::from_node(node, src)
16613 })
16614 .map(Self::PropertyPromotionParameter)
16615 .unwrap_or(Self::Unknown(node)),
16616 "qualified_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16617 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
16618 })
16619 .map(Self::QualifiedName)
16620 .unwrap_or(Self::Unknown(node)),
16621 "readonly_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16622 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
16623 })
16624 .map(Self::ReadonlyModifier)
16625 .unwrap_or(Self::Unknown(node)),
16626 "reference_assignment_expression" => {
16627 ::treesitter_types::runtime::maybe_grow_stack(|| {
16628 <ReferenceAssignmentExpression as ::treesitter_types::FromNode>::from_node(
16629 node, src,
16630 )
16631 })
16632 .map(Self::ReferenceAssignmentExpression)
16633 .unwrap_or(Self::Unknown(node))
16634 }
16635 "reference_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16636 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(node, src)
16637 })
16638 .map(Self::ReferenceModifier)
16639 .unwrap_or(Self::Unknown(node)),
16640 "relative_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16641 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
16642 })
16643 .map(Self::RelativeName)
16644 .unwrap_or(Self::Unknown(node)),
16645 "relative_scope" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16646 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)
16647 })
16648 .map(Self::RelativeScope)
16649 .unwrap_or(Self::Unknown(node)),
16650 "require_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16651 <RequireExpression as ::treesitter_types::FromNode>::from_node(node, src)
16652 })
16653 .map(Self::RequireExpression)
16654 .unwrap_or(Self::Unknown(node)),
16655 "require_once_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16656 <RequireOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
16657 })
16658 .map(Self::RequireOnceExpression)
16659 .unwrap_or(Self::Unknown(node)),
16660 "return_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16661 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
16662 })
16663 .map(Self::ReturnStatement)
16664 .unwrap_or(Self::Unknown(node)),
16665 "scoped_call_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16666 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
16667 })
16668 .map(Self::ScopedCallExpression)
16669 .unwrap_or(Self::Unknown(node)),
16670 "scoped_property_access_expression" => {
16671 ::treesitter_types::runtime::maybe_grow_stack(|| {
16672 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
16673 node, src,
16674 )
16675 })
16676 .map(Self::ScopedPropertyAccessExpression)
16677 .unwrap_or(Self::Unknown(node))
16678 }
16679 "sequence_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16680 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
16681 })
16682 .map(Self::SequenceExpression)
16683 .unwrap_or(Self::Unknown(node)),
16684 "shell_command_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16685 <ShellCommandExpression as ::treesitter_types::FromNode>::from_node(node, src)
16686 })
16687 .map(Self::ShellCommandExpression)
16688 .unwrap_or(Self::Unknown(node)),
16689 "simple_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16690 <SimpleParameter as ::treesitter_types::FromNode>::from_node(node, src)
16691 })
16692 .map(Self::SimpleParameter)
16693 .unwrap_or(Self::Unknown(node)),
16694 "static_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16695 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
16696 })
16697 .map(Self::StaticModifier)
16698 .unwrap_or(Self::Unknown(node)),
16699 "static_variable_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16700 <StaticVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16701 })
16702 .map(Self::StaticVariableDeclaration)
16703 .unwrap_or(Self::Unknown(node)),
16704 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16705 <String as ::treesitter_types::FromNode>::from_node(node, src)
16706 })
16707 .map(Self::String)
16708 .unwrap_or(Self::Unknown(node)),
16709 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16710 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
16711 })
16712 .map(Self::StringContent)
16713 .unwrap_or(Self::Unknown(node)),
16714 "subscript_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16715 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
16716 })
16717 .map(Self::SubscriptExpression)
16718 .unwrap_or(Self::Unknown(node)),
16719 "switch_block" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16720 <SwitchBlock as ::treesitter_types::FromNode>::from_node(node, src)
16721 })
16722 .map(Self::SwitchBlock)
16723 .unwrap_or(Self::Unknown(node)),
16724 "switch_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16725 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
16726 })
16727 .map(Self::SwitchStatement)
16728 .unwrap_or(Self::Unknown(node)),
16729 "text" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16730 <Text as ::treesitter_types::FromNode>::from_node(node, src)
16731 })
16732 .map(Self::Text)
16733 .unwrap_or(Self::Unknown(node)),
16734 "text_interpolation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16735 <TextInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
16736 })
16737 .map(Self::TextInterpolation)
16738 .unwrap_or(Self::Unknown(node)),
16739 "throw_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16740 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
16741 })
16742 .map(Self::ThrowExpression)
16743 .unwrap_or(Self::Unknown(node)),
16744 "trait_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16745 <TraitDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16746 })
16747 .map(Self::TraitDeclaration)
16748 .unwrap_or(Self::Unknown(node)),
16749 "try_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16750 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
16751 })
16752 .map(Self::TryStatement)
16753 .unwrap_or(Self::Unknown(node)),
16754 "type_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16755 <TypeList as ::treesitter_types::FromNode>::from_node(node, src)
16756 })
16757 .map(Self::TypeList)
16758 .unwrap_or(Self::Unknown(node)),
16759 "unary_op_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16760 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)
16761 })
16762 .map(Self::UnaryOpExpression)
16763 .unwrap_or(Self::Unknown(node)),
16764 "union_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16765 <UnionType as ::treesitter_types::FromNode>::from_node(node, src)
16766 })
16767 .map(Self::UnionType)
16768 .unwrap_or(Self::Unknown(node)),
16769 "unset_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16770 <UnsetStatement as ::treesitter_types::FromNode>::from_node(node, src)
16771 })
16772 .map(Self::UnsetStatement)
16773 .unwrap_or(Self::Unknown(node)),
16774 "update_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16775 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
16776 })
16777 .map(Self::UpdateExpression)
16778 .unwrap_or(Self::Unknown(node)),
16779 "use_as_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16780 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
16781 })
16782 .map(Self::UseAsClause)
16783 .unwrap_or(Self::Unknown(node)),
16784 "use_declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16785 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
16786 })
16787 .map(Self::UseDeclaration)
16788 .unwrap_or(Self::Unknown(node)),
16789 "use_instead_of_clause" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16790 <UseInsteadOfClause as ::treesitter_types::FromNode>::from_node(node, src)
16791 })
16792 .map(Self::UseInsteadOfClause)
16793 .unwrap_or(Self::Unknown(node)),
16794 "use_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16795 <UseList as ::treesitter_types::FromNode>::from_node(node, src)
16796 })
16797 .map(Self::UseList)
16798 .unwrap_or(Self::Unknown(node)),
16799 "variable_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16800 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
16801 })
16802 .map(Self::VariableName)
16803 .unwrap_or(Self::Unknown(node)),
16804 "variadic_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16805 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
16806 })
16807 .map(Self::VariadicParameter)
16808 .unwrap_or(Self::Unknown(node)),
16809 "variadic_placeholder" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16810 <VariadicPlaceholder as ::treesitter_types::FromNode>::from_node(node, src)
16811 })
16812 .map(Self::VariadicPlaceholder)
16813 .unwrap_or(Self::Unknown(node)),
16814 "variadic_unpacking" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16815 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)
16816 })
16817 .map(Self::VariadicUnpacking)
16818 .unwrap_or(Self::Unknown(node)),
16819 "visibility_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16820 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
16821 })
16822 .map(Self::VisibilityModifier)
16823 .unwrap_or(Self::Unknown(node)),
16824 "while_statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16825 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
16826 })
16827 .map(Self::WhileStatement)
16828 .unwrap_or(Self::Unknown(node)),
16829 "yield_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16830 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
16831 })
16832 .map(Self::YieldExpression)
16833 .unwrap_or(Self::Unknown(node)),
16834 "bottom_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16835 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
16836 })
16837 .map(Self::BottomType)
16838 .unwrap_or(Self::Unknown(node)),
16839 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16840 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
16841 })
16842 .map(Self::Comment)
16843 .unwrap_or(Self::Unknown(node)),
16844 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16845 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
16846 })
16847 .map(Self::EscapeSequence)
16848 .unwrap_or(Self::Unknown(node)),
16849 "float" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16850 <Float as ::treesitter_types::FromNode>::from_node(node, src)
16851 })
16852 .map(Self::Float)
16853 .unwrap_or(Self::Unknown(node)),
16854 "heredoc_end" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16855 <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)
16856 })
16857 .map(Self::HeredocEnd)
16858 .unwrap_or(Self::Unknown(node)),
16859 "heredoc_start" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16860 <HeredocStart as ::treesitter_types::FromNode>::from_node(node, src)
16861 })
16862 .map(Self::HeredocStart)
16863 .unwrap_or(Self::Unknown(node)),
16864 "integer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16865 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
16866 })
16867 .map(Self::Integer)
16868 .unwrap_or(Self::Unknown(node)),
16869 "nowdoc_string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16870 <NowdocString as ::treesitter_types::FromNode>::from_node(node, src)
16871 })
16872 .map(Self::NowdocString)
16873 .unwrap_or(Self::Unknown(node)),
16874 "operation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16875 <Operation as ::treesitter_types::FromNode>::from_node(node, src)
16876 })
16877 .map(Self::Operation)
16878 .unwrap_or(Self::Unknown(node)),
16879 "php_end_tag" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16880 <PhpEndTag as ::treesitter_types::FromNode>::from_node(node, src)
16881 })
16882 .map(Self::PhpEndTag)
16883 .unwrap_or(Self::Unknown(node)),
16884 "php_tag" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16885 <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)
16886 })
16887 .map(Self::PhpTag)
16888 .unwrap_or(Self::Unknown(node)),
16889 "var_modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16890 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
16891 })
16892 .map(Self::VarModifier)
16893 .unwrap_or(Self::Unknown(node)),
16894 _ => Self::Unknown(node),
16895 }
16896 }
16897}
16898impl ::treesitter_types::Spanned for AnyNode<'_> {
16899 fn span(&self) -> ::treesitter_types::Span {
16900 match self {
16901 Self::Expression(inner) => inner.span(),
16902 Self::Literal(inner) => inner.span(),
16903 Self::PrimaryExpression(inner) => inner.span(),
16904 Self::Statement(inner) => inner.span(),
16905 Self::Type(inner) => inner.span(),
16906 Self::AbstractModifier(inner) => inner.span(),
16907 Self::AnonymousClass(inner) => inner.span(),
16908 Self::AnonymousFunction(inner) => inner.span(),
16909 Self::AnonymousFunctionUseClause(inner) => inner.span(),
16910 Self::Argument(inner) => inner.span(),
16911 Self::Arguments(inner) => inner.span(),
16912 Self::ArrayCreationExpression(inner) => inner.span(),
16913 Self::ArrayElementInitializer(inner) => inner.span(),
16914 Self::ArrowFunction(inner) => inner.span(),
16915 Self::AssignmentExpression(inner) => inner.span(),
16916 Self::Attribute(inner) => inner.span(),
16917 Self::AttributeGroup(inner) => inner.span(),
16918 Self::AttributeList(inner) => inner.span(),
16919 Self::AugmentedAssignmentExpression(inner) => inner.span(),
16920 Self::BaseClause(inner) => inner.span(),
16921 Self::BinaryExpression(inner) => inner.span(),
16922 Self::Boolean(inner) => inner.span(),
16923 Self::BreakStatement(inner) => inner.span(),
16924 Self::ByRef(inner) => inner.span(),
16925 Self::CaseStatement(inner) => inner.span(),
16926 Self::CastExpression(inner) => inner.span(),
16927 Self::CastType(inner) => inner.span(),
16928 Self::CatchClause(inner) => inner.span(),
16929 Self::ClassConstantAccessExpression(inner) => inner.span(),
16930 Self::ClassDeclaration(inner) => inner.span(),
16931 Self::ClassInterfaceClause(inner) => inner.span(),
16932 Self::CloneExpression(inner) => inner.span(),
16933 Self::ColonBlock(inner) => inner.span(),
16934 Self::CompoundStatement(inner) => inner.span(),
16935 Self::ConditionalExpression(inner) => inner.span(),
16936 Self::ConstDeclaration(inner) => inner.span(),
16937 Self::ConstElement(inner) => inner.span(),
16938 Self::ContinueStatement(inner) => inner.span(),
16939 Self::DeclarationList(inner) => inner.span(),
16940 Self::DeclareDirective(inner) => inner.span(),
16941 Self::DeclareStatement(inner) => inner.span(),
16942 Self::DefaultStatement(inner) => inner.span(),
16943 Self::DisjunctiveNormalFormType(inner) => inner.span(),
16944 Self::DoStatement(inner) => inner.span(),
16945 Self::DynamicVariableName(inner) => inner.span(),
16946 Self::EchoStatement(inner) => inner.span(),
16947 Self::ElseClause(inner) => inner.span(),
16948 Self::ElseIfClause(inner) => inner.span(),
16949 Self::EmptyStatement(inner) => inner.span(),
16950 Self::EncapsedString(inner) => inner.span(),
16951 Self::EnumCase(inner) => inner.span(),
16952 Self::EnumDeclaration(inner) => inner.span(),
16953 Self::EnumDeclarationList(inner) => inner.span(),
16954 Self::ErrorSuppressionExpression(inner) => inner.span(),
16955 Self::ExitStatement(inner) => inner.span(),
16956 Self::ExpressionStatement(inner) => inner.span(),
16957 Self::FinalModifier(inner) => inner.span(),
16958 Self::FinallyClause(inner) => inner.span(),
16959 Self::ForStatement(inner) => inner.span(),
16960 Self::ForeachStatement(inner) => inner.span(),
16961 Self::FormalParameters(inner) => inner.span(),
16962 Self::FunctionCallExpression(inner) => inner.span(),
16963 Self::FunctionDefinition(inner) => inner.span(),
16964 Self::FunctionStaticDeclaration(inner) => inner.span(),
16965 Self::GlobalDeclaration(inner) => inner.span(),
16966 Self::GotoStatement(inner) => inner.span(),
16967 Self::Heredoc(inner) => inner.span(),
16968 Self::HeredocBody(inner) => inner.span(),
16969 Self::IfStatement(inner) => inner.span(),
16970 Self::IncludeExpression(inner) => inner.span(),
16971 Self::IncludeOnceExpression(inner) => inner.span(),
16972 Self::InterfaceDeclaration(inner) => inner.span(),
16973 Self::IntersectionType(inner) => inner.span(),
16974 Self::ListLiteral(inner) => inner.span(),
16975 Self::MatchBlock(inner) => inner.span(),
16976 Self::MatchConditionList(inner) => inner.span(),
16977 Self::MatchConditionalExpression(inner) => inner.span(),
16978 Self::MatchDefaultExpression(inner) => inner.span(),
16979 Self::MatchExpression(inner) => inner.span(),
16980 Self::MemberAccessExpression(inner) => inner.span(),
16981 Self::MemberCallExpression(inner) => inner.span(),
16982 Self::MethodDeclaration(inner) => inner.span(),
16983 Self::Name(inner) => inner.span(),
16984 Self::NamedLabelStatement(inner) => inner.span(),
16985 Self::NamedType(inner) => inner.span(),
16986 Self::NamespaceDefinition(inner) => inner.span(),
16987 Self::NamespaceName(inner) => inner.span(),
16988 Self::NamespaceUseClause(inner) => inner.span(),
16989 Self::NamespaceUseDeclaration(inner) => inner.span(),
16990 Self::NamespaceUseGroup(inner) => inner.span(),
16991 Self::Nowdoc(inner) => inner.span(),
16992 Self::NowdocBody(inner) => inner.span(),
16993 Self::Null(inner) => inner.span(),
16994 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
16995 Self::NullsafeMemberCallExpression(inner) => inner.span(),
16996 Self::ObjectCreationExpression(inner) => inner.span(),
16997 Self::OptionalType(inner) => inner.span(),
16998 Self::Pair(inner) => inner.span(),
16999 Self::ParenthesizedExpression(inner) => inner.span(),
17000 Self::PrimitiveType(inner) => inner.span(),
17001 Self::PrintIntrinsic(inner) => inner.span(),
17002 Self::Program(inner) => inner.span(),
17003 Self::PropertyDeclaration(inner) => inner.span(),
17004 Self::PropertyElement(inner) => inner.span(),
17005 Self::PropertyHook(inner) => inner.span(),
17006 Self::PropertyHookList(inner) => inner.span(),
17007 Self::PropertyPromotionParameter(inner) => inner.span(),
17008 Self::QualifiedName(inner) => inner.span(),
17009 Self::ReadonlyModifier(inner) => inner.span(),
17010 Self::ReferenceAssignmentExpression(inner) => inner.span(),
17011 Self::ReferenceModifier(inner) => inner.span(),
17012 Self::RelativeName(inner) => inner.span(),
17013 Self::RelativeScope(inner) => inner.span(),
17014 Self::RequireExpression(inner) => inner.span(),
17015 Self::RequireOnceExpression(inner) => inner.span(),
17016 Self::ReturnStatement(inner) => inner.span(),
17017 Self::ScopedCallExpression(inner) => inner.span(),
17018 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
17019 Self::SequenceExpression(inner) => inner.span(),
17020 Self::ShellCommandExpression(inner) => inner.span(),
17021 Self::SimpleParameter(inner) => inner.span(),
17022 Self::StaticModifier(inner) => inner.span(),
17023 Self::StaticVariableDeclaration(inner) => inner.span(),
17024 Self::String(inner) => inner.span(),
17025 Self::StringContent(inner) => inner.span(),
17026 Self::SubscriptExpression(inner) => inner.span(),
17027 Self::SwitchBlock(inner) => inner.span(),
17028 Self::SwitchStatement(inner) => inner.span(),
17029 Self::Text(inner) => inner.span(),
17030 Self::TextInterpolation(inner) => inner.span(),
17031 Self::ThrowExpression(inner) => inner.span(),
17032 Self::TraitDeclaration(inner) => inner.span(),
17033 Self::TryStatement(inner) => inner.span(),
17034 Self::TypeList(inner) => inner.span(),
17035 Self::UnaryOpExpression(inner) => inner.span(),
17036 Self::UnionType(inner) => inner.span(),
17037 Self::UnsetStatement(inner) => inner.span(),
17038 Self::UpdateExpression(inner) => inner.span(),
17039 Self::UseAsClause(inner) => inner.span(),
17040 Self::UseDeclaration(inner) => inner.span(),
17041 Self::UseInsteadOfClause(inner) => inner.span(),
17042 Self::UseList(inner) => inner.span(),
17043 Self::VariableName(inner) => inner.span(),
17044 Self::VariadicParameter(inner) => inner.span(),
17045 Self::VariadicPlaceholder(inner) => inner.span(),
17046 Self::VariadicUnpacking(inner) => inner.span(),
17047 Self::VisibilityModifier(inner) => inner.span(),
17048 Self::WhileStatement(inner) => inner.span(),
17049 Self::YieldExpression(inner) => inner.span(),
17050 Self::BottomType(inner) => inner.span(),
17051 Self::Comment(inner) => inner.span(),
17052 Self::EscapeSequence(inner) => inner.span(),
17053 Self::Float(inner) => inner.span(),
17054 Self::HeredocEnd(inner) => inner.span(),
17055 Self::HeredocStart(inner) => inner.span(),
17056 Self::Integer(inner) => inner.span(),
17057 Self::NowdocString(inner) => inner.span(),
17058 Self::Operation(inner) => inner.span(),
17059 Self::PhpEndTag(inner) => inner.span(),
17060 Self::PhpTag(inner) => inner.span(),
17061 Self::VarModifier(inner) => inner.span(),
17062 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
17063 }
17064 }
17065}