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