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