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