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