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