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 let mut result = vec![];
708 self.filter_map_internal(&f, &mut result);
709 result
710 }
711
712 #[inline]
713 fn filter_map_internal<F, T: 'ast>(&self, f: &F, result: &mut Vec<T>)
714 where
715 F: Fn(&Node<'ast, 'arena>) -> Option<T>,
716 {
717 for child in self.children() {
718 child.filter_map_internal(f, result);
719 }
720
721 if let Some(item) = f(self) {
722 result.push(item);
723 }
724 }
725
726 #[inline]
727 #[must_use]
728 pub const fn is_declaration(&self) -> bool {
729 matches!(
730 self,
731 Self::Class(_) | Self::Interface(_) | Self::Trait(_) | Self::Enum(_) | Self::Function(_) | Self::Method(_)
732 )
733 }
734
735 #[inline]
736 #[must_use]
737 pub const fn is_statement(&self) -> bool {
738 matches!(
739 self,
740 Self::Statement(_)
741 | Self::OpeningTag(_)
742 | Self::FullOpeningTag(_)
743 | Self::ShortOpeningTag(_)
744 | Self::ClosingTag(_)
745 | Self::Inline(_)
746 | Self::Namespace(_)
747 | Self::Use(_)
748 | Self::Class(_)
749 | Self::Interface(_)
750 | Self::Trait(_)
751 | Self::Enum(_)
752 | Self::Block(_)
753 | Self::Constant(_)
754 | Self::Function(_)
755 | Self::Declare(_)
756 | Self::Goto(_)
757 | Self::Label(_)
758 | Self::Try(_)
759 | Self::Foreach(_)
760 | Self::For(_)
761 | Self::While(_)
762 | Self::DoWhile(_)
763 | Self::Continue(_)
764 | Self::Break(_)
765 | Self::Switch(_)
766 | Self::If(_)
767 | Self::Return(_)
768 | Self::ExpressionStatement(_)
769 | Self::Echo(_)
770 | Self::EchoTag(_)
771 | Self::Global(_)
772 | Self::Static(_)
773 | Self::HaltCompiler(_)
774 | Self::Unset(_)
775 )
776 }
777
778 #[inline]
779 #[must_use]
780 pub const fn kind(&self) -> NodeKind {
781 match &self {
782 Self::Program(_) => NodeKind::Program,
783 Self::Access(_) => NodeKind::Access,
784 Self::ConstantAccess(_) => NodeKind::ConstantAccess,
785 Self::ClassConstantAccess(_) => NodeKind::ClassConstantAccess,
786 Self::NullSafePropertyAccess(_) => NodeKind::NullSafePropertyAccess,
787 Self::PropertyAccess(_) => NodeKind::PropertyAccess,
788 Self::StaticPropertyAccess(_) => NodeKind::StaticPropertyAccess,
789 Self::Argument(_) => NodeKind::Argument,
790 Self::ArgumentList(_) => NodeKind::ArgumentList,
791 Self::PartialArgument(_) => NodeKind::PartialArgument,
792 Self::PartialArgumentList(_) => NodeKind::PartialArgumentList,
793 Self::NamedArgument(_) => NodeKind::NamedArgument,
794 Self::NamedPlaceholderArgument(_) => NodeKind::NamedPlaceholderArgument,
795 Self::PlaceholderArgument(_) => NodeKind::PlaceholderArgument,
796 Self::PositionalArgument(_) => NodeKind::PositionalArgument,
797 Self::VariadicPlaceholderArgument(_) => NodeKind::VariadicPlaceholderArgument,
798 Self::Array(_) => NodeKind::Array,
799 Self::ArrayAccess(_) => NodeKind::ArrayAccess,
800 Self::ArrayAppend(_) => NodeKind::ArrayAppend,
801 Self::ArrayElement(_) => NodeKind::ArrayElement,
802 Self::KeyValueArrayElement(_) => NodeKind::KeyValueArrayElement,
803 Self::LegacyArray(_) => NodeKind::LegacyArray,
804 Self::List(_) => NodeKind::List,
805 Self::MissingArrayElement(_) => NodeKind::MissingArrayElement,
806 Self::ValueArrayElement(_) => NodeKind::ValueArrayElement,
807 Self::VariadicArrayElement(_) => NodeKind::VariadicArrayElement,
808 Self::Attribute(_) => NodeKind::Attribute,
809 Self::AttributeList(_) => NodeKind::AttributeList,
810 Self::Block(_) => NodeKind::Block,
811 Self::Call(_) => NodeKind::Call,
812 Self::FunctionCall(_) => NodeKind::FunctionCall,
813 Self::MethodCall(_) => NodeKind::MethodCall,
814 Self::NullSafeMethodCall(_) => NodeKind::NullSafeMethodCall,
815 Self::StaticMethodCall(_) => NodeKind::StaticMethodCall,
816 Self::PartialApplication(_) => NodeKind::PartialApplication,
817 Self::FunctionPartialApplication(_) => NodeKind::FunctionPartialApplication,
818 Self::MethodPartialApplication(_) => NodeKind::MethodPartialApplication,
819 Self::StaticMethodPartialApplication(_) => NodeKind::StaticMethodPartialApplication,
820 Self::ClassLikeConstant(_) => NodeKind::ClassLikeConstant,
821 Self::ClassLikeConstantItem(_) => NodeKind::ClassLikeConstantItem,
822 Self::EnumCase(_) => NodeKind::EnumCase,
823 Self::EnumCaseBackedItem(_) => NodeKind::EnumCaseBackedItem,
824 Self::EnumCaseItem(_) => NodeKind::EnumCaseItem,
825 Self::EnumCaseUnitItem(_) => NodeKind::EnumCaseUnitItem,
826 Self::Extends(_) => NodeKind::Extends,
827 Self::Implements(_) => NodeKind::Implements,
828 Self::ClassLikeConstantSelector(_) => NodeKind::ClassLikeConstantSelector,
829 Self::ClassLikeMember(_) => NodeKind::ClassLikeMember,
830 Self::ClassLikeMemberExpressionSelector(_) => NodeKind::ClassLikeMemberExpressionSelector,
831 Self::ClassLikeMemberSelector(_) => NodeKind::ClassLikeMemberSelector,
832 Self::Method(_) => NodeKind::Method,
833 Self::MethodAbstractBody(_) => NodeKind::MethodAbstractBody,
834 Self::MethodBody(_) => NodeKind::MethodBody,
835 Self::HookedProperty(_) => NodeKind::HookedProperty,
836 Self::PlainProperty(_) => NodeKind::PlainProperty,
837 Self::Property(_) => NodeKind::Property,
838 Self::PropertyAbstractItem(_) => NodeKind::PropertyAbstractItem,
839 Self::PropertyConcreteItem(_) => NodeKind::PropertyConcreteItem,
840 Self::PropertyHook(_) => NodeKind::PropertyHook,
841 Self::PropertyHookAbstractBody(_) => NodeKind::PropertyHookAbstractBody,
842 Self::PropertyHookBody(_) => NodeKind::PropertyHookBody,
843 Self::PropertyHookConcreteBody(_) => NodeKind::PropertyHookConcreteBody,
844 Self::PropertyHookConcreteExpressionBody(_) => NodeKind::PropertyHookConcreteExpressionBody,
845 Self::PropertyHookList(_) => NodeKind::PropertyHookList,
846 Self::PropertyItem(_) => NodeKind::PropertyItem,
847 Self::TraitUse(_) => NodeKind::TraitUse,
848 Self::TraitUseAbsoluteMethodReference(_) => NodeKind::TraitUseAbsoluteMethodReference,
849 Self::TraitUseAbstractSpecification(_) => NodeKind::TraitUseAbstractSpecification,
850 Self::TraitUseAdaptation(_) => NodeKind::TraitUseAdaptation,
851 Self::TraitUseAliasAdaptation(_) => NodeKind::TraitUseAliasAdaptation,
852 Self::TraitUseConcreteSpecification(_) => NodeKind::TraitUseConcreteSpecification,
853 Self::TraitUseMethodReference(_) => NodeKind::TraitUseMethodReference,
854 Self::TraitUsePrecedenceAdaptation(_) => NodeKind::TraitUsePrecedenceAdaptation,
855 Self::TraitUseSpecification(_) => NodeKind::TraitUseSpecification,
856 Self::AnonymousClass(_) => NodeKind::AnonymousClass,
857 Self::Class(_) => NodeKind::Class,
858 Self::Enum(_) => NodeKind::Enum,
859 Self::EnumBackingTypeHint(_) => NodeKind::EnumBackingTypeHint,
860 Self::Interface(_) => NodeKind::Interface,
861 Self::Trait(_) => NodeKind::Trait,
862 Self::Clone(_) => NodeKind::Clone,
863 Self::Constant(_) => NodeKind::Constant,
864 Self::ConstantItem(_) => NodeKind::ConstantItem,
865 Self::Construct(_) => NodeKind::Construct,
866 Self::DieConstruct(_) => NodeKind::DieConstruct,
867 Self::EmptyConstruct(_) => NodeKind::EmptyConstruct,
868 Self::EvalConstruct(_) => NodeKind::EvalConstruct,
869 Self::ExitConstruct(_) => NodeKind::ExitConstruct,
870 Self::IncludeConstruct(_) => NodeKind::IncludeConstruct,
871 Self::IncludeOnceConstruct(_) => NodeKind::IncludeOnceConstruct,
872 Self::IssetConstruct(_) => NodeKind::IssetConstruct,
873 Self::PrintConstruct(_) => NodeKind::PrintConstruct,
874 Self::RequireConstruct(_) => NodeKind::RequireConstruct,
875 Self::RequireOnceConstruct(_) => NodeKind::RequireOnceConstruct,
876 Self::If(_) => NodeKind::If,
877 Self::IfBody(_) => NodeKind::IfBody,
878 Self::IfColonDelimitedBody(_) => NodeKind::IfColonDelimitedBody,
879 Self::IfColonDelimitedBodyElseClause(_) => NodeKind::IfColonDelimitedBodyElseClause,
880 Self::IfColonDelimitedBodyElseIfClause(_) => NodeKind::IfColonDelimitedBodyElseIfClause,
881 Self::IfStatementBody(_) => NodeKind::IfStatementBody,
882 Self::IfStatementBodyElseClause(_) => NodeKind::IfStatementBodyElseClause,
883 Self::IfStatementBodyElseIfClause(_) => NodeKind::IfStatementBodyElseIfClause,
884 Self::Match(_) => NodeKind::Match,
885 Self::MatchArm(_) => NodeKind::MatchArm,
886 Self::MatchDefaultArm(_) => NodeKind::MatchDefaultArm,
887 Self::MatchExpressionArm(_) => NodeKind::MatchExpressionArm,
888 Self::Switch(_) => NodeKind::Switch,
889 Self::SwitchBody(_) => NodeKind::SwitchBody,
890 Self::SwitchBraceDelimitedBody(_) => NodeKind::SwitchBraceDelimitedBody,
891 Self::SwitchCase(_) => NodeKind::SwitchCase,
892 Self::SwitchCaseSeparator(_) => NodeKind::SwitchCaseSeparator,
893 Self::SwitchColonDelimitedBody(_) => NodeKind::SwitchColonDelimitedBody,
894 Self::SwitchDefaultCase(_) => NodeKind::SwitchDefaultCase,
895 Self::SwitchExpressionCase(_) => NodeKind::SwitchExpressionCase,
896 Self::Declare(_) => NodeKind::Declare,
897 Self::DeclareBody(_) => NodeKind::DeclareBody,
898 Self::DeclareColonDelimitedBody(_) => NodeKind::DeclareColonDelimitedBody,
899 Self::DeclareItem(_) => NodeKind::DeclareItem,
900 Self::Echo(_) => NodeKind::Echo,
901 Self::Expression(_) => NodeKind::Expression,
902 Self::Binary(_) => NodeKind::Binary,
903 Self::BinaryOperator(_) => NodeKind::BinaryOperator,
904 Self::UnaryPrefix(_) => NodeKind::UnaryPrefix,
905 Self::UnaryPrefixOperator(_) => NodeKind::UnaryPrefixOperator,
906 Self::UnaryPostfix(_) => NodeKind::UnaryPostfix,
907 Self::UnaryPostfixOperator(_) => NodeKind::UnaryPostfixOperator,
908 Self::Parenthesized(_) => NodeKind::Parenthesized,
909 Self::ArrowFunction(_) => NodeKind::ArrowFunction,
910 Self::Closure(_) => NodeKind::Closure,
911 Self::ClosureUseClause(_) => NodeKind::ClosureUseClause,
912 Self::ClosureUseClauseVariable(_) => NodeKind::ClosureUseClauseVariable,
913 Self::Function(_) => NodeKind::Function,
914 Self::FunctionLikeParameter(_) => NodeKind::FunctionLikeParameter,
915 Self::FunctionLikeParameterDefaultValue(_) => NodeKind::FunctionLikeParameterDefaultValue,
916 Self::FunctionLikeParameterList(_) => NodeKind::FunctionLikeParameterList,
917 Self::FunctionLikeReturnTypeHint(_) => NodeKind::FunctionLikeReturnTypeHint,
918 Self::Global(_) => NodeKind::Global,
919 Self::Goto(_) => NodeKind::Goto,
920 Self::Label(_) => NodeKind::Label,
921 Self::HaltCompiler(_) => NodeKind::HaltCompiler,
922 Self::FullyQualifiedIdentifier(_) => NodeKind::FullyQualifiedIdentifier,
923 Self::Identifier(_) => NodeKind::Identifier,
924 Self::LocalIdentifier(_) => NodeKind::LocalIdentifier,
925 Self::QualifiedIdentifier(_) => NodeKind::QualifiedIdentifier,
926 Self::Inline(_) => NodeKind::Inline,
927 Self::Instantiation(_) => NodeKind::Instantiation,
928 Self::Keyword(_) => NodeKind::Keyword,
929 Self::Literal(_) => NodeKind::Literal,
930 Self::LiteralFloat(_) => NodeKind::LiteralFloat,
931 Self::LiteralInteger(_) => NodeKind::LiteralInteger,
932 Self::LiteralString(_) => NodeKind::LiteralString,
933 Self::MagicConstant(_) => NodeKind::MagicConstant,
934 Self::Modifier(_) => NodeKind::Modifier,
935 Self::Namespace(_) => NodeKind::Namespace,
936 Self::NamespaceBody(_) => NodeKind::NamespaceBody,
937 Self::NamespaceImplicitBody(_) => NodeKind::NamespaceImplicitBody,
938 Self::Assignment(_) => NodeKind::Assignment,
939 Self::AssignmentOperator(_) => NodeKind::AssignmentOperator,
940 Self::Conditional(_) => NodeKind::Conditional,
941 Self::DoWhile(_) => NodeKind::DoWhile,
942 Self::Foreach(_) => NodeKind::Foreach,
943 Self::ForeachBody(_) => NodeKind::ForeachBody,
944 Self::ForeachColonDelimitedBody(_) => NodeKind::ForeachColonDelimitedBody,
945 Self::ForeachKeyValueTarget(_) => NodeKind::ForeachKeyValueTarget,
946 Self::ForeachTarget(_) => NodeKind::ForeachTarget,
947 Self::ForeachValueTarget(_) => NodeKind::ForeachValueTarget,
948 Self::For(_) => NodeKind::For,
949 Self::ForBody(_) => NodeKind::ForBody,
950 Self::ForColonDelimitedBody(_) => NodeKind::ForColonDelimitedBody,
951 Self::While(_) => NodeKind::While,
952 Self::WhileBody(_) => NodeKind::WhileBody,
953 Self::WhileColonDelimitedBody(_) => NodeKind::WhileColonDelimitedBody,
954 Self::Break(_) => NodeKind::Break,
955 Self::Continue(_) => NodeKind::Continue,
956 Self::Return(_) => NodeKind::Return,
957 Self::Static(_) => NodeKind::Static,
958 Self::StaticAbstractItem(_) => NodeKind::StaticAbstractItem,
959 Self::StaticConcreteItem(_) => NodeKind::StaticConcreteItem,
960 Self::StaticItem(_) => NodeKind::StaticItem,
961 Self::Try(_) => NodeKind::Try,
962 Self::TryCatchClause(_) => NodeKind::TryCatchClause,
963 Self::TryFinallyClause(_) => NodeKind::TryFinallyClause,
964 Self::MaybeTypedUseItem(_) => NodeKind::MaybeTypedUseItem,
965 Self::MixedUseItemList(_) => NodeKind::MixedUseItemList,
966 Self::TypedUseItemList(_) => NodeKind::TypedUseItemList,
967 Self::TypedUseItemSequence(_) => NodeKind::TypedUseItemSequence,
968 Self::Use(_) => NodeKind::Use,
969 Self::UseItem(_) => NodeKind::UseItem,
970 Self::UseItemAlias(_) => NodeKind::UseItemAlias,
971 Self::UseItemSequence(_) => NodeKind::UseItemSequence,
972 Self::UseItems(_) => NodeKind::UseItems,
973 Self::UseType(_) => NodeKind::UseType,
974 Self::Yield(_) => NodeKind::Yield,
975 Self::YieldFrom(_) => NodeKind::YieldFrom,
976 Self::YieldPair(_) => NodeKind::YieldPair,
977 Self::YieldValue(_) => NodeKind::YieldValue,
978 Self::Statement(_) => NodeKind::Statement,
979 Self::ExpressionStatement(_) => NodeKind::ExpressionStatement,
980 Self::BracedExpressionStringPart(_) => NodeKind::BracedExpressionStringPart,
981 Self::DocumentString(_) => NodeKind::DocumentString,
982 Self::InterpolatedString(_) => NodeKind::InterpolatedString,
983 Self::LiteralStringPart(_) => NodeKind::LiteralStringPart,
984 Self::ShellExecuteString(_) => NodeKind::ShellExecuteString,
985 Self::CompositeString(_) => NodeKind::CompositeString,
986 Self::StringPart(_) => NodeKind::StringPart,
987 Self::ClosingTag(_) => NodeKind::ClosingTag,
988 Self::EchoTag(_) => NodeKind::EchoTag,
989 Self::FullOpeningTag(_) => NodeKind::FullOpeningTag,
990 Self::OpeningTag(_) => NodeKind::OpeningTag,
991 Self::ShortOpeningTag(_) => NodeKind::ShortOpeningTag,
992 Self::Terminator(_) => NodeKind::Terminator,
993 Self::Throw(_) => NodeKind::Throw,
994 Self::Hint(_) => NodeKind::Hint,
995 Self::IntersectionHint(_) => NodeKind::IntersectionHint,
996 Self::NullableHint(_) => NodeKind::NullableHint,
997 Self::ParenthesizedHint(_) => NodeKind::ParenthesizedHint,
998 Self::UnionHint(_) => NodeKind::UnionHint,
999 Self::Unset(_) => NodeKind::Unset,
1000 Self::DirectVariable(_) => NodeKind::DirectVariable,
1001 Self::IndirectVariable(_) => NodeKind::IndirectVariable,
1002 Self::NestedVariable(_) => NodeKind::NestedVariable,
1003 Self::Variable(_) => NodeKind::Variable,
1004 Self::Pipe(_) => NodeKind::Pipe,
1005 Self::Error(_) => NodeKind::Error,
1006 Self::MissingTerminator(_) => NodeKind::MissingTerminator,
1007 Self::ClassLikeMemberMissingSelector(_) => NodeKind::ClassLikeMemberMissingSelector,
1008 Self::ClassLikeConstantMissingSelector(_) => NodeKind::ClassLikeConstantMissingSelector,
1009 }
1010 }
1011
1012 #[inline]
1013 pub fn children(&self) -> Vec<Node<'ast, 'arena>> {
1014 match &self {
1015 Node::Program(node) => {
1016 let mut children = vec![];
1017 for node in node.statements.as_slice() {
1018 children.push(Node::Statement(node));
1019 }
1020
1021 children
1022 }
1023 Node::Access(node) => match &node {
1024 Access::Property(node) => vec![Node::PropertyAccess(node)],
1025 Access::NullSafeProperty(node) => vec![Node::NullSafePropertyAccess(node)],
1026 Access::StaticProperty(node) => vec![Node::StaticPropertyAccess(node)],
1027 Access::ClassConstant(node) => vec![Node::ClassConstantAccess(node)],
1028 },
1029 Node::ConstantAccess(node) => {
1030 vec![Node::Identifier(&node.name)]
1031 }
1032 Node::ClassConstantAccess(node) => {
1033 vec![Node::Expression(node.class), Node::ClassLikeConstantSelector(&node.constant)]
1034 }
1035 Node::NullSafePropertyAccess(node) => {
1036 vec![Node::Expression(node.object), Node::ClassLikeMemberSelector(&node.property)]
1037 }
1038 Node::PropertyAccess(node) => {
1039 vec![Node::Expression(node.object), Node::ClassLikeMemberSelector(&node.property)]
1040 }
1041 Node::StaticPropertyAccess(node) => {
1042 vec![Node::Expression(node.class), Node::Variable(&node.property)]
1043 }
1044 Node::Argument(node) => match &node {
1045 Argument::Named(node) => vec![Node::NamedArgument(node)],
1046 Argument::Positional(node) => vec![Node::PositionalArgument(node)],
1047 },
1048 Node::ArgumentList(node) => {
1049 let mut children = vec![];
1050 for node in node.arguments.as_slice() {
1051 children.push(Node::Argument(node));
1052 }
1053
1054 children
1055 }
1056 Node::PartialArgument(node) => match &node {
1057 PartialArgument::Named(node) => vec![Node::NamedArgument(node)],
1058 PartialArgument::NamedPlaceholder(node) => vec![Node::NamedPlaceholderArgument(node)],
1059 PartialArgument::Placeholder(node) => vec![Node::PlaceholderArgument(node)],
1060 PartialArgument::Positional(node) => vec![Node::PositionalArgument(node)],
1061 PartialArgument::VariadicPlaceholder(node) => vec![Node::VariadicPlaceholderArgument(node)],
1062 },
1063 Node::PartialArgumentList(node) => {
1064 let mut children = vec![];
1065 for node in node.arguments.as_slice() {
1066 children.push(Node::PartialArgument(node));
1067 }
1068
1069 children
1070 }
1071 Node::NamedArgument(node) => {
1072 vec![Node::LocalIdentifier(&node.name), Node::Expression(node.value)]
1073 }
1074 Node::NamedPlaceholderArgument(node) => {
1075 vec![Node::LocalIdentifier(&node.name)]
1076 }
1077 Node::PlaceholderArgument(_) => vec![],
1078 Node::PositionalArgument(node) => vec![Node::Expression(node.value)],
1079 Node::VariadicPlaceholderArgument(_) => vec![],
1080 Node::Array(node) => {
1081 let mut children = vec![];
1082 for node in node.elements.as_slice() {
1083 children.push(Node::ArrayElement(node));
1084 }
1085
1086 children
1087 }
1088 Node::ArrayAccess(node) => {
1089 vec![Node::Expression(node.array), Node::Expression(node.index)]
1090 }
1091 Node::ArrayAppend(node) => {
1092 vec![Node::Expression(node.array)]
1093 }
1094 Node::ArrayElement(node) => match &node {
1095 ArrayElement::KeyValue(node) => vec![Node::KeyValueArrayElement(node)],
1096 ArrayElement::Missing(node) => vec![Node::MissingArrayElement(node)],
1097 ArrayElement::Value(node) => vec![Node::ValueArrayElement(node)],
1098 ArrayElement::Variadic(node) => vec![Node::VariadicArrayElement(node)],
1099 },
1100 Node::KeyValueArrayElement(node) => {
1101 vec![Node::Expression(node.key), Node::Expression(node.value)]
1102 }
1103 Node::LegacyArray(node) => node.elements.iter().map(Node::ArrayElement).collect(),
1104 Node::List(node) => node.elements.iter().map(Node::ArrayElement).collect(),
1105 Node::MissingArrayElement(_) => vec![],
1106 Node::ValueArrayElement(node) => vec![Node::Expression(node.value)],
1107 Node::VariadicArrayElement(node) => vec![Node::Expression(node.value)],
1108 Node::Attribute(node) => {
1109 let mut children = vec![Node::Identifier(&node.name)];
1110 if let Some(arguments) = &node.argument_list {
1111 children.push(Node::ArgumentList(arguments));
1112 }
1113
1114 children
1115 }
1116 Node::AttributeList(node) => node.attributes.iter().map(Node::Attribute).collect(),
1117 Node::Block(node) => node.statements.iter().map(Node::Statement).collect(),
1118 Node::Call(node) => match node {
1119 Call::Function(node) => vec![Node::FunctionCall(node)],
1120 Call::Method(node) => vec![Node::MethodCall(node)],
1121 Call::NullSafeMethod(node) => vec![Node::NullSafeMethodCall(node)],
1122 Call::StaticMethod(node) => vec![Node::StaticMethodCall(node)],
1123 },
1124 Node::FunctionCall(node) => {
1125 vec![Node::Expression(node.function), Node::ArgumentList(&node.argument_list)]
1126 }
1127 Node::MethodCall(node) => {
1128 vec![
1129 Node::Expression(node.object),
1130 Node::ClassLikeMemberSelector(&node.method),
1131 Node::ArgumentList(&node.argument_list),
1132 ]
1133 }
1134 Node::NullSafeMethodCall(node) => {
1135 vec![
1136 Node::Expression(node.object),
1137 Node::ClassLikeMemberSelector(&node.method),
1138 Node::ArgumentList(&node.argument_list),
1139 ]
1140 }
1141 Node::StaticMethodCall(node) => {
1142 vec![
1143 Node::Expression(node.class),
1144 Node::ClassLikeMemberSelector(&node.method),
1145 Node::ArgumentList(&node.argument_list),
1146 ]
1147 }
1148 Node::PartialApplication(node) => match node {
1149 PartialApplication::Function(node) => vec![Node::FunctionPartialApplication(node)],
1150 PartialApplication::Method(node) => vec![Node::MethodPartialApplication(node)],
1151 PartialApplication::StaticMethod(node) => vec![Node::StaticMethodPartialApplication(node)],
1152 },
1153 Node::FunctionPartialApplication(node) => {
1154 vec![Node::Expression(node.function), Node::PartialArgumentList(&node.argument_list)]
1155 }
1156 Node::MethodPartialApplication(node) => {
1157 vec![
1158 Node::Expression(node.object),
1159 Node::ClassLikeMemberSelector(&node.method),
1160 Node::PartialArgumentList(&node.argument_list),
1161 ]
1162 }
1163 Node::StaticMethodPartialApplication(node) => {
1164 vec![
1165 Node::Expression(node.class),
1166 Node::ClassLikeMemberSelector(&node.method),
1167 Node::PartialArgumentList(&node.argument_list),
1168 ]
1169 }
1170 Node::ClassLikeConstant(node) => {
1171 let mut children = vec![];
1172 for attr in &node.attribute_lists {
1173 children.push(Node::AttributeList(attr));
1174 }
1175
1176 children.extend(node.modifiers.iter().map(Node::Modifier));
1177 children.push(Node::Keyword(&node.r#const));
1178 if let Some(hint) = &node.hint {
1179 children.push(Node::Hint(hint));
1180 }
1181
1182 children.extend(node.items.iter().map(Node::ClassLikeConstantItem));
1183 children.push(Node::Terminator(&node.terminator));
1184
1185 children
1186 }
1187 Node::ClassLikeConstantItem(node) => {
1188 vec![Node::LocalIdentifier(&node.name), Node::Expression(node.value)]
1189 }
1190 Node::EnumCase(node) => {
1191 let mut children = vec![];
1192 for attr in &node.attribute_lists {
1193 children.push(Node::AttributeList(attr));
1194 }
1195
1196 children.push(Node::Keyword(&node.case));
1197 children.push(Node::EnumCaseItem(&node.item));
1198 children.push(Node::Terminator(&node.terminator));
1199
1200 children
1201 }
1202 Node::EnumCaseBackedItem(node) => {
1203 vec![Node::LocalIdentifier(&node.name), Node::Expression(node.value)]
1204 }
1205 Node::EnumCaseItem(node) => match &node {
1206 EnumCaseItem::Backed(node) => vec![Node::EnumCaseBackedItem(node)],
1207 EnumCaseItem::Unit(node) => vec![Node::EnumCaseUnitItem(node)],
1208 },
1209 Node::EnumCaseUnitItem(node) => vec![Node::LocalIdentifier(&node.name)],
1210 Node::Extends(node) => {
1211 let mut children = vec![];
1212
1213 children.push(Node::Keyword(&node.extends));
1214 children.extend(node.types.iter().map(Node::Identifier));
1215
1216 children
1217 }
1218 Node::Implements(node) => {
1219 let mut children = vec![];
1220
1221 children.push(Node::Keyword(&node.implements));
1222 children.extend(node.types.iter().map(Node::Identifier));
1223
1224 children
1225 }
1226 Node::ClassLikeConstantSelector(node) => match node {
1227 ClassLikeConstantSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
1228 ClassLikeConstantSelector::Expression(node) => {
1229 vec![Node::ClassLikeMemberExpressionSelector(node)]
1230 }
1231 ClassLikeConstantSelector::Missing(span) => vec![Node::ClassLikeConstantMissingSelector(*span)],
1232 },
1233 Node::ClassLikeMember(node) => match node {
1234 ClassLikeMember::TraitUse(node) => vec![Node::TraitUse(node)],
1235 ClassLikeMember::Constant(node) => vec![Node::ClassLikeConstant(node)],
1236 ClassLikeMember::Property(node) => vec![Node::Property(node)],
1237 ClassLikeMember::EnumCase(node) => vec![Node::EnumCase(node)],
1238 ClassLikeMember::Method(node) => vec![Node::Method(node)],
1239 },
1240 Node::ClassLikeMemberExpressionSelector(node) => vec![Node::Expression(node.expression)],
1241 Node::ClassLikeMemberSelector(node) => match node {
1242 ClassLikeMemberSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
1243 ClassLikeMemberSelector::Variable(node) => vec![Node::Variable(node)],
1244 ClassLikeMemberSelector::Expression(node) => {
1245 vec![Node::ClassLikeMemberExpressionSelector(node)]
1246 }
1247 ClassLikeMemberSelector::Missing(span) => vec![Node::ClassLikeMemberMissingSelector(*span)],
1248 },
1249 Node::Method(node) => {
1250 let mut children: Vec<Node> = vec![];
1251
1252 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1253 children.extend(node.modifiers.iter().map(Node::Modifier));
1254 children.push(Node::Keyword(&node.function));
1255 children.push(Node::LocalIdentifier(&node.name));
1256 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1257 children.extend(node.return_type_hint.iter().map(Node::FunctionLikeReturnTypeHint));
1258 children.push(Node::MethodBody(&node.body));
1259
1260 children
1261 }
1262 Node::MethodAbstractBody(_) => vec![],
1263 Node::MethodBody(node) => match node {
1264 MethodBody::Abstract(node) => vec![Node::MethodAbstractBody(node)],
1265 MethodBody::Concrete(node) => vec![Node::Block(node)],
1266 },
1267 Node::HookedProperty(node) => {
1268 let mut children: Vec<Node> = vec![];
1269
1270 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1271 children.extend(node.var.iter().map(Node::Keyword));
1272 children.extend(node.modifiers.iter().map(Node::Modifier));
1273 children.extend(node.hint.iter().map(Node::Hint));
1274 children.push(Node::PropertyItem(&node.item));
1275 children.push(Node::PropertyHookList(&node.hook_list));
1276
1277 children
1278 }
1279 Node::PlainProperty(node) => {
1280 let mut children: Vec<Node> = vec![];
1281
1282 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1283 children.extend(node.var.iter().map(Node::Keyword));
1284 children.extend(node.modifiers.iter().map(Node::Modifier));
1285 children.extend(node.hint.iter().map(Node::Hint));
1286 children.extend(node.items.iter().map(Node::PropertyItem));
1287
1288 children
1289 }
1290 Node::Property(node) => match node {
1291 Property::Plain(node) => vec![Node::PlainProperty(node)],
1292 Property::Hooked(node) => vec![Node::HookedProperty(node)],
1293 },
1294 Node::PropertyAbstractItem(node) => {
1295 vec![Node::DirectVariable(&node.variable)]
1296 }
1297 Node::PropertyConcreteItem(node) => {
1298 vec![Node::DirectVariable(&node.variable), Node::Expression(node.value)]
1299 }
1300 Node::PropertyHook(node) => {
1301 let mut children: Vec<Node> = vec![];
1302
1303 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1304 children.extend(node.modifiers.iter().map(Node::Modifier));
1305 children.push(Node::LocalIdentifier(&node.name));
1306 children.extend(node.parameter_list.iter().map(Node::FunctionLikeParameterList));
1307 children.push(Node::PropertyHookBody(&node.body));
1308
1309 children
1310 }
1311 Node::PropertyHookAbstractBody(_) => {
1312 vec![]
1313 }
1314 Node::PropertyHookBody(node) => vec![match node {
1315 PropertyHookBody::Abstract(node) => Node::PropertyHookAbstractBody(node),
1316 PropertyHookBody::Concrete(node) => Node::PropertyHookConcreteBody(node),
1317 }],
1318 Node::PropertyHookConcreteBody(node) => vec![match node {
1319 PropertyHookConcreteBody::Expression(node) => Node::PropertyHookConcreteExpressionBody(node),
1320 PropertyHookConcreteBody::Block(node) => Node::Block(node),
1321 }],
1322 Node::PropertyHookConcreteExpressionBody(node) => vec![Node::Expression(node.expression)],
1323 Node::PropertyHookList(node) => node.hooks.iter().map(Node::PropertyHook).collect(),
1324 Node::PropertyItem(node) => match node {
1325 PropertyItem::Abstract(node) => vec![Node::PropertyAbstractItem(node)],
1326 PropertyItem::Concrete(node) => vec![Node::PropertyConcreteItem(node)],
1327 },
1328 Node::TraitUse(node) => {
1329 let mut children: Vec<Node> = vec![];
1330
1331 children.push(Node::Keyword(&node.r#use));
1332 children.extend(node.trait_names.iter().map(Node::Identifier));
1333 children.push(Node::TraitUseSpecification(&node.specification));
1334
1335 children
1336 }
1337 Node::TraitUseAbsoluteMethodReference(node) => {
1338 vec![Node::Identifier(&node.trait_name), Node::LocalIdentifier(&node.method_name)]
1339 }
1340 Node::TraitUseAbstractSpecification(node) => vec![Node::Terminator(&node.0)],
1341 Node::TraitUseAdaptation(node) => match node {
1342 TraitUseAdaptation::Precedence(adaptation) => {
1343 let mut children = vec![
1344 Node::TraitUseAbsoluteMethodReference(&adaptation.method_reference),
1345 Node::Keyword(&adaptation.insteadof),
1346 ];
1347
1348 children.extend(adaptation.trait_names.iter().map(Node::Identifier));
1349 children.push(Node::Terminator(&adaptation.terminator));
1350
1351 children
1352 }
1353 TraitUseAdaptation::Alias(adaptation) => {
1354 let mut children = vec![
1355 Node::TraitUseMethodReference(&adaptation.method_reference),
1356 Node::Keyword(&adaptation.r#as),
1357 ];
1358
1359 if let Some(visibility) = &adaptation.visibility {
1360 children.push(Node::Modifier(visibility));
1361 }
1362
1363 if let Some(alias) = &adaptation.alias {
1364 children.push(Node::LocalIdentifier(alias));
1365 }
1366
1367 children.push(Node::Terminator(&adaptation.terminator));
1368 children
1369 }
1370 },
1371 Node::TraitUseAliasAdaptation(node) => {
1372 let mut children =
1373 vec![Node::TraitUseMethodReference(&node.method_reference), Node::Keyword(&node.r#as)];
1374
1375 if let Some(visibility) = &node.visibility {
1376 children.push(Node::Modifier(visibility));
1377 }
1378
1379 if let Some(alias) = &node.alias {
1380 children.push(Node::LocalIdentifier(alias));
1381 }
1382
1383 children.push(Node::Terminator(&node.terminator));
1384 children
1385 }
1386 Node::TraitUseConcreteSpecification(node) => {
1387 let mut children = vec![];
1388 for adaptation in node.adaptations.as_slice() {
1389 children.push(Node::TraitUseAdaptation(adaptation));
1390 }
1391
1392 children
1393 }
1394 Node::TraitUseMethodReference(node) => match node {
1395 TraitUseMethodReference::Identifier(identifier) => {
1396 vec![Node::LocalIdentifier(identifier)]
1397 }
1398 TraitUseMethodReference::Absolute(reference) => {
1399 vec![Node::TraitUseAbsoluteMethodReference(reference)]
1400 }
1401 },
1402 Node::TraitUsePrecedenceAdaptation(node) => {
1403 let mut children =
1404 vec![Node::TraitUseAbsoluteMethodReference(&node.method_reference), Node::Keyword(&node.insteadof)];
1405
1406 children.extend(node.trait_names.iter().map(Node::Identifier));
1407 children.push(Node::Terminator(&node.terminator));
1408
1409 children
1410 }
1411 Node::TraitUseSpecification(node) => match node {
1412 TraitUseSpecification::Abstract(specification) => {
1413 vec![Node::TraitUseAbstractSpecification(specification)]
1414 }
1415 TraitUseSpecification::Concrete(specification) => {
1416 vec![Node::TraitUseConcreteSpecification(specification)]
1417 }
1418 },
1419 Node::AnonymousClass(node) => {
1420 let mut children = vec![Node::Keyword(&node.new)];
1421 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1422 children.extend(node.modifiers.iter().map(Node::Modifier));
1423 children.push(Node::Keyword(&node.class));
1424 if let Some(argument_list) = &node.argument_list {
1425 children.push(Node::ArgumentList(argument_list));
1426 }
1427 children.extend(node.extends.iter().map(Node::Extends));
1428 children.extend(node.implements.iter().map(Node::Implements));
1429 children.extend(node.members.iter().map(Node::ClassLikeMember));
1430
1431 children
1432 }
1433 Node::Class(node) => {
1434 let mut children = vec![];
1435 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1436 children.extend(node.modifiers.iter().map(Node::Modifier));
1437 children.push(Node::Keyword(&node.class));
1438 children.push(Node::LocalIdentifier(&node.name));
1439 children.extend(node.extends.iter().map(Node::Extends));
1440 children.extend(node.implements.iter().map(Node::Implements));
1441 children.extend(node.members.iter().map(Node::ClassLikeMember));
1442
1443 children
1444 }
1445 Node::Enum(node) => {
1446 let mut children = vec![];
1447 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1448 children.push(Node::Keyword(&node.r#enum));
1449 children.push(Node::LocalIdentifier(&node.name));
1450 children.extend(node.backing_type_hint.iter().map(Node::EnumBackingTypeHint));
1451 children.extend(node.implements.iter().map(Node::Implements));
1452 children.extend(node.members.iter().map(Node::ClassLikeMember));
1453
1454 children
1455 }
1456 Node::EnumBackingTypeHint(node) => {
1457 vec![Node::Hint(&node.hint)]
1458 }
1459 Node::Interface(node) => {
1460 let mut children = vec![];
1461 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1462 children.push(Node::Keyword(&node.interface));
1463 children.push(Node::LocalIdentifier(&node.name));
1464 children.extend(node.extends.iter().map(Node::Extends));
1465 children.extend(node.members.iter().map(Node::ClassLikeMember));
1466
1467 children
1468 }
1469 Node::Trait(node) => {
1470 let mut children = vec![];
1471 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1472 children.push(Node::Keyword(&node.r#trait));
1473 children.push(Node::LocalIdentifier(&node.name));
1474 children.extend(node.members.iter().map(Node::ClassLikeMember));
1475
1476 children
1477 }
1478 Node::Clone(node) => {
1479 vec![Node::Keyword(&node.clone), Node::Expression(node.object)]
1480 }
1481 Node::Constant(node) => {
1482 let mut children = vec![];
1483 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1484 children.push(Node::Keyword(&node.r#const));
1485 children.extend(node.items.iter().map(Node::ConstantItem));
1486 children.push(Node::Terminator(&node.terminator));
1487
1488 children
1489 }
1490 Node::ConstantItem(node) => {
1491 vec![Node::LocalIdentifier(&node.name), Node::Expression(node.value)]
1492 }
1493 Node::Construct(node) => vec![match node {
1494 Construct::Isset(node) => Node::IssetConstruct(node),
1495 Construct::Empty(node) => Node::EmptyConstruct(node),
1496 Construct::Eval(node) => Node::EvalConstruct(node),
1497 Construct::Include(node) => Node::IncludeConstruct(node),
1498 Construct::IncludeOnce(node) => Node::IncludeOnceConstruct(node),
1499 Construct::Require(node) => Node::RequireConstruct(node),
1500 Construct::RequireOnce(node) => Node::RequireOnceConstruct(node),
1501 Construct::Print(node) => Node::PrintConstruct(node),
1502 Construct::Exit(node) => Node::ExitConstruct(node),
1503 Construct::Die(node) => Node::DieConstruct(node),
1504 }],
1505 Node::IssetConstruct(node) => {
1506 let mut children = vec![Node::Keyword(&node.isset)];
1507 children.extend(node.values.iter().map(|e| Node::Expression(e)));
1508
1509 children
1510 }
1511 Node::EmptyConstruct(node) => {
1512 vec![Node::Keyword(&node.empty), Node::Expression(node.value)]
1513 }
1514 Node::EvalConstruct(node) => {
1515 vec![Node::Keyword(&node.eval), Node::Expression(node.value)]
1516 }
1517 Node::IncludeConstruct(node) => {
1518 vec![Node::Keyword(&node.include), Node::Expression(node.value)]
1519 }
1520 Node::IncludeOnceConstruct(node) => {
1521 vec![Node::Keyword(&node.include_once), Node::Expression(node.value)]
1522 }
1523 Node::RequireConstruct(node) => {
1524 vec![Node::Keyword(&node.require), Node::Expression(node.value)]
1525 }
1526 Node::RequireOnceConstruct(node) => {
1527 vec![Node::Keyword(&node.require_once), Node::Expression(node.value)]
1528 }
1529 Node::PrintConstruct(node) => {
1530 vec![Node::Keyword(&node.print), Node::Expression(node.value)]
1531 }
1532 Node::ExitConstruct(node) => {
1533 let mut children = vec![Node::Keyword(&node.exit)];
1534 if let Some(arguments) = &node.arguments {
1535 children.push(Node::ArgumentList(arguments));
1536 }
1537 children
1538 }
1539 Node::DieConstruct(node) => {
1540 let mut children = vec![Node::Keyword(&node.die)];
1541 if let Some(arguments) = &node.arguments {
1542 children.push(Node::ArgumentList(arguments));
1543 }
1544 children
1545 }
1546 Node::If(node) => {
1547 vec![Node::Keyword(&node.r#if), Node::Expression(node.condition), Node::IfBody(&node.body)]
1548 }
1549 Node::IfBody(node) => match node {
1550 IfBody::Statement(statement_body) => vec![Node::IfStatementBody(statement_body)],
1551 IfBody::ColonDelimited(colon_body) => vec![Node::IfColonDelimitedBody(colon_body)],
1552 },
1553 Node::IfStatementBody(node) => {
1554 let mut children = vec![Node::Statement(node.statement)];
1555
1556 children.extend(node.else_if_clauses.iter().map(Node::IfStatementBodyElseIfClause));
1557 if let Some(else_clause) = &node.else_clause {
1558 children.push(Node::IfStatementBodyElseClause(else_clause));
1559 }
1560
1561 children
1562 }
1563 Node::IfStatementBodyElseIfClause(node) => {
1564 vec![Node::Keyword(&node.elseif), Node::Expression(node.condition), Node::Statement(node.statement)]
1565 }
1566 Node::IfStatementBodyElseClause(node) => {
1567 vec![Node::Keyword(&node.r#else), Node::Statement(node.statement)]
1568 }
1569 Node::IfColonDelimitedBody(node) => {
1570 let mut children = vec![];
1571 for stmt in node.statements.as_slice() {
1572 children.push(Node::Statement(stmt));
1573 }
1574
1575 children.extend(node.else_if_clauses.iter().map(Node::IfColonDelimitedBodyElseIfClause));
1576
1577 if let Some(else_clause) = &node.else_clause {
1578 children.push(Node::IfColonDelimitedBodyElseClause(else_clause));
1579 }
1580
1581 children.push(Node::Keyword(&node.endif));
1582 children.push(Node::Terminator(&node.terminator));
1583
1584 children
1585 }
1586 Node::IfColonDelimitedBodyElseIfClause(node) => {
1587 let mut children = vec![Node::Keyword(&node.elseif), Node::Expression(node.condition)];
1588 children.extend(node.statements.iter().map(Node::Statement));
1589
1590 children
1591 }
1592 Node::IfColonDelimitedBodyElseClause(node) => {
1593 let mut children = vec![Node::Keyword(&node.r#else)];
1594
1595 children.extend(node.statements.iter().map(Node::Statement));
1596
1597 children
1598 }
1599 Node::Match(node) => {
1600 let mut children = vec![Node::Keyword(&node.r#match), Node::Expression(node.expression)];
1601 children.extend(node.arms.iter().map(Node::MatchArm));
1602
1603 children
1604 }
1605 Node::MatchArm(node) => match node {
1606 MatchArm::Expression(expr_arm) => vec![Node::MatchExpressionArm(expr_arm)],
1607 MatchArm::Default(default_arm) => vec![Node::MatchDefaultArm(default_arm)],
1608 },
1609 Node::MatchExpressionArm(node) => {
1610 let mut children = vec![];
1611
1612 children.extend(node.conditions.iter().map(|e| Node::Expression(e)));
1613 children.push(Node::Expression(node.expression));
1614
1615 children
1616 }
1617 Node::MatchDefaultArm(node) => {
1618 vec![Node::Keyword(&node.default), Node::Expression(node.expression)]
1619 }
1620 Node::Switch(node) => {
1621 vec![Node::Keyword(&node.switch), Node::Expression(node.expression), Node::SwitchBody(&node.body)]
1622 }
1623 Node::SwitchBody(node) => match node {
1624 SwitchBody::BraceDelimited(body) => vec![Node::SwitchBraceDelimitedBody(body)],
1625 SwitchBody::ColonDelimited(body) => vec![Node::SwitchColonDelimitedBody(body)],
1626 },
1627 Node::SwitchBraceDelimitedBody(node) => {
1628 let mut children = vec![];
1629
1630 if let Some(terminator) = &node.optional_terminator {
1631 children.push(Node::Terminator(terminator));
1632 }
1633
1634 children.extend(node.cases.iter().map(Node::SwitchCase));
1635
1636 children
1637 }
1638 Node::SwitchColonDelimitedBody(node) => {
1639 let mut children = vec![];
1640
1641 if let Some(terminator) = &node.optional_terminator {
1642 children.push(Node::Terminator(terminator));
1643 }
1644
1645 children.extend(node.cases.iter().map(Node::SwitchCase));
1646 children.push(Node::Keyword(&node.end_switch));
1647 children.push(Node::Terminator(&node.terminator));
1648
1649 children
1650 }
1651 Node::SwitchCase(node) => match node {
1652 SwitchCase::Expression(expression_case) => {
1653 vec![Node::SwitchExpressionCase(expression_case)]
1654 }
1655 SwitchCase::Default(default_case) => vec![Node::SwitchDefaultCase(default_case)],
1656 },
1657 Node::SwitchExpressionCase(node) => {
1658 let mut children = vec![
1659 Node::Keyword(&node.case),
1660 Node::Expression(node.expression),
1661 Node::SwitchCaseSeparator(&node.separator),
1662 ];
1663
1664 children.extend(node.statements.iter().map(Node::Statement));
1665
1666 children
1667 }
1668 Node::SwitchDefaultCase(node) => {
1669 let mut children = vec![Node::Keyword(&node.default), Node::SwitchCaseSeparator(&node.separator)];
1670 children.extend(node.statements.iter().map(Node::Statement));
1671
1672 children
1673 }
1674 Node::SwitchCaseSeparator(_) => vec![],
1675 Node::Declare(node) => {
1676 let mut children = vec![Node::Keyword(&node.declare)];
1677
1678 children.extend(node.items.iter().map(Node::DeclareItem));
1679 children.push(Node::DeclareBody(&node.body));
1680
1681 children
1682 }
1683 Node::DeclareBody(node) => match node {
1684 DeclareBody::Statement(statement) => vec![Node::Statement(statement)],
1685 DeclareBody::ColonDelimited(body) => vec![Node::DeclareColonDelimitedBody(body)],
1686 },
1687 Node::DeclareColonDelimitedBody(node) => {
1688 let mut children = node.statements.iter().map(Node::Statement).collect::<Vec<_>>();
1689
1690 children.push(Node::Keyword(&node.end_declare));
1691 children.push(Node::Terminator(&node.terminator));
1692
1693 children
1694 }
1695 Node::DeclareItem(node) => {
1696 vec![Node::LocalIdentifier(&node.name), Node::Expression(node.value)]
1697 }
1698 Node::EchoTag(node) => {
1699 let mut children = vec![];
1700 children.extend(node.values.iter().map(|e| Node::Expression(e)));
1701 children.push(Node::Terminator(&node.terminator));
1702
1703 children
1704 }
1705 Node::Echo(node) => {
1706 let mut children = vec![Node::Keyword(&node.echo)];
1707 children.extend(node.values.iter().map(|e| Node::Expression(e)));
1708 children.push(Node::Terminator(&node.terminator));
1709
1710 children
1711 }
1712 Node::Parenthesized(node) => vec![Node::Expression(node.expression)],
1713 Node::Expression(node) => vec![match node {
1714 Expression::Binary(node) => Node::Binary(node),
1715 Expression::UnaryPrefix(node) => Node::UnaryPrefix(node),
1716 Expression::ConstantAccess(node) => Node::ConstantAccess(node),
1717 Expression::UnaryPostfix(node) => Node::UnaryPostfix(node),
1718 Expression::Parenthesized(node) => Node::Parenthesized(node),
1719 Expression::Literal(node) => Node::Literal(node),
1720 Expression::CompositeString(node) => Node::CompositeString(node),
1721 Expression::Assignment(node) => Node::Assignment(node),
1722 Expression::Conditional(node) => Node::Conditional(node),
1723 Expression::Array(node) => Node::Array(node),
1724 Expression::LegacyArray(node) => Node::LegacyArray(node),
1725 Expression::List(node) => Node::List(node),
1726 Expression::ArrayAccess(node) => Node::ArrayAccess(node),
1727 Expression::ArrayAppend(node) => Node::ArrayAppend(node),
1728 Expression::AnonymousClass(node) => Node::AnonymousClass(node),
1729 Expression::Closure(node) => Node::Closure(node),
1730 Expression::ArrowFunction(node) => Node::ArrowFunction(node),
1731 Expression::Variable(node) => Node::Variable(node),
1732 Expression::Identifier(node) => Node::Identifier(node),
1733 Expression::Match(node) => Node::Match(node),
1734 Expression::Yield(node) => Node::Yield(node),
1735 Expression::Construct(node) => Node::Construct(node),
1736 Expression::Throw(node) => Node::Throw(node),
1737 Expression::Clone(node) => Node::Clone(node),
1738 Expression::Call(node) => Node::Call(node),
1739 Expression::PartialApplication(node) => Node::PartialApplication(node),
1740 Expression::Access(node) => Node::Access(node),
1741 Expression::Parent(node) => Node::Keyword(node),
1742 Expression::Static(node) => Node::Keyword(node),
1743 Expression::Self_(node) => Node::Keyword(node),
1744 Expression::Instantiation(node) => Node::Instantiation(node),
1745 Expression::MagicConstant(node) => Node::MagicConstant(node),
1746 Expression::Pipe(node) => Node::Pipe(node),
1747 Expression::Error(span) => return vec![Node::Error(*span)],
1748 }],
1749 Node::Binary(node) => {
1750 vec![Node::Expression(node.lhs), Node::BinaryOperator(&node.operator), Node::Expression(node.rhs)]
1751 }
1752 Node::BinaryOperator(operator) => match operator {
1753 BinaryOperator::Addition(_) => vec![],
1754 BinaryOperator::Subtraction(_) => vec![],
1755 BinaryOperator::Multiplication(_) => vec![],
1756 BinaryOperator::Division(_) => vec![],
1757 BinaryOperator::Modulo(_) => vec![],
1758 BinaryOperator::Exponentiation(_) => vec![],
1759 BinaryOperator::BitwiseAnd(_) => vec![],
1760 BinaryOperator::BitwiseOr(_) => vec![],
1761 BinaryOperator::BitwiseXor(_) => vec![],
1762 BinaryOperator::LeftShift(_) => vec![],
1763 BinaryOperator::RightShift(_) => vec![],
1764 BinaryOperator::NullCoalesce(_) => vec![],
1765 BinaryOperator::Equal(_) => vec![],
1766 BinaryOperator::NotEqual(_) => vec![],
1767 BinaryOperator::Identical(_) => vec![],
1768 BinaryOperator::NotIdentical(_) => vec![],
1769 BinaryOperator::AngledNotEqual(_) => vec![],
1770 BinaryOperator::LessThan(_) => vec![],
1771 BinaryOperator::LessThanOrEqual(_) => vec![],
1772 BinaryOperator::GreaterThan(_) => vec![],
1773 BinaryOperator::GreaterThanOrEqual(_) => vec![],
1774 BinaryOperator::Spaceship(_) => vec![],
1775 BinaryOperator::StringConcat(_) => vec![],
1776 BinaryOperator::And(_) => vec![],
1777 BinaryOperator::Or(_) => vec![],
1778 BinaryOperator::Instanceof(keyword) => vec![Node::Keyword(keyword)],
1779 BinaryOperator::LowAnd(keyword) => vec![Node::Keyword(keyword)],
1780 BinaryOperator::LowOr(keyword) => vec![Node::Keyword(keyword)],
1781 BinaryOperator::LowXor(keyword) => vec![Node::Keyword(keyword)],
1782 },
1783 Node::UnaryPrefix(node) => {
1784 vec![Node::UnaryPrefixOperator(&node.operator), Node::Expression(node.operand)]
1785 }
1786 Node::UnaryPostfix(node) => {
1787 vec![Node::Expression(node.operand), Node::UnaryPostfixOperator(&node.operator)]
1788 }
1789 Node::UnaryPrefixOperator(_) | Node::UnaryPostfixOperator(_) => vec![],
1790 Node::ArrowFunction(node) => {
1791 let mut children = vec![];
1792
1793 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1794 if let Some(r#static) = &node.r#static {
1795 children.push(Node::Keyword(r#static));
1796 }
1797 children.push(Node::Keyword(&node.r#fn));
1798 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1799 if let Some(return_type_hint) = &node.return_type_hint {
1800 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1801 }
1802 children.push(Node::Expression(node.expression));
1803
1804 children
1805 }
1806 Node::Closure(node) => {
1807 let mut children = vec![];
1808
1809 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1810 children.push(Node::Keyword(&node.function));
1811 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1812 if let Some(use_clause) = &node.use_clause {
1813 children.push(Node::ClosureUseClause(use_clause));
1814 }
1815 if let Some(return_type_hint) = &node.return_type_hint {
1816 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1817 }
1818 children.push(Node::Block(&node.body));
1819
1820 children
1821 }
1822 Node::ClosureUseClause(node) => {
1823 let mut children = vec![Node::Keyword(&node.r#use)];
1824 children.extend(node.variables.iter().map(Node::ClosureUseClauseVariable));
1825
1826 children
1827 }
1828 Node::ClosureUseClauseVariable(node) => vec![Node::DirectVariable(&node.variable)],
1829 Node::Function(node) => {
1830 let mut children = vec![];
1831
1832 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1833 children.push(Node::Keyword(&node.function));
1834 children.push(Node::LocalIdentifier(&node.name));
1835 children.push(Node::FunctionLikeParameterList(&node.parameter_list));
1836 if let Some(return_type_hint) = &node.return_type_hint {
1837 children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
1838 }
1839
1840 children.push(Node::Block(&node.body));
1841
1842 children
1843 }
1844 Node::FunctionLikeParameterList(node) => node.parameters.iter().map(Node::FunctionLikeParameter).collect(),
1845 Node::FunctionLikeParameter(node) => {
1846 let mut children = vec![];
1847
1848 children.extend(node.attribute_lists.iter().map(Node::AttributeList));
1849 children.extend(node.modifiers.iter().map(Node::Modifier));
1850 if let Some(hint) = &node.hint {
1851 children.push(Node::Hint(hint));
1852 }
1853 children.push(Node::DirectVariable(&node.variable));
1854 if let Some(default_value) = &node.default_value {
1855 children.push(Node::FunctionLikeParameterDefaultValue(default_value));
1856 }
1857
1858 if let Some(hooks) = &node.hooks {
1859 children.push(Node::PropertyHookList(hooks));
1860 }
1861
1862 children
1863 }
1864 Node::FunctionLikeParameterDefaultValue(node) => vec![Node::Expression(node.value)],
1865 Node::FunctionLikeReturnTypeHint(hint) => vec![Node::Hint(&hint.hint)],
1866 Node::Global(node) => {
1867 let mut children: Vec<Node> = vec![];
1868
1869 children.push(Node::Keyword(&node.r#global));
1870 children.extend(node.variables.iter().map(Node::Variable));
1871
1872 children
1873 }
1874 Node::Goto(node) => {
1875 vec![Node::Keyword(&node.r#goto), Node::LocalIdentifier(&node.label)]
1876 }
1877 Node::Label(node) => {
1878 vec![Node::LocalIdentifier(&node.name)]
1879 }
1880 Node::HaltCompiler(node) => {
1881 vec![Node::Keyword(&node.halt_compiler)]
1882 }
1883 Node::FullyQualifiedIdentifier(_) => vec![],
1884 Node::Identifier(node) => vec![match node {
1885 Identifier::Local(node) => Node::LocalIdentifier(node),
1886 Identifier::Qualified(node) => Node::QualifiedIdentifier(node),
1887 Identifier::FullyQualified(node) => Node::FullyQualifiedIdentifier(node),
1888 }],
1889 Node::LocalIdentifier(_) => vec![],
1890 Node::QualifiedIdentifier(_) => vec![],
1891 Node::Inline(_) => vec![],
1892 Node::Instantiation(node) => {
1893 let mut children = vec![Node::Keyword(&node.new), Node::Expression(node.class)];
1894
1895 if let Some(argument_list) = &node.argument_list {
1896 children.push(Node::ArgumentList(argument_list));
1897 }
1898
1899 children
1900 }
1901 Node::Keyword(_) => vec![],
1902 Node::Literal(node) => vec![match node {
1903 Literal::Float(node) => Node::LiteralFloat(node),
1904 Literal::Integer(node) => Node::LiteralInteger(node),
1905 Literal::String(node) => Node::LiteralString(node),
1906 Literal::True(node) => Node::Keyword(node),
1907 Literal::False(node) => Node::Keyword(node),
1908 Literal::Null(node) => Node::Keyword(node),
1909 }],
1910 Node::LiteralFloat(_) => vec![],
1911 Node::LiteralInteger(_) => vec![],
1912 Node::LiteralString(_) => vec![],
1913 Node::MagicConstant(node) => vec![match node {
1914 MagicConstant::Class(node) => Node::LocalIdentifier(node),
1915 MagicConstant::Directory(node) => Node::LocalIdentifier(node),
1916 MagicConstant::File(node) => Node::LocalIdentifier(node),
1917 MagicConstant::Function(node) => Node::LocalIdentifier(node),
1918 MagicConstant::Line(node) => Node::LocalIdentifier(node),
1919 MagicConstant::Method(node) => Node::LocalIdentifier(node),
1920 MagicConstant::Namespace(node) => Node::LocalIdentifier(node),
1921 MagicConstant::Trait(node) => Node::LocalIdentifier(node),
1922 MagicConstant::Property(node) => Node::LocalIdentifier(node),
1923 }],
1924 Node::Modifier(node) => vec![match node {
1925 Modifier::Abstract(node) => Node::Keyword(node),
1926 Modifier::Final(node) => Node::Keyword(node),
1927 Modifier::Private(node) => Node::Keyword(node),
1928 Modifier::Protected(node) => Node::Keyword(node),
1929 Modifier::Public(node) => Node::Keyword(node),
1930 Modifier::Static(node) => Node::Keyword(node),
1931 Modifier::Readonly(node) => Node::Keyword(node),
1932 Modifier::PrivateSet(node) => Node::Keyword(node),
1933 Modifier::ProtectedSet(node) => Node::Keyword(node),
1934 Modifier::PublicSet(node) => Node::Keyword(node),
1935 }],
1936 Node::Namespace(node) => {
1937 let mut children = vec![Node::Keyword(&node.r#namespace)];
1938
1939 if let Some(name) = &node.name {
1940 children.push(Node::Identifier(name));
1941 }
1942
1943 children.push(Node::NamespaceBody(&node.body));
1944
1945 children
1946 }
1947 Node::NamespaceBody(node) => {
1948 vec![match node {
1949 NamespaceBody::BraceDelimited(node) => Node::Block(node),
1950 NamespaceBody::Implicit(node) => Node::NamespaceImplicitBody(node),
1951 }]
1952 }
1953 Node::NamespaceImplicitBody(node) => {
1954 let mut children = vec![Node::Terminator(&node.terminator)];
1955
1956 children.extend(node.statements.iter().map(Node::Statement));
1957
1958 children
1959 }
1960 Node::Assignment(node) => {
1961 vec![Node::Expression(node.lhs), Node::AssignmentOperator(&node.operator), Node::Expression(node.rhs)]
1962 }
1963 Node::AssignmentOperator(_) => vec![],
1964 Node::Conditional(node) => {
1965 let mut children = vec![Node::Expression(node.condition)];
1966
1967 if let Some(then) = &node.then {
1968 children.push(Node::Expression(then));
1969 }
1970
1971 children.push(Node::Expression(node.r#else));
1972
1973 children
1974 }
1975 Node::DoWhile(node) => vec![
1976 Node::Keyword(&node.r#do),
1977 Node::Statement(node.statement),
1978 Node::Keyword(&node.r#while),
1979 Node::Expression(node.condition),
1980 Node::Terminator(&node.terminator),
1981 ],
1982 Node::Foreach(node) => vec![
1983 Node::Keyword(&node.r#foreach),
1984 Node::Expression(node.expression),
1985 Node::Keyword(&node.r#as),
1986 Node::ForeachTarget(&node.target),
1987 Node::ForeachBody(&node.body),
1988 ],
1989 Node::ForeachBody(node) => vec![match node {
1990 ForeachBody::Statement(node) => Node::Statement(node),
1991 ForeachBody::ColonDelimited(node) => Node::ForeachColonDelimitedBody(node),
1992 }],
1993 Node::ForeachColonDelimitedBody(node) => {
1994 let mut children = node.statements.iter().map(Node::Statement).collect::<Vec<_>>();
1995
1996 children.push(Node::Keyword(&node.end_foreach));
1997 children.push(Node::Terminator(&node.terminator));
1998
1999 children
2000 }
2001 Node::ForeachKeyValueTarget(node) => {
2002 vec![Node::Expression(node.key), Node::Expression(node.value)]
2003 }
2004 Node::ForeachTarget(node) => vec![match node {
2005 ForeachTarget::KeyValue(node) => Node::ForeachKeyValueTarget(node),
2006 ForeachTarget::Value(node) => Node::ForeachValueTarget(node),
2007 }],
2008 Node::ForeachValueTarget(node) => vec![Node::Expression(node.value)],
2009 Node::For(node) => {
2010 let mut children = vec![Node::Keyword(&node.r#for)];
2011
2012 children.extend(node.initializations.iter().map(|e| Node::Expression(e)));
2013 children.extend(node.conditions.iter().map(|e| Node::Expression(e)));
2014 children.extend(node.increments.iter().map(|e| Node::Expression(e)));
2015 children.push(Node::ForBody(&node.body));
2016
2017 children
2018 }
2019 Node::ForBody(node) => match node {
2020 ForBody::Statement(statement) => vec![Node::Statement(statement)],
2021 ForBody::ColonDelimited(body) => vec![Node::ForColonDelimitedBody(body)],
2022 },
2023 Node::ForColonDelimitedBody(node) => {
2024 let mut children = vec![];
2025
2026 children.extend(node.statements.iter().map(Node::Statement));
2027 children.push(Node::Keyword(&node.end_for));
2028 children.push(Node::Terminator(&node.terminator));
2029
2030 children
2031 }
2032 Node::While(node) => {
2033 vec![Node::Keyword(&node.r#while), Node::Expression(node.condition), Node::WhileBody(&node.body)]
2034 }
2035 Node::WhileBody(node) => match node {
2036 WhileBody::Statement(statement) => vec![Node::Statement(statement)],
2037 WhileBody::ColonDelimited(body) => vec![Node::WhileColonDelimitedBody(body)],
2038 },
2039 Node::WhileColonDelimitedBody(node) => {
2040 let mut children = vec![];
2041
2042 children.extend(node.statements.iter().map(Node::Statement));
2043 children.push(Node::Keyword(&node.end_while));
2044 children.push(Node::Terminator(&node.terminator));
2045
2046 children
2047 }
2048 Node::Break(node) => {
2049 let mut children = vec![Node::Keyword(&node.r#break)];
2050
2051 if let Some(level) = &node.level {
2052 children.push(Node::Expression(level));
2053 }
2054
2055 children.push(Node::Terminator(&node.terminator));
2056
2057 children
2058 }
2059 Node::Continue(node) => {
2060 let mut children = vec![Node::Keyword(&node.r#continue)];
2061
2062 if let Some(level) = &node.level {
2063 children.push(Node::Expression(level));
2064 }
2065
2066 children.push(Node::Terminator(&node.terminator));
2067
2068 children
2069 }
2070 Node::Return(node) => {
2071 let mut children = vec![Node::Keyword(&node.r#return)];
2072
2073 if let Some(value) = &node.value {
2074 children.push(Node::Expression(value));
2075 }
2076
2077 children.push(Node::Terminator(&node.terminator));
2078
2079 children
2080 }
2081 Node::Static(node) => {
2082 let mut children = vec![Node::Keyword(&node.r#static)];
2083
2084 children.extend(node.items.iter().map(Node::StaticItem));
2085 children.push(Node::Terminator(&node.terminator));
2086
2087 children
2088 }
2089 Node::StaticItem(node) => vec![match node {
2090 StaticItem::Abstract(item) => Node::StaticAbstractItem(item),
2091 StaticItem::Concrete(item) => Node::StaticConcreteItem(item),
2092 }],
2093 Node::StaticAbstractItem(node) => {
2094 vec![Node::DirectVariable(&node.variable)]
2095 }
2096 Node::StaticConcreteItem(node) => {
2097 vec![Node::DirectVariable(&node.variable), Node::Expression(node.value)]
2098 }
2099 Node::Try(node) => {
2100 let mut children = vec![];
2101
2102 children.push(Node::Keyword(&node.r#try));
2103 children.push(Node::Block(&node.block));
2104 children.extend(node.catch_clauses.iter().map(Node::TryCatchClause));
2105 if let Some(finally) = &node.finally_clause {
2106 children.push(Node::TryFinallyClause(finally));
2107 }
2108
2109 children
2110 }
2111 Node::TryCatchClause(node) => {
2112 let mut children = vec![Node::Keyword(&node.r#catch), Node::Hint(&node.hint)];
2113 if let Some(variable) = &node.variable {
2114 children.push(Node::DirectVariable(variable));
2115 }
2116 children.push(Node::Block(&node.block));
2117
2118 children
2119 }
2120 Node::TryFinallyClause(node) => {
2121 vec![Node::Keyword(&node.r#finally), Node::Block(&node.block)]
2122 }
2123 Node::MaybeTypedUseItem(node) => {
2124 let mut children = vec![];
2125 if let Some(r#type) = &node.r#type {
2126 children.push(Node::UseType(r#type));
2127 }
2128
2129 children.push(Node::UseItem(&node.item));
2130
2131 children
2132 }
2133 Node::MixedUseItemList(node) => {
2134 let mut children = vec![Node::Identifier(&node.namespace)];
2135
2136 children.extend(node.items.iter().map(Node::MaybeTypedUseItem));
2137
2138 children
2139 }
2140 Node::TypedUseItemList(node) => {
2141 let mut children = vec![Node::UseType(&node.r#type), Node::Identifier(&node.namespace)];
2142
2143 children.extend(node.items.iter().map(Node::UseItem));
2144
2145 children
2146 }
2147 Node::TypedUseItemSequence(node) => {
2148 let mut children = vec![Node::UseType(&node.r#type)];
2149
2150 children.extend(node.items.iter().map(Node::UseItem));
2151 children
2152 }
2153 Node::Use(node) => {
2154 vec![Node::Keyword(&node.r#use), Node::UseItems(&node.items), Node::Terminator(&node.terminator)]
2155 }
2156 Node::UseItem(node) => {
2157 let mut result = vec![Node::Identifier(&node.name)];
2158
2159 if let Some(alias) = &node.alias {
2160 result.push(Node::UseItemAlias(alias));
2161 }
2162
2163 result
2164 }
2165 Node::UseItemAlias(node) => {
2166 vec![Node::Keyword(&node.r#as), Node::LocalIdentifier(&node.identifier)]
2167 }
2168 Node::UseItemSequence(node) => {
2169 let mut children = vec![];
2170 for item in &node.items {
2171 children.push(Node::UseItem(item));
2172 }
2173
2174 children
2175 }
2176 Node::UseItems(node) => vec![match node {
2177 UseItems::Sequence(node) => Node::UseItemSequence(node),
2178 UseItems::TypedList(node) => Node::TypedUseItemList(node),
2179 UseItems::MixedList(node) => Node::MixedUseItemList(node),
2180 UseItems::TypedSequence(node) => Node::TypedUseItemSequence(node),
2181 }],
2182 Node::UseType(node) => vec![match node {
2183 UseType::Const(node) => Node::Keyword(node),
2184 UseType::Function(node) => Node::Keyword(node),
2185 }],
2186 Node::Yield(node) => vec![match node {
2187 Yield::Value(node) => Node::YieldValue(node),
2188 Yield::Pair(node) => Node::YieldPair(node),
2189 Yield::From(node) => Node::YieldFrom(node),
2190 }],
2191 Node::YieldFrom(node) => {
2192 vec![Node::Keyword(&node.r#yield), Node::Keyword(&node.from), Node::Expression(node.iterator)]
2193 }
2194 Node::YieldPair(node) => {
2195 vec![Node::Keyword(&node.r#yield), Node::Expression(node.key), Node::Expression(node.value)]
2196 }
2197 Node::YieldValue(node) => match &node.value {
2198 Some(value) => vec![Node::Keyword(&node.r#yield), Node::Expression(value)],
2199 None => vec![Node::Keyword(&node.r#yield)],
2200 },
2201 Node::Statement(node) => match &node {
2202 Statement::OpeningTag(node) => vec![Node::OpeningTag(node)],
2203 Statement::ClosingTag(node) => vec![Node::ClosingTag(node)],
2204 Statement::Inline(node) => vec![Node::Inline(node)],
2205 Statement::Namespace(node) => vec![Node::Namespace(node)],
2206 Statement::Use(node) => vec![Node::Use(node)],
2207 Statement::Class(node) => vec![Node::Class(node)],
2208 Statement::Interface(node) => vec![Node::Interface(node)],
2209 Statement::Trait(node) => vec![Node::Trait(node)],
2210 Statement::Enum(node) => vec![Node::Enum(node)],
2211 Statement::Block(node) => vec![Node::Block(node)],
2212 Statement::Constant(node) => vec![Node::Constant(node)],
2213 Statement::Function(node) => vec![Node::Function(node)],
2214 Statement::Declare(node) => vec![Node::Declare(node)],
2215 Statement::Goto(node) => vec![Node::Goto(node)],
2216 Statement::Label(node) => vec![Node::Label(node)],
2217 Statement::Try(node) => vec![Node::Try(node)],
2218 Statement::Foreach(node) => vec![Node::Foreach(node)],
2219 Statement::For(node) => vec![Node::For(node)],
2220 Statement::While(node) => vec![Node::While(node)],
2221 Statement::DoWhile(node) => vec![Node::DoWhile(node)],
2222 Statement::Continue(node) => vec![Node::Continue(node)],
2223 Statement::Break(node) => vec![Node::Break(node)],
2224 Statement::Switch(node) => vec![Node::Switch(node)],
2225 Statement::If(node) => vec![Node::If(node)],
2226 Statement::Return(node) => vec![Node::Return(node)],
2227 Statement::Expression(node) => vec![Node::ExpressionStatement(node)],
2228 Statement::EchoTag(node) => vec![Node::EchoTag(node)],
2229 Statement::Echo(node) => vec![Node::Echo(node)],
2230 Statement::Global(node) => vec![Node::Global(node)],
2231 Statement::Static(node) => vec![Node::Static(node)],
2232 Statement::HaltCompiler(node) => vec![Node::HaltCompiler(node)],
2233 Statement::Unset(node) => vec![Node::Unset(node)],
2234 Statement::Noop(_) => vec![],
2235 },
2236 Node::ExpressionStatement(node) => {
2237 vec![Node::Expression(node.expression), Node::Terminator(&node.terminator)]
2238 }
2239 Node::BracedExpressionStringPart(node) => vec![Node::Expression(node.expression)],
2240 Node::DocumentString(node) => {
2241 let mut children = vec![];
2242 for part in node.parts.as_slice() {
2243 children.push(Node::StringPart(part));
2244 }
2245
2246 children
2247 }
2248 Node::InterpolatedString(node) => {
2249 let mut children = vec![];
2250 for part in node.parts.as_slice() {
2251 children.push(Node::StringPart(part));
2252 }
2253
2254 children
2255 }
2256 Node::LiteralStringPart(_) => vec![],
2257 Node::ShellExecuteString(node) => {
2258 let mut children = vec![];
2259 for part in node.parts.as_slice() {
2260 children.push(Node::StringPart(part));
2261 }
2262
2263 children
2264 }
2265 Node::CompositeString(node) => vec![match node {
2266 CompositeString::ShellExecute(node) => Node::ShellExecuteString(node),
2267 CompositeString::Interpolated(node) => Node::InterpolatedString(node),
2268 CompositeString::Document(node) => Node::DocumentString(node),
2269 }],
2270 Node::StringPart(node) => vec![match node {
2271 StringPart::Literal(node) => Node::LiteralStringPart(node),
2272 StringPart::Expression(node) => Node::Expression(node),
2273 StringPart::BracedExpression(node) => Node::BracedExpressionStringPart(node),
2274 }],
2275 Node::ClosingTag(_) => vec![],
2276 Node::FullOpeningTag(_) => vec![],
2277 Node::OpeningTag(node) => match node {
2278 OpeningTag::Full(node) => vec![Node::FullOpeningTag(node)],
2279 OpeningTag::Short(node) => vec![Node::ShortOpeningTag(node)],
2280 },
2281 Node::ShortOpeningTag(_) => vec![],
2282 Node::Terminator(node) => match node {
2283 Terminator::Semicolon(_) => vec![],
2284 Terminator::ClosingTag(closing_tag) => vec![Node::ClosingTag(closing_tag)],
2285 Terminator::TagPair(closing_tag, opening_tag) => {
2286 vec![Node::ClosingTag(closing_tag), Node::OpeningTag(opening_tag)]
2287 }
2288 Terminator::Missing(span) => vec![Node::MissingTerminator(*span)],
2289 },
2290 Node::Throw(node) => vec![Node::Keyword(&node.throw), Node::Expression(node.exception)],
2291 Node::Hint(node) => match &node {
2292 Hint::Identifier(identifier) => vec![Node::Identifier(identifier)],
2293 Hint::Parenthesized(parenthesized_hint) => {
2294 vec![Node::ParenthesizedHint(parenthesized_hint)]
2295 }
2296 Hint::Nullable(nullable_hint) => vec![Node::NullableHint(nullable_hint)],
2297 Hint::Union(union_hint) => vec![Node::UnionHint(union_hint)],
2298 Hint::Intersection(intersection_hint) => vec![Node::IntersectionHint(intersection_hint)],
2299 Hint::Null(keyword)
2300 | Hint::True(keyword)
2301 | Hint::False(keyword)
2302 | Hint::Array(keyword)
2303 | Hint::Callable(keyword)
2304 | Hint::Static(keyword)
2305 | Hint::Self_(keyword)
2306 | Hint::Parent(keyword) => vec![Node::Keyword(keyword)],
2307 Hint::Void(local_identifier)
2308 | Hint::Never(local_identifier)
2309 | Hint::Float(local_identifier)
2310 | Hint::Bool(local_identifier)
2311 | Hint::Integer(local_identifier)
2312 | Hint::String(local_identifier)
2313 | Hint::Object(local_identifier)
2314 | Hint::Mixed(local_identifier)
2315 | Hint::Iterable(local_identifier) => vec![Node::LocalIdentifier(local_identifier)],
2316 },
2317 Node::IntersectionHint(node) => vec![Node::Hint(node.left), Node::Hint(node.right)],
2318 Node::NullableHint(node) => vec![Node::Hint(node.hint)],
2319 Node::ParenthesizedHint(node) => vec![Node::Hint(node.hint)],
2320 Node::UnionHint(node) => vec![Node::Hint(node.left), Node::Hint(node.right)],
2321 Node::Unset(node) => {
2322 let mut children = vec![Node::Keyword(&node.unset)];
2323 children.extend(node.values.iter().map(|e| Node::Expression(e)));
2324 children.push(Node::Terminator(&node.terminator));
2325
2326 children
2327 }
2328 Node::DirectVariable(_) => vec![],
2329 Node::IndirectVariable(node) => vec![Node::Expression(node.expression)],
2330 Node::NestedVariable(node) => {
2331 vec![Node::Variable(node.variable)]
2332 }
2333 Node::Variable(node) => match node {
2334 Variable::Direct(node) => vec![Node::DirectVariable(node)],
2335 Variable::Indirect(node) => vec![Node::IndirectVariable(node)],
2336 Variable::Nested(node) => vec![Node::NestedVariable(node)],
2337 },
2338 Node::Pipe(pipe) => {
2339 vec![Node::Expression(pipe.input), Node::Expression(pipe.callable)]
2340 }
2341 Node::Error(_)
2342 | Node::MissingTerminator(_)
2343 | Node::ClassLikeMemberMissingSelector(_)
2344 | Node::ClassLikeConstantMissingSelector(_) => vec![],
2345 }
2346 }
2347}
2348
2349impl HasSpan for Node<'_, '_> {
2350 fn span(&self) -> Span {
2351 match self {
2352 Self::Program(node) => node.span(),
2353 Self::Access(node) => node.span(),
2354 Self::ConstantAccess(node) => node.span(),
2355 Self::ClassConstantAccess(node) => node.span(),
2356 Self::NullSafePropertyAccess(node) => node.span(),
2357 Self::PropertyAccess(node) => node.span(),
2358 Self::StaticPropertyAccess(node) => node.span(),
2359 Self::Argument(node) => node.span(),
2360 Self::ArgumentList(node) => node.span(),
2361 Self::PartialArgument(node) => node.span(),
2362 Self::PartialArgumentList(node) => node.span(),
2363 Self::NamedArgument(node) => node.span(),
2364 Self::NamedPlaceholderArgument(node) => node.span(),
2365 Self::PlaceholderArgument(node) => node.span(),
2366 Self::PositionalArgument(node) => node.span(),
2367 Self::VariadicPlaceholderArgument(node) => node.span(),
2368 Self::Array(node) => node.span(),
2369 Self::ArrayAccess(node) => node.span(),
2370 Self::ArrayAppend(node) => node.span(),
2371 Self::ArrayElement(node) => node.span(),
2372 Self::KeyValueArrayElement(node) => node.span(),
2373 Self::LegacyArray(node) => node.span(),
2374 Self::List(node) => node.span(),
2375 Self::MissingArrayElement(node) => node.span(),
2376 Self::ValueArrayElement(node) => node.span(),
2377 Self::VariadicArrayElement(node) => node.span(),
2378 Self::Attribute(node) => node.span(),
2379 Self::AttributeList(node) => node.span(),
2380 Self::Block(node) => node.span(),
2381 Self::Call(node) => node.span(),
2382 Self::FunctionCall(node) => node.span(),
2383 Self::MethodCall(node) => node.span(),
2384 Self::NullSafeMethodCall(node) => node.span(),
2385 Self::StaticMethodCall(node) => node.span(),
2386 Self::PartialApplication(node) => node.span(),
2387 Self::FunctionPartialApplication(node) => node.span(),
2388 Self::MethodPartialApplication(node) => node.span(),
2389 Self::StaticMethodPartialApplication(node) => node.span(),
2390 Self::ClassLikeConstant(node) => node.span(),
2391 Self::ClassLikeConstantItem(node) => node.span(),
2392 Self::EnumCase(node) => node.span(),
2393 Self::EnumCaseBackedItem(node) => node.span(),
2394 Self::EnumCaseItem(node) => node.span(),
2395 Self::EnumCaseUnitItem(node) => node.span(),
2396 Self::Extends(node) => node.span(),
2397 Self::Implements(node) => node.span(),
2398 Self::ClassLikeConstantSelector(node) => node.span(),
2399 Self::ClassLikeMember(node) => node.span(),
2400 Self::ClassLikeMemberExpressionSelector(node) => node.span(),
2401 Self::ClassLikeMemberSelector(node) => node.span(),
2402 Self::Method(node) => node.span(),
2403 Self::MethodAbstractBody(node) => node.span(),
2404 Self::MethodBody(node) => node.span(),
2405 Self::HookedProperty(node) => node.span(),
2406 Self::PlainProperty(node) => node.span(),
2407 Self::Property(node) => node.span(),
2408 Self::PropertyAbstractItem(node) => node.span(),
2409 Self::PropertyConcreteItem(node) => node.span(),
2410 Self::PropertyHook(node) => node.span(),
2411 Self::PropertyHookAbstractBody(node) => node.span(),
2412 Self::PropertyHookBody(node) => node.span(),
2413 Self::PropertyHookConcreteBody(node) => node.span(),
2414 Self::PropertyHookConcreteExpressionBody(node) => node.span(),
2415 Self::PropertyHookList(node) => node.span(),
2416 Self::PropertyItem(node) => node.span(),
2417 Self::TraitUse(node) => node.span(),
2418 Self::TraitUseAbsoluteMethodReference(node) => node.span(),
2419 Self::TraitUseAbstractSpecification(node) => node.span(),
2420 Self::TraitUseAdaptation(node) => node.span(),
2421 Self::TraitUseAliasAdaptation(node) => node.span(),
2422 Self::TraitUseConcreteSpecification(node) => node.span(),
2423 Self::TraitUseMethodReference(node) => node.span(),
2424 Self::TraitUsePrecedenceAdaptation(node) => node.span(),
2425 Self::TraitUseSpecification(node) => node.span(),
2426 Self::AnonymousClass(node) => node.span(),
2427 Self::Class(node) => node.span(),
2428 Self::Enum(node) => node.span(),
2429 Self::EnumBackingTypeHint(node) => node.span(),
2430 Self::Interface(node) => node.span(),
2431 Self::Trait(node) => node.span(),
2432 Self::Clone(node) => node.span(),
2433 Self::Constant(node) => node.span(),
2434 Self::ConstantItem(node) => node.span(),
2435 Self::Construct(node) => node.span(),
2436 Self::DieConstruct(node) => node.span(),
2437 Self::EmptyConstruct(node) => node.span(),
2438 Self::EvalConstruct(node) => node.span(),
2439 Self::ExitConstruct(node) => node.span(),
2440 Self::IncludeConstruct(node) => node.span(),
2441 Self::IncludeOnceConstruct(node) => node.span(),
2442 Self::IssetConstruct(node) => node.span(),
2443 Self::PrintConstruct(node) => node.span(),
2444 Self::RequireConstruct(node) => node.span(),
2445 Self::RequireOnceConstruct(node) => node.span(),
2446 Self::If(node) => node.span(),
2447 Self::IfBody(node) => node.span(),
2448 Self::IfColonDelimitedBody(node) => node.span(),
2449 Self::IfColonDelimitedBodyElseClause(node) => node.span(),
2450 Self::IfColonDelimitedBodyElseIfClause(node) => node.span(),
2451 Self::IfStatementBody(node) => node.span(),
2452 Self::IfStatementBodyElseClause(node) => node.span(),
2453 Self::IfStatementBodyElseIfClause(node) => node.span(),
2454 Self::Match(node) => node.span(),
2455 Self::MatchArm(node) => node.span(),
2456 Self::MatchDefaultArm(node) => node.span(),
2457 Self::MatchExpressionArm(node) => node.span(),
2458 Self::Switch(node) => node.span(),
2459 Self::SwitchBody(node) => node.span(),
2460 Self::SwitchBraceDelimitedBody(node) => node.span(),
2461 Self::SwitchCase(node) => node.span(),
2462 Self::SwitchCaseSeparator(node) => node.span(),
2463 Self::SwitchColonDelimitedBody(node) => node.span(),
2464 Self::SwitchDefaultCase(node) => node.span(),
2465 Self::SwitchExpressionCase(node) => node.span(),
2466 Self::Declare(node) => node.span(),
2467 Self::DeclareBody(node) => node.span(),
2468 Self::DeclareColonDelimitedBody(node) => node.span(),
2469 Self::DeclareItem(node) => node.span(),
2470 Self::Echo(node) => node.span(),
2471 Self::Expression(node) => node.span(),
2472 Self::Binary(node) => node.span(),
2473 Self::BinaryOperator(node) => node.span(),
2474 Self::UnaryPrefix(node) => node.span(),
2475 Self::UnaryPrefixOperator(node) => node.span(),
2476 Self::UnaryPostfix(node) => node.span(),
2477 Self::UnaryPostfixOperator(node) => node.span(),
2478 Self::Parenthesized(node) => node.span(),
2479 Self::ArrowFunction(node) => node.span(),
2480 Self::Closure(node) => node.span(),
2481 Self::ClosureUseClause(node) => node.span(),
2482 Self::ClosureUseClauseVariable(node) => node.span(),
2483 Self::Function(node) => node.span(),
2484 Self::FunctionLikeParameter(node) => node.span(),
2485 Self::FunctionLikeParameterDefaultValue(node) => node.span(),
2486 Self::FunctionLikeParameterList(node) => node.span(),
2487 Self::FunctionLikeReturnTypeHint(node) => node.span(),
2488 Self::Global(node) => node.span(),
2489 Self::Goto(node) => node.span(),
2490 Self::Label(node) => node.span(),
2491 Self::HaltCompiler(node) => node.span(),
2492 Self::FullyQualifiedIdentifier(node) => node.span(),
2493 Self::Identifier(node) => node.span(),
2494 Self::LocalIdentifier(node) => node.span(),
2495 Self::QualifiedIdentifier(node) => node.span(),
2496 Self::Inline(node) => node.span(),
2497 Self::Instantiation(node) => node.span(),
2498 Self::Keyword(node) => node.span(),
2499 Self::Literal(node) => node.span(),
2500 Self::LiteralFloat(node) => node.span(),
2501 Self::LiteralInteger(node) => node.span(),
2502 Self::LiteralString(node) => node.span(),
2503 Self::MagicConstant(node) => node.span(),
2504 Self::Modifier(node) => node.span(),
2505 Self::Namespace(node) => node.span(),
2506 Self::NamespaceBody(node) => node.span(),
2507 Self::NamespaceImplicitBody(node) => node.span(),
2508 Self::Assignment(node) => node.span(),
2509 Self::AssignmentOperator(node) => node.span(),
2510 Self::Conditional(node) => node.span(),
2511 Self::DoWhile(node) => node.span(),
2512 Self::Foreach(node) => node.span(),
2513 Self::ForeachBody(node) => node.span(),
2514 Self::ForeachColonDelimitedBody(node) => node.span(),
2515 Self::ForeachKeyValueTarget(node) => node.span(),
2516 Self::ForeachTarget(node) => node.span(),
2517 Self::ForeachValueTarget(node) => node.span(),
2518 Self::For(node) => node.span(),
2519 Self::ForBody(node) => node.span(),
2520 Self::ForColonDelimitedBody(node) => node.span(),
2521 Self::While(node) => node.span(),
2522 Self::WhileBody(node) => node.span(),
2523 Self::WhileColonDelimitedBody(node) => node.span(),
2524 Self::Break(node) => node.span(),
2525 Self::Continue(node) => node.span(),
2526 Self::Return(node) => node.span(),
2527 Self::Static(node) => node.span(),
2528 Self::StaticAbstractItem(node) => node.span(),
2529 Self::StaticConcreteItem(node) => node.span(),
2530 Self::StaticItem(node) => node.span(),
2531 Self::Try(node) => node.span(),
2532 Self::TryCatchClause(node) => node.span(),
2533 Self::TryFinallyClause(node) => node.span(),
2534 Self::MaybeTypedUseItem(node) => node.span(),
2535 Self::MixedUseItemList(node) => node.span(),
2536 Self::TypedUseItemList(node) => node.span(),
2537 Self::TypedUseItemSequence(node) => node.span(),
2538 Self::Use(node) => node.span(),
2539 Self::UseItem(node) => node.span(),
2540 Self::UseItemAlias(node) => node.span(),
2541 Self::UseItemSequence(node) => node.span(),
2542 Self::UseItems(node) => node.span(),
2543 Self::UseType(node) => node.span(),
2544 Self::Yield(node) => node.span(),
2545 Self::YieldFrom(node) => node.span(),
2546 Self::YieldPair(node) => node.span(),
2547 Self::YieldValue(node) => node.span(),
2548 Self::Statement(node) => node.span(),
2549 Self::ExpressionStatement(node) => node.span(),
2550 Self::BracedExpressionStringPart(node) => node.span(),
2551 Self::DocumentString(node) => node.span(),
2552 Self::InterpolatedString(node) => node.span(),
2553 Self::LiteralStringPart(node) => node.span(),
2554 Self::ShellExecuteString(node) => node.span(),
2555 Self::CompositeString(node) => node.span(),
2556 Self::StringPart(node) => node.span(),
2557 Self::ClosingTag(node) => node.span(),
2558 Self::EchoTag(node) => node.span(),
2559 Self::FullOpeningTag(node) => node.span(),
2560 Self::OpeningTag(node) => node.span(),
2561 Self::ShortOpeningTag(node) => node.span(),
2562 Self::Terminator(node) => node.span(),
2563 Self::Throw(node) => node.span(),
2564 Self::Hint(node) => node.span(),
2565 Self::IntersectionHint(node) => node.span(),
2566 Self::NullableHint(node) => node.span(),
2567 Self::ParenthesizedHint(node) => node.span(),
2568 Self::UnionHint(node) => node.span(),
2569 Self::Unset(node) => node.span(),
2570 Self::DirectVariable(node) => node.span(),
2571 Self::IndirectVariable(node) => node.span(),
2572 Self::NestedVariable(node) => node.span(),
2573 Self::Variable(node) => node.span(),
2574 Self::Pipe(node) => node.span(),
2575 Self::Error(span)
2576 | Self::MissingTerminator(span)
2577 | Self::ClassLikeMemberMissingSelector(span)
2578 | Self::ClassLikeConstantMissingSelector(span) => *span,
2579 }
2580 }
2581}