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