1use std::fmt::Debug;
2
3use serde::Deserialize;
4use serde::Serialize;
5use strum::Display;
6
7use mago_span::HasSpan;
8use mago_span::Span;
9
10use crate::ast::Program;
11use crate::ast::ast::*;
12
13#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, Deserialize, PartialOrd, Ord, Display)]
14#[serde(tag = "type", content = "value")]
15pub enum NodeKind {
16 Program,
17 ConstantAccess,
18 Access,
19 ClassConstantAccess,
20 NullSafePropertyAccess,
21 PropertyAccess,
22 StaticPropertyAccess,
23 Argument,
24 ArgumentList,
25 NamedArgument,
26 PositionalArgument,
27 Array,
28 ArrayAccess,
29 ArrayAppend,
30 ArrayElement,
31 KeyValueArrayElement,
32 LegacyArray,
33 List,
34 MissingArrayElement,
35 ValueArrayElement,
36 VariadicArrayElement,
37 Attribute,
38 AttributeList,
39 Block,
40 Call,
41 FunctionCall,
42 MethodCall,
43 NullSafeMethodCall,
44 StaticMethodCall,
45 ClassLikeConstant,
46 ClassLikeConstantItem,
47 EnumCase,
48 EnumCaseBackedItem,
49 EnumCaseItem,
50 EnumCaseUnitItem,
51 Extends,
52 Implements,
53 ClassLikeConstantSelector,
54 ClassLikeMember,
55 ClassLikeMemberExpressionSelector,
56 ClassLikeMemberSelector,
57 Method,
58 MethodAbstractBody,
59 MethodBody,
60 HookedProperty,
61 PlainProperty,
62 Property,
63 PropertyAbstractItem,
64 PropertyConcreteItem,
65 PropertyHook,
66 PropertyHookAbstractBody,
67 PropertyHookBody,
68 PropertyHookConcreteBody,
69 PropertyHookConcreteExpressionBody,
70 PropertyHookList,
71 PropertyItem,
72 TraitUse,
73 TraitUseAbsoluteMethodReference,
74 TraitUseAbstractSpecification,
75 TraitUseAdaptation,
76 TraitUseAliasAdaptation,
77 TraitUseConcreteSpecification,
78 TraitUseMethodReference,
79 TraitUsePrecedenceAdaptation,
80 TraitUseSpecification,
81 AnonymousClass,
82 Class,
83 Enum,
84 EnumBackingTypeHint,
85 Interface,
86 Trait,
87 Clone,
88 ClosureCreation,
89 FunctionClosureCreation,
90 MethodClosureCreation,
91 StaticMethodClosureCreation,
92 Constant,
93 ConstantItem,
94 Construct,
95 DieConstruct,
96 EmptyConstruct,
97 EvalConstruct,
98 ExitConstruct,
99 IncludeConstruct,
100 IncludeOnceConstruct,
101 IssetConstruct,
102 PrintConstruct,
103 RequireConstruct,
104 RequireOnceConstruct,
105 If,
106 IfBody,
107 IfColonDelimitedBody,
108 IfColonDelimitedBodyElseClause,
109 IfColonDelimitedBodyElseIfClause,
110 IfStatementBody,
111 IfStatementBodyElseClause,
112 IfStatementBodyElseIfClause,
113 Match,
114 MatchArm,
115 MatchDefaultArm,
116 MatchExpressionArm,
117 Switch,
118 SwitchBody,
119 SwitchBraceDelimitedBody,
120 SwitchCase,
121 SwitchCaseSeparator,
122 SwitchColonDelimitedBody,
123 SwitchDefaultCase,
124 SwitchExpressionCase,
125 Declare,
126 DeclareBody,
127 DeclareColonDelimitedBody,
128 DeclareItem,
129 Echo,
130 Expression,
131 Binary,
132 BinaryOperator,
133 UnaryPrefix,
134 UnaryPrefixOperator,
135 UnaryPostfix,
136 UnaryPostfixOperator,
137 Parenthesized,
138 ArrowFunction,
139 Closure,
140 ClosureUseClause,
141 ClosureUseClauseVariable,
142 Function,
143 FunctionLikeParameter,
144 FunctionLikeParameterDefaultValue,
145 FunctionLikeParameterList,
146 FunctionLikeReturnTypeHint,
147 Global,
148 Goto,
149 Label,
150 HaltCompiler,
151 FullyQualifiedIdentifier,
152 Identifier,
153 LocalIdentifier,
154 QualifiedIdentifier,
155 Inline,
156 Instantiation,
157 Keyword,
158 Literal,
159 Pipe,
160 LiteralFloat,
161 LiteralInteger,
162 LiteralString,
163 MagicConstant,
164 Modifier,
165 Namespace,
166 NamespaceBody,
167 NamespaceImplicitBody,
168 Assignment,
169 AssignmentOperator,
170 Conditional,
171 DoWhile,
172 Foreach,
173 ForeachBody,
174 ForeachColonDelimitedBody,
175 ForeachKeyValueTarget,
176 ForeachTarget,
177 ForeachValueTarget,
178 For,
179 ForBody,
180 ForColonDelimitedBody,
181 While,
182 WhileBody,
183 WhileColonDelimitedBody,
184 Break,
185 Continue,
186 Return,
187 Static,
188 StaticAbstractItem,
189 StaticConcreteItem,
190 StaticItem,
191 Try,
192 TryCatchClause,
193 TryFinallyClause,
194 MaybeTypedUseItem,
195 MixedUseItemList,
196 TypedUseItemList,
197 TypedUseItemSequence,
198 Use,
199 UseItem,
200 UseItemAlias,
201 UseItemSequence,
202 UseItems,
203 UseType,
204 Yield,
205 YieldFrom,
206 YieldPair,
207 YieldValue,
208 Statement,
209 ExpressionStatement,
210 BracedExpressionStringPart,
211 DocumentString,
212 InterpolatedString,
213 LiteralStringPart,
214 ShellExecuteString,
215 CompositeString,
216 StringPart,
217 ClosingTag,
218 EchoOpeningTag,
219 FullOpeningTag,
220 OpeningTag,
221 ShortOpeningTag,
222 Terminator,
223 Throw,
224 Hint,
225 IntersectionHint,
226 NullableHint,
227 ParenthesizedHint,
228 UnionHint,
229 Unset,
230 DirectVariable,
231 IndirectVariable,
232 NestedVariable,
233 Variable,
234}
235
236#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord, Display)]
237#[serde(tag = "type", content = "value")]
238#[repr(C, u8)]
239pub enum Node<'a> {
240 Program(&'a Program),
241 Access(&'a Access),
242 ConstantAccess(&'a ConstantAccess),
243 ClassConstantAccess(&'a ClassConstantAccess),
244 NullSafePropertyAccess(&'a NullSafePropertyAccess),
245 PropertyAccess(&'a PropertyAccess),
246 StaticPropertyAccess(&'a StaticPropertyAccess),
247 Argument(&'a Argument),
248 ArgumentList(&'a ArgumentList),
249 NamedArgument(&'a NamedArgument),
250 PositionalArgument(&'a PositionalArgument),
251 Array(&'a Array),
252 ArrayAccess(&'a ArrayAccess),
253 ArrayAppend(&'a ArrayAppend),
254 ArrayElement(&'a ArrayElement),
255 KeyValueArrayElement(&'a KeyValueArrayElement),
256 LegacyArray(&'a LegacyArray),
257 List(&'a List),
258 MissingArrayElement(&'a MissingArrayElement),
259 ValueArrayElement(&'a ValueArrayElement),
260 VariadicArrayElement(&'a VariadicArrayElement),
261 Attribute(&'a Attribute),
262 AttributeList(&'a AttributeList),
263 Block(&'a Block),
264 Call(&'a Call),
265 FunctionCall(&'a FunctionCall),
266 MethodCall(&'a MethodCall),
267 NullSafeMethodCall(&'a NullSafeMethodCall),
268 StaticMethodCall(&'a StaticMethodCall),
269 ClassLikeConstant(&'a ClassLikeConstant),
270 ClassLikeConstantItem(&'a ClassLikeConstantItem),
271 EnumCase(&'a EnumCase),
272 EnumCaseBackedItem(&'a EnumCaseBackedItem),
273 EnumCaseItem(&'a EnumCaseItem),
274 EnumCaseUnitItem(&'a EnumCaseUnitItem),
275 Extends(&'a Extends),
276 Implements(&'a Implements),
277 ClassLikeConstantSelector(&'a ClassLikeConstantSelector),
278 ClassLikeMember(&'a ClassLikeMember),
279 ClassLikeMemberExpressionSelector(&'a ClassLikeMemberExpressionSelector),
280 ClassLikeMemberSelector(&'a ClassLikeMemberSelector),
281 Method(&'a Method),
282 MethodAbstractBody(&'a MethodAbstractBody),
283 MethodBody(&'a MethodBody),
284 HookedProperty(&'a HookedProperty),
285 PlainProperty(&'a PlainProperty),
286 Property(&'a Property),
287 PropertyAbstractItem(&'a PropertyAbstractItem),
288 PropertyConcreteItem(&'a PropertyConcreteItem),
289 PropertyHook(&'a PropertyHook),
290 PropertyHookAbstractBody(&'a PropertyHookAbstractBody),
291 PropertyHookBody(&'a PropertyHookBody),
292 PropertyHookConcreteBody(&'a PropertyHookConcreteBody),
293 PropertyHookConcreteExpressionBody(&'a PropertyHookConcreteExpressionBody),
294 PropertyHookList(&'a PropertyHookList),
295 PropertyItem(&'a PropertyItem),
296 TraitUse(&'a TraitUse),
297 TraitUseAbsoluteMethodReference(&'a TraitUseAbsoluteMethodReference),
298 TraitUseAbstractSpecification(&'a TraitUseAbstractSpecification),
299 TraitUseAdaptation(&'a TraitUseAdaptation),
300 TraitUseAliasAdaptation(&'a TraitUseAliasAdaptation),
301 TraitUseConcreteSpecification(&'a TraitUseConcreteSpecification),
302 TraitUseMethodReference(&'a TraitUseMethodReference),
303 TraitUsePrecedenceAdaptation(&'a TraitUsePrecedenceAdaptation),
304 TraitUseSpecification(&'a TraitUseSpecification),
305 AnonymousClass(&'a AnonymousClass),
306 Class(&'a Class),
307 Enum(&'a Enum),
308 EnumBackingTypeHint(&'a EnumBackingTypeHint),
309 Interface(&'a Interface),
310 Trait(&'a Trait),
311 Clone(&'a Clone),
312 ClosureCreation(&'a ClosureCreation),
313 FunctionClosureCreation(&'a FunctionClosureCreation),
314 MethodClosureCreation(&'a MethodClosureCreation),
315 StaticMethodClosureCreation(&'a StaticMethodClosureCreation),
316 Constant(&'a Constant),
317 ConstantItem(&'a ConstantItem),
318 Construct(&'a Construct),
319 DieConstruct(&'a DieConstruct),
320 EmptyConstruct(&'a EmptyConstruct),
321 EvalConstruct(&'a EvalConstruct),
322 ExitConstruct(&'a ExitConstruct),
323 IncludeConstruct(&'a IncludeConstruct),
324 IncludeOnceConstruct(&'a IncludeOnceConstruct),
325 IssetConstruct(&'a IssetConstruct),
326 PrintConstruct(&'a PrintConstruct),
327 RequireConstruct(&'a RequireConstruct),
328 RequireOnceConstruct(&'a RequireOnceConstruct),
329 If(&'a If),
330 IfBody(&'a IfBody),
331 IfColonDelimitedBody(&'a IfColonDelimitedBody),
332 IfColonDelimitedBodyElseClause(&'a IfColonDelimitedBodyElseClause),
333 IfColonDelimitedBodyElseIfClause(&'a IfColonDelimitedBodyElseIfClause),
334 IfStatementBody(&'a IfStatementBody),
335 IfStatementBodyElseClause(&'a IfStatementBodyElseClause),
336 IfStatementBodyElseIfClause(&'a IfStatementBodyElseIfClause),
337 Match(&'a Match),
338 MatchArm(&'a MatchArm),
339 MatchDefaultArm(&'a MatchDefaultArm),
340 MatchExpressionArm(&'a MatchExpressionArm),
341 Switch(&'a Switch),
342 SwitchBody(&'a SwitchBody),
343 SwitchBraceDelimitedBody(&'a SwitchBraceDelimitedBody),
344 SwitchCase(&'a SwitchCase),
345 SwitchCaseSeparator(&'a SwitchCaseSeparator),
346 SwitchColonDelimitedBody(&'a SwitchColonDelimitedBody),
347 SwitchDefaultCase(&'a SwitchDefaultCase),
348 SwitchExpressionCase(&'a SwitchExpressionCase),
349 Declare(&'a Declare),
350 DeclareBody(&'a DeclareBody),
351 DeclareColonDelimitedBody(&'a DeclareColonDelimitedBody),
352 DeclareItem(&'a DeclareItem),
353 Echo(&'a Echo),
354 Expression(&'a Expression),
355 Binary(&'a Binary),
356 BinaryOperator(&'a BinaryOperator),
357 UnaryPrefix(&'a UnaryPrefix),
358 UnaryPrefixOperator(&'a UnaryPrefixOperator),
359 UnaryPostfix(&'a UnaryPostfix),
360 UnaryPostfixOperator(&'a UnaryPostfixOperator),
361 Parenthesized(&'a Parenthesized),
362 ArrowFunction(&'a ArrowFunction),
363 Closure(&'a Closure),
364 ClosureUseClause(&'a ClosureUseClause),
365 ClosureUseClauseVariable(&'a ClosureUseClauseVariable),
366 Function(&'a Function),
367 FunctionLikeParameter(&'a FunctionLikeParameter),
368 FunctionLikeParameterDefaultValue(&'a FunctionLikeParameterDefaultValue),
369 FunctionLikeParameterList(&'a FunctionLikeParameterList),
370 FunctionLikeReturnTypeHint(&'a FunctionLikeReturnTypeHint),
371 Global(&'a Global),
372 Goto(&'a Goto),
373 Label(&'a Label),
374 HaltCompiler(&'a HaltCompiler),
375 FullyQualifiedIdentifier(&'a FullyQualifiedIdentifier),
376 Identifier(&'a Identifier),
377 LocalIdentifier(&'a LocalIdentifier),
378 QualifiedIdentifier(&'a QualifiedIdentifier),
379 Inline(&'a Inline),
380 Instantiation(&'a Instantiation),
381 Keyword(&'a Keyword),
382 Literal(&'a Literal),
383 LiteralFloat(&'a LiteralFloat),
384 LiteralInteger(&'a LiteralInteger),
385 LiteralString(&'a LiteralString),
386 MagicConstant(&'a MagicConstant),
387 Modifier(&'a Modifier),
388 Namespace(&'a Namespace),
389 NamespaceBody(&'a NamespaceBody),
390 NamespaceImplicitBody(&'a NamespaceImplicitBody),
391 Assignment(&'a Assignment),
392 AssignmentOperator(&'a AssignmentOperator),
393 Conditional(&'a Conditional),
394 DoWhile(&'a DoWhile),
395 Foreach(&'a Foreach),
396 ForeachBody(&'a ForeachBody),
397 ForeachColonDelimitedBody(&'a ForeachColonDelimitedBody),
398 ForeachKeyValueTarget(&'a ForeachKeyValueTarget),
399 ForeachTarget(&'a ForeachTarget),
400 ForeachValueTarget(&'a ForeachValueTarget),
401 For(&'a For),
402 ForBody(&'a ForBody),
403 ForColonDelimitedBody(&'a ForColonDelimitedBody),
404 While(&'a While),
405 WhileBody(&'a WhileBody),
406 WhileColonDelimitedBody(&'a WhileColonDelimitedBody),
407 Break(&'a Break),
408 Continue(&'a Continue),
409 Return(&'a Return),
410 Static(&'a Static),
411 StaticAbstractItem(&'a StaticAbstractItem),
412 StaticConcreteItem(&'a StaticConcreteItem),
413 StaticItem(&'a StaticItem),
414 Try(&'a Try),
415 TryCatchClause(&'a TryCatchClause),
416 TryFinallyClause(&'a TryFinallyClause),
417 MaybeTypedUseItem(&'a MaybeTypedUseItem),
418 MixedUseItemList(&'a MixedUseItemList),
419 TypedUseItemList(&'a TypedUseItemList),
420 TypedUseItemSequence(&'a TypedUseItemSequence),
421 Use(&'a Use),
422 UseItem(&'a UseItem),
423 UseItemAlias(&'a UseItemAlias),
424 UseItemSequence(&'a UseItemSequence),
425 UseItems(&'a UseItems),
426 UseType(&'a UseType),
427 Yield(&'a Yield),
428 YieldFrom(&'a YieldFrom),
429 YieldPair(&'a YieldPair),
430 YieldValue(&'a YieldValue),
431 Statement(&'a Statement),
432 ExpressionStatement(&'a ExpressionStatement),
433 BracedExpressionStringPart(&'a BracedExpressionStringPart),
434 DocumentString(&'a DocumentString),
435 InterpolatedString(&'a InterpolatedString),
436 LiteralStringPart(&'a LiteralStringPart),
437 ShellExecuteString(&'a ShellExecuteString),
438 CompositeString(&'a CompositeString),
439 StringPart(&'a StringPart),
440 ClosingTag(&'a ClosingTag),
441 EchoOpeningTag(&'a EchoOpeningTag),
442 FullOpeningTag(&'a FullOpeningTag),
443 OpeningTag(&'a OpeningTag),
444 ShortOpeningTag(&'a ShortOpeningTag),
445 Terminator(&'a Terminator),
446 Throw(&'a Throw),
447 Hint(&'a Hint),
448 IntersectionHint(&'a IntersectionHint),
449 NullableHint(&'a NullableHint),
450 ParenthesizedHint(&'a ParenthesizedHint),
451 UnionHint(&'a UnionHint),
452 Unset(&'a Unset),
453 DirectVariable(&'a DirectVariable),
454 IndirectVariable(&'a IndirectVariable),
455 NestedVariable(&'a NestedVariable),
456 Variable(&'a Variable),
457 Pipe(&'a Pipe),
458}
459
460impl<'a> Node<'a> {
461 #[inline]
462 pub fn filter_map<F, T>(&self, f: F) -> Vec<T>
463 where
464 F: Fn(&Node<'a>) -> Option<T>,
465 {
466 self.filter_map_internal(&f)
467 }
468
469 #[inline]
470 fn filter_map_internal<F, T>(&self, f: &F) -> Vec<T>
471 where
472 F: Fn(&Node<'a>) -> Option<T>,
473 {
474 let mut result = vec![];
475 for child in self.children() {
476 result.extend(child.filter_map_internal(f));
477 }
478
479 if let Some(child) = f(self) {
480 result.push(child);
481 }
482
483 result
484 }
485
486 #[inline]
487 pub const fn is_declaration(&self) -> bool {
488 matches!(
489 self,
490 Self::Class(_) | Self::Interface(_) | Self::Trait(_) | Self::Enum(_) | Self::Function(_) | Self::Method(_)
491 )
492 }
493
494 #[inline]
495 pub const fn is_statement(&self) -> bool {
496 matches!(
497 self,
498 Self::Statement(_)
499 | Self::OpeningTag(_)
500 | Self::EchoOpeningTag(_)
501 | Self::FullOpeningTag(_)
502 | Self::ShortOpeningTag(_)
503 | Self::ClosingTag(_)
504 | Self::Inline(_)
505 | Self::Namespace(_)
506 | Self::Use(_)
507 | Self::Class(_)
508 | Self::Interface(_)
509 | Self::Trait(_)
510 | Self::Enum(_)
511 | Self::Block(_)
512 | Self::Constant(_)
513 | Self::Function(_)
514 | Self::Declare(_)
515 | Self::Goto(_)
516 | Self::Label(_)
517 | Self::Try(_)
518 | Self::Foreach(_)
519 | Self::For(_)
520 | Self::While(_)
521 | Self::DoWhile(_)
522 | Self::Continue(_)
523 | Self::Break(_)
524 | Self::Switch(_)
525 | Self::If(_)
526 | Self::Return(_)
527 | Self::ExpressionStatement(_)
528 | Self::Echo(_)
529 | Self::Global(_)
530 | Self::Static(_)
531 | Self::HaltCompiler(_)
532 | Self::Unset(_)
533 )
534 }
535
536 #[inline]
537 pub const fn kind(&self) -> NodeKind {
538 match &self {
539 Self::Program(_) => NodeKind::Program,
540 Self::Access(_) => NodeKind::Access,
541 Self::ConstantAccess(_) => NodeKind::ConstantAccess,
542 Self::ClassConstantAccess(_) => NodeKind::ClassConstantAccess,
543 Self::NullSafePropertyAccess(_) => NodeKind::NullSafePropertyAccess,
544 Self::PropertyAccess(_) => NodeKind::PropertyAccess,
545 Self::StaticPropertyAccess(_) => NodeKind::StaticPropertyAccess,
546 Self::Argument(_) => NodeKind::Argument,
547 Self::ArgumentList(_) => NodeKind::ArgumentList,
548 Self::NamedArgument(_) => NodeKind::NamedArgument,
549 Self::PositionalArgument(_) => NodeKind::PositionalArgument,
550 Self::Array(_) => NodeKind::Array,
551 Self::ArrayAccess(_) => NodeKind::ArrayAccess,
552 Self::ArrayAppend(_) => NodeKind::ArrayAppend,
553 Self::ArrayElement(_) => NodeKind::ArrayElement,
554 Self::KeyValueArrayElement(_) => NodeKind::KeyValueArrayElement,
555 Self::LegacyArray(_) => NodeKind::LegacyArray,
556 Self::List(_) => NodeKind::List,
557 Self::MissingArrayElement(_) => NodeKind::MissingArrayElement,
558 Self::ValueArrayElement(_) => NodeKind::ValueArrayElement,
559 Self::VariadicArrayElement(_) => NodeKind::VariadicArrayElement,
560 Self::Attribute(_) => NodeKind::Attribute,
561 Self::AttributeList(_) => NodeKind::AttributeList,
562 Self::Block(_) => NodeKind::Block,
563 Self::Call(_) => NodeKind::Call,
564 Self::FunctionCall(_) => NodeKind::FunctionCall,
565 Self::MethodCall(_) => NodeKind::MethodCall,
566 Self::NullSafeMethodCall(_) => NodeKind::NullSafeMethodCall,
567 Self::StaticMethodCall(_) => NodeKind::StaticMethodCall,
568 Self::ClassLikeConstant(_) => NodeKind::ClassLikeConstant,
569 Self::ClassLikeConstantItem(_) => NodeKind::ClassLikeConstantItem,
570 Self::EnumCase(_) => NodeKind::EnumCase,
571 Self::EnumCaseBackedItem(_) => NodeKind::EnumCaseBackedItem,
572 Self::EnumCaseItem(_) => NodeKind::EnumCaseItem,
573 Self::EnumCaseUnitItem(_) => NodeKind::EnumCaseUnitItem,
574 Self::Extends(_) => NodeKind::Extends,
575 Self::Implements(_) => NodeKind::Implements,
576 Self::ClassLikeConstantSelector(_) => NodeKind::ClassLikeConstantSelector,
577 Self::ClassLikeMember(_) => NodeKind::ClassLikeMember,
578 Self::ClassLikeMemberExpressionSelector(_) => NodeKind::ClassLikeMemberExpressionSelector,
579 Self::ClassLikeMemberSelector(_) => NodeKind::ClassLikeMemberSelector,
580 Self::Method(_) => NodeKind::Method,
581 Self::MethodAbstractBody(_) => NodeKind::MethodAbstractBody,
582 Self::MethodBody(_) => NodeKind::MethodBody,
583 Self::HookedProperty(_) => NodeKind::HookedProperty,
584 Self::PlainProperty(_) => NodeKind::PlainProperty,
585 Self::Property(_) => NodeKind::Property,
586 Self::PropertyAbstractItem(_) => NodeKind::PropertyAbstractItem,
587 Self::PropertyConcreteItem(_) => NodeKind::PropertyConcreteItem,
588 Self::PropertyHook(_) => NodeKind::PropertyHook,
589 Self::PropertyHookAbstractBody(_) => NodeKind::PropertyHookAbstractBody,
590 Self::PropertyHookBody(_) => NodeKind::PropertyHookBody,
591 Self::PropertyHookConcreteBody(_) => NodeKind::PropertyHookConcreteBody,
592 Self::PropertyHookConcreteExpressionBody(_) => NodeKind::PropertyHookConcreteExpressionBody,
593 Self::PropertyHookList(_) => NodeKind::PropertyHookList,
594 Self::PropertyItem(_) => NodeKind::PropertyItem,
595 Self::TraitUse(_) => NodeKind::TraitUse,
596 Self::TraitUseAbsoluteMethodReference(_) => NodeKind::TraitUseAbsoluteMethodReference,
597 Self::TraitUseAbstractSpecification(_) => NodeKind::TraitUseAbstractSpecification,
598 Self::TraitUseAdaptation(_) => NodeKind::TraitUseAdaptation,
599 Self::TraitUseAliasAdaptation(_) => NodeKind::TraitUseAliasAdaptation,
600 Self::TraitUseConcreteSpecification(_) => NodeKind::TraitUseConcreteSpecification,
601 Self::TraitUseMethodReference(_) => NodeKind::TraitUseMethodReference,
602 Self::TraitUsePrecedenceAdaptation(_) => NodeKind::TraitUsePrecedenceAdaptation,
603 Self::TraitUseSpecification(_) => NodeKind::TraitUseSpecification,
604 Self::AnonymousClass(_) => NodeKind::AnonymousClass,
605 Self::Class(_) => NodeKind::Class,
606 Self::Enum(_) => NodeKind::Enum,
607 Self::EnumBackingTypeHint(_) => NodeKind::EnumBackingTypeHint,
608 Self::Interface(_) => NodeKind::Interface,
609 Self::Trait(_) => NodeKind::Trait,
610 Self::Clone(_) => NodeKind::Clone,
611 Self::ClosureCreation(_) => NodeKind::ClosureCreation,
612 Self::FunctionClosureCreation(_) => NodeKind::FunctionClosureCreation,
613 Self::MethodClosureCreation(_) => NodeKind::MethodClosureCreation,
614 Self::StaticMethodClosureCreation(_) => NodeKind::StaticMethodClosureCreation,
615 Self::Constant(_) => NodeKind::Constant,
616 Self::ConstantItem(_) => NodeKind::ConstantItem,
617 Self::Construct(_) => NodeKind::Construct,
618 Self::DieConstruct(_) => NodeKind::DieConstruct,
619 Self::EmptyConstruct(_) => NodeKind::EmptyConstruct,
620 Self::EvalConstruct(_) => NodeKind::EvalConstruct,
621 Self::ExitConstruct(_) => NodeKind::ExitConstruct,
622 Self::IncludeConstruct(_) => NodeKind::IncludeConstruct,
623 Self::IncludeOnceConstruct(_) => NodeKind::IncludeOnceConstruct,
624 Self::IssetConstruct(_) => NodeKind::IssetConstruct,
625 Self::PrintConstruct(_) => NodeKind::PrintConstruct,
626 Self::RequireConstruct(_) => NodeKind::RequireConstruct,
627 Self::RequireOnceConstruct(_) => NodeKind::RequireOnceConstruct,
628 Self::If(_) => NodeKind::If,
629 Self::IfBody(_) => NodeKind::IfBody,
630 Self::IfColonDelimitedBody(_) => NodeKind::IfColonDelimitedBody,
631 Self::IfColonDelimitedBodyElseClause(_) => NodeKind::IfColonDelimitedBodyElseClause,
632 Self::IfColonDelimitedBodyElseIfClause(_) => NodeKind::IfColonDelimitedBodyElseIfClause,
633 Self::IfStatementBody(_) => NodeKind::IfStatementBody,
634 Self::IfStatementBodyElseClause(_) => NodeKind::IfStatementBodyElseClause,
635 Self::IfStatementBodyElseIfClause(_) => NodeKind::IfStatementBodyElseIfClause,
636 Self::Match(_) => NodeKind::Match,
637 Self::MatchArm(_) => NodeKind::MatchArm,
638 Self::MatchDefaultArm(_) => NodeKind::MatchDefaultArm,
639 Self::MatchExpressionArm(_) => NodeKind::MatchExpressionArm,
640 Self::Switch(_) => NodeKind::Switch,
641 Self::SwitchBody(_) => NodeKind::SwitchBody,
642 Self::SwitchBraceDelimitedBody(_) => NodeKind::SwitchBraceDelimitedBody,
643 Self::SwitchCase(_) => NodeKind::SwitchCase,
644 Self::SwitchCaseSeparator(_) => NodeKind::SwitchCaseSeparator,
645 Self::SwitchColonDelimitedBody(_) => NodeKind::SwitchColonDelimitedBody,
646 Self::SwitchDefaultCase(_) => NodeKind::SwitchDefaultCase,
647 Self::SwitchExpressionCase(_) => NodeKind::SwitchExpressionCase,
648 Self::Declare(_) => NodeKind::Declare,
649 Self::DeclareBody(_) => NodeKind::DeclareBody,
650 Self::DeclareColonDelimitedBody(_) => NodeKind::DeclareColonDelimitedBody,
651 Self::DeclareItem(_) => NodeKind::DeclareItem,
652 Self::Echo(_) => NodeKind::Echo,
653 Self::Expression(_) => NodeKind::Expression,
654 Self::Binary(_) => NodeKind::Binary,
655 Self::BinaryOperator(_) => NodeKind::BinaryOperator,
656 Self::UnaryPrefix(_) => NodeKind::UnaryPrefix,
657 Self::UnaryPrefixOperator(_) => NodeKind::UnaryPrefixOperator,
658 Self::UnaryPostfix(_) => NodeKind::UnaryPostfix,
659 Self::UnaryPostfixOperator(_) => NodeKind::UnaryPostfixOperator,
660 Self::Parenthesized(_) => NodeKind::Parenthesized,
661 Self::ArrowFunction(_) => NodeKind::ArrowFunction,
662 Self::Closure(_) => NodeKind::Closure,
663 Self::ClosureUseClause(_) => NodeKind::ClosureUseClause,
664 Self::ClosureUseClauseVariable(_) => NodeKind::ClosureUseClauseVariable,
665 Self::Function(_) => NodeKind::Function,
666 Self::FunctionLikeParameter(_) => NodeKind::FunctionLikeParameter,
667 Self::FunctionLikeParameterDefaultValue(_) => NodeKind::FunctionLikeParameterDefaultValue,
668 Self::FunctionLikeParameterList(_) => NodeKind::FunctionLikeParameterList,
669 Self::FunctionLikeReturnTypeHint(_) => NodeKind::FunctionLikeReturnTypeHint,
670 Self::Global(_) => NodeKind::Global,
671 Self::Goto(_) => NodeKind::Goto,
672 Self::Label(_) => NodeKind::Label,
673 Self::HaltCompiler(_) => NodeKind::HaltCompiler,
674 Self::FullyQualifiedIdentifier(_) => NodeKind::FullyQualifiedIdentifier,
675 Self::Identifier(_) => NodeKind::Identifier,
676 Self::LocalIdentifier(_) => NodeKind::LocalIdentifier,
677 Self::QualifiedIdentifier(_) => NodeKind::QualifiedIdentifier,
678 Self::Inline(_) => NodeKind::Inline,
679 Self::Instantiation(_) => NodeKind::Instantiation,
680 Self::Keyword(_) => NodeKind::Keyword,
681 Self::Literal(_) => NodeKind::Literal,
682 Self::LiteralFloat(_) => NodeKind::LiteralFloat,
683 Self::LiteralInteger(_) => NodeKind::LiteralInteger,
684 Self::LiteralString(_) => NodeKind::LiteralString,
685 Self::MagicConstant(_) => NodeKind::MagicConstant,
686 Self::Modifier(_) => NodeKind::Modifier,
687 Self::Namespace(_) => NodeKind::Namespace,
688 Self::NamespaceBody(_) => NodeKind::NamespaceBody,
689 Self::NamespaceImplicitBody(_) => NodeKind::NamespaceImplicitBody,
690 Self::Assignment(_) => NodeKind::Assignment,
691 Self::AssignmentOperator(_) => NodeKind::AssignmentOperator,
692 Self::Conditional(_) => NodeKind::Conditional,
693 Self::DoWhile(_) => NodeKind::DoWhile,
694 Self::Foreach(_) => NodeKind::Foreach,
695 Self::ForeachBody(_) => NodeKind::ForeachBody,
696 Self::ForeachColonDelimitedBody(_) => NodeKind::ForeachColonDelimitedBody,
697 Self::ForeachKeyValueTarget(_) => NodeKind::ForeachKeyValueTarget,
698 Self::ForeachTarget(_) => NodeKind::ForeachTarget,
699 Self::ForeachValueTarget(_) => NodeKind::ForeachValueTarget,
700 Self::For(_) => NodeKind::For,
701 Self::ForBody(_) => NodeKind::ForBody,
702 Self::ForColonDelimitedBody(_) => NodeKind::ForColonDelimitedBody,
703 Self::While(_) => NodeKind::While,
704 Self::WhileBody(_) => NodeKind::WhileBody,
705 Self::WhileColonDelimitedBody(_) => NodeKind::WhileColonDelimitedBody,
706 Self::Break(_) => NodeKind::Break,
707 Self::Continue(_) => NodeKind::Continue,
708 Self::Return(_) => NodeKind::Return,
709 Self::Static(_) => NodeKind::Static,
710 Self::StaticAbstractItem(_) => NodeKind::StaticAbstractItem,
711 Self::StaticConcreteItem(_) => NodeKind::StaticConcreteItem,
712 Self::StaticItem(_) => NodeKind::StaticItem,
713 Self::Try(_) => NodeKind::Try,
714 Self::TryCatchClause(_) => NodeKind::TryCatchClause,
715 Self::TryFinallyClause(_) => NodeKind::TryFinallyClause,
716 Self::MaybeTypedUseItem(_) => NodeKind::MaybeTypedUseItem,
717 Self::MixedUseItemList(_) => NodeKind::MixedUseItemList,
718 Self::TypedUseItemList(_) => NodeKind::TypedUseItemList,
719 Self::TypedUseItemSequence(_) => NodeKind::TypedUseItemSequence,
720 Self::Use(_) => NodeKind::Use,
721 Self::UseItem(_) => NodeKind::UseItem,
722 Self::UseItemAlias(_) => NodeKind::UseItemAlias,
723 Self::UseItemSequence(_) => NodeKind::UseItemSequence,
724 Self::UseItems(_) => NodeKind::UseItems,
725 Self::UseType(_) => NodeKind::UseType,
726 Self::Yield(_) => NodeKind::Yield,
727 Self::YieldFrom(_) => NodeKind::YieldFrom,
728 Self::YieldPair(_) => NodeKind::YieldPair,
729 Self::YieldValue(_) => NodeKind::YieldValue,
730 Self::Statement(_) => NodeKind::Statement,
731 Self::ExpressionStatement(_) => NodeKind::ExpressionStatement,
732 Self::BracedExpressionStringPart(_) => NodeKind::BracedExpressionStringPart,
733 Self::DocumentString(_) => NodeKind::DocumentString,
734 Self::InterpolatedString(_) => NodeKind::InterpolatedString,
735 Self::LiteralStringPart(_) => NodeKind::LiteralStringPart,
736 Self::ShellExecuteString(_) => NodeKind::ShellExecuteString,
737 Self::CompositeString(_) => NodeKind::CompositeString,
738 Self::StringPart(_) => NodeKind::StringPart,
739 Self::ClosingTag(_) => NodeKind::ClosingTag,
740 Self::EchoOpeningTag(_) => NodeKind::EchoOpeningTag,
741 Self::FullOpeningTag(_) => NodeKind::FullOpeningTag,
742 Self::OpeningTag(_) => NodeKind::OpeningTag,
743 Self::ShortOpeningTag(_) => NodeKind::ShortOpeningTag,
744 Self::Terminator(_) => NodeKind::Terminator,
745 Self::Throw(_) => NodeKind::Throw,
746 Self::Hint(_) => NodeKind::Hint,
747 Self::IntersectionHint(_) => NodeKind::IntersectionHint,
748 Self::NullableHint(_) => NodeKind::NullableHint,
749 Self::ParenthesizedHint(_) => NodeKind::ParenthesizedHint,
750 Self::UnionHint(_) => NodeKind::UnionHint,
751 Self::Unset(_) => NodeKind::Unset,
752 Self::DirectVariable(_) => NodeKind::DirectVariable,
753 Self::IndirectVariable(_) => NodeKind::IndirectVariable,
754 Self::NestedVariable(_) => NodeKind::NestedVariable,
755 Self::Variable(_) => NodeKind::Variable,
756 Self::Pipe(_) => NodeKind::Pipe,
757 }
758 }
759
760 #[inline]
761 pub fn children(&self) -> Vec<Node<'a>> {
762 match &self {
763 Node::Program(node) => node.statements.iter().map(Node::Statement).collect(),
764 Node::Access(node) => match &node {
765 Access::Property(node) => vec![Node::PropertyAccess(node)],
766 Access::NullSafeProperty(node) => vec![Node::NullSafePropertyAccess(node)],
767 Access::StaticProperty(node) => vec![Node::StaticPropertyAccess(node)],
768 Access::ClassConstant(node) => vec![Node::ClassConstantAccess(node)],
769 },
770 Node::ConstantAccess(node) => {
771 vec![Node::Identifier(&node.name)]
772 }
773 Node::ClassConstantAccess(node) => {
774 vec![Node::Expression(&node.class), Node::ClassLikeConstantSelector(&node.constant)]
775 }
776 Node::NullSafePropertyAccess(node) => {
777 vec![Node::Expression(&node.object), Node::ClassLikeMemberSelector(&node.property)]
778 }
779 Node::PropertyAccess(node) => {
780 vec![Node::Expression(&node.object), Node::ClassLikeMemberSelector(&node.property)]
781 }
782 Node::StaticPropertyAccess(node) => {
783 vec![Node::Expression(&node.class), Node::Variable(&node.property)]
784 }
785 Node::Argument(node) => match &node {
786 Argument::Named(node) => vec![Node::NamedArgument(node)],
787 Argument::Positional(node) => vec![Node::PositionalArgument(node)],
788 },
789 Node::ArgumentList(node) => node.arguments.iter().map(Node::Argument).collect(),
790 Node::NamedArgument(node) => {
791 vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
792 }
793 Node::PositionalArgument(node) => vec![Node::Expression(&node.value)],
794 Node::Array(node) => node.elements.iter().map(Node::ArrayElement).collect(),
795 Node::ArrayAccess(node) => {
796 vec![Node::Expression(&node.array), Node::Expression(&node.index)]
797 }
798 Node::ArrayAppend(node) => {
799 vec![Node::Expression(&node.array)]
800 }
801 Node::ArrayElement(node) => match &node {
802 ArrayElement::KeyValue(node) => vec![Node::KeyValueArrayElement(node)],
803 ArrayElement::Missing(node) => vec![Node::MissingArrayElement(node)],
804 ArrayElement::Value(node) => vec![Node::ValueArrayElement(node)],
805 ArrayElement::Variadic(node) => vec![Node::VariadicArrayElement(node)],
806 },
807 Node::KeyValueArrayElement(node) => {
808 vec![Node::Expression(&node.key), Node::Expression(&node.value)]
809 }
810 Node::LegacyArray(node) => node.elements.iter().map(Node::ArrayElement).collect(),
811 Node::List(node) => node.elements.iter().map(Node::ArrayElement).collect(),
812 Node::MissingArrayElement(_) => vec![],
813 Node::ValueArrayElement(node) => vec![Node::Expression(&node.value)],
814 Node::VariadicArrayElement(node) => vec![Node::Expression(&node.value)],
815 Node::Attribute(node) => {
816 let mut children = vec![Node::Identifier(&node.name)];
817 if let Some(arguments) = &node.argument_list {
818 children.push(Node::ArgumentList(arguments));
819 }
820
821 children
822 }
823 Node::AttributeList(node) => node.attributes.iter().map(Node::Attribute).collect(),
824 Node::Block(node) => node.statements.iter().map(Node::Statement).collect(),
825 Node::Call(node) => match node {
826 Call::Function(node) => vec![Node::FunctionCall(node)],
827 Call::Method(node) => vec![Node::MethodCall(node)],
828 Call::NullSafeMethod(node) => vec![Node::NullSafeMethodCall(node)],
829 Call::StaticMethod(node) => vec![Node::StaticMethodCall(node)],
830 },
831 Node::FunctionCall(node) => {
832 vec![Node::Expression(&node.function), Node::ArgumentList(&node.argument_list)]
833 }
834 Node::MethodCall(node) => {
835 vec![
836 Node::Expression(&node.object),
837 Node::ClassLikeMemberSelector(&node.method),
838 Node::ArgumentList(&node.argument_list),
839 ]
840 }
841 Node::NullSafeMethodCall(node) => {
842 vec![
843 Node::Expression(&node.object),
844 Node::ClassLikeMemberSelector(&node.method),
845 Node::ArgumentList(&node.argument_list),
846 ]
847 }
848 Node::StaticMethodCall(node) => {
849 vec![
850 Node::Expression(&node.class),
851 Node::ClassLikeMemberSelector(&node.method),
852 Node::ArgumentList(&node.argument_list),
853 ]
854 }
855 Node::ClassLikeConstant(node) => {
856 let mut children: Vec<_> = node.attribute_lists.iter().map(Node::AttributeList).collect();
857
858 children.extend(node.modifiers.iter().map(Node::Modifier));
859 children.push(Node::Keyword(&node.r#const));
860 if let Some(hint) = &node.hint {
861 children.push(Node::Hint(hint));
862 }
863
864 children.extend(node.items.iter().map(Node::ClassLikeConstantItem));
865 children.push(Node::Terminator(&node.terminator));
866
867 children
868 }
869 Node::ClassLikeConstantItem(node) => {
870 vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
871 }
872 Node::EnumCase(node) => {
873 let mut children: Vec<_> = node.attribute_lists.iter().map(Node::AttributeList).collect();
874
875 children.push(Node::Keyword(&node.case));
876 children.push(Node::EnumCaseItem(&node.item));
877 children.push(Node::Terminator(&node.terminator));
878
879 children
880 }
881 Node::EnumCaseBackedItem(node) => {
882 vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
883 }
884 Node::EnumCaseItem(node) => match &node {
885 EnumCaseItem::Backed(node) => vec![Node::EnumCaseBackedItem(node)],
886 EnumCaseItem::Unit(node) => vec![Node::EnumCaseUnitItem(node)],
887 },
888 Node::EnumCaseUnitItem(node) => vec![Node::LocalIdentifier(&node.name)],
889 Node::Extends(node) => {
890 let mut children = vec![];
891
892 children.push(Node::Keyword(&node.extends));
893 children.extend(node.types.iter().map(Node::Identifier));
894
895 children
896 }
897 Node::Implements(node) => {
898 let mut children = vec![];
899
900 children.push(Node::Keyword(&node.implements));
901 children.extend(node.types.iter().map(Node::Identifier));
902
903 children
904 }
905 Node::ClassLikeConstantSelector(node) => match node {
906 ClassLikeConstantSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
907 ClassLikeConstantSelector::Expression(node) => {
908 vec![Node::ClassLikeMemberExpressionSelector(node)]
909 }
910 },
911 Node::ClassLikeMember(node) => match node {
912 ClassLikeMember::TraitUse(node) => vec![Node::TraitUse(node)],
913 ClassLikeMember::Constant(node) => vec![Node::ClassLikeConstant(node)],
914 ClassLikeMember::Property(node) => vec![Node::Property(node)],
915 ClassLikeMember::EnumCase(node) => vec![Node::EnumCase(node)],
916 ClassLikeMember::Method(node) => vec![Node::Method(node)],
917 },
918 Node::ClassLikeMemberExpressionSelector(node) => vec![Node::Expression(&node.expression)],
919 Node::ClassLikeMemberSelector(node) => match node {
920 ClassLikeMemberSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
921 ClassLikeMemberSelector::Variable(node) => vec![Node::Variable(node)],
922 ClassLikeMemberSelector::Expression(node) => vec![Node::ClassLikeMemberExpressionSelector(node)],
923 },
924 Node::Method(node) => {
925 let mut children: Vec<Node> = vec![];
926
927 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
928 children.extend(node.modifiers.iter().map(Node::Modifier));
929 children.push(Node::Keyword(&node.function));
930 children.push(Node::LocalIdentifier(&node.name));
931 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
932 children.extend(node.return_type_hint.iter().map(Node::FunctionLikeReturnTypeHint));
933 children.push(Node::MethodBody(&node.body));
934
935 children
936 }
937 Node::MethodAbstractBody(_) => vec![],
938 Node::MethodBody(node) => match node {
939 MethodBody::Abstract(node) => vec![Node::MethodAbstractBody(node)],
940 MethodBody::Concrete(node) => vec![Node::Block(node)],
941 },
942 Node::HookedProperty(node) => {
943 let mut children: Vec<Node> = vec![];
944
945 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
946 children.extend(node.var.iter().map(Node::Keyword));
947 children.extend(node.modifiers.iter().map(Node::Modifier));
948 children.extend(node.hint.iter().map(Node::Hint));
949 children.push(Node::PropertyItem(&node.item));
950 children.push(Node::PropertyHookList(&node.hook_list));
951
952 children
953 }
954 Node::PlainProperty(node) => {
955 let mut children: Vec<Node> = vec![];
956
957 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
958 children.extend(node.var.iter().map(Node::Keyword));
959 children.extend(node.modifiers.iter().map(Node::Modifier));
960 children.extend(node.hint.iter().map(Node::Hint));
961 children.extend(node.items.iter().map(Node::PropertyItem));
962
963 children
964 }
965 Node::Property(node) => match node {
966 Property::Plain(node) => vec![Node::PlainProperty(node)],
967 Property::Hooked(node) => vec![Node::HookedProperty(node)],
968 },
969 Node::PropertyAbstractItem(node) => {
970 vec![Node::DirectVariable(&node.variable)]
971 }
972 Node::PropertyConcreteItem(node) => {
973 vec![Node::DirectVariable(&node.variable), Node::Expression(&node.value)]
974 }
975 Node::PropertyHook(node) => {
976 let mut children: Vec<Node> = vec![];
977
978 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
979 children.extend(node.modifiers.iter().map(Node::Modifier));
980 children.push(Node::LocalIdentifier(&node.name));
981 children.extend(node.parameters.iter().map(Node::FunctionLikeParameterList));
982 children.push(Node::PropertyHookBody(&node.body));
983
984 children
985 }
986 Node::PropertyHookAbstractBody(_) => {
987 vec![]
988 }
989 Node::PropertyHookBody(node) => vec![match node {
990 PropertyHookBody::Abstract(node) => Node::PropertyHookAbstractBody(node),
991 PropertyHookBody::Concrete(node) => Node::PropertyHookConcreteBody(node),
992 }],
993 Node::PropertyHookConcreteBody(node) => vec![match node {
994 PropertyHookConcreteBody::Expression(node) => Node::PropertyHookConcreteExpressionBody(node),
995 PropertyHookConcreteBody::Block(node) => Node::Block(node),
996 }],
997 Node::PropertyHookConcreteExpressionBody(node) => vec![Node::Expression(&node.expression)],
998 Node::PropertyHookList(node) => node.hooks.iter().map(Node::PropertyHook).collect(),
999 Node::PropertyItem(node) => match node {
1000 PropertyItem::Abstract(node) => vec![Node::PropertyAbstractItem(node)],
1001 PropertyItem::Concrete(node) => vec![Node::PropertyConcreteItem(node)],
1002 },
1003 Node::TraitUse(node) => {
1004 let mut children: Vec<Node> = vec![];
1005
1006 children.push(Node::Keyword(&node.r#use));
1007 children.extend(node.trait_names.iter().map(Node::Identifier));
1008 children.push(Node::TraitUseSpecification(&node.specification));
1009
1010 children
1011 }
1012 Node::TraitUseAbsoluteMethodReference(node) => {
1013 vec![Node::Identifier(&node.trait_name), Node::LocalIdentifier(&node.method_name)]
1014 }
1015 Node::TraitUseAbstractSpecification(node) => vec![Node::Terminator(&node.0)],
1016 Node::TraitUseAdaptation(node) => match node {
1017 TraitUseAdaptation::Precedence(adaptation) => {
1018 let mut children = vec![
1019 Node::TraitUseAbsoluteMethodReference(&adaptation.method_reference),
1020 Node::Keyword(&adaptation.insteadof),
1021 ];
1022
1023 children.extend(adaptation.trait_names.iter().map(Node::Identifier));
1024 children.push(Node::Terminator(&adaptation.terminator));
1025
1026 children
1027 }
1028 TraitUseAdaptation::Alias(adaptation) => {
1029 let mut children = vec![
1030 Node::TraitUseMethodReference(&adaptation.method_reference),
1031 Node::Keyword(&adaptation.r#as),
1032 ];
1033
1034 if let Some(visibility) = &adaptation.visibility {
1035 children.push(Node::Modifier(visibility));
1036 }
1037
1038 if let Some(alias) = &adaptation.alias {
1039 children.push(Node::LocalIdentifier(alias));
1040 }
1041
1042 children.push(Node::Terminator(&adaptation.terminator));
1043 children
1044 }
1045 },
1046 Node::TraitUseAliasAdaptation(node) => {
1047 let mut children =
1048 vec![Node::TraitUseMethodReference(&node.method_reference), Node::Keyword(&node.r#as)];
1049
1050 if let Some(visibility) = &node.visibility {
1051 children.push(Node::Modifier(visibility));
1052 }
1053
1054 if let Some(alias) = &node.alias {
1055 children.push(Node::LocalIdentifier(alias));
1056 }
1057
1058 children.push(Node::Terminator(&node.terminator));
1059 children
1060 }
1061 Node::TraitUseConcreteSpecification(node) => {
1062 node.adaptations.iter().map(Node::TraitUseAdaptation).collect()
1063 }
1064 Node::TraitUseMethodReference(node) => match node {
1065 TraitUseMethodReference::Identifier(identifier) => {
1066 vec![Node::LocalIdentifier(identifier)]
1067 }
1068 TraitUseMethodReference::Absolute(reference) => {
1069 vec![Node::TraitUseAbsoluteMethodReference(reference)]
1070 }
1071 },
1072 Node::TraitUsePrecedenceAdaptation(node) => {
1073 let mut children =
1074 vec![Node::TraitUseAbsoluteMethodReference(&node.method_reference), Node::Keyword(&node.insteadof)];
1075
1076 children.extend(node.trait_names.iter().map(Node::Identifier));
1077 children.push(Node::Terminator(&node.terminator));
1078
1079 children
1080 }
1081 Node::TraitUseSpecification(node) => match node {
1082 TraitUseSpecification::Abstract(specification) => {
1083 vec![Node::TraitUseAbstractSpecification(specification)]
1084 }
1085 TraitUseSpecification::Concrete(specification) => {
1086 vec![Node::TraitUseConcreteSpecification(specification)]
1087 }
1088 },
1089 Node::AnonymousClass(node) => {
1090 let mut children = vec![Node::Keyword(&node.new)];
1091 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1092 children.extend(node.modifiers.iter().map(Node::Modifier));
1093 children.push(Node::Keyword(&node.class));
1094 if let Some(argument_list) = &node.argument_list {
1095 children.push(Node::ArgumentList(argument_list));
1096 }
1097 children.extend(node.extends.iter().map(Node::Extends));
1098 children.extend(node.implements.iter().map(Node::Implements));
1099 children.extend(node.members.iter().map(Node::ClassLikeMember));
1100
1101 children
1102 }
1103 Node::Class(node) => {
1104 let mut children = vec![];
1105 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1106 children.extend(node.modifiers.iter().map(Node::Modifier));
1107 children.push(Node::Keyword(&node.class));
1108 children.push(Node::LocalIdentifier(&node.name));
1109 children.extend(node.extends.iter().map(Node::Extends));
1110 children.extend(node.implements.iter().map(Node::Implements));
1111 children.extend(node.members.iter().map(Node::ClassLikeMember));
1112
1113 children
1114 }
1115 Node::Enum(node) => {
1116 let mut children = vec![];
1117 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1118 children.push(Node::Keyword(&node.r#enum));
1119 children.push(Node::LocalIdentifier(&node.name));
1120 children.extend(node.backing_type_hint.iter().map(Node::EnumBackingTypeHint));
1121 children.extend(node.implements.iter().map(Node::Implements));
1122 children.extend(node.members.iter().map(Node::ClassLikeMember));
1123
1124 children
1125 }
1126 Node::EnumBackingTypeHint(node) => {
1127 vec![Node::Hint(&node.hint)]
1128 }
1129 Node::Interface(node) => {
1130 let mut children = vec![];
1131 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1132 children.push(Node::Keyword(&node.interface));
1133 children.push(Node::LocalIdentifier(&node.name));
1134 children.extend(node.extends.iter().map(Node::Extends));
1135 children.extend(node.members.iter().map(Node::ClassLikeMember));
1136
1137 children
1138 }
1139 Node::Trait(node) => {
1140 let mut children = vec![];
1141 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1142 children.push(Node::Keyword(&node.r#trait));
1143 children.push(Node::LocalIdentifier(&node.name));
1144 children.extend(node.members.iter().map(Node::ClassLikeMember));
1145
1146 children
1147 }
1148 Node::Clone(node) => {
1149 vec![Node::Keyword(&node.clone), Node::Expression(&node.object)]
1150 }
1151 Node::ClosureCreation(node) => vec![match node {
1152 ClosureCreation::Function(node) => Node::FunctionClosureCreation(node),
1153 ClosureCreation::Method(node) => Node::MethodClosureCreation(node),
1154 ClosureCreation::StaticMethod(node) => Node::StaticMethodClosureCreation(node),
1155 }],
1156 Node::FunctionClosureCreation(node) => vec![Node::Expression(&node.function)],
1157 Node::MethodClosureCreation(node) => {
1158 vec![Node::Expression(&node.object), Node::ClassLikeMemberSelector(&node.method)]
1159 }
1160 Node::StaticMethodClosureCreation(node) => {
1161 vec![Node::Expression(&node.class), Node::ClassLikeMemberSelector(&node.method)]
1162 }
1163 Node::Constant(node) => {
1164 let mut children = vec![];
1165 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1166 children.push(Node::Keyword(&node.r#const));
1167 children.extend(node.items.iter().map(Node::ConstantItem));
1168 children.push(Node::Terminator(&node.terminator));
1169
1170 children
1171 }
1172 Node::ConstantItem(node) => {
1173 vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
1174 }
1175 Node::Construct(node) => vec![match node {
1176 Construct::Isset(node) => Node::IssetConstruct(node),
1177 Construct::Empty(node) => Node::EmptyConstruct(node),
1178 Construct::Eval(node) => Node::EvalConstruct(node),
1179 Construct::Include(node) => Node::IncludeConstruct(node),
1180 Construct::IncludeOnce(node) => Node::IncludeOnceConstruct(node),
1181 Construct::Require(node) => Node::RequireConstruct(node),
1182 Construct::RequireOnce(node) => Node::RequireOnceConstruct(node),
1183 Construct::Print(node) => Node::PrintConstruct(node),
1184 Construct::Exit(node) => Node::ExitConstruct(node),
1185 Construct::Die(node) => Node::DieConstruct(node),
1186 }],
1187 Node::IssetConstruct(node) => {
1188 let mut children = vec![Node::Keyword(&node.isset)];
1189 children.extend(node.values.iter().map(Node::Expression));
1190
1191 children
1192 }
1193 Node::EmptyConstruct(node) => {
1194 vec![Node::Keyword(&node.empty), Node::Expression(&node.value)]
1195 }
1196 Node::EvalConstruct(node) => {
1197 vec![Node::Keyword(&node.eval), Node::Expression(&node.value)]
1198 }
1199 Node::IncludeConstruct(node) => {
1200 vec![Node::Keyword(&node.include), Node::Expression(&node.value)]
1201 }
1202 Node::IncludeOnceConstruct(node) => vec![Node::Keyword(&node.include_once), Node::Expression(&node.value)],
1203 Node::RequireConstruct(node) => {
1204 vec![Node::Keyword(&node.require), Node::Expression(&node.value)]
1205 }
1206 Node::RequireOnceConstruct(node) => vec![Node::Keyword(&node.require_once), Node::Expression(&node.value)],
1207 Node::PrintConstruct(node) => {
1208 vec![Node::Keyword(&node.print), Node::Expression(&node.value)]
1209 }
1210 Node::ExitConstruct(node) => {
1211 let mut children = vec![Node::Keyword(&node.exit)];
1212 if let Some(arguments) = &node.arguments {
1213 children.push(Node::ArgumentList(arguments));
1214 }
1215 children
1216 }
1217 Node::DieConstruct(node) => {
1218 let mut children = vec![Node::Keyword(&node.die)];
1219 if let Some(arguments) = &node.arguments {
1220 children.push(Node::ArgumentList(arguments));
1221 }
1222 children
1223 }
1224 Node::If(node) => {
1225 vec![Node::Keyword(&node.r#if), Node::Expression(&node.condition), Node::IfBody(&node.body)]
1226 }
1227 Node::IfBody(node) => match node {
1228 IfBody::Statement(statement_body) => vec![Node::IfStatementBody(statement_body)],
1229 IfBody::ColonDelimited(colon_body) => vec![Node::IfColonDelimitedBody(colon_body)],
1230 },
1231 Node::IfStatementBody(node) => {
1232 let mut children = vec![Node::Statement(&node.statement)];
1233
1234 children.extend(node.else_if_clauses.iter().map(Node::IfStatementBodyElseIfClause));
1235 if let Some(else_clause) = &node.else_clause {
1236 children.push(Node::IfStatementBodyElseClause(else_clause));
1237 }
1238
1239 children
1240 }
1241 Node::IfStatementBodyElseIfClause(node) => {
1242 vec![Node::Keyword(&node.elseif), Node::Expression(&node.condition), Node::Statement(&node.statement)]
1243 }
1244 Node::IfStatementBodyElseClause(node) => {
1245 vec![Node::Keyword(&node.r#else), Node::Statement(&node.statement)]
1246 }
1247 Node::IfColonDelimitedBody(node) => {
1248 let mut children = node.statements.iter().map(Node::Statement).collect::<Vec<_>>();
1249
1250 children.extend(node.else_if_clauses.iter().map(Node::IfColonDelimitedBodyElseIfClause));
1251
1252 if let Some(else_clause) = &node.else_clause {
1253 children.push(Node::IfColonDelimitedBodyElseClause(else_clause));
1254 }
1255
1256 children.push(Node::Keyword(&node.endif));
1257 children.push(Node::Terminator(&node.terminator));
1258
1259 children
1260 }
1261 Node::IfColonDelimitedBodyElseIfClause(node) => {
1262 let mut children = vec![Node::Keyword(&node.elseif), Node::Expression(&node.condition)];
1263 children.extend(node.statements.iter().map(Node::Statement));
1264
1265 children
1266 }
1267 Node::IfColonDelimitedBodyElseClause(node) => {
1268 let mut children = vec![Node::Keyword(&node.r#else)];
1269
1270 children.extend(node.statements.iter().map(Node::Statement));
1271
1272 children
1273 }
1274 Node::Match(node) => {
1275 let mut children = vec![Node::Keyword(&node.r#match), Node::Expression(&node.expression)];
1276 children.extend(node.arms.iter().map(Node::MatchArm));
1277
1278 children
1279 }
1280 Node::MatchArm(node) => match node {
1281 MatchArm::Expression(expr_arm) => vec![Node::MatchExpressionArm(expr_arm)],
1282 MatchArm::Default(default_arm) => vec![Node::MatchDefaultArm(default_arm)],
1283 },
1284 Node::MatchExpressionArm(node) => {
1285 let mut children = vec![];
1286
1287 children.extend(node.conditions.iter().map(Node::Expression));
1288 children.push(Node::Expression(&node.expression));
1289
1290 children
1291 }
1292 Node::MatchDefaultArm(node) => {
1293 vec![Node::Keyword(&node.default), Node::Expression(&node.expression)]
1294 }
1295 Node::Switch(node) => {
1296 vec![Node::Keyword(&node.switch), Node::Expression(&node.expression), Node::SwitchBody(&node.body)]
1297 }
1298 Node::SwitchBody(node) => match node {
1299 SwitchBody::BraceDelimited(body) => vec![Node::SwitchBraceDelimitedBody(body)],
1300 SwitchBody::ColonDelimited(body) => vec![Node::SwitchColonDelimitedBody(body)],
1301 },
1302 Node::SwitchBraceDelimitedBody(node) => {
1303 let mut children = vec![];
1304
1305 if let Some(terminator) = &node.optional_terminator {
1306 children.push(Node::Terminator(terminator));
1307 }
1308
1309 children.extend(node.cases.iter().map(Node::SwitchCase));
1310
1311 children
1312 }
1313 Node::SwitchColonDelimitedBody(node) => {
1314 let mut children = vec![];
1315
1316 if let Some(terminator) = &node.optional_terminator {
1317 children.push(Node::Terminator(terminator));
1318 }
1319
1320 children.extend(node.cases.iter().map(Node::SwitchCase));
1321 children.push(Node::Keyword(&node.end_switch));
1322 children.push(Node::Terminator(&node.terminator));
1323
1324 children
1325 }
1326 Node::SwitchCase(node) => match node {
1327 SwitchCase::Expression(expression_case) => vec![Node::SwitchExpressionCase(expression_case)],
1328 SwitchCase::Default(default_case) => vec![Node::SwitchDefaultCase(default_case)],
1329 },
1330 Node::SwitchExpressionCase(node) => {
1331 let mut children = vec![
1332 Node::Keyword(&node.case),
1333 Node::Expression(&node.expression),
1334 Node::SwitchCaseSeparator(&node.separator),
1335 ];
1336
1337 children.extend(node.statements.iter().map(Node::Statement));
1338
1339 children
1340 }
1341 Node::SwitchDefaultCase(node) => {
1342 let mut children = vec![Node::Keyword(&node.default), Node::SwitchCaseSeparator(&node.separator)];
1343 children.extend(node.statements.iter().map(Node::Statement));
1344
1345 children
1346 }
1347 Node::SwitchCaseSeparator(_) => vec![],
1348 Node::Declare(node) => {
1349 let mut children = vec![Node::Keyword(&node.declare)];
1350
1351 children.extend(node.items.iter().map(Node::DeclareItem));
1352 children.push(Node::DeclareBody(&node.body));
1353
1354 children
1355 }
1356 Node::DeclareBody(node) => match node {
1357 DeclareBody::Statement(statement) => vec![Node::Statement(statement)],
1358 DeclareBody::ColonDelimited(body) => vec![Node::DeclareColonDelimitedBody(body)],
1359 },
1360 Node::DeclareColonDelimitedBody(node) => {
1361 let mut children = node.statements.iter().map(Node::Statement).collect::<Vec<_>>();
1362
1363 children.push(Node::Keyword(&node.end_declare));
1364 children.push(Node::Terminator(&node.terminator));
1365
1366 children
1367 }
1368 Node::DeclareItem(node) => {
1369 vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
1370 }
1371 Node::Echo(node) => {
1372 let mut children = vec![Node::Keyword(&node.echo)];
1373 children.extend(node.values.iter().map(Node::Expression));
1374 children.push(Node::Terminator(&node.terminator));
1375
1376 children
1377 }
1378 Node::Parenthesized(node) => vec![Node::Expression(&node.expression)],
1379 Node::Expression(node) => vec![match node {
1380 Expression::Binary(node) => Node::Binary(node),
1381 Expression::UnaryPrefix(node) => Node::UnaryPrefix(node),
1382 Expression::ConstantAccess(node) => Node::ConstantAccess(node),
1383 Expression::UnaryPostfix(node) => Node::UnaryPostfix(node),
1384 Expression::Parenthesized(node) => Node::Parenthesized(node),
1385 Expression::Literal(node) => Node::Literal(node),
1386 Expression::CompositeString(node) => Node::CompositeString(node),
1387 Expression::Assignment(node) => Node::Assignment(node),
1388 Expression::Conditional(node) => Node::Conditional(node),
1389 Expression::Array(node) => Node::Array(node),
1390 Expression::LegacyArray(node) => Node::LegacyArray(node),
1391 Expression::List(node) => Node::List(node),
1392 Expression::ArrayAccess(node) => Node::ArrayAccess(node),
1393 Expression::ArrayAppend(node) => Node::ArrayAppend(node),
1394 Expression::AnonymousClass(node) => Node::AnonymousClass(node),
1395 Expression::Closure(node) => Node::Closure(node),
1396 Expression::ArrowFunction(node) => Node::ArrowFunction(node),
1397 Expression::Variable(node) => Node::Variable(node),
1398 Expression::Identifier(node) => Node::Identifier(node),
1399 Expression::Match(node) => Node::Match(node),
1400 Expression::Yield(node) => Node::Yield(node),
1401 Expression::Construct(node) => Node::Construct(node),
1402 Expression::Throw(node) => Node::Throw(node),
1403 Expression::Clone(node) => Node::Clone(node),
1404 Expression::Call(node) => Node::Call(node),
1405 Expression::Access(node) => Node::Access(node),
1406 Expression::ClosureCreation(node) => Node::ClosureCreation(node),
1407 Expression::Parent(node) => Node::Keyword(node),
1408 Expression::Static(node) => Node::Keyword(node),
1409 Expression::Self_(node) => Node::Keyword(node),
1410 Expression::Instantiation(node) => Node::Instantiation(node),
1411 Expression::MagicConstant(node) => Node::MagicConstant(node),
1412 Expression::Pipe(node) => Node::Pipe(node),
1413 }],
1414 Node::Binary(node) => {
1415 vec![Node::Expression(&node.lhs), Node::BinaryOperator(&node.operator), Node::Expression(&node.rhs)]
1416 }
1417 Node::BinaryOperator(operator) => match operator {
1418 BinaryOperator::Addition(_) => vec![],
1419 BinaryOperator::Subtraction(_) => vec![],
1420 BinaryOperator::Multiplication(_) => vec![],
1421 BinaryOperator::Division(_) => vec![],
1422 BinaryOperator::Modulo(_) => vec![],
1423 BinaryOperator::Exponentiation(_) => vec![],
1424 BinaryOperator::BitwiseAnd(_) => vec![],
1425 BinaryOperator::BitwiseOr(_) => vec![],
1426 BinaryOperator::BitwiseXor(_) => vec![],
1427 BinaryOperator::LeftShift(_) => vec![],
1428 BinaryOperator::RightShift(_) => vec![],
1429 BinaryOperator::NullCoalesce(_) => vec![],
1430 BinaryOperator::Equal(_) => vec![],
1431 BinaryOperator::NotEqual(_) => vec![],
1432 BinaryOperator::Identical(_) => vec![],
1433 BinaryOperator::NotIdentical(_) => vec![],
1434 BinaryOperator::AngledNotEqual(_) => vec![],
1435 BinaryOperator::LessThan(_) => vec![],
1436 BinaryOperator::LessThanOrEqual(_) => vec![],
1437 BinaryOperator::GreaterThan(_) => vec![],
1438 BinaryOperator::GreaterThanOrEqual(_) => vec![],
1439 BinaryOperator::Spaceship(_) => vec![],
1440 BinaryOperator::StringConcat(_) => vec![],
1441 BinaryOperator::And(_) => vec![],
1442 BinaryOperator::Or(_) => vec![],
1443 BinaryOperator::Elvis(_) => vec![],
1444 BinaryOperator::Instanceof(keyword) => vec![Node::Keyword(keyword)],
1445 BinaryOperator::LowAnd(keyword) => vec![Node::Keyword(keyword)],
1446 BinaryOperator::LowOr(keyword) => vec![Node::Keyword(keyword)],
1447 BinaryOperator::LowXor(keyword) => vec![Node::Keyword(keyword)],
1448 },
1449 Node::UnaryPrefix(node) => {
1450 vec![Node::UnaryPrefixOperator(&node.operator), Node::Expression(&node.operand)]
1451 }
1452 Node::UnaryPostfix(node) => {
1453 vec![Node::Expression(&node.operand), Node::UnaryPostfixOperator(&node.operator)]
1454 }
1455 Node::UnaryPrefixOperator(_) | Node::UnaryPostfixOperator(_) => vec![],
1456 Node::ArrowFunction(node) => {
1457 let mut children = vec![];
1458
1459 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1460 if let Some(r#static) = &node.r#static {
1461 children.push(Node::Keyword(r#static));
1462 }
1463 children.push(Node::Keyword(&node.r#fn));
1464 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1465 if let Some(return_type_hint) = &node.return_type_hint {
1466 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1467 }
1468 children.push(Node::Expression(&node.expression));
1469
1470 children
1471 }
1472 Node::Closure(node) => {
1473 let mut children = vec![];
1474
1475 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1476 children.push(Node::Keyword(&node.function));
1477 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1478 if let Some(use_clause) = &node.use_clause {
1479 children.push(Node::ClosureUseClause(use_clause));
1480 }
1481 if let Some(return_type_hint) = &node.return_type_hint {
1482 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1483 }
1484 children.push(Node::Block(&node.body));
1485
1486 children
1487 }
1488 Node::ClosureUseClause(node) => {
1489 let mut children = vec![Node::Keyword(&node.r#use)];
1490 children.extend(node.variables.iter().map(Node::ClosureUseClauseVariable));
1491
1492 children
1493 }
1494 Node::ClosureUseClauseVariable(node) => vec![Node::DirectVariable(&node.variable)],
1495 Node::Function(node) => {
1496 let mut children = vec![];
1497
1498 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1499 children.push(Node::Keyword(&node.function));
1500 children.push(Node::LocalIdentifier(&node.name));
1501 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1502 if let Some(return_type_hint) = &node.return_type_hint {
1503 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1504 }
1505
1506 children.push(Node::Block(&node.body));
1507
1508 children
1509 }
1510 Node::FunctionLikeParameterList(node) => node.parameters.iter().map(Node::FunctionLikeParameter).collect(),
1511 Node::FunctionLikeParameter(node) => {
1512 let mut children = vec![];
1513
1514 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1515 children.extend(node.modifiers.iter().map(Node::Modifier));
1516 if let Some(hint) = &node.hint {
1517 children.push(Node::Hint(hint));
1518 }
1519 children.push(Node::DirectVariable(&node.variable));
1520 if let Some(default_value) = &node.default_value {
1521 children.push(Node::FunctionLikeParameterDefaultValue(default_value));
1522 }
1523
1524 if let Some(hooks) = &node.hooks {
1525 children.push(Node::PropertyHookList(hooks));
1526 }
1527
1528 children
1529 }
1530 Node::FunctionLikeParameterDefaultValue(node) => vec![Node::Expression(&node.value)],
1531 Node::FunctionLikeReturnTypeHint(hint) => vec![Node::Hint(&hint.hint)],
1532 Node::Global(node) => {
1533 let mut children: Vec<Node> = vec![];
1534
1535 children.push(Node::Keyword(&node.r#global));
1536 children.extend(node.variables.iter().map(Node::Variable));
1537
1538 children
1539 }
1540 Node::Goto(node) => {
1541 vec![Node::Keyword(&node.r#goto), Node::LocalIdentifier(&node.label)]
1542 }
1543 Node::Label(node) => {
1544 vec![Node::LocalIdentifier(&node.name)]
1545 }
1546 Node::HaltCompiler(node) => {
1547 vec![Node::Keyword(&node.halt_compiler)]
1548 }
1549 Node::FullyQualifiedIdentifier(_) => vec![],
1550 Node::Identifier(node) => vec![match node {
1551 Identifier::Local(node) => Node::LocalIdentifier(node),
1552 Identifier::Qualified(node) => Node::QualifiedIdentifier(node),
1553 Identifier::FullyQualified(node) => Node::FullyQualifiedIdentifier(node),
1554 }],
1555 Node::LocalIdentifier(_) => vec![],
1556 Node::QualifiedIdentifier(_) => vec![],
1557 Node::Inline(_) => vec![],
1558 Node::Instantiation(node) => {
1559 let mut children = vec![Node::Keyword(&node.new), Node::Expression(&node.class)];
1560
1561 if let Some(argument_list) = &node.argument_list {
1562 children.push(Node::ArgumentList(argument_list));
1563 }
1564
1565 children
1566 }
1567 Node::Keyword(_) => vec![],
1568 Node::Literal(node) => vec![match node {
1569 Literal::Float(node) => Node::LiteralFloat(node),
1570 Literal::Integer(node) => Node::LiteralInteger(node),
1571 Literal::String(node) => Node::LiteralString(node),
1572 Literal::True(node) => Node::Keyword(node),
1573 Literal::False(node) => Node::Keyword(node),
1574 Literal::Null(node) => Node::Keyword(node),
1575 }],
1576 Node::LiteralFloat(_) => vec![],
1577 Node::LiteralInteger(_) => vec![],
1578 Node::LiteralString(_) => vec![],
1579 Node::MagicConstant(node) => vec![match node {
1580 MagicConstant::Class(node) => Node::LocalIdentifier(node),
1581 MagicConstant::Directory(node) => Node::LocalIdentifier(node),
1582 MagicConstant::File(node) => Node::LocalIdentifier(node),
1583 MagicConstant::Function(node) => Node::LocalIdentifier(node),
1584 MagicConstant::Line(node) => Node::LocalIdentifier(node),
1585 MagicConstant::Method(node) => Node::LocalIdentifier(node),
1586 MagicConstant::Namespace(node) => Node::LocalIdentifier(node),
1587 MagicConstant::Trait(node) => Node::LocalIdentifier(node),
1588 MagicConstant::Property(node) => Node::LocalIdentifier(node),
1589 }],
1590 Node::Modifier(node) => vec![match node {
1591 Modifier::Abstract(node) => Node::Keyword(node),
1592 Modifier::Final(node) => Node::Keyword(node),
1593 Modifier::Private(node) => Node::Keyword(node),
1594 Modifier::Protected(node) => Node::Keyword(node),
1595 Modifier::Public(node) => Node::Keyword(node),
1596 Modifier::Static(node) => Node::Keyword(node),
1597 Modifier::Readonly(node) => Node::Keyword(node),
1598 Modifier::PrivateSet(node) => Node::Keyword(node),
1599 Modifier::ProtectedSet(node) => Node::Keyword(node),
1600 Modifier::PublicSet(node) => Node::Keyword(node),
1601 }],
1602 Node::Namespace(node) => {
1603 let mut children = vec![Node::Keyword(&node.r#namespace)];
1604
1605 if let Some(name) = &node.name {
1606 children.push(Node::Identifier(name));
1607 }
1608
1609 children.push(Node::NamespaceBody(&node.body));
1610
1611 children
1612 }
1613 Node::NamespaceBody(node) => {
1614 vec![match node {
1615 NamespaceBody::BraceDelimited(node) => Node::Block(node),
1616 NamespaceBody::Implicit(node) => Node::NamespaceImplicitBody(node),
1617 }]
1618 }
1619 Node::NamespaceImplicitBody(node) => {
1620 let mut children = vec![Node::Terminator(&node.terminator)];
1621
1622 children.extend(node.statements.iter().map(Node::Statement));
1623
1624 children
1625 }
1626 Node::Assignment(node) => {
1627 vec![Node::Expression(&node.lhs), Node::AssignmentOperator(&node.operator), Node::Expression(&node.rhs)]
1628 }
1629 Node::AssignmentOperator(_) => vec![],
1630 Node::Conditional(node) => {
1631 let mut children = vec![Node::Expression(&node.condition)];
1632
1633 if let Some(then) = &node.then {
1634 children.push(Node::Expression(then));
1635 }
1636
1637 children.push(Node::Expression(&node.r#else));
1638
1639 children
1640 }
1641 Node::DoWhile(node) => vec![
1642 Node::Keyword(&node.r#do),
1643 Node::Statement(&node.statement),
1644 Node::Keyword(&node.r#while),
1645 Node::Expression(&node.condition),
1646 Node::Terminator(&node.terminator),
1647 ],
1648 Node::Foreach(node) => vec![
1649 Node::Keyword(&node.r#foreach),
1650 Node::Expression(&node.expression),
1651 Node::Keyword(&node.r#as),
1652 Node::ForeachTarget(&node.target),
1653 Node::ForeachBody(&node.body),
1654 ],
1655 Node::ForeachBody(node) => vec![match node {
1656 ForeachBody::Statement(node) => Node::Statement(node),
1657 ForeachBody::ColonDelimited(node) => Node::ForeachColonDelimitedBody(node),
1658 }],
1659 Node::ForeachColonDelimitedBody(node) => {
1660 let mut children = node.statements.iter().map(Node::Statement).collect::<Vec<_>>();
1661
1662 children.push(Node::Keyword(&node.end_foreach));
1663 children.push(Node::Terminator(&node.terminator));
1664
1665 children
1666 }
1667 Node::ForeachKeyValueTarget(node) => {
1668 vec![Node::Expression(&node.key), Node::Expression(&node.value)]
1669 }
1670 Node::ForeachTarget(node) => vec![match node {
1671 ForeachTarget::KeyValue(node) => Node::ForeachKeyValueTarget(node),
1672 ForeachTarget::Value(node) => Node::ForeachValueTarget(node),
1673 }],
1674 Node::ForeachValueTarget(node) => vec![Node::Expression(&node.value)],
1675 Node::For(node) => {
1676 let mut children = vec![Node::Keyword(&node.r#for)];
1677
1678 children.extend(node.initializations.iter().map(Node::Expression));
1679 children.extend(node.conditions.iter().map(Node::Expression));
1680 children.extend(node.increments.iter().map(Node::Expression));
1681 children.push(Node::ForBody(&node.body));
1682
1683 children
1684 }
1685 Node::ForBody(node) => match node {
1686 ForBody::Statement(statement) => vec![Node::Statement(statement)],
1687 ForBody::ColonDelimited(body) => vec![Node::ForColonDelimitedBody(body)],
1688 },
1689 Node::ForColonDelimitedBody(node) => {
1690 let mut children = vec![];
1691
1692 children.extend(node.statements.iter().map(Node::Statement));
1693 children.push(Node::Keyword(&node.end_for));
1694 children.push(Node::Terminator(&node.terminator));
1695
1696 children
1697 }
1698 Node::While(node) => {
1699 vec![Node::Keyword(&node.r#while), Node::Expression(&node.condition), Node::WhileBody(&node.body)]
1700 }
1701 Node::WhileBody(node) => match node {
1702 WhileBody::Statement(statement) => vec![Node::Statement(statement)],
1703 WhileBody::ColonDelimited(body) => vec![Node::WhileColonDelimitedBody(body)],
1704 },
1705 Node::WhileColonDelimitedBody(node) => {
1706 let mut children = vec![];
1707
1708 children.extend(node.statements.iter().map(Node::Statement));
1709 children.push(Node::Keyword(&node.end_while));
1710 children.push(Node::Terminator(&node.terminator));
1711
1712 children
1713 }
1714 Node::Break(node) => {
1715 let mut children = vec![Node::Keyword(&node.r#break)];
1716
1717 if let Some(level) = &node.level {
1718 children.push(Node::Expression(level));
1719 }
1720
1721 children.push(Node::Terminator(&node.terminator));
1722
1723 children
1724 }
1725 Node::Continue(node) => {
1726 let mut children = vec![Node::Keyword(&node.r#continue)];
1727
1728 if let Some(level) = &node.level {
1729 children.push(Node::Expression(level));
1730 }
1731
1732 children.push(Node::Terminator(&node.terminator));
1733
1734 children
1735 }
1736 Node::Return(node) => {
1737 let mut children = vec![Node::Keyword(&node.r#return)];
1738
1739 if let Some(value) = &node.value {
1740 children.push(Node::Expression(value));
1741 }
1742
1743 children.push(Node::Terminator(&node.terminator));
1744
1745 children
1746 }
1747 Node::Static(node) => {
1748 let mut children = vec![Node::Keyword(&node.r#static)];
1749
1750 children.extend(node.items.iter().map(Node::StaticItem));
1751 children.push(Node::Terminator(&node.terminator));
1752
1753 children
1754 }
1755 Node::StaticItem(node) => vec![match node {
1756 StaticItem::Abstract(item) => Node::StaticAbstractItem(item),
1757 StaticItem::Concrete(item) => Node::StaticConcreteItem(item),
1758 }],
1759 Node::StaticAbstractItem(node) => {
1760 vec![Node::DirectVariable(&node.variable)]
1761 }
1762 Node::StaticConcreteItem(node) => {
1763 vec![Node::DirectVariable(&node.variable), Node::Expression(&node.value)]
1764 }
1765 Node::Try(node) => {
1766 let mut children = vec![];
1767
1768 children.push(Node::Keyword(&node.r#try));
1769 children.push(Node::Block(&node.block));
1770 children.extend(node.catch_clauses.iter().map(Node::TryCatchClause));
1771 if let Some(finally) = &node.finally_clause {
1772 children.push(Node::TryFinallyClause(finally));
1773 }
1774
1775 children
1776 }
1777 Node::TryCatchClause(node) => {
1778 let mut children = vec![Node::Keyword(&node.r#catch), Node::Hint(&node.hint)];
1779 if let Some(variable) = &node.variable {
1780 children.push(Node::DirectVariable(variable));
1781 }
1782 children.push(Node::Block(&node.block));
1783
1784 children
1785 }
1786 Node::TryFinallyClause(node) => {
1787 vec![Node::Keyword(&node.r#finally), Node::Block(&node.block)]
1788 }
1789 Node::MaybeTypedUseItem(node) => {
1790 let mut children = vec![];
1791 if let Some(r#type) = &node.r#type {
1792 children.push(Node::UseType(r#type));
1793 }
1794
1795 children.push(Node::UseItem(&node.item));
1796
1797 children
1798 }
1799 Node::MixedUseItemList(node) => {
1800 let mut children = vec![Node::Identifier(&node.namespace)];
1801
1802 children.extend(node.items.iter().map(Node::MaybeTypedUseItem));
1803
1804 children
1805 }
1806 Node::TypedUseItemList(node) => {
1807 let mut children = vec![Node::UseType(&node.r#type), Node::Identifier(&node.namespace)];
1808
1809 children.extend(node.items.iter().map(Node::UseItem));
1810
1811 children
1812 }
1813 Node::TypedUseItemSequence(node) => {
1814 let mut children = vec![Node::UseType(&node.r#type)];
1815
1816 children.extend(node.items.iter().map(Node::UseItem));
1817 children
1818 }
1819 Node::Use(node) => {
1820 vec![Node::Keyword(&node.r#use), Node::UseItems(&node.items), Node::Terminator(&node.terminator)]
1821 }
1822 Node::UseItem(node) => {
1823 let mut result = vec![Node::Identifier(&node.name)];
1824
1825 if let Some(alias) = &node.alias {
1826 result.push(Node::UseItemAlias(alias));
1827 }
1828
1829 result
1830 }
1831 Node::UseItemAlias(node) => {
1832 vec![Node::Keyword(&node.r#as), Node::LocalIdentifier(&node.identifier)]
1833 }
1834 Node::UseItemSequence(node) => node.items.iter().map(Node::UseItem).collect(),
1835 Node::UseItems(node) => vec![match node {
1836 UseItems::Sequence(node) => Node::UseItemSequence(node),
1837 UseItems::TypedList(node) => Node::TypedUseItemList(node),
1838 UseItems::MixedList(node) => Node::MixedUseItemList(node),
1839 UseItems::TypedSequence(node) => Node::TypedUseItemSequence(node),
1840 }],
1841 Node::UseType(node) => vec![match node {
1842 UseType::Const(node) => Node::Keyword(node),
1843 UseType::Function(node) => Node::Keyword(node),
1844 }],
1845 Node::Yield(node) => vec![match node {
1846 Yield::Value(node) => Node::YieldValue(node),
1847 Yield::Pair(node) => Node::YieldPair(node),
1848 Yield::From(node) => Node::YieldFrom(node),
1849 }],
1850 Node::YieldFrom(node) => {
1851 vec![Node::Keyword(&node.r#yield), Node::Keyword(&node.from), Node::Expression(&node.iterator)]
1852 }
1853 Node::YieldPair(node) => {
1854 vec![Node::Keyword(&node.r#yield), Node::Expression(&node.key), Node::Expression(&node.value)]
1855 }
1856 Node::YieldValue(node) => match &node.value {
1857 Some(value) => vec![Node::Keyword(&node.r#yield), Node::Expression(value)],
1858 None => vec![Node::Keyword(&node.r#yield)],
1859 },
1860 Node::Statement(node) => match &node {
1861 Statement::OpeningTag(node) => vec![Node::OpeningTag(node)],
1862 Statement::ClosingTag(node) => vec![Node::ClosingTag(node)],
1863 Statement::Inline(node) => vec![Node::Inline(node)],
1864 Statement::Namespace(node) => vec![Node::Namespace(node)],
1865 Statement::Use(node) => vec![Node::Use(node)],
1866 Statement::Class(node) => vec![Node::Class(node)],
1867 Statement::Interface(node) => vec![Node::Interface(node)],
1868 Statement::Trait(node) => vec![Node::Trait(node)],
1869 Statement::Enum(node) => vec![Node::Enum(node)],
1870 Statement::Block(node) => vec![Node::Block(node)],
1871 Statement::Constant(node) => vec![Node::Constant(node)],
1872 Statement::Function(node) => vec![Node::Function(node)],
1873 Statement::Declare(node) => vec![Node::Declare(node)],
1874 Statement::Goto(node) => vec![Node::Goto(node)],
1875 Statement::Label(node) => vec![Node::Label(node)],
1876 Statement::Try(node) => vec![Node::Try(node)],
1877 Statement::Foreach(node) => vec![Node::Foreach(node)],
1878 Statement::For(node) => vec![Node::For(node)],
1879 Statement::While(node) => vec![Node::While(node)],
1880 Statement::DoWhile(node) => vec![Node::DoWhile(node)],
1881 Statement::Continue(node) => vec![Node::Continue(node)],
1882 Statement::Break(node) => vec![Node::Break(node)],
1883 Statement::Switch(node) => vec![Node::Switch(node)],
1884 Statement::If(node) => vec![Node::If(node)],
1885 Statement::Return(node) => vec![Node::Return(node)],
1886 Statement::Expression(node) => vec![Node::ExpressionStatement(node)],
1887 Statement::Echo(node) => vec![Node::Echo(node)],
1888 Statement::Global(node) => vec![Node::Global(node)],
1889 Statement::Static(node) => vec![Node::Static(node)],
1890 Statement::HaltCompiler(node) => vec![Node::HaltCompiler(node)],
1891 Statement::Unset(node) => vec![Node::Unset(node)],
1892 Statement::Noop(_) => vec![],
1893 },
1894 Node::ExpressionStatement(node) => {
1895 vec![Node::Expression(&node.expression), Node::Terminator(&node.terminator)]
1896 }
1897 Node::BracedExpressionStringPart(node) => vec![Node::Expression(&node.expression)],
1898 Node::DocumentString(node) => node.parts.iter().map(Node::StringPart).collect(),
1899 Node::InterpolatedString(node) => node.parts.iter().map(Node::StringPart).collect(),
1900 Node::LiteralStringPart(_) => vec![],
1901 Node::ShellExecuteString(node) => node.parts.iter().map(Node::StringPart).collect(),
1902 Node::CompositeString(node) => vec![match node {
1903 CompositeString::ShellExecute(node) => Node::ShellExecuteString(node),
1904 CompositeString::Interpolated(node) => Node::InterpolatedString(node),
1905 CompositeString::Document(node) => Node::DocumentString(node),
1906 }],
1907 Node::StringPart(node) => vec![match node {
1908 StringPart::Literal(node) => Node::LiteralStringPart(node),
1909 StringPart::Expression(node) => Node::Expression(node),
1910 StringPart::BracedExpression(node) => Node::BracedExpressionStringPart(node),
1911 }],
1912 Node::ClosingTag(_) => vec![],
1913 Node::EchoOpeningTag(_) => vec![],
1914 Node::FullOpeningTag(_) => vec![],
1915 Node::OpeningTag(node) => match node {
1916 OpeningTag::Full(node) => vec![Node::FullOpeningTag(node)],
1917 OpeningTag::Short(node) => vec![Node::ShortOpeningTag(node)],
1918 OpeningTag::Echo(node) => vec![Node::EchoOpeningTag(node)],
1919 },
1920 Node::ShortOpeningTag(_) => vec![],
1921 Node::Terminator(node) => match node {
1922 Terminator::Semicolon(_) => vec![],
1923 Terminator::ClosingTag(closing_tag) => vec![Node::ClosingTag(closing_tag)],
1924 Terminator::TagPair(closing_tag, opening_tag) => {
1925 vec![Node::ClosingTag(closing_tag), Node::OpeningTag(opening_tag)]
1926 }
1927 },
1928 Node::Throw(node) => vec![Node::Keyword(&node.throw), Node::Expression(&node.exception)],
1929 Node::Hint(node) => match &node {
1930 Hint::Identifier(identifier) => vec![Node::Identifier(identifier)],
1931 Hint::Parenthesized(parenthesized_hint) => vec![Node::ParenthesizedHint(parenthesized_hint)],
1932 Hint::Nullable(nullable_hint) => vec![Node::NullableHint(nullable_hint)],
1933 Hint::Union(union_hint) => vec![Node::UnionHint(union_hint)],
1934 Hint::Intersection(intersection_hint) => vec![Node::IntersectionHint(intersection_hint)],
1935 Hint::Null(keyword)
1936 | Hint::True(keyword)
1937 | Hint::False(keyword)
1938 | Hint::Array(keyword)
1939 | Hint::Callable(keyword)
1940 | Hint::Static(keyword)
1941 | Hint::Self_(keyword)
1942 | Hint::Parent(keyword) => vec![Node::Keyword(keyword)],
1943 Hint::Void(local_identifier)
1944 | Hint::Never(local_identifier)
1945 | Hint::Float(local_identifier)
1946 | Hint::Bool(local_identifier)
1947 | Hint::Integer(local_identifier)
1948 | Hint::String(local_identifier)
1949 | Hint::Object(local_identifier)
1950 | Hint::Mixed(local_identifier)
1951 | Hint::Iterable(local_identifier) => vec![Node::LocalIdentifier(local_identifier)],
1952 },
1953 Node::IntersectionHint(node) => vec![Node::Hint(&node.left), Node::Hint(&node.right)],
1954 Node::NullableHint(node) => vec![Node::Hint(&node.hint)],
1955 Node::ParenthesizedHint(node) => vec![Node::Hint(&node.hint)],
1956 Node::UnionHint(node) => vec![Node::Hint(&node.left), Node::Hint(&node.right)],
1957 Node::Unset(node) => {
1958 let mut children = vec![Node::Keyword(&node.unset)];
1959 children.extend(node.values.iter().map(Node::Expression));
1960 children.push(Node::Terminator(&node.terminator));
1961
1962 children
1963 }
1964 Node::DirectVariable(_) => vec![],
1965 Node::IndirectVariable(node) => vec![Node::Expression(&node.expression)],
1966 Node::NestedVariable(node) => {
1967 vec![Node::Variable(&node.variable)]
1968 }
1969 Node::Variable(node) => match node {
1970 Variable::Direct(node) => vec![Node::DirectVariable(node)],
1971 Variable::Indirect(node) => vec![Node::IndirectVariable(node)],
1972 Variable::Nested(node) => vec![Node::NestedVariable(node)],
1973 },
1974 Node::Pipe(pipe) => {
1975 vec![Node::Expression(&pipe.input), Node::Expression(&pipe.callable)]
1976 }
1977 }
1978 }
1979}
1980
1981impl HasSpan for Node<'_> {
1982 fn span(&self) -> Span {
1983 match self {
1984 Self::Program(node) => node.span(),
1985 Self::Access(node) => node.span(),
1986 Self::ConstantAccess(node) => node.span(),
1987 Self::ClassConstantAccess(node) => node.span(),
1988 Self::NullSafePropertyAccess(node) => node.span(),
1989 Self::PropertyAccess(node) => node.span(),
1990 Self::StaticPropertyAccess(node) => node.span(),
1991 Self::Argument(node) => node.span(),
1992 Self::ArgumentList(node) => node.span(),
1993 Self::NamedArgument(node) => node.span(),
1994 Self::PositionalArgument(node) => node.span(),
1995 Self::Array(node) => node.span(),
1996 Self::ArrayAccess(node) => node.span(),
1997 Self::ArrayAppend(node) => node.span(),
1998 Self::ArrayElement(node) => node.span(),
1999 Self::KeyValueArrayElement(node) => node.span(),
2000 Self::LegacyArray(node) => node.span(),
2001 Self::List(node) => node.span(),
2002 Self::MissingArrayElement(node) => node.span(),
2003 Self::ValueArrayElement(node) => node.span(),
2004 Self::VariadicArrayElement(node) => node.span(),
2005 Self::Attribute(node) => node.span(),
2006 Self::AttributeList(node) => node.span(),
2007 Self::Block(node) => node.span(),
2008 Self::Call(node) => node.span(),
2009 Self::FunctionCall(node) => node.span(),
2010 Self::MethodCall(node) => node.span(),
2011 Self::NullSafeMethodCall(node) => node.span(),
2012 Self::StaticMethodCall(node) => node.span(),
2013 Self::ClassLikeConstant(node) => node.span(),
2014 Self::ClassLikeConstantItem(node) => node.span(),
2015 Self::EnumCase(node) => node.span(),
2016 Self::EnumCaseBackedItem(node) => node.span(),
2017 Self::EnumCaseItem(node) => node.span(),
2018 Self::EnumCaseUnitItem(node) => node.span(),
2019 Self::Extends(node) => node.span(),
2020 Self::Implements(node) => node.span(),
2021 Self::ClassLikeConstantSelector(node) => node.span(),
2022 Self::ClassLikeMember(node) => node.span(),
2023 Self::ClassLikeMemberExpressionSelector(node) => node.span(),
2024 Self::ClassLikeMemberSelector(node) => node.span(),
2025 Self::Method(node) => node.span(),
2026 Self::MethodAbstractBody(node) => node.span(),
2027 Self::MethodBody(node) => node.span(),
2028 Self::HookedProperty(node) => node.span(),
2029 Self::PlainProperty(node) => node.span(),
2030 Self::Property(node) => node.span(),
2031 Self::PropertyAbstractItem(node) => node.span(),
2032 Self::PropertyConcreteItem(node) => node.span(),
2033 Self::PropertyHook(node) => node.span(),
2034 Self::PropertyHookAbstractBody(node) => node.span(),
2035 Self::PropertyHookBody(node) => node.span(),
2036 Self::PropertyHookConcreteBody(node) => node.span(),
2037 Self::PropertyHookConcreteExpressionBody(node) => node.span(),
2038 Self::PropertyHookList(node) => node.span(),
2039 Self::PropertyItem(node) => node.span(),
2040 Self::TraitUse(node) => node.span(),
2041 Self::TraitUseAbsoluteMethodReference(node) => node.span(),
2042 Self::TraitUseAbstractSpecification(node) => node.span(),
2043 Self::TraitUseAdaptation(node) => node.span(),
2044 Self::TraitUseAliasAdaptation(node) => node.span(),
2045 Self::TraitUseConcreteSpecification(node) => node.span(),
2046 Self::TraitUseMethodReference(node) => node.span(),
2047 Self::TraitUsePrecedenceAdaptation(node) => node.span(),
2048 Self::TraitUseSpecification(node) => node.span(),
2049 Self::AnonymousClass(node) => node.span(),
2050 Self::Class(node) => node.span(),
2051 Self::Enum(node) => node.span(),
2052 Self::EnumBackingTypeHint(node) => node.span(),
2053 Self::Interface(node) => node.span(),
2054 Self::Trait(node) => node.span(),
2055 Self::Clone(node) => node.span(),
2056 Self::ClosureCreation(node) => node.span(),
2057 Self::FunctionClosureCreation(node) => node.span(),
2058 Self::MethodClosureCreation(node) => node.span(),
2059 Self::StaticMethodClosureCreation(node) => node.span(),
2060 Self::Constant(node) => node.span(),
2061 Self::ConstantItem(node) => node.span(),
2062 Self::Construct(node) => node.span(),
2063 Self::DieConstruct(node) => node.span(),
2064 Self::EmptyConstruct(node) => node.span(),
2065 Self::EvalConstruct(node) => node.span(),
2066 Self::ExitConstruct(node) => node.span(),
2067 Self::IncludeConstruct(node) => node.span(),
2068 Self::IncludeOnceConstruct(node) => node.span(),
2069 Self::IssetConstruct(node) => node.span(),
2070 Self::PrintConstruct(node) => node.span(),
2071 Self::RequireConstruct(node) => node.span(),
2072 Self::RequireOnceConstruct(node) => node.span(),
2073 Self::If(node) => node.span(),
2074 Self::IfBody(node) => node.span(),
2075 Self::IfColonDelimitedBody(node) => node.span(),
2076 Self::IfColonDelimitedBodyElseClause(node) => node.span(),
2077 Self::IfColonDelimitedBodyElseIfClause(node) => node.span(),
2078 Self::IfStatementBody(node) => node.span(),
2079 Self::IfStatementBodyElseClause(node) => node.span(),
2080 Self::IfStatementBodyElseIfClause(node) => node.span(),
2081 Self::Match(node) => node.span(),
2082 Self::MatchArm(node) => node.span(),
2083 Self::MatchDefaultArm(node) => node.span(),
2084 Self::MatchExpressionArm(node) => node.span(),
2085 Self::Switch(node) => node.span(),
2086 Self::SwitchBody(node) => node.span(),
2087 Self::SwitchBraceDelimitedBody(node) => node.span(),
2088 Self::SwitchCase(node) => node.span(),
2089 Self::SwitchCaseSeparator(node) => node.span(),
2090 Self::SwitchColonDelimitedBody(node) => node.span(),
2091 Self::SwitchDefaultCase(node) => node.span(),
2092 Self::SwitchExpressionCase(node) => node.span(),
2093 Self::Declare(node) => node.span(),
2094 Self::DeclareBody(node) => node.span(),
2095 Self::DeclareColonDelimitedBody(node) => node.span(),
2096 Self::DeclareItem(node) => node.span(),
2097 Self::Echo(node) => node.span(),
2098 Self::Expression(node) => node.span(),
2099 Self::Binary(node) => node.span(),
2100 Self::BinaryOperator(node) => node.span(),
2101 Self::UnaryPrefix(node) => node.span(),
2102 Self::UnaryPrefixOperator(node) => node.span(),
2103 Self::UnaryPostfix(node) => node.span(),
2104 Self::UnaryPostfixOperator(node) => node.span(),
2105 Self::Parenthesized(node) => node.span(),
2106 Self::ArrowFunction(node) => node.span(),
2107 Self::Closure(node) => node.span(),
2108 Self::ClosureUseClause(node) => node.span(),
2109 Self::ClosureUseClauseVariable(node) => node.span(),
2110 Self::Function(node) => node.span(),
2111 Self::FunctionLikeParameter(node) => node.span(),
2112 Self::FunctionLikeParameterDefaultValue(node) => node.span(),
2113 Self::FunctionLikeParameterList(node) => node.span(),
2114 Self::FunctionLikeReturnTypeHint(node) => node.span(),
2115 Self::Global(node) => node.span(),
2116 Self::Goto(node) => node.span(),
2117 Self::Label(node) => node.span(),
2118 Self::HaltCompiler(node) => node.span(),
2119 Self::FullyQualifiedIdentifier(node) => node.span(),
2120 Self::Identifier(node) => node.span(),
2121 Self::LocalIdentifier(node) => node.span(),
2122 Self::QualifiedIdentifier(node) => node.span(),
2123 Self::Inline(node) => node.span(),
2124 Self::Instantiation(node) => node.span(),
2125 Self::Keyword(node) => node.span(),
2126 Self::Literal(node) => node.span(),
2127 Self::LiteralFloat(node) => node.span(),
2128 Self::LiteralInteger(node) => node.span(),
2129 Self::LiteralString(node) => node.span(),
2130 Self::MagicConstant(node) => node.span(),
2131 Self::Modifier(node) => node.span(),
2132 Self::Namespace(node) => node.span(),
2133 Self::NamespaceBody(node) => node.span(),
2134 Self::NamespaceImplicitBody(node) => node.span(),
2135 Self::Assignment(node) => node.span(),
2136 Self::AssignmentOperator(node) => node.span(),
2137 Self::Conditional(node) => node.span(),
2138 Self::DoWhile(node) => node.span(),
2139 Self::Foreach(node) => node.span(),
2140 Self::ForeachBody(node) => node.span(),
2141 Self::ForeachColonDelimitedBody(node) => node.span(),
2142 Self::ForeachKeyValueTarget(node) => node.span(),
2143 Self::ForeachTarget(node) => node.span(),
2144 Self::ForeachValueTarget(node) => node.span(),
2145 Self::For(node) => node.span(),
2146 Self::ForBody(node) => node.span(),
2147 Self::ForColonDelimitedBody(node) => node.span(),
2148 Self::While(node) => node.span(),
2149 Self::WhileBody(node) => node.span(),
2150 Self::WhileColonDelimitedBody(node) => node.span(),
2151 Self::Break(node) => node.span(),
2152 Self::Continue(node) => node.span(),
2153 Self::Return(node) => node.span(),
2154 Self::Static(node) => node.span(),
2155 Self::StaticAbstractItem(node) => node.span(),
2156 Self::StaticConcreteItem(node) => node.span(),
2157 Self::StaticItem(node) => node.span(),
2158 Self::Try(node) => node.span(),
2159 Self::TryCatchClause(node) => node.span(),
2160 Self::TryFinallyClause(node) => node.span(),
2161 Self::MaybeTypedUseItem(node) => node.span(),
2162 Self::MixedUseItemList(node) => node.span(),
2163 Self::TypedUseItemList(node) => node.span(),
2164 Self::TypedUseItemSequence(node) => node.span(),
2165 Self::Use(node) => node.span(),
2166 Self::UseItem(node) => node.span(),
2167 Self::UseItemAlias(node) => node.span(),
2168 Self::UseItemSequence(node) => node.span(),
2169 Self::UseItems(node) => node.span(),
2170 Self::UseType(node) => node.span(),
2171 Self::Yield(node) => node.span(),
2172 Self::YieldFrom(node) => node.span(),
2173 Self::YieldPair(node) => node.span(),
2174 Self::YieldValue(node) => node.span(),
2175 Self::Statement(node) => node.span(),
2176 Self::ExpressionStatement(node) => node.span(),
2177 Self::BracedExpressionStringPart(node) => node.span(),
2178 Self::DocumentString(node) => node.span(),
2179 Self::InterpolatedString(node) => node.span(),
2180 Self::LiteralStringPart(node) => node.span(),
2181 Self::ShellExecuteString(node) => node.span(),
2182 Self::CompositeString(node) => node.span(),
2183 Self::StringPart(node) => node.span(),
2184 Self::ClosingTag(node) => node.span(),
2185 Self::EchoOpeningTag(node) => node.span(),
2186 Self::FullOpeningTag(node) => node.span(),
2187 Self::OpeningTag(node) => node.span(),
2188 Self::ShortOpeningTag(node) => node.span(),
2189 Self::Terminator(node) => node.span(),
2190 Self::Throw(node) => node.span(),
2191 Self::Hint(node) => node.span(),
2192 Self::IntersectionHint(node) => node.span(),
2193 Self::NullableHint(node) => node.span(),
2194 Self::ParenthesizedHint(node) => node.span(),
2195 Self::UnionHint(node) => node.span(),
2196 Self::Unset(node) => node.span(),
2197 Self::DirectVariable(node) => node.span(),
2198 Self::IndirectVariable(node) => node.span(),
2199 Self::NestedVariable(node) => node.span(),
2200 Self::Variable(node) => node.span(),
2201 Self::Pipe(node) => node.span(),
2202 }
2203 }
2204}