1#[derive(Debug, Clone)]
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: ::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 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
29 ))),
30 "augmented_assignment_expression" => {
31 Ok(Self::AugmentedAssignmentExpression(::std::boxed::Box::new(
32 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
33 node, src,
34 )?,
35 )))
36 }
37 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
38 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
39 ))),
40 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
41 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
42 ))),
43 "clone_expression" => Ok(Self::CloneExpression(::std::boxed::Box::new(
44 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
45 ))),
46 "conditional_expression" => Ok(Self::ConditionalExpression(::std::boxed::Box::new(
47 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
48 ))),
49 "error_suppression_expression" => {
50 Ok(Self::ErrorSuppressionExpression(::std::boxed::Box::new(
51 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(
52 node, src,
53 )?,
54 )))
55 }
56 "include_expression" => Ok(Self::IncludeExpression(::std::boxed::Box::new(
57 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
58 ))),
59 "include_once_expression" => Ok(Self::IncludeOnceExpression(::std::boxed::Box::new(
60 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
61 ))),
62 "match_expression" => Ok(Self::MatchExpression(::std::boxed::Box::new(
63 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
64 ))),
65 "reference_assignment_expression" => {
66 Ok(Self::ReferenceAssignmentExpression(::std::boxed::Box::new(
67 <ReferenceAssignmentExpression as ::treesitter_types::FromNode>::from_node(
68 node, src,
69 )?,
70 )))
71 }
72 "require_expression" => Ok(Self::RequireExpression(::std::boxed::Box::new(
73 <RequireExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
74 ))),
75 "require_once_expression" => Ok(Self::RequireOnceExpression(::std::boxed::Box::new(
76 <RequireOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
77 ))),
78 "unary_op_expression" => Ok(Self::UnaryOpExpression(::std::boxed::Box::new(
79 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
80 ))),
81 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
82 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
83 ))),
84 _other => {
85 if let Ok(v) =
86 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
87 {
88 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
89 } else {
90 Err(::treesitter_types::ParseError::unexpected_kind(
91 _other, node,
92 ))
93 }
94 }
95 }
96 }
97}
98impl ::treesitter_types::Spanned for Expression<'_> {
99 fn span(&self) -> ::treesitter_types::Span {
100 match self {
101 Self::AssignmentExpression(inner) => inner.span(),
102 Self::AugmentedAssignmentExpression(inner) => inner.span(),
103 Self::BinaryExpression(inner) => inner.span(),
104 Self::CastExpression(inner) => inner.span(),
105 Self::CloneExpression(inner) => inner.span(),
106 Self::ConditionalExpression(inner) => inner.span(),
107 Self::ErrorSuppressionExpression(inner) => inner.span(),
108 Self::IncludeExpression(inner) => inner.span(),
109 Self::IncludeOnceExpression(inner) => inner.span(),
110 Self::MatchExpression(inner) => inner.span(),
111 Self::PrimaryExpression(inner) => inner.span(),
112 Self::ReferenceAssignmentExpression(inner) => inner.span(),
113 Self::RequireExpression(inner) => inner.span(),
114 Self::RequireOnceExpression(inner) => inner.span(),
115 Self::UnaryOpExpression(inner) => inner.span(),
116 Self::YieldExpression(inner) => inner.span(),
117 }
118 }
119}
120#[derive(Debug, Clone)]
121pub enum Literal<'tree> {
122 Boolean(::std::boxed::Box<Boolean<'tree>>),
123 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
124 Float(::std::boxed::Box<Float<'tree>>),
125 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
126 Integer(::std::boxed::Box<Integer<'tree>>),
127 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
128 Null(::std::boxed::Box<Null<'tree>>),
129 String(::std::boxed::Box<String<'tree>>),
130}
131impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
132 #[allow(clippy::collapsible_else_if)]
133 fn from_node(
134 node: ::tree_sitter::Node<'tree>,
135 src: &'tree [u8],
136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
137 match node.kind() {
138 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
139 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
140 ))),
141 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
142 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
143 ))),
144 "float" => Ok(Self::Float(::std::boxed::Box::new(
145 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
146 ))),
147 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
148 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
149 ))),
150 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
151 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
152 ))),
153 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
154 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
155 ))),
156 "null" => Ok(Self::Null(::std::boxed::Box::new(
157 <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
158 ))),
159 "string" => Ok(Self::String(::std::boxed::Box::new(
160 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
161 ))),
162 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
163 }
164 }
165}
166impl ::treesitter_types::Spanned for Literal<'_> {
167 fn span(&self) -> ::treesitter_types::Span {
168 match self {
169 Self::Boolean(inner) => inner.span(),
170 Self::EncapsedString(inner) => inner.span(),
171 Self::Float(inner) => inner.span(),
172 Self::Heredoc(inner) => inner.span(),
173 Self::Integer(inner) => inner.span(),
174 Self::Nowdoc(inner) => inner.span(),
175 Self::Null(inner) => inner.span(),
176 Self::String(inner) => inner.span(),
177 }
178 }
179}
180#[derive(Debug, Clone)]
181pub enum PrimaryExpression<'tree> {
182 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
183 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
184 ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
185 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
186 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
187 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
188 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
189 Literal(::std::boxed::Box<Literal<'tree>>),
190 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
191 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
192 Name(::std::boxed::Box<Name<'tree>>),
193 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
194 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
195 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
196 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
197 PrintIntrinsic(::std::boxed::Box<PrintIntrinsic<'tree>>),
198 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
199 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
200 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
201 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
202 ShellCommandExpression(::std::boxed::Box<ShellCommandExpression<'tree>>),
203 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
204 ThrowExpression(::std::boxed::Box<ThrowExpression<'tree>>),
205 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
206 VariableName(::std::boxed::Box<VariableName<'tree>>),
207}
208impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
209 #[allow(clippy::collapsible_else_if)]
210 fn from_node(
211 node: ::tree_sitter::Node<'tree>,
212 src: &'tree [u8],
213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
214 match node.kind() {
215 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
216 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
217 ))),
218 "array_creation_expression" => {
219 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
220 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
221 node, src,
222 )?,
223 )))
224 }
225 "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
226 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
227 ))),
228 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
229 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
230 ))),
231 "class_constant_access_expression" => {
232 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
233 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
234 node, src,
235 )?,
236 )))
237 }
238 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
239 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
240 ))),
241 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
242 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
243 ))),
244 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
245 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
246 ))),
247 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
248 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
249 ))),
250 "name" => Ok(Self::Name(::std::boxed::Box::new(
251 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
252 ))),
253 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
254 ::std::boxed::Box::new(
255 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
256 node, src,
257 )?,
258 ),
259 )),
260 "nullsafe_member_call_expression" => {
261 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
262 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
263 node, src,
264 )?,
265 )))
266 }
267 "object_creation_expression" => {
268 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
269 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
270 node, src,
271 )?,
272 )))
273 }
274 "parenthesized_expression" => {
275 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
276 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
277 node, src,
278 )?,
279 )))
280 }
281 "print_intrinsic" => Ok(Self::PrintIntrinsic(::std::boxed::Box::new(
282 <PrintIntrinsic as ::treesitter_types::FromNode>::from_node(node, src)?,
283 ))),
284 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
285 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
286 ))),
287 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
288 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
289 ))),
290 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
291 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
292 ))),
293 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
294 ::std::boxed::Box::new(
295 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
296 node, src,
297 )?,
298 ),
299 )),
300 "shell_command_expression" => Ok(Self::ShellCommandExpression(::std::boxed::Box::new(
301 <ShellCommandExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
302 ))),
303 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
304 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
305 ))),
306 "throw_expression" => Ok(Self::ThrowExpression(::std::boxed::Box::new(
307 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
308 ))),
309 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
310 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
311 ))),
312 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
313 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
314 ))),
315 _other => {
316 if let Ok(v) = <Literal as ::treesitter_types::FromNode>::from_node(node, src) {
317 Ok(Self::Literal(::std::boxed::Box::new(v)))
318 } else {
319 Err(::treesitter_types::ParseError::unexpected_kind(
320 _other, node,
321 ))
322 }
323 }
324 }
325 }
326}
327impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
328 fn span(&self) -> ::treesitter_types::Span {
329 match self {
330 Self::AnonymousFunction(inner) => inner.span(),
331 Self::ArrayCreationExpression(inner) => inner.span(),
332 Self::ArrowFunction(inner) => inner.span(),
333 Self::CastExpression(inner) => inner.span(),
334 Self::ClassConstantAccessExpression(inner) => inner.span(),
335 Self::DynamicVariableName(inner) => inner.span(),
336 Self::FunctionCallExpression(inner) => inner.span(),
337 Self::Literal(inner) => inner.span(),
338 Self::MemberAccessExpression(inner) => inner.span(),
339 Self::MemberCallExpression(inner) => inner.span(),
340 Self::Name(inner) => inner.span(),
341 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
342 Self::NullsafeMemberCallExpression(inner) => inner.span(),
343 Self::ObjectCreationExpression(inner) => inner.span(),
344 Self::ParenthesizedExpression(inner) => inner.span(),
345 Self::PrintIntrinsic(inner) => inner.span(),
346 Self::QualifiedName(inner) => inner.span(),
347 Self::RelativeName(inner) => inner.span(),
348 Self::ScopedCallExpression(inner) => inner.span(),
349 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
350 Self::ShellCommandExpression(inner) => inner.span(),
351 Self::SubscriptExpression(inner) => inner.span(),
352 Self::ThrowExpression(inner) => inner.span(),
353 Self::UpdateExpression(inner) => inner.span(),
354 Self::VariableName(inner) => inner.span(),
355 }
356 }
357}
358#[derive(Debug, Clone)]
359pub enum Statement<'tree> {
360 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
361 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
362 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
363 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
364 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
365 DeclareStatement(::std::boxed::Box<DeclareStatement<'tree>>),
366 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
367 EchoStatement(::std::boxed::Box<EchoStatement<'tree>>),
368 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
369 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
370 ExitStatement(::std::boxed::Box<ExitStatement<'tree>>),
371 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
372 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
373 ForeachStatement(::std::boxed::Box<ForeachStatement<'tree>>),
374 FunctionDefinition(::std::boxed::Box<FunctionDefinition<'tree>>),
375 FunctionStaticDeclaration(::std::boxed::Box<FunctionStaticDeclaration<'tree>>),
376 GlobalDeclaration(::std::boxed::Box<GlobalDeclaration<'tree>>),
377 GotoStatement(::std::boxed::Box<GotoStatement<'tree>>),
378 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
379 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
380 NamedLabelStatement(::std::boxed::Box<NamedLabelStatement<'tree>>),
381 NamespaceDefinition(::std::boxed::Box<NamespaceDefinition<'tree>>),
382 NamespaceUseDeclaration(::std::boxed::Box<NamespaceUseDeclaration<'tree>>),
383 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
384 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
385 TraitDeclaration(::std::boxed::Box<TraitDeclaration<'tree>>),
386 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
387 UnsetStatement(::std::boxed::Box<UnsetStatement<'tree>>),
388 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
389}
390impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
391 #[allow(clippy::collapsible_else_if)]
392 fn from_node(
393 node: ::tree_sitter::Node<'tree>,
394 src: &'tree [u8],
395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
396 match node.kind() {
397 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
398 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
399 ))),
400 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
401 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
402 ))),
403 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
404 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
405 ))),
406 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
407 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
408 ))),
409 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
410 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
411 ))),
412 "declare_statement" => Ok(Self::DeclareStatement(::std::boxed::Box::new(
413 <DeclareStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
414 ))),
415 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
416 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
417 ))),
418 "echo_statement" => Ok(Self::EchoStatement(::std::boxed::Box::new(
419 <EchoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
420 ))),
421 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
422 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
423 ))),
424 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
425 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
426 ))),
427 "exit_statement" => Ok(Self::ExitStatement(::std::boxed::Box::new(
428 <ExitStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
429 ))),
430 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
431 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
432 ))),
433 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
434 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
435 ))),
436 "foreach_statement" => Ok(Self::ForeachStatement(::std::boxed::Box::new(
437 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
438 ))),
439 "function_definition" => Ok(Self::FunctionDefinition(::std::boxed::Box::new(
440 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
441 ))),
442 "function_static_declaration" => {
443 Ok(Self::FunctionStaticDeclaration(::std::boxed::Box::new(
444 <FunctionStaticDeclaration as ::treesitter_types::FromNode>::from_node(
445 node, src,
446 )?,
447 )))
448 }
449 "global_declaration" => Ok(Self::GlobalDeclaration(::std::boxed::Box::new(
450 <GlobalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
451 ))),
452 "goto_statement" => Ok(Self::GotoStatement(::std::boxed::Box::new(
453 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
454 ))),
455 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
456 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
457 ))),
458 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
459 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
460 ))),
461 "named_label_statement" => Ok(Self::NamedLabelStatement(::std::boxed::Box::new(
462 <NamedLabelStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
463 ))),
464 "namespace_definition" => Ok(Self::NamespaceDefinition(::std::boxed::Box::new(
465 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
466 ))),
467 "namespace_use_declaration" => {
468 Ok(Self::NamespaceUseDeclaration(::std::boxed::Box::new(
469 <NamespaceUseDeclaration as ::treesitter_types::FromNode>::from_node(
470 node, src,
471 )?,
472 )))
473 }
474 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
475 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
476 ))),
477 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
478 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
479 ))),
480 "trait_declaration" => Ok(Self::TraitDeclaration(::std::boxed::Box::new(
481 <TraitDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
482 ))),
483 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
484 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
485 ))),
486 "unset_statement" => Ok(Self::UnsetStatement(::std::boxed::Box::new(
487 <UnsetStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
488 ))),
489 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
490 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
491 ))),
492 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
493 }
494 }
495}
496impl ::treesitter_types::Spanned for Statement<'_> {
497 fn span(&self) -> ::treesitter_types::Span {
498 match self {
499 Self::BreakStatement(inner) => inner.span(),
500 Self::ClassDeclaration(inner) => inner.span(),
501 Self::CompoundStatement(inner) => inner.span(),
502 Self::ConstDeclaration(inner) => inner.span(),
503 Self::ContinueStatement(inner) => inner.span(),
504 Self::DeclareStatement(inner) => inner.span(),
505 Self::DoStatement(inner) => inner.span(),
506 Self::EchoStatement(inner) => inner.span(),
507 Self::EmptyStatement(inner) => inner.span(),
508 Self::EnumDeclaration(inner) => inner.span(),
509 Self::ExitStatement(inner) => inner.span(),
510 Self::ExpressionStatement(inner) => inner.span(),
511 Self::ForStatement(inner) => inner.span(),
512 Self::ForeachStatement(inner) => inner.span(),
513 Self::FunctionDefinition(inner) => inner.span(),
514 Self::FunctionStaticDeclaration(inner) => inner.span(),
515 Self::GlobalDeclaration(inner) => inner.span(),
516 Self::GotoStatement(inner) => inner.span(),
517 Self::IfStatement(inner) => inner.span(),
518 Self::InterfaceDeclaration(inner) => inner.span(),
519 Self::NamedLabelStatement(inner) => inner.span(),
520 Self::NamespaceDefinition(inner) => inner.span(),
521 Self::NamespaceUseDeclaration(inner) => inner.span(),
522 Self::ReturnStatement(inner) => inner.span(),
523 Self::SwitchStatement(inner) => inner.span(),
524 Self::TraitDeclaration(inner) => inner.span(),
525 Self::TryStatement(inner) => inner.span(),
526 Self::UnsetStatement(inner) => inner.span(),
527 Self::WhileStatement(inner) => inner.span(),
528 }
529 }
530}
531#[derive(Debug, Clone)]
532pub enum Type<'tree> {
533 DisjunctiveNormalFormType(::std::boxed::Box<DisjunctiveNormalFormType<'tree>>),
534 IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
535 NamedType(::std::boxed::Box<NamedType<'tree>>),
536 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
537 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
538 UnionType(::std::boxed::Box<UnionType<'tree>>),
539}
540impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
541 #[allow(clippy::collapsible_else_if)]
542 fn from_node(
543 node: ::tree_sitter::Node<'tree>,
544 src: &'tree [u8],
545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
546 match node.kind() {
547 "disjunctive_normal_form_type" => {
548 Ok(Self::DisjunctiveNormalFormType(::std::boxed::Box::new(
549 <DisjunctiveNormalFormType as ::treesitter_types::FromNode>::from_node(
550 node, src,
551 )?,
552 )))
553 }
554 "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
555 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)?,
556 ))),
557 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
558 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)?,
559 ))),
560 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
561 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
562 ))),
563 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
564 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
565 ))),
566 "union_type" => Ok(Self::UnionType(::std::boxed::Box::new(
567 <UnionType as ::treesitter_types::FromNode>::from_node(node, src)?,
568 ))),
569 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
570 }
571 }
572}
573impl ::treesitter_types::Spanned for Type<'_> {
574 fn span(&self) -> ::treesitter_types::Span {
575 match self {
576 Self::DisjunctiveNormalFormType(inner) => inner.span(),
577 Self::IntersectionType(inner) => inner.span(),
578 Self::NamedType(inner) => inner.span(),
579 Self::OptionalType(inner) => inner.span(),
580 Self::PrimitiveType(inner) => inner.span(),
581 Self::UnionType(inner) => inner.span(),
582 }
583 }
584}
585#[derive(Debug, Clone)]
586pub struct AbstractModifier<'tree> {
587 pub span: ::treesitter_types::Span,
588 text: &'tree str,
589}
590impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractModifier<'tree> {
591 fn from_node(
592 node: ::tree_sitter::Node<'tree>,
593 src: &'tree [u8],
594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
595 debug_assert_eq!(node.kind(), "abstract_modifier");
596 Ok(Self {
597 span: ::treesitter_types::Span::from(node),
598 text: node.utf8_text(src)?,
599 })
600 }
601}
602impl<'tree> ::treesitter_types::LeafNode<'tree> for AbstractModifier<'tree> {
603 fn text(&self) -> &'tree str {
604 self.text
605 }
606}
607impl ::treesitter_types::Spanned for AbstractModifier<'_> {
608 fn span(&self) -> ::treesitter_types::Span {
609 self.span
610 }
611}
612#[derive(Debug, Clone)]
613pub struct AnonymousClass<'tree> {
614 pub span: ::treesitter_types::Span,
615 pub attributes: ::core::option::Option<AttributeList<'tree>>,
616 pub body: DeclarationList<'tree>,
617 pub children: ::std::vec::Vec<AnonymousClassChildren<'tree>>,
618}
619impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousClass<'tree> {
620 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
621 fn from_node(
622 node: ::tree_sitter::Node<'tree>,
623 src: &'tree [u8],
624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
625 debug_assert_eq!(node.kind(), "anonymous_class");
626 Ok(Self {
627 span: ::treesitter_types::Span::from(node),
628 attributes: match node.child_by_field_name("attributes") {
629 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
630 child, src,
631 )?),
632 None => None,
633 },
634 body: {
635 let child = node
636 .child_by_field_name("body")
637 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
638 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
639 },
640 children: {
641 #[allow(clippy::suspicious_else_formatting)]
642 let non_field_children = {
643 let mut cursor = node.walk();
644 let mut result = ::std::vec::Vec::new();
645 if cursor.goto_first_child() {
646 loop {
647 if cursor.field_name().is_none()
648 && cursor.node().is_named()
649 && !cursor.node().is_extra()
650 {
651 result.push(cursor.node());
652 }
653 if !cursor.goto_next_sibling() {
654 break;
655 }
656 }
657 }
658 result
659 };
660 let mut items = ::std::vec::Vec::new();
661 for child in non_field_children {
662 items.push(
663 <AnonymousClassChildren as ::treesitter_types::FromNode>::from_node(
664 child, src,
665 )?,
666 );
667 }
668 items
669 },
670 })
671 }
672}
673impl ::treesitter_types::Spanned for AnonymousClass<'_> {
674 fn span(&self) -> ::treesitter_types::Span {
675 self.span
676 }
677}
678#[derive(Debug, Clone)]
679pub struct AnonymousFunction<'tree> {
680 pub span: ::treesitter_types::Span,
681 pub attributes: ::core::option::Option<AttributeList<'tree>>,
682 pub body: CompoundStatement<'tree>,
683 pub parameters: FormalParameters<'tree>,
684 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
685 pub return_type: ::core::option::Option<AnonymousFunctionReturnType<'tree>>,
686 pub static_modifier: ::core::option::Option<StaticModifier<'tree>>,
687 pub children: ::core::option::Option<AnonymousFunctionUseClause<'tree>>,
688}
689impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunction<'tree> {
690 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
691 fn from_node(
692 node: ::tree_sitter::Node<'tree>,
693 src: &'tree [u8],
694 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
695 debug_assert_eq!(node.kind(), "anonymous_function");
696 Ok(Self {
697 span: ::treesitter_types::Span::from(node),
698 attributes: match node.child_by_field_name("attributes") {
699 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
700 child, src,
701 )?),
702 None => None,
703 },
704 body: {
705 let child = node
706 .child_by_field_name("body")
707 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
708 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
709 },
710 parameters: {
711 let child = node.child_by_field_name("parameters").ok_or_else(|| {
712 ::treesitter_types::ParseError::missing_field("parameters", node)
713 })?;
714 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
715 },
716 reference_modifier: match node.child_by_field_name("reference_modifier") {
717 Some(child) => Some(
718 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
719 ),
720 None => None,
721 },
722 return_type: match node.child_by_field_name("return_type") {
723 Some(child) => Some(
724 <AnonymousFunctionReturnType as ::treesitter_types::FromNode>::from_node(
725 child, src,
726 )?,
727 ),
728 None => None,
729 },
730 static_modifier: match node.child_by_field_name("static_modifier") {
731 Some(child) => Some(<StaticModifier as ::treesitter_types::FromNode>::from_node(
732 child, src,
733 )?),
734 None => None,
735 },
736 children: {
737 #[allow(clippy::suspicious_else_formatting)]
738 let non_field_children = {
739 let mut cursor = node.walk();
740 let mut result = ::std::vec::Vec::new();
741 if cursor.goto_first_child() {
742 loop {
743 if cursor.field_name().is_none()
744 && cursor.node().is_named()
745 && !cursor.node().is_extra()
746 {
747 result.push(cursor.node());
748 }
749 if !cursor.goto_next_sibling() {
750 break;
751 }
752 }
753 }
754 result
755 };
756 match non_field_children.first() {
757 Some(&child) => Some(
758 <AnonymousFunctionUseClause as ::treesitter_types::FromNode>::from_node(
759 child, src,
760 )?,
761 ),
762 None => None,
763 }
764 },
765 })
766 }
767}
768impl ::treesitter_types::Spanned for AnonymousFunction<'_> {
769 fn span(&self) -> ::treesitter_types::Span {
770 self.span
771 }
772}
773#[derive(Debug, Clone)]
774pub struct AnonymousFunctionUseClause<'tree> {
775 pub span: ::treesitter_types::Span,
776 pub children: ::std::vec::Vec<AnonymousFunctionUseClauseChildren<'tree>>,
777}
778impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionUseClause<'tree> {
779 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
780 fn from_node(
781 node: ::tree_sitter::Node<'tree>,
782 src: &'tree [u8],
783 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
784 debug_assert_eq!(node.kind(), "anonymous_function_use_clause");
785 Ok(Self {
786 span: ::treesitter_types::Span::from(node),
787 children: {
788 #[allow(clippy::suspicious_else_formatting)]
789 let non_field_children = {
790 let mut cursor = node.walk();
791 let mut result = ::std::vec::Vec::new();
792 if cursor.goto_first_child() {
793 loop {
794 if cursor.field_name().is_none()
795 && cursor.node().is_named()
796 && !cursor.node().is_extra()
797 {
798 result.push(cursor.node());
799 }
800 if !cursor.goto_next_sibling() {
801 break;
802 }
803 }
804 }
805 result
806 };
807 let mut items = ::std::vec::Vec::new();
808 for child in non_field_children {
809 items
810 .push(
811 <AnonymousFunctionUseClauseChildren as ::treesitter_types::FromNode>::from_node(
812 child,
813 src,
814 )?,
815 );
816 }
817 items
818 },
819 })
820 }
821}
822impl ::treesitter_types::Spanned for AnonymousFunctionUseClause<'_> {
823 fn span(&self) -> ::treesitter_types::Span {
824 self.span
825 }
826}
827#[derive(Debug, Clone)]
828pub struct Argument<'tree> {
829 pub span: ::treesitter_types::Span,
830 pub name: ::core::option::Option<Name<'tree>>,
831 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
832 pub children: ArgumentChildren<'tree>,
833}
834impl<'tree> ::treesitter_types::FromNode<'tree> for Argument<'tree> {
835 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
836 fn from_node(
837 node: ::tree_sitter::Node<'tree>,
838 src: &'tree [u8],
839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
840 debug_assert_eq!(node.kind(), "argument");
841 Ok(Self {
842 span: ::treesitter_types::Span::from(node),
843 name: match node.child_by_field_name("name") {
844 Some(child) => Some(<Name as ::treesitter_types::FromNode>::from_node(
845 child, src,
846 )?),
847 None => None,
848 },
849 reference_modifier: match node.child_by_field_name("reference_modifier") {
850 Some(child) => Some(
851 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
852 ),
853 None => None,
854 },
855 children: {
856 #[allow(clippy::suspicious_else_formatting)]
857 let non_field_children = {
858 let mut cursor = node.walk();
859 let mut result = ::std::vec::Vec::new();
860 if cursor.goto_first_child() {
861 loop {
862 if cursor.field_name().is_none()
863 && cursor.node().is_named()
864 && !cursor.node().is_extra()
865 {
866 result.push(cursor.node());
867 }
868 if !cursor.goto_next_sibling() {
869 break;
870 }
871 }
872 }
873 result
874 };
875 let child = if let Some(&c) = non_field_children.first() {
876 c
877 } else {
878 let mut fallback_cursor = node.walk();
879 let mut fallback_child = None;
880 if fallback_cursor.goto_first_child() {
881 loop {
882 if fallback_cursor.field_name().is_none()
883 && !fallback_cursor.node().is_extra()
884 {
885 let candidate = fallback_cursor.node();
886 #[allow(clippy::needless_question_mark)]
887 if (|| -> ::core::result::Result<
888 _,
889 ::treesitter_types::ParseError,
890 > {
891 let child = candidate;
892 Ok(
893 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
894 child,
895 src,
896 )?,
897 )
898 })()
899 .is_ok()
900 {
901 fallback_child = Some(candidate);
902 break;
903 }
904 }
905 if !fallback_cursor.goto_next_sibling() {
906 break;
907 }
908 }
909 }
910 if fallback_child.is_none() {
911 let mut cursor2 = node.walk();
912 if cursor2.goto_first_child() {
913 loop {
914 if cursor2.node().is_named() && !cursor2.node().is_extra() {
915 let candidate = cursor2.node();
916 #[allow(clippy::needless_question_mark)]
917 if (|| -> ::core::result::Result<
918 _,
919 ::treesitter_types::ParseError,
920 > {
921 let child = candidate;
922 Ok(
923 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(
924 child,
925 src,
926 )?,
927 )
928 })()
929 .is_ok()
930 {
931 fallback_child = Some(candidate);
932 break;
933 }
934 }
935 if !cursor2.goto_next_sibling() {
936 break;
937 }
938 }
939 }
940 }
941 fallback_child.ok_or_else(|| {
942 ::treesitter_types::ParseError::missing_field("children", node)
943 })?
944 };
945 <ArgumentChildren as ::treesitter_types::FromNode>::from_node(child, src)?
946 },
947 })
948 }
949}
950impl ::treesitter_types::Spanned for Argument<'_> {
951 fn span(&self) -> ::treesitter_types::Span {
952 self.span
953 }
954}
955#[derive(Debug, Clone)]
956pub struct Arguments<'tree> {
957 pub span: ::treesitter_types::Span,
958 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
959}
960impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
961 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
962 fn from_node(
963 node: ::tree_sitter::Node<'tree>,
964 src: &'tree [u8],
965 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
966 debug_assert_eq!(node.kind(), "arguments");
967 Ok(Self {
968 span: ::treesitter_types::Span::from(node),
969 children: {
970 #[allow(clippy::suspicious_else_formatting)]
971 let non_field_children = {
972 let mut cursor = node.walk();
973 let mut result = ::std::vec::Vec::new();
974 if cursor.goto_first_child() {
975 loop {
976 if cursor.field_name().is_none()
977 && cursor.node().is_named()
978 && !cursor.node().is_extra()
979 {
980 result.push(cursor.node());
981 }
982 if !cursor.goto_next_sibling() {
983 break;
984 }
985 }
986 }
987 result
988 };
989 let mut items = ::std::vec::Vec::new();
990 for child in non_field_children {
991 items.push(
992 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
993 );
994 }
995 items
996 },
997 })
998 }
999}
1000impl ::treesitter_types::Spanned for Arguments<'_> {
1001 fn span(&self) -> ::treesitter_types::Span {
1002 self.span
1003 }
1004}
1005#[derive(Debug, Clone)]
1006pub struct ArrayCreationExpression<'tree> {
1007 pub span: ::treesitter_types::Span,
1008 pub children: ::std::vec::Vec<ArrayElementInitializer<'tree>>,
1009}
1010impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayCreationExpression<'tree> {
1011 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1012 fn from_node(
1013 node: ::tree_sitter::Node<'tree>,
1014 src: &'tree [u8],
1015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1016 debug_assert_eq!(node.kind(), "array_creation_expression");
1017 Ok(Self {
1018 span: ::treesitter_types::Span::from(node),
1019 children: {
1020 #[allow(clippy::suspicious_else_formatting)]
1021 let non_field_children = {
1022 let mut cursor = node.walk();
1023 let mut result = ::std::vec::Vec::new();
1024 if cursor.goto_first_child() {
1025 loop {
1026 if cursor.field_name().is_none()
1027 && cursor.node().is_named()
1028 && !cursor.node().is_extra()
1029 {
1030 result.push(cursor.node());
1031 }
1032 if !cursor.goto_next_sibling() {
1033 break;
1034 }
1035 }
1036 }
1037 result
1038 };
1039 let mut items = ::std::vec::Vec::new();
1040 for child in non_field_children {
1041 items.push(
1042 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(
1043 child, src,
1044 )?,
1045 );
1046 }
1047 items
1048 },
1049 })
1050 }
1051}
1052impl ::treesitter_types::Spanned for ArrayCreationExpression<'_> {
1053 fn span(&self) -> ::treesitter_types::Span {
1054 self.span
1055 }
1056}
1057#[derive(Debug, Clone)]
1058pub struct ArrayElementInitializer<'tree> {
1059 pub span: ::treesitter_types::Span,
1060 pub children: ::std::vec::Vec<ArrayElementInitializerChildren<'tree>>,
1061}
1062impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayElementInitializer<'tree> {
1063 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1064 fn from_node(
1065 node: ::tree_sitter::Node<'tree>,
1066 src: &'tree [u8],
1067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1068 debug_assert_eq!(node.kind(), "array_element_initializer");
1069 Ok(Self {
1070 span: ::treesitter_types::Span::from(node),
1071 children: {
1072 #[allow(clippy::suspicious_else_formatting)]
1073 let non_field_children = {
1074 let mut cursor = node.walk();
1075 let mut result = ::std::vec::Vec::new();
1076 if cursor.goto_first_child() {
1077 loop {
1078 if cursor.field_name().is_none()
1079 && cursor.node().is_named()
1080 && !cursor.node().is_extra()
1081 {
1082 result.push(cursor.node());
1083 }
1084 if !cursor.goto_next_sibling() {
1085 break;
1086 }
1087 }
1088 }
1089 result
1090 };
1091 let mut items = ::std::vec::Vec::new();
1092 for child in non_field_children {
1093 items
1094 .push(
1095 <ArrayElementInitializerChildren as ::treesitter_types::FromNode>::from_node(
1096 child,
1097 src,
1098 )?,
1099 );
1100 }
1101 items
1102 },
1103 })
1104 }
1105}
1106impl ::treesitter_types::Spanned for ArrayElementInitializer<'_> {
1107 fn span(&self) -> ::treesitter_types::Span {
1108 self.span
1109 }
1110}
1111#[derive(Debug, Clone)]
1112pub struct ArrowFunction<'tree> {
1113 pub span: ::treesitter_types::Span,
1114 pub attributes: ::core::option::Option<AttributeList<'tree>>,
1115 pub body: Expression<'tree>,
1116 pub parameters: FormalParameters<'tree>,
1117 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
1118 pub return_type: ::core::option::Option<ArrowFunctionReturnType<'tree>>,
1119 pub static_modifier: ::core::option::Option<StaticModifier<'tree>>,
1120}
1121impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
1122 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1123 fn from_node(
1124 node: ::tree_sitter::Node<'tree>,
1125 src: &'tree [u8],
1126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1127 debug_assert_eq!(node.kind(), "arrow_function");
1128 Ok(Self {
1129 span: ::treesitter_types::Span::from(node),
1130 attributes: match node.child_by_field_name("attributes") {
1131 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
1132 child, src,
1133 )?),
1134 None => None,
1135 },
1136 body: {
1137 let child = node
1138 .child_by_field_name("body")
1139 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1140 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1141 },
1142 parameters: {
1143 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1144 ::treesitter_types::ParseError::missing_field("parameters", node)
1145 })?;
1146 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
1147 },
1148 reference_modifier: match node.child_by_field_name("reference_modifier") {
1149 Some(child) => Some(
1150 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
1151 ),
1152 None => None,
1153 },
1154 return_type: match node.child_by_field_name("return_type") {
1155 Some(child) => Some(
1156 <ArrowFunctionReturnType as ::treesitter_types::FromNode>::from_node(
1157 child, src,
1158 )?,
1159 ),
1160 None => None,
1161 },
1162 static_modifier: match node.child_by_field_name("static_modifier") {
1163 Some(child) => Some(<StaticModifier as ::treesitter_types::FromNode>::from_node(
1164 child, src,
1165 )?),
1166 None => None,
1167 },
1168 })
1169 }
1170}
1171impl ::treesitter_types::Spanned for ArrowFunction<'_> {
1172 fn span(&self) -> ::treesitter_types::Span {
1173 self.span
1174 }
1175}
1176#[derive(Debug, Clone)]
1177pub struct AssignmentExpression<'tree> {
1178 pub span: ::treesitter_types::Span,
1179 pub left: AssignmentExpressionLeft<'tree>,
1180 pub right: Expression<'tree>,
1181}
1182impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1183 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1184 fn from_node(
1185 node: ::tree_sitter::Node<'tree>,
1186 src: &'tree [u8],
1187 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1188 debug_assert_eq!(node.kind(), "assignment_expression");
1189 Ok(Self {
1190 span: ::treesitter_types::Span::from(node),
1191 left: {
1192 let child = node
1193 .child_by_field_name("left")
1194 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1195 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1196 },
1197 right: {
1198 let child = node
1199 .child_by_field_name("right")
1200 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1201 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1202 },
1203 })
1204 }
1205}
1206impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1207 fn span(&self) -> ::treesitter_types::Span {
1208 self.span
1209 }
1210}
1211#[derive(Debug, Clone)]
1212pub struct Attribute<'tree> {
1213 pub span: ::treesitter_types::Span,
1214 pub parameters: ::core::option::Option<Arguments<'tree>>,
1215 pub children: AttributeChildren<'tree>,
1216}
1217impl<'tree> ::treesitter_types::FromNode<'tree> for Attribute<'tree> {
1218 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1219 fn from_node(
1220 node: ::tree_sitter::Node<'tree>,
1221 src: &'tree [u8],
1222 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1223 debug_assert_eq!(node.kind(), "attribute");
1224 Ok(Self {
1225 span: ::treesitter_types::Span::from(node),
1226 parameters: match node.child_by_field_name("parameters") {
1227 Some(child) => Some(<Arguments as ::treesitter_types::FromNode>::from_node(
1228 child, src,
1229 )?),
1230 None => None,
1231 },
1232 children: {
1233 #[allow(clippy::suspicious_else_formatting)]
1234 let non_field_children = {
1235 let mut cursor = node.walk();
1236 let mut result = ::std::vec::Vec::new();
1237 if cursor.goto_first_child() {
1238 loop {
1239 if cursor.field_name().is_none()
1240 && cursor.node().is_named()
1241 && !cursor.node().is_extra()
1242 {
1243 result.push(cursor.node());
1244 }
1245 if !cursor.goto_next_sibling() {
1246 break;
1247 }
1248 }
1249 }
1250 result
1251 };
1252 let child = if let Some(&c) = non_field_children.first() {
1253 c
1254 } else {
1255 let mut fallback_cursor = node.walk();
1256 let mut fallback_child = None;
1257 if fallback_cursor.goto_first_child() {
1258 loop {
1259 if fallback_cursor.field_name().is_none()
1260 && !fallback_cursor.node().is_extra()
1261 {
1262 let candidate = fallback_cursor.node();
1263 #[allow(clippy::needless_question_mark)]
1264 if (|| -> ::core::result::Result<
1265 _,
1266 ::treesitter_types::ParseError,
1267 > {
1268 let child = candidate;
1269 Ok(
1270 <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1271 child,
1272 src,
1273 )?,
1274 )
1275 })()
1276 .is_ok()
1277 {
1278 fallback_child = Some(candidate);
1279 break;
1280 }
1281 }
1282 if !fallback_cursor.goto_next_sibling() {
1283 break;
1284 }
1285 }
1286 }
1287 if fallback_child.is_none() {
1288 let mut cursor2 = node.walk();
1289 if cursor2.goto_first_child() {
1290 loop {
1291 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1292 let candidate = cursor2.node();
1293 #[allow(clippy::needless_question_mark)]
1294 if (|| -> ::core::result::Result<
1295 _,
1296 ::treesitter_types::ParseError,
1297 > {
1298 let child = candidate;
1299 Ok(
1300 <AttributeChildren as ::treesitter_types::FromNode>::from_node(
1301 child,
1302 src,
1303 )?,
1304 )
1305 })()
1306 .is_ok()
1307 {
1308 fallback_child = Some(candidate);
1309 break;
1310 }
1311 }
1312 if !cursor2.goto_next_sibling() {
1313 break;
1314 }
1315 }
1316 }
1317 }
1318 fallback_child.ok_or_else(|| {
1319 ::treesitter_types::ParseError::missing_field("children", node)
1320 })?
1321 };
1322 <AttributeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1323 },
1324 })
1325 }
1326}
1327impl ::treesitter_types::Spanned for Attribute<'_> {
1328 fn span(&self) -> ::treesitter_types::Span {
1329 self.span
1330 }
1331}
1332#[derive(Debug, Clone)]
1333pub struct AttributeGroup<'tree> {
1334 pub span: ::treesitter_types::Span,
1335 pub children: ::std::vec::Vec<Attribute<'tree>>,
1336}
1337impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeGroup<'tree> {
1338 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1339 fn from_node(
1340 node: ::tree_sitter::Node<'tree>,
1341 src: &'tree [u8],
1342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1343 debug_assert_eq!(node.kind(), "attribute_group");
1344 Ok(Self {
1345 span: ::treesitter_types::Span::from(node),
1346 children: {
1347 #[allow(clippy::suspicious_else_formatting)]
1348 let non_field_children = {
1349 let mut cursor = node.walk();
1350 let mut result = ::std::vec::Vec::new();
1351 if cursor.goto_first_child() {
1352 loop {
1353 if cursor.field_name().is_none()
1354 && cursor.node().is_named()
1355 && !cursor.node().is_extra()
1356 {
1357 result.push(cursor.node());
1358 }
1359 if !cursor.goto_next_sibling() {
1360 break;
1361 }
1362 }
1363 }
1364 result
1365 };
1366 let mut items = ::std::vec::Vec::new();
1367 for child in non_field_children {
1368 items.push(<Attribute as ::treesitter_types::FromNode>::from_node(
1369 child, src,
1370 )?);
1371 }
1372 items
1373 },
1374 })
1375 }
1376}
1377impl ::treesitter_types::Spanned for AttributeGroup<'_> {
1378 fn span(&self) -> ::treesitter_types::Span {
1379 self.span
1380 }
1381}
1382#[derive(Debug, Clone)]
1383pub struct AttributeList<'tree> {
1384 pub span: ::treesitter_types::Span,
1385 pub children: ::std::vec::Vec<AttributeGroup<'tree>>,
1386}
1387impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeList<'tree> {
1388 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1389 fn from_node(
1390 node: ::tree_sitter::Node<'tree>,
1391 src: &'tree [u8],
1392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1393 debug_assert_eq!(node.kind(), "attribute_list");
1394 Ok(Self {
1395 span: ::treesitter_types::Span::from(node),
1396 children: {
1397 #[allow(clippy::suspicious_else_formatting)]
1398 let non_field_children = {
1399 let mut cursor = node.walk();
1400 let mut result = ::std::vec::Vec::new();
1401 if cursor.goto_first_child() {
1402 loop {
1403 if cursor.field_name().is_none()
1404 && cursor.node().is_named()
1405 && !cursor.node().is_extra()
1406 {
1407 result.push(cursor.node());
1408 }
1409 if !cursor.goto_next_sibling() {
1410 break;
1411 }
1412 }
1413 }
1414 result
1415 };
1416 let mut items = ::std::vec::Vec::new();
1417 for child in non_field_children {
1418 items.push(<AttributeGroup as ::treesitter_types::FromNode>::from_node(
1419 child, src,
1420 )?);
1421 }
1422 items
1423 },
1424 })
1425 }
1426}
1427impl ::treesitter_types::Spanned for AttributeList<'_> {
1428 fn span(&self) -> ::treesitter_types::Span {
1429 self.span
1430 }
1431}
1432#[derive(Debug, Clone)]
1433pub struct AugmentedAssignmentExpression<'tree> {
1434 pub span: ::treesitter_types::Span,
1435 pub left: AugmentedAssignmentExpressionLeft<'tree>,
1436 pub operator: AugmentedAssignmentExpressionOperator,
1437 pub right: Expression<'tree>,
1438}
1439impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
1440 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1441 fn from_node(
1442 node: ::tree_sitter::Node<'tree>,
1443 src: &'tree [u8],
1444 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1445 debug_assert_eq!(node.kind(), "augmented_assignment_expression");
1446 Ok(Self {
1447 span: ::treesitter_types::Span::from(node),
1448 left: {
1449 let child = node
1450 .child_by_field_name("left")
1451 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1452 <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1453 child, src,
1454 )?
1455 },
1456 operator: {
1457 let child = node.child_by_field_name("operator").ok_or_else(|| {
1458 ::treesitter_types::ParseError::missing_field("operator", node)
1459 })?;
1460 <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1461 child, src,
1462 )?
1463 },
1464 right: {
1465 let child = node
1466 .child_by_field_name("right")
1467 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1468 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1469 },
1470 })
1471 }
1472}
1473impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
1474 fn span(&self) -> ::treesitter_types::Span {
1475 self.span
1476 }
1477}
1478#[derive(Debug, Clone)]
1479pub struct BaseClause<'tree> {
1480 pub span: ::treesitter_types::Span,
1481 pub children: ::std::vec::Vec<BaseClauseChildren<'tree>>,
1482}
1483impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClause<'tree> {
1484 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1485 fn from_node(
1486 node: ::tree_sitter::Node<'tree>,
1487 src: &'tree [u8],
1488 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1489 debug_assert_eq!(node.kind(), "base_clause");
1490 Ok(Self {
1491 span: ::treesitter_types::Span::from(node),
1492 children: {
1493 #[allow(clippy::suspicious_else_formatting)]
1494 let non_field_children = {
1495 let mut cursor = node.walk();
1496 let mut result = ::std::vec::Vec::new();
1497 if cursor.goto_first_child() {
1498 loop {
1499 if cursor.field_name().is_none()
1500 && cursor.node().is_named()
1501 && !cursor.node().is_extra()
1502 {
1503 result.push(cursor.node());
1504 }
1505 if !cursor.goto_next_sibling() {
1506 break;
1507 }
1508 }
1509 }
1510 result
1511 };
1512 let mut items = ::std::vec::Vec::new();
1513 for child in non_field_children {
1514 items.push(
1515 <BaseClauseChildren as ::treesitter_types::FromNode>::from_node(
1516 child, src,
1517 )?,
1518 );
1519 }
1520 items
1521 },
1522 })
1523 }
1524}
1525impl ::treesitter_types::Spanned for BaseClause<'_> {
1526 fn span(&self) -> ::treesitter_types::Span {
1527 self.span
1528 }
1529}
1530#[derive(Debug, Clone)]
1531pub struct BinaryExpression<'tree> {
1532 pub span: ::treesitter_types::Span,
1533 pub left: Expression<'tree>,
1534 pub operator: BinaryExpressionOperator,
1535 pub right: BinaryExpressionRight<'tree>,
1536}
1537impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1538 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1539 fn from_node(
1540 node: ::tree_sitter::Node<'tree>,
1541 src: &'tree [u8],
1542 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1543 debug_assert_eq!(node.kind(), "binary_expression");
1544 Ok(Self {
1545 span: ::treesitter_types::Span::from(node),
1546 left: {
1547 let child = node
1548 .child_by_field_name("left")
1549 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1550 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1551 },
1552 operator: {
1553 let child = node.child_by_field_name("operator").ok_or_else(|| {
1554 ::treesitter_types::ParseError::missing_field("operator", node)
1555 })?;
1556 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1557 },
1558 right: {
1559 let child = node
1560 .child_by_field_name("right")
1561 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1562 <BinaryExpressionRight as ::treesitter_types::FromNode>::from_node(child, src)?
1563 },
1564 })
1565 }
1566}
1567impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1568 fn span(&self) -> ::treesitter_types::Span {
1569 self.span
1570 }
1571}
1572#[derive(Debug, Clone)]
1573pub struct Boolean<'tree> {
1574 pub span: ::treesitter_types::Span,
1575 text: &'tree str,
1576}
1577impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
1578 fn from_node(
1579 node: ::tree_sitter::Node<'tree>,
1580 src: &'tree [u8],
1581 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1582 debug_assert_eq!(node.kind(), "boolean");
1583 Ok(Self {
1584 span: ::treesitter_types::Span::from(node),
1585 text: node.utf8_text(src)?,
1586 })
1587 }
1588}
1589impl<'tree> ::treesitter_types::LeafNode<'tree> for Boolean<'tree> {
1590 fn text(&self) -> &'tree str {
1591 self.text
1592 }
1593}
1594impl ::treesitter_types::Spanned for Boolean<'_> {
1595 fn span(&self) -> ::treesitter_types::Span {
1596 self.span
1597 }
1598}
1599#[derive(Debug, Clone)]
1600pub struct BreakStatement<'tree> {
1601 pub span: ::treesitter_types::Span,
1602 pub children: ::core::option::Option<Expression<'tree>>,
1603}
1604impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1605 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1606 fn from_node(
1607 node: ::tree_sitter::Node<'tree>,
1608 src: &'tree [u8],
1609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1610 debug_assert_eq!(node.kind(), "break_statement");
1611 Ok(Self {
1612 span: ::treesitter_types::Span::from(node),
1613 children: {
1614 #[allow(clippy::suspicious_else_formatting)]
1615 let non_field_children = {
1616 let mut cursor = node.walk();
1617 let mut result = ::std::vec::Vec::new();
1618 if cursor.goto_first_child() {
1619 loop {
1620 if cursor.field_name().is_none()
1621 && cursor.node().is_named()
1622 && !cursor.node().is_extra()
1623 {
1624 result.push(cursor.node());
1625 }
1626 if !cursor.goto_next_sibling() {
1627 break;
1628 }
1629 }
1630 }
1631 result
1632 };
1633 match non_field_children.first() {
1634 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
1635 child, src,
1636 )?),
1637 None => None,
1638 }
1639 },
1640 })
1641 }
1642}
1643impl ::treesitter_types::Spanned for BreakStatement<'_> {
1644 fn span(&self) -> ::treesitter_types::Span {
1645 self.span
1646 }
1647}
1648#[derive(Debug, Clone)]
1649pub struct ByRef<'tree> {
1650 pub span: ::treesitter_types::Span,
1651 pub children: ByRefChildren<'tree>,
1652}
1653impl<'tree> ::treesitter_types::FromNode<'tree> for ByRef<'tree> {
1654 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1655 fn from_node(
1656 node: ::tree_sitter::Node<'tree>,
1657 src: &'tree [u8],
1658 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1659 debug_assert_eq!(node.kind(), "by_ref");
1660 Ok(Self {
1661 span: ::treesitter_types::Span::from(node),
1662 children: {
1663 #[allow(clippy::suspicious_else_formatting)]
1664 let non_field_children = {
1665 let mut cursor = node.walk();
1666 let mut result = ::std::vec::Vec::new();
1667 if cursor.goto_first_child() {
1668 loop {
1669 if cursor.field_name().is_none()
1670 && cursor.node().is_named()
1671 && !cursor.node().is_extra()
1672 {
1673 result.push(cursor.node());
1674 }
1675 if !cursor.goto_next_sibling() {
1676 break;
1677 }
1678 }
1679 }
1680 result
1681 };
1682 let child = if let Some(&c) = non_field_children.first() {
1683 c
1684 } else {
1685 let mut fallback_cursor = node.walk();
1686 let mut fallback_child = None;
1687 if fallback_cursor.goto_first_child() {
1688 loop {
1689 if fallback_cursor.field_name().is_none()
1690 && !fallback_cursor.node().is_extra()
1691 {
1692 let candidate = fallback_cursor.node();
1693 #[allow(clippy::needless_question_mark)]
1694 if (|| -> ::core::result::Result<
1695 _,
1696 ::treesitter_types::ParseError,
1697 > {
1698 let child = candidate;
1699 Ok(
1700 <ByRefChildren as ::treesitter_types::FromNode>::from_node(
1701 child,
1702 src,
1703 )?,
1704 )
1705 })()
1706 .is_ok()
1707 {
1708 fallback_child = Some(candidate);
1709 break;
1710 }
1711 }
1712 if !fallback_cursor.goto_next_sibling() {
1713 break;
1714 }
1715 }
1716 }
1717 if fallback_child.is_none() {
1718 let mut cursor2 = node.walk();
1719 if cursor2.goto_first_child() {
1720 loop {
1721 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1722 let candidate = cursor2.node();
1723 #[allow(clippy::needless_question_mark)]
1724 if (|| -> ::core::result::Result<
1725 _,
1726 ::treesitter_types::ParseError,
1727 > {
1728 let child = candidate;
1729 Ok(
1730 <ByRefChildren as ::treesitter_types::FromNode>::from_node(
1731 child,
1732 src,
1733 )?,
1734 )
1735 })()
1736 .is_ok()
1737 {
1738 fallback_child = Some(candidate);
1739 break;
1740 }
1741 }
1742 if !cursor2.goto_next_sibling() {
1743 break;
1744 }
1745 }
1746 }
1747 }
1748 fallback_child.ok_or_else(|| {
1749 ::treesitter_types::ParseError::missing_field("children", node)
1750 })?
1751 };
1752 <ByRefChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1753 },
1754 })
1755 }
1756}
1757impl ::treesitter_types::Spanned for ByRef<'_> {
1758 fn span(&self) -> ::treesitter_types::Span {
1759 self.span
1760 }
1761}
1762#[derive(Debug, Clone)]
1763pub struct CaseStatement<'tree> {
1764 pub span: ::treesitter_types::Span,
1765 pub value: Expression<'tree>,
1766 pub children: ::std::vec::Vec<Statement<'tree>>,
1767}
1768impl<'tree> ::treesitter_types::FromNode<'tree> for CaseStatement<'tree> {
1769 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1770 fn from_node(
1771 node: ::tree_sitter::Node<'tree>,
1772 src: &'tree [u8],
1773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1774 debug_assert_eq!(node.kind(), "case_statement");
1775 Ok(Self {
1776 span: ::treesitter_types::Span::from(node),
1777 value: {
1778 let child = node
1779 .child_by_field_name("value")
1780 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1781 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1782 },
1783 children: {
1784 #[allow(clippy::suspicious_else_formatting)]
1785 let non_field_children = {
1786 let mut cursor = node.walk();
1787 let mut result = ::std::vec::Vec::new();
1788 if cursor.goto_first_child() {
1789 loop {
1790 if cursor.field_name().is_none()
1791 && cursor.node().is_named()
1792 && !cursor.node().is_extra()
1793 {
1794 result.push(cursor.node());
1795 }
1796 if !cursor.goto_next_sibling() {
1797 break;
1798 }
1799 }
1800 }
1801 result
1802 };
1803 let mut items = ::std::vec::Vec::new();
1804 for child in non_field_children {
1805 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
1806 child, src,
1807 )?);
1808 }
1809 items
1810 },
1811 })
1812 }
1813}
1814impl ::treesitter_types::Spanned for CaseStatement<'_> {
1815 fn span(&self) -> ::treesitter_types::Span {
1816 self.span
1817 }
1818}
1819#[derive(Debug, Clone)]
1820pub struct CastExpression<'tree> {
1821 pub span: ::treesitter_types::Span,
1822 pub r#type: CastType<'tree>,
1823 pub value: CastExpressionValue<'tree>,
1824}
1825impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpression<'tree> {
1826 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1827 fn from_node(
1828 node: ::tree_sitter::Node<'tree>,
1829 src: &'tree [u8],
1830 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1831 debug_assert_eq!(node.kind(), "cast_expression");
1832 Ok(Self {
1833 span: ::treesitter_types::Span::from(node),
1834 r#type: {
1835 let child = node
1836 .child_by_field_name("type")
1837 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1838 <CastType as ::treesitter_types::FromNode>::from_node(child, src)?
1839 },
1840 value: {
1841 let child = node
1842 .child_by_field_name("value")
1843 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1844 <CastExpressionValue as ::treesitter_types::FromNode>::from_node(child, src)?
1845 },
1846 })
1847 }
1848}
1849impl ::treesitter_types::Spanned for CastExpression<'_> {
1850 fn span(&self) -> ::treesitter_types::Span {
1851 self.span
1852 }
1853}
1854#[derive(Debug, Clone)]
1855pub struct CastType<'tree> {
1856 pub span: ::treesitter_types::Span,
1857 text: &'tree str,
1858}
1859impl<'tree> ::treesitter_types::FromNode<'tree> for CastType<'tree> {
1860 fn from_node(
1861 node: ::tree_sitter::Node<'tree>,
1862 src: &'tree [u8],
1863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1864 debug_assert_eq!(node.kind(), "cast_type");
1865 Ok(Self {
1866 span: ::treesitter_types::Span::from(node),
1867 text: node.utf8_text(src)?,
1868 })
1869 }
1870}
1871impl<'tree> ::treesitter_types::LeafNode<'tree> for CastType<'tree> {
1872 fn text(&self) -> &'tree str {
1873 self.text
1874 }
1875}
1876impl ::treesitter_types::Spanned for CastType<'_> {
1877 fn span(&self) -> ::treesitter_types::Span {
1878 self.span
1879 }
1880}
1881#[derive(Debug, Clone)]
1882pub struct CatchClause<'tree> {
1883 pub span: ::treesitter_types::Span,
1884 pub body: CompoundStatement<'tree>,
1885 pub name: ::core::option::Option<VariableName<'tree>>,
1886 pub r#type: TypeList<'tree>,
1887}
1888impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1889 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1890 fn from_node(
1891 node: ::tree_sitter::Node<'tree>,
1892 src: &'tree [u8],
1893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1894 debug_assert_eq!(node.kind(), "catch_clause");
1895 Ok(Self {
1896 span: ::treesitter_types::Span::from(node),
1897 body: {
1898 let child = node
1899 .child_by_field_name("body")
1900 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1901 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
1902 },
1903 name: match node.child_by_field_name("name") {
1904 Some(child) => Some(<VariableName as ::treesitter_types::FromNode>::from_node(
1905 child, src,
1906 )?),
1907 None => None,
1908 },
1909 r#type: {
1910 let child = node
1911 .child_by_field_name("type")
1912 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1913 <TypeList as ::treesitter_types::FromNode>::from_node(child, src)?
1914 },
1915 })
1916 }
1917}
1918impl ::treesitter_types::Spanned for CatchClause<'_> {
1919 fn span(&self) -> ::treesitter_types::Span {
1920 self.span
1921 }
1922}
1923#[derive(Debug, Clone)]
1924pub struct ClassConstantAccessExpression<'tree> {
1925 pub span: ::treesitter_types::Span,
1926 pub children: ::std::vec::Vec<ClassConstantAccessExpressionChildren<'tree>>,
1927}
1928impl<'tree> ::treesitter_types::FromNode<'tree> for ClassConstantAccessExpression<'tree> {
1929 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1930 fn from_node(
1931 node: ::tree_sitter::Node<'tree>,
1932 src: &'tree [u8],
1933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1934 debug_assert_eq!(node.kind(), "class_constant_access_expression");
1935 Ok(Self {
1936 span: ::treesitter_types::Span::from(node),
1937 children: {
1938 #[allow(clippy::suspicious_else_formatting)]
1939 let non_field_children = {
1940 let mut cursor = node.walk();
1941 let mut result = ::std::vec::Vec::new();
1942 if cursor.goto_first_child() {
1943 loop {
1944 if cursor.field_name().is_none()
1945 && cursor.node().is_named()
1946 && !cursor.node().is_extra()
1947 {
1948 result.push(cursor.node());
1949 }
1950 if !cursor.goto_next_sibling() {
1951 break;
1952 }
1953 }
1954 }
1955 result
1956 };
1957 let mut items = ::std::vec::Vec::new();
1958 for child in non_field_children {
1959 items
1960 .push(
1961 <ClassConstantAccessExpressionChildren as ::treesitter_types::FromNode>::from_node(
1962 child,
1963 src,
1964 )?,
1965 );
1966 }
1967 items
1968 },
1969 })
1970 }
1971}
1972impl ::treesitter_types::Spanned for ClassConstantAccessExpression<'_> {
1973 fn span(&self) -> ::treesitter_types::Span {
1974 self.span
1975 }
1976}
1977#[derive(Debug, Clone)]
1978pub struct ClassDeclaration<'tree> {
1979 pub span: ::treesitter_types::Span,
1980 pub attributes: ::core::option::Option<AttributeList<'tree>>,
1981 pub body: DeclarationList<'tree>,
1982 pub name: Name<'tree>,
1983 pub children: ::std::vec::Vec<ClassDeclarationChildren<'tree>>,
1984}
1985impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1986 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1987 fn from_node(
1988 node: ::tree_sitter::Node<'tree>,
1989 src: &'tree [u8],
1990 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1991 debug_assert_eq!(node.kind(), "class_declaration");
1992 Ok(Self {
1993 span: ::treesitter_types::Span::from(node),
1994 attributes: match node.child_by_field_name("attributes") {
1995 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
1996 child, src,
1997 )?),
1998 None => None,
1999 },
2000 body: {
2001 let child = node
2002 .child_by_field_name("body")
2003 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2004 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
2005 },
2006 name: {
2007 let child = node
2008 .child_by_field_name("name")
2009 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2010 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
2011 },
2012 children: {
2013 #[allow(clippy::suspicious_else_formatting)]
2014 let non_field_children = {
2015 let mut cursor = node.walk();
2016 let mut result = ::std::vec::Vec::new();
2017 if cursor.goto_first_child() {
2018 loop {
2019 if cursor.field_name().is_none()
2020 && cursor.node().is_named()
2021 && !cursor.node().is_extra()
2022 {
2023 result.push(cursor.node());
2024 }
2025 if !cursor.goto_next_sibling() {
2026 break;
2027 }
2028 }
2029 }
2030 result
2031 };
2032 let mut items = ::std::vec::Vec::new();
2033 for child in non_field_children {
2034 items.push(
2035 <ClassDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2036 child, src,
2037 )?,
2038 );
2039 }
2040 items
2041 },
2042 })
2043 }
2044}
2045impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
2046 fn span(&self) -> ::treesitter_types::Span {
2047 self.span
2048 }
2049}
2050#[derive(Debug, Clone)]
2051pub struct ClassInterfaceClause<'tree> {
2052 pub span: ::treesitter_types::Span,
2053 pub children: ::std::vec::Vec<ClassInterfaceClauseChildren<'tree>>,
2054}
2055impl<'tree> ::treesitter_types::FromNode<'tree> for ClassInterfaceClause<'tree> {
2056 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2057 fn from_node(
2058 node: ::tree_sitter::Node<'tree>,
2059 src: &'tree [u8],
2060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2061 debug_assert_eq!(node.kind(), "class_interface_clause");
2062 Ok(Self {
2063 span: ::treesitter_types::Span::from(node),
2064 children: {
2065 #[allow(clippy::suspicious_else_formatting)]
2066 let non_field_children = {
2067 let mut cursor = node.walk();
2068 let mut result = ::std::vec::Vec::new();
2069 if cursor.goto_first_child() {
2070 loop {
2071 if cursor.field_name().is_none()
2072 && cursor.node().is_named()
2073 && !cursor.node().is_extra()
2074 {
2075 result.push(cursor.node());
2076 }
2077 if !cursor.goto_next_sibling() {
2078 break;
2079 }
2080 }
2081 }
2082 result
2083 };
2084 let mut items = ::std::vec::Vec::new();
2085 for child in non_field_children {
2086 items.push(
2087 <ClassInterfaceClauseChildren as ::treesitter_types::FromNode>::from_node(
2088 child, src,
2089 )?,
2090 );
2091 }
2092 items
2093 },
2094 })
2095 }
2096}
2097impl ::treesitter_types::Spanned for ClassInterfaceClause<'_> {
2098 fn span(&self) -> ::treesitter_types::Span {
2099 self.span
2100 }
2101}
2102#[derive(Debug, Clone)]
2103pub struct CloneExpression<'tree> {
2104 pub span: ::treesitter_types::Span,
2105 pub children: PrimaryExpression<'tree>,
2106}
2107impl<'tree> ::treesitter_types::FromNode<'tree> for CloneExpression<'tree> {
2108 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2109 fn from_node(
2110 node: ::tree_sitter::Node<'tree>,
2111 src: &'tree [u8],
2112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2113 debug_assert_eq!(node.kind(), "clone_expression");
2114 Ok(Self {
2115 span: ::treesitter_types::Span::from(node),
2116 children: {
2117 #[allow(clippy::suspicious_else_formatting)]
2118 let non_field_children = {
2119 let mut cursor = node.walk();
2120 let mut result = ::std::vec::Vec::new();
2121 if cursor.goto_first_child() {
2122 loop {
2123 if cursor.field_name().is_none()
2124 && cursor.node().is_named()
2125 && !cursor.node().is_extra()
2126 {
2127 result.push(cursor.node());
2128 }
2129 if !cursor.goto_next_sibling() {
2130 break;
2131 }
2132 }
2133 }
2134 result
2135 };
2136 let child = if let Some(&c) = non_field_children.first() {
2137 c
2138 } else {
2139 let mut fallback_cursor = node.walk();
2140 let mut fallback_child = None;
2141 if fallback_cursor.goto_first_child() {
2142 loop {
2143 if fallback_cursor.field_name().is_none()
2144 && !fallback_cursor.node().is_extra()
2145 {
2146 let candidate = fallback_cursor.node();
2147 #[allow(clippy::needless_question_mark)]
2148 if (|| -> ::core::result::Result<
2149 _,
2150 ::treesitter_types::ParseError,
2151 > {
2152 let child = candidate;
2153 Ok(
2154 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(
2155 child,
2156 src,
2157 )?,
2158 )
2159 })()
2160 .is_ok()
2161 {
2162 fallback_child = Some(candidate);
2163 break;
2164 }
2165 }
2166 if !fallback_cursor.goto_next_sibling() {
2167 break;
2168 }
2169 }
2170 }
2171 if fallback_child.is_none() {
2172 let mut cursor2 = node.walk();
2173 if cursor2.goto_first_child() {
2174 loop {
2175 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2176 let candidate = cursor2.node();
2177 #[allow(clippy::needless_question_mark)]
2178 if (|| -> ::core::result::Result<
2179 _,
2180 ::treesitter_types::ParseError,
2181 > {
2182 let child = candidate;
2183 Ok(
2184 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(
2185 child,
2186 src,
2187 )?,
2188 )
2189 })()
2190 .is_ok()
2191 {
2192 fallback_child = Some(candidate);
2193 break;
2194 }
2195 }
2196 if !cursor2.goto_next_sibling() {
2197 break;
2198 }
2199 }
2200 }
2201 }
2202 fallback_child.ok_or_else(|| {
2203 ::treesitter_types::ParseError::missing_field("children", node)
2204 })?
2205 };
2206 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2207 },
2208 })
2209 }
2210}
2211impl ::treesitter_types::Spanned for CloneExpression<'_> {
2212 fn span(&self) -> ::treesitter_types::Span {
2213 self.span
2214 }
2215}
2216#[derive(Debug, Clone)]
2217pub struct ColonBlock<'tree> {
2218 pub span: ::treesitter_types::Span,
2219 pub children: ::std::vec::Vec<Statement<'tree>>,
2220}
2221impl<'tree> ::treesitter_types::FromNode<'tree> for ColonBlock<'tree> {
2222 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2223 fn from_node(
2224 node: ::tree_sitter::Node<'tree>,
2225 src: &'tree [u8],
2226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2227 debug_assert_eq!(node.kind(), "colon_block");
2228 Ok(Self {
2229 span: ::treesitter_types::Span::from(node),
2230 children: {
2231 #[allow(clippy::suspicious_else_formatting)]
2232 let non_field_children = {
2233 let mut cursor = node.walk();
2234 let mut result = ::std::vec::Vec::new();
2235 if cursor.goto_first_child() {
2236 loop {
2237 if cursor.field_name().is_none()
2238 && cursor.node().is_named()
2239 && !cursor.node().is_extra()
2240 {
2241 result.push(cursor.node());
2242 }
2243 if !cursor.goto_next_sibling() {
2244 break;
2245 }
2246 }
2247 }
2248 result
2249 };
2250 let mut items = ::std::vec::Vec::new();
2251 for child in non_field_children {
2252 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
2253 child, src,
2254 )?);
2255 }
2256 items
2257 },
2258 })
2259 }
2260}
2261impl ::treesitter_types::Spanned for ColonBlock<'_> {
2262 fn span(&self) -> ::treesitter_types::Span {
2263 self.span
2264 }
2265}
2266#[derive(Debug, Clone)]
2267pub struct CompoundStatement<'tree> {
2268 pub span: ::treesitter_types::Span,
2269 pub children: ::std::vec::Vec<Statement<'tree>>,
2270}
2271impl<'tree> ::treesitter_types::FromNode<'tree> for CompoundStatement<'tree> {
2272 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2273 fn from_node(
2274 node: ::tree_sitter::Node<'tree>,
2275 src: &'tree [u8],
2276 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2277 debug_assert_eq!(node.kind(), "compound_statement");
2278 Ok(Self {
2279 span: ::treesitter_types::Span::from(node),
2280 children: {
2281 #[allow(clippy::suspicious_else_formatting)]
2282 let non_field_children = {
2283 let mut cursor = node.walk();
2284 let mut result = ::std::vec::Vec::new();
2285 if cursor.goto_first_child() {
2286 loop {
2287 if cursor.field_name().is_none()
2288 && cursor.node().is_named()
2289 && !cursor.node().is_extra()
2290 {
2291 result.push(cursor.node());
2292 }
2293 if !cursor.goto_next_sibling() {
2294 break;
2295 }
2296 }
2297 }
2298 result
2299 };
2300 let mut items = ::std::vec::Vec::new();
2301 for child in non_field_children {
2302 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
2303 child, src,
2304 )?);
2305 }
2306 items
2307 },
2308 })
2309 }
2310}
2311impl ::treesitter_types::Spanned for CompoundStatement<'_> {
2312 fn span(&self) -> ::treesitter_types::Span {
2313 self.span
2314 }
2315}
2316#[derive(Debug, Clone)]
2317pub struct ConditionalExpression<'tree> {
2318 pub span: ::treesitter_types::Span,
2319 pub alternative: Expression<'tree>,
2320 pub body: ::core::option::Option<Expression<'tree>>,
2321 pub condition: Expression<'tree>,
2322}
2323impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalExpression<'tree> {
2324 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2325 fn from_node(
2326 node: ::tree_sitter::Node<'tree>,
2327 src: &'tree [u8],
2328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2329 debug_assert_eq!(node.kind(), "conditional_expression");
2330 Ok(Self {
2331 span: ::treesitter_types::Span::from(node),
2332 alternative: {
2333 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2334 ::treesitter_types::ParseError::missing_field("alternative", node)
2335 })?;
2336 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2337 },
2338 body: match node.child_by_field_name("body") {
2339 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2340 child, src,
2341 )?),
2342 None => None,
2343 },
2344 condition: {
2345 let child = node.child_by_field_name("condition").ok_or_else(|| {
2346 ::treesitter_types::ParseError::missing_field("condition", node)
2347 })?;
2348 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2349 },
2350 })
2351 }
2352}
2353impl ::treesitter_types::Spanned for ConditionalExpression<'_> {
2354 fn span(&self) -> ::treesitter_types::Span {
2355 self.span
2356 }
2357}
2358#[derive(Debug, Clone)]
2359pub struct ConstDeclaration<'tree> {
2360 pub span: ::treesitter_types::Span,
2361 pub attributes: ::core::option::Option<AttributeList<'tree>>,
2362 pub r#type: ::core::option::Option<Type<'tree>>,
2363 pub children: ::std::vec::Vec<ConstDeclarationChildren<'tree>>,
2364}
2365impl<'tree> ::treesitter_types::FromNode<'tree> for ConstDeclaration<'tree> {
2366 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2367 fn from_node(
2368 node: ::tree_sitter::Node<'tree>,
2369 src: &'tree [u8],
2370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2371 debug_assert_eq!(node.kind(), "const_declaration");
2372 Ok(Self {
2373 span: ::treesitter_types::Span::from(node),
2374 attributes: match node.child_by_field_name("attributes") {
2375 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
2376 child, src,
2377 )?),
2378 None => None,
2379 },
2380 r#type: match node.child_by_field_name("type") {
2381 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
2382 child, src,
2383 )?),
2384 None => None,
2385 },
2386 children: {
2387 #[allow(clippy::suspicious_else_formatting)]
2388 let non_field_children = {
2389 let mut cursor = node.walk();
2390 let mut result = ::std::vec::Vec::new();
2391 if cursor.goto_first_child() {
2392 loop {
2393 if cursor.field_name().is_none()
2394 && cursor.node().is_named()
2395 && !cursor.node().is_extra()
2396 {
2397 result.push(cursor.node());
2398 }
2399 if !cursor.goto_next_sibling() {
2400 break;
2401 }
2402 }
2403 }
2404 result
2405 };
2406 let mut items = ::std::vec::Vec::new();
2407 for child in non_field_children {
2408 items.push(
2409 <ConstDeclarationChildren as ::treesitter_types::FromNode>::from_node(
2410 child, src,
2411 )?,
2412 );
2413 }
2414 items
2415 },
2416 })
2417 }
2418}
2419impl ::treesitter_types::Spanned for ConstDeclaration<'_> {
2420 fn span(&self) -> ::treesitter_types::Span {
2421 self.span
2422 }
2423}
2424#[derive(Debug, Clone)]
2425pub struct ConstElement<'tree> {
2426 pub span: ::treesitter_types::Span,
2427 pub children: ::std::vec::Vec<ConstElementChildren<'tree>>,
2428}
2429impl<'tree> ::treesitter_types::FromNode<'tree> for ConstElement<'tree> {
2430 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2431 fn from_node(
2432 node: ::tree_sitter::Node<'tree>,
2433 src: &'tree [u8],
2434 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2435 debug_assert_eq!(node.kind(), "const_element");
2436 Ok(Self {
2437 span: ::treesitter_types::Span::from(node),
2438 children: {
2439 #[allow(clippy::suspicious_else_formatting)]
2440 let non_field_children = {
2441 let mut cursor = node.walk();
2442 let mut result = ::std::vec::Vec::new();
2443 if cursor.goto_first_child() {
2444 loop {
2445 if cursor.field_name().is_none()
2446 && cursor.node().is_named()
2447 && !cursor.node().is_extra()
2448 {
2449 result.push(cursor.node());
2450 }
2451 if !cursor.goto_next_sibling() {
2452 break;
2453 }
2454 }
2455 }
2456 result
2457 };
2458 let mut items = ::std::vec::Vec::new();
2459 for child in non_field_children {
2460 items.push(
2461 <ConstElementChildren as ::treesitter_types::FromNode>::from_node(
2462 child, src,
2463 )?,
2464 );
2465 }
2466 items
2467 },
2468 })
2469 }
2470}
2471impl ::treesitter_types::Spanned for ConstElement<'_> {
2472 fn span(&self) -> ::treesitter_types::Span {
2473 self.span
2474 }
2475}
2476#[derive(Debug, Clone)]
2477pub struct ContinueStatement<'tree> {
2478 pub span: ::treesitter_types::Span,
2479 pub children: ::core::option::Option<Expression<'tree>>,
2480}
2481impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2482 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2483 fn from_node(
2484 node: ::tree_sitter::Node<'tree>,
2485 src: &'tree [u8],
2486 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2487 debug_assert_eq!(node.kind(), "continue_statement");
2488 Ok(Self {
2489 span: ::treesitter_types::Span::from(node),
2490 children: {
2491 #[allow(clippy::suspicious_else_formatting)]
2492 let non_field_children = {
2493 let mut cursor = node.walk();
2494 let mut result = ::std::vec::Vec::new();
2495 if cursor.goto_first_child() {
2496 loop {
2497 if cursor.field_name().is_none()
2498 && cursor.node().is_named()
2499 && !cursor.node().is_extra()
2500 {
2501 result.push(cursor.node());
2502 }
2503 if !cursor.goto_next_sibling() {
2504 break;
2505 }
2506 }
2507 }
2508 result
2509 };
2510 match non_field_children.first() {
2511 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2512 child, src,
2513 )?),
2514 None => None,
2515 }
2516 },
2517 })
2518 }
2519}
2520impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2521 fn span(&self) -> ::treesitter_types::Span {
2522 self.span
2523 }
2524}
2525#[derive(Debug, Clone)]
2526pub struct DeclarationList<'tree> {
2527 pub span: ::treesitter_types::Span,
2528 pub children: ::std::vec::Vec<DeclarationListChildren<'tree>>,
2529}
2530impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationList<'tree> {
2531 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2532 fn from_node(
2533 node: ::tree_sitter::Node<'tree>,
2534 src: &'tree [u8],
2535 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2536 debug_assert_eq!(node.kind(), "declaration_list");
2537 Ok(Self {
2538 span: ::treesitter_types::Span::from(node),
2539 children: {
2540 #[allow(clippy::suspicious_else_formatting)]
2541 let non_field_children = {
2542 let mut cursor = node.walk();
2543 let mut result = ::std::vec::Vec::new();
2544 if cursor.goto_first_child() {
2545 loop {
2546 if cursor.field_name().is_none()
2547 && cursor.node().is_named()
2548 && !cursor.node().is_extra()
2549 {
2550 result.push(cursor.node());
2551 }
2552 if !cursor.goto_next_sibling() {
2553 break;
2554 }
2555 }
2556 }
2557 result
2558 };
2559 let mut items = ::std::vec::Vec::new();
2560 for child in non_field_children {
2561 items.push(
2562 <DeclarationListChildren as ::treesitter_types::FromNode>::from_node(
2563 child, src,
2564 )?,
2565 );
2566 }
2567 items
2568 },
2569 })
2570 }
2571}
2572impl ::treesitter_types::Spanned for DeclarationList<'_> {
2573 fn span(&self) -> ::treesitter_types::Span {
2574 self.span
2575 }
2576}
2577#[derive(Debug, Clone)]
2578pub struct DeclareDirective<'tree> {
2579 pub span: ::treesitter_types::Span,
2580 pub children: Literal<'tree>,
2581}
2582impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareDirective<'tree> {
2583 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2584 fn from_node(
2585 node: ::tree_sitter::Node<'tree>,
2586 src: &'tree [u8],
2587 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2588 debug_assert_eq!(node.kind(), "declare_directive");
2589 Ok(Self {
2590 span: ::treesitter_types::Span::from(node),
2591 children: {
2592 #[allow(clippy::suspicious_else_formatting)]
2593 let non_field_children = {
2594 let mut cursor = node.walk();
2595 let mut result = ::std::vec::Vec::new();
2596 if cursor.goto_first_child() {
2597 loop {
2598 if cursor.field_name().is_none()
2599 && cursor.node().is_named()
2600 && !cursor.node().is_extra()
2601 {
2602 result.push(cursor.node());
2603 }
2604 if !cursor.goto_next_sibling() {
2605 break;
2606 }
2607 }
2608 }
2609 result
2610 };
2611 let child = if let Some(&c) = non_field_children.first() {
2612 c
2613 } else {
2614 let mut fallback_cursor = node.walk();
2615 let mut fallback_child = None;
2616 if fallback_cursor.goto_first_child() {
2617 loop {
2618 if fallback_cursor.field_name().is_none()
2619 && !fallback_cursor.node().is_extra()
2620 {
2621 let candidate = fallback_cursor.node();
2622 #[allow(clippy::needless_question_mark)]
2623 if (|| -> ::core::result::Result<
2624 _,
2625 ::treesitter_types::ParseError,
2626 > {
2627 let child = candidate;
2628 Ok(
2629 <Literal as ::treesitter_types::FromNode>::from_node(
2630 child,
2631 src,
2632 )?,
2633 )
2634 })()
2635 .is_ok()
2636 {
2637 fallback_child = Some(candidate);
2638 break;
2639 }
2640 }
2641 if !fallback_cursor.goto_next_sibling() {
2642 break;
2643 }
2644 }
2645 }
2646 if fallback_child.is_none() {
2647 let mut cursor2 = node.walk();
2648 if cursor2.goto_first_child() {
2649 loop {
2650 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2651 let candidate = cursor2.node();
2652 #[allow(clippy::needless_question_mark)]
2653 if (|| -> ::core::result::Result<
2654 _,
2655 ::treesitter_types::ParseError,
2656 > {
2657 let child = candidate;
2658 Ok(
2659 <Literal as ::treesitter_types::FromNode>::from_node(
2660 child,
2661 src,
2662 )?,
2663 )
2664 })()
2665 .is_ok()
2666 {
2667 fallback_child = Some(candidate);
2668 break;
2669 }
2670 }
2671 if !cursor2.goto_next_sibling() {
2672 break;
2673 }
2674 }
2675 }
2676 }
2677 fallback_child.ok_or_else(|| {
2678 ::treesitter_types::ParseError::missing_field("children", node)
2679 })?
2680 };
2681 <Literal as ::treesitter_types::FromNode>::from_node(child, src)?
2682 },
2683 })
2684 }
2685}
2686impl ::treesitter_types::Spanned for DeclareDirective<'_> {
2687 fn span(&self) -> ::treesitter_types::Span {
2688 self.span
2689 }
2690}
2691#[derive(Debug, Clone)]
2692pub struct DeclareStatement<'tree> {
2693 pub span: ::treesitter_types::Span,
2694 pub children: ::std::vec::Vec<DeclareStatementChildren<'tree>>,
2695}
2696impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareStatement<'tree> {
2697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2698 fn from_node(
2699 node: ::tree_sitter::Node<'tree>,
2700 src: &'tree [u8],
2701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2702 debug_assert_eq!(node.kind(), "declare_statement");
2703 Ok(Self {
2704 span: ::treesitter_types::Span::from(node),
2705 children: {
2706 #[allow(clippy::suspicious_else_formatting)]
2707 let non_field_children = {
2708 let mut cursor = node.walk();
2709 let mut result = ::std::vec::Vec::new();
2710 if cursor.goto_first_child() {
2711 loop {
2712 if cursor.field_name().is_none()
2713 && cursor.node().is_named()
2714 && !cursor.node().is_extra()
2715 {
2716 result.push(cursor.node());
2717 }
2718 if !cursor.goto_next_sibling() {
2719 break;
2720 }
2721 }
2722 }
2723 result
2724 };
2725 let mut items = ::std::vec::Vec::new();
2726 for child in non_field_children {
2727 items.push(
2728 <DeclareStatementChildren as ::treesitter_types::FromNode>::from_node(
2729 child, src,
2730 )?,
2731 );
2732 }
2733 items
2734 },
2735 })
2736 }
2737}
2738impl ::treesitter_types::Spanned for DeclareStatement<'_> {
2739 fn span(&self) -> ::treesitter_types::Span {
2740 self.span
2741 }
2742}
2743#[derive(Debug, Clone)]
2744pub struct DefaultStatement<'tree> {
2745 pub span: ::treesitter_types::Span,
2746 pub children: ::std::vec::Vec<Statement<'tree>>,
2747}
2748impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultStatement<'tree> {
2749 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2750 fn from_node(
2751 node: ::tree_sitter::Node<'tree>,
2752 src: &'tree [u8],
2753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2754 debug_assert_eq!(node.kind(), "default_statement");
2755 Ok(Self {
2756 span: ::treesitter_types::Span::from(node),
2757 children: {
2758 #[allow(clippy::suspicious_else_formatting)]
2759 let non_field_children = {
2760 let mut cursor = node.walk();
2761 let mut result = ::std::vec::Vec::new();
2762 if cursor.goto_first_child() {
2763 loop {
2764 if cursor.field_name().is_none()
2765 && cursor.node().is_named()
2766 && !cursor.node().is_extra()
2767 {
2768 result.push(cursor.node());
2769 }
2770 if !cursor.goto_next_sibling() {
2771 break;
2772 }
2773 }
2774 }
2775 result
2776 };
2777 let mut items = ::std::vec::Vec::new();
2778 for child in non_field_children {
2779 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
2780 child, src,
2781 )?);
2782 }
2783 items
2784 },
2785 })
2786 }
2787}
2788impl ::treesitter_types::Spanned for DefaultStatement<'_> {
2789 fn span(&self) -> ::treesitter_types::Span {
2790 self.span
2791 }
2792}
2793#[derive(Debug, Clone)]
2794pub struct DisjunctiveNormalFormType<'tree> {
2795 pub span: ::treesitter_types::Span,
2796 pub children: ::std::vec::Vec<DisjunctiveNormalFormTypeChildren<'tree>>,
2797}
2798impl<'tree> ::treesitter_types::FromNode<'tree> for DisjunctiveNormalFormType<'tree> {
2799 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2800 fn from_node(
2801 node: ::tree_sitter::Node<'tree>,
2802 src: &'tree [u8],
2803 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2804 debug_assert_eq!(node.kind(), "disjunctive_normal_form_type");
2805 Ok(Self {
2806 span: ::treesitter_types::Span::from(node),
2807 children: {
2808 #[allow(clippy::suspicious_else_formatting)]
2809 let non_field_children = {
2810 let mut cursor = node.walk();
2811 let mut result = ::std::vec::Vec::new();
2812 if cursor.goto_first_child() {
2813 loop {
2814 if cursor.field_name().is_none()
2815 && cursor.node().is_named()
2816 && !cursor.node().is_extra()
2817 {
2818 result.push(cursor.node());
2819 }
2820 if !cursor.goto_next_sibling() {
2821 break;
2822 }
2823 }
2824 }
2825 result
2826 };
2827 let mut items = ::std::vec::Vec::new();
2828 for child in non_field_children {
2829 items
2830 .push(
2831 <DisjunctiveNormalFormTypeChildren as ::treesitter_types::FromNode>::from_node(
2832 child,
2833 src,
2834 )?,
2835 );
2836 }
2837 items
2838 },
2839 })
2840 }
2841}
2842impl ::treesitter_types::Spanned for DisjunctiveNormalFormType<'_> {
2843 fn span(&self) -> ::treesitter_types::Span {
2844 self.span
2845 }
2846}
2847#[derive(Debug, Clone)]
2848pub struct DoStatement<'tree> {
2849 pub span: ::treesitter_types::Span,
2850 pub body: Statement<'tree>,
2851 pub condition: ParenthesizedExpression<'tree>,
2852}
2853impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2854 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2855 fn from_node(
2856 node: ::tree_sitter::Node<'tree>,
2857 src: &'tree [u8],
2858 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2859 debug_assert_eq!(node.kind(), "do_statement");
2860 Ok(Self {
2861 span: ::treesitter_types::Span::from(node),
2862 body: {
2863 let child = node
2864 .child_by_field_name("body")
2865 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2866 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2867 },
2868 condition: {
2869 let child = node.child_by_field_name("condition").ok_or_else(|| {
2870 ::treesitter_types::ParseError::missing_field("condition", node)
2871 })?;
2872 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2873 },
2874 })
2875 }
2876}
2877impl ::treesitter_types::Spanned for DoStatement<'_> {
2878 fn span(&self) -> ::treesitter_types::Span {
2879 self.span
2880 }
2881}
2882#[derive(Debug, Clone)]
2883pub struct DynamicVariableName<'tree> {
2884 pub span: ::treesitter_types::Span,
2885 pub children: DynamicVariableNameChildren<'tree>,
2886}
2887impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicVariableName<'tree> {
2888 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2889 fn from_node(
2890 node: ::tree_sitter::Node<'tree>,
2891 src: &'tree [u8],
2892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2893 debug_assert_eq!(node.kind(), "dynamic_variable_name");
2894 Ok(Self {
2895 span: ::treesitter_types::Span::from(node),
2896 children: {
2897 #[allow(clippy::suspicious_else_formatting)]
2898 let non_field_children = {
2899 let mut cursor = node.walk();
2900 let mut result = ::std::vec::Vec::new();
2901 if cursor.goto_first_child() {
2902 loop {
2903 if cursor.field_name().is_none()
2904 && cursor.node().is_named()
2905 && !cursor.node().is_extra()
2906 {
2907 result.push(cursor.node());
2908 }
2909 if !cursor.goto_next_sibling() {
2910 break;
2911 }
2912 }
2913 }
2914 result
2915 };
2916 let child = if let Some(&c) = non_field_children.first() {
2917 c
2918 } else {
2919 let mut fallback_cursor = node.walk();
2920 let mut fallback_child = None;
2921 if fallback_cursor.goto_first_child() {
2922 loop {
2923 if fallback_cursor.field_name().is_none()
2924 && !fallback_cursor.node().is_extra()
2925 {
2926 let candidate = fallback_cursor.node();
2927 #[allow(clippy::needless_question_mark)]
2928 if (|| -> ::core::result::Result<
2929 _,
2930 ::treesitter_types::ParseError,
2931 > {
2932 let child = candidate;
2933 Ok(
2934 <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
2935 child,
2936 src,
2937 )?,
2938 )
2939 })()
2940 .is_ok()
2941 {
2942 fallback_child = Some(candidate);
2943 break;
2944 }
2945 }
2946 if !fallback_cursor.goto_next_sibling() {
2947 break;
2948 }
2949 }
2950 }
2951 if fallback_child.is_none() {
2952 let mut cursor2 = node.walk();
2953 if cursor2.goto_first_child() {
2954 loop {
2955 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2956 let candidate = cursor2.node();
2957 #[allow(clippy::needless_question_mark)]
2958 if (|| -> ::core::result::Result<
2959 _,
2960 ::treesitter_types::ParseError,
2961 > {
2962 let child = candidate;
2963 Ok(
2964 <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
2965 child,
2966 src,
2967 )?,
2968 )
2969 })()
2970 .is_ok()
2971 {
2972 fallback_child = Some(candidate);
2973 break;
2974 }
2975 }
2976 if !cursor2.goto_next_sibling() {
2977 break;
2978 }
2979 }
2980 }
2981 }
2982 fallback_child.ok_or_else(|| {
2983 ::treesitter_types::ParseError::missing_field("children", node)
2984 })?
2985 };
2986 <DynamicVariableNameChildren as ::treesitter_types::FromNode>::from_node(
2987 child, src,
2988 )?
2989 },
2990 })
2991 }
2992}
2993impl ::treesitter_types::Spanned for DynamicVariableName<'_> {
2994 fn span(&self) -> ::treesitter_types::Span {
2995 self.span
2996 }
2997}
2998#[derive(Debug, Clone)]
2999pub struct EchoStatement<'tree> {
3000 pub span: ::treesitter_types::Span,
3001 pub children: EchoStatementChildren<'tree>,
3002}
3003impl<'tree> ::treesitter_types::FromNode<'tree> for EchoStatement<'tree> {
3004 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3005 fn from_node(
3006 node: ::tree_sitter::Node<'tree>,
3007 src: &'tree [u8],
3008 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3009 debug_assert_eq!(node.kind(), "echo_statement");
3010 Ok(Self {
3011 span: ::treesitter_types::Span::from(node),
3012 children: {
3013 #[allow(clippy::suspicious_else_formatting)]
3014 let non_field_children = {
3015 let mut cursor = node.walk();
3016 let mut result = ::std::vec::Vec::new();
3017 if cursor.goto_first_child() {
3018 loop {
3019 if cursor.field_name().is_none()
3020 && cursor.node().is_named()
3021 && !cursor.node().is_extra()
3022 {
3023 result.push(cursor.node());
3024 }
3025 if !cursor.goto_next_sibling() {
3026 break;
3027 }
3028 }
3029 }
3030 result
3031 };
3032 let child = if let Some(&c) = non_field_children.first() {
3033 c
3034 } else {
3035 let mut fallback_cursor = node.walk();
3036 let mut fallback_child = None;
3037 if fallback_cursor.goto_first_child() {
3038 loop {
3039 if fallback_cursor.field_name().is_none()
3040 && !fallback_cursor.node().is_extra()
3041 {
3042 let candidate = fallback_cursor.node();
3043 #[allow(clippy::needless_question_mark)]
3044 if (|| -> ::core::result::Result<
3045 _,
3046 ::treesitter_types::ParseError,
3047 > {
3048 let child = candidate;
3049 Ok(
3050 <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(
3051 child,
3052 src,
3053 )?,
3054 )
3055 })()
3056 .is_ok()
3057 {
3058 fallback_child = Some(candidate);
3059 break;
3060 }
3061 }
3062 if !fallback_cursor.goto_next_sibling() {
3063 break;
3064 }
3065 }
3066 }
3067 if fallback_child.is_none() {
3068 let mut cursor2 = node.walk();
3069 if cursor2.goto_first_child() {
3070 loop {
3071 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3072 let candidate = cursor2.node();
3073 #[allow(clippy::needless_question_mark)]
3074 if (|| -> ::core::result::Result<
3075 _,
3076 ::treesitter_types::ParseError,
3077 > {
3078 let child = candidate;
3079 Ok(
3080 <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(
3081 child,
3082 src,
3083 )?,
3084 )
3085 })()
3086 .is_ok()
3087 {
3088 fallback_child = Some(candidate);
3089 break;
3090 }
3091 }
3092 if !cursor2.goto_next_sibling() {
3093 break;
3094 }
3095 }
3096 }
3097 }
3098 fallback_child.ok_or_else(|| {
3099 ::treesitter_types::ParseError::missing_field("children", node)
3100 })?
3101 };
3102 <EchoStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3103 },
3104 })
3105 }
3106}
3107impl ::treesitter_types::Spanned for EchoStatement<'_> {
3108 fn span(&self) -> ::treesitter_types::Span {
3109 self.span
3110 }
3111}
3112#[derive(Debug, Clone)]
3113pub struct ElseClause<'tree> {
3114 pub span: ::treesitter_types::Span,
3115 pub body: ElseClauseBody<'tree>,
3116}
3117impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
3118 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3119 fn from_node(
3120 node: ::tree_sitter::Node<'tree>,
3121 src: &'tree [u8],
3122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3123 debug_assert_eq!(node.kind(), "else_clause");
3124 Ok(Self {
3125 span: ::treesitter_types::Span::from(node),
3126 body: {
3127 let child = node
3128 .child_by_field_name("body")
3129 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3130 <ElseClauseBody as ::treesitter_types::FromNode>::from_node(child, src)?
3131 },
3132 })
3133 }
3134}
3135impl ::treesitter_types::Spanned for ElseClause<'_> {
3136 fn span(&self) -> ::treesitter_types::Span {
3137 self.span
3138 }
3139}
3140#[derive(Debug, Clone)]
3141pub struct ElseIfClause<'tree> {
3142 pub span: ::treesitter_types::Span,
3143 pub body: ElseIfClauseBody<'tree>,
3144 pub condition: ParenthesizedExpression<'tree>,
3145}
3146impl<'tree> ::treesitter_types::FromNode<'tree> for ElseIfClause<'tree> {
3147 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3148 fn from_node(
3149 node: ::tree_sitter::Node<'tree>,
3150 src: &'tree [u8],
3151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3152 debug_assert_eq!(node.kind(), "else_if_clause");
3153 Ok(Self {
3154 span: ::treesitter_types::Span::from(node),
3155 body: {
3156 let child = node
3157 .child_by_field_name("body")
3158 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3159 <ElseIfClauseBody as ::treesitter_types::FromNode>::from_node(child, src)?
3160 },
3161 condition: {
3162 let child = node.child_by_field_name("condition").ok_or_else(|| {
3163 ::treesitter_types::ParseError::missing_field("condition", node)
3164 })?;
3165 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
3166 },
3167 })
3168 }
3169}
3170impl ::treesitter_types::Spanned for ElseIfClause<'_> {
3171 fn span(&self) -> ::treesitter_types::Span {
3172 self.span
3173 }
3174}
3175#[derive(Debug, Clone)]
3176pub struct EmptyStatement<'tree> {
3177 pub span: ::treesitter_types::Span,
3178 text: &'tree str,
3179}
3180impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
3181 fn from_node(
3182 node: ::tree_sitter::Node<'tree>,
3183 src: &'tree [u8],
3184 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3185 debug_assert_eq!(node.kind(), "empty_statement");
3186 Ok(Self {
3187 span: ::treesitter_types::Span::from(node),
3188 text: node.utf8_text(src)?,
3189 })
3190 }
3191}
3192impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
3193 fn text(&self) -> &'tree str {
3194 self.text
3195 }
3196}
3197impl ::treesitter_types::Spanned for EmptyStatement<'_> {
3198 fn span(&self) -> ::treesitter_types::Span {
3199 self.span
3200 }
3201}
3202#[derive(Debug, Clone)]
3203pub struct EncapsedString<'tree> {
3204 pub span: ::treesitter_types::Span,
3205 pub children: ::std::vec::Vec<EncapsedStringChildren<'tree>>,
3206}
3207impl<'tree> ::treesitter_types::FromNode<'tree> for EncapsedString<'tree> {
3208 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3209 fn from_node(
3210 node: ::tree_sitter::Node<'tree>,
3211 src: &'tree [u8],
3212 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3213 debug_assert_eq!(node.kind(), "encapsed_string");
3214 Ok(Self {
3215 span: ::treesitter_types::Span::from(node),
3216 children: {
3217 #[allow(clippy::suspicious_else_formatting)]
3218 let non_field_children = {
3219 let mut cursor = node.walk();
3220 let mut result = ::std::vec::Vec::new();
3221 if cursor.goto_first_child() {
3222 loop {
3223 if cursor.field_name().is_none()
3224 && cursor.node().is_named()
3225 && !cursor.node().is_extra()
3226 {
3227 result.push(cursor.node());
3228 }
3229 if !cursor.goto_next_sibling() {
3230 break;
3231 }
3232 }
3233 }
3234 result
3235 };
3236 let mut items = ::std::vec::Vec::new();
3237 for child in non_field_children {
3238 items.push(
3239 <EncapsedStringChildren as ::treesitter_types::FromNode>::from_node(
3240 child, src,
3241 )?,
3242 );
3243 }
3244 items
3245 },
3246 })
3247 }
3248}
3249impl ::treesitter_types::Spanned for EncapsedString<'_> {
3250 fn span(&self) -> ::treesitter_types::Span {
3251 self.span
3252 }
3253}
3254#[derive(Debug, Clone)]
3255pub struct EnumCase<'tree> {
3256 pub span: ::treesitter_types::Span,
3257 pub attributes: ::core::option::Option<AttributeList<'tree>>,
3258 pub name: Name<'tree>,
3259 pub value: ::core::option::Option<Expression<'tree>>,
3260}
3261impl<'tree> ::treesitter_types::FromNode<'tree> for EnumCase<'tree> {
3262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3263 fn from_node(
3264 node: ::tree_sitter::Node<'tree>,
3265 src: &'tree [u8],
3266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3267 debug_assert_eq!(node.kind(), "enum_case");
3268 Ok(Self {
3269 span: ::treesitter_types::Span::from(node),
3270 attributes: match node.child_by_field_name("attributes") {
3271 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
3272 child, src,
3273 )?),
3274 None => None,
3275 },
3276 name: {
3277 let child = node
3278 .child_by_field_name("name")
3279 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3280 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
3281 },
3282 value: match node.child_by_field_name("value") {
3283 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3284 child, src,
3285 )?),
3286 None => None,
3287 },
3288 })
3289 }
3290}
3291impl ::treesitter_types::Spanned for EnumCase<'_> {
3292 fn span(&self) -> ::treesitter_types::Span {
3293 self.span
3294 }
3295}
3296#[derive(Debug, Clone)]
3297pub struct EnumDeclaration<'tree> {
3298 pub span: ::treesitter_types::Span,
3299 pub attributes: ::core::option::Option<AttributeList<'tree>>,
3300 pub body: EnumDeclarationList<'tree>,
3301 pub name: Name<'tree>,
3302 pub children: ::std::vec::Vec<EnumDeclarationChildren<'tree>>,
3303}
3304impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
3305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3306 fn from_node(
3307 node: ::tree_sitter::Node<'tree>,
3308 src: &'tree [u8],
3309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3310 debug_assert_eq!(node.kind(), "enum_declaration");
3311 Ok(Self {
3312 span: ::treesitter_types::Span::from(node),
3313 attributes: match node.child_by_field_name("attributes") {
3314 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
3315 child, src,
3316 )?),
3317 None => None,
3318 },
3319 body: {
3320 let child = node
3321 .child_by_field_name("body")
3322 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3323 <EnumDeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
3324 },
3325 name: {
3326 let child = node
3327 .child_by_field_name("name")
3328 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3329 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
3330 },
3331 children: {
3332 #[allow(clippy::suspicious_else_formatting)]
3333 let non_field_children = {
3334 let mut cursor = node.walk();
3335 let mut result = ::std::vec::Vec::new();
3336 if cursor.goto_first_child() {
3337 loop {
3338 if cursor.field_name().is_none()
3339 && cursor.node().is_named()
3340 && !cursor.node().is_extra()
3341 {
3342 result.push(cursor.node());
3343 }
3344 if !cursor.goto_next_sibling() {
3345 break;
3346 }
3347 }
3348 }
3349 result
3350 };
3351 let mut items = ::std::vec::Vec::new();
3352 for child in non_field_children {
3353 items.push(
3354 <EnumDeclarationChildren as ::treesitter_types::FromNode>::from_node(
3355 child, src,
3356 )?,
3357 );
3358 }
3359 items
3360 },
3361 })
3362 }
3363}
3364impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
3365 fn span(&self) -> ::treesitter_types::Span {
3366 self.span
3367 }
3368}
3369#[derive(Debug, Clone)]
3370pub struct EnumDeclarationList<'tree> {
3371 pub span: ::treesitter_types::Span,
3372 pub children: ::std::vec::Vec<EnumDeclarationListChildren<'tree>>,
3373}
3374impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationList<'tree> {
3375 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3376 fn from_node(
3377 node: ::tree_sitter::Node<'tree>,
3378 src: &'tree [u8],
3379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3380 debug_assert_eq!(node.kind(), "enum_declaration_list");
3381 Ok(Self {
3382 span: ::treesitter_types::Span::from(node),
3383 children: {
3384 #[allow(clippy::suspicious_else_formatting)]
3385 let non_field_children = {
3386 let mut cursor = node.walk();
3387 let mut result = ::std::vec::Vec::new();
3388 if cursor.goto_first_child() {
3389 loop {
3390 if cursor.field_name().is_none()
3391 && cursor.node().is_named()
3392 && !cursor.node().is_extra()
3393 {
3394 result.push(cursor.node());
3395 }
3396 if !cursor.goto_next_sibling() {
3397 break;
3398 }
3399 }
3400 }
3401 result
3402 };
3403 let mut items = ::std::vec::Vec::new();
3404 for child in non_field_children {
3405 items.push(
3406 <EnumDeclarationListChildren as ::treesitter_types::FromNode>::from_node(
3407 child, src,
3408 )?,
3409 );
3410 }
3411 items
3412 },
3413 })
3414 }
3415}
3416impl ::treesitter_types::Spanned for EnumDeclarationList<'_> {
3417 fn span(&self) -> ::treesitter_types::Span {
3418 self.span
3419 }
3420}
3421#[derive(Debug, Clone)]
3422pub struct ErrorSuppressionExpression<'tree> {
3423 pub span: ::treesitter_types::Span,
3424 pub children: Expression<'tree>,
3425}
3426impl<'tree> ::treesitter_types::FromNode<'tree> for ErrorSuppressionExpression<'tree> {
3427 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3428 fn from_node(
3429 node: ::tree_sitter::Node<'tree>,
3430 src: &'tree [u8],
3431 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3432 debug_assert_eq!(node.kind(), "error_suppression_expression");
3433 Ok(Self {
3434 span: ::treesitter_types::Span::from(node),
3435 children: {
3436 #[allow(clippy::suspicious_else_formatting)]
3437 let non_field_children = {
3438 let mut cursor = node.walk();
3439 let mut result = ::std::vec::Vec::new();
3440 if cursor.goto_first_child() {
3441 loop {
3442 if cursor.field_name().is_none()
3443 && cursor.node().is_named()
3444 && !cursor.node().is_extra()
3445 {
3446 result.push(cursor.node());
3447 }
3448 if !cursor.goto_next_sibling() {
3449 break;
3450 }
3451 }
3452 }
3453 result
3454 };
3455 let child = if let Some(&c) = non_field_children.first() {
3456 c
3457 } else {
3458 let mut fallback_cursor = node.walk();
3459 let mut fallback_child = None;
3460 if fallback_cursor.goto_first_child() {
3461 loop {
3462 if fallback_cursor.field_name().is_none()
3463 && !fallback_cursor.node().is_extra()
3464 {
3465 let candidate = fallback_cursor.node();
3466 #[allow(clippy::needless_question_mark)]
3467 if (|| -> ::core::result::Result<
3468 _,
3469 ::treesitter_types::ParseError,
3470 > {
3471 let child = candidate;
3472 Ok(
3473 <Expression as ::treesitter_types::FromNode>::from_node(
3474 child,
3475 src,
3476 )?,
3477 )
3478 })()
3479 .is_ok()
3480 {
3481 fallback_child = Some(candidate);
3482 break;
3483 }
3484 }
3485 if !fallback_cursor.goto_next_sibling() {
3486 break;
3487 }
3488 }
3489 }
3490 if fallback_child.is_none() {
3491 let mut cursor2 = node.walk();
3492 if cursor2.goto_first_child() {
3493 loop {
3494 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3495 let candidate = cursor2.node();
3496 #[allow(clippy::needless_question_mark)]
3497 if (|| -> ::core::result::Result<
3498 _,
3499 ::treesitter_types::ParseError,
3500 > {
3501 let child = candidate;
3502 Ok(
3503 <Expression as ::treesitter_types::FromNode>::from_node(
3504 child,
3505 src,
3506 )?,
3507 )
3508 })()
3509 .is_ok()
3510 {
3511 fallback_child = Some(candidate);
3512 break;
3513 }
3514 }
3515 if !cursor2.goto_next_sibling() {
3516 break;
3517 }
3518 }
3519 }
3520 }
3521 fallback_child.ok_or_else(|| {
3522 ::treesitter_types::ParseError::missing_field("children", node)
3523 })?
3524 };
3525 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3526 },
3527 })
3528 }
3529}
3530impl ::treesitter_types::Spanned for ErrorSuppressionExpression<'_> {
3531 fn span(&self) -> ::treesitter_types::Span {
3532 self.span
3533 }
3534}
3535#[derive(Debug, Clone)]
3536pub struct ExitStatement<'tree> {
3537 pub span: ::treesitter_types::Span,
3538 pub children: ::core::option::Option<Expression<'tree>>,
3539}
3540impl<'tree> ::treesitter_types::FromNode<'tree> for ExitStatement<'tree> {
3541 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3542 fn from_node(
3543 node: ::tree_sitter::Node<'tree>,
3544 src: &'tree [u8],
3545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3546 debug_assert_eq!(node.kind(), "exit_statement");
3547 Ok(Self {
3548 span: ::treesitter_types::Span::from(node),
3549 children: {
3550 #[allow(clippy::suspicious_else_formatting)]
3551 let non_field_children = {
3552 let mut cursor = node.walk();
3553 let mut result = ::std::vec::Vec::new();
3554 if cursor.goto_first_child() {
3555 loop {
3556 if cursor.field_name().is_none()
3557 && cursor.node().is_named()
3558 && !cursor.node().is_extra()
3559 {
3560 result.push(cursor.node());
3561 }
3562 if !cursor.goto_next_sibling() {
3563 break;
3564 }
3565 }
3566 }
3567 result
3568 };
3569 match non_field_children.first() {
3570 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3571 child, src,
3572 )?),
3573 None => None,
3574 }
3575 },
3576 })
3577 }
3578}
3579impl ::treesitter_types::Spanned for ExitStatement<'_> {
3580 fn span(&self) -> ::treesitter_types::Span {
3581 self.span
3582 }
3583}
3584#[derive(Debug, Clone)]
3585pub struct ExpressionStatement<'tree> {
3586 pub span: ::treesitter_types::Span,
3587 pub children: Expression<'tree>,
3588}
3589impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3590 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3591 fn from_node(
3592 node: ::tree_sitter::Node<'tree>,
3593 src: &'tree [u8],
3594 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3595 debug_assert_eq!(node.kind(), "expression_statement");
3596 Ok(Self {
3597 span: ::treesitter_types::Span::from(node),
3598 children: {
3599 #[allow(clippy::suspicious_else_formatting)]
3600 let non_field_children = {
3601 let mut cursor = node.walk();
3602 let mut result = ::std::vec::Vec::new();
3603 if cursor.goto_first_child() {
3604 loop {
3605 if cursor.field_name().is_none()
3606 && cursor.node().is_named()
3607 && !cursor.node().is_extra()
3608 {
3609 result.push(cursor.node());
3610 }
3611 if !cursor.goto_next_sibling() {
3612 break;
3613 }
3614 }
3615 }
3616 result
3617 };
3618 let child = if let Some(&c) = non_field_children.first() {
3619 c
3620 } else {
3621 let mut fallback_cursor = node.walk();
3622 let mut fallback_child = None;
3623 if fallback_cursor.goto_first_child() {
3624 loop {
3625 if fallback_cursor.field_name().is_none()
3626 && !fallback_cursor.node().is_extra()
3627 {
3628 let candidate = fallback_cursor.node();
3629 #[allow(clippy::needless_question_mark)]
3630 if (|| -> ::core::result::Result<
3631 _,
3632 ::treesitter_types::ParseError,
3633 > {
3634 let child = candidate;
3635 Ok(
3636 <Expression as ::treesitter_types::FromNode>::from_node(
3637 child,
3638 src,
3639 )?,
3640 )
3641 })()
3642 .is_ok()
3643 {
3644 fallback_child = Some(candidate);
3645 break;
3646 }
3647 }
3648 if !fallback_cursor.goto_next_sibling() {
3649 break;
3650 }
3651 }
3652 }
3653 if fallback_child.is_none() {
3654 let mut cursor2 = node.walk();
3655 if cursor2.goto_first_child() {
3656 loop {
3657 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3658 let candidate = cursor2.node();
3659 #[allow(clippy::needless_question_mark)]
3660 if (|| -> ::core::result::Result<
3661 _,
3662 ::treesitter_types::ParseError,
3663 > {
3664 let child = candidate;
3665 Ok(
3666 <Expression as ::treesitter_types::FromNode>::from_node(
3667 child,
3668 src,
3669 )?,
3670 )
3671 })()
3672 .is_ok()
3673 {
3674 fallback_child = Some(candidate);
3675 break;
3676 }
3677 }
3678 if !cursor2.goto_next_sibling() {
3679 break;
3680 }
3681 }
3682 }
3683 }
3684 fallback_child.ok_or_else(|| {
3685 ::treesitter_types::ParseError::missing_field("children", node)
3686 })?
3687 };
3688 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3689 },
3690 })
3691 }
3692}
3693impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3694 fn span(&self) -> ::treesitter_types::Span {
3695 self.span
3696 }
3697}
3698#[derive(Debug, Clone)]
3699pub struct FinalModifier<'tree> {
3700 pub span: ::treesitter_types::Span,
3701 text: &'tree str,
3702}
3703impl<'tree> ::treesitter_types::FromNode<'tree> for FinalModifier<'tree> {
3704 fn from_node(
3705 node: ::tree_sitter::Node<'tree>,
3706 src: &'tree [u8],
3707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3708 debug_assert_eq!(node.kind(), "final_modifier");
3709 Ok(Self {
3710 span: ::treesitter_types::Span::from(node),
3711 text: node.utf8_text(src)?,
3712 })
3713 }
3714}
3715impl<'tree> ::treesitter_types::LeafNode<'tree> for FinalModifier<'tree> {
3716 fn text(&self) -> &'tree str {
3717 self.text
3718 }
3719}
3720impl ::treesitter_types::Spanned for FinalModifier<'_> {
3721 fn span(&self) -> ::treesitter_types::Span {
3722 self.span
3723 }
3724}
3725#[derive(Debug, Clone)]
3726pub struct FinallyClause<'tree> {
3727 pub span: ::treesitter_types::Span,
3728 pub body: CompoundStatement<'tree>,
3729}
3730impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3732 fn from_node(
3733 node: ::tree_sitter::Node<'tree>,
3734 src: &'tree [u8],
3735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3736 debug_assert_eq!(node.kind(), "finally_clause");
3737 Ok(Self {
3738 span: ::treesitter_types::Span::from(node),
3739 body: {
3740 let child = node
3741 .child_by_field_name("body")
3742 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3743 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
3744 },
3745 })
3746 }
3747}
3748impl ::treesitter_types::Spanned for FinallyClause<'_> {
3749 fn span(&self) -> ::treesitter_types::Span {
3750 self.span
3751 }
3752}
3753#[derive(Debug, Clone)]
3754pub struct ForStatement<'tree> {
3755 pub span: ::treesitter_types::Span,
3756 pub body: ::std::vec::Vec<Statement<'tree>>,
3757 pub condition: ::core::option::Option<ForStatementCondition<'tree>>,
3758 pub initialize: ::core::option::Option<ForStatementInitialize<'tree>>,
3759 pub update: ::core::option::Option<ForStatementUpdate<'tree>>,
3760}
3761impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3762 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3763 fn from_node(
3764 node: ::tree_sitter::Node<'tree>,
3765 src: &'tree [u8],
3766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3767 debug_assert_eq!(node.kind(), "for_statement");
3768 Ok(Self {
3769 span: ::treesitter_types::Span::from(node),
3770 body: {
3771 let mut cursor = node.walk();
3772 let mut items = ::std::vec::Vec::new();
3773 for child in node.children_by_field_name("body", &mut cursor) {
3774 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
3775 child, src,
3776 )?);
3777 }
3778 items
3779 },
3780 condition: match node.child_by_field_name("condition") {
3781 Some(child) => Some(
3782 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(child, src)?,
3783 ),
3784 None => None,
3785 },
3786 initialize: match node.child_by_field_name("initialize") {
3787 Some(child) => Some(
3788 <ForStatementInitialize as ::treesitter_types::FromNode>::from_node(
3789 child, src,
3790 )?,
3791 ),
3792 None => None,
3793 },
3794 update: match node.child_by_field_name("update") {
3795 Some(child) => Some(
3796 <ForStatementUpdate as ::treesitter_types::FromNode>::from_node(child, src)?,
3797 ),
3798 None => None,
3799 },
3800 })
3801 }
3802}
3803impl ::treesitter_types::Spanned for ForStatement<'_> {
3804 fn span(&self) -> ::treesitter_types::Span {
3805 self.span
3806 }
3807}
3808#[derive(Debug, Clone)]
3809pub struct ForeachStatement<'tree> {
3810 pub span: ::treesitter_types::Span,
3811 pub body: ::core::option::Option<ForeachStatementBody<'tree>>,
3812 pub children: ::std::vec::Vec<ForeachStatementChildren<'tree>>,
3813}
3814impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatement<'tree> {
3815 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3816 fn from_node(
3817 node: ::tree_sitter::Node<'tree>,
3818 src: &'tree [u8],
3819 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3820 debug_assert_eq!(node.kind(), "foreach_statement");
3821 Ok(Self {
3822 span: ::treesitter_types::Span::from(node),
3823 body: match node.child_by_field_name("body") {
3824 Some(child) => Some(
3825 <ForeachStatementBody as ::treesitter_types::FromNode>::from_node(child, src)?,
3826 ),
3827 None => None,
3828 },
3829 children: {
3830 #[allow(clippy::suspicious_else_formatting)]
3831 let non_field_children = {
3832 let mut cursor = node.walk();
3833 let mut result = ::std::vec::Vec::new();
3834 if cursor.goto_first_child() {
3835 loop {
3836 if cursor.field_name().is_none()
3837 && cursor.node().is_named()
3838 && !cursor.node().is_extra()
3839 {
3840 result.push(cursor.node());
3841 }
3842 if !cursor.goto_next_sibling() {
3843 break;
3844 }
3845 }
3846 }
3847 result
3848 };
3849 let mut items = ::std::vec::Vec::new();
3850 for child in non_field_children {
3851 items.push(
3852 <ForeachStatementChildren as ::treesitter_types::FromNode>::from_node(
3853 child, src,
3854 )?,
3855 );
3856 }
3857 items
3858 },
3859 })
3860 }
3861}
3862impl ::treesitter_types::Spanned for ForeachStatement<'_> {
3863 fn span(&self) -> ::treesitter_types::Span {
3864 self.span
3865 }
3866}
3867#[derive(Debug, Clone)]
3868pub struct FormalParameters<'tree> {
3869 pub span: ::treesitter_types::Span,
3870 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
3871}
3872impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
3873 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3874 fn from_node(
3875 node: ::tree_sitter::Node<'tree>,
3876 src: &'tree [u8],
3877 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3878 debug_assert_eq!(node.kind(), "formal_parameters");
3879 Ok(Self {
3880 span: ::treesitter_types::Span::from(node),
3881 children: {
3882 #[allow(clippy::suspicious_else_formatting)]
3883 let non_field_children = {
3884 let mut cursor = node.walk();
3885 let mut result = ::std::vec::Vec::new();
3886 if cursor.goto_first_child() {
3887 loop {
3888 if cursor.field_name().is_none()
3889 && cursor.node().is_named()
3890 && !cursor.node().is_extra()
3891 {
3892 result.push(cursor.node());
3893 }
3894 if !cursor.goto_next_sibling() {
3895 break;
3896 }
3897 }
3898 }
3899 result
3900 };
3901 let mut items = ::std::vec::Vec::new();
3902 for child in non_field_children {
3903 items.push(
3904 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
3905 child, src,
3906 )?,
3907 );
3908 }
3909 items
3910 },
3911 })
3912 }
3913}
3914impl ::treesitter_types::Spanned for FormalParameters<'_> {
3915 fn span(&self) -> ::treesitter_types::Span {
3916 self.span
3917 }
3918}
3919#[derive(Debug, Clone)]
3920pub struct FunctionCallExpression<'tree> {
3921 pub span: ::treesitter_types::Span,
3922 pub arguments: Arguments<'tree>,
3923 pub function: FunctionCallExpressionFunction<'tree>,
3924}
3925impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCallExpression<'tree> {
3926 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3927 fn from_node(
3928 node: ::tree_sitter::Node<'tree>,
3929 src: &'tree [u8],
3930 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3931 debug_assert_eq!(node.kind(), "function_call_expression");
3932 Ok(Self {
3933 span: ::treesitter_types::Span::from(node),
3934 arguments: {
3935 let child = node.child_by_field_name("arguments").ok_or_else(|| {
3936 ::treesitter_types::ParseError::missing_field("arguments", node)
3937 })?;
3938 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
3939 },
3940 function: {
3941 let child = node.child_by_field_name("function").ok_or_else(|| {
3942 ::treesitter_types::ParseError::missing_field("function", node)
3943 })?;
3944 <FunctionCallExpressionFunction as ::treesitter_types::FromNode>::from_node(
3945 child, src,
3946 )?
3947 },
3948 })
3949 }
3950}
3951impl ::treesitter_types::Spanned for FunctionCallExpression<'_> {
3952 fn span(&self) -> ::treesitter_types::Span {
3953 self.span
3954 }
3955}
3956#[derive(Debug, Clone)]
3957pub struct FunctionDefinition<'tree> {
3958 pub span: ::treesitter_types::Span,
3959 pub attributes: ::core::option::Option<AttributeList<'tree>>,
3960 pub body: CompoundStatement<'tree>,
3961 pub name: Name<'tree>,
3962 pub parameters: FormalParameters<'tree>,
3963 pub return_type: ::core::option::Option<FunctionDefinitionReturnType<'tree>>,
3964 pub children: ::core::option::Option<ReferenceModifier<'tree>>,
3965}
3966impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinition<'tree> {
3967 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3968 fn from_node(
3969 node: ::tree_sitter::Node<'tree>,
3970 src: &'tree [u8],
3971 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3972 debug_assert_eq!(node.kind(), "function_definition");
3973 Ok(Self {
3974 span: ::treesitter_types::Span::from(node),
3975 attributes: match node.child_by_field_name("attributes") {
3976 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
3977 child, src,
3978 )?),
3979 None => None,
3980 },
3981 body: {
3982 let child = node
3983 .child_by_field_name("body")
3984 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3985 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
3986 },
3987 name: {
3988 let child = node
3989 .child_by_field_name("name")
3990 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3991 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
3992 },
3993 parameters: {
3994 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3995 ::treesitter_types::ParseError::missing_field("parameters", node)
3996 })?;
3997 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3998 },
3999 return_type: match node.child_by_field_name("return_type") {
4000 Some(child) => Some(
4001 <FunctionDefinitionReturnType as ::treesitter_types::FromNode>::from_node(
4002 child, src,
4003 )?,
4004 ),
4005 None => None,
4006 },
4007 children: {
4008 #[allow(clippy::suspicious_else_formatting)]
4009 let non_field_children = {
4010 let mut cursor = node.walk();
4011 let mut result = ::std::vec::Vec::new();
4012 if cursor.goto_first_child() {
4013 loop {
4014 if cursor.field_name().is_none()
4015 && cursor.node().is_named()
4016 && !cursor.node().is_extra()
4017 {
4018 result.push(cursor.node());
4019 }
4020 if !cursor.goto_next_sibling() {
4021 break;
4022 }
4023 }
4024 }
4025 result
4026 };
4027 match non_field_children.first() {
4028 Some(&child) => Some(
4029 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
4030 ),
4031 None => None,
4032 }
4033 },
4034 })
4035 }
4036}
4037impl ::treesitter_types::Spanned for FunctionDefinition<'_> {
4038 fn span(&self) -> ::treesitter_types::Span {
4039 self.span
4040 }
4041}
4042#[derive(Debug, Clone)]
4043pub struct FunctionStaticDeclaration<'tree> {
4044 pub span: ::treesitter_types::Span,
4045 pub children: ::std::vec::Vec<StaticVariableDeclaration<'tree>>,
4046}
4047impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionStaticDeclaration<'tree> {
4048 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4049 fn from_node(
4050 node: ::tree_sitter::Node<'tree>,
4051 src: &'tree [u8],
4052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4053 debug_assert_eq!(node.kind(), "function_static_declaration");
4054 Ok(Self {
4055 span: ::treesitter_types::Span::from(node),
4056 children: {
4057 #[allow(clippy::suspicious_else_formatting)]
4058 let non_field_children = {
4059 let mut cursor = node.walk();
4060 let mut result = ::std::vec::Vec::new();
4061 if cursor.goto_first_child() {
4062 loop {
4063 if cursor.field_name().is_none()
4064 && cursor.node().is_named()
4065 && !cursor.node().is_extra()
4066 {
4067 result.push(cursor.node());
4068 }
4069 if !cursor.goto_next_sibling() {
4070 break;
4071 }
4072 }
4073 }
4074 result
4075 };
4076 let mut items = ::std::vec::Vec::new();
4077 for child in non_field_children {
4078 items.push(
4079 <StaticVariableDeclaration as ::treesitter_types::FromNode>::from_node(
4080 child, src,
4081 )?,
4082 );
4083 }
4084 items
4085 },
4086 })
4087 }
4088}
4089impl ::treesitter_types::Spanned for FunctionStaticDeclaration<'_> {
4090 fn span(&self) -> ::treesitter_types::Span {
4091 self.span
4092 }
4093}
4094#[derive(Debug, Clone)]
4095pub struct GlobalDeclaration<'tree> {
4096 pub span: ::treesitter_types::Span,
4097 pub children: ::std::vec::Vec<GlobalDeclarationChildren<'tree>>,
4098}
4099impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalDeclaration<'tree> {
4100 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4101 fn from_node(
4102 node: ::tree_sitter::Node<'tree>,
4103 src: &'tree [u8],
4104 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4105 debug_assert_eq!(node.kind(), "global_declaration");
4106 Ok(Self {
4107 span: ::treesitter_types::Span::from(node),
4108 children: {
4109 #[allow(clippy::suspicious_else_formatting)]
4110 let non_field_children = {
4111 let mut cursor = node.walk();
4112 let mut result = ::std::vec::Vec::new();
4113 if cursor.goto_first_child() {
4114 loop {
4115 if cursor.field_name().is_none()
4116 && cursor.node().is_named()
4117 && !cursor.node().is_extra()
4118 {
4119 result.push(cursor.node());
4120 }
4121 if !cursor.goto_next_sibling() {
4122 break;
4123 }
4124 }
4125 }
4126 result
4127 };
4128 let mut items = ::std::vec::Vec::new();
4129 for child in non_field_children {
4130 items.push(
4131 <GlobalDeclarationChildren as ::treesitter_types::FromNode>::from_node(
4132 child, src,
4133 )?,
4134 );
4135 }
4136 items
4137 },
4138 })
4139 }
4140}
4141impl ::treesitter_types::Spanned for GlobalDeclaration<'_> {
4142 fn span(&self) -> ::treesitter_types::Span {
4143 self.span
4144 }
4145}
4146#[derive(Debug, Clone)]
4147pub struct GotoStatement<'tree> {
4148 pub span: ::treesitter_types::Span,
4149 pub children: Name<'tree>,
4150}
4151impl<'tree> ::treesitter_types::FromNode<'tree> for GotoStatement<'tree> {
4152 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4153 fn from_node(
4154 node: ::tree_sitter::Node<'tree>,
4155 src: &'tree [u8],
4156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4157 debug_assert_eq!(node.kind(), "goto_statement");
4158 Ok(Self {
4159 span: ::treesitter_types::Span::from(node),
4160 children: {
4161 #[allow(clippy::suspicious_else_formatting)]
4162 let non_field_children = {
4163 let mut cursor = node.walk();
4164 let mut result = ::std::vec::Vec::new();
4165 if cursor.goto_first_child() {
4166 loop {
4167 if cursor.field_name().is_none()
4168 && cursor.node().is_named()
4169 && !cursor.node().is_extra()
4170 {
4171 result.push(cursor.node());
4172 }
4173 if !cursor.goto_next_sibling() {
4174 break;
4175 }
4176 }
4177 }
4178 result
4179 };
4180 let child = if let Some(&c) = non_field_children.first() {
4181 c
4182 } else {
4183 let mut fallback_cursor = node.walk();
4184 let mut fallback_child = None;
4185 if fallback_cursor.goto_first_child() {
4186 loop {
4187 if fallback_cursor.field_name().is_none()
4188 && !fallback_cursor.node().is_extra()
4189 {
4190 let candidate = fallback_cursor.node();
4191 #[allow(clippy::needless_question_mark)]
4192 if (|| -> ::core::result::Result<
4193 _,
4194 ::treesitter_types::ParseError,
4195 > {
4196 let child = candidate;
4197 Ok(
4198 <Name as ::treesitter_types::FromNode>::from_node(
4199 child,
4200 src,
4201 )?,
4202 )
4203 })()
4204 .is_ok()
4205 {
4206 fallback_child = Some(candidate);
4207 break;
4208 }
4209 }
4210 if !fallback_cursor.goto_next_sibling() {
4211 break;
4212 }
4213 }
4214 }
4215 if fallback_child.is_none() {
4216 let mut cursor2 = node.walk();
4217 if cursor2.goto_first_child() {
4218 loop {
4219 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4220 let candidate = cursor2.node();
4221 #[allow(clippy::needless_question_mark)]
4222 if (|| -> ::core::result::Result<
4223 _,
4224 ::treesitter_types::ParseError,
4225 > {
4226 let child = candidate;
4227 Ok(
4228 <Name as ::treesitter_types::FromNode>::from_node(
4229 child,
4230 src,
4231 )?,
4232 )
4233 })()
4234 .is_ok()
4235 {
4236 fallback_child = Some(candidate);
4237 break;
4238 }
4239 }
4240 if !cursor2.goto_next_sibling() {
4241 break;
4242 }
4243 }
4244 }
4245 }
4246 fallback_child.ok_or_else(|| {
4247 ::treesitter_types::ParseError::missing_field("children", node)
4248 })?
4249 };
4250 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
4251 },
4252 })
4253 }
4254}
4255impl ::treesitter_types::Spanned for GotoStatement<'_> {
4256 fn span(&self) -> ::treesitter_types::Span {
4257 self.span
4258 }
4259}
4260#[derive(Debug, Clone)]
4261pub struct Heredoc<'tree> {
4262 pub span: ::treesitter_types::Span,
4263 pub end_tag: HeredocEnd<'tree>,
4264 pub identifier: HeredocStart<'tree>,
4265 pub value: ::core::option::Option<HeredocBody<'tree>>,
4266}
4267impl<'tree> ::treesitter_types::FromNode<'tree> for Heredoc<'tree> {
4268 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4269 fn from_node(
4270 node: ::tree_sitter::Node<'tree>,
4271 src: &'tree [u8],
4272 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4273 debug_assert_eq!(node.kind(), "heredoc");
4274 Ok(Self {
4275 span: ::treesitter_types::Span::from(node),
4276 end_tag: {
4277 let child = node.child_by_field_name("end_tag").ok_or_else(|| {
4278 ::treesitter_types::ParseError::missing_field("end_tag", node)
4279 })?;
4280 <HeredocEnd as ::treesitter_types::FromNode>::from_node(child, src)?
4281 },
4282 identifier: {
4283 let child = node.child_by_field_name("identifier").ok_or_else(|| {
4284 ::treesitter_types::ParseError::missing_field("identifier", node)
4285 })?;
4286 <HeredocStart as ::treesitter_types::FromNode>::from_node(child, src)?
4287 },
4288 value: match node.child_by_field_name("value") {
4289 Some(child) => Some(<HeredocBody as ::treesitter_types::FromNode>::from_node(
4290 child, src,
4291 )?),
4292 None => None,
4293 },
4294 })
4295 }
4296}
4297impl ::treesitter_types::Spanned for Heredoc<'_> {
4298 fn span(&self) -> ::treesitter_types::Span {
4299 self.span
4300 }
4301}
4302#[derive(Debug, Clone)]
4303pub struct HeredocBody<'tree> {
4304 pub span: ::treesitter_types::Span,
4305 pub children: ::std::vec::Vec<HeredocBodyChildren<'tree>>,
4306}
4307impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBody<'tree> {
4308 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4309 fn from_node(
4310 node: ::tree_sitter::Node<'tree>,
4311 src: &'tree [u8],
4312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4313 debug_assert_eq!(node.kind(), "heredoc_body");
4314 Ok(Self {
4315 span: ::treesitter_types::Span::from(node),
4316 children: {
4317 #[allow(clippy::suspicious_else_formatting)]
4318 let non_field_children = {
4319 let mut cursor = node.walk();
4320 let mut result = ::std::vec::Vec::new();
4321 if cursor.goto_first_child() {
4322 loop {
4323 if cursor.field_name().is_none()
4324 && cursor.node().is_named()
4325 && !cursor.node().is_extra()
4326 {
4327 result.push(cursor.node());
4328 }
4329 if !cursor.goto_next_sibling() {
4330 break;
4331 }
4332 }
4333 }
4334 result
4335 };
4336 let mut items = ::std::vec::Vec::new();
4337 for child in non_field_children {
4338 items.push(
4339 <HeredocBodyChildren as ::treesitter_types::FromNode>::from_node(
4340 child, src,
4341 )?,
4342 );
4343 }
4344 items
4345 },
4346 })
4347 }
4348}
4349impl ::treesitter_types::Spanned for HeredocBody<'_> {
4350 fn span(&self) -> ::treesitter_types::Span {
4351 self.span
4352 }
4353}
4354#[derive(Debug, Clone)]
4355pub struct IfStatement<'tree> {
4356 pub span: ::treesitter_types::Span,
4357 pub alternative: ::std::vec::Vec<IfStatementAlternative<'tree>>,
4358 pub body: IfStatementBody<'tree>,
4359 pub condition: ParenthesizedExpression<'tree>,
4360}
4361impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
4362 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4363 fn from_node(
4364 node: ::tree_sitter::Node<'tree>,
4365 src: &'tree [u8],
4366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4367 debug_assert_eq!(node.kind(), "if_statement");
4368 Ok(Self {
4369 span: ::treesitter_types::Span::from(node),
4370 alternative: {
4371 let mut cursor = node.walk();
4372 let mut items = ::std::vec::Vec::new();
4373 for child in node.children_by_field_name("alternative", &mut cursor) {
4374 items.push(
4375 <IfStatementAlternative as ::treesitter_types::FromNode>::from_node(
4376 child, src,
4377 )?,
4378 );
4379 }
4380 items
4381 },
4382 body: {
4383 let child = node
4384 .child_by_field_name("body")
4385 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4386 <IfStatementBody as ::treesitter_types::FromNode>::from_node(child, src)?
4387 },
4388 condition: {
4389 let child = node.child_by_field_name("condition").ok_or_else(|| {
4390 ::treesitter_types::ParseError::missing_field("condition", node)
4391 })?;
4392 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
4393 },
4394 })
4395 }
4396}
4397impl ::treesitter_types::Spanned for IfStatement<'_> {
4398 fn span(&self) -> ::treesitter_types::Span {
4399 self.span
4400 }
4401}
4402#[derive(Debug, Clone)]
4403pub struct IncludeExpression<'tree> {
4404 pub span: ::treesitter_types::Span,
4405 pub children: Expression<'tree>,
4406}
4407impl<'tree> ::treesitter_types::FromNode<'tree> for IncludeExpression<'tree> {
4408 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4409 fn from_node(
4410 node: ::tree_sitter::Node<'tree>,
4411 src: &'tree [u8],
4412 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4413 debug_assert_eq!(node.kind(), "include_expression");
4414 Ok(Self {
4415 span: ::treesitter_types::Span::from(node),
4416 children: {
4417 #[allow(clippy::suspicious_else_formatting)]
4418 let non_field_children = {
4419 let mut cursor = node.walk();
4420 let mut result = ::std::vec::Vec::new();
4421 if cursor.goto_first_child() {
4422 loop {
4423 if cursor.field_name().is_none()
4424 && cursor.node().is_named()
4425 && !cursor.node().is_extra()
4426 {
4427 result.push(cursor.node());
4428 }
4429 if !cursor.goto_next_sibling() {
4430 break;
4431 }
4432 }
4433 }
4434 result
4435 };
4436 let child = if let Some(&c) = non_field_children.first() {
4437 c
4438 } else {
4439 let mut fallback_cursor = node.walk();
4440 let mut fallback_child = None;
4441 if fallback_cursor.goto_first_child() {
4442 loop {
4443 if fallback_cursor.field_name().is_none()
4444 && !fallback_cursor.node().is_extra()
4445 {
4446 let candidate = fallback_cursor.node();
4447 #[allow(clippy::needless_question_mark)]
4448 if (|| -> ::core::result::Result<
4449 _,
4450 ::treesitter_types::ParseError,
4451 > {
4452 let child = candidate;
4453 Ok(
4454 <Expression as ::treesitter_types::FromNode>::from_node(
4455 child,
4456 src,
4457 )?,
4458 )
4459 })()
4460 .is_ok()
4461 {
4462 fallback_child = Some(candidate);
4463 break;
4464 }
4465 }
4466 if !fallback_cursor.goto_next_sibling() {
4467 break;
4468 }
4469 }
4470 }
4471 if fallback_child.is_none() {
4472 let mut cursor2 = node.walk();
4473 if cursor2.goto_first_child() {
4474 loop {
4475 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4476 let candidate = cursor2.node();
4477 #[allow(clippy::needless_question_mark)]
4478 if (|| -> ::core::result::Result<
4479 _,
4480 ::treesitter_types::ParseError,
4481 > {
4482 let child = candidate;
4483 Ok(
4484 <Expression as ::treesitter_types::FromNode>::from_node(
4485 child,
4486 src,
4487 )?,
4488 )
4489 })()
4490 .is_ok()
4491 {
4492 fallback_child = Some(candidate);
4493 break;
4494 }
4495 }
4496 if !cursor2.goto_next_sibling() {
4497 break;
4498 }
4499 }
4500 }
4501 }
4502 fallback_child.ok_or_else(|| {
4503 ::treesitter_types::ParseError::missing_field("children", node)
4504 })?
4505 };
4506 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4507 },
4508 })
4509 }
4510}
4511impl ::treesitter_types::Spanned for IncludeExpression<'_> {
4512 fn span(&self) -> ::treesitter_types::Span {
4513 self.span
4514 }
4515}
4516#[derive(Debug, Clone)]
4517pub struct IncludeOnceExpression<'tree> {
4518 pub span: ::treesitter_types::Span,
4519 pub children: Expression<'tree>,
4520}
4521impl<'tree> ::treesitter_types::FromNode<'tree> for IncludeOnceExpression<'tree> {
4522 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4523 fn from_node(
4524 node: ::tree_sitter::Node<'tree>,
4525 src: &'tree [u8],
4526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4527 debug_assert_eq!(node.kind(), "include_once_expression");
4528 Ok(Self {
4529 span: ::treesitter_types::Span::from(node),
4530 children: {
4531 #[allow(clippy::suspicious_else_formatting)]
4532 let non_field_children = {
4533 let mut cursor = node.walk();
4534 let mut result = ::std::vec::Vec::new();
4535 if cursor.goto_first_child() {
4536 loop {
4537 if cursor.field_name().is_none()
4538 && cursor.node().is_named()
4539 && !cursor.node().is_extra()
4540 {
4541 result.push(cursor.node());
4542 }
4543 if !cursor.goto_next_sibling() {
4544 break;
4545 }
4546 }
4547 }
4548 result
4549 };
4550 let child = if let Some(&c) = non_field_children.first() {
4551 c
4552 } else {
4553 let mut fallback_cursor = node.walk();
4554 let mut fallback_child = None;
4555 if fallback_cursor.goto_first_child() {
4556 loop {
4557 if fallback_cursor.field_name().is_none()
4558 && !fallback_cursor.node().is_extra()
4559 {
4560 let candidate = fallback_cursor.node();
4561 #[allow(clippy::needless_question_mark)]
4562 if (|| -> ::core::result::Result<
4563 _,
4564 ::treesitter_types::ParseError,
4565 > {
4566 let child = candidate;
4567 Ok(
4568 <Expression as ::treesitter_types::FromNode>::from_node(
4569 child,
4570 src,
4571 )?,
4572 )
4573 })()
4574 .is_ok()
4575 {
4576 fallback_child = Some(candidate);
4577 break;
4578 }
4579 }
4580 if !fallback_cursor.goto_next_sibling() {
4581 break;
4582 }
4583 }
4584 }
4585 if fallback_child.is_none() {
4586 let mut cursor2 = node.walk();
4587 if cursor2.goto_first_child() {
4588 loop {
4589 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4590 let candidate = cursor2.node();
4591 #[allow(clippy::needless_question_mark)]
4592 if (|| -> ::core::result::Result<
4593 _,
4594 ::treesitter_types::ParseError,
4595 > {
4596 let child = candidate;
4597 Ok(
4598 <Expression as ::treesitter_types::FromNode>::from_node(
4599 child,
4600 src,
4601 )?,
4602 )
4603 })()
4604 .is_ok()
4605 {
4606 fallback_child = Some(candidate);
4607 break;
4608 }
4609 }
4610 if !cursor2.goto_next_sibling() {
4611 break;
4612 }
4613 }
4614 }
4615 }
4616 fallback_child.ok_or_else(|| {
4617 ::treesitter_types::ParseError::missing_field("children", node)
4618 })?
4619 };
4620 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4621 },
4622 })
4623 }
4624}
4625impl ::treesitter_types::Spanned for IncludeOnceExpression<'_> {
4626 fn span(&self) -> ::treesitter_types::Span {
4627 self.span
4628 }
4629}
4630#[derive(Debug, Clone)]
4631pub struct InterfaceDeclaration<'tree> {
4632 pub span: ::treesitter_types::Span,
4633 pub attributes: ::core::option::Option<AttributeList<'tree>>,
4634 pub body: DeclarationList<'tree>,
4635 pub name: Name<'tree>,
4636 pub children: ::core::option::Option<BaseClause<'tree>>,
4637}
4638impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
4639 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4640 fn from_node(
4641 node: ::tree_sitter::Node<'tree>,
4642 src: &'tree [u8],
4643 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4644 debug_assert_eq!(node.kind(), "interface_declaration");
4645 Ok(Self {
4646 span: ::treesitter_types::Span::from(node),
4647 attributes: match node.child_by_field_name("attributes") {
4648 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
4649 child, src,
4650 )?),
4651 None => None,
4652 },
4653 body: {
4654 let child = node
4655 .child_by_field_name("body")
4656 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4657 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
4658 },
4659 name: {
4660 let child = node
4661 .child_by_field_name("name")
4662 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4663 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
4664 },
4665 children: {
4666 #[allow(clippy::suspicious_else_formatting)]
4667 let non_field_children = {
4668 let mut cursor = node.walk();
4669 let mut result = ::std::vec::Vec::new();
4670 if cursor.goto_first_child() {
4671 loop {
4672 if cursor.field_name().is_none()
4673 && cursor.node().is_named()
4674 && !cursor.node().is_extra()
4675 {
4676 result.push(cursor.node());
4677 }
4678 if !cursor.goto_next_sibling() {
4679 break;
4680 }
4681 }
4682 }
4683 result
4684 };
4685 match non_field_children.first() {
4686 Some(&child) => Some(<BaseClause as ::treesitter_types::FromNode>::from_node(
4687 child, src,
4688 )?),
4689 None => None,
4690 }
4691 },
4692 })
4693 }
4694}
4695impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
4696 fn span(&self) -> ::treesitter_types::Span {
4697 self.span
4698 }
4699}
4700#[derive(Debug, Clone)]
4701pub struct IntersectionType<'tree> {
4702 pub span: ::treesitter_types::Span,
4703 pub children: ::std::vec::Vec<IntersectionTypeChildren<'tree>>,
4704}
4705impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionType<'tree> {
4706 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4707 fn from_node(
4708 node: ::tree_sitter::Node<'tree>,
4709 src: &'tree [u8],
4710 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4711 debug_assert_eq!(node.kind(), "intersection_type");
4712 Ok(Self {
4713 span: ::treesitter_types::Span::from(node),
4714 children: {
4715 #[allow(clippy::suspicious_else_formatting)]
4716 let non_field_children = {
4717 let mut cursor = node.walk();
4718 let mut result = ::std::vec::Vec::new();
4719 if cursor.goto_first_child() {
4720 loop {
4721 if cursor.field_name().is_none()
4722 && cursor.node().is_named()
4723 && !cursor.node().is_extra()
4724 {
4725 result.push(cursor.node());
4726 }
4727 if !cursor.goto_next_sibling() {
4728 break;
4729 }
4730 }
4731 }
4732 result
4733 };
4734 let mut items = ::std::vec::Vec::new();
4735 for child in non_field_children {
4736 items.push(
4737 <IntersectionTypeChildren as ::treesitter_types::FromNode>::from_node(
4738 child, src,
4739 )?,
4740 );
4741 }
4742 items
4743 },
4744 })
4745 }
4746}
4747impl ::treesitter_types::Spanned for IntersectionType<'_> {
4748 fn span(&self) -> ::treesitter_types::Span {
4749 self.span
4750 }
4751}
4752#[derive(Debug, Clone)]
4753pub struct ListLiteral<'tree> {
4754 pub span: ::treesitter_types::Span,
4755 pub children: ::std::vec::Vec<ListLiteralChildren<'tree>>,
4756}
4757impl<'tree> ::treesitter_types::FromNode<'tree> for ListLiteral<'tree> {
4758 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4759 fn from_node(
4760 node: ::tree_sitter::Node<'tree>,
4761 src: &'tree [u8],
4762 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4763 debug_assert_eq!(node.kind(), "list_literal");
4764 Ok(Self {
4765 span: ::treesitter_types::Span::from(node),
4766 children: {
4767 #[allow(clippy::suspicious_else_formatting)]
4768 let non_field_children = {
4769 let mut cursor = node.walk();
4770 let mut result = ::std::vec::Vec::new();
4771 if cursor.goto_first_child() {
4772 loop {
4773 if cursor.field_name().is_none()
4774 && cursor.node().is_named()
4775 && !cursor.node().is_extra()
4776 {
4777 result.push(cursor.node());
4778 }
4779 if !cursor.goto_next_sibling() {
4780 break;
4781 }
4782 }
4783 }
4784 result
4785 };
4786 let mut items = ::std::vec::Vec::new();
4787 for child in non_field_children {
4788 items.push(
4789 <ListLiteralChildren as ::treesitter_types::FromNode>::from_node(
4790 child, src,
4791 )?,
4792 );
4793 }
4794 items
4795 },
4796 })
4797 }
4798}
4799impl ::treesitter_types::Spanned for ListLiteral<'_> {
4800 fn span(&self) -> ::treesitter_types::Span {
4801 self.span
4802 }
4803}
4804#[derive(Debug, Clone)]
4805pub struct MatchBlock<'tree> {
4806 pub span: ::treesitter_types::Span,
4807 pub children: ::std::vec::Vec<MatchBlockChildren<'tree>>,
4808}
4809impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlock<'tree> {
4810 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4811 fn from_node(
4812 node: ::tree_sitter::Node<'tree>,
4813 src: &'tree [u8],
4814 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4815 debug_assert_eq!(node.kind(), "match_block");
4816 Ok(Self {
4817 span: ::treesitter_types::Span::from(node),
4818 children: {
4819 #[allow(clippy::suspicious_else_formatting)]
4820 let non_field_children = {
4821 let mut cursor = node.walk();
4822 let mut result = ::std::vec::Vec::new();
4823 if cursor.goto_first_child() {
4824 loop {
4825 if cursor.field_name().is_none()
4826 && cursor.node().is_named()
4827 && !cursor.node().is_extra()
4828 {
4829 result.push(cursor.node());
4830 }
4831 if !cursor.goto_next_sibling() {
4832 break;
4833 }
4834 }
4835 }
4836 result
4837 };
4838 let mut items = ::std::vec::Vec::new();
4839 for child in non_field_children {
4840 items.push(
4841 <MatchBlockChildren as ::treesitter_types::FromNode>::from_node(
4842 child, src,
4843 )?,
4844 );
4845 }
4846 items
4847 },
4848 })
4849 }
4850}
4851impl ::treesitter_types::Spanned for MatchBlock<'_> {
4852 fn span(&self) -> ::treesitter_types::Span {
4853 self.span
4854 }
4855}
4856#[derive(Debug, Clone)]
4857pub struct MatchConditionList<'tree> {
4858 pub span: ::treesitter_types::Span,
4859 pub children: ::std::vec::Vec<Expression<'tree>>,
4860}
4861impl<'tree> ::treesitter_types::FromNode<'tree> for MatchConditionList<'tree> {
4862 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4863 fn from_node(
4864 node: ::tree_sitter::Node<'tree>,
4865 src: &'tree [u8],
4866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4867 debug_assert_eq!(node.kind(), "match_condition_list");
4868 Ok(Self {
4869 span: ::treesitter_types::Span::from(node),
4870 children: {
4871 #[allow(clippy::suspicious_else_formatting)]
4872 let non_field_children = {
4873 let mut cursor = node.walk();
4874 let mut result = ::std::vec::Vec::new();
4875 if cursor.goto_first_child() {
4876 loop {
4877 if cursor.field_name().is_none()
4878 && cursor.node().is_named()
4879 && !cursor.node().is_extra()
4880 {
4881 result.push(cursor.node());
4882 }
4883 if !cursor.goto_next_sibling() {
4884 break;
4885 }
4886 }
4887 }
4888 result
4889 };
4890 let mut items = ::std::vec::Vec::new();
4891 for child in non_field_children {
4892 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
4893 child, src,
4894 )?);
4895 }
4896 items
4897 },
4898 })
4899 }
4900}
4901impl ::treesitter_types::Spanned for MatchConditionList<'_> {
4902 fn span(&self) -> ::treesitter_types::Span {
4903 self.span
4904 }
4905}
4906#[derive(Debug, Clone)]
4907pub struct MatchConditionalExpression<'tree> {
4908 pub span: ::treesitter_types::Span,
4909 pub conditional_expressions: MatchConditionList<'tree>,
4910 pub return_expression: Expression<'tree>,
4911}
4912impl<'tree> ::treesitter_types::FromNode<'tree> for MatchConditionalExpression<'tree> {
4913 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4914 fn from_node(
4915 node: ::tree_sitter::Node<'tree>,
4916 src: &'tree [u8],
4917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4918 debug_assert_eq!(node.kind(), "match_conditional_expression");
4919 Ok(Self {
4920 span: ::treesitter_types::Span::from(node),
4921 conditional_expressions: {
4922 let child = node
4923 .child_by_field_name("conditional_expressions")
4924 .ok_or_else(|| {
4925 ::treesitter_types::ParseError::missing_field(
4926 "conditional_expressions",
4927 node,
4928 )
4929 })?;
4930 <MatchConditionList as ::treesitter_types::FromNode>::from_node(child, src)?
4931 },
4932 return_expression: {
4933 let child = node
4934 .child_by_field_name("return_expression")
4935 .ok_or_else(|| {
4936 ::treesitter_types::ParseError::missing_field("return_expression", node)
4937 })?;
4938 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4939 },
4940 })
4941 }
4942}
4943impl ::treesitter_types::Spanned for MatchConditionalExpression<'_> {
4944 fn span(&self) -> ::treesitter_types::Span {
4945 self.span
4946 }
4947}
4948#[derive(Debug, Clone)]
4949pub struct MatchDefaultExpression<'tree> {
4950 pub span: ::treesitter_types::Span,
4951 pub return_expression: Expression<'tree>,
4952}
4953impl<'tree> ::treesitter_types::FromNode<'tree> for MatchDefaultExpression<'tree> {
4954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4955 fn from_node(
4956 node: ::tree_sitter::Node<'tree>,
4957 src: &'tree [u8],
4958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4959 debug_assert_eq!(node.kind(), "match_default_expression");
4960 Ok(Self {
4961 span: ::treesitter_types::Span::from(node),
4962 return_expression: {
4963 let child = node
4964 .child_by_field_name("return_expression")
4965 .ok_or_else(|| {
4966 ::treesitter_types::ParseError::missing_field("return_expression", node)
4967 })?;
4968 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4969 },
4970 })
4971 }
4972}
4973impl ::treesitter_types::Spanned for MatchDefaultExpression<'_> {
4974 fn span(&self) -> ::treesitter_types::Span {
4975 self.span
4976 }
4977}
4978#[derive(Debug, Clone)]
4979pub struct MatchExpression<'tree> {
4980 pub span: ::treesitter_types::Span,
4981 pub body: MatchBlock<'tree>,
4982 pub condition: ParenthesizedExpression<'tree>,
4983}
4984impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
4985 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4986 fn from_node(
4987 node: ::tree_sitter::Node<'tree>,
4988 src: &'tree [u8],
4989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4990 debug_assert_eq!(node.kind(), "match_expression");
4991 Ok(Self {
4992 span: ::treesitter_types::Span::from(node),
4993 body: {
4994 let child = node
4995 .child_by_field_name("body")
4996 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4997 <MatchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
4998 },
4999 condition: {
5000 let child = node.child_by_field_name("condition").ok_or_else(|| {
5001 ::treesitter_types::ParseError::missing_field("condition", node)
5002 })?;
5003 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5004 },
5005 })
5006 }
5007}
5008impl ::treesitter_types::Spanned for MatchExpression<'_> {
5009 fn span(&self) -> ::treesitter_types::Span {
5010 self.span
5011 }
5012}
5013#[derive(Debug, Clone)]
5014pub struct MemberAccessExpression<'tree> {
5015 pub span: ::treesitter_types::Span,
5016 pub name: MemberAccessExpressionName<'tree>,
5017 pub object: MemberAccessExpressionObject<'tree>,
5018}
5019impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpression<'tree> {
5020 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5021 fn from_node(
5022 node: ::tree_sitter::Node<'tree>,
5023 src: &'tree [u8],
5024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5025 debug_assert_eq!(node.kind(), "member_access_expression");
5026 Ok(Self {
5027 span: ::treesitter_types::Span::from(node),
5028 name: {
5029 let child = node
5030 .child_by_field_name("name")
5031 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5032 <MemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
5033 },
5034 object: {
5035 let child = node
5036 .child_by_field_name("object")
5037 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5038 <MemberAccessExpressionObject as ::treesitter_types::FromNode>::from_node(
5039 child, src,
5040 )?
5041 },
5042 })
5043 }
5044}
5045impl ::treesitter_types::Spanned for MemberAccessExpression<'_> {
5046 fn span(&self) -> ::treesitter_types::Span {
5047 self.span
5048 }
5049}
5050#[derive(Debug, Clone)]
5051pub struct MemberCallExpression<'tree> {
5052 pub span: ::treesitter_types::Span,
5053 pub arguments: Arguments<'tree>,
5054 pub name: MemberCallExpressionName<'tree>,
5055 pub object: MemberCallExpressionObject<'tree>,
5056}
5057impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpression<'tree> {
5058 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5059 fn from_node(
5060 node: ::tree_sitter::Node<'tree>,
5061 src: &'tree [u8],
5062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5063 debug_assert_eq!(node.kind(), "member_call_expression");
5064 Ok(Self {
5065 span: ::treesitter_types::Span::from(node),
5066 arguments: {
5067 let child = node.child_by_field_name("arguments").ok_or_else(|| {
5068 ::treesitter_types::ParseError::missing_field("arguments", node)
5069 })?;
5070 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
5071 },
5072 name: {
5073 let child = node
5074 .child_by_field_name("name")
5075 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5076 <MemberCallExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
5077 },
5078 object: {
5079 let child = node
5080 .child_by_field_name("object")
5081 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5082 <MemberCallExpressionObject as ::treesitter_types::FromNode>::from_node(child, src)?
5083 },
5084 })
5085 }
5086}
5087impl ::treesitter_types::Spanned for MemberCallExpression<'_> {
5088 fn span(&self) -> ::treesitter_types::Span {
5089 self.span
5090 }
5091}
5092#[derive(Debug, Clone)]
5093pub struct MethodDeclaration<'tree> {
5094 pub span: ::treesitter_types::Span,
5095 pub attributes: ::core::option::Option<AttributeList<'tree>>,
5096 pub body: ::core::option::Option<CompoundStatement<'tree>>,
5097 pub name: Name<'tree>,
5098 pub parameters: FormalParameters<'tree>,
5099 pub return_type: ::core::option::Option<MethodDeclarationReturnType<'tree>>,
5100 pub children: ::std::vec::Vec<MethodDeclarationChildren<'tree>>,
5101}
5102impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclaration<'tree> {
5103 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5104 fn from_node(
5105 node: ::tree_sitter::Node<'tree>,
5106 src: &'tree [u8],
5107 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5108 debug_assert_eq!(node.kind(), "method_declaration");
5109 Ok(Self {
5110 span: ::treesitter_types::Span::from(node),
5111 attributes: match node.child_by_field_name("attributes") {
5112 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
5113 child, src,
5114 )?),
5115 None => None,
5116 },
5117 body: match node.child_by_field_name("body") {
5118 Some(child) => Some(
5119 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?,
5120 ),
5121 None => None,
5122 },
5123 name: {
5124 let child = node
5125 .child_by_field_name("name")
5126 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5127 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
5128 },
5129 parameters: {
5130 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5131 ::treesitter_types::ParseError::missing_field("parameters", node)
5132 })?;
5133 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
5134 },
5135 return_type: match node.child_by_field_name("return_type") {
5136 Some(child) => Some(
5137 <MethodDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
5138 child, src,
5139 )?,
5140 ),
5141 None => None,
5142 },
5143 children: {
5144 #[allow(clippy::suspicious_else_formatting)]
5145 let non_field_children = {
5146 let mut cursor = node.walk();
5147 let mut result = ::std::vec::Vec::new();
5148 if cursor.goto_first_child() {
5149 loop {
5150 if cursor.field_name().is_none()
5151 && cursor.node().is_named()
5152 && !cursor.node().is_extra()
5153 {
5154 result.push(cursor.node());
5155 }
5156 if !cursor.goto_next_sibling() {
5157 break;
5158 }
5159 }
5160 }
5161 result
5162 };
5163 let mut items = ::std::vec::Vec::new();
5164 for child in non_field_children {
5165 items.push(
5166 <MethodDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5167 child, src,
5168 )?,
5169 );
5170 }
5171 items
5172 },
5173 })
5174 }
5175}
5176impl ::treesitter_types::Spanned for MethodDeclaration<'_> {
5177 fn span(&self) -> ::treesitter_types::Span {
5178 self.span
5179 }
5180}
5181#[derive(Debug, Clone)]
5182pub struct Name<'tree> {
5183 pub span: ::treesitter_types::Span,
5184 text: &'tree str,
5185}
5186impl<'tree> ::treesitter_types::FromNode<'tree> for Name<'tree> {
5187 fn from_node(
5188 node: ::tree_sitter::Node<'tree>,
5189 src: &'tree [u8],
5190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5191 debug_assert_eq!(node.kind(), "name");
5192 Ok(Self {
5193 span: ::treesitter_types::Span::from(node),
5194 text: node.utf8_text(src)?,
5195 })
5196 }
5197}
5198impl<'tree> ::treesitter_types::LeafNode<'tree> for Name<'tree> {
5199 fn text(&self) -> &'tree str {
5200 self.text
5201 }
5202}
5203impl ::treesitter_types::Spanned for Name<'_> {
5204 fn span(&self) -> ::treesitter_types::Span {
5205 self.span
5206 }
5207}
5208#[derive(Debug, Clone)]
5209pub struct NamedLabelStatement<'tree> {
5210 pub span: ::treesitter_types::Span,
5211 pub children: Name<'tree>,
5212}
5213impl<'tree> ::treesitter_types::FromNode<'tree> for NamedLabelStatement<'tree> {
5214 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5215 fn from_node(
5216 node: ::tree_sitter::Node<'tree>,
5217 src: &'tree [u8],
5218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5219 debug_assert_eq!(node.kind(), "named_label_statement");
5220 Ok(Self {
5221 span: ::treesitter_types::Span::from(node),
5222 children: {
5223 #[allow(clippy::suspicious_else_formatting)]
5224 let non_field_children = {
5225 let mut cursor = node.walk();
5226 let mut result = ::std::vec::Vec::new();
5227 if cursor.goto_first_child() {
5228 loop {
5229 if cursor.field_name().is_none()
5230 && cursor.node().is_named()
5231 && !cursor.node().is_extra()
5232 {
5233 result.push(cursor.node());
5234 }
5235 if !cursor.goto_next_sibling() {
5236 break;
5237 }
5238 }
5239 }
5240 result
5241 };
5242 let child = if let Some(&c) = non_field_children.first() {
5243 c
5244 } else {
5245 let mut fallback_cursor = node.walk();
5246 let mut fallback_child = None;
5247 if fallback_cursor.goto_first_child() {
5248 loop {
5249 if fallback_cursor.field_name().is_none()
5250 && !fallback_cursor.node().is_extra()
5251 {
5252 let candidate = fallback_cursor.node();
5253 #[allow(clippy::needless_question_mark)]
5254 if (|| -> ::core::result::Result<
5255 _,
5256 ::treesitter_types::ParseError,
5257 > {
5258 let child = candidate;
5259 Ok(
5260 <Name as ::treesitter_types::FromNode>::from_node(
5261 child,
5262 src,
5263 )?,
5264 )
5265 })()
5266 .is_ok()
5267 {
5268 fallback_child = Some(candidate);
5269 break;
5270 }
5271 }
5272 if !fallback_cursor.goto_next_sibling() {
5273 break;
5274 }
5275 }
5276 }
5277 if fallback_child.is_none() {
5278 let mut cursor2 = node.walk();
5279 if cursor2.goto_first_child() {
5280 loop {
5281 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5282 let candidate = cursor2.node();
5283 #[allow(clippy::needless_question_mark)]
5284 if (|| -> ::core::result::Result<
5285 _,
5286 ::treesitter_types::ParseError,
5287 > {
5288 let child = candidate;
5289 Ok(
5290 <Name as ::treesitter_types::FromNode>::from_node(
5291 child,
5292 src,
5293 )?,
5294 )
5295 })()
5296 .is_ok()
5297 {
5298 fallback_child = Some(candidate);
5299 break;
5300 }
5301 }
5302 if !cursor2.goto_next_sibling() {
5303 break;
5304 }
5305 }
5306 }
5307 }
5308 fallback_child.ok_or_else(|| {
5309 ::treesitter_types::ParseError::missing_field("children", node)
5310 })?
5311 };
5312 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
5313 },
5314 })
5315 }
5316}
5317impl ::treesitter_types::Spanned for NamedLabelStatement<'_> {
5318 fn span(&self) -> ::treesitter_types::Span {
5319 self.span
5320 }
5321}
5322#[derive(Debug, Clone)]
5323pub struct NamedType<'tree> {
5324 pub span: ::treesitter_types::Span,
5325 pub children: NamedTypeChildren<'tree>,
5326}
5327impl<'tree> ::treesitter_types::FromNode<'tree> for NamedType<'tree> {
5328 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5329 fn from_node(
5330 node: ::tree_sitter::Node<'tree>,
5331 src: &'tree [u8],
5332 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5333 debug_assert_eq!(node.kind(), "named_type");
5334 Ok(Self {
5335 span: ::treesitter_types::Span::from(node),
5336 children: {
5337 #[allow(clippy::suspicious_else_formatting)]
5338 let non_field_children = {
5339 let mut cursor = node.walk();
5340 let mut result = ::std::vec::Vec::new();
5341 if cursor.goto_first_child() {
5342 loop {
5343 if cursor.field_name().is_none()
5344 && cursor.node().is_named()
5345 && !cursor.node().is_extra()
5346 {
5347 result.push(cursor.node());
5348 }
5349 if !cursor.goto_next_sibling() {
5350 break;
5351 }
5352 }
5353 }
5354 result
5355 };
5356 let child = if let Some(&c) = non_field_children.first() {
5357 c
5358 } else {
5359 let mut fallback_cursor = node.walk();
5360 let mut fallback_child = None;
5361 if fallback_cursor.goto_first_child() {
5362 loop {
5363 if fallback_cursor.field_name().is_none()
5364 && !fallback_cursor.node().is_extra()
5365 {
5366 let candidate = fallback_cursor.node();
5367 #[allow(clippy::needless_question_mark)]
5368 if (|| -> ::core::result::Result<
5369 _,
5370 ::treesitter_types::ParseError,
5371 > {
5372 let child = candidate;
5373 Ok(
5374 <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(
5375 child,
5376 src,
5377 )?,
5378 )
5379 })()
5380 .is_ok()
5381 {
5382 fallback_child = Some(candidate);
5383 break;
5384 }
5385 }
5386 if !fallback_cursor.goto_next_sibling() {
5387 break;
5388 }
5389 }
5390 }
5391 if fallback_child.is_none() {
5392 let mut cursor2 = node.walk();
5393 if cursor2.goto_first_child() {
5394 loop {
5395 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5396 let candidate = cursor2.node();
5397 #[allow(clippy::needless_question_mark)]
5398 if (|| -> ::core::result::Result<
5399 _,
5400 ::treesitter_types::ParseError,
5401 > {
5402 let child = candidate;
5403 Ok(
5404 <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(
5405 child,
5406 src,
5407 )?,
5408 )
5409 })()
5410 .is_ok()
5411 {
5412 fallback_child = Some(candidate);
5413 break;
5414 }
5415 }
5416 if !cursor2.goto_next_sibling() {
5417 break;
5418 }
5419 }
5420 }
5421 }
5422 fallback_child.ok_or_else(|| {
5423 ::treesitter_types::ParseError::missing_field("children", node)
5424 })?
5425 };
5426 <NamedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5427 },
5428 })
5429 }
5430}
5431impl ::treesitter_types::Spanned for NamedType<'_> {
5432 fn span(&self) -> ::treesitter_types::Span {
5433 self.span
5434 }
5435}
5436#[derive(Debug, Clone)]
5437pub struct NamespaceDefinition<'tree> {
5438 pub span: ::treesitter_types::Span,
5439 pub body: ::core::option::Option<CompoundStatement<'tree>>,
5440 pub name: ::core::option::Option<NamespaceName<'tree>>,
5441}
5442impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceDefinition<'tree> {
5443 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5444 fn from_node(
5445 node: ::tree_sitter::Node<'tree>,
5446 src: &'tree [u8],
5447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5448 debug_assert_eq!(node.kind(), "namespace_definition");
5449 Ok(Self {
5450 span: ::treesitter_types::Span::from(node),
5451 body: match node.child_by_field_name("body") {
5452 Some(child) => Some(
5453 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?,
5454 ),
5455 None => None,
5456 },
5457 name: match node.child_by_field_name("name") {
5458 Some(child) => Some(<NamespaceName as ::treesitter_types::FromNode>::from_node(
5459 child, src,
5460 )?),
5461 None => None,
5462 },
5463 })
5464 }
5465}
5466impl ::treesitter_types::Spanned for NamespaceDefinition<'_> {
5467 fn span(&self) -> ::treesitter_types::Span {
5468 self.span
5469 }
5470}
5471#[derive(Debug, Clone)]
5472pub struct NamespaceName<'tree> {
5473 pub span: ::treesitter_types::Span,
5474 pub children: ::std::vec::Vec<Name<'tree>>,
5475}
5476impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceName<'tree> {
5477 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5478 fn from_node(
5479 node: ::tree_sitter::Node<'tree>,
5480 src: &'tree [u8],
5481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5482 debug_assert_eq!(node.kind(), "namespace_name");
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 mut items = ::std::vec::Vec::new();
5506 for child in non_field_children {
5507 items.push(<Name as ::treesitter_types::FromNode>::from_node(
5508 child, src,
5509 )?);
5510 }
5511 items
5512 },
5513 })
5514 }
5515}
5516impl ::treesitter_types::Spanned for NamespaceName<'_> {
5517 fn span(&self) -> ::treesitter_types::Span {
5518 self.span
5519 }
5520}
5521#[derive(Debug, Clone)]
5522pub struct NamespaceUseClause<'tree> {
5523 pub span: ::treesitter_types::Span,
5524 pub alias: ::core::option::Option<Name<'tree>>,
5525 pub r#type: ::core::option::Option<NamespaceUseClauseType>,
5526 pub children: NamespaceUseClauseChildren<'tree>,
5527}
5528impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClause<'tree> {
5529 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5530 fn from_node(
5531 node: ::tree_sitter::Node<'tree>,
5532 src: &'tree [u8],
5533 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5534 debug_assert_eq!(node.kind(), "namespace_use_clause");
5535 Ok(Self {
5536 span: ::treesitter_types::Span::from(node),
5537 alias: match node.child_by_field_name("alias") {
5538 Some(child) => Some(<Name as ::treesitter_types::FromNode>::from_node(
5539 child, src,
5540 )?),
5541 None => None,
5542 },
5543 r#type: match node.child_by_field_name("type") {
5544 Some(child) => Some(
5545 <NamespaceUseClauseType as ::treesitter_types::FromNode>::from_node(
5546 child, src,
5547 )?,
5548 ),
5549 None => None,
5550 },
5551 children: {
5552 #[allow(clippy::suspicious_else_formatting)]
5553 let non_field_children = {
5554 let mut cursor = node.walk();
5555 let mut result = ::std::vec::Vec::new();
5556 if cursor.goto_first_child() {
5557 loop {
5558 if cursor.field_name().is_none()
5559 && cursor.node().is_named()
5560 && !cursor.node().is_extra()
5561 {
5562 result.push(cursor.node());
5563 }
5564 if !cursor.goto_next_sibling() {
5565 break;
5566 }
5567 }
5568 }
5569 result
5570 };
5571 let child = if let Some(&c) = non_field_children.first() {
5572 c
5573 } else {
5574 let mut fallback_cursor = node.walk();
5575 let mut fallback_child = None;
5576 if fallback_cursor.goto_first_child() {
5577 loop {
5578 if fallback_cursor.field_name().is_none()
5579 && !fallback_cursor.node().is_extra()
5580 {
5581 let candidate = fallback_cursor.node();
5582 #[allow(clippy::needless_question_mark)]
5583 if (|| -> ::core::result::Result<
5584 _,
5585 ::treesitter_types::ParseError,
5586 > {
5587 let child = candidate;
5588 Ok(
5589 <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(
5590 child,
5591 src,
5592 )?,
5593 )
5594 })()
5595 .is_ok()
5596 {
5597 fallback_child = Some(candidate);
5598 break;
5599 }
5600 }
5601 if !fallback_cursor.goto_next_sibling() {
5602 break;
5603 }
5604 }
5605 }
5606 if fallback_child.is_none() {
5607 let mut cursor2 = node.walk();
5608 if cursor2.goto_first_child() {
5609 loop {
5610 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5611 let candidate = cursor2.node();
5612 #[allow(clippy::needless_question_mark)]
5613 if (|| -> ::core::result::Result<
5614 _,
5615 ::treesitter_types::ParseError,
5616 > {
5617 let child = candidate;
5618 Ok(
5619 <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(
5620 child,
5621 src,
5622 )?,
5623 )
5624 })()
5625 .is_ok()
5626 {
5627 fallback_child = Some(candidate);
5628 break;
5629 }
5630 }
5631 if !cursor2.goto_next_sibling() {
5632 break;
5633 }
5634 }
5635 }
5636 }
5637 fallback_child.ok_or_else(|| {
5638 ::treesitter_types::ParseError::missing_field("children", node)
5639 })?
5640 };
5641 <NamespaceUseClauseChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5642 },
5643 })
5644 }
5645}
5646impl ::treesitter_types::Spanned for NamespaceUseClause<'_> {
5647 fn span(&self) -> ::treesitter_types::Span {
5648 self.span
5649 }
5650}
5651#[derive(Debug, Clone)]
5652pub struct NamespaceUseDeclaration<'tree> {
5653 pub span: ::treesitter_types::Span,
5654 pub body: ::core::option::Option<NamespaceUseGroup<'tree>>,
5655 pub r#type: ::core::option::Option<NamespaceUseDeclarationType>,
5656 pub children: ::std::vec::Vec<NamespaceUseDeclarationChildren<'tree>>,
5657}
5658impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclaration<'tree> {
5659 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5660 fn from_node(
5661 node: ::tree_sitter::Node<'tree>,
5662 src: &'tree [u8],
5663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5664 debug_assert_eq!(node.kind(), "namespace_use_declaration");
5665 Ok(Self {
5666 span: ::treesitter_types::Span::from(node),
5667 body: match node.child_by_field_name("body") {
5668 Some(child) => Some(
5669 <NamespaceUseGroup as ::treesitter_types::FromNode>::from_node(child, src)?,
5670 ),
5671 None => None,
5672 },
5673 r#type: match node.child_by_field_name("type") {
5674 Some(child) => Some(
5675 <NamespaceUseDeclarationType as ::treesitter_types::FromNode>::from_node(
5676 child, src,
5677 )?,
5678 ),
5679 None => None,
5680 },
5681 children: {
5682 #[allow(clippy::suspicious_else_formatting)]
5683 let non_field_children = {
5684 let mut cursor = node.walk();
5685 let mut result = ::std::vec::Vec::new();
5686 if cursor.goto_first_child() {
5687 loop {
5688 if cursor.field_name().is_none()
5689 && cursor.node().is_named()
5690 && !cursor.node().is_extra()
5691 {
5692 result.push(cursor.node());
5693 }
5694 if !cursor.goto_next_sibling() {
5695 break;
5696 }
5697 }
5698 }
5699 result
5700 };
5701 let mut items = ::std::vec::Vec::new();
5702 for child in non_field_children {
5703 items
5704 .push(
5705 <NamespaceUseDeclarationChildren as ::treesitter_types::FromNode>::from_node(
5706 child,
5707 src,
5708 )?,
5709 );
5710 }
5711 items
5712 },
5713 })
5714 }
5715}
5716impl ::treesitter_types::Spanned for NamespaceUseDeclaration<'_> {
5717 fn span(&self) -> ::treesitter_types::Span {
5718 self.span
5719 }
5720}
5721#[derive(Debug, Clone)]
5722pub struct NamespaceUseGroup<'tree> {
5723 pub span: ::treesitter_types::Span,
5724 pub children: ::std::vec::Vec<NamespaceUseClause<'tree>>,
5725}
5726impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseGroup<'tree> {
5727 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5728 fn from_node(
5729 node: ::tree_sitter::Node<'tree>,
5730 src: &'tree [u8],
5731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5732 debug_assert_eq!(node.kind(), "namespace_use_group");
5733 Ok(Self {
5734 span: ::treesitter_types::Span::from(node),
5735 children: {
5736 #[allow(clippy::suspicious_else_formatting)]
5737 let non_field_children = {
5738 let mut cursor = node.walk();
5739 let mut result = ::std::vec::Vec::new();
5740 if cursor.goto_first_child() {
5741 loop {
5742 if cursor.field_name().is_none()
5743 && cursor.node().is_named()
5744 && !cursor.node().is_extra()
5745 {
5746 result.push(cursor.node());
5747 }
5748 if !cursor.goto_next_sibling() {
5749 break;
5750 }
5751 }
5752 }
5753 result
5754 };
5755 let mut items = ::std::vec::Vec::new();
5756 for child in non_field_children {
5757 items.push(
5758 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(
5759 child, src,
5760 )?,
5761 );
5762 }
5763 items
5764 },
5765 })
5766 }
5767}
5768impl ::treesitter_types::Spanned for NamespaceUseGroup<'_> {
5769 fn span(&self) -> ::treesitter_types::Span {
5770 self.span
5771 }
5772}
5773#[derive(Debug, Clone)]
5774pub struct Nowdoc<'tree> {
5775 pub span: ::treesitter_types::Span,
5776 pub end_tag: HeredocEnd<'tree>,
5777 pub identifier: HeredocStart<'tree>,
5778 pub value: ::core::option::Option<NowdocBody<'tree>>,
5779}
5780impl<'tree> ::treesitter_types::FromNode<'tree> for Nowdoc<'tree> {
5781 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5782 fn from_node(
5783 node: ::tree_sitter::Node<'tree>,
5784 src: &'tree [u8],
5785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5786 debug_assert_eq!(node.kind(), "nowdoc");
5787 Ok(Self {
5788 span: ::treesitter_types::Span::from(node),
5789 end_tag: {
5790 let child = node.child_by_field_name("end_tag").ok_or_else(|| {
5791 ::treesitter_types::ParseError::missing_field("end_tag", node)
5792 })?;
5793 <HeredocEnd as ::treesitter_types::FromNode>::from_node(child, src)?
5794 },
5795 identifier: {
5796 let child = node.child_by_field_name("identifier").ok_or_else(|| {
5797 ::treesitter_types::ParseError::missing_field("identifier", node)
5798 })?;
5799 <HeredocStart as ::treesitter_types::FromNode>::from_node(child, src)?
5800 },
5801 value: match node.child_by_field_name("value") {
5802 Some(child) => Some(<NowdocBody as ::treesitter_types::FromNode>::from_node(
5803 child, src,
5804 )?),
5805 None => None,
5806 },
5807 })
5808 }
5809}
5810impl ::treesitter_types::Spanned for Nowdoc<'_> {
5811 fn span(&self) -> ::treesitter_types::Span {
5812 self.span
5813 }
5814}
5815#[derive(Debug, Clone)]
5816pub struct NowdocBody<'tree> {
5817 pub span: ::treesitter_types::Span,
5818 pub children: ::std::vec::Vec<NowdocString<'tree>>,
5819}
5820impl<'tree> ::treesitter_types::FromNode<'tree> for NowdocBody<'tree> {
5821 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5822 fn from_node(
5823 node: ::tree_sitter::Node<'tree>,
5824 src: &'tree [u8],
5825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5826 debug_assert_eq!(node.kind(), "nowdoc_body");
5827 Ok(Self {
5828 span: ::treesitter_types::Span::from(node),
5829 children: {
5830 #[allow(clippy::suspicious_else_formatting)]
5831 let non_field_children = {
5832 let mut cursor = node.walk();
5833 let mut result = ::std::vec::Vec::new();
5834 if cursor.goto_first_child() {
5835 loop {
5836 if cursor.field_name().is_none()
5837 && cursor.node().is_named()
5838 && !cursor.node().is_extra()
5839 {
5840 result.push(cursor.node());
5841 }
5842 if !cursor.goto_next_sibling() {
5843 break;
5844 }
5845 }
5846 }
5847 result
5848 };
5849 let mut items = ::std::vec::Vec::new();
5850 for child in non_field_children {
5851 items.push(<NowdocString as ::treesitter_types::FromNode>::from_node(
5852 child, src,
5853 )?);
5854 }
5855 items
5856 },
5857 })
5858 }
5859}
5860impl ::treesitter_types::Spanned for NowdocBody<'_> {
5861 fn span(&self) -> ::treesitter_types::Span {
5862 self.span
5863 }
5864}
5865#[derive(Debug, Clone)]
5866pub struct Null<'tree> {
5867 pub span: ::treesitter_types::Span,
5868 text: &'tree str,
5869}
5870impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
5871 fn from_node(
5872 node: ::tree_sitter::Node<'tree>,
5873 src: &'tree [u8],
5874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5875 debug_assert_eq!(node.kind(), "null");
5876 Ok(Self {
5877 span: ::treesitter_types::Span::from(node),
5878 text: node.utf8_text(src)?,
5879 })
5880 }
5881}
5882impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
5883 fn text(&self) -> &'tree str {
5884 self.text
5885 }
5886}
5887impl ::treesitter_types::Spanned for Null<'_> {
5888 fn span(&self) -> ::treesitter_types::Span {
5889 self.span
5890 }
5891}
5892#[derive(Debug, Clone)]
5893pub struct NullsafeMemberAccessExpression<'tree> {
5894 pub span: ::treesitter_types::Span,
5895 pub name: NullsafeMemberAccessExpressionName<'tree>,
5896 pub object: NullsafeMemberAccessExpressionObject<'tree>,
5897}
5898impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpression<'tree> {
5899 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5900 fn from_node(
5901 node: ::tree_sitter::Node<'tree>,
5902 src: &'tree [u8],
5903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5904 debug_assert_eq!(node.kind(), "nullsafe_member_access_expression");
5905 Ok(Self {
5906 span: ::treesitter_types::Span::from(node),
5907 name: {
5908 let child = node
5909 .child_by_field_name("name")
5910 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5911 <NullsafeMemberAccessExpressionName as ::treesitter_types::FromNode>::from_node(
5912 child, src,
5913 )?
5914 },
5915 object: {
5916 let child = node
5917 .child_by_field_name("object")
5918 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5919 <NullsafeMemberAccessExpressionObject as ::treesitter_types::FromNode>::from_node(
5920 child, src,
5921 )?
5922 },
5923 })
5924 }
5925}
5926impl ::treesitter_types::Spanned for NullsafeMemberAccessExpression<'_> {
5927 fn span(&self) -> ::treesitter_types::Span {
5928 self.span
5929 }
5930}
5931#[derive(Debug, Clone)]
5932pub struct NullsafeMemberCallExpression<'tree> {
5933 pub span: ::treesitter_types::Span,
5934 pub arguments: Arguments<'tree>,
5935 pub name: NullsafeMemberCallExpressionName<'tree>,
5936 pub object: NullsafeMemberCallExpressionObject<'tree>,
5937}
5938impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpression<'tree> {
5939 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5940 fn from_node(
5941 node: ::tree_sitter::Node<'tree>,
5942 src: &'tree [u8],
5943 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5944 debug_assert_eq!(node.kind(), "nullsafe_member_call_expression");
5945 Ok(Self {
5946 span: ::treesitter_types::Span::from(node),
5947 arguments: {
5948 let child = node.child_by_field_name("arguments").ok_or_else(|| {
5949 ::treesitter_types::ParseError::missing_field("arguments", node)
5950 })?;
5951 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
5952 },
5953 name: {
5954 let child = node
5955 .child_by_field_name("name")
5956 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5957 <NullsafeMemberCallExpressionName as ::treesitter_types::FromNode>::from_node(
5958 child, src,
5959 )?
5960 },
5961 object: {
5962 let child = node
5963 .child_by_field_name("object")
5964 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5965 <NullsafeMemberCallExpressionObject as ::treesitter_types::FromNode>::from_node(
5966 child, src,
5967 )?
5968 },
5969 })
5970 }
5971}
5972impl ::treesitter_types::Spanned for NullsafeMemberCallExpression<'_> {
5973 fn span(&self) -> ::treesitter_types::Span {
5974 self.span
5975 }
5976}
5977#[derive(Debug, Clone)]
5978pub struct ObjectCreationExpression<'tree> {
5979 pub span: ::treesitter_types::Span,
5980 pub children: ::std::vec::Vec<ObjectCreationExpressionChildren<'tree>>,
5981}
5982impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpression<'tree> {
5983 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5984 fn from_node(
5985 node: ::tree_sitter::Node<'tree>,
5986 src: &'tree [u8],
5987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5988 debug_assert_eq!(node.kind(), "object_creation_expression");
5989 Ok(Self {
5990 span: ::treesitter_types::Span::from(node),
5991 children: {
5992 #[allow(clippy::suspicious_else_formatting)]
5993 let non_field_children = {
5994 let mut cursor = node.walk();
5995 let mut result = ::std::vec::Vec::new();
5996 if cursor.goto_first_child() {
5997 loop {
5998 if cursor.field_name().is_none()
5999 && cursor.node().is_named()
6000 && !cursor.node().is_extra()
6001 {
6002 result.push(cursor.node());
6003 }
6004 if !cursor.goto_next_sibling() {
6005 break;
6006 }
6007 }
6008 }
6009 result
6010 };
6011 let mut items = ::std::vec::Vec::new();
6012 for child in non_field_children {
6013 items
6014 .push(
6015 <ObjectCreationExpressionChildren as ::treesitter_types::FromNode>::from_node(
6016 child,
6017 src,
6018 )?,
6019 );
6020 }
6021 items
6022 },
6023 })
6024 }
6025}
6026impl ::treesitter_types::Spanned for ObjectCreationExpression<'_> {
6027 fn span(&self) -> ::treesitter_types::Span {
6028 self.span
6029 }
6030}
6031#[derive(Debug, Clone)]
6032pub struct OptionalType<'tree> {
6033 pub span: ::treesitter_types::Span,
6034 pub children: OptionalTypeChildren<'tree>,
6035}
6036impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalType<'tree> {
6037 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6038 fn from_node(
6039 node: ::tree_sitter::Node<'tree>,
6040 src: &'tree [u8],
6041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6042 debug_assert_eq!(node.kind(), "optional_type");
6043 Ok(Self {
6044 span: ::treesitter_types::Span::from(node),
6045 children: {
6046 #[allow(clippy::suspicious_else_formatting)]
6047 let non_field_children = {
6048 let mut cursor = node.walk();
6049 let mut result = ::std::vec::Vec::new();
6050 if cursor.goto_first_child() {
6051 loop {
6052 if cursor.field_name().is_none()
6053 && cursor.node().is_named()
6054 && !cursor.node().is_extra()
6055 {
6056 result.push(cursor.node());
6057 }
6058 if !cursor.goto_next_sibling() {
6059 break;
6060 }
6061 }
6062 }
6063 result
6064 };
6065 let child = if let Some(&c) = non_field_children.first() {
6066 c
6067 } else {
6068 let mut fallback_cursor = node.walk();
6069 let mut fallback_child = None;
6070 if fallback_cursor.goto_first_child() {
6071 loop {
6072 if fallback_cursor.field_name().is_none()
6073 && !fallback_cursor.node().is_extra()
6074 {
6075 let candidate = fallback_cursor.node();
6076 #[allow(clippy::needless_question_mark)]
6077 if (|| -> ::core::result::Result<
6078 _,
6079 ::treesitter_types::ParseError,
6080 > {
6081 let child = candidate;
6082 Ok(
6083 <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(
6084 child,
6085 src,
6086 )?,
6087 )
6088 })()
6089 .is_ok()
6090 {
6091 fallback_child = Some(candidate);
6092 break;
6093 }
6094 }
6095 if !fallback_cursor.goto_next_sibling() {
6096 break;
6097 }
6098 }
6099 }
6100 if fallback_child.is_none() {
6101 let mut cursor2 = node.walk();
6102 if cursor2.goto_first_child() {
6103 loop {
6104 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6105 let candidate = cursor2.node();
6106 #[allow(clippy::needless_question_mark)]
6107 if (|| -> ::core::result::Result<
6108 _,
6109 ::treesitter_types::ParseError,
6110 > {
6111 let child = candidate;
6112 Ok(
6113 <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(
6114 child,
6115 src,
6116 )?,
6117 )
6118 })()
6119 .is_ok()
6120 {
6121 fallback_child = Some(candidate);
6122 break;
6123 }
6124 }
6125 if !cursor2.goto_next_sibling() {
6126 break;
6127 }
6128 }
6129 }
6130 }
6131 fallback_child.ok_or_else(|| {
6132 ::treesitter_types::ParseError::missing_field("children", node)
6133 })?
6134 };
6135 <OptionalTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
6136 },
6137 })
6138 }
6139}
6140impl ::treesitter_types::Spanned for OptionalType<'_> {
6141 fn span(&self) -> ::treesitter_types::Span {
6142 self.span
6143 }
6144}
6145#[derive(Debug, Clone)]
6146pub struct Pair<'tree> {
6147 pub span: ::treesitter_types::Span,
6148 pub children: ::std::vec::Vec<PairChildren<'tree>>,
6149}
6150impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
6151 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6152 fn from_node(
6153 node: ::tree_sitter::Node<'tree>,
6154 src: &'tree [u8],
6155 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6156 debug_assert_eq!(node.kind(), "pair");
6157 Ok(Self {
6158 span: ::treesitter_types::Span::from(node),
6159 children: {
6160 #[allow(clippy::suspicious_else_formatting)]
6161 let non_field_children = {
6162 let mut cursor = node.walk();
6163 let mut result = ::std::vec::Vec::new();
6164 if cursor.goto_first_child() {
6165 loop {
6166 if cursor.field_name().is_none()
6167 && cursor.node().is_named()
6168 && !cursor.node().is_extra()
6169 {
6170 result.push(cursor.node());
6171 }
6172 if !cursor.goto_next_sibling() {
6173 break;
6174 }
6175 }
6176 }
6177 result
6178 };
6179 let mut items = ::std::vec::Vec::new();
6180 for child in non_field_children {
6181 items.push(<PairChildren as ::treesitter_types::FromNode>::from_node(
6182 child, src,
6183 )?);
6184 }
6185 items
6186 },
6187 })
6188 }
6189}
6190impl ::treesitter_types::Spanned for Pair<'_> {
6191 fn span(&self) -> ::treesitter_types::Span {
6192 self.span
6193 }
6194}
6195#[derive(Debug, Clone)]
6196pub struct ParenthesizedExpression<'tree> {
6197 pub span: ::treesitter_types::Span,
6198 pub children: Expression<'tree>,
6199}
6200impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
6201 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6202 fn from_node(
6203 node: ::tree_sitter::Node<'tree>,
6204 src: &'tree [u8],
6205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6206 debug_assert_eq!(node.kind(), "parenthesized_expression");
6207 Ok(Self {
6208 span: ::treesitter_types::Span::from(node),
6209 children: {
6210 #[allow(clippy::suspicious_else_formatting)]
6211 let non_field_children = {
6212 let mut cursor = node.walk();
6213 let mut result = ::std::vec::Vec::new();
6214 if cursor.goto_first_child() {
6215 loop {
6216 if cursor.field_name().is_none()
6217 && cursor.node().is_named()
6218 && !cursor.node().is_extra()
6219 {
6220 result.push(cursor.node());
6221 }
6222 if !cursor.goto_next_sibling() {
6223 break;
6224 }
6225 }
6226 }
6227 result
6228 };
6229 let child = if let Some(&c) = non_field_children.first() {
6230 c
6231 } else {
6232 let mut fallback_cursor = node.walk();
6233 let mut fallback_child = None;
6234 if fallback_cursor.goto_first_child() {
6235 loop {
6236 if fallback_cursor.field_name().is_none()
6237 && !fallback_cursor.node().is_extra()
6238 {
6239 let candidate = fallback_cursor.node();
6240 #[allow(clippy::needless_question_mark)]
6241 if (|| -> ::core::result::Result<
6242 _,
6243 ::treesitter_types::ParseError,
6244 > {
6245 let child = candidate;
6246 Ok(
6247 <Expression as ::treesitter_types::FromNode>::from_node(
6248 child,
6249 src,
6250 )?,
6251 )
6252 })()
6253 .is_ok()
6254 {
6255 fallback_child = Some(candidate);
6256 break;
6257 }
6258 }
6259 if !fallback_cursor.goto_next_sibling() {
6260 break;
6261 }
6262 }
6263 }
6264 if fallback_child.is_none() {
6265 let mut cursor2 = node.walk();
6266 if cursor2.goto_first_child() {
6267 loop {
6268 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6269 let candidate = cursor2.node();
6270 #[allow(clippy::needless_question_mark)]
6271 if (|| -> ::core::result::Result<
6272 _,
6273 ::treesitter_types::ParseError,
6274 > {
6275 let child = candidate;
6276 Ok(
6277 <Expression as ::treesitter_types::FromNode>::from_node(
6278 child,
6279 src,
6280 )?,
6281 )
6282 })()
6283 .is_ok()
6284 {
6285 fallback_child = Some(candidate);
6286 break;
6287 }
6288 }
6289 if !cursor2.goto_next_sibling() {
6290 break;
6291 }
6292 }
6293 }
6294 }
6295 fallback_child.ok_or_else(|| {
6296 ::treesitter_types::ParseError::missing_field("children", node)
6297 })?
6298 };
6299 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6300 },
6301 })
6302 }
6303}
6304impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
6305 fn span(&self) -> ::treesitter_types::Span {
6306 self.span
6307 }
6308}
6309#[derive(Debug, Clone)]
6310pub struct PrimitiveType<'tree> {
6311 pub span: ::treesitter_types::Span,
6312 text: &'tree str,
6313}
6314impl<'tree> ::treesitter_types::FromNode<'tree> for PrimitiveType<'tree> {
6315 fn from_node(
6316 node: ::tree_sitter::Node<'tree>,
6317 src: &'tree [u8],
6318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6319 debug_assert_eq!(node.kind(), "primitive_type");
6320 Ok(Self {
6321 span: ::treesitter_types::Span::from(node),
6322 text: node.utf8_text(src)?,
6323 })
6324 }
6325}
6326impl<'tree> ::treesitter_types::LeafNode<'tree> for PrimitiveType<'tree> {
6327 fn text(&self) -> &'tree str {
6328 self.text
6329 }
6330}
6331impl ::treesitter_types::Spanned for PrimitiveType<'_> {
6332 fn span(&self) -> ::treesitter_types::Span {
6333 self.span
6334 }
6335}
6336#[derive(Debug, Clone)]
6337pub struct PrintIntrinsic<'tree> {
6338 pub span: ::treesitter_types::Span,
6339 pub children: Expression<'tree>,
6340}
6341impl<'tree> ::treesitter_types::FromNode<'tree> for PrintIntrinsic<'tree> {
6342 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6343 fn from_node(
6344 node: ::tree_sitter::Node<'tree>,
6345 src: &'tree [u8],
6346 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6347 debug_assert_eq!(node.kind(), "print_intrinsic");
6348 Ok(Self {
6349 span: ::treesitter_types::Span::from(node),
6350 children: {
6351 #[allow(clippy::suspicious_else_formatting)]
6352 let non_field_children = {
6353 let mut cursor = node.walk();
6354 let mut result = ::std::vec::Vec::new();
6355 if cursor.goto_first_child() {
6356 loop {
6357 if cursor.field_name().is_none()
6358 && cursor.node().is_named()
6359 && !cursor.node().is_extra()
6360 {
6361 result.push(cursor.node());
6362 }
6363 if !cursor.goto_next_sibling() {
6364 break;
6365 }
6366 }
6367 }
6368 result
6369 };
6370 let child = if let Some(&c) = non_field_children.first() {
6371 c
6372 } else {
6373 let mut fallback_cursor = node.walk();
6374 let mut fallback_child = None;
6375 if fallback_cursor.goto_first_child() {
6376 loop {
6377 if fallback_cursor.field_name().is_none()
6378 && !fallback_cursor.node().is_extra()
6379 {
6380 let candidate = fallback_cursor.node();
6381 #[allow(clippy::needless_question_mark)]
6382 if (|| -> ::core::result::Result<
6383 _,
6384 ::treesitter_types::ParseError,
6385 > {
6386 let child = candidate;
6387 Ok(
6388 <Expression as ::treesitter_types::FromNode>::from_node(
6389 child,
6390 src,
6391 )?,
6392 )
6393 })()
6394 .is_ok()
6395 {
6396 fallback_child = Some(candidate);
6397 break;
6398 }
6399 }
6400 if !fallback_cursor.goto_next_sibling() {
6401 break;
6402 }
6403 }
6404 }
6405 if fallback_child.is_none() {
6406 let mut cursor2 = node.walk();
6407 if cursor2.goto_first_child() {
6408 loop {
6409 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6410 let candidate = cursor2.node();
6411 #[allow(clippy::needless_question_mark)]
6412 if (|| -> ::core::result::Result<
6413 _,
6414 ::treesitter_types::ParseError,
6415 > {
6416 let child = candidate;
6417 Ok(
6418 <Expression as ::treesitter_types::FromNode>::from_node(
6419 child,
6420 src,
6421 )?,
6422 )
6423 })()
6424 .is_ok()
6425 {
6426 fallback_child = Some(candidate);
6427 break;
6428 }
6429 }
6430 if !cursor2.goto_next_sibling() {
6431 break;
6432 }
6433 }
6434 }
6435 }
6436 fallback_child.ok_or_else(|| {
6437 ::treesitter_types::ParseError::missing_field("children", node)
6438 })?
6439 };
6440 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6441 },
6442 })
6443 }
6444}
6445impl ::treesitter_types::Spanned for PrintIntrinsic<'_> {
6446 fn span(&self) -> ::treesitter_types::Span {
6447 self.span
6448 }
6449}
6450#[derive(Debug, Clone)]
6451pub struct Program<'tree> {
6452 pub span: ::treesitter_types::Span,
6453 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
6454}
6455impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
6456 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6457 fn from_node(
6458 node: ::tree_sitter::Node<'tree>,
6459 src: &'tree [u8],
6460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6461 debug_assert_eq!(node.kind(), "program");
6462 Ok(Self {
6463 span: ::treesitter_types::Span::from(node),
6464 children: {
6465 #[allow(clippy::suspicious_else_formatting)]
6466 let non_field_children = {
6467 let mut cursor = node.walk();
6468 let mut result = ::std::vec::Vec::new();
6469 if cursor.goto_first_child() {
6470 loop {
6471 if cursor.field_name().is_none()
6472 && cursor.node().is_named()
6473 && !cursor.node().is_extra()
6474 {
6475 result.push(cursor.node());
6476 }
6477 if !cursor.goto_next_sibling() {
6478 break;
6479 }
6480 }
6481 }
6482 result
6483 };
6484 let mut items = ::std::vec::Vec::new();
6485 for child in non_field_children {
6486 items.push(
6487 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6488 );
6489 }
6490 items
6491 },
6492 })
6493 }
6494}
6495impl ::treesitter_types::Spanned for Program<'_> {
6496 fn span(&self) -> ::treesitter_types::Span {
6497 self.span
6498 }
6499}
6500#[derive(Debug, Clone)]
6501pub struct PropertyDeclaration<'tree> {
6502 pub span: ::treesitter_types::Span,
6503 pub attributes: ::core::option::Option<AttributeList<'tree>>,
6504 pub r#type: ::core::option::Option<Type<'tree>>,
6505 pub children: ::std::vec::Vec<PropertyDeclarationChildren<'tree>>,
6506}
6507impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclaration<'tree> {
6508 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6509 fn from_node(
6510 node: ::tree_sitter::Node<'tree>,
6511 src: &'tree [u8],
6512 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6513 debug_assert_eq!(node.kind(), "property_declaration");
6514 Ok(Self {
6515 span: ::treesitter_types::Span::from(node),
6516 attributes: match node.child_by_field_name("attributes") {
6517 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
6518 child, src,
6519 )?),
6520 None => None,
6521 },
6522 r#type: match node.child_by_field_name("type") {
6523 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
6524 child, src,
6525 )?),
6526 None => None,
6527 },
6528 children: {
6529 #[allow(clippy::suspicious_else_formatting)]
6530 let non_field_children = {
6531 let mut cursor = node.walk();
6532 let mut result = ::std::vec::Vec::new();
6533 if cursor.goto_first_child() {
6534 loop {
6535 if cursor.field_name().is_none()
6536 && cursor.node().is_named()
6537 && !cursor.node().is_extra()
6538 {
6539 result.push(cursor.node());
6540 }
6541 if !cursor.goto_next_sibling() {
6542 break;
6543 }
6544 }
6545 }
6546 result
6547 };
6548 let mut items = ::std::vec::Vec::new();
6549 for child in non_field_children {
6550 items.push(
6551 <PropertyDeclarationChildren as ::treesitter_types::FromNode>::from_node(
6552 child, src,
6553 )?,
6554 );
6555 }
6556 items
6557 },
6558 })
6559 }
6560}
6561impl ::treesitter_types::Spanned for PropertyDeclaration<'_> {
6562 fn span(&self) -> ::treesitter_types::Span {
6563 self.span
6564 }
6565}
6566#[derive(Debug, Clone)]
6567pub struct PropertyElement<'tree> {
6568 pub span: ::treesitter_types::Span,
6569 pub default_value: ::core::option::Option<Expression<'tree>>,
6570 pub name: VariableName<'tree>,
6571}
6572impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyElement<'tree> {
6573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6574 fn from_node(
6575 node: ::tree_sitter::Node<'tree>,
6576 src: &'tree [u8],
6577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6578 debug_assert_eq!(node.kind(), "property_element");
6579 Ok(Self {
6580 span: ::treesitter_types::Span::from(node),
6581 default_value: match node.child_by_field_name("default_value") {
6582 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6583 child, src,
6584 )?),
6585 None => None,
6586 },
6587 name: {
6588 let child = node
6589 .child_by_field_name("name")
6590 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6591 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)?
6592 },
6593 })
6594 }
6595}
6596impl ::treesitter_types::Spanned for PropertyElement<'_> {
6597 fn span(&self) -> ::treesitter_types::Span {
6598 self.span
6599 }
6600}
6601#[derive(Debug, Clone)]
6602pub struct PropertyHook<'tree> {
6603 pub span: ::treesitter_types::Span,
6604 pub attributes: ::core::option::Option<AttributeList<'tree>>,
6605 pub body: ::core::option::Option<PropertyHookBody<'tree>>,
6606 pub r#final: ::core::option::Option<FinalModifier<'tree>>,
6607 pub parameters: ::core::option::Option<FormalParameters<'tree>>,
6608 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
6609 pub children: Name<'tree>,
6610}
6611impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHook<'tree> {
6612 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6613 fn from_node(
6614 node: ::tree_sitter::Node<'tree>,
6615 src: &'tree [u8],
6616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6617 debug_assert_eq!(node.kind(), "property_hook");
6618 Ok(Self {
6619 span: ::treesitter_types::Span::from(node),
6620 attributes: match node.child_by_field_name("attributes") {
6621 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
6622 child, src,
6623 )?),
6624 None => None,
6625 },
6626 body: match node.child_by_field_name("body") {
6627 Some(child) => {
6628 Some(<PropertyHookBody as ::treesitter_types::FromNode>::from_node(child, src)?)
6629 }
6630 None => None,
6631 },
6632 r#final: match node.child_by_field_name("final") {
6633 Some(child) => Some(<FinalModifier as ::treesitter_types::FromNode>::from_node(
6634 child, src,
6635 )?),
6636 None => None,
6637 },
6638 parameters: match node.child_by_field_name("parameters") {
6639 Some(child) => {
6640 Some(<FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
6641 }
6642 None => None,
6643 },
6644 reference_modifier: match node.child_by_field_name("reference_modifier") {
6645 Some(child) => Some(
6646 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
6647 ),
6648 None => None,
6649 },
6650 children: {
6651 #[allow(clippy::suspicious_else_formatting)]
6652 let non_field_children = {
6653 let mut cursor = node.walk();
6654 let mut result = ::std::vec::Vec::new();
6655 if cursor.goto_first_child() {
6656 loop {
6657 if cursor.field_name().is_none()
6658 && cursor.node().is_named()
6659 && !cursor.node().is_extra()
6660 {
6661 result.push(cursor.node());
6662 }
6663 if !cursor.goto_next_sibling() {
6664 break;
6665 }
6666 }
6667 }
6668 result
6669 };
6670 let child = if let Some(&c) = non_field_children.first() {
6671 c
6672 } else {
6673 let mut fallback_cursor = node.walk();
6674 let mut fallback_child = None;
6675 if fallback_cursor.goto_first_child() {
6676 loop {
6677 if fallback_cursor.field_name().is_none()
6678 && !fallback_cursor.node().is_extra()
6679 {
6680 let candidate = fallback_cursor.node();
6681 #[allow(clippy::needless_question_mark)]
6682 if (|| -> ::core::result::Result<
6683 _,
6684 ::treesitter_types::ParseError,
6685 > {
6686 let child = candidate;
6687 Ok(
6688 <Name as ::treesitter_types::FromNode>::from_node(
6689 child,
6690 src,
6691 )?,
6692 )
6693 })()
6694 .is_ok()
6695 {
6696 fallback_child = Some(candidate);
6697 break;
6698 }
6699 }
6700 if !fallback_cursor.goto_next_sibling() {
6701 break;
6702 }
6703 }
6704 }
6705 if fallback_child.is_none() {
6706 let mut cursor2 = node.walk();
6707 if cursor2.goto_first_child() {
6708 loop {
6709 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6710 let candidate = cursor2.node();
6711 #[allow(clippy::needless_question_mark)]
6712 if (|| -> ::core::result::Result<
6713 _,
6714 ::treesitter_types::ParseError,
6715 > {
6716 let child = candidate;
6717 Ok(
6718 <Name as ::treesitter_types::FromNode>::from_node(
6719 child,
6720 src,
6721 )?,
6722 )
6723 })()
6724 .is_ok()
6725 {
6726 fallback_child = Some(candidate);
6727 break;
6728 }
6729 }
6730 if !cursor2.goto_next_sibling() {
6731 break;
6732 }
6733 }
6734 }
6735 }
6736 fallback_child.ok_or_else(|| {
6737 ::treesitter_types::ParseError::missing_field("children", node)
6738 })?
6739 };
6740 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
6741 },
6742 })
6743 }
6744}
6745impl ::treesitter_types::Spanned for PropertyHook<'_> {
6746 fn span(&self) -> ::treesitter_types::Span {
6747 self.span
6748 }
6749}
6750#[derive(Debug, Clone)]
6751pub struct PropertyHookList<'tree> {
6752 pub span: ::treesitter_types::Span,
6753 pub children: ::std::vec::Vec<PropertyHook<'tree>>,
6754}
6755impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHookList<'tree> {
6756 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6757 fn from_node(
6758 node: ::tree_sitter::Node<'tree>,
6759 src: &'tree [u8],
6760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6761 debug_assert_eq!(node.kind(), "property_hook_list");
6762 Ok(Self {
6763 span: ::treesitter_types::Span::from(node),
6764 children: {
6765 #[allow(clippy::suspicious_else_formatting)]
6766 let non_field_children = {
6767 let mut cursor = node.walk();
6768 let mut result = ::std::vec::Vec::new();
6769 if cursor.goto_first_child() {
6770 loop {
6771 if cursor.field_name().is_none()
6772 && cursor.node().is_named()
6773 && !cursor.node().is_extra()
6774 {
6775 result.push(cursor.node());
6776 }
6777 if !cursor.goto_next_sibling() {
6778 break;
6779 }
6780 }
6781 }
6782 result
6783 };
6784 let mut items = ::std::vec::Vec::new();
6785 for child in non_field_children {
6786 items.push(<PropertyHook as ::treesitter_types::FromNode>::from_node(
6787 child, src,
6788 )?);
6789 }
6790 items
6791 },
6792 })
6793 }
6794}
6795impl ::treesitter_types::Spanned for PropertyHookList<'_> {
6796 fn span(&self) -> ::treesitter_types::Span {
6797 self.span
6798 }
6799}
6800#[derive(Debug, Clone)]
6801pub struct PropertyPromotionParameter<'tree> {
6802 pub span: ::treesitter_types::Span,
6803 pub attributes: ::core::option::Option<AttributeList<'tree>>,
6804 pub default_value: ::core::option::Option<Expression<'tree>>,
6805 pub name: PropertyPromotionParameterName<'tree>,
6806 pub readonly: ::core::option::Option<ReadonlyModifier<'tree>>,
6807 pub r#type: ::core::option::Option<Type<'tree>>,
6808 pub visibility: VisibilityModifier<'tree>,
6809 pub children: ::core::option::Option<PropertyHookList<'tree>>,
6810}
6811impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPromotionParameter<'tree> {
6812 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6813 fn from_node(
6814 node: ::tree_sitter::Node<'tree>,
6815 src: &'tree [u8],
6816 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6817 debug_assert_eq!(node.kind(), "property_promotion_parameter");
6818 Ok(Self {
6819 span: ::treesitter_types::Span::from(node),
6820 attributes: match node.child_by_field_name("attributes") {
6821 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
6822 child, src,
6823 )?),
6824 None => None,
6825 },
6826 default_value: match node.child_by_field_name("default_value") {
6827 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6828 child, src,
6829 )?),
6830 None => None,
6831 },
6832 name: {
6833 let child = node
6834 .child_by_field_name("name")
6835 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6836 <PropertyPromotionParameterName as ::treesitter_types::FromNode>::from_node(
6837 child, src,
6838 )?
6839 },
6840 readonly: match node.child_by_field_name("readonly") {
6841 Some(child) => {
6842 Some(<ReadonlyModifier as ::treesitter_types::FromNode>::from_node(child, src)?)
6843 }
6844 None => None,
6845 },
6846 r#type: match node.child_by_field_name("type") {
6847 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
6848 child, src,
6849 )?),
6850 None => None,
6851 },
6852 visibility: {
6853 let child = node.child_by_field_name("visibility").ok_or_else(|| {
6854 ::treesitter_types::ParseError::missing_field("visibility", node)
6855 })?;
6856 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(child, src)?
6857 },
6858 children: {
6859 #[allow(clippy::suspicious_else_formatting)]
6860 let non_field_children = {
6861 let mut cursor = node.walk();
6862 let mut result = ::std::vec::Vec::new();
6863 if cursor.goto_first_child() {
6864 loop {
6865 if cursor.field_name().is_none()
6866 && cursor.node().is_named()
6867 && !cursor.node().is_extra()
6868 {
6869 result.push(cursor.node());
6870 }
6871 if !cursor.goto_next_sibling() {
6872 break;
6873 }
6874 }
6875 }
6876 result
6877 };
6878 match non_field_children.first() {
6879 Some(&child) => Some(
6880 <PropertyHookList as ::treesitter_types::FromNode>::from_node(child, src)?,
6881 ),
6882 None => None,
6883 }
6884 },
6885 })
6886 }
6887}
6888impl ::treesitter_types::Spanned for PropertyPromotionParameter<'_> {
6889 fn span(&self) -> ::treesitter_types::Span {
6890 self.span
6891 }
6892}
6893#[derive(Debug, Clone)]
6894pub struct QualifiedName<'tree> {
6895 pub span: ::treesitter_types::Span,
6896 pub prefix: ::std::vec::Vec<QualifiedNamePrefix<'tree>>,
6897 pub children: Name<'tree>,
6898}
6899impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedName<'tree> {
6900 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6901 fn from_node(
6902 node: ::tree_sitter::Node<'tree>,
6903 src: &'tree [u8],
6904 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6905 debug_assert_eq!(node.kind(), "qualified_name");
6906 Ok(Self {
6907 span: ::treesitter_types::Span::from(node),
6908 prefix: {
6909 let mut cursor = node.walk();
6910 let mut items = ::std::vec::Vec::new();
6911 for child in node.children_by_field_name("prefix", &mut cursor) {
6912 items.push(
6913 <QualifiedNamePrefix as ::treesitter_types::FromNode>::from_node(
6914 child, src,
6915 )?,
6916 );
6917 }
6918 items
6919 },
6920 children: {
6921 #[allow(clippy::suspicious_else_formatting)]
6922 let non_field_children = {
6923 let mut cursor = node.walk();
6924 let mut result = ::std::vec::Vec::new();
6925 if cursor.goto_first_child() {
6926 loop {
6927 if cursor.field_name().is_none()
6928 && cursor.node().is_named()
6929 && !cursor.node().is_extra()
6930 {
6931 result.push(cursor.node());
6932 }
6933 if !cursor.goto_next_sibling() {
6934 break;
6935 }
6936 }
6937 }
6938 result
6939 };
6940 let child = if let Some(&c) = non_field_children.first() {
6941 c
6942 } else {
6943 let mut fallback_cursor = node.walk();
6944 let mut fallback_child = None;
6945 if fallback_cursor.goto_first_child() {
6946 loop {
6947 if fallback_cursor.field_name().is_none()
6948 && !fallback_cursor.node().is_extra()
6949 {
6950 let candidate = fallback_cursor.node();
6951 #[allow(clippy::needless_question_mark)]
6952 if (|| -> ::core::result::Result<
6953 _,
6954 ::treesitter_types::ParseError,
6955 > {
6956 let child = candidate;
6957 Ok(
6958 <Name as ::treesitter_types::FromNode>::from_node(
6959 child,
6960 src,
6961 )?,
6962 )
6963 })()
6964 .is_ok()
6965 {
6966 fallback_child = Some(candidate);
6967 break;
6968 }
6969 }
6970 if !fallback_cursor.goto_next_sibling() {
6971 break;
6972 }
6973 }
6974 }
6975 if fallback_child.is_none() {
6976 let mut cursor2 = node.walk();
6977 if cursor2.goto_first_child() {
6978 loop {
6979 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6980 let candidate = cursor2.node();
6981 #[allow(clippy::needless_question_mark)]
6982 if (|| -> ::core::result::Result<
6983 _,
6984 ::treesitter_types::ParseError,
6985 > {
6986 let child = candidate;
6987 Ok(
6988 <Name as ::treesitter_types::FromNode>::from_node(
6989 child,
6990 src,
6991 )?,
6992 )
6993 })()
6994 .is_ok()
6995 {
6996 fallback_child = Some(candidate);
6997 break;
6998 }
6999 }
7000 if !cursor2.goto_next_sibling() {
7001 break;
7002 }
7003 }
7004 }
7005 }
7006 fallback_child.ok_or_else(|| {
7007 ::treesitter_types::ParseError::missing_field("children", node)
7008 })?
7009 };
7010 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
7011 },
7012 })
7013 }
7014}
7015impl ::treesitter_types::Spanned for QualifiedName<'_> {
7016 fn span(&self) -> ::treesitter_types::Span {
7017 self.span
7018 }
7019}
7020#[derive(Debug, Clone)]
7021pub struct ReadonlyModifier<'tree> {
7022 pub span: ::treesitter_types::Span,
7023 text: &'tree str,
7024}
7025impl<'tree> ::treesitter_types::FromNode<'tree> for ReadonlyModifier<'tree> {
7026 fn from_node(
7027 node: ::tree_sitter::Node<'tree>,
7028 src: &'tree [u8],
7029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7030 debug_assert_eq!(node.kind(), "readonly_modifier");
7031 Ok(Self {
7032 span: ::treesitter_types::Span::from(node),
7033 text: node.utf8_text(src)?,
7034 })
7035 }
7036}
7037impl<'tree> ::treesitter_types::LeafNode<'tree> for ReadonlyModifier<'tree> {
7038 fn text(&self) -> &'tree str {
7039 self.text
7040 }
7041}
7042impl ::treesitter_types::Spanned for ReadonlyModifier<'_> {
7043 fn span(&self) -> ::treesitter_types::Span {
7044 self.span
7045 }
7046}
7047#[derive(Debug, Clone)]
7048pub struct ReferenceAssignmentExpression<'tree> {
7049 pub span: ::treesitter_types::Span,
7050 pub left: ReferenceAssignmentExpressionLeft<'tree>,
7051 pub right: Expression<'tree>,
7052}
7053impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceAssignmentExpression<'tree> {
7054 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7055 fn from_node(
7056 node: ::tree_sitter::Node<'tree>,
7057 src: &'tree [u8],
7058 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7059 debug_assert_eq!(node.kind(), "reference_assignment_expression");
7060 Ok(Self {
7061 span: ::treesitter_types::Span::from(node),
7062 left: {
7063 let child = node
7064 .child_by_field_name("left")
7065 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
7066 <ReferenceAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
7067 child, src,
7068 )?
7069 },
7070 right: {
7071 let child = node
7072 .child_by_field_name("right")
7073 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
7074 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7075 },
7076 })
7077 }
7078}
7079impl ::treesitter_types::Spanned for ReferenceAssignmentExpression<'_> {
7080 fn span(&self) -> ::treesitter_types::Span {
7081 self.span
7082 }
7083}
7084#[derive(Debug, Clone)]
7085pub struct ReferenceModifier<'tree> {
7086 pub span: ::treesitter_types::Span,
7087 text: &'tree str,
7088}
7089impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceModifier<'tree> {
7090 fn from_node(
7091 node: ::tree_sitter::Node<'tree>,
7092 src: &'tree [u8],
7093 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7094 debug_assert_eq!(node.kind(), "reference_modifier");
7095 Ok(Self {
7096 span: ::treesitter_types::Span::from(node),
7097 text: node.utf8_text(src)?,
7098 })
7099 }
7100}
7101impl<'tree> ::treesitter_types::LeafNode<'tree> for ReferenceModifier<'tree> {
7102 fn text(&self) -> &'tree str {
7103 self.text
7104 }
7105}
7106impl ::treesitter_types::Spanned for ReferenceModifier<'_> {
7107 fn span(&self) -> ::treesitter_types::Span {
7108 self.span
7109 }
7110}
7111#[derive(Debug, Clone)]
7112pub struct RelativeName<'tree> {
7113 pub span: ::treesitter_types::Span,
7114 pub prefix: ::std::vec::Vec<RelativeNamePrefix<'tree>>,
7115 pub children: Name<'tree>,
7116}
7117impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeName<'tree> {
7118 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7119 fn from_node(
7120 node: ::tree_sitter::Node<'tree>,
7121 src: &'tree [u8],
7122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7123 debug_assert_eq!(node.kind(), "relative_name");
7124 Ok(Self {
7125 span: ::treesitter_types::Span::from(node),
7126 prefix: {
7127 let mut cursor = node.walk();
7128 let mut items = ::std::vec::Vec::new();
7129 for child in node.children_by_field_name("prefix", &mut cursor) {
7130 items.push(
7131 <RelativeNamePrefix as ::treesitter_types::FromNode>::from_node(
7132 child, src,
7133 )?,
7134 );
7135 }
7136 items
7137 },
7138 children: {
7139 #[allow(clippy::suspicious_else_formatting)]
7140 let non_field_children = {
7141 let mut cursor = node.walk();
7142 let mut result = ::std::vec::Vec::new();
7143 if cursor.goto_first_child() {
7144 loop {
7145 if cursor.field_name().is_none()
7146 && cursor.node().is_named()
7147 && !cursor.node().is_extra()
7148 {
7149 result.push(cursor.node());
7150 }
7151 if !cursor.goto_next_sibling() {
7152 break;
7153 }
7154 }
7155 }
7156 result
7157 };
7158 let child = if let Some(&c) = non_field_children.first() {
7159 c
7160 } else {
7161 let mut fallback_cursor = node.walk();
7162 let mut fallback_child = None;
7163 if fallback_cursor.goto_first_child() {
7164 loop {
7165 if fallback_cursor.field_name().is_none()
7166 && !fallback_cursor.node().is_extra()
7167 {
7168 let candidate = fallback_cursor.node();
7169 #[allow(clippy::needless_question_mark)]
7170 if (|| -> ::core::result::Result<
7171 _,
7172 ::treesitter_types::ParseError,
7173 > {
7174 let child = candidate;
7175 Ok(
7176 <Name as ::treesitter_types::FromNode>::from_node(
7177 child,
7178 src,
7179 )?,
7180 )
7181 })()
7182 .is_ok()
7183 {
7184 fallback_child = Some(candidate);
7185 break;
7186 }
7187 }
7188 if !fallback_cursor.goto_next_sibling() {
7189 break;
7190 }
7191 }
7192 }
7193 if fallback_child.is_none() {
7194 let mut cursor2 = node.walk();
7195 if cursor2.goto_first_child() {
7196 loop {
7197 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7198 let candidate = cursor2.node();
7199 #[allow(clippy::needless_question_mark)]
7200 if (|| -> ::core::result::Result<
7201 _,
7202 ::treesitter_types::ParseError,
7203 > {
7204 let child = candidate;
7205 Ok(
7206 <Name as ::treesitter_types::FromNode>::from_node(
7207 child,
7208 src,
7209 )?,
7210 )
7211 })()
7212 .is_ok()
7213 {
7214 fallback_child = Some(candidate);
7215 break;
7216 }
7217 }
7218 if !cursor2.goto_next_sibling() {
7219 break;
7220 }
7221 }
7222 }
7223 }
7224 fallback_child.ok_or_else(|| {
7225 ::treesitter_types::ParseError::missing_field("children", node)
7226 })?
7227 };
7228 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
7229 },
7230 })
7231 }
7232}
7233impl ::treesitter_types::Spanned for RelativeName<'_> {
7234 fn span(&self) -> ::treesitter_types::Span {
7235 self.span
7236 }
7237}
7238#[derive(Debug, Clone)]
7239pub struct RelativeScope<'tree> {
7240 pub span: ::treesitter_types::Span,
7241 text: &'tree str,
7242}
7243impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeScope<'tree> {
7244 fn from_node(
7245 node: ::tree_sitter::Node<'tree>,
7246 src: &'tree [u8],
7247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7248 debug_assert_eq!(node.kind(), "relative_scope");
7249 Ok(Self {
7250 span: ::treesitter_types::Span::from(node),
7251 text: node.utf8_text(src)?,
7252 })
7253 }
7254}
7255impl<'tree> ::treesitter_types::LeafNode<'tree> for RelativeScope<'tree> {
7256 fn text(&self) -> &'tree str {
7257 self.text
7258 }
7259}
7260impl ::treesitter_types::Spanned for RelativeScope<'_> {
7261 fn span(&self) -> ::treesitter_types::Span {
7262 self.span
7263 }
7264}
7265#[derive(Debug, Clone)]
7266pub struct RequireExpression<'tree> {
7267 pub span: ::treesitter_types::Span,
7268 pub children: Expression<'tree>,
7269}
7270impl<'tree> ::treesitter_types::FromNode<'tree> for RequireExpression<'tree> {
7271 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7272 fn from_node(
7273 node: ::tree_sitter::Node<'tree>,
7274 src: &'tree [u8],
7275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7276 debug_assert_eq!(node.kind(), "require_expression");
7277 Ok(Self {
7278 span: ::treesitter_types::Span::from(node),
7279 children: {
7280 #[allow(clippy::suspicious_else_formatting)]
7281 let non_field_children = {
7282 let mut cursor = node.walk();
7283 let mut result = ::std::vec::Vec::new();
7284 if cursor.goto_first_child() {
7285 loop {
7286 if cursor.field_name().is_none()
7287 && cursor.node().is_named()
7288 && !cursor.node().is_extra()
7289 {
7290 result.push(cursor.node());
7291 }
7292 if !cursor.goto_next_sibling() {
7293 break;
7294 }
7295 }
7296 }
7297 result
7298 };
7299 let child = if let Some(&c) = non_field_children.first() {
7300 c
7301 } else {
7302 let mut fallback_cursor = node.walk();
7303 let mut fallback_child = None;
7304 if fallback_cursor.goto_first_child() {
7305 loop {
7306 if fallback_cursor.field_name().is_none()
7307 && !fallback_cursor.node().is_extra()
7308 {
7309 let candidate = fallback_cursor.node();
7310 #[allow(clippy::needless_question_mark)]
7311 if (|| -> ::core::result::Result<
7312 _,
7313 ::treesitter_types::ParseError,
7314 > {
7315 let child = candidate;
7316 Ok(
7317 <Expression as ::treesitter_types::FromNode>::from_node(
7318 child,
7319 src,
7320 )?,
7321 )
7322 })()
7323 .is_ok()
7324 {
7325 fallback_child = Some(candidate);
7326 break;
7327 }
7328 }
7329 if !fallback_cursor.goto_next_sibling() {
7330 break;
7331 }
7332 }
7333 }
7334 if fallback_child.is_none() {
7335 let mut cursor2 = node.walk();
7336 if cursor2.goto_first_child() {
7337 loop {
7338 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7339 let candidate = cursor2.node();
7340 #[allow(clippy::needless_question_mark)]
7341 if (|| -> ::core::result::Result<
7342 _,
7343 ::treesitter_types::ParseError,
7344 > {
7345 let child = candidate;
7346 Ok(
7347 <Expression as ::treesitter_types::FromNode>::from_node(
7348 child,
7349 src,
7350 )?,
7351 )
7352 })()
7353 .is_ok()
7354 {
7355 fallback_child = Some(candidate);
7356 break;
7357 }
7358 }
7359 if !cursor2.goto_next_sibling() {
7360 break;
7361 }
7362 }
7363 }
7364 }
7365 fallback_child.ok_or_else(|| {
7366 ::treesitter_types::ParseError::missing_field("children", node)
7367 })?
7368 };
7369 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7370 },
7371 })
7372 }
7373}
7374impl ::treesitter_types::Spanned for RequireExpression<'_> {
7375 fn span(&self) -> ::treesitter_types::Span {
7376 self.span
7377 }
7378}
7379#[derive(Debug, Clone)]
7380pub struct RequireOnceExpression<'tree> {
7381 pub span: ::treesitter_types::Span,
7382 pub children: Expression<'tree>,
7383}
7384impl<'tree> ::treesitter_types::FromNode<'tree> for RequireOnceExpression<'tree> {
7385 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7386 fn from_node(
7387 node: ::tree_sitter::Node<'tree>,
7388 src: &'tree [u8],
7389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7390 debug_assert_eq!(node.kind(), "require_once_expression");
7391 Ok(Self {
7392 span: ::treesitter_types::Span::from(node),
7393 children: {
7394 #[allow(clippy::suspicious_else_formatting)]
7395 let non_field_children = {
7396 let mut cursor = node.walk();
7397 let mut result = ::std::vec::Vec::new();
7398 if cursor.goto_first_child() {
7399 loop {
7400 if cursor.field_name().is_none()
7401 && cursor.node().is_named()
7402 && !cursor.node().is_extra()
7403 {
7404 result.push(cursor.node());
7405 }
7406 if !cursor.goto_next_sibling() {
7407 break;
7408 }
7409 }
7410 }
7411 result
7412 };
7413 let child = if let Some(&c) = non_field_children.first() {
7414 c
7415 } else {
7416 let mut fallback_cursor = node.walk();
7417 let mut fallback_child = None;
7418 if fallback_cursor.goto_first_child() {
7419 loop {
7420 if fallback_cursor.field_name().is_none()
7421 && !fallback_cursor.node().is_extra()
7422 {
7423 let candidate = fallback_cursor.node();
7424 #[allow(clippy::needless_question_mark)]
7425 if (|| -> ::core::result::Result<
7426 _,
7427 ::treesitter_types::ParseError,
7428 > {
7429 let child = candidate;
7430 Ok(
7431 <Expression as ::treesitter_types::FromNode>::from_node(
7432 child,
7433 src,
7434 )?,
7435 )
7436 })()
7437 .is_ok()
7438 {
7439 fallback_child = Some(candidate);
7440 break;
7441 }
7442 }
7443 if !fallback_cursor.goto_next_sibling() {
7444 break;
7445 }
7446 }
7447 }
7448 if fallback_child.is_none() {
7449 let mut cursor2 = node.walk();
7450 if cursor2.goto_first_child() {
7451 loop {
7452 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7453 let candidate = cursor2.node();
7454 #[allow(clippy::needless_question_mark)]
7455 if (|| -> ::core::result::Result<
7456 _,
7457 ::treesitter_types::ParseError,
7458 > {
7459 let child = candidate;
7460 Ok(
7461 <Expression as ::treesitter_types::FromNode>::from_node(
7462 child,
7463 src,
7464 )?,
7465 )
7466 })()
7467 .is_ok()
7468 {
7469 fallback_child = Some(candidate);
7470 break;
7471 }
7472 }
7473 if !cursor2.goto_next_sibling() {
7474 break;
7475 }
7476 }
7477 }
7478 }
7479 fallback_child.ok_or_else(|| {
7480 ::treesitter_types::ParseError::missing_field("children", node)
7481 })?
7482 };
7483 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7484 },
7485 })
7486 }
7487}
7488impl ::treesitter_types::Spanned for RequireOnceExpression<'_> {
7489 fn span(&self) -> ::treesitter_types::Span {
7490 self.span
7491 }
7492}
7493#[derive(Debug, Clone)]
7494pub struct ReturnStatement<'tree> {
7495 pub span: ::treesitter_types::Span,
7496 pub children: ::core::option::Option<Expression<'tree>>,
7497}
7498impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
7499 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7500 fn from_node(
7501 node: ::tree_sitter::Node<'tree>,
7502 src: &'tree [u8],
7503 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7504 debug_assert_eq!(node.kind(), "return_statement");
7505 Ok(Self {
7506 span: ::treesitter_types::Span::from(node),
7507 children: {
7508 #[allow(clippy::suspicious_else_formatting)]
7509 let non_field_children = {
7510 let mut cursor = node.walk();
7511 let mut result = ::std::vec::Vec::new();
7512 if cursor.goto_first_child() {
7513 loop {
7514 if cursor.field_name().is_none()
7515 && cursor.node().is_named()
7516 && !cursor.node().is_extra()
7517 {
7518 result.push(cursor.node());
7519 }
7520 if !cursor.goto_next_sibling() {
7521 break;
7522 }
7523 }
7524 }
7525 result
7526 };
7527 match non_field_children.first() {
7528 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
7529 child, src,
7530 )?),
7531 None => None,
7532 }
7533 },
7534 })
7535 }
7536}
7537impl ::treesitter_types::Spanned for ReturnStatement<'_> {
7538 fn span(&self) -> ::treesitter_types::Span {
7539 self.span
7540 }
7541}
7542#[derive(Debug, Clone)]
7543pub struct ScopedCallExpression<'tree> {
7544 pub span: ::treesitter_types::Span,
7545 pub arguments: Arguments<'tree>,
7546 pub name: ScopedCallExpressionName<'tree>,
7547 pub scope: ScopedCallExpressionScope<'tree>,
7548}
7549impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpression<'tree> {
7550 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7551 fn from_node(
7552 node: ::tree_sitter::Node<'tree>,
7553 src: &'tree [u8],
7554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7555 debug_assert_eq!(node.kind(), "scoped_call_expression");
7556 Ok(Self {
7557 span: ::treesitter_types::Span::from(node),
7558 arguments: {
7559 let child = node.child_by_field_name("arguments").ok_or_else(|| {
7560 ::treesitter_types::ParseError::missing_field("arguments", node)
7561 })?;
7562 <Arguments as ::treesitter_types::FromNode>::from_node(child, src)?
7563 },
7564 name: {
7565 let child = node
7566 .child_by_field_name("name")
7567 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7568 <ScopedCallExpressionName as ::treesitter_types::FromNode>::from_node(child, src)?
7569 },
7570 scope: {
7571 let child = node
7572 .child_by_field_name("scope")
7573 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
7574 <ScopedCallExpressionScope as ::treesitter_types::FromNode>::from_node(child, src)?
7575 },
7576 })
7577 }
7578}
7579impl ::treesitter_types::Spanned for ScopedCallExpression<'_> {
7580 fn span(&self) -> ::treesitter_types::Span {
7581 self.span
7582 }
7583}
7584#[derive(Debug, Clone)]
7585pub struct ScopedPropertyAccessExpression<'tree> {
7586 pub span: ::treesitter_types::Span,
7587 pub name: ScopedPropertyAccessExpressionName<'tree>,
7588 pub scope: ScopedPropertyAccessExpressionScope<'tree>,
7589}
7590impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpression<'tree> {
7591 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7592 fn from_node(
7593 node: ::tree_sitter::Node<'tree>,
7594 src: &'tree [u8],
7595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7596 debug_assert_eq!(node.kind(), "scoped_property_access_expression");
7597 Ok(Self {
7598 span: ::treesitter_types::Span::from(node),
7599 name: {
7600 let child = node
7601 .child_by_field_name("name")
7602 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7603 <ScopedPropertyAccessExpressionName as ::treesitter_types::FromNode>::from_node(
7604 child, src,
7605 )?
7606 },
7607 scope: {
7608 let child = node
7609 .child_by_field_name("scope")
7610 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("scope", node))?;
7611 <ScopedPropertyAccessExpressionScope as ::treesitter_types::FromNode>::from_node(
7612 child, src,
7613 )?
7614 },
7615 })
7616 }
7617}
7618impl ::treesitter_types::Spanned for ScopedPropertyAccessExpression<'_> {
7619 fn span(&self) -> ::treesitter_types::Span {
7620 self.span
7621 }
7622}
7623#[derive(Debug, Clone)]
7624pub struct SequenceExpression<'tree> {
7625 pub span: ::treesitter_types::Span,
7626 pub children: ::std::vec::Vec<SequenceExpressionChildren<'tree>>,
7627}
7628impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
7629 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7630 fn from_node(
7631 node: ::tree_sitter::Node<'tree>,
7632 src: &'tree [u8],
7633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7634 debug_assert_eq!(node.kind(), "sequence_expression");
7635 Ok(Self {
7636 span: ::treesitter_types::Span::from(node),
7637 children: {
7638 #[allow(clippy::suspicious_else_formatting)]
7639 let non_field_children = {
7640 let mut cursor = node.walk();
7641 let mut result = ::std::vec::Vec::new();
7642 if cursor.goto_first_child() {
7643 loop {
7644 if cursor.field_name().is_none()
7645 && cursor.node().is_named()
7646 && !cursor.node().is_extra()
7647 {
7648 result.push(cursor.node());
7649 }
7650 if !cursor.goto_next_sibling() {
7651 break;
7652 }
7653 }
7654 }
7655 result
7656 };
7657 let mut items = ::std::vec::Vec::new();
7658 for child in non_field_children {
7659 items.push(
7660 <SequenceExpressionChildren as ::treesitter_types::FromNode>::from_node(
7661 child, src,
7662 )?,
7663 );
7664 }
7665 items
7666 },
7667 })
7668 }
7669}
7670impl ::treesitter_types::Spanned for SequenceExpression<'_> {
7671 fn span(&self) -> ::treesitter_types::Span {
7672 self.span
7673 }
7674}
7675#[derive(Debug, Clone)]
7676pub struct ShellCommandExpression<'tree> {
7677 pub span: ::treesitter_types::Span,
7678 pub children: ::std::vec::Vec<ShellCommandExpressionChildren<'tree>>,
7679}
7680impl<'tree> ::treesitter_types::FromNode<'tree> for ShellCommandExpression<'tree> {
7681 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7682 fn from_node(
7683 node: ::tree_sitter::Node<'tree>,
7684 src: &'tree [u8],
7685 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7686 debug_assert_eq!(node.kind(), "shell_command_expression");
7687 Ok(Self {
7688 span: ::treesitter_types::Span::from(node),
7689 children: {
7690 #[allow(clippy::suspicious_else_formatting)]
7691 let non_field_children = {
7692 let mut cursor = node.walk();
7693 let mut result = ::std::vec::Vec::new();
7694 if cursor.goto_first_child() {
7695 loop {
7696 if cursor.field_name().is_none()
7697 && cursor.node().is_named()
7698 && !cursor.node().is_extra()
7699 {
7700 result.push(cursor.node());
7701 }
7702 if !cursor.goto_next_sibling() {
7703 break;
7704 }
7705 }
7706 }
7707 result
7708 };
7709 let mut items = ::std::vec::Vec::new();
7710 for child in non_field_children {
7711 items
7712 .push(
7713 <ShellCommandExpressionChildren as ::treesitter_types::FromNode>::from_node(
7714 child,
7715 src,
7716 )?,
7717 );
7718 }
7719 items
7720 },
7721 })
7722 }
7723}
7724impl ::treesitter_types::Spanned for ShellCommandExpression<'_> {
7725 fn span(&self) -> ::treesitter_types::Span {
7726 self.span
7727 }
7728}
7729#[derive(Debug, Clone)]
7730pub struct SimpleParameter<'tree> {
7731 pub span: ::treesitter_types::Span,
7732 pub attributes: ::core::option::Option<AttributeList<'tree>>,
7733 pub default_value: ::core::option::Option<Expression<'tree>>,
7734 pub name: VariableName<'tree>,
7735 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
7736 pub r#type: ::core::option::Option<Type<'tree>>,
7737}
7738impl<'tree> ::treesitter_types::FromNode<'tree> for SimpleParameter<'tree> {
7739 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7740 fn from_node(
7741 node: ::tree_sitter::Node<'tree>,
7742 src: &'tree [u8],
7743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7744 debug_assert_eq!(node.kind(), "simple_parameter");
7745 Ok(Self {
7746 span: ::treesitter_types::Span::from(node),
7747 attributes: match node.child_by_field_name("attributes") {
7748 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
7749 child, src,
7750 )?),
7751 None => None,
7752 },
7753 default_value: match node.child_by_field_name("default_value") {
7754 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
7755 child, src,
7756 )?),
7757 None => None,
7758 },
7759 name: {
7760 let child = node
7761 .child_by_field_name("name")
7762 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7763 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)?
7764 },
7765 reference_modifier: match node.child_by_field_name("reference_modifier") {
7766 Some(child) => Some(
7767 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
7768 ),
7769 None => None,
7770 },
7771 r#type: match node.child_by_field_name("type") {
7772 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
7773 child, src,
7774 )?),
7775 None => None,
7776 },
7777 })
7778 }
7779}
7780impl ::treesitter_types::Spanned for SimpleParameter<'_> {
7781 fn span(&self) -> ::treesitter_types::Span {
7782 self.span
7783 }
7784}
7785#[derive(Debug, Clone)]
7786pub struct StaticModifier<'tree> {
7787 pub span: ::treesitter_types::Span,
7788 text: &'tree str,
7789}
7790impl<'tree> ::treesitter_types::FromNode<'tree> for StaticModifier<'tree> {
7791 fn from_node(
7792 node: ::tree_sitter::Node<'tree>,
7793 src: &'tree [u8],
7794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7795 debug_assert_eq!(node.kind(), "static_modifier");
7796 Ok(Self {
7797 span: ::treesitter_types::Span::from(node),
7798 text: node.utf8_text(src)?,
7799 })
7800 }
7801}
7802impl<'tree> ::treesitter_types::LeafNode<'tree> for StaticModifier<'tree> {
7803 fn text(&self) -> &'tree str {
7804 self.text
7805 }
7806}
7807impl ::treesitter_types::Spanned for StaticModifier<'_> {
7808 fn span(&self) -> ::treesitter_types::Span {
7809 self.span
7810 }
7811}
7812#[derive(Debug, Clone)]
7813pub struct StaticVariableDeclaration<'tree> {
7814 pub span: ::treesitter_types::Span,
7815 pub name: VariableName<'tree>,
7816 pub value: ::core::option::Option<Expression<'tree>>,
7817}
7818impl<'tree> ::treesitter_types::FromNode<'tree> for StaticVariableDeclaration<'tree> {
7819 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7820 fn from_node(
7821 node: ::tree_sitter::Node<'tree>,
7822 src: &'tree [u8],
7823 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7824 debug_assert_eq!(node.kind(), "static_variable_declaration");
7825 Ok(Self {
7826 span: ::treesitter_types::Span::from(node),
7827 name: {
7828 let child = node
7829 .child_by_field_name("name")
7830 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7831 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)?
7832 },
7833 value: match node.child_by_field_name("value") {
7834 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
7835 child, src,
7836 )?),
7837 None => None,
7838 },
7839 })
7840 }
7841}
7842impl ::treesitter_types::Spanned for StaticVariableDeclaration<'_> {
7843 fn span(&self) -> ::treesitter_types::Span {
7844 self.span
7845 }
7846}
7847#[derive(Debug, Clone)]
7848pub struct String<'tree> {
7849 pub span: ::treesitter_types::Span,
7850 pub children: ::std::vec::Vec<StringChildren<'tree>>,
7851}
7852impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
7853 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7854 fn from_node(
7855 node: ::tree_sitter::Node<'tree>,
7856 src: &'tree [u8],
7857 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7858 debug_assert_eq!(node.kind(), "string");
7859 Ok(Self {
7860 span: ::treesitter_types::Span::from(node),
7861 children: {
7862 #[allow(clippy::suspicious_else_formatting)]
7863 let non_field_children = {
7864 let mut cursor = node.walk();
7865 let mut result = ::std::vec::Vec::new();
7866 if cursor.goto_first_child() {
7867 loop {
7868 if cursor.field_name().is_none()
7869 && cursor.node().is_named()
7870 && !cursor.node().is_extra()
7871 {
7872 result.push(cursor.node());
7873 }
7874 if !cursor.goto_next_sibling() {
7875 break;
7876 }
7877 }
7878 }
7879 result
7880 };
7881 let mut items = ::std::vec::Vec::new();
7882 for child in non_field_children {
7883 items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
7884 child, src,
7885 )?);
7886 }
7887 items
7888 },
7889 })
7890 }
7891}
7892impl ::treesitter_types::Spanned for String<'_> {
7893 fn span(&self) -> ::treesitter_types::Span {
7894 self.span
7895 }
7896}
7897#[derive(Debug, Clone)]
7898pub struct StringContent<'tree> {
7899 pub span: ::treesitter_types::Span,
7900 text: &'tree str,
7901}
7902impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
7903 fn from_node(
7904 node: ::tree_sitter::Node<'tree>,
7905 src: &'tree [u8],
7906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7907 debug_assert_eq!(node.kind(), "string_content");
7908 Ok(Self {
7909 span: ::treesitter_types::Span::from(node),
7910 text: node.utf8_text(src)?,
7911 })
7912 }
7913}
7914impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
7915 fn text(&self) -> &'tree str {
7916 self.text
7917 }
7918}
7919impl ::treesitter_types::Spanned for StringContent<'_> {
7920 fn span(&self) -> ::treesitter_types::Span {
7921 self.span
7922 }
7923}
7924#[derive(Debug, Clone)]
7925pub struct SubscriptExpression<'tree> {
7926 pub span: ::treesitter_types::Span,
7927 pub children: ::std::vec::Vec<SubscriptExpressionChildren<'tree>>,
7928}
7929impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
7930 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7931 fn from_node(
7932 node: ::tree_sitter::Node<'tree>,
7933 src: &'tree [u8],
7934 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7935 debug_assert_eq!(node.kind(), "subscript_expression");
7936 Ok(Self {
7937 span: ::treesitter_types::Span::from(node),
7938 children: {
7939 #[allow(clippy::suspicious_else_formatting)]
7940 let non_field_children = {
7941 let mut cursor = node.walk();
7942 let mut result = ::std::vec::Vec::new();
7943 if cursor.goto_first_child() {
7944 loop {
7945 if cursor.field_name().is_none()
7946 && cursor.node().is_named()
7947 && !cursor.node().is_extra()
7948 {
7949 result.push(cursor.node());
7950 }
7951 if !cursor.goto_next_sibling() {
7952 break;
7953 }
7954 }
7955 }
7956 result
7957 };
7958 let mut items = ::std::vec::Vec::new();
7959 for child in non_field_children {
7960 items.push(
7961 <SubscriptExpressionChildren as ::treesitter_types::FromNode>::from_node(
7962 child, src,
7963 )?,
7964 );
7965 }
7966 items
7967 },
7968 })
7969 }
7970}
7971impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
7972 fn span(&self) -> ::treesitter_types::Span {
7973 self.span
7974 }
7975}
7976#[derive(Debug, Clone)]
7977pub struct SwitchBlock<'tree> {
7978 pub span: ::treesitter_types::Span,
7979 pub children: ::std::vec::Vec<SwitchBlockChildren<'tree>>,
7980}
7981impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlock<'tree> {
7982 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7983 fn from_node(
7984 node: ::tree_sitter::Node<'tree>,
7985 src: &'tree [u8],
7986 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7987 debug_assert_eq!(node.kind(), "switch_block");
7988 Ok(Self {
7989 span: ::treesitter_types::Span::from(node),
7990 children: {
7991 #[allow(clippy::suspicious_else_formatting)]
7992 let non_field_children = {
7993 let mut cursor = node.walk();
7994 let mut result = ::std::vec::Vec::new();
7995 if cursor.goto_first_child() {
7996 loop {
7997 if cursor.field_name().is_none()
7998 && cursor.node().is_named()
7999 && !cursor.node().is_extra()
8000 {
8001 result.push(cursor.node());
8002 }
8003 if !cursor.goto_next_sibling() {
8004 break;
8005 }
8006 }
8007 }
8008 result
8009 };
8010 let mut items = ::std::vec::Vec::new();
8011 for child in non_field_children {
8012 items.push(
8013 <SwitchBlockChildren as ::treesitter_types::FromNode>::from_node(
8014 child, src,
8015 )?,
8016 );
8017 }
8018 items
8019 },
8020 })
8021 }
8022}
8023impl ::treesitter_types::Spanned for SwitchBlock<'_> {
8024 fn span(&self) -> ::treesitter_types::Span {
8025 self.span
8026 }
8027}
8028#[derive(Debug, Clone)]
8029pub struct SwitchStatement<'tree> {
8030 pub span: ::treesitter_types::Span,
8031 pub body: SwitchBlock<'tree>,
8032 pub condition: ParenthesizedExpression<'tree>,
8033}
8034impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
8035 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8036 fn from_node(
8037 node: ::tree_sitter::Node<'tree>,
8038 src: &'tree [u8],
8039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8040 debug_assert_eq!(node.kind(), "switch_statement");
8041 Ok(Self {
8042 span: ::treesitter_types::Span::from(node),
8043 body: {
8044 let child = node
8045 .child_by_field_name("body")
8046 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8047 <SwitchBlock as ::treesitter_types::FromNode>::from_node(child, src)?
8048 },
8049 condition: {
8050 let child = node.child_by_field_name("condition").ok_or_else(|| {
8051 ::treesitter_types::ParseError::missing_field("condition", node)
8052 })?;
8053 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
8054 },
8055 })
8056 }
8057}
8058impl ::treesitter_types::Spanned for SwitchStatement<'_> {
8059 fn span(&self) -> ::treesitter_types::Span {
8060 self.span
8061 }
8062}
8063#[derive(Debug, Clone)]
8064pub struct Text<'tree> {
8065 pub span: ::treesitter_types::Span,
8066 text: &'tree str,
8067}
8068impl<'tree> ::treesitter_types::FromNode<'tree> for Text<'tree> {
8069 fn from_node(
8070 node: ::tree_sitter::Node<'tree>,
8071 src: &'tree [u8],
8072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8073 debug_assert_eq!(node.kind(), "text");
8074 Ok(Self {
8075 span: ::treesitter_types::Span::from(node),
8076 text: node.utf8_text(src)?,
8077 })
8078 }
8079}
8080impl<'tree> ::treesitter_types::LeafNode<'tree> for Text<'tree> {
8081 fn text(&self) -> &'tree str {
8082 self.text
8083 }
8084}
8085impl ::treesitter_types::Spanned for Text<'_> {
8086 fn span(&self) -> ::treesitter_types::Span {
8087 self.span
8088 }
8089}
8090#[derive(Debug, Clone)]
8091pub struct TextInterpolation<'tree> {
8092 pub span: ::treesitter_types::Span,
8093 pub children: ::std::vec::Vec<TextInterpolationChildren<'tree>>,
8094}
8095impl<'tree> ::treesitter_types::FromNode<'tree> for TextInterpolation<'tree> {
8096 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8097 fn from_node(
8098 node: ::tree_sitter::Node<'tree>,
8099 src: &'tree [u8],
8100 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8101 debug_assert_eq!(node.kind(), "text_interpolation");
8102 Ok(Self {
8103 span: ::treesitter_types::Span::from(node),
8104 children: {
8105 #[allow(clippy::suspicious_else_formatting)]
8106 let non_field_children = {
8107 let mut cursor = node.walk();
8108 let mut result = ::std::vec::Vec::new();
8109 if cursor.goto_first_child() {
8110 loop {
8111 if cursor.field_name().is_none()
8112 && cursor.node().is_named()
8113 && !cursor.node().is_extra()
8114 {
8115 result.push(cursor.node());
8116 }
8117 if !cursor.goto_next_sibling() {
8118 break;
8119 }
8120 }
8121 }
8122 result
8123 };
8124 let mut items = ::std::vec::Vec::new();
8125 for child in non_field_children {
8126 items.push(
8127 <TextInterpolationChildren as ::treesitter_types::FromNode>::from_node(
8128 child, src,
8129 )?,
8130 );
8131 }
8132 items
8133 },
8134 })
8135 }
8136}
8137impl ::treesitter_types::Spanned for TextInterpolation<'_> {
8138 fn span(&self) -> ::treesitter_types::Span {
8139 self.span
8140 }
8141}
8142#[derive(Debug, Clone)]
8143pub struct ThrowExpression<'tree> {
8144 pub span: ::treesitter_types::Span,
8145 pub children: Expression<'tree>,
8146}
8147impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowExpression<'tree> {
8148 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8149 fn from_node(
8150 node: ::tree_sitter::Node<'tree>,
8151 src: &'tree [u8],
8152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8153 debug_assert_eq!(node.kind(), "throw_expression");
8154 Ok(Self {
8155 span: ::treesitter_types::Span::from(node),
8156 children: {
8157 #[allow(clippy::suspicious_else_formatting)]
8158 let non_field_children = {
8159 let mut cursor = node.walk();
8160 let mut result = ::std::vec::Vec::new();
8161 if cursor.goto_first_child() {
8162 loop {
8163 if cursor.field_name().is_none()
8164 && cursor.node().is_named()
8165 && !cursor.node().is_extra()
8166 {
8167 result.push(cursor.node());
8168 }
8169 if !cursor.goto_next_sibling() {
8170 break;
8171 }
8172 }
8173 }
8174 result
8175 };
8176 let child = if let Some(&c) = non_field_children.first() {
8177 c
8178 } else {
8179 let mut fallback_cursor = node.walk();
8180 let mut fallback_child = None;
8181 if fallback_cursor.goto_first_child() {
8182 loop {
8183 if fallback_cursor.field_name().is_none()
8184 && !fallback_cursor.node().is_extra()
8185 {
8186 let candidate = fallback_cursor.node();
8187 #[allow(clippy::needless_question_mark)]
8188 if (|| -> ::core::result::Result<
8189 _,
8190 ::treesitter_types::ParseError,
8191 > {
8192 let child = candidate;
8193 Ok(
8194 <Expression as ::treesitter_types::FromNode>::from_node(
8195 child,
8196 src,
8197 )?,
8198 )
8199 })()
8200 .is_ok()
8201 {
8202 fallback_child = Some(candidate);
8203 break;
8204 }
8205 }
8206 if !fallback_cursor.goto_next_sibling() {
8207 break;
8208 }
8209 }
8210 }
8211 if fallback_child.is_none() {
8212 let mut cursor2 = node.walk();
8213 if cursor2.goto_first_child() {
8214 loop {
8215 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8216 let candidate = cursor2.node();
8217 #[allow(clippy::needless_question_mark)]
8218 if (|| -> ::core::result::Result<
8219 _,
8220 ::treesitter_types::ParseError,
8221 > {
8222 let child = candidate;
8223 Ok(
8224 <Expression as ::treesitter_types::FromNode>::from_node(
8225 child,
8226 src,
8227 )?,
8228 )
8229 })()
8230 .is_ok()
8231 {
8232 fallback_child = Some(candidate);
8233 break;
8234 }
8235 }
8236 if !cursor2.goto_next_sibling() {
8237 break;
8238 }
8239 }
8240 }
8241 }
8242 fallback_child.ok_or_else(|| {
8243 ::treesitter_types::ParseError::missing_field("children", node)
8244 })?
8245 };
8246 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8247 },
8248 })
8249 }
8250}
8251impl ::treesitter_types::Spanned for ThrowExpression<'_> {
8252 fn span(&self) -> ::treesitter_types::Span {
8253 self.span
8254 }
8255}
8256#[derive(Debug, Clone)]
8257pub struct TraitDeclaration<'tree> {
8258 pub span: ::treesitter_types::Span,
8259 pub attributes: ::core::option::Option<AttributeList<'tree>>,
8260 pub body: DeclarationList<'tree>,
8261 pub name: Name<'tree>,
8262}
8263impl<'tree> ::treesitter_types::FromNode<'tree> for TraitDeclaration<'tree> {
8264 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8265 fn from_node(
8266 node: ::tree_sitter::Node<'tree>,
8267 src: &'tree [u8],
8268 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8269 debug_assert_eq!(node.kind(), "trait_declaration");
8270 Ok(Self {
8271 span: ::treesitter_types::Span::from(node),
8272 attributes: match node.child_by_field_name("attributes") {
8273 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
8274 child, src,
8275 )?),
8276 None => None,
8277 },
8278 body: {
8279 let child = node
8280 .child_by_field_name("body")
8281 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8282 <DeclarationList as ::treesitter_types::FromNode>::from_node(child, src)?
8283 },
8284 name: {
8285 let child = node
8286 .child_by_field_name("name")
8287 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8288 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
8289 },
8290 })
8291 }
8292}
8293impl ::treesitter_types::Spanned for TraitDeclaration<'_> {
8294 fn span(&self) -> ::treesitter_types::Span {
8295 self.span
8296 }
8297}
8298#[derive(Debug, Clone)]
8299pub struct TryStatement<'tree> {
8300 pub span: ::treesitter_types::Span,
8301 pub body: CompoundStatement<'tree>,
8302 pub children: ::std::vec::Vec<TryStatementChildren<'tree>>,
8303}
8304impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
8305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8306 fn from_node(
8307 node: ::tree_sitter::Node<'tree>,
8308 src: &'tree [u8],
8309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8310 debug_assert_eq!(node.kind(), "try_statement");
8311 Ok(Self {
8312 span: ::treesitter_types::Span::from(node),
8313 body: {
8314 let child = node
8315 .child_by_field_name("body")
8316 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8317 <CompoundStatement as ::treesitter_types::FromNode>::from_node(child, src)?
8318 },
8319 children: {
8320 #[allow(clippy::suspicious_else_formatting)]
8321 let non_field_children = {
8322 let mut cursor = node.walk();
8323 let mut result = ::std::vec::Vec::new();
8324 if cursor.goto_first_child() {
8325 loop {
8326 if cursor.field_name().is_none()
8327 && cursor.node().is_named()
8328 && !cursor.node().is_extra()
8329 {
8330 result.push(cursor.node());
8331 }
8332 if !cursor.goto_next_sibling() {
8333 break;
8334 }
8335 }
8336 }
8337 result
8338 };
8339 let mut items = ::std::vec::Vec::new();
8340 for child in non_field_children {
8341 items.push(
8342 <TryStatementChildren as ::treesitter_types::FromNode>::from_node(
8343 child, src,
8344 )?,
8345 );
8346 }
8347 items
8348 },
8349 })
8350 }
8351}
8352impl ::treesitter_types::Spanned for TryStatement<'_> {
8353 fn span(&self) -> ::treesitter_types::Span {
8354 self.span
8355 }
8356}
8357#[derive(Debug, Clone)]
8358pub struct TypeList<'tree> {
8359 pub span: ::treesitter_types::Span,
8360 pub children: ::std::vec::Vec<NamedType<'tree>>,
8361}
8362impl<'tree> ::treesitter_types::FromNode<'tree> for TypeList<'tree> {
8363 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8364 fn from_node(
8365 node: ::tree_sitter::Node<'tree>,
8366 src: &'tree [u8],
8367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8368 debug_assert_eq!(node.kind(), "type_list");
8369 Ok(Self {
8370 span: ::treesitter_types::Span::from(node),
8371 children: {
8372 #[allow(clippy::suspicious_else_formatting)]
8373 let non_field_children = {
8374 let mut cursor = node.walk();
8375 let mut result = ::std::vec::Vec::new();
8376 if cursor.goto_first_child() {
8377 loop {
8378 if cursor.field_name().is_none()
8379 && cursor.node().is_named()
8380 && !cursor.node().is_extra()
8381 {
8382 result.push(cursor.node());
8383 }
8384 if !cursor.goto_next_sibling() {
8385 break;
8386 }
8387 }
8388 }
8389 result
8390 };
8391 let mut items = ::std::vec::Vec::new();
8392 for child in non_field_children {
8393 items.push(<NamedType as ::treesitter_types::FromNode>::from_node(
8394 child, src,
8395 )?);
8396 }
8397 items
8398 },
8399 })
8400 }
8401}
8402impl ::treesitter_types::Spanned for TypeList<'_> {
8403 fn span(&self) -> ::treesitter_types::Span {
8404 self.span
8405 }
8406}
8407#[derive(Debug, Clone)]
8408pub struct UnaryOpExpression<'tree> {
8409 pub span: ::treesitter_types::Span,
8410 pub argument: ::core::option::Option<Expression<'tree>>,
8411 pub operator: ::core::option::Option<UnaryOpExpressionOperator>,
8412 pub children: ::core::option::Option<Integer<'tree>>,
8413}
8414impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOpExpression<'tree> {
8415 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8416 fn from_node(
8417 node: ::tree_sitter::Node<'tree>,
8418 src: &'tree [u8],
8419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8420 debug_assert_eq!(node.kind(), "unary_op_expression");
8421 Ok(Self {
8422 span: ::treesitter_types::Span::from(node),
8423 argument: match node.child_by_field_name("argument") {
8424 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
8425 child, src,
8426 )?),
8427 None => None,
8428 },
8429 operator: match node.child_by_field_name("operator") {
8430 Some(child) => Some(
8431 <UnaryOpExpressionOperator as ::treesitter_types::FromNode>::from_node(
8432 child, src,
8433 )?,
8434 ),
8435 None => None,
8436 },
8437 children: {
8438 #[allow(clippy::suspicious_else_formatting)]
8439 let non_field_children = {
8440 let mut cursor = node.walk();
8441 let mut result = ::std::vec::Vec::new();
8442 if cursor.goto_first_child() {
8443 loop {
8444 if cursor.field_name().is_none()
8445 && cursor.node().is_named()
8446 && !cursor.node().is_extra()
8447 {
8448 result.push(cursor.node());
8449 }
8450 if !cursor.goto_next_sibling() {
8451 break;
8452 }
8453 }
8454 }
8455 result
8456 };
8457 match non_field_children.first() {
8458 Some(&child) => Some(<Integer as ::treesitter_types::FromNode>::from_node(
8459 child, src,
8460 )?),
8461 None => None,
8462 }
8463 },
8464 })
8465 }
8466}
8467impl ::treesitter_types::Spanned for UnaryOpExpression<'_> {
8468 fn span(&self) -> ::treesitter_types::Span {
8469 self.span
8470 }
8471}
8472#[derive(Debug, Clone)]
8473pub struct UnionType<'tree> {
8474 pub span: ::treesitter_types::Span,
8475 pub children: ::std::vec::Vec<UnionTypeChildren<'tree>>,
8476}
8477impl<'tree> ::treesitter_types::FromNode<'tree> for UnionType<'tree> {
8478 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8479 fn from_node(
8480 node: ::tree_sitter::Node<'tree>,
8481 src: &'tree [u8],
8482 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8483 debug_assert_eq!(node.kind(), "union_type");
8484 Ok(Self {
8485 span: ::treesitter_types::Span::from(node),
8486 children: {
8487 #[allow(clippy::suspicious_else_formatting)]
8488 let non_field_children = {
8489 let mut cursor = node.walk();
8490 let mut result = ::std::vec::Vec::new();
8491 if cursor.goto_first_child() {
8492 loop {
8493 if cursor.field_name().is_none()
8494 && cursor.node().is_named()
8495 && !cursor.node().is_extra()
8496 {
8497 result.push(cursor.node());
8498 }
8499 if !cursor.goto_next_sibling() {
8500 break;
8501 }
8502 }
8503 }
8504 result
8505 };
8506 let mut items = ::std::vec::Vec::new();
8507 for child in non_field_children {
8508 items.push(
8509 <UnionTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8510 );
8511 }
8512 items
8513 },
8514 })
8515 }
8516}
8517impl ::treesitter_types::Spanned for UnionType<'_> {
8518 fn span(&self) -> ::treesitter_types::Span {
8519 self.span
8520 }
8521}
8522#[derive(Debug, Clone)]
8523pub struct UnsetStatement<'tree> {
8524 pub span: ::treesitter_types::Span,
8525 pub children: ::std::vec::Vec<UnsetStatementChildren<'tree>>,
8526}
8527impl<'tree> ::treesitter_types::FromNode<'tree> for UnsetStatement<'tree> {
8528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8529 fn from_node(
8530 node: ::tree_sitter::Node<'tree>,
8531 src: &'tree [u8],
8532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8533 debug_assert_eq!(node.kind(), "unset_statement");
8534 Ok(Self {
8535 span: ::treesitter_types::Span::from(node),
8536 children: {
8537 #[allow(clippy::suspicious_else_formatting)]
8538 let non_field_children = {
8539 let mut cursor = node.walk();
8540 let mut result = ::std::vec::Vec::new();
8541 if cursor.goto_first_child() {
8542 loop {
8543 if cursor.field_name().is_none()
8544 && cursor.node().is_named()
8545 && !cursor.node().is_extra()
8546 {
8547 result.push(cursor.node());
8548 }
8549 if !cursor.goto_next_sibling() {
8550 break;
8551 }
8552 }
8553 }
8554 result
8555 };
8556 let mut items = ::std::vec::Vec::new();
8557 for child in non_field_children {
8558 items.push(
8559 <UnsetStatementChildren as ::treesitter_types::FromNode>::from_node(
8560 child, src,
8561 )?,
8562 );
8563 }
8564 items
8565 },
8566 })
8567 }
8568}
8569impl ::treesitter_types::Spanned for UnsetStatement<'_> {
8570 fn span(&self) -> ::treesitter_types::Span {
8571 self.span
8572 }
8573}
8574#[derive(Debug, Clone)]
8575pub struct UpdateExpression<'tree> {
8576 pub span: ::treesitter_types::Span,
8577 pub argument: UpdateExpressionArgument<'tree>,
8578 pub operator: UpdateExpressionOperator,
8579}
8580impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
8581 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8582 fn from_node(
8583 node: ::tree_sitter::Node<'tree>,
8584 src: &'tree [u8],
8585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8586 debug_assert_eq!(node.kind(), "update_expression");
8587 Ok(Self {
8588 span: ::treesitter_types::Span::from(node),
8589 argument: {
8590 let child = node.child_by_field_name("argument").ok_or_else(|| {
8591 ::treesitter_types::ParseError::missing_field("argument", node)
8592 })?;
8593 <UpdateExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)?
8594 },
8595 operator: {
8596 let child = node.child_by_field_name("operator").ok_or_else(|| {
8597 ::treesitter_types::ParseError::missing_field("operator", node)
8598 })?;
8599 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
8600 },
8601 })
8602 }
8603}
8604impl ::treesitter_types::Spanned for UpdateExpression<'_> {
8605 fn span(&self) -> ::treesitter_types::Span {
8606 self.span
8607 }
8608}
8609#[derive(Debug, Clone)]
8610pub struct UseAsClause<'tree> {
8611 pub span: ::treesitter_types::Span,
8612 pub children: ::std::vec::Vec<UseAsClauseChildren<'tree>>,
8613}
8614impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClause<'tree> {
8615 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8616 fn from_node(
8617 node: ::tree_sitter::Node<'tree>,
8618 src: &'tree [u8],
8619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8620 debug_assert_eq!(node.kind(), "use_as_clause");
8621 Ok(Self {
8622 span: ::treesitter_types::Span::from(node),
8623 children: {
8624 #[allow(clippy::suspicious_else_formatting)]
8625 let non_field_children = {
8626 let mut cursor = node.walk();
8627 let mut result = ::std::vec::Vec::new();
8628 if cursor.goto_first_child() {
8629 loop {
8630 if cursor.field_name().is_none()
8631 && cursor.node().is_named()
8632 && !cursor.node().is_extra()
8633 {
8634 result.push(cursor.node());
8635 }
8636 if !cursor.goto_next_sibling() {
8637 break;
8638 }
8639 }
8640 }
8641 result
8642 };
8643 let mut items = ::std::vec::Vec::new();
8644 for child in non_field_children {
8645 items.push(
8646 <UseAsClauseChildren as ::treesitter_types::FromNode>::from_node(
8647 child, src,
8648 )?,
8649 );
8650 }
8651 items
8652 },
8653 })
8654 }
8655}
8656impl ::treesitter_types::Spanned for UseAsClause<'_> {
8657 fn span(&self) -> ::treesitter_types::Span {
8658 self.span
8659 }
8660}
8661#[derive(Debug, Clone)]
8662pub struct UseDeclaration<'tree> {
8663 pub span: ::treesitter_types::Span,
8664 pub children: ::std::vec::Vec<UseDeclarationChildren<'tree>>,
8665}
8666impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclaration<'tree> {
8667 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8668 fn from_node(
8669 node: ::tree_sitter::Node<'tree>,
8670 src: &'tree [u8],
8671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8672 debug_assert_eq!(node.kind(), "use_declaration");
8673 Ok(Self {
8674 span: ::treesitter_types::Span::from(node),
8675 children: {
8676 #[allow(clippy::suspicious_else_formatting)]
8677 let non_field_children = {
8678 let mut cursor = node.walk();
8679 let mut result = ::std::vec::Vec::new();
8680 if cursor.goto_first_child() {
8681 loop {
8682 if cursor.field_name().is_none()
8683 && cursor.node().is_named()
8684 && !cursor.node().is_extra()
8685 {
8686 result.push(cursor.node());
8687 }
8688 if !cursor.goto_next_sibling() {
8689 break;
8690 }
8691 }
8692 }
8693 result
8694 };
8695 let mut items = ::std::vec::Vec::new();
8696 for child in non_field_children {
8697 items.push(
8698 <UseDeclarationChildren as ::treesitter_types::FromNode>::from_node(
8699 child, src,
8700 )?,
8701 );
8702 }
8703 items
8704 },
8705 })
8706 }
8707}
8708impl ::treesitter_types::Spanned for UseDeclaration<'_> {
8709 fn span(&self) -> ::treesitter_types::Span {
8710 self.span
8711 }
8712}
8713#[derive(Debug, Clone)]
8714pub struct UseInsteadOfClause<'tree> {
8715 pub span: ::treesitter_types::Span,
8716 pub children: ::std::vec::Vec<UseInsteadOfClauseChildren<'tree>>,
8717}
8718impl<'tree> ::treesitter_types::FromNode<'tree> for UseInsteadOfClause<'tree> {
8719 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8720 fn from_node(
8721 node: ::tree_sitter::Node<'tree>,
8722 src: &'tree [u8],
8723 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8724 debug_assert_eq!(node.kind(), "use_instead_of_clause");
8725 Ok(Self {
8726 span: ::treesitter_types::Span::from(node),
8727 children: {
8728 #[allow(clippy::suspicious_else_formatting)]
8729 let non_field_children = {
8730 let mut cursor = node.walk();
8731 let mut result = ::std::vec::Vec::new();
8732 if cursor.goto_first_child() {
8733 loop {
8734 if cursor.field_name().is_none()
8735 && cursor.node().is_named()
8736 && !cursor.node().is_extra()
8737 {
8738 result.push(cursor.node());
8739 }
8740 if !cursor.goto_next_sibling() {
8741 break;
8742 }
8743 }
8744 }
8745 result
8746 };
8747 let mut items = ::std::vec::Vec::new();
8748 for child in non_field_children {
8749 items.push(
8750 <UseInsteadOfClauseChildren as ::treesitter_types::FromNode>::from_node(
8751 child, src,
8752 )?,
8753 );
8754 }
8755 items
8756 },
8757 })
8758 }
8759}
8760impl ::treesitter_types::Spanned for UseInsteadOfClause<'_> {
8761 fn span(&self) -> ::treesitter_types::Span {
8762 self.span
8763 }
8764}
8765#[derive(Debug, Clone)]
8766pub struct UseList<'tree> {
8767 pub span: ::treesitter_types::Span,
8768 pub children: ::std::vec::Vec<UseListChildren<'tree>>,
8769}
8770impl<'tree> ::treesitter_types::FromNode<'tree> for UseList<'tree> {
8771 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8772 fn from_node(
8773 node: ::tree_sitter::Node<'tree>,
8774 src: &'tree [u8],
8775 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8776 debug_assert_eq!(node.kind(), "use_list");
8777 Ok(Self {
8778 span: ::treesitter_types::Span::from(node),
8779 children: {
8780 #[allow(clippy::suspicious_else_formatting)]
8781 let non_field_children = {
8782 let mut cursor = node.walk();
8783 let mut result = ::std::vec::Vec::new();
8784 if cursor.goto_first_child() {
8785 loop {
8786 if cursor.field_name().is_none()
8787 && cursor.node().is_named()
8788 && !cursor.node().is_extra()
8789 {
8790 result.push(cursor.node());
8791 }
8792 if !cursor.goto_next_sibling() {
8793 break;
8794 }
8795 }
8796 }
8797 result
8798 };
8799 let mut items = ::std::vec::Vec::new();
8800 for child in non_field_children {
8801 items.push(
8802 <UseListChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
8803 );
8804 }
8805 items
8806 },
8807 })
8808 }
8809}
8810impl ::treesitter_types::Spanned for UseList<'_> {
8811 fn span(&self) -> ::treesitter_types::Span {
8812 self.span
8813 }
8814}
8815#[derive(Debug, Clone)]
8816pub struct VariableName<'tree> {
8817 pub span: ::treesitter_types::Span,
8818 pub children: Name<'tree>,
8819}
8820impl<'tree> ::treesitter_types::FromNode<'tree> for VariableName<'tree> {
8821 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8822 fn from_node(
8823 node: ::tree_sitter::Node<'tree>,
8824 src: &'tree [u8],
8825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8826 debug_assert_eq!(node.kind(), "variable_name");
8827 Ok(Self {
8828 span: ::treesitter_types::Span::from(node),
8829 children: {
8830 #[allow(clippy::suspicious_else_formatting)]
8831 let non_field_children = {
8832 let mut cursor = node.walk();
8833 let mut result = ::std::vec::Vec::new();
8834 if cursor.goto_first_child() {
8835 loop {
8836 if cursor.field_name().is_none()
8837 && cursor.node().is_named()
8838 && !cursor.node().is_extra()
8839 {
8840 result.push(cursor.node());
8841 }
8842 if !cursor.goto_next_sibling() {
8843 break;
8844 }
8845 }
8846 }
8847 result
8848 };
8849 let child = if let Some(&c) = non_field_children.first() {
8850 c
8851 } else {
8852 let mut fallback_cursor = node.walk();
8853 let mut fallback_child = None;
8854 if fallback_cursor.goto_first_child() {
8855 loop {
8856 if fallback_cursor.field_name().is_none()
8857 && !fallback_cursor.node().is_extra()
8858 {
8859 let candidate = fallback_cursor.node();
8860 #[allow(clippy::needless_question_mark)]
8861 if (|| -> ::core::result::Result<
8862 _,
8863 ::treesitter_types::ParseError,
8864 > {
8865 let child = candidate;
8866 Ok(
8867 <Name as ::treesitter_types::FromNode>::from_node(
8868 child,
8869 src,
8870 )?,
8871 )
8872 })()
8873 .is_ok()
8874 {
8875 fallback_child = Some(candidate);
8876 break;
8877 }
8878 }
8879 if !fallback_cursor.goto_next_sibling() {
8880 break;
8881 }
8882 }
8883 }
8884 if fallback_child.is_none() {
8885 let mut cursor2 = node.walk();
8886 if cursor2.goto_first_child() {
8887 loop {
8888 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8889 let candidate = cursor2.node();
8890 #[allow(clippy::needless_question_mark)]
8891 if (|| -> ::core::result::Result<
8892 _,
8893 ::treesitter_types::ParseError,
8894 > {
8895 let child = candidate;
8896 Ok(
8897 <Name as ::treesitter_types::FromNode>::from_node(
8898 child,
8899 src,
8900 )?,
8901 )
8902 })()
8903 .is_ok()
8904 {
8905 fallback_child = Some(candidate);
8906 break;
8907 }
8908 }
8909 if !cursor2.goto_next_sibling() {
8910 break;
8911 }
8912 }
8913 }
8914 }
8915 fallback_child.ok_or_else(|| {
8916 ::treesitter_types::ParseError::missing_field("children", node)
8917 })?
8918 };
8919 <Name as ::treesitter_types::FromNode>::from_node(child, src)?
8920 },
8921 })
8922 }
8923}
8924impl ::treesitter_types::Spanned for VariableName<'_> {
8925 fn span(&self) -> ::treesitter_types::Span {
8926 self.span
8927 }
8928}
8929#[derive(Debug, Clone)]
8930pub struct VariadicParameter<'tree> {
8931 pub span: ::treesitter_types::Span,
8932 pub attributes: ::core::option::Option<AttributeList<'tree>>,
8933 pub name: VariableName<'tree>,
8934 pub reference_modifier: ::core::option::Option<ReferenceModifier<'tree>>,
8935 pub r#type: ::core::option::Option<Type<'tree>>,
8936}
8937impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicParameter<'tree> {
8938 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8939 fn from_node(
8940 node: ::tree_sitter::Node<'tree>,
8941 src: &'tree [u8],
8942 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8943 debug_assert_eq!(node.kind(), "variadic_parameter");
8944 Ok(Self {
8945 span: ::treesitter_types::Span::from(node),
8946 attributes: match node.child_by_field_name("attributes") {
8947 Some(child) => Some(<AttributeList as ::treesitter_types::FromNode>::from_node(
8948 child, src,
8949 )?),
8950 None => None,
8951 },
8952 name: {
8953 let child = node
8954 .child_by_field_name("name")
8955 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8956 <VariableName as ::treesitter_types::FromNode>::from_node(child, src)?
8957 },
8958 reference_modifier: match node.child_by_field_name("reference_modifier") {
8959 Some(child) => Some(
8960 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(child, src)?,
8961 ),
8962 None => None,
8963 },
8964 r#type: match node.child_by_field_name("type") {
8965 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
8966 child, src,
8967 )?),
8968 None => None,
8969 },
8970 })
8971 }
8972}
8973impl ::treesitter_types::Spanned for VariadicParameter<'_> {
8974 fn span(&self) -> ::treesitter_types::Span {
8975 self.span
8976 }
8977}
8978#[derive(Debug, Clone)]
8979pub struct VariadicPlaceholder<'tree> {
8980 pub span: ::treesitter_types::Span,
8981 text: &'tree str,
8982}
8983impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicPlaceholder<'tree> {
8984 fn from_node(
8985 node: ::tree_sitter::Node<'tree>,
8986 src: &'tree [u8],
8987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8988 debug_assert_eq!(node.kind(), "variadic_placeholder");
8989 Ok(Self {
8990 span: ::treesitter_types::Span::from(node),
8991 text: node.utf8_text(src)?,
8992 })
8993 }
8994}
8995impl<'tree> ::treesitter_types::LeafNode<'tree> for VariadicPlaceholder<'tree> {
8996 fn text(&self) -> &'tree str {
8997 self.text
8998 }
8999}
9000impl ::treesitter_types::Spanned for VariadicPlaceholder<'_> {
9001 fn span(&self) -> ::treesitter_types::Span {
9002 self.span
9003 }
9004}
9005#[derive(Debug, Clone)]
9006pub struct VariadicUnpacking<'tree> {
9007 pub span: ::treesitter_types::Span,
9008 pub children: Expression<'tree>,
9009}
9010impl<'tree> ::treesitter_types::FromNode<'tree> for VariadicUnpacking<'tree> {
9011 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9012 fn from_node(
9013 node: ::tree_sitter::Node<'tree>,
9014 src: &'tree [u8],
9015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9016 debug_assert_eq!(node.kind(), "variadic_unpacking");
9017 Ok(Self {
9018 span: ::treesitter_types::Span::from(node),
9019 children: {
9020 #[allow(clippy::suspicious_else_formatting)]
9021 let non_field_children = {
9022 let mut cursor = node.walk();
9023 let mut result = ::std::vec::Vec::new();
9024 if cursor.goto_first_child() {
9025 loop {
9026 if cursor.field_name().is_none()
9027 && cursor.node().is_named()
9028 && !cursor.node().is_extra()
9029 {
9030 result.push(cursor.node());
9031 }
9032 if !cursor.goto_next_sibling() {
9033 break;
9034 }
9035 }
9036 }
9037 result
9038 };
9039 let child = if let Some(&c) = non_field_children.first() {
9040 c
9041 } else {
9042 let mut fallback_cursor = node.walk();
9043 let mut fallback_child = None;
9044 if fallback_cursor.goto_first_child() {
9045 loop {
9046 if fallback_cursor.field_name().is_none()
9047 && !fallback_cursor.node().is_extra()
9048 {
9049 let candidate = fallback_cursor.node();
9050 #[allow(clippy::needless_question_mark)]
9051 if (|| -> ::core::result::Result<
9052 _,
9053 ::treesitter_types::ParseError,
9054 > {
9055 let child = candidate;
9056 Ok(
9057 <Expression as ::treesitter_types::FromNode>::from_node(
9058 child,
9059 src,
9060 )?,
9061 )
9062 })()
9063 .is_ok()
9064 {
9065 fallback_child = Some(candidate);
9066 break;
9067 }
9068 }
9069 if !fallback_cursor.goto_next_sibling() {
9070 break;
9071 }
9072 }
9073 }
9074 if fallback_child.is_none() {
9075 let mut cursor2 = node.walk();
9076 if cursor2.goto_first_child() {
9077 loop {
9078 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9079 let candidate = cursor2.node();
9080 #[allow(clippy::needless_question_mark)]
9081 if (|| -> ::core::result::Result<
9082 _,
9083 ::treesitter_types::ParseError,
9084 > {
9085 let child = candidate;
9086 Ok(
9087 <Expression as ::treesitter_types::FromNode>::from_node(
9088 child,
9089 src,
9090 )?,
9091 )
9092 })()
9093 .is_ok()
9094 {
9095 fallback_child = Some(candidate);
9096 break;
9097 }
9098 }
9099 if !cursor2.goto_next_sibling() {
9100 break;
9101 }
9102 }
9103 }
9104 }
9105 fallback_child.ok_or_else(|| {
9106 ::treesitter_types::ParseError::missing_field("children", node)
9107 })?
9108 };
9109 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
9110 },
9111 })
9112 }
9113}
9114impl ::treesitter_types::Spanned for VariadicUnpacking<'_> {
9115 fn span(&self) -> ::treesitter_types::Span {
9116 self.span
9117 }
9118}
9119#[derive(Debug, Clone)]
9120pub struct VisibilityModifier<'tree> {
9121 pub span: ::treesitter_types::Span,
9122 pub children: ::core::option::Option<Operation<'tree>>,
9123}
9124impl<'tree> ::treesitter_types::FromNode<'tree> for VisibilityModifier<'tree> {
9125 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9126 fn from_node(
9127 node: ::tree_sitter::Node<'tree>,
9128 src: &'tree [u8],
9129 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9130 debug_assert_eq!(node.kind(), "visibility_modifier");
9131 Ok(Self {
9132 span: ::treesitter_types::Span::from(node),
9133 children: {
9134 #[allow(clippy::suspicious_else_formatting)]
9135 let non_field_children = {
9136 let mut cursor = node.walk();
9137 let mut result = ::std::vec::Vec::new();
9138 if cursor.goto_first_child() {
9139 loop {
9140 if cursor.field_name().is_none()
9141 && cursor.node().is_named()
9142 && !cursor.node().is_extra()
9143 {
9144 result.push(cursor.node());
9145 }
9146 if !cursor.goto_next_sibling() {
9147 break;
9148 }
9149 }
9150 }
9151 result
9152 };
9153 match non_field_children.first() {
9154 Some(&child) => Some(<Operation as ::treesitter_types::FromNode>::from_node(
9155 child, src,
9156 )?),
9157 None => None,
9158 }
9159 },
9160 })
9161 }
9162}
9163impl ::treesitter_types::Spanned for VisibilityModifier<'_> {
9164 fn span(&self) -> ::treesitter_types::Span {
9165 self.span
9166 }
9167}
9168#[derive(Debug, Clone)]
9169pub struct WhileStatement<'tree> {
9170 pub span: ::treesitter_types::Span,
9171 pub body: WhileStatementBody<'tree>,
9172 pub condition: ParenthesizedExpression<'tree>,
9173}
9174impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
9175 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9176 fn from_node(
9177 node: ::tree_sitter::Node<'tree>,
9178 src: &'tree [u8],
9179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9180 debug_assert_eq!(node.kind(), "while_statement");
9181 Ok(Self {
9182 span: ::treesitter_types::Span::from(node),
9183 body: {
9184 let child = node
9185 .child_by_field_name("body")
9186 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
9187 <WhileStatementBody as ::treesitter_types::FromNode>::from_node(child, src)?
9188 },
9189 condition: {
9190 let child = node.child_by_field_name("condition").ok_or_else(|| {
9191 ::treesitter_types::ParseError::missing_field("condition", node)
9192 })?;
9193 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
9194 },
9195 })
9196 }
9197}
9198impl ::treesitter_types::Spanned for WhileStatement<'_> {
9199 fn span(&self) -> ::treesitter_types::Span {
9200 self.span
9201 }
9202}
9203#[derive(Debug, Clone)]
9204pub struct YieldExpression<'tree> {
9205 pub span: ::treesitter_types::Span,
9206 pub children: ::core::option::Option<YieldExpressionChildren<'tree>>,
9207}
9208impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
9209 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9210 fn from_node(
9211 node: ::tree_sitter::Node<'tree>,
9212 src: &'tree [u8],
9213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9214 debug_assert_eq!(node.kind(), "yield_expression");
9215 Ok(Self {
9216 span: ::treesitter_types::Span::from(node),
9217 children: {
9218 #[allow(clippy::suspicious_else_formatting)]
9219 let non_field_children = {
9220 let mut cursor = node.walk();
9221 let mut result = ::std::vec::Vec::new();
9222 if cursor.goto_first_child() {
9223 loop {
9224 if cursor.field_name().is_none()
9225 && cursor.node().is_named()
9226 && !cursor.node().is_extra()
9227 {
9228 result.push(cursor.node());
9229 }
9230 if !cursor.goto_next_sibling() {
9231 break;
9232 }
9233 }
9234 }
9235 result
9236 };
9237 match non_field_children.first() {
9238 Some(&child) => Some(
9239 <YieldExpressionChildren as ::treesitter_types::FromNode>::from_node(
9240 child, src,
9241 )?,
9242 ),
9243 None => None,
9244 }
9245 },
9246 })
9247 }
9248}
9249impl ::treesitter_types::Spanned for YieldExpression<'_> {
9250 fn span(&self) -> ::treesitter_types::Span {
9251 self.span
9252 }
9253}
9254#[derive(Debug, Clone)]
9255pub struct BottomType<'tree> {
9256 pub span: ::treesitter_types::Span,
9257 text: &'tree str,
9258}
9259impl<'tree> ::treesitter_types::FromNode<'tree> for BottomType<'tree> {
9260 fn from_node(
9261 node: ::tree_sitter::Node<'tree>,
9262 src: &'tree [u8],
9263 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9264 debug_assert_eq!(node.kind(), "bottom_type");
9265 Ok(Self {
9266 span: ::treesitter_types::Span::from(node),
9267 text: node.utf8_text(src)?,
9268 })
9269 }
9270}
9271impl<'tree> ::treesitter_types::LeafNode<'tree> for BottomType<'tree> {
9272 fn text(&self) -> &'tree str {
9273 self.text
9274 }
9275}
9276impl ::treesitter_types::Spanned for BottomType<'_> {
9277 fn span(&self) -> ::treesitter_types::Span {
9278 self.span
9279 }
9280}
9281#[derive(Debug, Clone)]
9282pub struct Comment<'tree> {
9283 pub span: ::treesitter_types::Span,
9284 text: &'tree str,
9285}
9286impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
9287 fn from_node(
9288 node: ::tree_sitter::Node<'tree>,
9289 src: &'tree [u8],
9290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9291 debug_assert_eq!(node.kind(), "comment");
9292 Ok(Self {
9293 span: ::treesitter_types::Span::from(node),
9294 text: node.utf8_text(src)?,
9295 })
9296 }
9297}
9298impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
9299 fn text(&self) -> &'tree str {
9300 self.text
9301 }
9302}
9303impl ::treesitter_types::Spanned for Comment<'_> {
9304 fn span(&self) -> ::treesitter_types::Span {
9305 self.span
9306 }
9307}
9308#[derive(Debug, Clone)]
9309pub struct EscapeSequence<'tree> {
9310 pub span: ::treesitter_types::Span,
9311 text: &'tree str,
9312}
9313impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
9314 fn from_node(
9315 node: ::tree_sitter::Node<'tree>,
9316 src: &'tree [u8],
9317 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9318 debug_assert_eq!(node.kind(), "escape_sequence");
9319 Ok(Self {
9320 span: ::treesitter_types::Span::from(node),
9321 text: node.utf8_text(src)?,
9322 })
9323 }
9324}
9325impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
9326 fn text(&self) -> &'tree str {
9327 self.text
9328 }
9329}
9330impl ::treesitter_types::Spanned for EscapeSequence<'_> {
9331 fn span(&self) -> ::treesitter_types::Span {
9332 self.span
9333 }
9334}
9335#[derive(Debug, Clone)]
9336pub struct Float<'tree> {
9337 pub span: ::treesitter_types::Span,
9338 text: &'tree str,
9339}
9340impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
9341 fn from_node(
9342 node: ::tree_sitter::Node<'tree>,
9343 src: &'tree [u8],
9344 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9345 debug_assert_eq!(node.kind(), "float");
9346 Ok(Self {
9347 span: ::treesitter_types::Span::from(node),
9348 text: node.utf8_text(src)?,
9349 })
9350 }
9351}
9352impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
9353 fn text(&self) -> &'tree str {
9354 self.text
9355 }
9356}
9357impl ::treesitter_types::Spanned for Float<'_> {
9358 fn span(&self) -> ::treesitter_types::Span {
9359 self.span
9360 }
9361}
9362#[derive(Debug, Clone)]
9363pub struct HeredocEnd<'tree> {
9364 pub span: ::treesitter_types::Span,
9365 text: &'tree str,
9366}
9367impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocEnd<'tree> {
9368 fn from_node(
9369 node: ::tree_sitter::Node<'tree>,
9370 src: &'tree [u8],
9371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9372 debug_assert_eq!(node.kind(), "heredoc_end");
9373 Ok(Self {
9374 span: ::treesitter_types::Span::from(node),
9375 text: node.utf8_text(src)?,
9376 })
9377 }
9378}
9379impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocEnd<'tree> {
9380 fn text(&self) -> &'tree str {
9381 self.text
9382 }
9383}
9384impl ::treesitter_types::Spanned for HeredocEnd<'_> {
9385 fn span(&self) -> ::treesitter_types::Span {
9386 self.span
9387 }
9388}
9389#[derive(Debug, Clone)]
9390pub struct HeredocStart<'tree> {
9391 pub span: ::treesitter_types::Span,
9392 text: &'tree str,
9393}
9394impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocStart<'tree> {
9395 fn from_node(
9396 node: ::tree_sitter::Node<'tree>,
9397 src: &'tree [u8],
9398 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9399 debug_assert_eq!(node.kind(), "heredoc_start");
9400 Ok(Self {
9401 span: ::treesitter_types::Span::from(node),
9402 text: node.utf8_text(src)?,
9403 })
9404 }
9405}
9406impl<'tree> ::treesitter_types::LeafNode<'tree> for HeredocStart<'tree> {
9407 fn text(&self) -> &'tree str {
9408 self.text
9409 }
9410}
9411impl ::treesitter_types::Spanned for HeredocStart<'_> {
9412 fn span(&self) -> ::treesitter_types::Span {
9413 self.span
9414 }
9415}
9416#[derive(Debug, Clone)]
9417pub struct Integer<'tree> {
9418 pub span: ::treesitter_types::Span,
9419 text: &'tree str,
9420}
9421impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
9422 fn from_node(
9423 node: ::tree_sitter::Node<'tree>,
9424 src: &'tree [u8],
9425 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9426 debug_assert_eq!(node.kind(), "integer");
9427 Ok(Self {
9428 span: ::treesitter_types::Span::from(node),
9429 text: node.utf8_text(src)?,
9430 })
9431 }
9432}
9433impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
9434 fn text(&self) -> &'tree str {
9435 self.text
9436 }
9437}
9438impl ::treesitter_types::Spanned for Integer<'_> {
9439 fn span(&self) -> ::treesitter_types::Span {
9440 self.span
9441 }
9442}
9443#[derive(Debug, Clone)]
9444pub struct NowdocString<'tree> {
9445 pub span: ::treesitter_types::Span,
9446 text: &'tree str,
9447}
9448impl<'tree> ::treesitter_types::FromNode<'tree> for NowdocString<'tree> {
9449 fn from_node(
9450 node: ::tree_sitter::Node<'tree>,
9451 src: &'tree [u8],
9452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9453 debug_assert_eq!(node.kind(), "nowdoc_string");
9454 Ok(Self {
9455 span: ::treesitter_types::Span::from(node),
9456 text: node.utf8_text(src)?,
9457 })
9458 }
9459}
9460impl<'tree> ::treesitter_types::LeafNode<'tree> for NowdocString<'tree> {
9461 fn text(&self) -> &'tree str {
9462 self.text
9463 }
9464}
9465impl ::treesitter_types::Spanned for NowdocString<'_> {
9466 fn span(&self) -> ::treesitter_types::Span {
9467 self.span
9468 }
9469}
9470#[derive(Debug, Clone)]
9471pub struct Operation<'tree> {
9472 pub span: ::treesitter_types::Span,
9473 text: &'tree str,
9474}
9475impl<'tree> ::treesitter_types::FromNode<'tree> for Operation<'tree> {
9476 fn from_node(
9477 node: ::tree_sitter::Node<'tree>,
9478 src: &'tree [u8],
9479 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9480 debug_assert_eq!(node.kind(), "operation");
9481 Ok(Self {
9482 span: ::treesitter_types::Span::from(node),
9483 text: node.utf8_text(src)?,
9484 })
9485 }
9486}
9487impl<'tree> ::treesitter_types::LeafNode<'tree> for Operation<'tree> {
9488 fn text(&self) -> &'tree str {
9489 self.text
9490 }
9491}
9492impl ::treesitter_types::Spanned for Operation<'_> {
9493 fn span(&self) -> ::treesitter_types::Span {
9494 self.span
9495 }
9496}
9497#[derive(Debug, Clone)]
9498pub struct PhpEndTag<'tree> {
9499 pub span: ::treesitter_types::Span,
9500 text: &'tree str,
9501}
9502impl<'tree> ::treesitter_types::FromNode<'tree> for PhpEndTag<'tree> {
9503 fn from_node(
9504 node: ::tree_sitter::Node<'tree>,
9505 src: &'tree [u8],
9506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9507 debug_assert_eq!(node.kind(), "php_end_tag");
9508 Ok(Self {
9509 span: ::treesitter_types::Span::from(node),
9510 text: node.utf8_text(src)?,
9511 })
9512 }
9513}
9514impl<'tree> ::treesitter_types::LeafNode<'tree> for PhpEndTag<'tree> {
9515 fn text(&self) -> &'tree str {
9516 self.text
9517 }
9518}
9519impl ::treesitter_types::Spanned for PhpEndTag<'_> {
9520 fn span(&self) -> ::treesitter_types::Span {
9521 self.span
9522 }
9523}
9524#[derive(Debug, Clone)]
9525pub struct PhpTag<'tree> {
9526 pub span: ::treesitter_types::Span,
9527 text: &'tree str,
9528}
9529impl<'tree> ::treesitter_types::FromNode<'tree> for PhpTag<'tree> {
9530 fn from_node(
9531 node: ::tree_sitter::Node<'tree>,
9532 src: &'tree [u8],
9533 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9534 debug_assert_eq!(node.kind(), "php_tag");
9535 Ok(Self {
9536 span: ::treesitter_types::Span::from(node),
9537 text: node.utf8_text(src)?,
9538 })
9539 }
9540}
9541impl<'tree> ::treesitter_types::LeafNode<'tree> for PhpTag<'tree> {
9542 fn text(&self) -> &'tree str {
9543 self.text
9544 }
9545}
9546impl ::treesitter_types::Spanned for PhpTag<'_> {
9547 fn span(&self) -> ::treesitter_types::Span {
9548 self.span
9549 }
9550}
9551#[derive(Debug, Clone)]
9552pub struct VarModifier<'tree> {
9553 pub span: ::treesitter_types::Span,
9554 text: &'tree str,
9555}
9556impl<'tree> ::treesitter_types::FromNode<'tree> for VarModifier<'tree> {
9557 fn from_node(
9558 node: ::tree_sitter::Node<'tree>,
9559 src: &'tree [u8],
9560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9561 debug_assert_eq!(node.kind(), "var_modifier");
9562 Ok(Self {
9563 span: ::treesitter_types::Span::from(node),
9564 text: node.utf8_text(src)?,
9565 })
9566 }
9567}
9568impl<'tree> ::treesitter_types::LeafNode<'tree> for VarModifier<'tree> {
9569 fn text(&self) -> &'tree str {
9570 self.text
9571 }
9572}
9573impl ::treesitter_types::Spanned for VarModifier<'_> {
9574 fn span(&self) -> ::treesitter_types::Span {
9575 self.span
9576 }
9577}
9578#[derive(Debug, Clone)]
9579pub enum AnonymousClassChildren<'tree> {
9580 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
9581 Arguments(::std::boxed::Box<Arguments<'tree>>),
9582 BaseClause(::std::boxed::Box<BaseClause<'tree>>),
9583 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
9584 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
9585 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
9586 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
9587 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
9588 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
9589}
9590impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousClassChildren<'tree> {
9591 #[allow(clippy::collapsible_else_if)]
9592 fn from_node(
9593 node: ::tree_sitter::Node<'tree>,
9594 src: &'tree [u8],
9595 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9596 match node.kind() {
9597 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
9598 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9599 ))),
9600 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
9601 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
9602 ))),
9603 "base_clause" => Ok(Self::BaseClause(::std::boxed::Box::new(
9604 <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)?,
9605 ))),
9606 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
9607 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)?,
9608 ))),
9609 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
9610 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9611 ))),
9612 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
9613 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9614 ))),
9615 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
9616 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9617 ))),
9618 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
9619 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9620 ))),
9621 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
9622 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9623 ))),
9624 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9625 }
9626 }
9627}
9628impl ::treesitter_types::Spanned for AnonymousClassChildren<'_> {
9629 fn span(&self) -> ::treesitter_types::Span {
9630 match self {
9631 Self::AbstractModifier(inner) => inner.span(),
9632 Self::Arguments(inner) => inner.span(),
9633 Self::BaseClause(inner) => inner.span(),
9634 Self::ClassInterfaceClause(inner) => inner.span(),
9635 Self::FinalModifier(inner) => inner.span(),
9636 Self::ReadonlyModifier(inner) => inner.span(),
9637 Self::StaticModifier(inner) => inner.span(),
9638 Self::VarModifier(inner) => inner.span(),
9639 Self::VisibilityModifier(inner) => inner.span(),
9640 }
9641 }
9642}
9643#[derive(Debug, Clone)]
9644pub enum AnonymousFunctionReturnType<'tree> {
9645 BottomType(::std::boxed::Box<BottomType<'tree>>),
9646 Type(::std::boxed::Box<Type<'tree>>),
9647}
9648impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionReturnType<'tree> {
9649 #[allow(clippy::collapsible_else_if)]
9650 fn from_node(
9651 node: ::tree_sitter::Node<'tree>,
9652 src: &'tree [u8],
9653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9654 match node.kind() {
9655 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
9656 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)?,
9657 ))),
9658 _other => {
9659 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9660 Ok(Self::Type(::std::boxed::Box::new(v)))
9661 } else {
9662 Err(::treesitter_types::ParseError::unexpected_kind(
9663 _other, node,
9664 ))
9665 }
9666 }
9667 }
9668 }
9669}
9670impl ::treesitter_types::Spanned for AnonymousFunctionReturnType<'_> {
9671 fn span(&self) -> ::treesitter_types::Span {
9672 match self {
9673 Self::BottomType(inner) => inner.span(),
9674 Self::Type(inner) => inner.span(),
9675 }
9676 }
9677}
9678#[derive(Debug, Clone)]
9679pub enum AnonymousFunctionUseClauseChildren<'tree> {
9680 ByRef(::std::boxed::Box<ByRef<'tree>>),
9681 VariableName(::std::boxed::Box<VariableName<'tree>>),
9682}
9683impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunctionUseClauseChildren<'tree> {
9684 #[allow(clippy::collapsible_else_if)]
9685 fn from_node(
9686 node: ::tree_sitter::Node<'tree>,
9687 src: &'tree [u8],
9688 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9689 match node.kind() {
9690 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
9691 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
9692 ))),
9693 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
9694 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
9695 ))),
9696 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9697 }
9698 }
9699}
9700impl ::treesitter_types::Spanned for AnonymousFunctionUseClauseChildren<'_> {
9701 fn span(&self) -> ::treesitter_types::Span {
9702 match self {
9703 Self::ByRef(inner) => inner.span(),
9704 Self::VariableName(inner) => inner.span(),
9705 }
9706 }
9707}
9708#[derive(Debug, Clone)]
9709pub enum ArgumentChildren<'tree> {
9710 Expression(::std::boxed::Box<Expression<'tree>>),
9711 Name(::std::boxed::Box<Name<'tree>>),
9712 VariadicUnpacking(::std::boxed::Box<VariadicUnpacking<'tree>>),
9713}
9714impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentChildren<'tree> {
9715 #[allow(clippy::collapsible_else_if)]
9716 fn from_node(
9717 node: ::tree_sitter::Node<'tree>,
9718 src: &'tree [u8],
9719 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9720 match node.kind() {
9721 "name" => Ok(Self::Name(::std::boxed::Box::new(
9722 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
9723 ))),
9724 "variadic_unpacking" => Ok(Self::VariadicUnpacking(::std::boxed::Box::new(
9725 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)?,
9726 ))),
9727 _other => {
9728 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9729 Ok(Self::Expression(::std::boxed::Box::new(v)))
9730 } else {
9731 Err(::treesitter_types::ParseError::unexpected_kind(
9732 _other, node,
9733 ))
9734 }
9735 }
9736 }
9737 }
9738}
9739impl ::treesitter_types::Spanned for ArgumentChildren<'_> {
9740 fn span(&self) -> ::treesitter_types::Span {
9741 match self {
9742 Self::Expression(inner) => inner.span(),
9743 Self::Name(inner) => inner.span(),
9744 Self::VariadicUnpacking(inner) => inner.span(),
9745 }
9746 }
9747}
9748#[derive(Debug, Clone)]
9749pub enum ArgumentsChildren<'tree> {
9750 Argument(::std::boxed::Box<Argument<'tree>>),
9751 VariadicPlaceholder(::std::boxed::Box<VariadicPlaceholder<'tree>>),
9752}
9753impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
9754 #[allow(clippy::collapsible_else_if)]
9755 fn from_node(
9756 node: ::tree_sitter::Node<'tree>,
9757 src: &'tree [u8],
9758 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9759 match node.kind() {
9760 "argument" => Ok(Self::Argument(::std::boxed::Box::new(
9761 <Argument as ::treesitter_types::FromNode>::from_node(node, src)?,
9762 ))),
9763 "variadic_placeholder" => Ok(Self::VariadicPlaceholder(::std::boxed::Box::new(
9764 <VariadicPlaceholder as ::treesitter_types::FromNode>::from_node(node, src)?,
9765 ))),
9766 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9767 }
9768 }
9769}
9770impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
9771 fn span(&self) -> ::treesitter_types::Span {
9772 match self {
9773 Self::Argument(inner) => inner.span(),
9774 Self::VariadicPlaceholder(inner) => inner.span(),
9775 }
9776 }
9777}
9778#[derive(Debug, Clone)]
9779pub enum ArrayElementInitializerChildren<'tree> {
9780 ByRef(::std::boxed::Box<ByRef<'tree>>),
9781 Expression(::std::boxed::Box<Expression<'tree>>),
9782 VariadicUnpacking(::std::boxed::Box<VariadicUnpacking<'tree>>),
9783}
9784impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayElementInitializerChildren<'tree> {
9785 #[allow(clippy::collapsible_else_if)]
9786 fn from_node(
9787 node: ::tree_sitter::Node<'tree>,
9788 src: &'tree [u8],
9789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9790 match node.kind() {
9791 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
9792 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
9793 ))),
9794 "variadic_unpacking" => Ok(Self::VariadicUnpacking(::std::boxed::Box::new(
9795 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)?,
9796 ))),
9797 _other => {
9798 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9799 Ok(Self::Expression(::std::boxed::Box::new(v)))
9800 } else {
9801 Err(::treesitter_types::ParseError::unexpected_kind(
9802 _other, node,
9803 ))
9804 }
9805 }
9806 }
9807 }
9808}
9809impl ::treesitter_types::Spanned for ArrayElementInitializerChildren<'_> {
9810 fn span(&self) -> ::treesitter_types::Span {
9811 match self {
9812 Self::ByRef(inner) => inner.span(),
9813 Self::Expression(inner) => inner.span(),
9814 Self::VariadicUnpacking(inner) => inner.span(),
9815 }
9816 }
9817}
9818#[derive(Debug, Clone)]
9819pub enum ArrowFunctionReturnType<'tree> {
9820 BottomType(::std::boxed::Box<BottomType<'tree>>),
9821 Type(::std::boxed::Box<Type<'tree>>),
9822}
9823impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionReturnType<'tree> {
9824 #[allow(clippy::collapsible_else_if)]
9825 fn from_node(
9826 node: ::tree_sitter::Node<'tree>,
9827 src: &'tree [u8],
9828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9829 match node.kind() {
9830 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
9831 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)?,
9832 ))),
9833 _other => {
9834 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9835 Ok(Self::Type(::std::boxed::Box::new(v)))
9836 } else {
9837 Err(::treesitter_types::ParseError::unexpected_kind(
9838 _other, node,
9839 ))
9840 }
9841 }
9842 }
9843 }
9844}
9845impl ::treesitter_types::Spanned for ArrowFunctionReturnType<'_> {
9846 fn span(&self) -> ::treesitter_types::Span {
9847 match self {
9848 Self::BottomType(inner) => inner.span(),
9849 Self::Type(inner) => inner.span(),
9850 }
9851 }
9852}
9853#[derive(Debug, Clone)]
9854pub enum AssignmentExpressionLeft<'tree> {
9855 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
9856 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
9857 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
9858 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
9859 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
9860 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
9861 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
9862 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
9863 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
9864 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
9865 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
9866 VariableName(::std::boxed::Box<VariableName<'tree>>),
9867}
9868impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
9869 #[allow(clippy::collapsible_else_if)]
9870 fn from_node(
9871 node: ::tree_sitter::Node<'tree>,
9872 src: &'tree [u8],
9873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9874 match node.kind() {
9875 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
9876 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9877 ))),
9878 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
9879 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
9880 ))),
9881 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
9882 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9883 ))),
9884 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
9885 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
9886 ))),
9887 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
9888 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9889 ))),
9890 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
9891 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9892 ))),
9893 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
9894 ::std::boxed::Box::new(
9895 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
9896 node, src,
9897 )?,
9898 ),
9899 )),
9900 "nullsafe_member_call_expression" => {
9901 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
9902 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
9903 node, src,
9904 )?,
9905 )))
9906 }
9907 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
9908 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9909 ))),
9910 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
9911 ::std::boxed::Box::new(
9912 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
9913 node, src,
9914 )?,
9915 ),
9916 )),
9917 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
9918 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9919 ))),
9920 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
9921 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
9922 ))),
9923 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9924 }
9925 }
9926}
9927impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
9928 fn span(&self) -> ::treesitter_types::Span {
9929 match self {
9930 Self::CastExpression(inner) => inner.span(),
9931 Self::DynamicVariableName(inner) => inner.span(),
9932 Self::FunctionCallExpression(inner) => inner.span(),
9933 Self::ListLiteral(inner) => inner.span(),
9934 Self::MemberAccessExpression(inner) => inner.span(),
9935 Self::MemberCallExpression(inner) => inner.span(),
9936 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
9937 Self::NullsafeMemberCallExpression(inner) => inner.span(),
9938 Self::ScopedCallExpression(inner) => inner.span(),
9939 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
9940 Self::SubscriptExpression(inner) => inner.span(),
9941 Self::VariableName(inner) => inner.span(),
9942 }
9943 }
9944}
9945#[derive(Debug, Clone)]
9946pub enum AttributeChildren<'tree> {
9947 Name(::std::boxed::Box<Name<'tree>>),
9948 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
9949 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
9950}
9951impl<'tree> ::treesitter_types::FromNode<'tree> for AttributeChildren<'tree> {
9952 #[allow(clippy::collapsible_else_if)]
9953 fn from_node(
9954 node: ::tree_sitter::Node<'tree>,
9955 src: &'tree [u8],
9956 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9957 match node.kind() {
9958 "name" => Ok(Self::Name(::std::boxed::Box::new(
9959 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
9960 ))),
9961 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
9962 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
9963 ))),
9964 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
9965 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
9966 ))),
9967 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9968 }
9969 }
9970}
9971impl ::treesitter_types::Spanned for AttributeChildren<'_> {
9972 fn span(&self) -> ::treesitter_types::Span {
9973 match self {
9974 Self::Name(inner) => inner.span(),
9975 Self::QualifiedName(inner) => inner.span(),
9976 Self::RelativeName(inner) => inner.span(),
9977 }
9978 }
9979}
9980#[derive(Debug, Clone)]
9981pub enum AugmentedAssignmentExpressionLeft<'tree> {
9982 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
9983 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
9984 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
9985 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
9986 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
9987 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
9988 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
9989 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
9990 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
9991 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
9992 VariableName(::std::boxed::Box<VariableName<'tree>>),
9993}
9994impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
9995 #[allow(clippy::collapsible_else_if)]
9996 fn from_node(
9997 node: ::tree_sitter::Node<'tree>,
9998 src: &'tree [u8],
9999 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10000 match node.kind() {
10001 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10002 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10003 ))),
10004 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10005 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10006 ))),
10007 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10008 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10009 ))),
10010 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10011 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10012 ))),
10013 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10014 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10015 ))),
10016 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10017 ::std::boxed::Box::new(
10018 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10019 node, src,
10020 )?,
10021 ),
10022 )),
10023 "nullsafe_member_call_expression" => {
10024 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
10025 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10026 node, src,
10027 )?,
10028 )))
10029 }
10030 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10031 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10032 ))),
10033 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10034 ::std::boxed::Box::new(
10035 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10036 node, src,
10037 )?,
10038 ),
10039 )),
10040 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10041 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10042 ))),
10043 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10044 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10045 ))),
10046 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10047 }
10048 }
10049}
10050impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
10051 fn span(&self) -> ::treesitter_types::Span {
10052 match self {
10053 Self::CastExpression(inner) => inner.span(),
10054 Self::DynamicVariableName(inner) => inner.span(),
10055 Self::FunctionCallExpression(inner) => inner.span(),
10056 Self::MemberAccessExpression(inner) => inner.span(),
10057 Self::MemberCallExpression(inner) => inner.span(),
10058 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10059 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10060 Self::ScopedCallExpression(inner) => inner.span(),
10061 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10062 Self::SubscriptExpression(inner) => inner.span(),
10063 Self::VariableName(inner) => inner.span(),
10064 }
10065 }
10066}
10067#[derive(Debug, Clone)]
10068pub enum AugmentedAssignmentExpressionOperator {
10069 PercentEq(::treesitter_types::Span),
10070 AmpEq(::treesitter_types::Span),
10071 StarStarEq(::treesitter_types::Span),
10072 StarEq(::treesitter_types::Span),
10073 PlusEq(::treesitter_types::Span),
10074 MinusEq(::treesitter_types::Span),
10075 DotEq(::treesitter_types::Span),
10076 SlashEq(::treesitter_types::Span),
10077 ShlEq(::treesitter_types::Span),
10078 ShrEq(::treesitter_types::Span),
10079 QuestionQuestionEq(::treesitter_types::Span),
10080 CaretEq(::treesitter_types::Span),
10081 PipeEq(::treesitter_types::Span),
10082}
10083impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
10084 #[allow(clippy::collapsible_else_if)]
10085 fn from_node(
10086 node: ::tree_sitter::Node<'tree>,
10087 _src: &'tree [u8],
10088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10089 match node.kind() {
10090 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
10091 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
10092 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
10093 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
10094 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
10095 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
10096 ".=" => Ok(Self::DotEq(::treesitter_types::Span::from(node))),
10097 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
10098 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
10099 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
10100 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
10101 node,
10102 ))),
10103 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
10104 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
10105 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10106 }
10107 }
10108}
10109impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
10110 fn span(&self) -> ::treesitter_types::Span {
10111 match self {
10112 Self::PercentEq(span) => *span,
10113 Self::AmpEq(span) => *span,
10114 Self::StarStarEq(span) => *span,
10115 Self::StarEq(span) => *span,
10116 Self::PlusEq(span) => *span,
10117 Self::MinusEq(span) => *span,
10118 Self::DotEq(span) => *span,
10119 Self::SlashEq(span) => *span,
10120 Self::ShlEq(span) => *span,
10121 Self::ShrEq(span) => *span,
10122 Self::QuestionQuestionEq(span) => *span,
10123 Self::CaretEq(span) => *span,
10124 Self::PipeEq(span) => *span,
10125 }
10126 }
10127}
10128#[derive(Debug, Clone)]
10129pub enum BaseClauseChildren<'tree> {
10130 Name(::std::boxed::Box<Name<'tree>>),
10131 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10132 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10133}
10134impl<'tree> ::treesitter_types::FromNode<'tree> for BaseClauseChildren<'tree> {
10135 #[allow(clippy::collapsible_else_if)]
10136 fn from_node(
10137 node: ::tree_sitter::Node<'tree>,
10138 src: &'tree [u8],
10139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10140 match node.kind() {
10141 "name" => Ok(Self::Name(::std::boxed::Box::new(
10142 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10143 ))),
10144 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10145 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
10146 ))),
10147 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10148 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
10149 ))),
10150 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10151 }
10152 }
10153}
10154impl ::treesitter_types::Spanned for BaseClauseChildren<'_> {
10155 fn span(&self) -> ::treesitter_types::Span {
10156 match self {
10157 Self::Name(inner) => inner.span(),
10158 Self::QualifiedName(inner) => inner.span(),
10159 Self::RelativeName(inner) => inner.span(),
10160 }
10161 }
10162}
10163#[derive(Debug, Clone)]
10164pub enum BinaryExpressionOperator {
10165 NotEq(::treesitter_types::Span),
10166 BangEqEq(::treesitter_types::Span),
10167 Percent(::treesitter_types::Span),
10168 Amp(::treesitter_types::Span),
10169 AmpAmp(::treesitter_types::Span),
10170 Star(::treesitter_types::Span),
10171 StarStar(::treesitter_types::Span),
10172 Plus(::treesitter_types::Span),
10173 Minus(::treesitter_types::Span),
10174 Dot(::treesitter_types::Span),
10175 Slash(::treesitter_types::Span),
10176 Lt(::treesitter_types::Span),
10177 Shl(::treesitter_types::Span),
10178 LtEq(::treesitter_types::Span),
10179 LtEqGt(::treesitter_types::Span),
10180 LtGt(::treesitter_types::Span),
10181 EqEq(::treesitter_types::Span),
10182 EqEqEq(::treesitter_types::Span),
10183 Gt(::treesitter_types::Span),
10184 GtEq(::treesitter_types::Span),
10185 Shr(::treesitter_types::Span),
10186 QuestionQuestion(::treesitter_types::Span),
10187 Caret(::treesitter_types::Span),
10188 And(::treesitter_types::Span),
10189 Instanceof(::treesitter_types::Span),
10190 Or(::treesitter_types::Span),
10191 Xor(::treesitter_types::Span),
10192 Pipe(::treesitter_types::Span),
10193 PipeGt(::treesitter_types::Span),
10194 PipePipe(::treesitter_types::Span),
10195}
10196impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
10197 #[allow(clippy::collapsible_else_if)]
10198 fn from_node(
10199 node: ::tree_sitter::Node<'tree>,
10200 _src: &'tree [u8],
10201 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10202 match node.kind() {
10203 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
10204 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
10205 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
10206 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
10207 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
10208 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
10209 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
10210 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
10211 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
10212 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
10213 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
10214 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
10215 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
10216 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
10217 "<=>" => Ok(Self::LtEqGt(::treesitter_types::Span::from(node))),
10218 "<>" => Ok(Self::LtGt(::treesitter_types::Span::from(node))),
10219 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
10220 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
10221 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
10222 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
10223 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
10224 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
10225 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
10226 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
10227 "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
10228 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
10229 "xor" => Ok(Self::Xor(::treesitter_types::Span::from(node))),
10230 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
10231 "|>" => Ok(Self::PipeGt(::treesitter_types::Span::from(node))),
10232 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
10233 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10234 }
10235 }
10236}
10237impl ::treesitter_types::Spanned for BinaryExpressionOperator {
10238 fn span(&self) -> ::treesitter_types::Span {
10239 match self {
10240 Self::NotEq(span) => *span,
10241 Self::BangEqEq(span) => *span,
10242 Self::Percent(span) => *span,
10243 Self::Amp(span) => *span,
10244 Self::AmpAmp(span) => *span,
10245 Self::Star(span) => *span,
10246 Self::StarStar(span) => *span,
10247 Self::Plus(span) => *span,
10248 Self::Minus(span) => *span,
10249 Self::Dot(span) => *span,
10250 Self::Slash(span) => *span,
10251 Self::Lt(span) => *span,
10252 Self::Shl(span) => *span,
10253 Self::LtEq(span) => *span,
10254 Self::LtEqGt(span) => *span,
10255 Self::LtGt(span) => *span,
10256 Self::EqEq(span) => *span,
10257 Self::EqEqEq(span) => *span,
10258 Self::Gt(span) => *span,
10259 Self::GtEq(span) => *span,
10260 Self::Shr(span) => *span,
10261 Self::QuestionQuestion(span) => *span,
10262 Self::Caret(span) => *span,
10263 Self::And(span) => *span,
10264 Self::Instanceof(span) => *span,
10265 Self::Or(span) => *span,
10266 Self::Xor(span) => *span,
10267 Self::Pipe(span) => *span,
10268 Self::PipeGt(span) => *span,
10269 Self::PipePipe(span) => *span,
10270 }
10271 }
10272}
10273#[derive(Debug, Clone)]
10274pub enum BinaryExpressionRight<'tree> {
10275 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10276 Expression(::std::boxed::Box<Expression<'tree>>),
10277 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10278 Name(::std::boxed::Box<Name<'tree>>),
10279 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10280 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10281 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10282 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10283 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10284 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10285 VariableName(::std::boxed::Box<VariableName<'tree>>),
10286}
10287impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionRight<'tree> {
10288 #[allow(clippy::collapsible_else_if)]
10289 fn from_node(
10290 node: ::tree_sitter::Node<'tree>,
10291 src: &'tree [u8],
10292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10293 match node.kind() {
10294 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10295 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10296 ))),
10297 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10298 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10299 ))),
10300 "name" => Ok(Self::Name(::std::boxed::Box::new(
10301 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10302 ))),
10303 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10304 ::std::boxed::Box::new(
10305 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10306 node, src,
10307 )?,
10308 ),
10309 )),
10310 "parenthesized_expression" => {
10311 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
10312 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
10313 node, src,
10314 )?,
10315 )))
10316 }
10317 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10318 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
10319 ))),
10320 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10321 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
10322 ))),
10323 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10324 ::std::boxed::Box::new(
10325 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10326 node, src,
10327 )?,
10328 ),
10329 )),
10330 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10331 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10332 ))),
10333 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10334 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10335 ))),
10336 _other => {
10337 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10338 Ok(Self::Expression(::std::boxed::Box::new(v)))
10339 } else {
10340 Err(::treesitter_types::ParseError::unexpected_kind(
10341 _other, node,
10342 ))
10343 }
10344 }
10345 }
10346 }
10347}
10348impl ::treesitter_types::Spanned for BinaryExpressionRight<'_> {
10349 fn span(&self) -> ::treesitter_types::Span {
10350 match self {
10351 Self::DynamicVariableName(inner) => inner.span(),
10352 Self::Expression(inner) => inner.span(),
10353 Self::MemberAccessExpression(inner) => inner.span(),
10354 Self::Name(inner) => inner.span(),
10355 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10356 Self::ParenthesizedExpression(inner) => inner.span(),
10357 Self::QualifiedName(inner) => inner.span(),
10358 Self::RelativeName(inner) => inner.span(),
10359 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10360 Self::SubscriptExpression(inner) => inner.span(),
10361 Self::VariableName(inner) => inner.span(),
10362 }
10363 }
10364}
10365#[derive(Debug, Clone)]
10366pub enum ByRefChildren<'tree> {
10367 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10368 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10369 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10370 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10371 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
10372 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10373 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
10374 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
10375 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10376 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10377 VariableName(::std::boxed::Box<VariableName<'tree>>),
10378}
10379impl<'tree> ::treesitter_types::FromNode<'tree> for ByRefChildren<'tree> {
10380 #[allow(clippy::collapsible_else_if)]
10381 fn from_node(
10382 node: ::tree_sitter::Node<'tree>,
10383 src: &'tree [u8],
10384 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10385 match node.kind() {
10386 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10387 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10388 ))),
10389 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10390 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10391 ))),
10392 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10393 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10394 ))),
10395 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10396 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10397 ))),
10398 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10399 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10400 ))),
10401 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10402 ::std::boxed::Box::new(
10403 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10404 node, src,
10405 )?,
10406 ),
10407 )),
10408 "nullsafe_member_call_expression" => {
10409 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
10410 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10411 node, src,
10412 )?,
10413 )))
10414 }
10415 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10416 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10417 ))),
10418 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10419 ::std::boxed::Box::new(
10420 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10421 node, src,
10422 )?,
10423 ),
10424 )),
10425 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10426 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10427 ))),
10428 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10429 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10430 ))),
10431 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10432 }
10433 }
10434}
10435impl ::treesitter_types::Spanned for ByRefChildren<'_> {
10436 fn span(&self) -> ::treesitter_types::Span {
10437 match self {
10438 Self::CastExpression(inner) => inner.span(),
10439 Self::DynamicVariableName(inner) => inner.span(),
10440 Self::FunctionCallExpression(inner) => inner.span(),
10441 Self::MemberAccessExpression(inner) => inner.span(),
10442 Self::MemberCallExpression(inner) => inner.span(),
10443 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10444 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10445 Self::ScopedCallExpression(inner) => inner.span(),
10446 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10447 Self::SubscriptExpression(inner) => inner.span(),
10448 Self::VariableName(inner) => inner.span(),
10449 }
10450 }
10451}
10452#[derive(Debug, Clone)]
10453pub enum CastExpressionValue<'tree> {
10454 CloneExpression(::std::boxed::Box<CloneExpression<'tree>>),
10455 ErrorSuppressionExpression(::std::boxed::Box<ErrorSuppressionExpression<'tree>>),
10456 IncludeExpression(::std::boxed::Box<IncludeExpression<'tree>>),
10457 IncludeOnceExpression(::std::boxed::Box<IncludeOnceExpression<'tree>>),
10458 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
10459 UnaryOpExpression(::std::boxed::Box<UnaryOpExpression<'tree>>),
10460}
10461impl<'tree> ::treesitter_types::FromNode<'tree> for CastExpressionValue<'tree> {
10462 #[allow(clippy::collapsible_else_if)]
10463 fn from_node(
10464 node: ::tree_sitter::Node<'tree>,
10465 src: &'tree [u8],
10466 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10467 match node.kind() {
10468 "clone_expression" => Ok(Self::CloneExpression(::std::boxed::Box::new(
10469 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10470 ))),
10471 "error_suppression_expression" => {
10472 Ok(Self::ErrorSuppressionExpression(::std::boxed::Box::new(
10473 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(
10474 node, src,
10475 )?,
10476 )))
10477 }
10478 "include_expression" => Ok(Self::IncludeExpression(::std::boxed::Box::new(
10479 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10480 ))),
10481 "include_once_expression" => Ok(Self::IncludeOnceExpression(::std::boxed::Box::new(
10482 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10483 ))),
10484 "unary_op_expression" => Ok(Self::UnaryOpExpression(::std::boxed::Box::new(
10485 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10486 ))),
10487 _other => {
10488 if let Ok(v) =
10489 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
10490 {
10491 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
10492 } else {
10493 Err(::treesitter_types::ParseError::unexpected_kind(
10494 _other, node,
10495 ))
10496 }
10497 }
10498 }
10499 }
10500}
10501impl ::treesitter_types::Spanned for CastExpressionValue<'_> {
10502 fn span(&self) -> ::treesitter_types::Span {
10503 match self {
10504 Self::CloneExpression(inner) => inner.span(),
10505 Self::ErrorSuppressionExpression(inner) => inner.span(),
10506 Self::IncludeExpression(inner) => inner.span(),
10507 Self::IncludeOnceExpression(inner) => inner.span(),
10508 Self::PrimaryExpression(inner) => inner.span(),
10509 Self::UnaryOpExpression(inner) => inner.span(),
10510 }
10511 }
10512}
10513#[derive(Debug, Clone)]
10514pub enum ClassConstantAccessExpressionChildren<'tree> {
10515 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
10516 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
10517 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
10518 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10519 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
10520 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
10521 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
10522 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
10523 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
10524 Name(::std::boxed::Box<Name<'tree>>),
10525 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
10526 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
10527 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
10528 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
10529 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10530 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10531 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10532 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
10533 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
10534 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
10535 String(::std::boxed::Box<String<'tree>>),
10536 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10537 VariableName(::std::boxed::Box<VariableName<'tree>>),
10538}
10539impl<'tree> ::treesitter_types::FromNode<'tree> for ClassConstantAccessExpressionChildren<'tree> {
10540 #[allow(clippy::collapsible_else_if)]
10541 fn from_node(
10542 node: ::tree_sitter::Node<'tree>,
10543 src: &'tree [u8],
10544 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10545 match node.kind() {
10546 "array_creation_expression" => {
10547 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
10548 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
10549 node, src,
10550 )?,
10551 )))
10552 }
10553 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
10554 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10555 ))),
10556 "class_constant_access_expression" => {
10557 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
10558 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
10559 node, src,
10560 )?,
10561 )))
10562 }
10563 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10564 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10565 ))),
10566 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
10567 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
10568 ))),
10569 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
10570 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10571 ))),
10572 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
10573 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
10574 ))),
10575 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
10576 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10577 ))),
10578 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
10579 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10580 ))),
10581 "name" => Ok(Self::Name(::std::boxed::Box::new(
10582 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10583 ))),
10584 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
10585 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
10586 ))),
10587 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
10588 ::std::boxed::Box::new(
10589 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
10590 node, src,
10591 )?,
10592 ),
10593 )),
10594 "nullsafe_member_call_expression" => {
10595 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
10596 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
10597 node, src,
10598 )?,
10599 )))
10600 }
10601 "object_creation_expression" => {
10602 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
10603 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
10604 node, src,
10605 )?,
10606 )))
10607 }
10608 "parenthesized_expression" => {
10609 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
10610 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
10611 node, src,
10612 )?,
10613 )))
10614 }
10615 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10616 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
10617 ))),
10618 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10619 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
10620 ))),
10621 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
10622 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)?,
10623 ))),
10624 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
10625 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10626 ))),
10627 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
10628 ::std::boxed::Box::new(
10629 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
10630 node, src,
10631 )?,
10632 ),
10633 )),
10634 "string" => Ok(Self::String(::std::boxed::Box::new(
10635 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
10636 ))),
10637 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10638 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10639 ))),
10640 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10641 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10642 ))),
10643 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10644 }
10645 }
10646}
10647impl ::treesitter_types::Spanned for ClassConstantAccessExpressionChildren<'_> {
10648 fn span(&self) -> ::treesitter_types::Span {
10649 match self {
10650 Self::ArrayCreationExpression(inner) => inner.span(),
10651 Self::CastExpression(inner) => inner.span(),
10652 Self::ClassConstantAccessExpression(inner) => inner.span(),
10653 Self::DynamicVariableName(inner) => inner.span(),
10654 Self::EncapsedString(inner) => inner.span(),
10655 Self::FunctionCallExpression(inner) => inner.span(),
10656 Self::Heredoc(inner) => inner.span(),
10657 Self::MemberAccessExpression(inner) => inner.span(),
10658 Self::MemberCallExpression(inner) => inner.span(),
10659 Self::Name(inner) => inner.span(),
10660 Self::Nowdoc(inner) => inner.span(),
10661 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
10662 Self::NullsafeMemberCallExpression(inner) => inner.span(),
10663 Self::ObjectCreationExpression(inner) => inner.span(),
10664 Self::ParenthesizedExpression(inner) => inner.span(),
10665 Self::QualifiedName(inner) => inner.span(),
10666 Self::RelativeName(inner) => inner.span(),
10667 Self::RelativeScope(inner) => inner.span(),
10668 Self::ScopedCallExpression(inner) => inner.span(),
10669 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
10670 Self::String(inner) => inner.span(),
10671 Self::SubscriptExpression(inner) => inner.span(),
10672 Self::VariableName(inner) => inner.span(),
10673 }
10674 }
10675}
10676#[derive(Debug, Clone)]
10677pub enum ClassDeclarationChildren<'tree> {
10678 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
10679 BaseClause(::std::boxed::Box<BaseClause<'tree>>),
10680 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
10681 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
10682 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
10683 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
10684 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
10685 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10686}
10687impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarationChildren<'tree> {
10688 #[allow(clippy::collapsible_else_if)]
10689 fn from_node(
10690 node: ::tree_sitter::Node<'tree>,
10691 src: &'tree [u8],
10692 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10693 match node.kind() {
10694 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
10695 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10696 ))),
10697 "base_clause" => Ok(Self::BaseClause(::std::boxed::Box::new(
10698 <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10699 ))),
10700 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
10701 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10702 ))),
10703 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
10704 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10705 ))),
10706 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
10707 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10708 ))),
10709 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
10710 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10711 ))),
10712 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
10713 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10714 ))),
10715 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10716 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10717 ))),
10718 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10719 }
10720 }
10721}
10722impl ::treesitter_types::Spanned for ClassDeclarationChildren<'_> {
10723 fn span(&self) -> ::treesitter_types::Span {
10724 match self {
10725 Self::AbstractModifier(inner) => inner.span(),
10726 Self::BaseClause(inner) => inner.span(),
10727 Self::ClassInterfaceClause(inner) => inner.span(),
10728 Self::FinalModifier(inner) => inner.span(),
10729 Self::ReadonlyModifier(inner) => inner.span(),
10730 Self::StaticModifier(inner) => inner.span(),
10731 Self::VarModifier(inner) => inner.span(),
10732 Self::VisibilityModifier(inner) => inner.span(),
10733 }
10734 }
10735}
10736#[derive(Debug, Clone)]
10737pub enum ClassInterfaceClauseChildren<'tree> {
10738 Name(::std::boxed::Box<Name<'tree>>),
10739 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
10740 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
10741}
10742impl<'tree> ::treesitter_types::FromNode<'tree> for ClassInterfaceClauseChildren<'tree> {
10743 #[allow(clippy::collapsible_else_if)]
10744 fn from_node(
10745 node: ::tree_sitter::Node<'tree>,
10746 src: &'tree [u8],
10747 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10748 match node.kind() {
10749 "name" => Ok(Self::Name(::std::boxed::Box::new(
10750 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10751 ))),
10752 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
10753 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
10754 ))),
10755 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
10756 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
10757 ))),
10758 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10759 }
10760 }
10761}
10762impl ::treesitter_types::Spanned for ClassInterfaceClauseChildren<'_> {
10763 fn span(&self) -> ::treesitter_types::Span {
10764 match self {
10765 Self::Name(inner) => inner.span(),
10766 Self::QualifiedName(inner) => inner.span(),
10767 Self::RelativeName(inner) => inner.span(),
10768 }
10769 }
10770}
10771#[derive(Debug, Clone)]
10772pub enum ConstDeclarationChildren<'tree> {
10773 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
10774 ConstElement(::std::boxed::Box<ConstElement<'tree>>),
10775 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
10776 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
10777 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
10778 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
10779 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
10780}
10781impl<'tree> ::treesitter_types::FromNode<'tree> for ConstDeclarationChildren<'tree> {
10782 #[allow(clippy::collapsible_else_if)]
10783 fn from_node(
10784 node: ::tree_sitter::Node<'tree>,
10785 src: &'tree [u8],
10786 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10787 match node.kind() {
10788 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
10789 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10790 ))),
10791 "const_element" => Ok(Self::ConstElement(::std::boxed::Box::new(
10792 <ConstElement as ::treesitter_types::FromNode>::from_node(node, src)?,
10793 ))),
10794 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
10795 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10796 ))),
10797 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
10798 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10799 ))),
10800 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
10801 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10802 ))),
10803 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
10804 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10805 ))),
10806 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
10807 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10808 ))),
10809 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10810 }
10811 }
10812}
10813impl ::treesitter_types::Spanned for ConstDeclarationChildren<'_> {
10814 fn span(&self) -> ::treesitter_types::Span {
10815 match self {
10816 Self::AbstractModifier(inner) => inner.span(),
10817 Self::ConstElement(inner) => inner.span(),
10818 Self::FinalModifier(inner) => inner.span(),
10819 Self::ReadonlyModifier(inner) => inner.span(),
10820 Self::StaticModifier(inner) => inner.span(),
10821 Self::VarModifier(inner) => inner.span(),
10822 Self::VisibilityModifier(inner) => inner.span(),
10823 }
10824 }
10825}
10826#[derive(Debug, Clone)]
10827pub enum ConstElementChildren<'tree> {
10828 Expression(::std::boxed::Box<Expression<'tree>>),
10829 Name(::std::boxed::Box<Name<'tree>>),
10830}
10831impl<'tree> ::treesitter_types::FromNode<'tree> for ConstElementChildren<'tree> {
10832 #[allow(clippy::collapsible_else_if)]
10833 fn from_node(
10834 node: ::tree_sitter::Node<'tree>,
10835 src: &'tree [u8],
10836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10837 match node.kind() {
10838 "name" => Ok(Self::Name(::std::boxed::Box::new(
10839 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10840 ))),
10841 _other => {
10842 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10843 Ok(Self::Expression(::std::boxed::Box::new(v)))
10844 } else {
10845 Err(::treesitter_types::ParseError::unexpected_kind(
10846 _other, node,
10847 ))
10848 }
10849 }
10850 }
10851 }
10852}
10853impl ::treesitter_types::Spanned for ConstElementChildren<'_> {
10854 fn span(&self) -> ::treesitter_types::Span {
10855 match self {
10856 Self::Expression(inner) => inner.span(),
10857 Self::Name(inner) => inner.span(),
10858 }
10859 }
10860}
10861#[derive(Debug, Clone)]
10862pub enum DeclarationListChildren<'tree> {
10863 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
10864 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
10865 PropertyDeclaration(::std::boxed::Box<PropertyDeclaration<'tree>>),
10866 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
10867}
10868impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationListChildren<'tree> {
10869 #[allow(clippy::collapsible_else_if)]
10870 fn from_node(
10871 node: ::tree_sitter::Node<'tree>,
10872 src: &'tree [u8],
10873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10874 match node.kind() {
10875 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
10876 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10877 ))),
10878 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
10879 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10880 ))),
10881 "property_declaration" => Ok(Self::PropertyDeclaration(::std::boxed::Box::new(
10882 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10883 ))),
10884 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
10885 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10886 ))),
10887 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10888 }
10889 }
10890}
10891impl ::treesitter_types::Spanned for DeclarationListChildren<'_> {
10892 fn span(&self) -> ::treesitter_types::Span {
10893 match self {
10894 Self::ConstDeclaration(inner) => inner.span(),
10895 Self::MethodDeclaration(inner) => inner.span(),
10896 Self::PropertyDeclaration(inner) => inner.span(),
10897 Self::UseDeclaration(inner) => inner.span(),
10898 }
10899 }
10900}
10901#[derive(Debug, Clone)]
10902pub enum DeclareStatementChildren<'tree> {
10903 DeclareDirective(::std::boxed::Box<DeclareDirective<'tree>>),
10904 Statement(::std::boxed::Box<Statement<'tree>>),
10905}
10906impl<'tree> ::treesitter_types::FromNode<'tree> for DeclareStatementChildren<'tree> {
10907 #[allow(clippy::collapsible_else_if)]
10908 fn from_node(
10909 node: ::tree_sitter::Node<'tree>,
10910 src: &'tree [u8],
10911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10912 match node.kind() {
10913 "declare_directive" => Ok(Self::DeclareDirective(::std::boxed::Box::new(
10914 <DeclareDirective as ::treesitter_types::FromNode>::from_node(node, src)?,
10915 ))),
10916 _other => {
10917 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
10918 Ok(Self::Statement(::std::boxed::Box::new(v)))
10919 } else {
10920 Err(::treesitter_types::ParseError::unexpected_kind(
10921 _other, node,
10922 ))
10923 }
10924 }
10925 }
10926 }
10927}
10928impl ::treesitter_types::Spanned for DeclareStatementChildren<'_> {
10929 fn span(&self) -> ::treesitter_types::Span {
10930 match self {
10931 Self::DeclareDirective(inner) => inner.span(),
10932 Self::Statement(inner) => inner.span(),
10933 }
10934 }
10935}
10936#[derive(Debug, Clone)]
10937pub enum DisjunctiveNormalFormTypeChildren<'tree> {
10938 IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
10939 NamedType(::std::boxed::Box<NamedType<'tree>>),
10940 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
10941 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
10942}
10943impl<'tree> ::treesitter_types::FromNode<'tree> for DisjunctiveNormalFormTypeChildren<'tree> {
10944 #[allow(clippy::collapsible_else_if)]
10945 fn from_node(
10946 node: ::tree_sitter::Node<'tree>,
10947 src: &'tree [u8],
10948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10949 match node.kind() {
10950 "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
10951 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)?,
10952 ))),
10953 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
10954 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)?,
10955 ))),
10956 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
10957 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
10958 ))),
10959 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
10960 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
10961 ))),
10962 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10963 }
10964 }
10965}
10966impl ::treesitter_types::Spanned for DisjunctiveNormalFormTypeChildren<'_> {
10967 fn span(&self) -> ::treesitter_types::Span {
10968 match self {
10969 Self::IntersectionType(inner) => inner.span(),
10970 Self::NamedType(inner) => inner.span(),
10971 Self::OptionalType(inner) => inner.span(),
10972 Self::PrimitiveType(inner) => inner.span(),
10973 }
10974 }
10975}
10976#[derive(Debug, Clone)]
10977pub enum DynamicVariableNameChildren<'tree> {
10978 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
10979 Expression(::std::boxed::Box<Expression<'tree>>),
10980 VariableName(::std::boxed::Box<VariableName<'tree>>),
10981}
10982impl<'tree> ::treesitter_types::FromNode<'tree> for DynamicVariableNameChildren<'tree> {
10983 #[allow(clippy::collapsible_else_if)]
10984 fn from_node(
10985 node: ::tree_sitter::Node<'tree>,
10986 src: &'tree [u8],
10987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10988 match node.kind() {
10989 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
10990 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10991 ))),
10992 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
10993 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
10994 ))),
10995 _other => {
10996 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10997 Ok(Self::Expression(::std::boxed::Box::new(v)))
10998 } else {
10999 Err(::treesitter_types::ParseError::unexpected_kind(
11000 _other, node,
11001 ))
11002 }
11003 }
11004 }
11005 }
11006}
11007impl ::treesitter_types::Spanned for DynamicVariableNameChildren<'_> {
11008 fn span(&self) -> ::treesitter_types::Span {
11009 match self {
11010 Self::DynamicVariableName(inner) => inner.span(),
11011 Self::Expression(inner) => inner.span(),
11012 Self::VariableName(inner) => inner.span(),
11013 }
11014 }
11015}
11016#[derive(Debug, Clone)]
11017pub enum EchoStatementChildren<'tree> {
11018 Expression(::std::boxed::Box<Expression<'tree>>),
11019 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11020}
11021impl<'tree> ::treesitter_types::FromNode<'tree> for EchoStatementChildren<'tree> {
11022 #[allow(clippy::collapsible_else_if)]
11023 fn from_node(
11024 node: ::tree_sitter::Node<'tree>,
11025 src: &'tree [u8],
11026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11027 match node.kind() {
11028 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11029 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11030 ))),
11031 _other => {
11032 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11033 Ok(Self::Expression(::std::boxed::Box::new(v)))
11034 } else {
11035 Err(::treesitter_types::ParseError::unexpected_kind(
11036 _other, node,
11037 ))
11038 }
11039 }
11040 }
11041 }
11042}
11043impl ::treesitter_types::Spanned for EchoStatementChildren<'_> {
11044 fn span(&self) -> ::treesitter_types::Span {
11045 match self {
11046 Self::Expression(inner) => inner.span(),
11047 Self::SequenceExpression(inner) => inner.span(),
11048 }
11049 }
11050}
11051#[derive(Debug, Clone)]
11052pub enum ElseClauseBody<'tree> {
11053 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11054 Statement(::std::boxed::Box<Statement<'tree>>),
11055}
11056impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClauseBody<'tree> {
11057 #[allow(clippy::collapsible_else_if)]
11058 fn from_node(
11059 node: ::tree_sitter::Node<'tree>,
11060 src: &'tree [u8],
11061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11062 match node.kind() {
11063 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11064 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
11065 ))),
11066 _other => {
11067 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
11068 Ok(Self::Statement(::std::boxed::Box::new(v)))
11069 } else {
11070 Err(::treesitter_types::ParseError::unexpected_kind(
11071 _other, node,
11072 ))
11073 }
11074 }
11075 }
11076 }
11077}
11078impl ::treesitter_types::Spanned for ElseClauseBody<'_> {
11079 fn span(&self) -> ::treesitter_types::Span {
11080 match self {
11081 Self::ColonBlock(inner) => inner.span(),
11082 Self::Statement(inner) => inner.span(),
11083 }
11084 }
11085}
11086#[derive(Debug, Clone)]
11087pub enum ElseIfClauseBody<'tree> {
11088 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11089 Statement(::std::boxed::Box<Statement<'tree>>),
11090}
11091impl<'tree> ::treesitter_types::FromNode<'tree> for ElseIfClauseBody<'tree> {
11092 #[allow(clippy::collapsible_else_if)]
11093 fn from_node(
11094 node: ::tree_sitter::Node<'tree>,
11095 src: &'tree [u8],
11096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11097 match node.kind() {
11098 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11099 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
11100 ))),
11101 _other => {
11102 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
11103 Ok(Self::Statement(::std::boxed::Box::new(v)))
11104 } else {
11105 Err(::treesitter_types::ParseError::unexpected_kind(
11106 _other, node,
11107 ))
11108 }
11109 }
11110 }
11111 }
11112}
11113impl ::treesitter_types::Spanned for ElseIfClauseBody<'_> {
11114 fn span(&self) -> ::treesitter_types::Span {
11115 match self {
11116 Self::ColonBlock(inner) => inner.span(),
11117 Self::Statement(inner) => inner.span(),
11118 }
11119 }
11120}
11121#[derive(Debug, Clone)]
11122pub enum EncapsedStringChildren<'tree> {
11123 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11124 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11125 Expression(::std::boxed::Box<Expression<'tree>>),
11126 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
11127 StringContent(::std::boxed::Box<StringContent<'tree>>),
11128 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11129 VariableName(::std::boxed::Box<VariableName<'tree>>),
11130}
11131impl<'tree> ::treesitter_types::FromNode<'tree> for EncapsedStringChildren<'tree> {
11132 #[allow(clippy::collapsible_else_if)]
11133 fn from_node(
11134 node: ::tree_sitter::Node<'tree>,
11135 src: &'tree [u8],
11136 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11137 match node.kind() {
11138 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11139 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11140 ))),
11141 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11142 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
11143 ))),
11144 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
11145 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11146 ))),
11147 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
11148 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
11149 ))),
11150 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11151 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11152 ))),
11153 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11154 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11155 ))),
11156 _other => {
11157 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11158 Ok(Self::Expression(::std::boxed::Box::new(v)))
11159 } else {
11160 Err(::treesitter_types::ParseError::unexpected_kind(
11161 _other, node,
11162 ))
11163 }
11164 }
11165 }
11166 }
11167}
11168impl ::treesitter_types::Spanned for EncapsedStringChildren<'_> {
11169 fn span(&self) -> ::treesitter_types::Span {
11170 match self {
11171 Self::DynamicVariableName(inner) => inner.span(),
11172 Self::EscapeSequence(inner) => inner.span(),
11173 Self::Expression(inner) => inner.span(),
11174 Self::MemberAccessExpression(inner) => inner.span(),
11175 Self::StringContent(inner) => inner.span(),
11176 Self::SubscriptExpression(inner) => inner.span(),
11177 Self::VariableName(inner) => inner.span(),
11178 }
11179 }
11180}
11181#[derive(Debug, Clone)]
11182pub enum EnumDeclarationChildren<'tree> {
11183 ClassInterfaceClause(::std::boxed::Box<ClassInterfaceClause<'tree>>),
11184 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11185}
11186impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationChildren<'tree> {
11187 #[allow(clippy::collapsible_else_if)]
11188 fn from_node(
11189 node: ::tree_sitter::Node<'tree>,
11190 src: &'tree [u8],
11191 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11192 match node.kind() {
11193 "class_interface_clause" => Ok(Self::ClassInterfaceClause(::std::boxed::Box::new(
11194 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11195 ))),
11196 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11197 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11198 ))),
11199 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11200 }
11201 }
11202}
11203impl ::treesitter_types::Spanned for EnumDeclarationChildren<'_> {
11204 fn span(&self) -> ::treesitter_types::Span {
11205 match self {
11206 Self::ClassInterfaceClause(inner) => inner.span(),
11207 Self::PrimitiveType(inner) => inner.span(),
11208 }
11209 }
11210}
11211#[derive(Debug, Clone)]
11212pub enum EnumDeclarationListChildren<'tree> {
11213 ConstDeclaration(::std::boxed::Box<ConstDeclaration<'tree>>),
11214 EnumCase(::std::boxed::Box<EnumCase<'tree>>),
11215 MethodDeclaration(::std::boxed::Box<MethodDeclaration<'tree>>),
11216 UseDeclaration(::std::boxed::Box<UseDeclaration<'tree>>),
11217}
11218impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclarationListChildren<'tree> {
11219 #[allow(clippy::collapsible_else_if)]
11220 fn from_node(
11221 node: ::tree_sitter::Node<'tree>,
11222 src: &'tree [u8],
11223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11224 match node.kind() {
11225 "const_declaration" => Ok(Self::ConstDeclaration(::std::boxed::Box::new(
11226 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
11227 ))),
11228 "enum_case" => Ok(Self::EnumCase(::std::boxed::Box::new(
11229 <EnumCase as ::treesitter_types::FromNode>::from_node(node, src)?,
11230 ))),
11231 "method_declaration" => Ok(Self::MethodDeclaration(::std::boxed::Box::new(
11232 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
11233 ))),
11234 "use_declaration" => Ok(Self::UseDeclaration(::std::boxed::Box::new(
11235 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
11236 ))),
11237 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11238 }
11239 }
11240}
11241impl ::treesitter_types::Spanned for EnumDeclarationListChildren<'_> {
11242 fn span(&self) -> ::treesitter_types::Span {
11243 match self {
11244 Self::ConstDeclaration(inner) => inner.span(),
11245 Self::EnumCase(inner) => inner.span(),
11246 Self::MethodDeclaration(inner) => inner.span(),
11247 Self::UseDeclaration(inner) => inner.span(),
11248 }
11249 }
11250}
11251#[derive(Debug, Clone)]
11252pub enum ForStatementCondition<'tree> {
11253 Expression(::std::boxed::Box<Expression<'tree>>),
11254 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11255}
11256impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
11257 #[allow(clippy::collapsible_else_if)]
11258 fn from_node(
11259 node: ::tree_sitter::Node<'tree>,
11260 src: &'tree [u8],
11261 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11262 match node.kind() {
11263 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11264 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11265 ))),
11266 _other => {
11267 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11268 Ok(Self::Expression(::std::boxed::Box::new(v)))
11269 } else {
11270 Err(::treesitter_types::ParseError::unexpected_kind(
11271 _other, node,
11272 ))
11273 }
11274 }
11275 }
11276 }
11277}
11278impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
11279 fn span(&self) -> ::treesitter_types::Span {
11280 match self {
11281 Self::Expression(inner) => inner.span(),
11282 Self::SequenceExpression(inner) => inner.span(),
11283 }
11284 }
11285}
11286#[derive(Debug, Clone)]
11287pub enum ForStatementInitialize<'tree> {
11288 Expression(::std::boxed::Box<Expression<'tree>>),
11289 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11290}
11291impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitialize<'tree> {
11292 #[allow(clippy::collapsible_else_if)]
11293 fn from_node(
11294 node: ::tree_sitter::Node<'tree>,
11295 src: &'tree [u8],
11296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11297 match node.kind() {
11298 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11299 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11300 ))),
11301 _other => {
11302 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11303 Ok(Self::Expression(::std::boxed::Box::new(v)))
11304 } else {
11305 Err(::treesitter_types::ParseError::unexpected_kind(
11306 _other, node,
11307 ))
11308 }
11309 }
11310 }
11311 }
11312}
11313impl ::treesitter_types::Spanned for ForStatementInitialize<'_> {
11314 fn span(&self) -> ::treesitter_types::Span {
11315 match self {
11316 Self::Expression(inner) => inner.span(),
11317 Self::SequenceExpression(inner) => inner.span(),
11318 }
11319 }
11320}
11321#[derive(Debug, Clone)]
11322pub enum ForStatementUpdate<'tree> {
11323 Expression(::std::boxed::Box<Expression<'tree>>),
11324 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
11325}
11326impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementUpdate<'tree> {
11327 #[allow(clippy::collapsible_else_if)]
11328 fn from_node(
11329 node: ::tree_sitter::Node<'tree>,
11330 src: &'tree [u8],
11331 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11332 match node.kind() {
11333 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
11334 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11335 ))),
11336 _other => {
11337 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11338 Ok(Self::Expression(::std::boxed::Box::new(v)))
11339 } else {
11340 Err(::treesitter_types::ParseError::unexpected_kind(
11341 _other, node,
11342 ))
11343 }
11344 }
11345 }
11346 }
11347}
11348impl ::treesitter_types::Spanned for ForStatementUpdate<'_> {
11349 fn span(&self) -> ::treesitter_types::Span {
11350 match self {
11351 Self::Expression(inner) => inner.span(),
11352 Self::SequenceExpression(inner) => inner.span(),
11353 }
11354 }
11355}
11356#[derive(Debug, Clone)]
11357pub enum ForeachStatementBody<'tree> {
11358 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11359 Statement(::std::boxed::Box<Statement<'tree>>),
11360}
11361impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementBody<'tree> {
11362 #[allow(clippy::collapsible_else_if)]
11363 fn from_node(
11364 node: ::tree_sitter::Node<'tree>,
11365 src: &'tree [u8],
11366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11367 match node.kind() {
11368 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11369 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
11370 ))),
11371 _other => {
11372 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
11373 Ok(Self::Statement(::std::boxed::Box::new(v)))
11374 } else {
11375 Err(::treesitter_types::ParseError::unexpected_kind(
11376 _other, node,
11377 ))
11378 }
11379 }
11380 }
11381 }
11382}
11383impl ::treesitter_types::Spanned for ForeachStatementBody<'_> {
11384 fn span(&self) -> ::treesitter_types::Span {
11385 match self {
11386 Self::ColonBlock(inner) => inner.span(),
11387 Self::Statement(inner) => inner.span(),
11388 }
11389 }
11390}
11391#[derive(Debug, Clone)]
11392pub enum ForeachStatementChildren<'tree> {
11393 ByRef(::std::boxed::Box<ByRef<'tree>>),
11394 Expression(::std::boxed::Box<Expression<'tree>>),
11395 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
11396 Pair(::std::boxed::Box<Pair<'tree>>),
11397}
11398impl<'tree> ::treesitter_types::FromNode<'tree> for ForeachStatementChildren<'tree> {
11399 #[allow(clippy::collapsible_else_if)]
11400 fn from_node(
11401 node: ::tree_sitter::Node<'tree>,
11402 src: &'tree [u8],
11403 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11404 match node.kind() {
11405 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
11406 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
11407 ))),
11408 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
11409 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11410 ))),
11411 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
11412 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
11413 ))),
11414 _other => {
11415 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11416 Ok(Self::Expression(::std::boxed::Box::new(v)))
11417 } else {
11418 Err(::treesitter_types::ParseError::unexpected_kind(
11419 _other, node,
11420 ))
11421 }
11422 }
11423 }
11424 }
11425}
11426impl ::treesitter_types::Spanned for ForeachStatementChildren<'_> {
11427 fn span(&self) -> ::treesitter_types::Span {
11428 match self {
11429 Self::ByRef(inner) => inner.span(),
11430 Self::Expression(inner) => inner.span(),
11431 Self::ListLiteral(inner) => inner.span(),
11432 Self::Pair(inner) => inner.span(),
11433 }
11434 }
11435}
11436#[derive(Debug, Clone)]
11437pub enum FormalParametersChildren<'tree> {
11438 PropertyPromotionParameter(::std::boxed::Box<PropertyPromotionParameter<'tree>>),
11439 SimpleParameter(::std::boxed::Box<SimpleParameter<'tree>>),
11440 VariadicParameter(::std::boxed::Box<VariadicParameter<'tree>>),
11441}
11442impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
11443 #[allow(clippy::collapsible_else_if)]
11444 fn from_node(
11445 node: ::tree_sitter::Node<'tree>,
11446 src: &'tree [u8],
11447 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11448 match node.kind() {
11449 "property_promotion_parameter" => {
11450 Ok(Self::PropertyPromotionParameter(::std::boxed::Box::new(
11451 <PropertyPromotionParameter as ::treesitter_types::FromNode>::from_node(
11452 node, src,
11453 )?,
11454 )))
11455 }
11456 "simple_parameter" => Ok(Self::SimpleParameter(::std::boxed::Box::new(
11457 <SimpleParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
11458 ))),
11459 "variadic_parameter" => Ok(Self::VariadicParameter(::std::boxed::Box::new(
11460 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
11461 ))),
11462 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11463 }
11464 }
11465}
11466impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
11467 fn span(&self) -> ::treesitter_types::Span {
11468 match self {
11469 Self::PropertyPromotionParameter(inner) => inner.span(),
11470 Self::SimpleParameter(inner) => inner.span(),
11471 Self::VariadicParameter(inner) => inner.span(),
11472 }
11473 }
11474}
11475#[derive(Debug, Clone)]
11476pub enum FunctionCallExpressionFunction<'tree> {
11477 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
11478 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11479 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
11480 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
11481 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
11482 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
11483 Name(::std::boxed::Box<Name<'tree>>),
11484 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
11485 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
11486 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
11487 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
11488 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
11489 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
11490 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
11491 String(::std::boxed::Box<String<'tree>>),
11492 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11493 VariableName(::std::boxed::Box<VariableName<'tree>>),
11494}
11495impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionCallExpressionFunction<'tree> {
11496 #[allow(clippy::collapsible_else_if)]
11497 fn from_node(
11498 node: ::tree_sitter::Node<'tree>,
11499 src: &'tree [u8],
11500 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11501 match node.kind() {
11502 "array_creation_expression" => {
11503 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
11504 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
11505 node, src,
11506 )?,
11507 )))
11508 }
11509 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11510 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11511 ))),
11512 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
11513 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
11514 ))),
11515 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
11516 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11517 ))),
11518 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
11519 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
11520 ))),
11521 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
11522 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11523 ))),
11524 "name" => Ok(Self::Name(::std::boxed::Box::new(
11525 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11526 ))),
11527 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
11528 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
11529 ))),
11530 "nullsafe_member_call_expression" => {
11531 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
11532 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
11533 node, src,
11534 )?,
11535 )))
11536 }
11537 "object_creation_expression" => {
11538 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
11539 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
11540 node, src,
11541 )?,
11542 )))
11543 }
11544 "parenthesized_expression" => {
11545 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
11546 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
11547 node, src,
11548 )?,
11549 )))
11550 }
11551 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
11552 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
11553 ))),
11554 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
11555 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
11556 ))),
11557 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
11558 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11559 ))),
11560 "string" => Ok(Self::String(::std::boxed::Box::new(
11561 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11562 ))),
11563 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11564 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11565 ))),
11566 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11567 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11568 ))),
11569 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11570 }
11571 }
11572}
11573impl ::treesitter_types::Spanned for FunctionCallExpressionFunction<'_> {
11574 fn span(&self) -> ::treesitter_types::Span {
11575 match self {
11576 Self::ArrayCreationExpression(inner) => inner.span(),
11577 Self::DynamicVariableName(inner) => inner.span(),
11578 Self::EncapsedString(inner) => inner.span(),
11579 Self::FunctionCallExpression(inner) => inner.span(),
11580 Self::Heredoc(inner) => inner.span(),
11581 Self::MemberCallExpression(inner) => inner.span(),
11582 Self::Name(inner) => inner.span(),
11583 Self::Nowdoc(inner) => inner.span(),
11584 Self::NullsafeMemberCallExpression(inner) => inner.span(),
11585 Self::ObjectCreationExpression(inner) => inner.span(),
11586 Self::ParenthesizedExpression(inner) => inner.span(),
11587 Self::QualifiedName(inner) => inner.span(),
11588 Self::RelativeName(inner) => inner.span(),
11589 Self::ScopedCallExpression(inner) => inner.span(),
11590 Self::String(inner) => inner.span(),
11591 Self::SubscriptExpression(inner) => inner.span(),
11592 Self::VariableName(inner) => inner.span(),
11593 }
11594 }
11595}
11596#[derive(Debug, Clone)]
11597pub enum FunctionDefinitionReturnType<'tree> {
11598 BottomType(::std::boxed::Box<BottomType<'tree>>),
11599 Type(::std::boxed::Box<Type<'tree>>),
11600}
11601impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDefinitionReturnType<'tree> {
11602 #[allow(clippy::collapsible_else_if)]
11603 fn from_node(
11604 node: ::tree_sitter::Node<'tree>,
11605 src: &'tree [u8],
11606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11607 match node.kind() {
11608 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
11609 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)?,
11610 ))),
11611 _other => {
11612 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11613 Ok(Self::Type(::std::boxed::Box::new(v)))
11614 } else {
11615 Err(::treesitter_types::ParseError::unexpected_kind(
11616 _other, node,
11617 ))
11618 }
11619 }
11620 }
11621 }
11622}
11623impl ::treesitter_types::Spanned for FunctionDefinitionReturnType<'_> {
11624 fn span(&self) -> ::treesitter_types::Span {
11625 match self {
11626 Self::BottomType(inner) => inner.span(),
11627 Self::Type(inner) => inner.span(),
11628 }
11629 }
11630}
11631#[derive(Debug, Clone)]
11632pub enum GlobalDeclarationChildren<'tree> {
11633 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11634 VariableName(::std::boxed::Box<VariableName<'tree>>),
11635}
11636impl<'tree> ::treesitter_types::FromNode<'tree> for GlobalDeclarationChildren<'tree> {
11637 #[allow(clippy::collapsible_else_if)]
11638 fn from_node(
11639 node: ::tree_sitter::Node<'tree>,
11640 src: &'tree [u8],
11641 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11642 match node.kind() {
11643 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11644 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11645 ))),
11646 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11647 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11648 ))),
11649 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11650 }
11651 }
11652}
11653impl ::treesitter_types::Spanned for GlobalDeclarationChildren<'_> {
11654 fn span(&self) -> ::treesitter_types::Span {
11655 match self {
11656 Self::DynamicVariableName(inner) => inner.span(),
11657 Self::VariableName(inner) => inner.span(),
11658 }
11659 }
11660}
11661#[derive(Debug, Clone)]
11662pub enum HeredocBodyChildren<'tree> {
11663 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11664 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
11665 Expression(::std::boxed::Box<Expression<'tree>>),
11666 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
11667 StringContent(::std::boxed::Box<StringContent<'tree>>),
11668 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11669 VariableName(::std::boxed::Box<VariableName<'tree>>),
11670}
11671impl<'tree> ::treesitter_types::FromNode<'tree> for HeredocBodyChildren<'tree> {
11672 #[allow(clippy::collapsible_else_if)]
11673 fn from_node(
11674 node: ::tree_sitter::Node<'tree>,
11675 src: &'tree [u8],
11676 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11677 match node.kind() {
11678 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11679 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11680 ))),
11681 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
11682 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
11683 ))),
11684 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
11685 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11686 ))),
11687 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
11688 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
11689 ))),
11690 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11691 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11692 ))),
11693 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11694 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11695 ))),
11696 _other => {
11697 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11698 Ok(Self::Expression(::std::boxed::Box::new(v)))
11699 } else {
11700 Err(::treesitter_types::ParseError::unexpected_kind(
11701 _other, node,
11702 ))
11703 }
11704 }
11705 }
11706 }
11707}
11708impl ::treesitter_types::Spanned for HeredocBodyChildren<'_> {
11709 fn span(&self) -> ::treesitter_types::Span {
11710 match self {
11711 Self::DynamicVariableName(inner) => inner.span(),
11712 Self::EscapeSequence(inner) => inner.span(),
11713 Self::Expression(inner) => inner.span(),
11714 Self::MemberAccessExpression(inner) => inner.span(),
11715 Self::StringContent(inner) => inner.span(),
11716 Self::SubscriptExpression(inner) => inner.span(),
11717 Self::VariableName(inner) => inner.span(),
11718 }
11719 }
11720}
11721#[derive(Debug, Clone)]
11722pub enum IfStatementAlternative<'tree> {
11723 ElseClause(::std::boxed::Box<ElseClause<'tree>>),
11724 ElseIfClause(::std::boxed::Box<ElseIfClause<'tree>>),
11725}
11726impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementAlternative<'tree> {
11727 #[allow(clippy::collapsible_else_if)]
11728 fn from_node(
11729 node: ::tree_sitter::Node<'tree>,
11730 src: &'tree [u8],
11731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11732 match node.kind() {
11733 "else_clause" => Ok(Self::ElseClause(::std::boxed::Box::new(
11734 <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11735 ))),
11736 "else_if_clause" => Ok(Self::ElseIfClause(::std::boxed::Box::new(
11737 <ElseIfClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11738 ))),
11739 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11740 }
11741 }
11742}
11743impl ::treesitter_types::Spanned for IfStatementAlternative<'_> {
11744 fn span(&self) -> ::treesitter_types::Span {
11745 match self {
11746 Self::ElseClause(inner) => inner.span(),
11747 Self::ElseIfClause(inner) => inner.span(),
11748 }
11749 }
11750}
11751#[derive(Debug, Clone)]
11752pub enum IfStatementBody<'tree> {
11753 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
11754 Statement(::std::boxed::Box<Statement<'tree>>),
11755}
11756impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatementBody<'tree> {
11757 #[allow(clippy::collapsible_else_if)]
11758 fn from_node(
11759 node: ::tree_sitter::Node<'tree>,
11760 src: &'tree [u8],
11761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11762 match node.kind() {
11763 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
11764 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
11765 ))),
11766 _other => {
11767 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
11768 Ok(Self::Statement(::std::boxed::Box::new(v)))
11769 } else {
11770 Err(::treesitter_types::ParseError::unexpected_kind(
11771 _other, node,
11772 ))
11773 }
11774 }
11775 }
11776 }
11777}
11778impl ::treesitter_types::Spanned for IfStatementBody<'_> {
11779 fn span(&self) -> ::treesitter_types::Span {
11780 match self {
11781 Self::ColonBlock(inner) => inner.span(),
11782 Self::Statement(inner) => inner.span(),
11783 }
11784 }
11785}
11786#[derive(Debug, Clone)]
11787pub enum IntersectionTypeChildren<'tree> {
11788 NamedType(::std::boxed::Box<NamedType<'tree>>),
11789 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
11790 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
11791}
11792impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionTypeChildren<'tree> {
11793 #[allow(clippy::collapsible_else_if)]
11794 fn from_node(
11795 node: ::tree_sitter::Node<'tree>,
11796 src: &'tree [u8],
11797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11798 match node.kind() {
11799 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
11800 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)?,
11801 ))),
11802 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
11803 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
11804 ))),
11805 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
11806 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
11807 ))),
11808 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11809 }
11810 }
11811}
11812impl ::treesitter_types::Spanned for IntersectionTypeChildren<'_> {
11813 fn span(&self) -> ::treesitter_types::Span {
11814 match self {
11815 Self::NamedType(inner) => inner.span(),
11816 Self::OptionalType(inner) => inner.span(),
11817 Self::PrimitiveType(inner) => inner.span(),
11818 }
11819 }
11820}
11821#[derive(Debug, Clone)]
11822pub enum ListLiteralChildren<'tree> {
11823 ByRef(::std::boxed::Box<ByRef<'tree>>),
11824 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11825 Expression(::std::boxed::Box<Expression<'tree>>),
11826 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
11827 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
11828 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
11829 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
11830 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
11831 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
11832 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
11833 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
11834 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11835 VariableName(::std::boxed::Box<VariableName<'tree>>),
11836}
11837impl<'tree> ::treesitter_types::FromNode<'tree> for ListLiteralChildren<'tree> {
11838 #[allow(clippy::collapsible_else_if)]
11839 fn from_node(
11840 node: ::tree_sitter::Node<'tree>,
11841 src: &'tree [u8],
11842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11843 match node.kind() {
11844 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
11845 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
11846 ))),
11847 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11848 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11849 ))),
11850 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
11851 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11852 ))),
11853 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
11854 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
11855 ))),
11856 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
11857 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11858 ))),
11859 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
11860 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11861 ))),
11862 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
11863 ::std::boxed::Box::new(
11864 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
11865 node, src,
11866 )?,
11867 ),
11868 )),
11869 "nullsafe_member_call_expression" => {
11870 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
11871 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
11872 node, src,
11873 )?,
11874 )))
11875 }
11876 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
11877 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11878 ))),
11879 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
11880 ::std::boxed::Box::new(
11881 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
11882 node, src,
11883 )?,
11884 ),
11885 )),
11886 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11887 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11888 ))),
11889 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11890 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11891 ))),
11892 _other => {
11893 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11894 Ok(Self::Expression(::std::boxed::Box::new(v)))
11895 } else {
11896 Err(::treesitter_types::ParseError::unexpected_kind(
11897 _other, node,
11898 ))
11899 }
11900 }
11901 }
11902 }
11903}
11904impl ::treesitter_types::Spanned for ListLiteralChildren<'_> {
11905 fn span(&self) -> ::treesitter_types::Span {
11906 match self {
11907 Self::ByRef(inner) => inner.span(),
11908 Self::DynamicVariableName(inner) => inner.span(),
11909 Self::Expression(inner) => inner.span(),
11910 Self::FunctionCallExpression(inner) => inner.span(),
11911 Self::ListLiteral(inner) => inner.span(),
11912 Self::MemberAccessExpression(inner) => inner.span(),
11913 Self::MemberCallExpression(inner) => inner.span(),
11914 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
11915 Self::NullsafeMemberCallExpression(inner) => inner.span(),
11916 Self::ScopedCallExpression(inner) => inner.span(),
11917 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
11918 Self::SubscriptExpression(inner) => inner.span(),
11919 Self::VariableName(inner) => inner.span(),
11920 }
11921 }
11922}
11923#[derive(Debug, Clone)]
11924pub enum MatchBlockChildren<'tree> {
11925 MatchConditionalExpression(::std::boxed::Box<MatchConditionalExpression<'tree>>),
11926 MatchDefaultExpression(::std::boxed::Box<MatchDefaultExpression<'tree>>),
11927}
11928impl<'tree> ::treesitter_types::FromNode<'tree> for MatchBlockChildren<'tree> {
11929 #[allow(clippy::collapsible_else_if)]
11930 fn from_node(
11931 node: ::tree_sitter::Node<'tree>,
11932 src: &'tree [u8],
11933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11934 match node.kind() {
11935 "match_conditional_expression" => {
11936 Ok(Self::MatchConditionalExpression(::std::boxed::Box::new(
11937 <MatchConditionalExpression as ::treesitter_types::FromNode>::from_node(
11938 node, src,
11939 )?,
11940 )))
11941 }
11942 "match_default_expression" => Ok(Self::MatchDefaultExpression(::std::boxed::Box::new(
11943 <MatchDefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11944 ))),
11945 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11946 }
11947 }
11948}
11949impl ::treesitter_types::Spanned for MatchBlockChildren<'_> {
11950 fn span(&self) -> ::treesitter_types::Span {
11951 match self {
11952 Self::MatchConditionalExpression(inner) => inner.span(),
11953 Self::MatchDefaultExpression(inner) => inner.span(),
11954 }
11955 }
11956}
11957#[derive(Debug, Clone)]
11958pub enum MemberAccessExpressionName<'tree> {
11959 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
11960 Expression(::std::boxed::Box<Expression<'tree>>),
11961 Name(::std::boxed::Box<Name<'tree>>),
11962 VariableName(::std::boxed::Box<VariableName<'tree>>),
11963}
11964impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionName<'tree> {
11965 #[allow(clippy::collapsible_else_if)]
11966 fn from_node(
11967 node: ::tree_sitter::Node<'tree>,
11968 src: &'tree [u8],
11969 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11970 match node.kind() {
11971 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
11972 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11973 ))),
11974 "name" => Ok(Self::Name(::std::boxed::Box::new(
11975 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11976 ))),
11977 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
11978 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
11979 ))),
11980 _other => {
11981 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11982 Ok(Self::Expression(::std::boxed::Box::new(v)))
11983 } else {
11984 Err(::treesitter_types::ParseError::unexpected_kind(
11985 _other, node,
11986 ))
11987 }
11988 }
11989 }
11990 }
11991}
11992impl ::treesitter_types::Spanned for MemberAccessExpressionName<'_> {
11993 fn span(&self) -> ::treesitter_types::Span {
11994 match self {
11995 Self::DynamicVariableName(inner) => inner.span(),
11996 Self::Expression(inner) => inner.span(),
11997 Self::Name(inner) => inner.span(),
11998 Self::VariableName(inner) => inner.span(),
11999 }
12000 }
12001}
12002#[derive(Debug, Clone)]
12003pub enum MemberAccessExpressionObject<'tree> {
12004 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12005 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12006 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12007 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12008 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12009 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12010 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12011 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12012 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12013 Name(::std::boxed::Box<Name<'tree>>),
12014 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12015 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12016 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12017 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12018 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12019 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12020 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12021 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12022 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12023 String(::std::boxed::Box<String<'tree>>),
12024 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12025 VariableName(::std::boxed::Box<VariableName<'tree>>),
12026}
12027impl<'tree> ::treesitter_types::FromNode<'tree> for MemberAccessExpressionObject<'tree> {
12028 #[allow(clippy::collapsible_else_if)]
12029 fn from_node(
12030 node: ::tree_sitter::Node<'tree>,
12031 src: &'tree [u8],
12032 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12033 match node.kind() {
12034 "array_creation_expression" => {
12035 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
12036 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
12037 node, src,
12038 )?,
12039 )))
12040 }
12041 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12042 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12043 ))),
12044 "class_constant_access_expression" => {
12045 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
12046 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
12047 node, src,
12048 )?,
12049 )))
12050 }
12051 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12052 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12053 ))),
12054 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12055 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
12056 ))),
12057 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12058 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12059 ))),
12060 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12061 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12062 ))),
12063 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12064 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12065 ))),
12066 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12067 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12068 ))),
12069 "name" => Ok(Self::Name(::std::boxed::Box::new(
12070 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12071 ))),
12072 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12073 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12074 ))),
12075 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12076 ::std::boxed::Box::new(
12077 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12078 node, src,
12079 )?,
12080 ),
12081 )),
12082 "nullsafe_member_call_expression" => {
12083 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
12084 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12085 node, src,
12086 )?,
12087 )))
12088 }
12089 "object_creation_expression" => {
12090 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
12091 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
12092 node, src,
12093 )?,
12094 )))
12095 }
12096 "parenthesized_expression" => {
12097 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
12098 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
12099 node, src,
12100 )?,
12101 )))
12102 }
12103 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12104 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12105 ))),
12106 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12107 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
12108 ))),
12109 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12110 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12111 ))),
12112 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12113 ::std::boxed::Box::new(
12114 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12115 node, src,
12116 )?,
12117 ),
12118 )),
12119 "string" => Ok(Self::String(::std::boxed::Box::new(
12120 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12121 ))),
12122 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12123 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12124 ))),
12125 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12126 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12127 ))),
12128 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12129 }
12130 }
12131}
12132impl ::treesitter_types::Spanned for MemberAccessExpressionObject<'_> {
12133 fn span(&self) -> ::treesitter_types::Span {
12134 match self {
12135 Self::ArrayCreationExpression(inner) => inner.span(),
12136 Self::CastExpression(inner) => inner.span(),
12137 Self::ClassConstantAccessExpression(inner) => inner.span(),
12138 Self::DynamicVariableName(inner) => inner.span(),
12139 Self::EncapsedString(inner) => inner.span(),
12140 Self::FunctionCallExpression(inner) => inner.span(),
12141 Self::Heredoc(inner) => inner.span(),
12142 Self::MemberAccessExpression(inner) => inner.span(),
12143 Self::MemberCallExpression(inner) => inner.span(),
12144 Self::Name(inner) => inner.span(),
12145 Self::Nowdoc(inner) => inner.span(),
12146 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12147 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12148 Self::ObjectCreationExpression(inner) => inner.span(),
12149 Self::ParenthesizedExpression(inner) => inner.span(),
12150 Self::QualifiedName(inner) => inner.span(),
12151 Self::RelativeName(inner) => inner.span(),
12152 Self::ScopedCallExpression(inner) => inner.span(),
12153 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
12154 Self::String(inner) => inner.span(),
12155 Self::SubscriptExpression(inner) => inner.span(),
12156 Self::VariableName(inner) => inner.span(),
12157 }
12158 }
12159}
12160#[derive(Debug, Clone)]
12161pub enum MemberCallExpressionName<'tree> {
12162 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12163 Expression(::std::boxed::Box<Expression<'tree>>),
12164 Name(::std::boxed::Box<Name<'tree>>),
12165 VariableName(::std::boxed::Box<VariableName<'tree>>),
12166}
12167impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpressionName<'tree> {
12168 #[allow(clippy::collapsible_else_if)]
12169 fn from_node(
12170 node: ::tree_sitter::Node<'tree>,
12171 src: &'tree [u8],
12172 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12173 match node.kind() {
12174 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12175 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12176 ))),
12177 "name" => Ok(Self::Name(::std::boxed::Box::new(
12178 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12179 ))),
12180 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12181 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12182 ))),
12183 _other => {
12184 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12185 Ok(Self::Expression(::std::boxed::Box::new(v)))
12186 } else {
12187 Err(::treesitter_types::ParseError::unexpected_kind(
12188 _other, node,
12189 ))
12190 }
12191 }
12192 }
12193 }
12194}
12195impl ::treesitter_types::Spanned for MemberCallExpressionName<'_> {
12196 fn span(&self) -> ::treesitter_types::Span {
12197 match self {
12198 Self::DynamicVariableName(inner) => inner.span(),
12199 Self::Expression(inner) => inner.span(),
12200 Self::Name(inner) => inner.span(),
12201 Self::VariableName(inner) => inner.span(),
12202 }
12203 }
12204}
12205#[derive(Debug, Clone)]
12206pub enum MemberCallExpressionObject<'tree> {
12207 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12208 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12209 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12210 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12211 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12212 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12213 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12214 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12215 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12216 Name(::std::boxed::Box<Name<'tree>>),
12217 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12218 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12219 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12220 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12221 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12222 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12223 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12224 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12225 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12226 String(::std::boxed::Box<String<'tree>>),
12227 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12228 VariableName(::std::boxed::Box<VariableName<'tree>>),
12229}
12230impl<'tree> ::treesitter_types::FromNode<'tree> for MemberCallExpressionObject<'tree> {
12231 #[allow(clippy::collapsible_else_if)]
12232 fn from_node(
12233 node: ::tree_sitter::Node<'tree>,
12234 src: &'tree [u8],
12235 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12236 match node.kind() {
12237 "array_creation_expression" => {
12238 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
12239 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
12240 node, src,
12241 )?,
12242 )))
12243 }
12244 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12245 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12246 ))),
12247 "class_constant_access_expression" => {
12248 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
12249 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
12250 node, src,
12251 )?,
12252 )))
12253 }
12254 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12255 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12256 ))),
12257 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12258 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
12259 ))),
12260 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12261 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12262 ))),
12263 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12264 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12265 ))),
12266 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12267 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12268 ))),
12269 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12270 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12271 ))),
12272 "name" => Ok(Self::Name(::std::boxed::Box::new(
12273 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12274 ))),
12275 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12276 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12277 ))),
12278 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12279 ::std::boxed::Box::new(
12280 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12281 node, src,
12282 )?,
12283 ),
12284 )),
12285 "nullsafe_member_call_expression" => {
12286 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
12287 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12288 node, src,
12289 )?,
12290 )))
12291 }
12292 "object_creation_expression" => {
12293 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
12294 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
12295 node, src,
12296 )?,
12297 )))
12298 }
12299 "parenthesized_expression" => {
12300 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
12301 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
12302 node, src,
12303 )?,
12304 )))
12305 }
12306 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12307 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12308 ))),
12309 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12310 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
12311 ))),
12312 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12313 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12314 ))),
12315 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12316 ::std::boxed::Box::new(
12317 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12318 node, src,
12319 )?,
12320 ),
12321 )),
12322 "string" => Ok(Self::String(::std::boxed::Box::new(
12323 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12324 ))),
12325 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12326 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12327 ))),
12328 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12329 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12330 ))),
12331 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12332 }
12333 }
12334}
12335impl ::treesitter_types::Spanned for MemberCallExpressionObject<'_> {
12336 fn span(&self) -> ::treesitter_types::Span {
12337 match self {
12338 Self::ArrayCreationExpression(inner) => inner.span(),
12339 Self::CastExpression(inner) => inner.span(),
12340 Self::ClassConstantAccessExpression(inner) => inner.span(),
12341 Self::DynamicVariableName(inner) => inner.span(),
12342 Self::EncapsedString(inner) => inner.span(),
12343 Self::FunctionCallExpression(inner) => inner.span(),
12344 Self::Heredoc(inner) => inner.span(),
12345 Self::MemberAccessExpression(inner) => inner.span(),
12346 Self::MemberCallExpression(inner) => inner.span(),
12347 Self::Name(inner) => inner.span(),
12348 Self::Nowdoc(inner) => inner.span(),
12349 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12350 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12351 Self::ObjectCreationExpression(inner) => inner.span(),
12352 Self::ParenthesizedExpression(inner) => inner.span(),
12353 Self::QualifiedName(inner) => inner.span(),
12354 Self::RelativeName(inner) => inner.span(),
12355 Self::ScopedCallExpression(inner) => inner.span(),
12356 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
12357 Self::String(inner) => inner.span(),
12358 Self::SubscriptExpression(inner) => inner.span(),
12359 Self::VariableName(inner) => inner.span(),
12360 }
12361 }
12362}
12363#[derive(Debug, Clone)]
12364pub enum MethodDeclarationReturnType<'tree> {
12365 BottomType(::std::boxed::Box<BottomType<'tree>>),
12366 Type(::std::boxed::Box<Type<'tree>>),
12367}
12368impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationReturnType<'tree> {
12369 #[allow(clippy::collapsible_else_if)]
12370 fn from_node(
12371 node: ::tree_sitter::Node<'tree>,
12372 src: &'tree [u8],
12373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12374 match node.kind() {
12375 "bottom_type" => Ok(Self::BottomType(::std::boxed::Box::new(
12376 <BottomType as ::treesitter_types::FromNode>::from_node(node, src)?,
12377 ))),
12378 _other => {
12379 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
12380 Ok(Self::Type(::std::boxed::Box::new(v)))
12381 } else {
12382 Err(::treesitter_types::ParseError::unexpected_kind(
12383 _other, node,
12384 ))
12385 }
12386 }
12387 }
12388 }
12389}
12390impl ::treesitter_types::Spanned for MethodDeclarationReturnType<'_> {
12391 fn span(&self) -> ::treesitter_types::Span {
12392 match self {
12393 Self::BottomType(inner) => inner.span(),
12394 Self::Type(inner) => inner.span(),
12395 }
12396 }
12397}
12398#[derive(Debug, Clone)]
12399pub enum MethodDeclarationChildren<'tree> {
12400 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
12401 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
12402 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
12403 ReferenceModifier(::std::boxed::Box<ReferenceModifier<'tree>>),
12404 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
12405 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
12406 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
12407}
12408impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDeclarationChildren<'tree> {
12409 #[allow(clippy::collapsible_else_if)]
12410 fn from_node(
12411 node: ::tree_sitter::Node<'tree>,
12412 src: &'tree [u8],
12413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12414 match node.kind() {
12415 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
12416 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12417 ))),
12418 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
12419 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12420 ))),
12421 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
12422 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12423 ))),
12424 "reference_modifier" => Ok(Self::ReferenceModifier(::std::boxed::Box::new(
12425 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12426 ))),
12427 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
12428 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12429 ))),
12430 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
12431 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12432 ))),
12433 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
12434 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12435 ))),
12436 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12437 }
12438 }
12439}
12440impl ::treesitter_types::Spanned for MethodDeclarationChildren<'_> {
12441 fn span(&self) -> ::treesitter_types::Span {
12442 match self {
12443 Self::AbstractModifier(inner) => inner.span(),
12444 Self::FinalModifier(inner) => inner.span(),
12445 Self::ReadonlyModifier(inner) => inner.span(),
12446 Self::ReferenceModifier(inner) => inner.span(),
12447 Self::StaticModifier(inner) => inner.span(),
12448 Self::VarModifier(inner) => inner.span(),
12449 Self::VisibilityModifier(inner) => inner.span(),
12450 }
12451 }
12452}
12453#[derive(Debug, Clone)]
12454pub enum NamedTypeChildren<'tree> {
12455 Name(::std::boxed::Box<Name<'tree>>),
12456 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12457 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12458}
12459impl<'tree> ::treesitter_types::FromNode<'tree> for NamedTypeChildren<'tree> {
12460 #[allow(clippy::collapsible_else_if)]
12461 fn from_node(
12462 node: ::tree_sitter::Node<'tree>,
12463 src: &'tree [u8],
12464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12465 match node.kind() {
12466 "name" => Ok(Self::Name(::std::boxed::Box::new(
12467 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12468 ))),
12469 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12470 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12471 ))),
12472 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12473 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
12474 ))),
12475 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12476 }
12477 }
12478}
12479impl ::treesitter_types::Spanned for NamedTypeChildren<'_> {
12480 fn span(&self) -> ::treesitter_types::Span {
12481 match self {
12482 Self::Name(inner) => inner.span(),
12483 Self::QualifiedName(inner) => inner.span(),
12484 Self::RelativeName(inner) => inner.span(),
12485 }
12486 }
12487}
12488#[derive(Debug, Clone)]
12489pub enum NamespaceUseClauseType {
12490 Const(::treesitter_types::Span),
12491 Function(::treesitter_types::Span),
12492}
12493impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClauseType {
12494 #[allow(clippy::collapsible_else_if)]
12495 fn from_node(
12496 node: ::tree_sitter::Node<'tree>,
12497 _src: &'tree [u8],
12498 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12499 match node.kind() {
12500 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
12501 "function" => Ok(Self::Function(::treesitter_types::Span::from(node))),
12502 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12503 }
12504 }
12505}
12506impl ::treesitter_types::Spanned for NamespaceUseClauseType {
12507 fn span(&self) -> ::treesitter_types::Span {
12508 match self {
12509 Self::Const(span) => *span,
12510 Self::Function(span) => *span,
12511 }
12512 }
12513}
12514#[derive(Debug, Clone)]
12515pub enum NamespaceUseClauseChildren<'tree> {
12516 Name(::std::boxed::Box<Name<'tree>>),
12517 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12518}
12519impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseClauseChildren<'tree> {
12520 #[allow(clippy::collapsible_else_if)]
12521 fn from_node(
12522 node: ::tree_sitter::Node<'tree>,
12523 src: &'tree [u8],
12524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12525 match node.kind() {
12526 "name" => Ok(Self::Name(::std::boxed::Box::new(
12527 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12528 ))),
12529 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12530 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12531 ))),
12532 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12533 }
12534 }
12535}
12536impl ::treesitter_types::Spanned for NamespaceUseClauseChildren<'_> {
12537 fn span(&self) -> ::treesitter_types::Span {
12538 match self {
12539 Self::Name(inner) => inner.span(),
12540 Self::QualifiedName(inner) => inner.span(),
12541 }
12542 }
12543}
12544#[derive(Debug, Clone)]
12545pub enum NamespaceUseDeclarationType {
12546 Const(::treesitter_types::Span),
12547 Function(::treesitter_types::Span),
12548}
12549impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclarationType {
12550 #[allow(clippy::collapsible_else_if)]
12551 fn from_node(
12552 node: ::tree_sitter::Node<'tree>,
12553 _src: &'tree [u8],
12554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12555 match node.kind() {
12556 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
12557 "function" => Ok(Self::Function(::treesitter_types::Span::from(node))),
12558 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12559 }
12560 }
12561}
12562impl ::treesitter_types::Spanned for NamespaceUseDeclarationType {
12563 fn span(&self) -> ::treesitter_types::Span {
12564 match self {
12565 Self::Const(span) => *span,
12566 Self::Function(span) => *span,
12567 }
12568 }
12569}
12570#[derive(Debug, Clone)]
12571pub enum NamespaceUseDeclarationChildren<'tree> {
12572 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
12573 NamespaceUseClause(::std::boxed::Box<NamespaceUseClause<'tree>>),
12574}
12575impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceUseDeclarationChildren<'tree> {
12576 #[allow(clippy::collapsible_else_if)]
12577 fn from_node(
12578 node: ::tree_sitter::Node<'tree>,
12579 src: &'tree [u8],
12580 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12581 match node.kind() {
12582 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
12583 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
12584 ))),
12585 "namespace_use_clause" => Ok(Self::NamespaceUseClause(::std::boxed::Box::new(
12586 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(node, src)?,
12587 ))),
12588 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12589 }
12590 }
12591}
12592impl ::treesitter_types::Spanned for NamespaceUseDeclarationChildren<'_> {
12593 fn span(&self) -> ::treesitter_types::Span {
12594 match self {
12595 Self::NamespaceName(inner) => inner.span(),
12596 Self::NamespaceUseClause(inner) => inner.span(),
12597 }
12598 }
12599}
12600#[derive(Debug, Clone)]
12601pub enum NullsafeMemberAccessExpressionName<'tree> {
12602 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12603 Expression(::std::boxed::Box<Expression<'tree>>),
12604 Name(::std::boxed::Box<Name<'tree>>),
12605 VariableName(::std::boxed::Box<VariableName<'tree>>),
12606}
12607impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpressionName<'tree> {
12608 #[allow(clippy::collapsible_else_if)]
12609 fn from_node(
12610 node: ::tree_sitter::Node<'tree>,
12611 src: &'tree [u8],
12612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12613 match node.kind() {
12614 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12615 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12616 ))),
12617 "name" => Ok(Self::Name(::std::boxed::Box::new(
12618 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12619 ))),
12620 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12621 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12622 ))),
12623 _other => {
12624 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12625 Ok(Self::Expression(::std::boxed::Box::new(v)))
12626 } else {
12627 Err(::treesitter_types::ParseError::unexpected_kind(
12628 _other, node,
12629 ))
12630 }
12631 }
12632 }
12633 }
12634}
12635impl ::treesitter_types::Spanned for NullsafeMemberAccessExpressionName<'_> {
12636 fn span(&self) -> ::treesitter_types::Span {
12637 match self {
12638 Self::DynamicVariableName(inner) => inner.span(),
12639 Self::Expression(inner) => inner.span(),
12640 Self::Name(inner) => inner.span(),
12641 Self::VariableName(inner) => inner.span(),
12642 }
12643 }
12644}
12645#[derive(Debug, Clone)]
12646pub enum NullsafeMemberAccessExpressionObject<'tree> {
12647 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12648 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12649 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12650 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12651 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12652 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12653 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12654 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12655 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12656 Name(::std::boxed::Box<Name<'tree>>),
12657 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12658 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12659 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12660 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12661 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12662 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12663 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12664 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12665 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12666 String(::std::boxed::Box<String<'tree>>),
12667 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12668 VariableName(::std::boxed::Box<VariableName<'tree>>),
12669}
12670impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberAccessExpressionObject<'tree> {
12671 #[allow(clippy::collapsible_else_if)]
12672 fn from_node(
12673 node: ::tree_sitter::Node<'tree>,
12674 src: &'tree [u8],
12675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12676 match node.kind() {
12677 "array_creation_expression" => {
12678 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
12679 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
12680 node, src,
12681 )?,
12682 )))
12683 }
12684 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12685 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12686 ))),
12687 "class_constant_access_expression" => {
12688 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
12689 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
12690 node, src,
12691 )?,
12692 )))
12693 }
12694 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12695 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12696 ))),
12697 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12698 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
12699 ))),
12700 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12701 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12702 ))),
12703 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12704 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12705 ))),
12706 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12707 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12708 ))),
12709 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12710 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12711 ))),
12712 "name" => Ok(Self::Name(::std::boxed::Box::new(
12713 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12714 ))),
12715 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12716 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12717 ))),
12718 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12719 ::std::boxed::Box::new(
12720 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12721 node, src,
12722 )?,
12723 ),
12724 )),
12725 "nullsafe_member_call_expression" => {
12726 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
12727 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12728 node, src,
12729 )?,
12730 )))
12731 }
12732 "object_creation_expression" => {
12733 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
12734 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
12735 node, src,
12736 )?,
12737 )))
12738 }
12739 "parenthesized_expression" => {
12740 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
12741 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
12742 node, src,
12743 )?,
12744 )))
12745 }
12746 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12747 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12748 ))),
12749 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12750 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
12751 ))),
12752 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12753 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12754 ))),
12755 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12756 ::std::boxed::Box::new(
12757 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12758 node, src,
12759 )?,
12760 ),
12761 )),
12762 "string" => Ok(Self::String(::std::boxed::Box::new(
12763 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12764 ))),
12765 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12766 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12767 ))),
12768 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12769 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12770 ))),
12771 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12772 }
12773 }
12774}
12775impl ::treesitter_types::Spanned for NullsafeMemberAccessExpressionObject<'_> {
12776 fn span(&self) -> ::treesitter_types::Span {
12777 match self {
12778 Self::ArrayCreationExpression(inner) => inner.span(),
12779 Self::CastExpression(inner) => inner.span(),
12780 Self::ClassConstantAccessExpression(inner) => inner.span(),
12781 Self::DynamicVariableName(inner) => inner.span(),
12782 Self::EncapsedString(inner) => inner.span(),
12783 Self::FunctionCallExpression(inner) => inner.span(),
12784 Self::Heredoc(inner) => inner.span(),
12785 Self::MemberAccessExpression(inner) => inner.span(),
12786 Self::MemberCallExpression(inner) => inner.span(),
12787 Self::Name(inner) => inner.span(),
12788 Self::Nowdoc(inner) => inner.span(),
12789 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12790 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12791 Self::ObjectCreationExpression(inner) => inner.span(),
12792 Self::ParenthesizedExpression(inner) => inner.span(),
12793 Self::QualifiedName(inner) => inner.span(),
12794 Self::RelativeName(inner) => inner.span(),
12795 Self::ScopedCallExpression(inner) => inner.span(),
12796 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
12797 Self::String(inner) => inner.span(),
12798 Self::SubscriptExpression(inner) => inner.span(),
12799 Self::VariableName(inner) => inner.span(),
12800 }
12801 }
12802}
12803#[derive(Debug, Clone)]
12804pub enum NullsafeMemberCallExpressionName<'tree> {
12805 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12806 Expression(::std::boxed::Box<Expression<'tree>>),
12807 Name(::std::boxed::Box<Name<'tree>>),
12808 VariableName(::std::boxed::Box<VariableName<'tree>>),
12809}
12810impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpressionName<'tree> {
12811 #[allow(clippy::collapsible_else_if)]
12812 fn from_node(
12813 node: ::tree_sitter::Node<'tree>,
12814 src: &'tree [u8],
12815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12816 match node.kind() {
12817 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12818 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12819 ))),
12820 "name" => Ok(Self::Name(::std::boxed::Box::new(
12821 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12822 ))),
12823 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12824 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12825 ))),
12826 _other => {
12827 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12828 Ok(Self::Expression(::std::boxed::Box::new(v)))
12829 } else {
12830 Err(::treesitter_types::ParseError::unexpected_kind(
12831 _other, node,
12832 ))
12833 }
12834 }
12835 }
12836 }
12837}
12838impl ::treesitter_types::Spanned for NullsafeMemberCallExpressionName<'_> {
12839 fn span(&self) -> ::treesitter_types::Span {
12840 match self {
12841 Self::DynamicVariableName(inner) => inner.span(),
12842 Self::Expression(inner) => inner.span(),
12843 Self::Name(inner) => inner.span(),
12844 Self::VariableName(inner) => inner.span(),
12845 }
12846 }
12847}
12848#[derive(Debug, Clone)]
12849pub enum NullsafeMemberCallExpressionObject<'tree> {
12850 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
12851 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
12852 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
12853 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
12854 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
12855 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
12856 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
12857 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
12858 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
12859 Name(::std::boxed::Box<Name<'tree>>),
12860 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
12861 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
12862 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
12863 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
12864 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
12865 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
12866 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
12867 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
12868 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
12869 String(::std::boxed::Box<String<'tree>>),
12870 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12871 VariableName(::std::boxed::Box<VariableName<'tree>>),
12872}
12873impl<'tree> ::treesitter_types::FromNode<'tree> for NullsafeMemberCallExpressionObject<'tree> {
12874 #[allow(clippy::collapsible_else_if)]
12875 fn from_node(
12876 node: ::tree_sitter::Node<'tree>,
12877 src: &'tree [u8],
12878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12879 match node.kind() {
12880 "array_creation_expression" => {
12881 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
12882 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
12883 node, src,
12884 )?,
12885 )))
12886 }
12887 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
12888 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12889 ))),
12890 "class_constant_access_expression" => {
12891 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
12892 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
12893 node, src,
12894 )?,
12895 )))
12896 }
12897 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
12898 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12899 ))),
12900 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
12901 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
12902 ))),
12903 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
12904 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12905 ))),
12906 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
12907 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12908 ))),
12909 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
12910 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12911 ))),
12912 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
12913 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12914 ))),
12915 "name" => Ok(Self::Name(::std::boxed::Box::new(
12916 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12917 ))),
12918 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
12919 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
12920 ))),
12921 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
12922 ::std::boxed::Box::new(
12923 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
12924 node, src,
12925 )?,
12926 ),
12927 )),
12928 "nullsafe_member_call_expression" => {
12929 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
12930 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
12931 node, src,
12932 )?,
12933 )))
12934 }
12935 "object_creation_expression" => {
12936 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
12937 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
12938 node, src,
12939 )?,
12940 )))
12941 }
12942 "parenthesized_expression" => {
12943 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
12944 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
12945 node, src,
12946 )?,
12947 )))
12948 }
12949 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
12950 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
12951 ))),
12952 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
12953 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
12954 ))),
12955 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
12956 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12957 ))),
12958 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
12959 ::std::boxed::Box::new(
12960 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
12961 node, src,
12962 )?,
12963 ),
12964 )),
12965 "string" => Ok(Self::String(::std::boxed::Box::new(
12966 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12967 ))),
12968 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12969 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12970 ))),
12971 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
12972 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
12973 ))),
12974 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12975 }
12976 }
12977}
12978impl ::treesitter_types::Spanned for NullsafeMemberCallExpressionObject<'_> {
12979 fn span(&self) -> ::treesitter_types::Span {
12980 match self {
12981 Self::ArrayCreationExpression(inner) => inner.span(),
12982 Self::CastExpression(inner) => inner.span(),
12983 Self::ClassConstantAccessExpression(inner) => inner.span(),
12984 Self::DynamicVariableName(inner) => inner.span(),
12985 Self::EncapsedString(inner) => inner.span(),
12986 Self::FunctionCallExpression(inner) => inner.span(),
12987 Self::Heredoc(inner) => inner.span(),
12988 Self::MemberAccessExpression(inner) => inner.span(),
12989 Self::MemberCallExpression(inner) => inner.span(),
12990 Self::Name(inner) => inner.span(),
12991 Self::Nowdoc(inner) => inner.span(),
12992 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
12993 Self::NullsafeMemberCallExpression(inner) => inner.span(),
12994 Self::ObjectCreationExpression(inner) => inner.span(),
12995 Self::ParenthesizedExpression(inner) => inner.span(),
12996 Self::QualifiedName(inner) => inner.span(),
12997 Self::RelativeName(inner) => inner.span(),
12998 Self::ScopedCallExpression(inner) => inner.span(),
12999 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13000 Self::String(inner) => inner.span(),
13001 Self::SubscriptExpression(inner) => inner.span(),
13002 Self::VariableName(inner) => inner.span(),
13003 }
13004 }
13005}
13006#[derive(Debug, Clone)]
13007pub enum ObjectCreationExpressionChildren<'tree> {
13008 AnonymousClass(::std::boxed::Box<AnonymousClass<'tree>>),
13009 Arguments(::std::boxed::Box<Arguments<'tree>>),
13010 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13011 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13012 Name(::std::boxed::Box<Name<'tree>>),
13013 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13014 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13015 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13016 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13017 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13018 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13019 VariableName(::std::boxed::Box<VariableName<'tree>>),
13020}
13021impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectCreationExpressionChildren<'tree> {
13022 #[allow(clippy::collapsible_else_if)]
13023 fn from_node(
13024 node: ::tree_sitter::Node<'tree>,
13025 src: &'tree [u8],
13026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13027 match node.kind() {
13028 "anonymous_class" => Ok(Self::AnonymousClass(::std::boxed::Box::new(
13029 <AnonymousClass as ::treesitter_types::FromNode>::from_node(node, src)?,
13030 ))),
13031 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
13032 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
13033 ))),
13034 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13035 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13036 ))),
13037 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13038 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13039 ))),
13040 "name" => Ok(Self::Name(::std::boxed::Box::new(
13041 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13042 ))),
13043 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13044 ::std::boxed::Box::new(
13045 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13046 node, src,
13047 )?,
13048 ),
13049 )),
13050 "parenthesized_expression" => {
13051 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
13052 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
13053 node, src,
13054 )?,
13055 )))
13056 }
13057 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13058 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13059 ))),
13060 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13061 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
13062 ))),
13063 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13064 ::std::boxed::Box::new(
13065 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13066 node, src,
13067 )?,
13068 ),
13069 )),
13070 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13071 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13072 ))),
13073 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13074 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13075 ))),
13076 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13077 }
13078 }
13079}
13080impl ::treesitter_types::Spanned for ObjectCreationExpressionChildren<'_> {
13081 fn span(&self) -> ::treesitter_types::Span {
13082 match self {
13083 Self::AnonymousClass(inner) => inner.span(),
13084 Self::Arguments(inner) => inner.span(),
13085 Self::DynamicVariableName(inner) => inner.span(),
13086 Self::MemberAccessExpression(inner) => inner.span(),
13087 Self::Name(inner) => inner.span(),
13088 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13089 Self::ParenthesizedExpression(inner) => inner.span(),
13090 Self::QualifiedName(inner) => inner.span(),
13091 Self::RelativeName(inner) => inner.span(),
13092 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13093 Self::SubscriptExpression(inner) => inner.span(),
13094 Self::VariableName(inner) => inner.span(),
13095 }
13096 }
13097}
13098#[derive(Debug, Clone)]
13099pub enum OptionalTypeChildren<'tree> {
13100 NamedType(::std::boxed::Box<NamedType<'tree>>),
13101 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
13102}
13103impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalTypeChildren<'tree> {
13104 #[allow(clippy::collapsible_else_if)]
13105 fn from_node(
13106 node: ::tree_sitter::Node<'tree>,
13107 src: &'tree [u8],
13108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13109 match node.kind() {
13110 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
13111 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)?,
13112 ))),
13113 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
13114 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
13115 ))),
13116 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13117 }
13118 }
13119}
13120impl ::treesitter_types::Spanned for OptionalTypeChildren<'_> {
13121 fn span(&self) -> ::treesitter_types::Span {
13122 match self {
13123 Self::NamedType(inner) => inner.span(),
13124 Self::PrimitiveType(inner) => inner.span(),
13125 }
13126 }
13127}
13128#[derive(Debug, Clone)]
13129pub enum PairChildren<'tree> {
13130 ByRef(::std::boxed::Box<ByRef<'tree>>),
13131 Expression(::std::boxed::Box<Expression<'tree>>),
13132 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
13133}
13134impl<'tree> ::treesitter_types::FromNode<'tree> for PairChildren<'tree> {
13135 #[allow(clippy::collapsible_else_if)]
13136 fn from_node(
13137 node: ::tree_sitter::Node<'tree>,
13138 src: &'tree [u8],
13139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13140 match node.kind() {
13141 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
13142 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
13143 ))),
13144 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
13145 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
13146 ))),
13147 _other => {
13148 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13149 Ok(Self::Expression(::std::boxed::Box::new(v)))
13150 } else {
13151 Err(::treesitter_types::ParseError::unexpected_kind(
13152 _other, node,
13153 ))
13154 }
13155 }
13156 }
13157 }
13158}
13159impl ::treesitter_types::Spanned for PairChildren<'_> {
13160 fn span(&self) -> ::treesitter_types::Span {
13161 match self {
13162 Self::ByRef(inner) => inner.span(),
13163 Self::Expression(inner) => inner.span(),
13164 Self::ListLiteral(inner) => inner.span(),
13165 }
13166 }
13167}
13168#[derive(Debug, Clone)]
13169pub enum ProgramChildren<'tree> {
13170 PhpTag(::std::boxed::Box<PhpTag<'tree>>),
13171 Statement(::std::boxed::Box<Statement<'tree>>),
13172 Text(::std::boxed::Box<Text<'tree>>),
13173}
13174impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
13175 #[allow(clippy::collapsible_else_if)]
13176 fn from_node(
13177 node: ::tree_sitter::Node<'tree>,
13178 src: &'tree [u8],
13179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13180 match node.kind() {
13181 "php_tag" => Ok(Self::PhpTag(::std::boxed::Box::new(
13182 <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)?,
13183 ))),
13184 "text" => Ok(Self::Text(::std::boxed::Box::new(
13185 <Text as ::treesitter_types::FromNode>::from_node(node, src)?,
13186 ))),
13187 _other => {
13188 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
13189 Ok(Self::Statement(::std::boxed::Box::new(v)))
13190 } else {
13191 Err(::treesitter_types::ParseError::unexpected_kind(
13192 _other, node,
13193 ))
13194 }
13195 }
13196 }
13197 }
13198}
13199impl ::treesitter_types::Spanned for ProgramChildren<'_> {
13200 fn span(&self) -> ::treesitter_types::Span {
13201 match self {
13202 Self::PhpTag(inner) => inner.span(),
13203 Self::Statement(inner) => inner.span(),
13204 Self::Text(inner) => inner.span(),
13205 }
13206 }
13207}
13208#[derive(Debug, Clone)]
13209pub enum PropertyDeclarationChildren<'tree> {
13210 AbstractModifier(::std::boxed::Box<AbstractModifier<'tree>>),
13211 FinalModifier(::std::boxed::Box<FinalModifier<'tree>>),
13212 PropertyElement(::std::boxed::Box<PropertyElement<'tree>>),
13213 PropertyHookList(::std::boxed::Box<PropertyHookList<'tree>>),
13214 ReadonlyModifier(::std::boxed::Box<ReadonlyModifier<'tree>>),
13215 StaticModifier(::std::boxed::Box<StaticModifier<'tree>>),
13216 VarModifier(::std::boxed::Box<VarModifier<'tree>>),
13217 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
13218}
13219impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyDeclarationChildren<'tree> {
13220 #[allow(clippy::collapsible_else_if)]
13221 fn from_node(
13222 node: ::tree_sitter::Node<'tree>,
13223 src: &'tree [u8],
13224 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13225 match node.kind() {
13226 "abstract_modifier" => Ok(Self::AbstractModifier(::std::boxed::Box::new(
13227 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13228 ))),
13229 "final_modifier" => Ok(Self::FinalModifier(::std::boxed::Box::new(
13230 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13231 ))),
13232 "property_element" => Ok(Self::PropertyElement(::std::boxed::Box::new(
13233 <PropertyElement as ::treesitter_types::FromNode>::from_node(node, src)?,
13234 ))),
13235 "property_hook_list" => Ok(Self::PropertyHookList(::std::boxed::Box::new(
13236 <PropertyHookList as ::treesitter_types::FromNode>::from_node(node, src)?,
13237 ))),
13238 "readonly_modifier" => Ok(Self::ReadonlyModifier(::std::boxed::Box::new(
13239 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13240 ))),
13241 "static_modifier" => Ok(Self::StaticModifier(::std::boxed::Box::new(
13242 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13243 ))),
13244 "var_modifier" => Ok(Self::VarModifier(::std::boxed::Box::new(
13245 <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13246 ))),
13247 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
13248 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13249 ))),
13250 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13251 }
13252 }
13253}
13254impl ::treesitter_types::Spanned for PropertyDeclarationChildren<'_> {
13255 fn span(&self) -> ::treesitter_types::Span {
13256 match self {
13257 Self::AbstractModifier(inner) => inner.span(),
13258 Self::FinalModifier(inner) => inner.span(),
13259 Self::PropertyElement(inner) => inner.span(),
13260 Self::PropertyHookList(inner) => inner.span(),
13261 Self::ReadonlyModifier(inner) => inner.span(),
13262 Self::StaticModifier(inner) => inner.span(),
13263 Self::VarModifier(inner) => inner.span(),
13264 Self::VisibilityModifier(inner) => inner.span(),
13265 }
13266 }
13267}
13268#[derive(Debug, Clone)]
13269pub enum PropertyHookBody<'tree> {
13270 CompoundStatement(::std::boxed::Box<CompoundStatement<'tree>>),
13271 Expression(::std::boxed::Box<Expression<'tree>>),
13272}
13273impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyHookBody<'tree> {
13274 #[allow(clippy::collapsible_else_if)]
13275 fn from_node(
13276 node: ::tree_sitter::Node<'tree>,
13277 src: &'tree [u8],
13278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13279 match node.kind() {
13280 "compound_statement" => Ok(Self::CompoundStatement(::std::boxed::Box::new(
13281 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
13282 ))),
13283 _other => {
13284 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13285 Ok(Self::Expression(::std::boxed::Box::new(v)))
13286 } else {
13287 Err(::treesitter_types::ParseError::unexpected_kind(
13288 _other, node,
13289 ))
13290 }
13291 }
13292 }
13293 }
13294}
13295impl ::treesitter_types::Spanned for PropertyHookBody<'_> {
13296 fn span(&self) -> ::treesitter_types::Span {
13297 match self {
13298 Self::CompoundStatement(inner) => inner.span(),
13299 Self::Expression(inner) => inner.span(),
13300 }
13301 }
13302}
13303#[derive(Debug, Clone)]
13304pub enum PropertyPromotionParameterName<'tree> {
13305 ByRef(::std::boxed::Box<ByRef<'tree>>),
13306 VariableName(::std::boxed::Box<VariableName<'tree>>),
13307}
13308impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyPromotionParameterName<'tree> {
13309 #[allow(clippy::collapsible_else_if)]
13310 fn from_node(
13311 node: ::tree_sitter::Node<'tree>,
13312 src: &'tree [u8],
13313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13314 match node.kind() {
13315 "by_ref" => Ok(Self::ByRef(::std::boxed::Box::new(
13316 <ByRef as ::treesitter_types::FromNode>::from_node(node, src)?,
13317 ))),
13318 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13319 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13320 ))),
13321 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13322 }
13323 }
13324}
13325impl ::treesitter_types::Spanned for PropertyPromotionParameterName<'_> {
13326 fn span(&self) -> ::treesitter_types::Span {
13327 match self {
13328 Self::ByRef(inner) => inner.span(),
13329 Self::VariableName(inner) => inner.span(),
13330 }
13331 }
13332}
13333#[derive(Debug, Clone)]
13334pub enum QualifiedNamePrefix<'tree> {
13335 Backslash(::treesitter_types::Span),
13336 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
13337}
13338impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedNamePrefix<'tree> {
13339 #[allow(clippy::collapsible_else_if)]
13340 fn from_node(
13341 node: ::tree_sitter::Node<'tree>,
13342 src: &'tree [u8],
13343 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13344 match node.kind() {
13345 "\\" => Ok(Self::Backslash(::treesitter_types::Span::from(node))),
13346 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
13347 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
13348 ))),
13349 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13350 }
13351 }
13352}
13353impl ::treesitter_types::Spanned for QualifiedNamePrefix<'_> {
13354 fn span(&self) -> ::treesitter_types::Span {
13355 match self {
13356 Self::Backslash(span) => *span,
13357 Self::NamespaceName(inner) => inner.span(),
13358 }
13359 }
13360}
13361#[derive(Debug, Clone)]
13362pub enum ReferenceAssignmentExpressionLeft<'tree> {
13363 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
13364 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13365 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
13366 ListLiteral(::std::boxed::Box<ListLiteral<'tree>>),
13367 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13368 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
13369 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13370 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
13371 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
13372 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13373 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13374 VariableName(::std::boxed::Box<VariableName<'tree>>),
13375}
13376impl<'tree> ::treesitter_types::FromNode<'tree> for ReferenceAssignmentExpressionLeft<'tree> {
13377 #[allow(clippy::collapsible_else_if)]
13378 fn from_node(
13379 node: ::tree_sitter::Node<'tree>,
13380 src: &'tree [u8],
13381 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13382 match node.kind() {
13383 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
13384 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13385 ))),
13386 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13387 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13388 ))),
13389 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13390 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13391 ))),
13392 "list_literal" => Ok(Self::ListLiteral(::std::boxed::Box::new(
13393 <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)?,
13394 ))),
13395 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13396 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13397 ))),
13398 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13399 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13400 ))),
13401 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13402 ::std::boxed::Box::new(
13403 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13404 node, src,
13405 )?,
13406 ),
13407 )),
13408 "nullsafe_member_call_expression" => {
13409 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
13410 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13411 node, src,
13412 )?,
13413 )))
13414 }
13415 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13416 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13417 ))),
13418 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13419 ::std::boxed::Box::new(
13420 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13421 node, src,
13422 )?,
13423 ),
13424 )),
13425 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13426 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13427 ))),
13428 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13429 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13430 ))),
13431 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13432 }
13433 }
13434}
13435impl ::treesitter_types::Spanned for ReferenceAssignmentExpressionLeft<'_> {
13436 fn span(&self) -> ::treesitter_types::Span {
13437 match self {
13438 Self::CastExpression(inner) => inner.span(),
13439 Self::DynamicVariableName(inner) => inner.span(),
13440 Self::FunctionCallExpression(inner) => inner.span(),
13441 Self::ListLiteral(inner) => inner.span(),
13442 Self::MemberAccessExpression(inner) => inner.span(),
13443 Self::MemberCallExpression(inner) => inner.span(),
13444 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13445 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13446 Self::ScopedCallExpression(inner) => inner.span(),
13447 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13448 Self::SubscriptExpression(inner) => inner.span(),
13449 Self::VariableName(inner) => inner.span(),
13450 }
13451 }
13452}
13453#[derive(Debug, Clone)]
13454pub enum RelativeNamePrefix<'tree> {
13455 Backslash(::treesitter_types::Span),
13456 Namespace(::treesitter_types::Span),
13457 NamespaceName(::std::boxed::Box<NamespaceName<'tree>>),
13458}
13459impl<'tree> ::treesitter_types::FromNode<'tree> for RelativeNamePrefix<'tree> {
13460 #[allow(clippy::collapsible_else_if)]
13461 fn from_node(
13462 node: ::tree_sitter::Node<'tree>,
13463 src: &'tree [u8],
13464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13465 match node.kind() {
13466 "\\" => Ok(Self::Backslash(::treesitter_types::Span::from(node))),
13467 "namespace" => Ok(Self::Namespace(::treesitter_types::Span::from(node))),
13468 "namespace_name" => Ok(Self::NamespaceName(::std::boxed::Box::new(
13469 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
13470 ))),
13471 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13472 }
13473 }
13474}
13475impl ::treesitter_types::Spanned for RelativeNamePrefix<'_> {
13476 fn span(&self) -> ::treesitter_types::Span {
13477 match self {
13478 Self::Backslash(span) => *span,
13479 Self::Namespace(span) => *span,
13480 Self::NamespaceName(inner) => inner.span(),
13481 }
13482 }
13483}
13484#[derive(Debug, Clone)]
13485pub enum ScopedCallExpressionName<'tree> {
13486 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13487 Expression(::std::boxed::Box<Expression<'tree>>),
13488 Name(::std::boxed::Box<Name<'tree>>),
13489 VariableName(::std::boxed::Box<VariableName<'tree>>),
13490}
13491impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpressionName<'tree> {
13492 #[allow(clippy::collapsible_else_if)]
13493 fn from_node(
13494 node: ::tree_sitter::Node<'tree>,
13495 src: &'tree [u8],
13496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13497 match node.kind() {
13498 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13499 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13500 ))),
13501 "name" => Ok(Self::Name(::std::boxed::Box::new(
13502 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13503 ))),
13504 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13505 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13506 ))),
13507 _other => {
13508 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13509 Ok(Self::Expression(::std::boxed::Box::new(v)))
13510 } else {
13511 Err(::treesitter_types::ParseError::unexpected_kind(
13512 _other, node,
13513 ))
13514 }
13515 }
13516 }
13517 }
13518}
13519impl ::treesitter_types::Spanned for ScopedCallExpressionName<'_> {
13520 fn span(&self) -> ::treesitter_types::Span {
13521 match self {
13522 Self::DynamicVariableName(inner) => inner.span(),
13523 Self::Expression(inner) => inner.span(),
13524 Self::Name(inner) => inner.span(),
13525 Self::VariableName(inner) => inner.span(),
13526 }
13527 }
13528}
13529#[derive(Debug, Clone)]
13530pub enum ScopedCallExpressionScope<'tree> {
13531 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
13532 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
13533 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
13534 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13535 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
13536 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
13537 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
13538 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13539 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
13540 Name(::std::boxed::Box<Name<'tree>>),
13541 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
13542 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13543 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
13544 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
13545 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13546 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13547 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13548 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
13549 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
13550 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13551 String(::std::boxed::Box<String<'tree>>),
13552 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13553 VariableName(::std::boxed::Box<VariableName<'tree>>),
13554}
13555impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedCallExpressionScope<'tree> {
13556 #[allow(clippy::collapsible_else_if)]
13557 fn from_node(
13558 node: ::tree_sitter::Node<'tree>,
13559 src: &'tree [u8],
13560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13561 match node.kind() {
13562 "array_creation_expression" => {
13563 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
13564 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
13565 node, src,
13566 )?,
13567 )))
13568 }
13569 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
13570 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13571 ))),
13572 "class_constant_access_expression" => {
13573 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
13574 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
13575 node, src,
13576 )?,
13577 )))
13578 }
13579 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13580 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13581 ))),
13582 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
13583 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
13584 ))),
13585 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13586 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13587 ))),
13588 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
13589 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
13590 ))),
13591 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13592 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13593 ))),
13594 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13595 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13596 ))),
13597 "name" => Ok(Self::Name(::std::boxed::Box::new(
13598 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13599 ))),
13600 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
13601 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
13602 ))),
13603 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13604 ::std::boxed::Box::new(
13605 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13606 node, src,
13607 )?,
13608 ),
13609 )),
13610 "nullsafe_member_call_expression" => {
13611 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
13612 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13613 node, src,
13614 )?,
13615 )))
13616 }
13617 "object_creation_expression" => {
13618 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
13619 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
13620 node, src,
13621 )?,
13622 )))
13623 }
13624 "parenthesized_expression" => {
13625 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
13626 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
13627 node, src,
13628 )?,
13629 )))
13630 }
13631 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13632 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13633 ))),
13634 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13635 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
13636 ))),
13637 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
13638 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)?,
13639 ))),
13640 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13641 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13642 ))),
13643 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13644 ::std::boxed::Box::new(
13645 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13646 node, src,
13647 )?,
13648 ),
13649 )),
13650 "string" => Ok(Self::String(::std::boxed::Box::new(
13651 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
13652 ))),
13653 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13654 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13655 ))),
13656 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13657 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13658 ))),
13659 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13660 }
13661 }
13662}
13663impl ::treesitter_types::Spanned for ScopedCallExpressionScope<'_> {
13664 fn span(&self) -> ::treesitter_types::Span {
13665 match self {
13666 Self::ArrayCreationExpression(inner) => inner.span(),
13667 Self::CastExpression(inner) => inner.span(),
13668 Self::ClassConstantAccessExpression(inner) => inner.span(),
13669 Self::DynamicVariableName(inner) => inner.span(),
13670 Self::EncapsedString(inner) => inner.span(),
13671 Self::FunctionCallExpression(inner) => inner.span(),
13672 Self::Heredoc(inner) => inner.span(),
13673 Self::MemberAccessExpression(inner) => inner.span(),
13674 Self::MemberCallExpression(inner) => inner.span(),
13675 Self::Name(inner) => inner.span(),
13676 Self::Nowdoc(inner) => inner.span(),
13677 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13678 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13679 Self::ObjectCreationExpression(inner) => inner.span(),
13680 Self::ParenthesizedExpression(inner) => inner.span(),
13681 Self::QualifiedName(inner) => inner.span(),
13682 Self::RelativeName(inner) => inner.span(),
13683 Self::RelativeScope(inner) => inner.span(),
13684 Self::ScopedCallExpression(inner) => inner.span(),
13685 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13686 Self::String(inner) => inner.span(),
13687 Self::SubscriptExpression(inner) => inner.span(),
13688 Self::VariableName(inner) => inner.span(),
13689 }
13690 }
13691}
13692#[derive(Debug, Clone)]
13693pub enum ScopedPropertyAccessExpressionName<'tree> {
13694 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13695 VariableName(::std::boxed::Box<VariableName<'tree>>),
13696}
13697impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpressionName<'tree> {
13698 #[allow(clippy::collapsible_else_if)]
13699 fn from_node(
13700 node: ::tree_sitter::Node<'tree>,
13701 src: &'tree [u8],
13702 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13703 match node.kind() {
13704 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13705 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13706 ))),
13707 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13708 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13709 ))),
13710 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13711 }
13712 }
13713}
13714impl ::treesitter_types::Spanned for ScopedPropertyAccessExpressionName<'_> {
13715 fn span(&self) -> ::treesitter_types::Span {
13716 match self {
13717 Self::DynamicVariableName(inner) => inner.span(),
13718 Self::VariableName(inner) => inner.span(),
13719 }
13720 }
13721}
13722#[derive(Debug, Clone)]
13723pub enum ScopedPropertyAccessExpressionScope<'tree> {
13724 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
13725 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
13726 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
13727 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13728 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
13729 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
13730 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
13731 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13732 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
13733 Name(::std::boxed::Box<Name<'tree>>),
13734 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
13735 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
13736 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
13737 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
13738 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
13739 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
13740 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
13741 RelativeScope(::std::boxed::Box<RelativeScope<'tree>>),
13742 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
13743 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
13744 String(::std::boxed::Box<String<'tree>>),
13745 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13746 VariableName(::std::boxed::Box<VariableName<'tree>>),
13747}
13748impl<'tree> ::treesitter_types::FromNode<'tree> for ScopedPropertyAccessExpressionScope<'tree> {
13749 #[allow(clippy::collapsible_else_if)]
13750 fn from_node(
13751 node: ::tree_sitter::Node<'tree>,
13752 src: &'tree [u8],
13753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13754 match node.kind() {
13755 "array_creation_expression" => {
13756 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
13757 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
13758 node, src,
13759 )?,
13760 )))
13761 }
13762 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
13763 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13764 ))),
13765 "class_constant_access_expression" => {
13766 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
13767 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
13768 node, src,
13769 )?,
13770 )))
13771 }
13772 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13773 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13774 ))),
13775 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
13776 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
13777 ))),
13778 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
13779 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13780 ))),
13781 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
13782 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
13783 ))),
13784 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13785 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13786 ))),
13787 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
13788 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13789 ))),
13790 "name" => Ok(Self::Name(::std::boxed::Box::new(
13791 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13792 ))),
13793 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
13794 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
13795 ))),
13796 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
13797 ::std::boxed::Box::new(
13798 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
13799 node, src,
13800 )?,
13801 ),
13802 )),
13803 "nullsafe_member_call_expression" => {
13804 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
13805 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
13806 node, src,
13807 )?,
13808 )))
13809 }
13810 "object_creation_expression" => {
13811 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
13812 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
13813 node, src,
13814 )?,
13815 )))
13816 }
13817 "parenthesized_expression" => {
13818 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
13819 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
13820 node, src,
13821 )?,
13822 )))
13823 }
13824 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
13825 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
13826 ))),
13827 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
13828 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
13829 ))),
13830 "relative_scope" => Ok(Self::RelativeScope(::std::boxed::Box::new(
13831 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)?,
13832 ))),
13833 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
13834 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13835 ))),
13836 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
13837 ::std::boxed::Box::new(
13838 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
13839 node, src,
13840 )?,
13841 ),
13842 )),
13843 "string" => Ok(Self::String(::std::boxed::Box::new(
13844 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
13845 ))),
13846 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13847 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13848 ))),
13849 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13850 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13851 ))),
13852 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13853 }
13854 }
13855}
13856impl ::treesitter_types::Spanned for ScopedPropertyAccessExpressionScope<'_> {
13857 fn span(&self) -> ::treesitter_types::Span {
13858 match self {
13859 Self::ArrayCreationExpression(inner) => inner.span(),
13860 Self::CastExpression(inner) => inner.span(),
13861 Self::ClassConstantAccessExpression(inner) => inner.span(),
13862 Self::DynamicVariableName(inner) => inner.span(),
13863 Self::EncapsedString(inner) => inner.span(),
13864 Self::FunctionCallExpression(inner) => inner.span(),
13865 Self::Heredoc(inner) => inner.span(),
13866 Self::MemberAccessExpression(inner) => inner.span(),
13867 Self::MemberCallExpression(inner) => inner.span(),
13868 Self::Name(inner) => inner.span(),
13869 Self::Nowdoc(inner) => inner.span(),
13870 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
13871 Self::NullsafeMemberCallExpression(inner) => inner.span(),
13872 Self::ObjectCreationExpression(inner) => inner.span(),
13873 Self::ParenthesizedExpression(inner) => inner.span(),
13874 Self::QualifiedName(inner) => inner.span(),
13875 Self::RelativeName(inner) => inner.span(),
13876 Self::RelativeScope(inner) => inner.span(),
13877 Self::ScopedCallExpression(inner) => inner.span(),
13878 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
13879 Self::String(inner) => inner.span(),
13880 Self::SubscriptExpression(inner) => inner.span(),
13881 Self::VariableName(inner) => inner.span(),
13882 }
13883 }
13884}
13885#[derive(Debug, Clone)]
13886pub enum SequenceExpressionChildren<'tree> {
13887 Expression(::std::boxed::Box<Expression<'tree>>),
13888 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
13889}
13890impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpressionChildren<'tree> {
13891 #[allow(clippy::collapsible_else_if)]
13892 fn from_node(
13893 node: ::tree_sitter::Node<'tree>,
13894 src: &'tree [u8],
13895 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13896 match node.kind() {
13897 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
13898 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13899 ))),
13900 _other => {
13901 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13902 Ok(Self::Expression(::std::boxed::Box::new(v)))
13903 } else {
13904 Err(::treesitter_types::ParseError::unexpected_kind(
13905 _other, node,
13906 ))
13907 }
13908 }
13909 }
13910 }
13911}
13912impl ::treesitter_types::Spanned for SequenceExpressionChildren<'_> {
13913 fn span(&self) -> ::treesitter_types::Span {
13914 match self {
13915 Self::Expression(inner) => inner.span(),
13916 Self::SequenceExpression(inner) => inner.span(),
13917 }
13918 }
13919}
13920#[derive(Debug, Clone)]
13921pub enum ShellCommandExpressionChildren<'tree> {
13922 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
13923 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
13924 Expression(::std::boxed::Box<Expression<'tree>>),
13925 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
13926 StringContent(::std::boxed::Box<StringContent<'tree>>),
13927 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13928 VariableName(::std::boxed::Box<VariableName<'tree>>),
13929}
13930impl<'tree> ::treesitter_types::FromNode<'tree> for ShellCommandExpressionChildren<'tree> {
13931 #[allow(clippy::collapsible_else_if)]
13932 fn from_node(
13933 node: ::tree_sitter::Node<'tree>,
13934 src: &'tree [u8],
13935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13936 match node.kind() {
13937 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
13938 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13939 ))),
13940 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
13941 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
13942 ))),
13943 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
13944 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13945 ))),
13946 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
13947 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
13948 ))),
13949 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13950 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13951 ))),
13952 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
13953 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
13954 ))),
13955 _other => {
13956 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13957 Ok(Self::Expression(::std::boxed::Box::new(v)))
13958 } else {
13959 Err(::treesitter_types::ParseError::unexpected_kind(
13960 _other, node,
13961 ))
13962 }
13963 }
13964 }
13965 }
13966}
13967impl ::treesitter_types::Spanned for ShellCommandExpressionChildren<'_> {
13968 fn span(&self) -> ::treesitter_types::Span {
13969 match self {
13970 Self::DynamicVariableName(inner) => inner.span(),
13971 Self::EscapeSequence(inner) => inner.span(),
13972 Self::Expression(inner) => inner.span(),
13973 Self::MemberAccessExpression(inner) => inner.span(),
13974 Self::StringContent(inner) => inner.span(),
13975 Self::SubscriptExpression(inner) => inner.span(),
13976 Self::VariableName(inner) => inner.span(),
13977 }
13978 }
13979}
13980#[derive(Debug, Clone)]
13981pub enum StringChildren<'tree> {
13982 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
13983 StringContent(::std::boxed::Box<StringContent<'tree>>),
13984}
13985impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
13986 #[allow(clippy::collapsible_else_if)]
13987 fn from_node(
13988 node: ::tree_sitter::Node<'tree>,
13989 src: &'tree [u8],
13990 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13991 match node.kind() {
13992 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
13993 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
13994 ))),
13995 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
13996 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)?,
13997 ))),
13998 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13999 }
14000 }
14001}
14002impl ::treesitter_types::Spanned for StringChildren<'_> {
14003 fn span(&self) -> ::treesitter_types::Span {
14004 match self {
14005 Self::EscapeSequence(inner) => inner.span(),
14006 Self::StringContent(inner) => inner.span(),
14007 }
14008 }
14009}
14010#[derive(Debug, Clone)]
14011pub enum SubscriptExpressionChildren<'tree> {
14012 ArrayCreationExpression(::std::boxed::Box<ArrayCreationExpression<'tree>>),
14013 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
14014 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14015 EncapsedString(::std::boxed::Box<EncapsedString<'tree>>),
14016 Expression(::std::boxed::Box<Expression<'tree>>),
14017 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14018 Heredoc(::std::boxed::Box<Heredoc<'tree>>),
14019 Integer(::std::boxed::Box<Integer<'tree>>),
14020 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14021 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14022 Name(::std::boxed::Box<Name<'tree>>),
14023 Nowdoc(::std::boxed::Box<Nowdoc<'tree>>),
14024 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14025 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14026 ObjectCreationExpression(::std::boxed::Box<ObjectCreationExpression<'tree>>),
14027 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
14028 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14029 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
14030 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14031 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14032 String(::std::boxed::Box<String<'tree>>),
14033 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14034 VariableName(::std::boxed::Box<VariableName<'tree>>),
14035}
14036impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionChildren<'tree> {
14037 #[allow(clippy::collapsible_else_if)]
14038 fn from_node(
14039 node: ::tree_sitter::Node<'tree>,
14040 src: &'tree [u8],
14041 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14042 match node.kind() {
14043 "array_creation_expression" => {
14044 Ok(Self::ArrayCreationExpression(::std::boxed::Box::new(
14045 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(
14046 node, src,
14047 )?,
14048 )))
14049 }
14050 "class_constant_access_expression" => {
14051 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
14052 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
14053 node, src,
14054 )?,
14055 )))
14056 }
14057 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14058 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14059 ))),
14060 "encapsed_string" => Ok(Self::EncapsedString(::std::boxed::Box::new(
14061 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)?,
14062 ))),
14063 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14064 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14065 ))),
14066 "heredoc" => Ok(Self::Heredoc(::std::boxed::Box::new(
14067 <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)?,
14068 ))),
14069 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
14070 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
14071 ))),
14072 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14073 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14074 ))),
14075 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14076 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14077 ))),
14078 "name" => Ok(Self::Name(::std::boxed::Box::new(
14079 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14080 ))),
14081 "nowdoc" => Ok(Self::Nowdoc(::std::boxed::Box::new(
14082 <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)?,
14083 ))),
14084 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14085 ::std::boxed::Box::new(
14086 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14087 node, src,
14088 )?,
14089 ),
14090 )),
14091 "nullsafe_member_call_expression" => {
14092 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
14093 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14094 node, src,
14095 )?,
14096 )))
14097 }
14098 "object_creation_expression" => {
14099 Ok(Self::ObjectCreationExpression(::std::boxed::Box::new(
14100 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(
14101 node, src,
14102 )?,
14103 )))
14104 }
14105 "parenthesized_expression" => {
14106 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
14107 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
14108 node, src,
14109 )?,
14110 )))
14111 }
14112 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14113 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
14114 ))),
14115 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
14116 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
14117 ))),
14118 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14119 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14120 ))),
14121 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14122 ::std::boxed::Box::new(
14123 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14124 node, src,
14125 )?,
14126 ),
14127 )),
14128 "string" => Ok(Self::String(::std::boxed::Box::new(
14129 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
14130 ))),
14131 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14132 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14133 ))),
14134 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14135 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14136 ))),
14137 _other => {
14138 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14139 Ok(Self::Expression(::std::boxed::Box::new(v)))
14140 } else {
14141 Err(::treesitter_types::ParseError::unexpected_kind(
14142 _other, node,
14143 ))
14144 }
14145 }
14146 }
14147 }
14148}
14149impl ::treesitter_types::Spanned for SubscriptExpressionChildren<'_> {
14150 fn span(&self) -> ::treesitter_types::Span {
14151 match self {
14152 Self::ArrayCreationExpression(inner) => inner.span(),
14153 Self::ClassConstantAccessExpression(inner) => inner.span(),
14154 Self::DynamicVariableName(inner) => inner.span(),
14155 Self::EncapsedString(inner) => inner.span(),
14156 Self::Expression(inner) => inner.span(),
14157 Self::FunctionCallExpression(inner) => inner.span(),
14158 Self::Heredoc(inner) => inner.span(),
14159 Self::Integer(inner) => inner.span(),
14160 Self::MemberAccessExpression(inner) => inner.span(),
14161 Self::MemberCallExpression(inner) => inner.span(),
14162 Self::Name(inner) => inner.span(),
14163 Self::Nowdoc(inner) => inner.span(),
14164 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14165 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14166 Self::ObjectCreationExpression(inner) => inner.span(),
14167 Self::ParenthesizedExpression(inner) => inner.span(),
14168 Self::QualifiedName(inner) => inner.span(),
14169 Self::RelativeName(inner) => inner.span(),
14170 Self::ScopedCallExpression(inner) => inner.span(),
14171 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14172 Self::String(inner) => inner.span(),
14173 Self::SubscriptExpression(inner) => inner.span(),
14174 Self::VariableName(inner) => inner.span(),
14175 }
14176 }
14177}
14178#[derive(Debug, Clone)]
14179pub enum SwitchBlockChildren<'tree> {
14180 CaseStatement(::std::boxed::Box<CaseStatement<'tree>>),
14181 DefaultStatement(::std::boxed::Box<DefaultStatement<'tree>>),
14182}
14183impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBlockChildren<'tree> {
14184 #[allow(clippy::collapsible_else_if)]
14185 fn from_node(
14186 node: ::tree_sitter::Node<'tree>,
14187 src: &'tree [u8],
14188 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14189 match node.kind() {
14190 "case_statement" => Ok(Self::CaseStatement(::std::boxed::Box::new(
14191 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
14192 ))),
14193 "default_statement" => Ok(Self::DefaultStatement(::std::boxed::Box::new(
14194 <DefaultStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
14195 ))),
14196 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14197 }
14198 }
14199}
14200impl ::treesitter_types::Spanned for SwitchBlockChildren<'_> {
14201 fn span(&self) -> ::treesitter_types::Span {
14202 match self {
14203 Self::CaseStatement(inner) => inner.span(),
14204 Self::DefaultStatement(inner) => inner.span(),
14205 }
14206 }
14207}
14208#[derive(Debug, Clone)]
14209pub enum TextInterpolationChildren<'tree> {
14210 PhpEndTag(::std::boxed::Box<PhpEndTag<'tree>>),
14211 PhpTag(::std::boxed::Box<PhpTag<'tree>>),
14212 Text(::std::boxed::Box<Text<'tree>>),
14213}
14214impl<'tree> ::treesitter_types::FromNode<'tree> for TextInterpolationChildren<'tree> {
14215 #[allow(clippy::collapsible_else_if)]
14216 fn from_node(
14217 node: ::tree_sitter::Node<'tree>,
14218 src: &'tree [u8],
14219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14220 match node.kind() {
14221 "php_end_tag" => Ok(Self::PhpEndTag(::std::boxed::Box::new(
14222 <PhpEndTag as ::treesitter_types::FromNode>::from_node(node, src)?,
14223 ))),
14224 "php_tag" => Ok(Self::PhpTag(::std::boxed::Box::new(
14225 <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)?,
14226 ))),
14227 "text" => Ok(Self::Text(::std::boxed::Box::new(
14228 <Text as ::treesitter_types::FromNode>::from_node(node, src)?,
14229 ))),
14230 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14231 }
14232 }
14233}
14234impl ::treesitter_types::Spanned for TextInterpolationChildren<'_> {
14235 fn span(&self) -> ::treesitter_types::Span {
14236 match self {
14237 Self::PhpEndTag(inner) => inner.span(),
14238 Self::PhpTag(inner) => inner.span(),
14239 Self::Text(inner) => inner.span(),
14240 }
14241 }
14242}
14243#[derive(Debug, Clone)]
14244pub enum TryStatementChildren<'tree> {
14245 CatchClause(::std::boxed::Box<CatchClause<'tree>>),
14246 FinallyClause(::std::boxed::Box<FinallyClause<'tree>>),
14247}
14248impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatementChildren<'tree> {
14249 #[allow(clippy::collapsible_else_if)]
14250 fn from_node(
14251 node: ::tree_sitter::Node<'tree>,
14252 src: &'tree [u8],
14253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14254 match node.kind() {
14255 "catch_clause" => Ok(Self::CatchClause(::std::boxed::Box::new(
14256 <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14257 ))),
14258 "finally_clause" => Ok(Self::FinallyClause(::std::boxed::Box::new(
14259 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14260 ))),
14261 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14262 }
14263 }
14264}
14265impl ::treesitter_types::Spanned for TryStatementChildren<'_> {
14266 fn span(&self) -> ::treesitter_types::Span {
14267 match self {
14268 Self::CatchClause(inner) => inner.span(),
14269 Self::FinallyClause(inner) => inner.span(),
14270 }
14271 }
14272}
14273#[derive(Debug, Clone)]
14274pub enum UnaryOpExpressionOperator {
14275 Bang(::treesitter_types::Span),
14276 Plus(::treesitter_types::Span),
14277 Minus(::treesitter_types::Span),
14278 Tilde(::treesitter_types::Span),
14279}
14280impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOpExpressionOperator {
14281 #[allow(clippy::collapsible_else_if)]
14282 fn from_node(
14283 node: ::tree_sitter::Node<'tree>,
14284 _src: &'tree [u8],
14285 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14286 match node.kind() {
14287 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
14288 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
14289 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
14290 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
14291 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14292 }
14293 }
14294}
14295impl ::treesitter_types::Spanned for UnaryOpExpressionOperator {
14296 fn span(&self) -> ::treesitter_types::Span {
14297 match self {
14298 Self::Bang(span) => *span,
14299 Self::Plus(span) => *span,
14300 Self::Minus(span) => *span,
14301 Self::Tilde(span) => *span,
14302 }
14303 }
14304}
14305#[derive(Debug, Clone)]
14306pub enum UnionTypeChildren<'tree> {
14307 NamedType(::std::boxed::Box<NamedType<'tree>>),
14308 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
14309 PrimitiveType(::std::boxed::Box<PrimitiveType<'tree>>),
14310}
14311impl<'tree> ::treesitter_types::FromNode<'tree> for UnionTypeChildren<'tree> {
14312 #[allow(clippy::collapsible_else_if)]
14313 fn from_node(
14314 node: ::tree_sitter::Node<'tree>,
14315 src: &'tree [u8],
14316 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14317 match node.kind() {
14318 "named_type" => Ok(Self::NamedType(::std::boxed::Box::new(
14319 <NamedType as ::treesitter_types::FromNode>::from_node(node, src)?,
14320 ))),
14321 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
14322 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
14323 ))),
14324 "primitive_type" => Ok(Self::PrimitiveType(::std::boxed::Box::new(
14325 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)?,
14326 ))),
14327 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14328 }
14329 }
14330}
14331impl ::treesitter_types::Spanned for UnionTypeChildren<'_> {
14332 fn span(&self) -> ::treesitter_types::Span {
14333 match self {
14334 Self::NamedType(inner) => inner.span(),
14335 Self::OptionalType(inner) => inner.span(),
14336 Self::PrimitiveType(inner) => inner.span(),
14337 }
14338 }
14339}
14340#[derive(Debug, Clone)]
14341pub enum UnsetStatementChildren<'tree> {
14342 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14343 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14344 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14345 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14346 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14347 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14348 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14349 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14350 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14351 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14352 VariableName(::std::boxed::Box<VariableName<'tree>>),
14353}
14354impl<'tree> ::treesitter_types::FromNode<'tree> for UnsetStatementChildren<'tree> {
14355 #[allow(clippy::collapsible_else_if)]
14356 fn from_node(
14357 node: ::tree_sitter::Node<'tree>,
14358 src: &'tree [u8],
14359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14360 match node.kind() {
14361 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14362 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14363 ))),
14364 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14365 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14366 ))),
14367 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14368 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14369 ))),
14370 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14371 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14372 ))),
14373 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14374 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14375 ))),
14376 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14377 ::std::boxed::Box::new(
14378 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14379 node, src,
14380 )?,
14381 ),
14382 )),
14383 "nullsafe_member_call_expression" => {
14384 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
14385 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14386 node, src,
14387 )?,
14388 )))
14389 }
14390 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14391 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14392 ))),
14393 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14394 ::std::boxed::Box::new(
14395 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14396 node, src,
14397 )?,
14398 ),
14399 )),
14400 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14401 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14402 ))),
14403 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14404 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14405 ))),
14406 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14407 }
14408 }
14409}
14410impl ::treesitter_types::Spanned for UnsetStatementChildren<'_> {
14411 fn span(&self) -> ::treesitter_types::Span {
14412 match self {
14413 Self::CastExpression(inner) => inner.span(),
14414 Self::DynamicVariableName(inner) => inner.span(),
14415 Self::FunctionCallExpression(inner) => inner.span(),
14416 Self::MemberAccessExpression(inner) => inner.span(),
14417 Self::MemberCallExpression(inner) => inner.span(),
14418 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14419 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14420 Self::ScopedCallExpression(inner) => inner.span(),
14421 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14422 Self::SubscriptExpression(inner) => inner.span(),
14423 Self::VariableName(inner) => inner.span(),
14424 }
14425 }
14426}
14427#[derive(Debug, Clone)]
14428pub enum UpdateExpressionArgument<'tree> {
14429 CastExpression(::std::boxed::Box<CastExpression<'tree>>),
14430 DynamicVariableName(::std::boxed::Box<DynamicVariableName<'tree>>),
14431 FunctionCallExpression(::std::boxed::Box<FunctionCallExpression<'tree>>),
14432 MemberAccessExpression(::std::boxed::Box<MemberAccessExpression<'tree>>),
14433 MemberCallExpression(::std::boxed::Box<MemberCallExpression<'tree>>),
14434 NullsafeMemberAccessExpression(::std::boxed::Box<NullsafeMemberAccessExpression<'tree>>),
14435 NullsafeMemberCallExpression(::std::boxed::Box<NullsafeMemberCallExpression<'tree>>),
14436 ScopedCallExpression(::std::boxed::Box<ScopedCallExpression<'tree>>),
14437 ScopedPropertyAccessExpression(::std::boxed::Box<ScopedPropertyAccessExpression<'tree>>),
14438 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
14439 VariableName(::std::boxed::Box<VariableName<'tree>>),
14440}
14441impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionArgument<'tree> {
14442 #[allow(clippy::collapsible_else_if)]
14443 fn from_node(
14444 node: ::tree_sitter::Node<'tree>,
14445 src: &'tree [u8],
14446 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14447 match node.kind() {
14448 "cast_expression" => Ok(Self::CastExpression(::std::boxed::Box::new(
14449 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14450 ))),
14451 "dynamic_variable_name" => Ok(Self::DynamicVariableName(::std::boxed::Box::new(
14452 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14453 ))),
14454 "function_call_expression" => Ok(Self::FunctionCallExpression(::std::boxed::Box::new(
14455 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14456 ))),
14457 "member_access_expression" => Ok(Self::MemberAccessExpression(::std::boxed::Box::new(
14458 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14459 ))),
14460 "member_call_expression" => Ok(Self::MemberCallExpression(::std::boxed::Box::new(
14461 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14462 ))),
14463 "nullsafe_member_access_expression" => Ok(Self::NullsafeMemberAccessExpression(
14464 ::std::boxed::Box::new(
14465 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
14466 node, src,
14467 )?,
14468 ),
14469 )),
14470 "nullsafe_member_call_expression" => {
14471 Ok(Self::NullsafeMemberCallExpression(::std::boxed::Box::new(
14472 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(
14473 node, src,
14474 )?,
14475 )))
14476 }
14477 "scoped_call_expression" => Ok(Self::ScopedCallExpression(::std::boxed::Box::new(
14478 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14479 ))),
14480 "scoped_property_access_expression" => Ok(Self::ScopedPropertyAccessExpression(
14481 ::std::boxed::Box::new(
14482 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
14483 node, src,
14484 )?,
14485 ),
14486 )),
14487 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
14488 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14489 ))),
14490 "variable_name" => Ok(Self::VariableName(::std::boxed::Box::new(
14491 <VariableName as ::treesitter_types::FromNode>::from_node(node, src)?,
14492 ))),
14493 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14494 }
14495 }
14496}
14497impl ::treesitter_types::Spanned for UpdateExpressionArgument<'_> {
14498 fn span(&self) -> ::treesitter_types::Span {
14499 match self {
14500 Self::CastExpression(inner) => inner.span(),
14501 Self::DynamicVariableName(inner) => inner.span(),
14502 Self::FunctionCallExpression(inner) => inner.span(),
14503 Self::MemberAccessExpression(inner) => inner.span(),
14504 Self::MemberCallExpression(inner) => inner.span(),
14505 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
14506 Self::NullsafeMemberCallExpression(inner) => inner.span(),
14507 Self::ScopedCallExpression(inner) => inner.span(),
14508 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
14509 Self::SubscriptExpression(inner) => inner.span(),
14510 Self::VariableName(inner) => inner.span(),
14511 }
14512 }
14513}
14514#[derive(Debug, Clone)]
14515pub enum UpdateExpressionOperator {
14516 PlusPlus(::treesitter_types::Span),
14517 MinusMinus(::treesitter_types::Span),
14518}
14519impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
14520 #[allow(clippy::collapsible_else_if)]
14521 fn from_node(
14522 node: ::tree_sitter::Node<'tree>,
14523 _src: &'tree [u8],
14524 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14525 match node.kind() {
14526 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
14527 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
14528 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14529 }
14530 }
14531}
14532impl ::treesitter_types::Spanned for UpdateExpressionOperator {
14533 fn span(&self) -> ::treesitter_types::Span {
14534 match self {
14535 Self::PlusPlus(span) => *span,
14536 Self::MinusMinus(span) => *span,
14537 }
14538 }
14539}
14540#[derive(Debug, Clone)]
14541pub enum UseAsClauseChildren<'tree> {
14542 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
14543 Name(::std::boxed::Box<Name<'tree>>),
14544 VisibilityModifier(::std::boxed::Box<VisibilityModifier<'tree>>),
14545}
14546impl<'tree> ::treesitter_types::FromNode<'tree> for UseAsClauseChildren<'tree> {
14547 #[allow(clippy::collapsible_else_if)]
14548 fn from_node(
14549 node: ::tree_sitter::Node<'tree>,
14550 src: &'tree [u8],
14551 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14552 match node.kind() {
14553 "class_constant_access_expression" => {
14554 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
14555 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
14556 node, src,
14557 )?,
14558 )))
14559 }
14560 "name" => Ok(Self::Name(::std::boxed::Box::new(
14561 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14562 ))),
14563 "visibility_modifier" => Ok(Self::VisibilityModifier(::std::boxed::Box::new(
14564 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
14565 ))),
14566 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14567 }
14568 }
14569}
14570impl ::treesitter_types::Spanned for UseAsClauseChildren<'_> {
14571 fn span(&self) -> ::treesitter_types::Span {
14572 match self {
14573 Self::ClassConstantAccessExpression(inner) => inner.span(),
14574 Self::Name(inner) => inner.span(),
14575 Self::VisibilityModifier(inner) => inner.span(),
14576 }
14577 }
14578}
14579#[derive(Debug, Clone)]
14580pub enum UseDeclarationChildren<'tree> {
14581 Name(::std::boxed::Box<Name<'tree>>),
14582 QualifiedName(::std::boxed::Box<QualifiedName<'tree>>),
14583 RelativeName(::std::boxed::Box<RelativeName<'tree>>),
14584 UseList(::std::boxed::Box<UseList<'tree>>),
14585}
14586impl<'tree> ::treesitter_types::FromNode<'tree> for UseDeclarationChildren<'tree> {
14587 #[allow(clippy::collapsible_else_if)]
14588 fn from_node(
14589 node: ::tree_sitter::Node<'tree>,
14590 src: &'tree [u8],
14591 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14592 match node.kind() {
14593 "name" => Ok(Self::Name(::std::boxed::Box::new(
14594 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14595 ))),
14596 "qualified_name" => Ok(Self::QualifiedName(::std::boxed::Box::new(
14597 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)?,
14598 ))),
14599 "relative_name" => Ok(Self::RelativeName(::std::boxed::Box::new(
14600 <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)?,
14601 ))),
14602 "use_list" => Ok(Self::UseList(::std::boxed::Box::new(
14603 <UseList as ::treesitter_types::FromNode>::from_node(node, src)?,
14604 ))),
14605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14606 }
14607 }
14608}
14609impl ::treesitter_types::Spanned for UseDeclarationChildren<'_> {
14610 fn span(&self) -> ::treesitter_types::Span {
14611 match self {
14612 Self::Name(inner) => inner.span(),
14613 Self::QualifiedName(inner) => inner.span(),
14614 Self::RelativeName(inner) => inner.span(),
14615 Self::UseList(inner) => inner.span(),
14616 }
14617 }
14618}
14619#[derive(Debug, Clone)]
14620pub enum UseInsteadOfClauseChildren<'tree> {
14621 ClassConstantAccessExpression(::std::boxed::Box<ClassConstantAccessExpression<'tree>>),
14622 Name(::std::boxed::Box<Name<'tree>>),
14623}
14624impl<'tree> ::treesitter_types::FromNode<'tree> for UseInsteadOfClauseChildren<'tree> {
14625 #[allow(clippy::collapsible_else_if)]
14626 fn from_node(
14627 node: ::tree_sitter::Node<'tree>,
14628 src: &'tree [u8],
14629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14630 match node.kind() {
14631 "class_constant_access_expression" => {
14632 Ok(Self::ClassConstantAccessExpression(::std::boxed::Box::new(
14633 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
14634 node, src,
14635 )?,
14636 )))
14637 }
14638 "name" => Ok(Self::Name(::std::boxed::Box::new(
14639 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14640 ))),
14641 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14642 }
14643 }
14644}
14645impl ::treesitter_types::Spanned for UseInsteadOfClauseChildren<'_> {
14646 fn span(&self) -> ::treesitter_types::Span {
14647 match self {
14648 Self::ClassConstantAccessExpression(inner) => inner.span(),
14649 Self::Name(inner) => inner.span(),
14650 }
14651 }
14652}
14653#[derive(Debug, Clone)]
14654pub enum UseListChildren<'tree> {
14655 UseAsClause(::std::boxed::Box<UseAsClause<'tree>>),
14656 UseInsteadOfClause(::std::boxed::Box<UseInsteadOfClause<'tree>>),
14657}
14658impl<'tree> ::treesitter_types::FromNode<'tree> for UseListChildren<'tree> {
14659 #[allow(clippy::collapsible_else_if)]
14660 fn from_node(
14661 node: ::tree_sitter::Node<'tree>,
14662 src: &'tree [u8],
14663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14664 match node.kind() {
14665 "use_as_clause" => Ok(Self::UseAsClause(::std::boxed::Box::new(
14666 <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14667 ))),
14668 "use_instead_of_clause" => Ok(Self::UseInsteadOfClause(::std::boxed::Box::new(
14669 <UseInsteadOfClause as ::treesitter_types::FromNode>::from_node(node, src)?,
14670 ))),
14671 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14672 }
14673 }
14674}
14675impl ::treesitter_types::Spanned for UseListChildren<'_> {
14676 fn span(&self) -> ::treesitter_types::Span {
14677 match self {
14678 Self::UseAsClause(inner) => inner.span(),
14679 Self::UseInsteadOfClause(inner) => inner.span(),
14680 }
14681 }
14682}
14683#[derive(Debug, Clone)]
14684pub enum WhileStatementBody<'tree> {
14685 ColonBlock(::std::boxed::Box<ColonBlock<'tree>>),
14686 Statement(::std::boxed::Box<Statement<'tree>>),
14687}
14688impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatementBody<'tree> {
14689 #[allow(clippy::collapsible_else_if)]
14690 fn from_node(
14691 node: ::tree_sitter::Node<'tree>,
14692 src: &'tree [u8],
14693 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14694 match node.kind() {
14695 "colon_block" => Ok(Self::ColonBlock(::std::boxed::Box::new(
14696 <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
14697 ))),
14698 _other => {
14699 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
14700 Ok(Self::Statement(::std::boxed::Box::new(v)))
14701 } else {
14702 Err(::treesitter_types::ParseError::unexpected_kind(
14703 _other, node,
14704 ))
14705 }
14706 }
14707 }
14708 }
14709}
14710impl ::treesitter_types::Spanned for WhileStatementBody<'_> {
14711 fn span(&self) -> ::treesitter_types::Span {
14712 match self {
14713 Self::ColonBlock(inner) => inner.span(),
14714 Self::Statement(inner) => inner.span(),
14715 }
14716 }
14717}
14718#[derive(Debug, Clone)]
14719pub enum YieldExpressionChildren<'tree> {
14720 ArrayElementInitializer(::std::boxed::Box<ArrayElementInitializer<'tree>>),
14721 Expression(::std::boxed::Box<Expression<'tree>>),
14722}
14723impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpressionChildren<'tree> {
14724 #[allow(clippy::collapsible_else_if)]
14725 fn from_node(
14726 node: ::tree_sitter::Node<'tree>,
14727 src: &'tree [u8],
14728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14729 match node.kind() {
14730 "array_element_initializer" => {
14731 Ok(Self::ArrayElementInitializer(::std::boxed::Box::new(
14732 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(
14733 node, src,
14734 )?,
14735 )))
14736 }
14737 _other => {
14738 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14739 Ok(Self::Expression(::std::boxed::Box::new(v)))
14740 } else {
14741 Err(::treesitter_types::ParseError::unexpected_kind(
14742 _other, node,
14743 ))
14744 }
14745 }
14746 }
14747 }
14748}
14749impl ::treesitter_types::Spanned for YieldExpressionChildren<'_> {
14750 fn span(&self) -> ::treesitter_types::Span {
14751 match self {
14752 Self::ArrayElementInitializer(inner) => inner.span(),
14753 Self::Expression(inner) => inner.span(),
14754 }
14755 }
14756}
14757#[derive(Debug, Clone)]
14758pub enum AnyNode<'tree> {
14759 Expression(Expression<'tree>),
14760 Literal(Literal<'tree>),
14761 PrimaryExpression(PrimaryExpression<'tree>),
14762 Statement(Statement<'tree>),
14763 Type(Type<'tree>),
14764 AbstractModifier(AbstractModifier<'tree>),
14765 AnonymousClass(AnonymousClass<'tree>),
14766 AnonymousFunction(AnonymousFunction<'tree>),
14767 AnonymousFunctionUseClause(AnonymousFunctionUseClause<'tree>),
14768 Argument(Argument<'tree>),
14769 Arguments(Arguments<'tree>),
14770 ArrayCreationExpression(ArrayCreationExpression<'tree>),
14771 ArrayElementInitializer(ArrayElementInitializer<'tree>),
14772 ArrowFunction(ArrowFunction<'tree>),
14773 AssignmentExpression(AssignmentExpression<'tree>),
14774 Attribute(Attribute<'tree>),
14775 AttributeGroup(AttributeGroup<'tree>),
14776 AttributeList(AttributeList<'tree>),
14777 AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
14778 BaseClause(BaseClause<'tree>),
14779 BinaryExpression(BinaryExpression<'tree>),
14780 Boolean(Boolean<'tree>),
14781 BreakStatement(BreakStatement<'tree>),
14782 ByRef(ByRef<'tree>),
14783 CaseStatement(CaseStatement<'tree>),
14784 CastExpression(CastExpression<'tree>),
14785 CastType(CastType<'tree>),
14786 CatchClause(CatchClause<'tree>),
14787 ClassConstantAccessExpression(ClassConstantAccessExpression<'tree>),
14788 ClassDeclaration(ClassDeclaration<'tree>),
14789 ClassInterfaceClause(ClassInterfaceClause<'tree>),
14790 CloneExpression(CloneExpression<'tree>),
14791 ColonBlock(ColonBlock<'tree>),
14792 CompoundStatement(CompoundStatement<'tree>),
14793 ConditionalExpression(ConditionalExpression<'tree>),
14794 ConstDeclaration(ConstDeclaration<'tree>),
14795 ConstElement(ConstElement<'tree>),
14796 ContinueStatement(ContinueStatement<'tree>),
14797 DeclarationList(DeclarationList<'tree>),
14798 DeclareDirective(DeclareDirective<'tree>),
14799 DeclareStatement(DeclareStatement<'tree>),
14800 DefaultStatement(DefaultStatement<'tree>),
14801 DisjunctiveNormalFormType(DisjunctiveNormalFormType<'tree>),
14802 DoStatement(DoStatement<'tree>),
14803 DynamicVariableName(DynamicVariableName<'tree>),
14804 EchoStatement(EchoStatement<'tree>),
14805 ElseClause(ElseClause<'tree>),
14806 ElseIfClause(ElseIfClause<'tree>),
14807 EmptyStatement(EmptyStatement<'tree>),
14808 EncapsedString(EncapsedString<'tree>),
14809 EnumCase(EnumCase<'tree>),
14810 EnumDeclaration(EnumDeclaration<'tree>),
14811 EnumDeclarationList(EnumDeclarationList<'tree>),
14812 ErrorSuppressionExpression(ErrorSuppressionExpression<'tree>),
14813 ExitStatement(ExitStatement<'tree>),
14814 ExpressionStatement(ExpressionStatement<'tree>),
14815 FinalModifier(FinalModifier<'tree>),
14816 FinallyClause(FinallyClause<'tree>),
14817 ForStatement(ForStatement<'tree>),
14818 ForeachStatement(ForeachStatement<'tree>),
14819 FormalParameters(FormalParameters<'tree>),
14820 FunctionCallExpression(FunctionCallExpression<'tree>),
14821 FunctionDefinition(FunctionDefinition<'tree>),
14822 FunctionStaticDeclaration(FunctionStaticDeclaration<'tree>),
14823 GlobalDeclaration(GlobalDeclaration<'tree>),
14824 GotoStatement(GotoStatement<'tree>),
14825 Heredoc(Heredoc<'tree>),
14826 HeredocBody(HeredocBody<'tree>),
14827 IfStatement(IfStatement<'tree>),
14828 IncludeExpression(IncludeExpression<'tree>),
14829 IncludeOnceExpression(IncludeOnceExpression<'tree>),
14830 InterfaceDeclaration(InterfaceDeclaration<'tree>),
14831 IntersectionType(IntersectionType<'tree>),
14832 ListLiteral(ListLiteral<'tree>),
14833 MatchBlock(MatchBlock<'tree>),
14834 MatchConditionList(MatchConditionList<'tree>),
14835 MatchConditionalExpression(MatchConditionalExpression<'tree>),
14836 MatchDefaultExpression(MatchDefaultExpression<'tree>),
14837 MatchExpression(MatchExpression<'tree>),
14838 MemberAccessExpression(MemberAccessExpression<'tree>),
14839 MemberCallExpression(MemberCallExpression<'tree>),
14840 MethodDeclaration(MethodDeclaration<'tree>),
14841 Name(Name<'tree>),
14842 NamedLabelStatement(NamedLabelStatement<'tree>),
14843 NamedType(NamedType<'tree>),
14844 NamespaceDefinition(NamespaceDefinition<'tree>),
14845 NamespaceName(NamespaceName<'tree>),
14846 NamespaceUseClause(NamespaceUseClause<'tree>),
14847 NamespaceUseDeclaration(NamespaceUseDeclaration<'tree>),
14848 NamespaceUseGroup(NamespaceUseGroup<'tree>),
14849 Nowdoc(Nowdoc<'tree>),
14850 NowdocBody(NowdocBody<'tree>),
14851 Null(Null<'tree>),
14852 NullsafeMemberAccessExpression(NullsafeMemberAccessExpression<'tree>),
14853 NullsafeMemberCallExpression(NullsafeMemberCallExpression<'tree>),
14854 ObjectCreationExpression(ObjectCreationExpression<'tree>),
14855 OptionalType(OptionalType<'tree>),
14856 Pair(Pair<'tree>),
14857 ParenthesizedExpression(ParenthesizedExpression<'tree>),
14858 PrimitiveType(PrimitiveType<'tree>),
14859 PrintIntrinsic(PrintIntrinsic<'tree>),
14860 Program(Program<'tree>),
14861 PropertyDeclaration(PropertyDeclaration<'tree>),
14862 PropertyElement(PropertyElement<'tree>),
14863 PropertyHook(PropertyHook<'tree>),
14864 PropertyHookList(PropertyHookList<'tree>),
14865 PropertyPromotionParameter(PropertyPromotionParameter<'tree>),
14866 QualifiedName(QualifiedName<'tree>),
14867 ReadonlyModifier(ReadonlyModifier<'tree>),
14868 ReferenceAssignmentExpression(ReferenceAssignmentExpression<'tree>),
14869 ReferenceModifier(ReferenceModifier<'tree>),
14870 RelativeName(RelativeName<'tree>),
14871 RelativeScope(RelativeScope<'tree>),
14872 RequireExpression(RequireExpression<'tree>),
14873 RequireOnceExpression(RequireOnceExpression<'tree>),
14874 ReturnStatement(ReturnStatement<'tree>),
14875 ScopedCallExpression(ScopedCallExpression<'tree>),
14876 ScopedPropertyAccessExpression(ScopedPropertyAccessExpression<'tree>),
14877 SequenceExpression(SequenceExpression<'tree>),
14878 ShellCommandExpression(ShellCommandExpression<'tree>),
14879 SimpleParameter(SimpleParameter<'tree>),
14880 StaticModifier(StaticModifier<'tree>),
14881 StaticVariableDeclaration(StaticVariableDeclaration<'tree>),
14882 String(String<'tree>),
14883 StringContent(StringContent<'tree>),
14884 SubscriptExpression(SubscriptExpression<'tree>),
14885 SwitchBlock(SwitchBlock<'tree>),
14886 SwitchStatement(SwitchStatement<'tree>),
14887 Text(Text<'tree>),
14888 TextInterpolation(TextInterpolation<'tree>),
14889 ThrowExpression(ThrowExpression<'tree>),
14890 TraitDeclaration(TraitDeclaration<'tree>),
14891 TryStatement(TryStatement<'tree>),
14892 TypeList(TypeList<'tree>),
14893 UnaryOpExpression(UnaryOpExpression<'tree>),
14894 UnionType(UnionType<'tree>),
14895 UnsetStatement(UnsetStatement<'tree>),
14896 UpdateExpression(UpdateExpression<'tree>),
14897 UseAsClause(UseAsClause<'tree>),
14898 UseDeclaration(UseDeclaration<'tree>),
14899 UseInsteadOfClause(UseInsteadOfClause<'tree>),
14900 UseList(UseList<'tree>),
14901 VariableName(VariableName<'tree>),
14902 VariadicParameter(VariadicParameter<'tree>),
14903 VariadicPlaceholder(VariadicPlaceholder<'tree>),
14904 VariadicUnpacking(VariadicUnpacking<'tree>),
14905 VisibilityModifier(VisibilityModifier<'tree>),
14906 WhileStatement(WhileStatement<'tree>),
14907 YieldExpression(YieldExpression<'tree>),
14908 BottomType(BottomType<'tree>),
14909 Comment(Comment<'tree>),
14910 EscapeSequence(EscapeSequence<'tree>),
14911 Float(Float<'tree>),
14912 HeredocEnd(HeredocEnd<'tree>),
14913 HeredocStart(HeredocStart<'tree>),
14914 Integer(Integer<'tree>),
14915 NowdocString(NowdocString<'tree>),
14916 Operation(Operation<'tree>),
14917 PhpEndTag(PhpEndTag<'tree>),
14918 PhpTag(PhpTag<'tree>),
14919 VarModifier(VarModifier<'tree>),
14920 Unknown(::tree_sitter::Node<'tree>),
14921}
14922impl<'tree> AnyNode<'tree> {
14923 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
14924 match node.kind() {
14925 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14926 .map(Self::Expression)
14927 .unwrap_or(Self::Unknown(node)),
14928 "literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
14929 .map(Self::Literal)
14930 .unwrap_or(Self::Unknown(node)),
14931 "primary_expression" => {
14932 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14933 .map(Self::PrimaryExpression)
14934 .unwrap_or(Self::Unknown(node))
14935 }
14936 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
14937 .map(Self::Statement)
14938 .unwrap_or(Self::Unknown(node)),
14939 "type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
14940 .map(Self::Type)
14941 .unwrap_or(Self::Unknown(node)),
14942 "abstract_modifier" => {
14943 <AbstractModifier as ::treesitter_types::FromNode>::from_node(node, src)
14944 .map(Self::AbstractModifier)
14945 .unwrap_or(Self::Unknown(node))
14946 }
14947 "anonymous_class" => {
14948 <AnonymousClass as ::treesitter_types::FromNode>::from_node(node, src)
14949 .map(Self::AnonymousClass)
14950 .unwrap_or(Self::Unknown(node))
14951 }
14952 "anonymous_function" => {
14953 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)
14954 .map(Self::AnonymousFunction)
14955 .unwrap_or(Self::Unknown(node))
14956 }
14957 "anonymous_function_use_clause" => {
14958 <AnonymousFunctionUseClause as ::treesitter_types::FromNode>::from_node(node, src)
14959 .map(Self::AnonymousFunctionUseClause)
14960 .unwrap_or(Self::Unknown(node))
14961 }
14962 "argument" => <Argument as ::treesitter_types::FromNode>::from_node(node, src)
14963 .map(Self::Argument)
14964 .unwrap_or(Self::Unknown(node)),
14965 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
14966 .map(Self::Arguments)
14967 .unwrap_or(Self::Unknown(node)),
14968 "array_creation_expression" => {
14969 <ArrayCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14970 .map(Self::ArrayCreationExpression)
14971 .unwrap_or(Self::Unknown(node))
14972 }
14973 "array_element_initializer" => {
14974 <ArrayElementInitializer as ::treesitter_types::FromNode>::from_node(node, src)
14975 .map(Self::ArrayElementInitializer)
14976 .unwrap_or(Self::Unknown(node))
14977 }
14978 "arrow_function" => {
14979 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
14980 .map(Self::ArrowFunction)
14981 .unwrap_or(Self::Unknown(node))
14982 }
14983 "assignment_expression" => {
14984 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
14985 .map(Self::AssignmentExpression)
14986 .unwrap_or(Self::Unknown(node))
14987 }
14988 "attribute" => <Attribute as ::treesitter_types::FromNode>::from_node(node, src)
14989 .map(Self::Attribute)
14990 .unwrap_or(Self::Unknown(node)),
14991 "attribute_group" => {
14992 <AttributeGroup as ::treesitter_types::FromNode>::from_node(node, src)
14993 .map(Self::AttributeGroup)
14994 .unwrap_or(Self::Unknown(node))
14995 }
14996 "attribute_list" => {
14997 <AttributeList as ::treesitter_types::FromNode>::from_node(node, src)
14998 .map(Self::AttributeList)
14999 .unwrap_or(Self::Unknown(node))
15000 }
15001 "augmented_assignment_expression" => {
15002 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
15003 node, src,
15004 )
15005 .map(Self::AugmentedAssignmentExpression)
15006 .unwrap_or(Self::Unknown(node))
15007 }
15008 "base_clause" => <BaseClause as ::treesitter_types::FromNode>::from_node(node, src)
15009 .map(Self::BaseClause)
15010 .unwrap_or(Self::Unknown(node)),
15011 "binary_expression" => {
15012 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
15013 .map(Self::BinaryExpression)
15014 .unwrap_or(Self::Unknown(node))
15015 }
15016 "boolean" => <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
15017 .map(Self::Boolean)
15018 .unwrap_or(Self::Unknown(node)),
15019 "break_statement" => {
15020 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
15021 .map(Self::BreakStatement)
15022 .unwrap_or(Self::Unknown(node))
15023 }
15024 "by_ref" => <ByRef as ::treesitter_types::FromNode>::from_node(node, src)
15025 .map(Self::ByRef)
15026 .unwrap_or(Self::Unknown(node)),
15027 "case_statement" => {
15028 <CaseStatement as ::treesitter_types::FromNode>::from_node(node, src)
15029 .map(Self::CaseStatement)
15030 .unwrap_or(Self::Unknown(node))
15031 }
15032 "cast_expression" => {
15033 <CastExpression as ::treesitter_types::FromNode>::from_node(node, src)
15034 .map(Self::CastExpression)
15035 .unwrap_or(Self::Unknown(node))
15036 }
15037 "cast_type" => <CastType as ::treesitter_types::FromNode>::from_node(node, src)
15038 .map(Self::CastType)
15039 .unwrap_or(Self::Unknown(node)),
15040 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
15041 .map(Self::CatchClause)
15042 .unwrap_or(Self::Unknown(node)),
15043 "class_constant_access_expression" => {
15044 <ClassConstantAccessExpression as ::treesitter_types::FromNode>::from_node(
15045 node, src,
15046 )
15047 .map(Self::ClassConstantAccessExpression)
15048 .unwrap_or(Self::Unknown(node))
15049 }
15050 "class_declaration" => {
15051 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15052 .map(Self::ClassDeclaration)
15053 .unwrap_or(Self::Unknown(node))
15054 }
15055 "class_interface_clause" => {
15056 <ClassInterfaceClause as ::treesitter_types::FromNode>::from_node(node, src)
15057 .map(Self::ClassInterfaceClause)
15058 .unwrap_or(Self::Unknown(node))
15059 }
15060 "clone_expression" => {
15061 <CloneExpression as ::treesitter_types::FromNode>::from_node(node, src)
15062 .map(Self::CloneExpression)
15063 .unwrap_or(Self::Unknown(node))
15064 }
15065 "colon_block" => <ColonBlock as ::treesitter_types::FromNode>::from_node(node, src)
15066 .map(Self::ColonBlock)
15067 .unwrap_or(Self::Unknown(node)),
15068 "compound_statement" => {
15069 <CompoundStatement as ::treesitter_types::FromNode>::from_node(node, src)
15070 .map(Self::CompoundStatement)
15071 .unwrap_or(Self::Unknown(node))
15072 }
15073 "conditional_expression" => {
15074 <ConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
15075 .map(Self::ConditionalExpression)
15076 .unwrap_or(Self::Unknown(node))
15077 }
15078 "const_declaration" => {
15079 <ConstDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15080 .map(Self::ConstDeclaration)
15081 .unwrap_or(Self::Unknown(node))
15082 }
15083 "const_element" => <ConstElement as ::treesitter_types::FromNode>::from_node(node, src)
15084 .map(Self::ConstElement)
15085 .unwrap_or(Self::Unknown(node)),
15086 "continue_statement" => {
15087 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
15088 .map(Self::ContinueStatement)
15089 .unwrap_or(Self::Unknown(node))
15090 }
15091 "declaration_list" => {
15092 <DeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
15093 .map(Self::DeclarationList)
15094 .unwrap_or(Self::Unknown(node))
15095 }
15096 "declare_directive" => {
15097 <DeclareDirective as ::treesitter_types::FromNode>::from_node(node, src)
15098 .map(Self::DeclareDirective)
15099 .unwrap_or(Self::Unknown(node))
15100 }
15101 "declare_statement" => {
15102 <DeclareStatement as ::treesitter_types::FromNode>::from_node(node, src)
15103 .map(Self::DeclareStatement)
15104 .unwrap_or(Self::Unknown(node))
15105 }
15106 "default_statement" => {
15107 <DefaultStatement as ::treesitter_types::FromNode>::from_node(node, src)
15108 .map(Self::DefaultStatement)
15109 .unwrap_or(Self::Unknown(node))
15110 }
15111 "disjunctive_normal_form_type" => {
15112 <DisjunctiveNormalFormType as ::treesitter_types::FromNode>::from_node(node, src)
15113 .map(Self::DisjunctiveNormalFormType)
15114 .unwrap_or(Self::Unknown(node))
15115 }
15116 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
15117 .map(Self::DoStatement)
15118 .unwrap_or(Self::Unknown(node)),
15119 "dynamic_variable_name" => {
15120 <DynamicVariableName as ::treesitter_types::FromNode>::from_node(node, src)
15121 .map(Self::DynamicVariableName)
15122 .unwrap_or(Self::Unknown(node))
15123 }
15124 "echo_statement" => {
15125 <EchoStatement as ::treesitter_types::FromNode>::from_node(node, src)
15126 .map(Self::EchoStatement)
15127 .unwrap_or(Self::Unknown(node))
15128 }
15129 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
15130 .map(Self::ElseClause)
15131 .unwrap_or(Self::Unknown(node)),
15132 "else_if_clause" => {
15133 <ElseIfClause as ::treesitter_types::FromNode>::from_node(node, src)
15134 .map(Self::ElseIfClause)
15135 .unwrap_or(Self::Unknown(node))
15136 }
15137 "empty_statement" => {
15138 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
15139 .map(Self::EmptyStatement)
15140 .unwrap_or(Self::Unknown(node))
15141 }
15142 "encapsed_string" => {
15143 <EncapsedString as ::treesitter_types::FromNode>::from_node(node, src)
15144 .map(Self::EncapsedString)
15145 .unwrap_or(Self::Unknown(node))
15146 }
15147 "enum_case" => <EnumCase as ::treesitter_types::FromNode>::from_node(node, src)
15148 .map(Self::EnumCase)
15149 .unwrap_or(Self::Unknown(node)),
15150 "enum_declaration" => {
15151 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15152 .map(Self::EnumDeclaration)
15153 .unwrap_or(Self::Unknown(node))
15154 }
15155 "enum_declaration_list" => {
15156 <EnumDeclarationList as ::treesitter_types::FromNode>::from_node(node, src)
15157 .map(Self::EnumDeclarationList)
15158 .unwrap_or(Self::Unknown(node))
15159 }
15160 "error_suppression_expression" => {
15161 <ErrorSuppressionExpression as ::treesitter_types::FromNode>::from_node(node, src)
15162 .map(Self::ErrorSuppressionExpression)
15163 .unwrap_or(Self::Unknown(node))
15164 }
15165 "exit_statement" => {
15166 <ExitStatement as ::treesitter_types::FromNode>::from_node(node, src)
15167 .map(Self::ExitStatement)
15168 .unwrap_or(Self::Unknown(node))
15169 }
15170 "expression_statement" => {
15171 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
15172 .map(Self::ExpressionStatement)
15173 .unwrap_or(Self::Unknown(node))
15174 }
15175 "final_modifier" => {
15176 <FinalModifier as ::treesitter_types::FromNode>::from_node(node, src)
15177 .map(Self::FinalModifier)
15178 .unwrap_or(Self::Unknown(node))
15179 }
15180 "finally_clause" => {
15181 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
15182 .map(Self::FinallyClause)
15183 .unwrap_or(Self::Unknown(node))
15184 }
15185 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
15186 .map(Self::ForStatement)
15187 .unwrap_or(Self::Unknown(node)),
15188 "foreach_statement" => {
15189 <ForeachStatement as ::treesitter_types::FromNode>::from_node(node, src)
15190 .map(Self::ForeachStatement)
15191 .unwrap_or(Self::Unknown(node))
15192 }
15193 "formal_parameters" => {
15194 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
15195 .map(Self::FormalParameters)
15196 .unwrap_or(Self::Unknown(node))
15197 }
15198 "function_call_expression" => {
15199 <FunctionCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15200 .map(Self::FunctionCallExpression)
15201 .unwrap_or(Self::Unknown(node))
15202 }
15203 "function_definition" => {
15204 <FunctionDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15205 .map(Self::FunctionDefinition)
15206 .unwrap_or(Self::Unknown(node))
15207 }
15208 "function_static_declaration" => {
15209 <FunctionStaticDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15210 .map(Self::FunctionStaticDeclaration)
15211 .unwrap_or(Self::Unknown(node))
15212 }
15213 "global_declaration" => {
15214 <GlobalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15215 .map(Self::GlobalDeclaration)
15216 .unwrap_or(Self::Unknown(node))
15217 }
15218 "goto_statement" => {
15219 <GotoStatement as ::treesitter_types::FromNode>::from_node(node, src)
15220 .map(Self::GotoStatement)
15221 .unwrap_or(Self::Unknown(node))
15222 }
15223 "heredoc" => <Heredoc as ::treesitter_types::FromNode>::from_node(node, src)
15224 .map(Self::Heredoc)
15225 .unwrap_or(Self::Unknown(node)),
15226 "heredoc_body" => <HeredocBody as ::treesitter_types::FromNode>::from_node(node, src)
15227 .map(Self::HeredocBody)
15228 .unwrap_or(Self::Unknown(node)),
15229 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
15230 .map(Self::IfStatement)
15231 .unwrap_or(Self::Unknown(node)),
15232 "include_expression" => {
15233 <IncludeExpression as ::treesitter_types::FromNode>::from_node(node, src)
15234 .map(Self::IncludeExpression)
15235 .unwrap_or(Self::Unknown(node))
15236 }
15237 "include_once_expression" => {
15238 <IncludeOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
15239 .map(Self::IncludeOnceExpression)
15240 .unwrap_or(Self::Unknown(node))
15241 }
15242 "interface_declaration" => {
15243 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15244 .map(Self::InterfaceDeclaration)
15245 .unwrap_or(Self::Unknown(node))
15246 }
15247 "intersection_type" => {
15248 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
15249 .map(Self::IntersectionType)
15250 .unwrap_or(Self::Unknown(node))
15251 }
15252 "list_literal" => <ListLiteral as ::treesitter_types::FromNode>::from_node(node, src)
15253 .map(Self::ListLiteral)
15254 .unwrap_or(Self::Unknown(node)),
15255 "match_block" => <MatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
15256 .map(Self::MatchBlock)
15257 .unwrap_or(Self::Unknown(node)),
15258 "match_condition_list" => {
15259 <MatchConditionList as ::treesitter_types::FromNode>::from_node(node, src)
15260 .map(Self::MatchConditionList)
15261 .unwrap_or(Self::Unknown(node))
15262 }
15263 "match_conditional_expression" => {
15264 <MatchConditionalExpression as ::treesitter_types::FromNode>::from_node(node, src)
15265 .map(Self::MatchConditionalExpression)
15266 .unwrap_or(Self::Unknown(node))
15267 }
15268 "match_default_expression" => {
15269 <MatchDefaultExpression as ::treesitter_types::FromNode>::from_node(node, src)
15270 .map(Self::MatchDefaultExpression)
15271 .unwrap_or(Self::Unknown(node))
15272 }
15273 "match_expression" => {
15274 <MatchExpression as ::treesitter_types::FromNode>::from_node(node, src)
15275 .map(Self::MatchExpression)
15276 .unwrap_or(Self::Unknown(node))
15277 }
15278 "member_access_expression" => {
15279 <MemberAccessExpression as ::treesitter_types::FromNode>::from_node(node, src)
15280 .map(Self::MemberAccessExpression)
15281 .unwrap_or(Self::Unknown(node))
15282 }
15283 "member_call_expression" => {
15284 <MemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15285 .map(Self::MemberCallExpression)
15286 .unwrap_or(Self::Unknown(node))
15287 }
15288 "method_declaration" => {
15289 <MethodDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15290 .map(Self::MethodDeclaration)
15291 .unwrap_or(Self::Unknown(node))
15292 }
15293 "name" => <Name as ::treesitter_types::FromNode>::from_node(node, src)
15294 .map(Self::Name)
15295 .unwrap_or(Self::Unknown(node)),
15296 "named_label_statement" => {
15297 <NamedLabelStatement as ::treesitter_types::FromNode>::from_node(node, src)
15298 .map(Self::NamedLabelStatement)
15299 .unwrap_or(Self::Unknown(node))
15300 }
15301 "named_type" => <NamedType as ::treesitter_types::FromNode>::from_node(node, src)
15302 .map(Self::NamedType)
15303 .unwrap_or(Self::Unknown(node)),
15304 "namespace_definition" => {
15305 <NamespaceDefinition as ::treesitter_types::FromNode>::from_node(node, src)
15306 .map(Self::NamespaceDefinition)
15307 .unwrap_or(Self::Unknown(node))
15308 }
15309 "namespace_name" => {
15310 <NamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
15311 .map(Self::NamespaceName)
15312 .unwrap_or(Self::Unknown(node))
15313 }
15314 "namespace_use_clause" => {
15315 <NamespaceUseClause as ::treesitter_types::FromNode>::from_node(node, src)
15316 .map(Self::NamespaceUseClause)
15317 .unwrap_or(Self::Unknown(node))
15318 }
15319 "namespace_use_declaration" => {
15320 <NamespaceUseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15321 .map(Self::NamespaceUseDeclaration)
15322 .unwrap_or(Self::Unknown(node))
15323 }
15324 "namespace_use_group" => {
15325 <NamespaceUseGroup as ::treesitter_types::FromNode>::from_node(node, src)
15326 .map(Self::NamespaceUseGroup)
15327 .unwrap_or(Self::Unknown(node))
15328 }
15329 "nowdoc" => <Nowdoc as ::treesitter_types::FromNode>::from_node(node, src)
15330 .map(Self::Nowdoc)
15331 .unwrap_or(Self::Unknown(node)),
15332 "nowdoc_body" => <NowdocBody as ::treesitter_types::FromNode>::from_node(node, src)
15333 .map(Self::NowdocBody)
15334 .unwrap_or(Self::Unknown(node)),
15335 "null" => <Null as ::treesitter_types::FromNode>::from_node(node, src)
15336 .map(Self::Null)
15337 .unwrap_or(Self::Unknown(node)),
15338 "nullsafe_member_access_expression" => {
15339 <NullsafeMemberAccessExpression as ::treesitter_types::FromNode>::from_node(
15340 node, src,
15341 )
15342 .map(Self::NullsafeMemberAccessExpression)
15343 .unwrap_or(Self::Unknown(node))
15344 }
15345 "nullsafe_member_call_expression" => {
15346 <NullsafeMemberCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15347 .map(Self::NullsafeMemberCallExpression)
15348 .unwrap_or(Self::Unknown(node))
15349 }
15350 "object_creation_expression" => {
15351 <ObjectCreationExpression as ::treesitter_types::FromNode>::from_node(node, src)
15352 .map(Self::ObjectCreationExpression)
15353 .unwrap_or(Self::Unknown(node))
15354 }
15355 "optional_type" => <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
15356 .map(Self::OptionalType)
15357 .unwrap_or(Self::Unknown(node)),
15358 "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
15359 .map(Self::Pair)
15360 .unwrap_or(Self::Unknown(node)),
15361 "parenthesized_expression" => {
15362 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15363 .map(Self::ParenthesizedExpression)
15364 .unwrap_or(Self::Unknown(node))
15365 }
15366 "primitive_type" => {
15367 <PrimitiveType as ::treesitter_types::FromNode>::from_node(node, src)
15368 .map(Self::PrimitiveType)
15369 .unwrap_or(Self::Unknown(node))
15370 }
15371 "print_intrinsic" => {
15372 <PrintIntrinsic as ::treesitter_types::FromNode>::from_node(node, src)
15373 .map(Self::PrintIntrinsic)
15374 .unwrap_or(Self::Unknown(node))
15375 }
15376 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
15377 .map(Self::Program)
15378 .unwrap_or(Self::Unknown(node)),
15379 "property_declaration" => {
15380 <PropertyDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15381 .map(Self::PropertyDeclaration)
15382 .unwrap_or(Self::Unknown(node))
15383 }
15384 "property_element" => {
15385 <PropertyElement as ::treesitter_types::FromNode>::from_node(node, src)
15386 .map(Self::PropertyElement)
15387 .unwrap_or(Self::Unknown(node))
15388 }
15389 "property_hook" => <PropertyHook as ::treesitter_types::FromNode>::from_node(node, src)
15390 .map(Self::PropertyHook)
15391 .unwrap_or(Self::Unknown(node)),
15392 "property_hook_list" => {
15393 <PropertyHookList as ::treesitter_types::FromNode>::from_node(node, src)
15394 .map(Self::PropertyHookList)
15395 .unwrap_or(Self::Unknown(node))
15396 }
15397 "property_promotion_parameter" => {
15398 <PropertyPromotionParameter as ::treesitter_types::FromNode>::from_node(node, src)
15399 .map(Self::PropertyPromotionParameter)
15400 .unwrap_or(Self::Unknown(node))
15401 }
15402 "qualified_name" => {
15403 <QualifiedName as ::treesitter_types::FromNode>::from_node(node, src)
15404 .map(Self::QualifiedName)
15405 .unwrap_or(Self::Unknown(node))
15406 }
15407 "readonly_modifier" => {
15408 <ReadonlyModifier as ::treesitter_types::FromNode>::from_node(node, src)
15409 .map(Self::ReadonlyModifier)
15410 .unwrap_or(Self::Unknown(node))
15411 }
15412 "reference_assignment_expression" => {
15413 <ReferenceAssignmentExpression as ::treesitter_types::FromNode>::from_node(
15414 node, src,
15415 )
15416 .map(Self::ReferenceAssignmentExpression)
15417 .unwrap_or(Self::Unknown(node))
15418 }
15419 "reference_modifier" => {
15420 <ReferenceModifier as ::treesitter_types::FromNode>::from_node(node, src)
15421 .map(Self::ReferenceModifier)
15422 .unwrap_or(Self::Unknown(node))
15423 }
15424 "relative_name" => <RelativeName as ::treesitter_types::FromNode>::from_node(node, src)
15425 .map(Self::RelativeName)
15426 .unwrap_or(Self::Unknown(node)),
15427 "relative_scope" => {
15428 <RelativeScope as ::treesitter_types::FromNode>::from_node(node, src)
15429 .map(Self::RelativeScope)
15430 .unwrap_or(Self::Unknown(node))
15431 }
15432 "require_expression" => {
15433 <RequireExpression as ::treesitter_types::FromNode>::from_node(node, src)
15434 .map(Self::RequireExpression)
15435 .unwrap_or(Self::Unknown(node))
15436 }
15437 "require_once_expression" => {
15438 <RequireOnceExpression as ::treesitter_types::FromNode>::from_node(node, src)
15439 .map(Self::RequireOnceExpression)
15440 .unwrap_or(Self::Unknown(node))
15441 }
15442 "return_statement" => {
15443 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
15444 .map(Self::ReturnStatement)
15445 .unwrap_or(Self::Unknown(node))
15446 }
15447 "scoped_call_expression" => {
15448 <ScopedCallExpression as ::treesitter_types::FromNode>::from_node(node, src)
15449 .map(Self::ScopedCallExpression)
15450 .unwrap_or(Self::Unknown(node))
15451 }
15452 "scoped_property_access_expression" => {
15453 <ScopedPropertyAccessExpression as ::treesitter_types::FromNode>::from_node(
15454 node, src,
15455 )
15456 .map(Self::ScopedPropertyAccessExpression)
15457 .unwrap_or(Self::Unknown(node))
15458 }
15459 "sequence_expression" => {
15460 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
15461 .map(Self::SequenceExpression)
15462 .unwrap_or(Self::Unknown(node))
15463 }
15464 "shell_command_expression" => {
15465 <ShellCommandExpression as ::treesitter_types::FromNode>::from_node(node, src)
15466 .map(Self::ShellCommandExpression)
15467 .unwrap_or(Self::Unknown(node))
15468 }
15469 "simple_parameter" => {
15470 <SimpleParameter as ::treesitter_types::FromNode>::from_node(node, src)
15471 .map(Self::SimpleParameter)
15472 .unwrap_or(Self::Unknown(node))
15473 }
15474 "static_modifier" => {
15475 <StaticModifier as ::treesitter_types::FromNode>::from_node(node, src)
15476 .map(Self::StaticModifier)
15477 .unwrap_or(Self::Unknown(node))
15478 }
15479 "static_variable_declaration" => {
15480 <StaticVariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15481 .map(Self::StaticVariableDeclaration)
15482 .unwrap_or(Self::Unknown(node))
15483 }
15484 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
15485 .map(Self::String)
15486 .unwrap_or(Self::Unknown(node)),
15487 "string_content" => {
15488 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
15489 .map(Self::StringContent)
15490 .unwrap_or(Self::Unknown(node))
15491 }
15492 "subscript_expression" => {
15493 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
15494 .map(Self::SubscriptExpression)
15495 .unwrap_or(Self::Unknown(node))
15496 }
15497 "switch_block" => <SwitchBlock as ::treesitter_types::FromNode>::from_node(node, src)
15498 .map(Self::SwitchBlock)
15499 .unwrap_or(Self::Unknown(node)),
15500 "switch_statement" => {
15501 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
15502 .map(Self::SwitchStatement)
15503 .unwrap_or(Self::Unknown(node))
15504 }
15505 "text" => <Text as ::treesitter_types::FromNode>::from_node(node, src)
15506 .map(Self::Text)
15507 .unwrap_or(Self::Unknown(node)),
15508 "text_interpolation" => {
15509 <TextInterpolation as ::treesitter_types::FromNode>::from_node(node, src)
15510 .map(Self::TextInterpolation)
15511 .unwrap_or(Self::Unknown(node))
15512 }
15513 "throw_expression" => {
15514 <ThrowExpression as ::treesitter_types::FromNode>::from_node(node, src)
15515 .map(Self::ThrowExpression)
15516 .unwrap_or(Self::Unknown(node))
15517 }
15518 "trait_declaration" => {
15519 <TraitDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15520 .map(Self::TraitDeclaration)
15521 .unwrap_or(Self::Unknown(node))
15522 }
15523 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
15524 .map(Self::TryStatement)
15525 .unwrap_or(Self::Unknown(node)),
15526 "type_list" => <TypeList as ::treesitter_types::FromNode>::from_node(node, src)
15527 .map(Self::TypeList)
15528 .unwrap_or(Self::Unknown(node)),
15529 "unary_op_expression" => {
15530 <UnaryOpExpression as ::treesitter_types::FromNode>::from_node(node, src)
15531 .map(Self::UnaryOpExpression)
15532 .unwrap_or(Self::Unknown(node))
15533 }
15534 "union_type" => <UnionType as ::treesitter_types::FromNode>::from_node(node, src)
15535 .map(Self::UnionType)
15536 .unwrap_or(Self::Unknown(node)),
15537 "unset_statement" => {
15538 <UnsetStatement as ::treesitter_types::FromNode>::from_node(node, src)
15539 .map(Self::UnsetStatement)
15540 .unwrap_or(Self::Unknown(node))
15541 }
15542 "update_expression" => {
15543 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
15544 .map(Self::UpdateExpression)
15545 .unwrap_or(Self::Unknown(node))
15546 }
15547 "use_as_clause" => <UseAsClause as ::treesitter_types::FromNode>::from_node(node, src)
15548 .map(Self::UseAsClause)
15549 .unwrap_or(Self::Unknown(node)),
15550 "use_declaration" => {
15551 <UseDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
15552 .map(Self::UseDeclaration)
15553 .unwrap_or(Self::Unknown(node))
15554 }
15555 "use_instead_of_clause" => {
15556 <UseInsteadOfClause as ::treesitter_types::FromNode>::from_node(node, src)
15557 .map(Self::UseInsteadOfClause)
15558 .unwrap_or(Self::Unknown(node))
15559 }
15560 "use_list" => <UseList as ::treesitter_types::FromNode>::from_node(node, src)
15561 .map(Self::UseList)
15562 .unwrap_or(Self::Unknown(node)),
15563 "variable_name" => <VariableName as ::treesitter_types::FromNode>::from_node(node, src)
15564 .map(Self::VariableName)
15565 .unwrap_or(Self::Unknown(node)),
15566 "variadic_parameter" => {
15567 <VariadicParameter as ::treesitter_types::FromNode>::from_node(node, src)
15568 .map(Self::VariadicParameter)
15569 .unwrap_or(Self::Unknown(node))
15570 }
15571 "variadic_placeholder" => {
15572 <VariadicPlaceholder as ::treesitter_types::FromNode>::from_node(node, src)
15573 .map(Self::VariadicPlaceholder)
15574 .unwrap_or(Self::Unknown(node))
15575 }
15576 "variadic_unpacking" => {
15577 <VariadicUnpacking as ::treesitter_types::FromNode>::from_node(node, src)
15578 .map(Self::VariadicUnpacking)
15579 .unwrap_or(Self::Unknown(node))
15580 }
15581 "visibility_modifier" => {
15582 <VisibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
15583 .map(Self::VisibilityModifier)
15584 .unwrap_or(Self::Unknown(node))
15585 }
15586 "while_statement" => {
15587 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
15588 .map(Self::WhileStatement)
15589 .unwrap_or(Self::Unknown(node))
15590 }
15591 "yield_expression" => {
15592 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
15593 .map(Self::YieldExpression)
15594 .unwrap_or(Self::Unknown(node))
15595 }
15596 "bottom_type" => <BottomType as ::treesitter_types::FromNode>::from_node(node, src)
15597 .map(Self::BottomType)
15598 .unwrap_or(Self::Unknown(node)),
15599 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
15600 .map(Self::Comment)
15601 .unwrap_or(Self::Unknown(node)),
15602 "escape_sequence" => {
15603 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
15604 .map(Self::EscapeSequence)
15605 .unwrap_or(Self::Unknown(node))
15606 }
15607 "float" => <Float as ::treesitter_types::FromNode>::from_node(node, src)
15608 .map(Self::Float)
15609 .unwrap_or(Self::Unknown(node)),
15610 "heredoc_end" => <HeredocEnd as ::treesitter_types::FromNode>::from_node(node, src)
15611 .map(Self::HeredocEnd)
15612 .unwrap_or(Self::Unknown(node)),
15613 "heredoc_start" => <HeredocStart as ::treesitter_types::FromNode>::from_node(node, src)
15614 .map(Self::HeredocStart)
15615 .unwrap_or(Self::Unknown(node)),
15616 "integer" => <Integer as ::treesitter_types::FromNode>::from_node(node, src)
15617 .map(Self::Integer)
15618 .unwrap_or(Self::Unknown(node)),
15619 "nowdoc_string" => <NowdocString as ::treesitter_types::FromNode>::from_node(node, src)
15620 .map(Self::NowdocString)
15621 .unwrap_or(Self::Unknown(node)),
15622 "operation" => <Operation as ::treesitter_types::FromNode>::from_node(node, src)
15623 .map(Self::Operation)
15624 .unwrap_or(Self::Unknown(node)),
15625 "php_end_tag" => <PhpEndTag as ::treesitter_types::FromNode>::from_node(node, src)
15626 .map(Self::PhpEndTag)
15627 .unwrap_or(Self::Unknown(node)),
15628 "php_tag" => <PhpTag as ::treesitter_types::FromNode>::from_node(node, src)
15629 .map(Self::PhpTag)
15630 .unwrap_or(Self::Unknown(node)),
15631 "var_modifier" => <VarModifier as ::treesitter_types::FromNode>::from_node(node, src)
15632 .map(Self::VarModifier)
15633 .unwrap_or(Self::Unknown(node)),
15634 _ => Self::Unknown(node),
15635 }
15636 }
15637}
15638impl ::treesitter_types::Spanned for AnyNode<'_> {
15639 fn span(&self) -> ::treesitter_types::Span {
15640 match self {
15641 Self::Expression(inner) => inner.span(),
15642 Self::Literal(inner) => inner.span(),
15643 Self::PrimaryExpression(inner) => inner.span(),
15644 Self::Statement(inner) => inner.span(),
15645 Self::Type(inner) => inner.span(),
15646 Self::AbstractModifier(inner) => inner.span(),
15647 Self::AnonymousClass(inner) => inner.span(),
15648 Self::AnonymousFunction(inner) => inner.span(),
15649 Self::AnonymousFunctionUseClause(inner) => inner.span(),
15650 Self::Argument(inner) => inner.span(),
15651 Self::Arguments(inner) => inner.span(),
15652 Self::ArrayCreationExpression(inner) => inner.span(),
15653 Self::ArrayElementInitializer(inner) => inner.span(),
15654 Self::ArrowFunction(inner) => inner.span(),
15655 Self::AssignmentExpression(inner) => inner.span(),
15656 Self::Attribute(inner) => inner.span(),
15657 Self::AttributeGroup(inner) => inner.span(),
15658 Self::AttributeList(inner) => inner.span(),
15659 Self::AugmentedAssignmentExpression(inner) => inner.span(),
15660 Self::BaseClause(inner) => inner.span(),
15661 Self::BinaryExpression(inner) => inner.span(),
15662 Self::Boolean(inner) => inner.span(),
15663 Self::BreakStatement(inner) => inner.span(),
15664 Self::ByRef(inner) => inner.span(),
15665 Self::CaseStatement(inner) => inner.span(),
15666 Self::CastExpression(inner) => inner.span(),
15667 Self::CastType(inner) => inner.span(),
15668 Self::CatchClause(inner) => inner.span(),
15669 Self::ClassConstantAccessExpression(inner) => inner.span(),
15670 Self::ClassDeclaration(inner) => inner.span(),
15671 Self::ClassInterfaceClause(inner) => inner.span(),
15672 Self::CloneExpression(inner) => inner.span(),
15673 Self::ColonBlock(inner) => inner.span(),
15674 Self::CompoundStatement(inner) => inner.span(),
15675 Self::ConditionalExpression(inner) => inner.span(),
15676 Self::ConstDeclaration(inner) => inner.span(),
15677 Self::ConstElement(inner) => inner.span(),
15678 Self::ContinueStatement(inner) => inner.span(),
15679 Self::DeclarationList(inner) => inner.span(),
15680 Self::DeclareDirective(inner) => inner.span(),
15681 Self::DeclareStatement(inner) => inner.span(),
15682 Self::DefaultStatement(inner) => inner.span(),
15683 Self::DisjunctiveNormalFormType(inner) => inner.span(),
15684 Self::DoStatement(inner) => inner.span(),
15685 Self::DynamicVariableName(inner) => inner.span(),
15686 Self::EchoStatement(inner) => inner.span(),
15687 Self::ElseClause(inner) => inner.span(),
15688 Self::ElseIfClause(inner) => inner.span(),
15689 Self::EmptyStatement(inner) => inner.span(),
15690 Self::EncapsedString(inner) => inner.span(),
15691 Self::EnumCase(inner) => inner.span(),
15692 Self::EnumDeclaration(inner) => inner.span(),
15693 Self::EnumDeclarationList(inner) => inner.span(),
15694 Self::ErrorSuppressionExpression(inner) => inner.span(),
15695 Self::ExitStatement(inner) => inner.span(),
15696 Self::ExpressionStatement(inner) => inner.span(),
15697 Self::FinalModifier(inner) => inner.span(),
15698 Self::FinallyClause(inner) => inner.span(),
15699 Self::ForStatement(inner) => inner.span(),
15700 Self::ForeachStatement(inner) => inner.span(),
15701 Self::FormalParameters(inner) => inner.span(),
15702 Self::FunctionCallExpression(inner) => inner.span(),
15703 Self::FunctionDefinition(inner) => inner.span(),
15704 Self::FunctionStaticDeclaration(inner) => inner.span(),
15705 Self::GlobalDeclaration(inner) => inner.span(),
15706 Self::GotoStatement(inner) => inner.span(),
15707 Self::Heredoc(inner) => inner.span(),
15708 Self::HeredocBody(inner) => inner.span(),
15709 Self::IfStatement(inner) => inner.span(),
15710 Self::IncludeExpression(inner) => inner.span(),
15711 Self::IncludeOnceExpression(inner) => inner.span(),
15712 Self::InterfaceDeclaration(inner) => inner.span(),
15713 Self::IntersectionType(inner) => inner.span(),
15714 Self::ListLiteral(inner) => inner.span(),
15715 Self::MatchBlock(inner) => inner.span(),
15716 Self::MatchConditionList(inner) => inner.span(),
15717 Self::MatchConditionalExpression(inner) => inner.span(),
15718 Self::MatchDefaultExpression(inner) => inner.span(),
15719 Self::MatchExpression(inner) => inner.span(),
15720 Self::MemberAccessExpression(inner) => inner.span(),
15721 Self::MemberCallExpression(inner) => inner.span(),
15722 Self::MethodDeclaration(inner) => inner.span(),
15723 Self::Name(inner) => inner.span(),
15724 Self::NamedLabelStatement(inner) => inner.span(),
15725 Self::NamedType(inner) => inner.span(),
15726 Self::NamespaceDefinition(inner) => inner.span(),
15727 Self::NamespaceName(inner) => inner.span(),
15728 Self::NamespaceUseClause(inner) => inner.span(),
15729 Self::NamespaceUseDeclaration(inner) => inner.span(),
15730 Self::NamespaceUseGroup(inner) => inner.span(),
15731 Self::Nowdoc(inner) => inner.span(),
15732 Self::NowdocBody(inner) => inner.span(),
15733 Self::Null(inner) => inner.span(),
15734 Self::NullsafeMemberAccessExpression(inner) => inner.span(),
15735 Self::NullsafeMemberCallExpression(inner) => inner.span(),
15736 Self::ObjectCreationExpression(inner) => inner.span(),
15737 Self::OptionalType(inner) => inner.span(),
15738 Self::Pair(inner) => inner.span(),
15739 Self::ParenthesizedExpression(inner) => inner.span(),
15740 Self::PrimitiveType(inner) => inner.span(),
15741 Self::PrintIntrinsic(inner) => inner.span(),
15742 Self::Program(inner) => inner.span(),
15743 Self::PropertyDeclaration(inner) => inner.span(),
15744 Self::PropertyElement(inner) => inner.span(),
15745 Self::PropertyHook(inner) => inner.span(),
15746 Self::PropertyHookList(inner) => inner.span(),
15747 Self::PropertyPromotionParameter(inner) => inner.span(),
15748 Self::QualifiedName(inner) => inner.span(),
15749 Self::ReadonlyModifier(inner) => inner.span(),
15750 Self::ReferenceAssignmentExpression(inner) => inner.span(),
15751 Self::ReferenceModifier(inner) => inner.span(),
15752 Self::RelativeName(inner) => inner.span(),
15753 Self::RelativeScope(inner) => inner.span(),
15754 Self::RequireExpression(inner) => inner.span(),
15755 Self::RequireOnceExpression(inner) => inner.span(),
15756 Self::ReturnStatement(inner) => inner.span(),
15757 Self::ScopedCallExpression(inner) => inner.span(),
15758 Self::ScopedPropertyAccessExpression(inner) => inner.span(),
15759 Self::SequenceExpression(inner) => inner.span(),
15760 Self::ShellCommandExpression(inner) => inner.span(),
15761 Self::SimpleParameter(inner) => inner.span(),
15762 Self::StaticModifier(inner) => inner.span(),
15763 Self::StaticVariableDeclaration(inner) => inner.span(),
15764 Self::String(inner) => inner.span(),
15765 Self::StringContent(inner) => inner.span(),
15766 Self::SubscriptExpression(inner) => inner.span(),
15767 Self::SwitchBlock(inner) => inner.span(),
15768 Self::SwitchStatement(inner) => inner.span(),
15769 Self::Text(inner) => inner.span(),
15770 Self::TextInterpolation(inner) => inner.span(),
15771 Self::ThrowExpression(inner) => inner.span(),
15772 Self::TraitDeclaration(inner) => inner.span(),
15773 Self::TryStatement(inner) => inner.span(),
15774 Self::TypeList(inner) => inner.span(),
15775 Self::UnaryOpExpression(inner) => inner.span(),
15776 Self::UnionType(inner) => inner.span(),
15777 Self::UnsetStatement(inner) => inner.span(),
15778 Self::UpdateExpression(inner) => inner.span(),
15779 Self::UseAsClause(inner) => inner.span(),
15780 Self::UseDeclaration(inner) => inner.span(),
15781 Self::UseInsteadOfClause(inner) => inner.span(),
15782 Self::UseList(inner) => inner.span(),
15783 Self::VariableName(inner) => inner.span(),
15784 Self::VariadicParameter(inner) => inner.span(),
15785 Self::VariadicPlaceholder(inner) => inner.span(),
15786 Self::VariadicUnpacking(inner) => inner.span(),
15787 Self::VisibilityModifier(inner) => inner.span(),
15788 Self::WhileStatement(inner) => inner.span(),
15789 Self::YieldExpression(inner) => inner.span(),
15790 Self::BottomType(inner) => inner.span(),
15791 Self::Comment(inner) => inner.span(),
15792 Self::EscapeSequence(inner) => inner.span(),
15793 Self::Float(inner) => inner.span(),
15794 Self::HeredocEnd(inner) => inner.span(),
15795 Self::HeredocStart(inner) => inner.span(),
15796 Self::Integer(inner) => inner.span(),
15797 Self::NowdocString(inner) => inner.span(),
15798 Self::Operation(inner) => inner.span(),
15799 Self::PhpEndTag(inner) => inner.span(),
15800 Self::PhpTag(inner) => inner.span(),
15801 Self::VarModifier(inner) => inner.span(),
15802 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
15803 }
15804 }
15805}