mago_syntax/cst/

node.rs

use std::fmt::Debug;

use strum::Display;
use strum::EnumIter;
use strum::EnumString;

use mago_span::HasSpan;
use mago_span::Span;

use crate::cst::Program;
use crate::cst::cst::Access;
use crate::cst::cst::AnonymousClass;
use crate::cst::cst::Argument;
use crate::cst::cst::ArgumentList;
use crate::cst::cst::Array;
use crate::cst::cst::ArrayAccess;
use crate::cst::cst::ArrayAppend;
use crate::cst::cst::ArrayElement;
use crate::cst::cst::ArrowFunction;
use crate::cst::cst::Assignment;
use crate::cst::cst::AssignmentOperator;
use crate::cst::cst::Attribute;
use crate::cst::cst::AttributeList;
use crate::cst::cst::Binary;
use crate::cst::cst::BinaryOperator;
use crate::cst::cst::Block;
use crate::cst::cst::BracedExpressionStringPart;
use crate::cst::cst::Break;
use crate::cst::cst::Call;
use crate::cst::cst::Class;
use crate::cst::cst::ClassConstantAccess;
use crate::cst::cst::ClassLikeConstant;
use crate::cst::cst::ClassLikeConstantItem;
use crate::cst::cst::ClassLikeConstantSelector;
use crate::cst::cst::ClassLikeMember;
use crate::cst::cst::ClassLikeMemberExpressionSelector;
use crate::cst::cst::ClassLikeMemberSelector;
use crate::cst::cst::Clone;
use crate::cst::cst::ClosingTag;
use crate::cst::cst::Closure;
use crate::cst::cst::ClosureUseClause;
use crate::cst::cst::ClosureUseClauseVariable;
use crate::cst::cst::CompositeString;
use crate::cst::cst::Conditional;
use crate::cst::cst::Constant;
use crate::cst::cst::ConstantAccess;
use crate::cst::cst::ConstantItem;
use crate::cst::cst::Construct;
use crate::cst::cst::Continue;
use crate::cst::cst::Declare;
use crate::cst::cst::DeclareBody;
use crate::cst::cst::DeclareColonDelimitedBody;
use crate::cst::cst::DeclareItem;
use crate::cst::cst::DieConstruct;
use crate::cst::cst::DirectVariable;
use crate::cst::cst::DoWhile;
use crate::cst::cst::DocumentString;
use crate::cst::cst::Echo;
use crate::cst::cst::EchoTag;
use crate::cst::cst::EmptyConstruct;
use crate::cst::cst::Enum;
use crate::cst::cst::EnumBackingTypeHint;
use crate::cst::cst::EnumCase;
use crate::cst::cst::EnumCaseBackedItem;
use crate::cst::cst::EnumCaseItem;
use crate::cst::cst::EnumCaseUnitItem;
use crate::cst::cst::EvalConstruct;
use crate::cst::cst::ExitConstruct;
use crate::cst::cst::Expression;
use crate::cst::cst::ExpressionStatement;
use crate::cst::cst::Extends;
use crate::cst::cst::For;
use crate::cst::cst::ForBody;
use crate::cst::cst::ForColonDelimitedBody;
use crate::cst::cst::Foreach;
use crate::cst::cst::ForeachBody;
use crate::cst::cst::ForeachColonDelimitedBody;
use crate::cst::cst::ForeachKeyValueTarget;
use crate::cst::cst::ForeachTarget;
use crate::cst::cst::ForeachValueTarget;
use crate::cst::cst::FullOpeningTag;
use crate::cst::cst::FullyQualifiedIdentifier;
use crate::cst::cst::Function;
use crate::cst::cst::FunctionCall;
use crate::cst::cst::FunctionLikeParameter;
use crate::cst::cst::FunctionLikeParameterDefaultValue;
use crate::cst::cst::FunctionLikeParameterList;
use crate::cst::cst::FunctionLikeReturnTypeHint;
use crate::cst::cst::FunctionPartialApplication;
use crate::cst::cst::Global;
use crate::cst::cst::Goto;
use crate::cst::cst::HaltCompiler;
use crate::cst::cst::Hint;
use crate::cst::cst::HookedProperty;
use crate::cst::cst::Identifier;
use crate::cst::cst::If;
use crate::cst::cst::IfBody;
use crate::cst::cst::IfColonDelimitedBody;
use crate::cst::cst::IfColonDelimitedBodyElseClause;
use crate::cst::cst::IfColonDelimitedBodyElseIfClause;
use crate::cst::cst::IfStatementBody;
use crate::cst::cst::IfStatementBodyElseClause;
use crate::cst::cst::IfStatementBodyElseIfClause;
use crate::cst::cst::Implements;
use crate::cst::cst::IncludeConstruct;
use crate::cst::cst::IncludeOnceConstruct;
use crate::cst::cst::IndirectVariable;
use crate::cst::cst::Inline;
use crate::cst::cst::Instantiation;
use crate::cst::cst::Interface;
use crate::cst::cst::InterpolatedString;
use crate::cst::cst::IntersectionHint;
use crate::cst::cst::IssetConstruct;
use crate::cst::cst::KeyValueArrayElement;
use crate::cst::cst::Keyword;
use crate::cst::cst::Label;
use crate::cst::cst::LegacyArray;
use crate::cst::cst::List;
use crate::cst::cst::Literal;
use crate::cst::cst::LiteralFloat;
use crate::cst::cst::LiteralInteger;
use crate::cst::cst::LiteralString;
use crate::cst::cst::LiteralStringPart;
use crate::cst::cst::LocalIdentifier;
use crate::cst::cst::MagicConstant;
use crate::cst::cst::Match;
use crate::cst::cst::MatchArm;
use crate::cst::cst::MatchDefaultArm;
use crate::cst::cst::MatchExpressionArm;
use crate::cst::cst::MaybeTypedUseItem;
use crate::cst::cst::Method;
use crate::cst::cst::MethodAbstractBody;
use crate::cst::cst::MethodBody;
use crate::cst::cst::MethodCall;
use crate::cst::cst::MethodPartialApplication;
use crate::cst::cst::MissingArrayElement;
use crate::cst::cst::MixedUseItemList;
use crate::cst::cst::Modifier;
use crate::cst::cst::NamedArgument;
use crate::cst::cst::NamedPlaceholderArgument;
use crate::cst::cst::Namespace;
use crate::cst::cst::NamespaceBody;
use crate::cst::cst::NamespaceImplicitBody;
use crate::cst::cst::NestedVariable;
use crate::cst::cst::NullSafeMethodCall;
use crate::cst::cst::NullSafePropertyAccess;
use crate::cst::cst::NullableHint;
use crate::cst::cst::OpeningTag;
use crate::cst::cst::Parenthesized;
use crate::cst::cst::ParenthesizedHint;
use crate::cst::cst::PartialApplication;
use crate::cst::cst::PartialArgument;
use crate::cst::cst::PartialArgumentList;
use crate::cst::cst::Pipe;
use crate::cst::cst::PlaceholderArgument;
use crate::cst::cst::PlainProperty;
use crate::cst::cst::PositionalArgument;
use crate::cst::cst::PrintConstruct;
use crate::cst::cst::Property;
use crate::cst::cst::PropertyAbstractItem;
use crate::cst::cst::PropertyAccess;
use crate::cst::cst::PropertyConcreteItem;
use crate::cst::cst::PropertyHook;
use crate::cst::cst::PropertyHookAbstractBody;
use crate::cst::cst::PropertyHookBody;
use crate::cst::cst::PropertyHookConcreteBody;
use crate::cst::cst::PropertyHookConcreteExpressionBody;
use crate::cst::cst::PropertyHookList;
use crate::cst::cst::PropertyItem;
use crate::cst::cst::QualifiedIdentifier;
use crate::cst::cst::RequireConstruct;
use crate::cst::cst::RequireOnceConstruct;
use crate::cst::cst::Return;
use crate::cst::cst::ShellExecuteString;
use crate::cst::cst::ShortOpeningTag;
use crate::cst::cst::Statement;
use crate::cst::cst::Static;
use crate::cst::cst::StaticAbstractItem;
use crate::cst::cst::StaticConcreteItem;
use crate::cst::cst::StaticItem;
use crate::cst::cst::StaticMethodCall;
use crate::cst::cst::StaticMethodPartialApplication;
use crate::cst::cst::StaticPropertyAccess;
use crate::cst::cst::StringPart;
use crate::cst::cst::Switch;
use crate::cst::cst::SwitchBody;
use crate::cst::cst::SwitchBraceDelimitedBody;
use crate::cst::cst::SwitchCase;
use crate::cst::cst::SwitchCaseSeparator;
use crate::cst::cst::SwitchColonDelimitedBody;
use crate::cst::cst::SwitchDefaultCase;
use crate::cst::cst::SwitchExpressionCase;
use crate::cst::cst::Terminator;
use crate::cst::cst::Throw;
use crate::cst::cst::Trait;
use crate::cst::cst::TraitUse;
use crate::cst::cst::TraitUseAbsoluteMethodReference;
use crate::cst::cst::TraitUseAbstractSpecification;
use crate::cst::cst::TraitUseAdaptation;
use crate::cst::cst::TraitUseAliasAdaptation;
use crate::cst::cst::TraitUseConcreteSpecification;
use crate::cst::cst::TraitUseMethodReference;
use crate::cst::cst::TraitUsePrecedenceAdaptation;
use crate::cst::cst::TraitUseSpecification;
use crate::cst::cst::Try;
use crate::cst::cst::TryCatchClause;
use crate::cst::cst::TryFinallyClause;
use crate::cst::cst::TypedUseItemList;
use crate::cst::cst::TypedUseItemSequence;
use crate::cst::cst::UnaryPostfix;
use crate::cst::cst::UnaryPostfixOperator;
use crate::cst::cst::UnaryPrefix;
use crate::cst::cst::UnaryPrefixOperator;
use crate::cst::cst::UnionHint;
use crate::cst::cst::Unset;
use crate::cst::cst::Use;
use crate::cst::cst::UseItem;
use crate::cst::cst::UseItemAlias;
use crate::cst::cst::UseItemSequence;
use crate::cst::cst::UseItems;
use crate::cst::cst::UseType;
use crate::cst::cst::ValueArrayElement;
use crate::cst::cst::Variable;
use crate::cst::cst::VariadicArrayElement;
use crate::cst::cst::VariadicPlaceholderArgument;
use crate::cst::cst::While;
use crate::cst::cst::WhileBody;
use crate::cst::cst::WhileColonDelimitedBody;
use crate::cst::cst::Yield;
use crate::cst::cst::YieldFrom;
use crate::cst::cst::YieldPair;
use crate::cst::cst::YieldValue;

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, Display, EnumIter, EnumString)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "type", content = "value"))]
#[repr(u8)]
#[non_exhaustive]
pub enum NodeKind {
    Program,
    ConstantAccess,
    Access,
    ClassConstantAccess,
    NullSafePropertyAccess,
    PropertyAccess,
    StaticPropertyAccess,
    Argument,
    ArgumentList,
    PartialArgument,
    PartialArgumentList,
    NamedArgument,
    NamedPlaceholderArgument,
    PlaceholderArgument,
    PositionalArgument,
    VariadicPlaceholderArgument,
    Array,
    ArrayAccess,
    ArrayAppend,
    ArrayElement,
    KeyValueArrayElement,
    LegacyArray,
    List,
    MissingArrayElement,
    ValueArrayElement,
    VariadicArrayElement,
    Attribute,
    AttributeList,
    Block,
    Call,
    FunctionCall,
    MethodCall,
    NullSafeMethodCall,
    StaticMethodCall,
    PartialApplication,
    FunctionPartialApplication,
    MethodPartialApplication,
    StaticMethodPartialApplication,
    ClassLikeConstant,
    ClassLikeConstantItem,
    EnumCase,
    EnumCaseBackedItem,
    EnumCaseItem,
    EnumCaseUnitItem,
    Extends,
    Implements,
    ClassLikeConstantSelector,
    ClassLikeMember,
    ClassLikeMemberExpressionSelector,
    ClassLikeMemberSelector,
    Method,
    MethodAbstractBody,
    MethodBody,
    HookedProperty,
    PlainProperty,
    Property,
    PropertyAbstractItem,
    PropertyConcreteItem,
    PropertyHook,
    PropertyHookAbstractBody,
    PropertyHookBody,
    PropertyHookConcreteBody,
    PropertyHookConcreteExpressionBody,
    PropertyHookList,
    PropertyItem,
    TraitUse,
    TraitUseAbsoluteMethodReference,
    TraitUseAbstractSpecification,
    TraitUseAdaptation,
    TraitUseAliasAdaptation,
    TraitUseConcreteSpecification,
    TraitUseMethodReference,
    TraitUsePrecedenceAdaptation,
    TraitUseSpecification,
    AnonymousClass,
    Class,
    Enum,
    EnumBackingTypeHint,
    Interface,
    Trait,
    Clone,
    Constant,
    ConstantItem,
    Construct,
    DieConstruct,
    EmptyConstruct,
    EvalConstruct,
    ExitConstruct,
    IncludeConstruct,
    IncludeOnceConstruct,
    IssetConstruct,
    PrintConstruct,
    RequireConstruct,
    RequireOnceConstruct,
    If,
    IfBody,
    IfColonDelimitedBody,
    IfColonDelimitedBodyElseClause,
    IfColonDelimitedBodyElseIfClause,
    IfStatementBody,
    IfStatementBodyElseClause,
    IfStatementBodyElseIfClause,
    Match,
    MatchArm,
    MatchDefaultArm,
    MatchExpressionArm,
    Switch,
    SwitchBody,
    SwitchBraceDelimitedBody,
    SwitchCase,
    SwitchCaseSeparator,
    SwitchColonDelimitedBody,
    SwitchDefaultCase,
    SwitchExpressionCase,
    Declare,
    DeclareBody,
    DeclareColonDelimitedBody,
    DeclareItem,
    EchoTag,
    Echo,
    Expression,
    Binary,
    BinaryOperator,
    UnaryPrefix,
    UnaryPrefixOperator,
    UnaryPostfix,
    UnaryPostfixOperator,
    Parenthesized,
    ArrowFunction,
    Closure,
    ClosureUseClause,
    ClosureUseClauseVariable,
    Function,
    FunctionLikeParameter,
    FunctionLikeParameterDefaultValue,
    FunctionLikeParameterList,
    FunctionLikeReturnTypeHint,
    Global,
    Goto,
    Label,
    HaltCompiler,
    FullyQualifiedIdentifier,
    Identifier,
    LocalIdentifier,
    QualifiedIdentifier,
    Inline,
    Instantiation,
    Keyword,
    Literal,
    Pipe,
    LiteralFloat,
    LiteralInteger,
    LiteralString,
    MagicConstant,
    Modifier,
    Namespace,
    NamespaceBody,
    NamespaceImplicitBody,
    Assignment,
    AssignmentOperator,
    Conditional,
    DoWhile,
    Foreach,
    ForeachBody,
    ForeachColonDelimitedBody,
    ForeachKeyValueTarget,
    ForeachTarget,
    ForeachValueTarget,
    For,
    ForBody,
    ForColonDelimitedBody,
    While,
    WhileBody,
    WhileColonDelimitedBody,
    Break,
    Continue,
    Return,
    Static,
    StaticAbstractItem,
    StaticConcreteItem,
    StaticItem,
    Try,
    TryCatchClause,
    TryFinallyClause,
    MaybeTypedUseItem,
    MixedUseItemList,
    TypedUseItemList,
    TypedUseItemSequence,
    Use,
    UseItem,
    UseItemAlias,
    UseItemSequence,
    UseItems,
    UseType,
    Yield,
    YieldFrom,
    YieldPair,
    YieldValue,
    Statement,
    ExpressionStatement,
    BracedExpressionStringPart,
    DocumentString,
    InterpolatedString,
    LiteralStringPart,
    ShellExecuteString,
    CompositeString,
    StringPart,
    ClosingTag,
    FullOpeningTag,
    OpeningTag,
    ShortOpeningTag,
    Terminator,
    Throw,
    Hint,
    IntersectionHint,
    NullableHint,
    ParenthesizedHint,
    UnionHint,
    Unset,
    DirectVariable,
    IndirectVariable,
    NestedVariable,
    Variable,
    Error,
    MissingTerminator,
    ClassLikeMemberMissingSelector,
    ClassLikeConstantMissingSelector,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, Display)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(tag = "type", content = "value"))]
#[repr(u8)]
#[non_exhaustive]
pub enum Node<'ast, 'arena> {
    Program(&'ast Program<'arena>),
    Access(&'ast Access<'arena>),
    ConstantAccess(&'ast ConstantAccess<'arena>),
    ClassConstantAccess(&'ast ClassConstantAccess<'arena>),
    NullSafePropertyAccess(&'ast NullSafePropertyAccess<'arena>),
    PropertyAccess(&'ast PropertyAccess<'arena>),
    StaticPropertyAccess(&'ast StaticPropertyAccess<'arena>),
    Argument(&'ast Argument<'arena>),
    ArgumentList(&'ast ArgumentList<'arena>),
    PartialArgument(&'ast PartialArgument<'arena>),
    PartialArgumentList(&'ast PartialArgumentList<'arena>),
    NamedArgument(&'ast NamedArgument<'arena>),
    NamedPlaceholderArgument(&'ast NamedPlaceholderArgument<'arena>),
    PlaceholderArgument(&'ast PlaceholderArgument),
    PositionalArgument(&'ast PositionalArgument<'arena>),
    VariadicPlaceholderArgument(&'ast VariadicPlaceholderArgument),
    Array(&'ast Array<'arena>),
    ArrayAccess(&'ast ArrayAccess<'arena>),
    ArrayAppend(&'ast ArrayAppend<'arena>),
    ArrayElement(&'ast ArrayElement<'arena>),
    KeyValueArrayElement(&'ast KeyValueArrayElement<'arena>),
    LegacyArray(&'ast LegacyArray<'arena>),
    List(&'ast List<'arena>),
    MissingArrayElement(&'ast MissingArrayElement),
    ValueArrayElement(&'ast ValueArrayElement<'arena>),
    VariadicArrayElement(&'ast VariadicArrayElement<'arena>),
    Attribute(&'ast Attribute<'arena>),
    AttributeList(&'ast AttributeList<'arena>),
    Block(&'ast Block<'arena>),
    Call(&'ast Call<'arena>),
    FunctionCall(&'ast FunctionCall<'arena>),
    MethodCall(&'ast MethodCall<'arena>),
    NullSafeMethodCall(&'ast NullSafeMethodCall<'arena>),
    StaticMethodCall(&'ast StaticMethodCall<'arena>),
    PartialApplication(&'ast PartialApplication<'arena>),
    FunctionPartialApplication(&'ast FunctionPartialApplication<'arena>),
    MethodPartialApplication(&'ast MethodPartialApplication<'arena>),
    StaticMethodPartialApplication(&'ast StaticMethodPartialApplication<'arena>),
    ClassLikeConstant(&'ast ClassLikeConstant<'arena>),
    ClassLikeConstantItem(&'ast ClassLikeConstantItem<'arena>),
    EnumCase(&'ast EnumCase<'arena>),
    EnumCaseBackedItem(&'ast EnumCaseBackedItem<'arena>),
    EnumCaseItem(&'ast EnumCaseItem<'arena>),
    EnumCaseUnitItem(&'ast EnumCaseUnitItem<'arena>),
    Extends(&'ast Extends<'arena>),
    Implements(&'ast Implements<'arena>),
    ClassLikeConstantSelector(&'ast ClassLikeConstantSelector<'arena>),
    ClassLikeMember(&'ast ClassLikeMember<'arena>),
    ClassLikeMemberExpressionSelector(&'ast ClassLikeMemberExpressionSelector<'arena>),
    ClassLikeMemberSelector(&'ast ClassLikeMemberSelector<'arena>),
    Method(&'ast Method<'arena>),
    MethodAbstractBody(&'ast MethodAbstractBody<'arena>),
    MethodBody(&'ast MethodBody<'arena>),
    HookedProperty(&'ast HookedProperty<'arena>),
    PlainProperty(&'ast PlainProperty<'arena>),
    Property(&'ast Property<'arena>),
    PropertyAbstractItem(&'ast PropertyAbstractItem<'arena>),
    PropertyConcreteItem(&'ast PropertyConcreteItem<'arena>),
    PropertyHook(&'ast PropertyHook<'arena>),
    PropertyHookAbstractBody(&'ast PropertyHookAbstractBody),
    PropertyHookBody(&'ast PropertyHookBody<'arena>),
    PropertyHookConcreteBody(&'ast PropertyHookConcreteBody<'arena>),
    PropertyHookConcreteExpressionBody(&'ast PropertyHookConcreteExpressionBody<'arena>),
    PropertyHookList(&'ast PropertyHookList<'arena>),
    PropertyItem(&'ast PropertyItem<'arena>),
    TraitUse(&'ast TraitUse<'arena>),
    TraitUseAbsoluteMethodReference(&'ast TraitUseAbsoluteMethodReference<'arena>),
    TraitUseAbstractSpecification(&'ast TraitUseAbstractSpecification<'arena>),
    TraitUseAdaptation(&'ast TraitUseAdaptation<'arena>),
    TraitUseAliasAdaptation(&'ast TraitUseAliasAdaptation<'arena>),
    TraitUseConcreteSpecification(&'ast TraitUseConcreteSpecification<'arena>),
    TraitUseMethodReference(&'ast TraitUseMethodReference<'arena>),
    TraitUsePrecedenceAdaptation(&'ast TraitUsePrecedenceAdaptation<'arena>),
    TraitUseSpecification(&'ast TraitUseSpecification<'arena>),
    AnonymousClass(&'ast AnonymousClass<'arena>),
    Class(&'ast Class<'arena>),
    Enum(&'ast Enum<'arena>),
    EnumBackingTypeHint(&'ast EnumBackingTypeHint<'arena>),
    Interface(&'ast Interface<'arena>),
    Trait(&'ast Trait<'arena>),
    Clone(&'ast Clone<'arena>),
    Constant(&'ast Constant<'arena>),
    ConstantItem(&'ast ConstantItem<'arena>),
    Construct(&'ast Construct<'arena>),
    DieConstruct(&'ast DieConstruct<'arena>),
    EmptyConstruct(&'ast EmptyConstruct<'arena>),
    EvalConstruct(&'ast EvalConstruct<'arena>),
    ExitConstruct(&'ast ExitConstruct<'arena>),
    IncludeConstruct(&'ast IncludeConstruct<'arena>),
    IncludeOnceConstruct(&'ast IncludeOnceConstruct<'arena>),
    IssetConstruct(&'ast IssetConstruct<'arena>),
    PrintConstruct(&'ast PrintConstruct<'arena>),
    RequireConstruct(&'ast RequireConstruct<'arena>),
    RequireOnceConstruct(&'ast RequireOnceConstruct<'arena>),
    If(&'ast If<'arena>),
    IfBody(&'ast IfBody<'arena>),
    IfColonDelimitedBody(&'ast IfColonDelimitedBody<'arena>),
    IfColonDelimitedBodyElseClause(&'ast IfColonDelimitedBodyElseClause<'arena>),
    IfColonDelimitedBodyElseIfClause(&'ast IfColonDelimitedBodyElseIfClause<'arena>),
    IfStatementBody(&'ast IfStatementBody<'arena>),
    IfStatementBodyElseClause(&'ast IfStatementBodyElseClause<'arena>),
    IfStatementBodyElseIfClause(&'ast IfStatementBodyElseIfClause<'arena>),
    Match(&'ast Match<'arena>),
    MatchArm(&'ast MatchArm<'arena>),
    MatchDefaultArm(&'ast MatchDefaultArm<'arena>),
    MatchExpressionArm(&'ast MatchExpressionArm<'arena>),
    Switch(&'ast Switch<'arena>),
    SwitchBody(&'ast SwitchBody<'arena>),
    SwitchBraceDelimitedBody(&'ast SwitchBraceDelimitedBody<'arena>),
    SwitchCase(&'ast SwitchCase<'arena>),
    SwitchCaseSeparator(&'ast SwitchCaseSeparator),
    SwitchColonDelimitedBody(&'ast SwitchColonDelimitedBody<'arena>),
    SwitchDefaultCase(&'ast SwitchDefaultCase<'arena>),
    SwitchExpressionCase(&'ast SwitchExpressionCase<'arena>),
    Declare(&'ast Declare<'arena>),
    DeclareBody(&'ast DeclareBody<'arena>),
    DeclareColonDelimitedBody(&'ast DeclareColonDelimitedBody<'arena>),
    DeclareItem(&'ast DeclareItem<'arena>),
    EchoTag(&'ast EchoTag<'arena>),
    Echo(&'ast Echo<'arena>),
    Expression(&'ast Expression<'arena>),
    Binary(&'ast Binary<'arena>),
    BinaryOperator(&'ast BinaryOperator<'arena>),
    UnaryPrefix(&'ast UnaryPrefix<'arena>),
    UnaryPrefixOperator(&'ast UnaryPrefixOperator<'arena>),
    UnaryPostfix(&'ast UnaryPostfix<'arena>),
    UnaryPostfixOperator(&'ast UnaryPostfixOperator),
    Parenthesized(&'ast Parenthesized<'arena>),
    ArrowFunction(&'ast ArrowFunction<'arena>),
    Closure(&'ast Closure<'arena>),
    ClosureUseClause(&'ast ClosureUseClause<'arena>),
    ClosureUseClauseVariable(&'ast ClosureUseClauseVariable<'arena>),
    Function(&'ast Function<'arena>),
    FunctionLikeParameter(&'ast FunctionLikeParameter<'arena>),
    FunctionLikeParameterDefaultValue(&'ast FunctionLikeParameterDefaultValue<'arena>),
    FunctionLikeParameterList(&'ast FunctionLikeParameterList<'arena>),
    FunctionLikeReturnTypeHint(&'ast FunctionLikeReturnTypeHint<'arena>),
    Global(&'ast Global<'arena>),
    Goto(&'ast Goto<'arena>),
    Label(&'ast Label<'arena>),
    HaltCompiler(&'ast HaltCompiler<'arena>),
    FullyQualifiedIdentifier(&'ast FullyQualifiedIdentifier<'arena>),
    Identifier(&'ast Identifier<'arena>),
    LocalIdentifier(&'ast LocalIdentifier<'arena>),
    QualifiedIdentifier(&'ast QualifiedIdentifier<'arena>),
    Inline(&'ast Inline<'arena>),
    Instantiation(&'ast Instantiation<'arena>),
    Keyword(&'ast Keyword<'arena>),
    Literal(&'ast Literal<'arena>),
    LiteralFloat(&'ast LiteralFloat<'arena>),
    LiteralInteger(&'ast LiteralInteger<'arena>),
    LiteralString(&'ast LiteralString<'arena>),
    MagicConstant(&'ast MagicConstant<'arena>),
    Modifier(&'ast Modifier<'arena>),
    Namespace(&'ast Namespace<'arena>),
    NamespaceBody(&'ast NamespaceBody<'arena>),
    NamespaceImplicitBody(&'ast NamespaceImplicitBody<'arena>),
    Assignment(&'ast Assignment<'arena>),
    AssignmentOperator(&'ast AssignmentOperator),
    Conditional(&'ast Conditional<'arena>),
    DoWhile(&'ast DoWhile<'arena>),
    Foreach(&'ast Foreach<'arena>),
    ForeachBody(&'ast ForeachBody<'arena>),
    ForeachColonDelimitedBody(&'ast ForeachColonDelimitedBody<'arena>),
    ForeachKeyValueTarget(&'ast ForeachKeyValueTarget<'arena>),
    ForeachTarget(&'ast ForeachTarget<'arena>),
    ForeachValueTarget(&'ast ForeachValueTarget<'arena>),
    For(&'ast For<'arena>),
    ForBody(&'ast ForBody<'arena>),
    ForColonDelimitedBody(&'ast ForColonDelimitedBody<'arena>),
    While(&'ast While<'arena>),
    WhileBody(&'ast WhileBody<'arena>),
    WhileColonDelimitedBody(&'ast WhileColonDelimitedBody<'arena>),
    Break(&'ast Break<'arena>),
    Continue(&'ast Continue<'arena>),
    Return(&'ast Return<'arena>),
    Static(&'ast Static<'arena>),
    StaticAbstractItem(&'ast StaticAbstractItem<'arena>),
    StaticConcreteItem(&'ast StaticConcreteItem<'arena>),
    StaticItem(&'ast StaticItem<'arena>),
    Try(&'ast Try<'arena>),
    TryCatchClause(&'ast TryCatchClause<'arena>),
    TryFinallyClause(&'ast TryFinallyClause<'arena>),
    MaybeTypedUseItem(&'ast MaybeTypedUseItem<'arena>),
    MixedUseItemList(&'ast MixedUseItemList<'arena>),
    TypedUseItemList(&'ast TypedUseItemList<'arena>),
    TypedUseItemSequence(&'ast TypedUseItemSequence<'arena>),
    Use(&'ast Use<'arena>),
    UseItem(&'ast UseItem<'arena>),
    UseItemAlias(&'ast UseItemAlias<'arena>),
    UseItemSequence(&'ast UseItemSequence<'arena>),
    UseItems(&'ast UseItems<'arena>),
    UseType(&'ast UseType<'arena>),
    Yield(&'ast Yield<'arena>),
    YieldFrom(&'ast YieldFrom<'arena>),
    YieldPair(&'ast YieldPair<'arena>),
    YieldValue(&'ast YieldValue<'arena>),
    Statement(&'ast Statement<'arena>),
    ExpressionStatement(&'ast ExpressionStatement<'arena>),
    BracedExpressionStringPart(&'ast BracedExpressionStringPart<'arena>),
    DocumentString(&'ast DocumentString<'arena>),
    InterpolatedString(&'ast InterpolatedString<'arena>),
    LiteralStringPart(&'ast LiteralStringPart<'arena>),
    ShellExecuteString(&'ast ShellExecuteString<'arena>),
    CompositeString(&'ast CompositeString<'arena>),
    StringPart(&'ast StringPart<'arena>),
    ClosingTag(&'ast ClosingTag),
    FullOpeningTag(&'ast FullOpeningTag<'arena>),
    OpeningTag(&'ast OpeningTag<'arena>),
    ShortOpeningTag(&'ast ShortOpeningTag),
    Terminator(&'ast Terminator<'arena>),
    Throw(&'ast Throw<'arena>),
    Hint(&'ast Hint<'arena>),
    IntersectionHint(&'ast IntersectionHint<'arena>),
    NullableHint(&'ast NullableHint<'arena>),
    ParenthesizedHint(&'ast ParenthesizedHint<'arena>),
    UnionHint(&'ast UnionHint<'arena>),
    Unset(&'ast Unset<'arena>),
    DirectVariable(&'ast DirectVariable<'arena>),
    IndirectVariable(&'ast IndirectVariable<'arena>),
    NestedVariable(&'ast NestedVariable<'arena>),
    Variable(&'ast Variable<'arena>),
    Pipe(&'ast Pipe<'arena>),
    Error(Span),
    MissingTerminator(Span),
    ClassLikeMemberMissingSelector(Span),
    ClassLikeConstantMissingSelector(Span),
}

impl<'ast, 'arena> Node<'ast, 'arena> {
    #[inline]
    pub fn filter_map<F, T>(&self, f: F) -> Vec<T>
    where
        F: Fn(&Node<'ast, 'arena>) -> Option<T>,
        T: 'ast,
    {
        let mut result = vec![];
        self.filter_map_internal(&f, &mut result);
        result
    }

    #[inline]
    fn filter_map_internal<F, T>(&self, f: &F, result: &mut Vec<T>)
    where
        F: Fn(&Node<'ast, 'arena>) -> Option<T>,
        T: 'ast,
    {
        self.visit_children(|child| child.filter_map_internal(f, result));

        if let Some(item) = f(self) {
            result.push(item);
        }
    }

    #[inline]
    #[must_use]
    pub const fn is_declaration(&self) -> bool {
        matches!(
            self,
            Self::Class(_) | Self::Interface(_) | Self::Trait(_) | Self::Enum(_) | Self::Function(_) | Self::Method(_)
        )
    }

    #[inline]
    #[must_use]
    pub const fn is_statement(&self) -> bool {
        matches!(
            self,
            Self::Statement(_)
                | Self::OpeningTag(_)
                | Self::FullOpeningTag(_)
                | Self::ShortOpeningTag(_)
                | Self::ClosingTag(_)
                | Self::Inline(_)
                | Self::Namespace(_)
                | Self::Use(_)
                | Self::Class(_)
                | Self::Interface(_)
                | Self::Trait(_)
                | Self::Enum(_)
                | Self::Block(_)
                | Self::Constant(_)
                | Self::Function(_)
                | Self::Declare(_)
                | Self::Goto(_)
                | Self::Label(_)
                | Self::Try(_)
                | Self::Foreach(_)
                | Self::For(_)
                | Self::While(_)
                | Self::DoWhile(_)
                | Self::Continue(_)
                | Self::Break(_)
                | Self::Switch(_)
                | Self::If(_)
                | Self::Return(_)
                | Self::ExpressionStatement(_)
                | Self::Echo(_)
                | Self::EchoTag(_)
                | Self::Global(_)
                | Self::Static(_)
                | Self::HaltCompiler(_)
                | Self::Unset(_)
        )
    }

    #[inline]
    #[must_use]
    pub const fn kind(&self) -> NodeKind {
        match &self {
            Self::Program(_) => NodeKind::Program,
            Self::Access(_) => NodeKind::Access,
            Self::ConstantAccess(_) => NodeKind::ConstantAccess,
            Self::ClassConstantAccess(_) => NodeKind::ClassConstantAccess,
            Self::NullSafePropertyAccess(_) => NodeKind::NullSafePropertyAccess,
            Self::PropertyAccess(_) => NodeKind::PropertyAccess,
            Self::StaticPropertyAccess(_) => NodeKind::StaticPropertyAccess,
            Self::Argument(_) => NodeKind::Argument,
            Self::ArgumentList(_) => NodeKind::ArgumentList,
            Self::PartialArgument(_) => NodeKind::PartialArgument,
            Self::PartialArgumentList(_) => NodeKind::PartialArgumentList,
            Self::NamedArgument(_) => NodeKind::NamedArgument,
            Self::NamedPlaceholderArgument(_) => NodeKind::NamedPlaceholderArgument,
            Self::PlaceholderArgument(_) => NodeKind::PlaceholderArgument,
            Self::PositionalArgument(_) => NodeKind::PositionalArgument,
            Self::VariadicPlaceholderArgument(_) => NodeKind::VariadicPlaceholderArgument,
            Self::Array(_) => NodeKind::Array,
            Self::ArrayAccess(_) => NodeKind::ArrayAccess,
            Self::ArrayAppend(_) => NodeKind::ArrayAppend,
            Self::ArrayElement(_) => NodeKind::ArrayElement,
            Self::KeyValueArrayElement(_) => NodeKind::KeyValueArrayElement,
            Self::LegacyArray(_) => NodeKind::LegacyArray,
            Self::List(_) => NodeKind::List,
            Self::MissingArrayElement(_) => NodeKind::MissingArrayElement,
            Self::ValueArrayElement(_) => NodeKind::ValueArrayElement,
            Self::VariadicArrayElement(_) => NodeKind::VariadicArrayElement,
            Self::Attribute(_) => NodeKind::Attribute,
            Self::AttributeList(_) => NodeKind::AttributeList,
            Self::Block(_) => NodeKind::Block,
            Self::Call(_) => NodeKind::Call,
            Self::FunctionCall(_) => NodeKind::FunctionCall,
            Self::MethodCall(_) => NodeKind::MethodCall,
            Self::NullSafeMethodCall(_) => NodeKind::NullSafeMethodCall,
            Self::StaticMethodCall(_) => NodeKind::StaticMethodCall,
            Self::PartialApplication(_) => NodeKind::PartialApplication,
            Self::FunctionPartialApplication(_) => NodeKind::FunctionPartialApplication,
            Self::MethodPartialApplication(_) => NodeKind::MethodPartialApplication,
            Self::StaticMethodPartialApplication(_) => NodeKind::StaticMethodPartialApplication,
            Self::ClassLikeConstant(_) => NodeKind::ClassLikeConstant,
            Self::ClassLikeConstantItem(_) => NodeKind::ClassLikeConstantItem,
            Self::EnumCase(_) => NodeKind::EnumCase,
            Self::EnumCaseBackedItem(_) => NodeKind::EnumCaseBackedItem,
            Self::EnumCaseItem(_) => NodeKind::EnumCaseItem,
            Self::EnumCaseUnitItem(_) => NodeKind::EnumCaseUnitItem,
            Self::Extends(_) => NodeKind::Extends,
            Self::Implements(_) => NodeKind::Implements,
            Self::ClassLikeConstantSelector(_) => NodeKind::ClassLikeConstantSelector,
            Self::ClassLikeMember(_) => NodeKind::ClassLikeMember,
            Self::ClassLikeMemberExpressionSelector(_) => NodeKind::ClassLikeMemberExpressionSelector,
            Self::ClassLikeMemberSelector(_) => NodeKind::ClassLikeMemberSelector,
            Self::Method(_) => NodeKind::Method,
            Self::MethodAbstractBody(_) => NodeKind::MethodAbstractBody,
            Self::MethodBody(_) => NodeKind::MethodBody,
            Self::HookedProperty(_) => NodeKind::HookedProperty,
            Self::PlainProperty(_) => NodeKind::PlainProperty,
            Self::Property(_) => NodeKind::Property,
            Self::PropertyAbstractItem(_) => NodeKind::PropertyAbstractItem,
            Self::PropertyConcreteItem(_) => NodeKind::PropertyConcreteItem,
            Self::PropertyHook(_) => NodeKind::PropertyHook,
            Self::PropertyHookAbstractBody(_) => NodeKind::PropertyHookAbstractBody,
            Self::PropertyHookBody(_) => NodeKind::PropertyHookBody,
            Self::PropertyHookConcreteBody(_) => NodeKind::PropertyHookConcreteBody,
            Self::PropertyHookConcreteExpressionBody(_) => NodeKind::PropertyHookConcreteExpressionBody,
            Self::PropertyHookList(_) => NodeKind::PropertyHookList,
            Self::PropertyItem(_) => NodeKind::PropertyItem,
            Self::TraitUse(_) => NodeKind::TraitUse,
            Self::TraitUseAbsoluteMethodReference(_) => NodeKind::TraitUseAbsoluteMethodReference,
            Self::TraitUseAbstractSpecification(_) => NodeKind::TraitUseAbstractSpecification,
            Self::TraitUseAdaptation(_) => NodeKind::TraitUseAdaptation,
            Self::TraitUseAliasAdaptation(_) => NodeKind::TraitUseAliasAdaptation,
            Self::TraitUseConcreteSpecification(_) => NodeKind::TraitUseConcreteSpecification,
            Self::TraitUseMethodReference(_) => NodeKind::TraitUseMethodReference,
            Self::TraitUsePrecedenceAdaptation(_) => NodeKind::TraitUsePrecedenceAdaptation,
            Self::TraitUseSpecification(_) => NodeKind::TraitUseSpecification,
            Self::AnonymousClass(_) => NodeKind::AnonymousClass,
            Self::Class(_) => NodeKind::Class,
            Self::Enum(_) => NodeKind::Enum,
            Self::EnumBackingTypeHint(_) => NodeKind::EnumBackingTypeHint,
            Self::Interface(_) => NodeKind::Interface,
            Self::Trait(_) => NodeKind::Trait,
            Self::Clone(_) => NodeKind::Clone,
            Self::Constant(_) => NodeKind::Constant,
            Self::ConstantItem(_) => NodeKind::ConstantItem,
            Self::Construct(_) => NodeKind::Construct,
            Self::DieConstruct(_) => NodeKind::DieConstruct,
            Self::EmptyConstruct(_) => NodeKind::EmptyConstruct,
            Self::EvalConstruct(_) => NodeKind::EvalConstruct,
            Self::ExitConstruct(_) => NodeKind::ExitConstruct,
            Self::IncludeConstruct(_) => NodeKind::IncludeConstruct,
            Self::IncludeOnceConstruct(_) => NodeKind::IncludeOnceConstruct,
            Self::IssetConstruct(_) => NodeKind::IssetConstruct,
            Self::PrintConstruct(_) => NodeKind::PrintConstruct,
            Self::RequireConstruct(_) => NodeKind::RequireConstruct,
            Self::RequireOnceConstruct(_) => NodeKind::RequireOnceConstruct,
            Self::If(_) => NodeKind::If,
            Self::IfBody(_) => NodeKind::IfBody,
            Self::IfColonDelimitedBody(_) => NodeKind::IfColonDelimitedBody,
            Self::IfColonDelimitedBodyElseClause(_) => NodeKind::IfColonDelimitedBodyElseClause,
            Self::IfColonDelimitedBodyElseIfClause(_) => NodeKind::IfColonDelimitedBodyElseIfClause,
            Self::IfStatementBody(_) => NodeKind::IfStatementBody,
            Self::IfStatementBodyElseClause(_) => NodeKind::IfStatementBodyElseClause,
            Self::IfStatementBodyElseIfClause(_) => NodeKind::IfStatementBodyElseIfClause,
            Self::Match(_) => NodeKind::Match,
            Self::MatchArm(_) => NodeKind::MatchArm,
            Self::MatchDefaultArm(_) => NodeKind::MatchDefaultArm,
            Self::MatchExpressionArm(_) => NodeKind::MatchExpressionArm,
            Self::Switch(_) => NodeKind::Switch,
            Self::SwitchBody(_) => NodeKind::SwitchBody,
            Self::SwitchBraceDelimitedBody(_) => NodeKind::SwitchBraceDelimitedBody,
            Self::SwitchCase(_) => NodeKind::SwitchCase,
            Self::SwitchCaseSeparator(_) => NodeKind::SwitchCaseSeparator,
            Self::SwitchColonDelimitedBody(_) => NodeKind::SwitchColonDelimitedBody,
            Self::SwitchDefaultCase(_) => NodeKind::SwitchDefaultCase,
            Self::SwitchExpressionCase(_) => NodeKind::SwitchExpressionCase,
            Self::Declare(_) => NodeKind::Declare,
            Self::DeclareBody(_) => NodeKind::DeclareBody,
            Self::DeclareColonDelimitedBody(_) => NodeKind::DeclareColonDelimitedBody,
            Self::DeclareItem(_) => NodeKind::DeclareItem,
            Self::Echo(_) => NodeKind::Echo,
            Self::Expression(_) => NodeKind::Expression,
            Self::Binary(_) => NodeKind::Binary,
            Self::BinaryOperator(_) => NodeKind::BinaryOperator,
            Self::UnaryPrefix(_) => NodeKind::UnaryPrefix,
            Self::UnaryPrefixOperator(_) => NodeKind::UnaryPrefixOperator,
            Self::UnaryPostfix(_) => NodeKind::UnaryPostfix,
            Self::UnaryPostfixOperator(_) => NodeKind::UnaryPostfixOperator,
            Self::Parenthesized(_) => NodeKind::Parenthesized,
            Self::ArrowFunction(_) => NodeKind::ArrowFunction,
            Self::Closure(_) => NodeKind::Closure,
            Self::ClosureUseClause(_) => NodeKind::ClosureUseClause,
            Self::ClosureUseClauseVariable(_) => NodeKind::ClosureUseClauseVariable,
            Self::Function(_) => NodeKind::Function,
            Self::FunctionLikeParameter(_) => NodeKind::FunctionLikeParameter,
            Self::FunctionLikeParameterDefaultValue(_) => NodeKind::FunctionLikeParameterDefaultValue,
            Self::FunctionLikeParameterList(_) => NodeKind::FunctionLikeParameterList,
            Self::FunctionLikeReturnTypeHint(_) => NodeKind::FunctionLikeReturnTypeHint,
            Self::Global(_) => NodeKind::Global,
            Self::Goto(_) => NodeKind::Goto,
            Self::Label(_) => NodeKind::Label,
            Self::HaltCompiler(_) => NodeKind::HaltCompiler,
            Self::FullyQualifiedIdentifier(_) => NodeKind::FullyQualifiedIdentifier,
            Self::Identifier(_) => NodeKind::Identifier,
            Self::LocalIdentifier(_) => NodeKind::LocalIdentifier,
            Self::QualifiedIdentifier(_) => NodeKind::QualifiedIdentifier,
            Self::Inline(_) => NodeKind::Inline,
            Self::Instantiation(_) => NodeKind::Instantiation,
            Self::Keyword(_) => NodeKind::Keyword,
            Self::Literal(_) => NodeKind::Literal,
            Self::LiteralFloat(_) => NodeKind::LiteralFloat,
            Self::LiteralInteger(_) => NodeKind::LiteralInteger,
            Self::LiteralString(_) => NodeKind::LiteralString,
            Self::MagicConstant(_) => NodeKind::MagicConstant,
            Self::Modifier(_) => NodeKind::Modifier,
            Self::Namespace(_) => NodeKind::Namespace,
            Self::NamespaceBody(_) => NodeKind::NamespaceBody,
            Self::NamespaceImplicitBody(_) => NodeKind::NamespaceImplicitBody,
            Self::Assignment(_) => NodeKind::Assignment,
            Self::AssignmentOperator(_) => NodeKind::AssignmentOperator,
            Self::Conditional(_) => NodeKind::Conditional,
            Self::DoWhile(_) => NodeKind::DoWhile,
            Self::Foreach(_) => NodeKind::Foreach,
            Self::ForeachBody(_) => NodeKind::ForeachBody,
            Self::ForeachColonDelimitedBody(_) => NodeKind::ForeachColonDelimitedBody,
            Self::ForeachKeyValueTarget(_) => NodeKind::ForeachKeyValueTarget,
            Self::ForeachTarget(_) => NodeKind::ForeachTarget,
            Self::ForeachValueTarget(_) => NodeKind::ForeachValueTarget,
            Self::For(_) => NodeKind::For,
            Self::ForBody(_) => NodeKind::ForBody,
            Self::ForColonDelimitedBody(_) => NodeKind::ForColonDelimitedBody,
            Self::While(_) => NodeKind::While,
            Self::WhileBody(_) => NodeKind::WhileBody,
            Self::WhileColonDelimitedBody(_) => NodeKind::WhileColonDelimitedBody,
            Self::Break(_) => NodeKind::Break,
            Self::Continue(_) => NodeKind::Continue,
            Self::Return(_) => NodeKind::Return,
            Self::Static(_) => NodeKind::Static,
            Self::StaticAbstractItem(_) => NodeKind::StaticAbstractItem,
            Self::StaticConcreteItem(_) => NodeKind::StaticConcreteItem,
            Self::StaticItem(_) => NodeKind::StaticItem,
            Self::Try(_) => NodeKind::Try,
            Self::TryCatchClause(_) => NodeKind::TryCatchClause,
            Self::TryFinallyClause(_) => NodeKind::TryFinallyClause,
            Self::MaybeTypedUseItem(_) => NodeKind::MaybeTypedUseItem,
            Self::MixedUseItemList(_) => NodeKind::MixedUseItemList,
            Self::TypedUseItemList(_) => NodeKind::TypedUseItemList,
            Self::TypedUseItemSequence(_) => NodeKind::TypedUseItemSequence,
            Self::Use(_) => NodeKind::Use,
            Self::UseItem(_) => NodeKind::UseItem,
            Self::UseItemAlias(_) => NodeKind::UseItemAlias,
            Self::UseItemSequence(_) => NodeKind::UseItemSequence,
            Self::UseItems(_) => NodeKind::UseItems,
            Self::UseType(_) => NodeKind::UseType,
            Self::Yield(_) => NodeKind::Yield,
            Self::YieldFrom(_) => NodeKind::YieldFrom,
            Self::YieldPair(_) => NodeKind::YieldPair,
            Self::YieldValue(_) => NodeKind::YieldValue,
            Self::Statement(_) => NodeKind::Statement,
            Self::ExpressionStatement(_) => NodeKind::ExpressionStatement,
            Self::BracedExpressionStringPart(_) => NodeKind::BracedExpressionStringPart,
            Self::DocumentString(_) => NodeKind::DocumentString,
            Self::InterpolatedString(_) => NodeKind::InterpolatedString,
            Self::LiteralStringPart(_) => NodeKind::LiteralStringPart,
            Self::ShellExecuteString(_) => NodeKind::ShellExecuteString,
            Self::CompositeString(_) => NodeKind::CompositeString,
            Self::StringPart(_) => NodeKind::StringPart,
            Self::ClosingTag(_) => NodeKind::ClosingTag,
            Self::EchoTag(_) => NodeKind::EchoTag,
            Self::FullOpeningTag(_) => NodeKind::FullOpeningTag,
            Self::OpeningTag(_) => NodeKind::OpeningTag,
            Self::ShortOpeningTag(_) => NodeKind::ShortOpeningTag,
            Self::Terminator(_) => NodeKind::Terminator,
            Self::Throw(_) => NodeKind::Throw,
            Self::Hint(_) => NodeKind::Hint,
            Self::IntersectionHint(_) => NodeKind::IntersectionHint,
            Self::NullableHint(_) => NodeKind::NullableHint,
            Self::ParenthesizedHint(_) => NodeKind::ParenthesizedHint,
            Self::UnionHint(_) => NodeKind::UnionHint,
            Self::Unset(_) => NodeKind::Unset,
            Self::DirectVariable(_) => NodeKind::DirectVariable,
            Self::IndirectVariable(_) => NodeKind::IndirectVariable,
            Self::NestedVariable(_) => NodeKind::NestedVariable,
            Self::Variable(_) => NodeKind::Variable,
            Self::Pipe(_) => NodeKind::Pipe,
            Self::Error(_) => NodeKind::Error,
            Self::MissingTerminator(_) => NodeKind::MissingTerminator,
            Self::ClassLikeMemberMissingSelector(_) => NodeKind::ClassLikeMemberMissingSelector,
            Self::ClassLikeConstantMissingSelector(_) => NodeKind::ClassLikeConstantMissingSelector,
        }
    }

    pub fn visit_children<F>(&self, mut f: F)
    where
        F: FnMut(Node<'ast, 'arena>),
    {
        match &self {
            Node::Program(node) => {
                for node in node.statements.as_slice() {
                    f(Node::Statement(node));
                }
            }
            Node::Access(node) => match &node {
                Access::Property(node) => f(Node::PropertyAccess(node)),
                Access::NullSafeProperty(node) => f(Node::NullSafePropertyAccess(node)),
                Access::StaticProperty(node) => f(Node::StaticPropertyAccess(node)),
                Access::ClassConstant(node) => f(Node::ClassConstantAccess(node)),
            },
            Node::ConstantAccess(node) => {
                f(Node::Identifier(&node.name));
            }
            Node::ClassConstantAccess(node) => {
                f(Node::Expression(node.class));
                f(Node::ClassLikeConstantSelector(&node.constant));
            }
            Node::NullSafePropertyAccess(node) => {
                f(Node::Expression(node.object));
                f(Node::ClassLikeMemberSelector(&node.property));
            }
            Node::PropertyAccess(node) => {
                f(Node::Expression(node.object));
                f(Node::ClassLikeMemberSelector(&node.property));
            }
            Node::StaticPropertyAccess(node) => {
                f(Node::Expression(node.class));
                f(Node::Variable(&node.property));
            }
            Node::Argument(node) => match &node {
                Argument::Named(node) => f(Node::NamedArgument(node)),
                Argument::Positional(node) => f(Node::PositionalArgument(node)),
            },
            Node::ArgumentList(node) => {
                for node in node.arguments.as_slice() {
                    f(Node::Argument(node));
                }
            }
            Node::PartialArgument(node) => match &node {
                PartialArgument::Named(node) => f(Node::NamedArgument(node)),
                PartialArgument::NamedPlaceholder(node) => f(Node::NamedPlaceholderArgument(node)),
                PartialArgument::Placeholder(node) => f(Node::PlaceholderArgument(node)),
                PartialArgument::Positional(node) => f(Node::PositionalArgument(node)),
                PartialArgument::VariadicPlaceholder(node) => f(Node::VariadicPlaceholderArgument(node)),
            },
            Node::PartialArgumentList(node) => {
                for node in node.arguments.as_slice() {
                    f(Node::PartialArgument(node));
                }
            }
            Node::NamedArgument(node) => {
                f(Node::LocalIdentifier(&node.name));
                f(Node::Expression(node.value));
            }
            Node::NamedPlaceholderArgument(node) => {
                f(Node::LocalIdentifier(&node.name));
            }
            Node::PlaceholderArgument(_) => {}
            Node::PositionalArgument(node) => f(Node::Expression(node.value)),
            Node::VariadicPlaceholderArgument(_) => {}
            Node::Array(node) => {
                for node in node.elements.as_slice() {
                    f(Node::ArrayElement(node));
                }
            }
            Node::ArrayAccess(node) => {
                f(Node::Expression(node.array));
                f(Node::Expression(node.index));
            }
            Node::ArrayAppend(node) => {
                f(Node::Expression(node.array));
            }
            Node::ArrayElement(node) => match &node {
                ArrayElement::KeyValue(node) => f(Node::KeyValueArrayElement(node)),
                ArrayElement::Missing(node) => f(Node::MissingArrayElement(node)),
                ArrayElement::Value(node) => f(Node::ValueArrayElement(node)),
                ArrayElement::Variadic(node) => f(Node::VariadicArrayElement(node)),
            },
            Node::KeyValueArrayElement(node) => {
                f(Node::Expression(node.key));
                f(Node::Expression(node.value));
            }
            Node::LegacyArray(node) => {
                for item in node.elements.iter() {
                    f(Node::ArrayElement(item));
                }
            }
            Node::List(node) => {
                for item in node.elements.iter() {
                    f(Node::ArrayElement(item));
                }
            }
            Node::MissingArrayElement(_) => {}
            Node::ValueArrayElement(node) => f(Node::Expression(node.value)),
            Node::VariadicArrayElement(node) => f(Node::Expression(node.value)),
            Node::Attribute(node) => {
                f(Node::Identifier(&node.name));
                if let Some(arguments) = &node.argument_list {
                    f(Node::PartialArgumentList(arguments));
                }
            }
            Node::AttributeList(node) => {
                for item in node.attributes.iter() {
                    f(Node::Attribute(item));
                }
            }
            Node::Block(node) => {
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::Call(node) => match node {
                Call::Function(node) => f(Node::FunctionCall(node)),
                Call::Method(node) => f(Node::MethodCall(node)),
                Call::NullSafeMethod(node) => f(Node::NullSafeMethodCall(node)),
                Call::StaticMethod(node) => f(Node::StaticMethodCall(node)),
            },
            Node::FunctionCall(node) => {
                f(Node::Expression(node.function));
                f(Node::ArgumentList(&node.argument_list));
            }
            Node::MethodCall(node) => {
                f(Node::Expression(node.object));
                f(Node::ClassLikeMemberSelector(&node.method));
                f(Node::ArgumentList(&node.argument_list));
            }
            Node::NullSafeMethodCall(node) => {
                f(Node::Expression(node.object));
                f(Node::ClassLikeMemberSelector(&node.method));
                f(Node::ArgumentList(&node.argument_list));
            }
            Node::StaticMethodCall(node) => {
                f(Node::Expression(node.class));
                f(Node::ClassLikeMemberSelector(&node.method));
                f(Node::ArgumentList(&node.argument_list));
            }
            Node::PartialApplication(node) => match node {
                PartialApplication::Function(node) => f(Node::FunctionPartialApplication(node)),
                PartialApplication::Method(node) => f(Node::MethodPartialApplication(node)),
                PartialApplication::StaticMethod(node) => f(Node::StaticMethodPartialApplication(node)),
            },
            Node::FunctionPartialApplication(node) => {
                f(Node::Expression(node.function));
                f(Node::PartialArgumentList(&node.argument_list));
            }
            Node::MethodPartialApplication(node) => {
                f(Node::Expression(node.object));
                f(Node::ClassLikeMemberSelector(&node.method));
                f(Node::PartialArgumentList(&node.argument_list));
            }
            Node::StaticMethodPartialApplication(node) => {
                f(Node::Expression(node.class));
                f(Node::ClassLikeMemberSelector(&node.method));
                f(Node::PartialArgumentList(&node.argument_list));
            }
            Node::ClassLikeConstant(node) => {
                for attr in &node.attribute_lists {
                    f(Node::AttributeList(attr));
                }

                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                f(Node::Keyword(&node.r#const));
                if let Some(hint) = &node.hint {
                    f(Node::Hint(hint));
                }

                for item in node.items.iter() {
                    f(Node::ClassLikeConstantItem(item));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::ClassLikeConstantItem(node) => {
                f(Node::LocalIdentifier(&node.name));
                f(Node::Expression(node.value));
            }
            Node::EnumCase(node) => {
                for attr in &node.attribute_lists {
                    f(Node::AttributeList(attr));
                }

                f(Node::Keyword(&node.case));
                f(Node::EnumCaseItem(&node.item));
                f(Node::Terminator(&node.terminator));
            }
            Node::EnumCaseBackedItem(node) => {
                f(Node::LocalIdentifier(&node.name));
                f(Node::Expression(node.value));
            }
            Node::EnumCaseItem(node) => match &node {
                EnumCaseItem::Backed(node) => f(Node::EnumCaseBackedItem(node)),
                EnumCaseItem::Unit(node) => f(Node::EnumCaseUnitItem(node)),
            },
            Node::EnumCaseUnitItem(node) => f(Node::LocalIdentifier(&node.name)),
            Node::Extends(node) => {
                f(Node::Keyword(&node.extends));
                for item in node.types.iter() {
                    f(Node::Identifier(item));
                }
            }
            Node::Implements(node) => {
                f(Node::Keyword(&node.implements));
                for item in node.types.iter() {
                    f(Node::Identifier(item));
                }
            }
            Node::ClassLikeConstantSelector(node) => match node {
                ClassLikeConstantSelector::Identifier(node) => f(Node::LocalIdentifier(node)),
                ClassLikeConstantSelector::Expression(node) => {
                    f(Node::ClassLikeMemberExpressionSelector(node));
                }
                ClassLikeConstantSelector::Missing(span) => f(Node::ClassLikeConstantMissingSelector(*span)),
            },
            Node::ClassLikeMember(node) => match node {
                ClassLikeMember::TraitUse(node) => f(Node::TraitUse(node)),
                ClassLikeMember::Constant(node) => f(Node::ClassLikeConstant(node)),
                ClassLikeMember::Property(node) => f(Node::Property(node)),
                ClassLikeMember::EnumCase(node) => f(Node::EnumCase(node)),
                ClassLikeMember::Method(node) => f(Node::Method(node)),
            },
            Node::ClassLikeMemberExpressionSelector(node) => f(Node::Expression(node.expression)),
            Node::ClassLikeMemberSelector(node) => match node {
                ClassLikeMemberSelector::Identifier(node) => f(Node::LocalIdentifier(node)),
                ClassLikeMemberSelector::Variable(node) => f(Node::Variable(node)),
                ClassLikeMemberSelector::Expression(node) => {
                    f(Node::ClassLikeMemberExpressionSelector(node));
                }
                ClassLikeMemberSelector::Missing(span) => f(Node::ClassLikeMemberMissingSelector(*span)),
            },
            Node::Method(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                f(Node::Keyword(&node.function));
                f(Node::LocalIdentifier(&node.name));
                f(Node::FunctionLikeParameterList(&node.parameter_list));
                for item in node.return_type_hint.iter() {
                    f(Node::FunctionLikeReturnTypeHint(item));
                }
                f(Node::MethodBody(&node.body));
            }
            Node::MethodAbstractBody(node) => {
                f(Node::Terminator(&node.terminator));
            }
            Node::MethodBody(node) => match node {
                MethodBody::Abstract(node) => f(Node::MethodAbstractBody(node)),
                MethodBody::Concrete(node) => f(Node::Block(node)),
            },
            Node::HookedProperty(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.var.iter() {
                    f(Node::Keyword(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                for item in node.hint.iter() {
                    f(Node::Hint(item));
                }
                f(Node::PropertyItem(&node.item));
                f(Node::PropertyHookList(&node.hook_list));
            }
            Node::PlainProperty(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.var.iter() {
                    f(Node::Keyword(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                for item in node.hint.iter() {
                    f(Node::Hint(item));
                }
                for item in node.items.iter() {
                    f(Node::PropertyItem(item));
                }
            }
            Node::Property(node) => match node {
                Property::Plain(node) => f(Node::PlainProperty(node)),
                Property::Hooked(node) => f(Node::HookedProperty(node)),
            },
            Node::PropertyAbstractItem(node) => {
                f(Node::DirectVariable(&node.variable));
            }
            Node::PropertyConcreteItem(node) => {
                f(Node::DirectVariable(&node.variable));
                f(Node::Expression(node.value));
            }
            Node::PropertyHook(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                f(Node::LocalIdentifier(&node.name));
                for item in node.parameter_list.iter() {
                    f(Node::FunctionLikeParameterList(item));
                }
                f(Node::PropertyHookBody(&node.body));
            }
            Node::PropertyHookAbstractBody(_) => {}
            Node::PropertyHookBody(node) => f(match node {
                PropertyHookBody::Abstract(node) => Node::PropertyHookAbstractBody(node),
                PropertyHookBody::Concrete(node) => Node::PropertyHookConcreteBody(node),
            }),
            Node::PropertyHookConcreteBody(node) => f(match node {
                PropertyHookConcreteBody::Expression(node) => Node::PropertyHookConcreteExpressionBody(node),
                PropertyHookConcreteBody::Block(node) => Node::Block(node),
            }),
            Node::PropertyHookConcreteExpressionBody(node) => f(Node::Expression(node.expression)),
            Node::PropertyHookList(node) => {
                for item in node.hooks.iter() {
                    f(Node::PropertyHook(item));
                }
            }
            Node::PropertyItem(node) => match node {
                PropertyItem::Abstract(node) => f(Node::PropertyAbstractItem(node)),
                PropertyItem::Concrete(node) => f(Node::PropertyConcreteItem(node)),
            },
            Node::TraitUse(node) => {
                f(Node::Keyword(&node.r#use));
                for item in node.trait_names.iter() {
                    f(Node::Identifier(item));
                }
                f(Node::TraitUseSpecification(&node.specification));
            }
            Node::TraitUseAbsoluteMethodReference(node) => {
                f(Node::Identifier(&node.trait_name));
                f(Node::LocalIdentifier(&node.method_name));
            }
            Node::TraitUseAbstractSpecification(node) => f(Node::Terminator(&node.0)),
            Node::TraitUseAdaptation(node) => match node {
                TraitUseAdaptation::Precedence(adaptation) => {
                    f(Node::TraitUseAbsoluteMethodReference(&adaptation.method_reference));
                    f(Node::Keyword(&adaptation.insteadof));

                    for item in adaptation.trait_names.iter() {
                        f(Node::Identifier(item));
                    }
                    f(Node::Terminator(&adaptation.terminator));
                }
                TraitUseAdaptation::Alias(adaptation) => {
                    f(Node::TraitUseMethodReference(&adaptation.method_reference));
                    f(Node::Keyword(&adaptation.r#as));

                    if let Some(visibility) = &adaptation.modifier {
                        f(Node::Modifier(visibility));
                    }

                    if let Some(alias) = &adaptation.alias {
                        f(Node::LocalIdentifier(alias));
                    }

                    f(Node::Terminator(&adaptation.terminator));
                }
            },
            Node::TraitUseAliasAdaptation(node) => {
                f(Node::TraitUseMethodReference(&node.method_reference));
                f(Node::Keyword(&node.r#as));

                if let Some(visibility) = &node.modifier {
                    f(Node::Modifier(visibility));
                }

                if let Some(alias) = &node.alias {
                    f(Node::LocalIdentifier(alias));
                }

                f(Node::Terminator(&node.terminator));
            }
            Node::TraitUseConcreteSpecification(node) => {
                for adaptation in node.adaptations.as_slice() {
                    f(Node::TraitUseAdaptation(adaptation));
                }
            }
            Node::TraitUseMethodReference(node) => match node {
                TraitUseMethodReference::Identifier(identifier) => {
                    f(Node::LocalIdentifier(identifier));
                }
                TraitUseMethodReference::Absolute(reference) => {
                    f(Node::TraitUseAbsoluteMethodReference(reference));
                }
            },
            Node::TraitUsePrecedenceAdaptation(node) => {
                f(Node::TraitUseAbsoluteMethodReference(&node.method_reference));
                f(Node::Keyword(&node.insteadof));

                for item in node.trait_names.iter() {
                    f(Node::Identifier(item));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::TraitUseSpecification(node) => match node {
                TraitUseSpecification::Abstract(specification) => {
                    f(Node::TraitUseAbstractSpecification(specification));
                }
                TraitUseSpecification::Concrete(specification) => {
                    f(Node::TraitUseConcreteSpecification(specification));
                }
            },
            Node::AnonymousClass(node) => {
                f(Node::Keyword(&node.new));
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                f(Node::Keyword(&node.class));
                if let Some(argument_list) = &node.argument_list {
                    f(Node::PartialArgumentList(argument_list));
                }
                for item in node.extends.iter() {
                    f(Node::Extends(item));
                }
                for item in node.implements.iter() {
                    f(Node::Implements(item));
                }
                for item in node.members.iter() {
                    f(Node::ClassLikeMember(item));
                }
            }
            Node::Class(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                f(Node::Keyword(&node.class));
                f(Node::LocalIdentifier(&node.name));
                for item in node.extends.iter() {
                    f(Node::Extends(item));
                }
                for item in node.implements.iter() {
                    f(Node::Implements(item));
                }
                for item in node.members.iter() {
                    f(Node::ClassLikeMember(item));
                }
            }
            Node::Enum(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.r#enum));
                f(Node::LocalIdentifier(&node.name));
                for item in node.backing_type_hint.iter() {
                    f(Node::EnumBackingTypeHint(item));
                }
                for item in node.implements.iter() {
                    f(Node::Implements(item));
                }
                for item in node.members.iter() {
                    f(Node::ClassLikeMember(item));
                }
            }
            Node::EnumBackingTypeHint(node) => {
                f(Node::Hint(&node.hint));
            }
            Node::Interface(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.interface));
                f(Node::LocalIdentifier(&node.name));
                for item in node.extends.iter() {
                    f(Node::Extends(item));
                }
                for item in node.members.iter() {
                    f(Node::ClassLikeMember(item));
                }
            }
            Node::Trait(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.r#trait));
                f(Node::LocalIdentifier(&node.name));
                for item in node.members.iter() {
                    f(Node::ClassLikeMember(item));
                }
            }
            Node::Clone(node) => {
                f(Node::Keyword(&node.clone));
                f(Node::Expression(node.object));
            }
            Node::Constant(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.r#const));
                for item in node.items.iter() {
                    f(Node::ConstantItem(item));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::ConstantItem(node) => {
                f(Node::LocalIdentifier(&node.name));
                f(Node::Expression(node.value));
            }
            Node::Construct(node) => f(match node {
                Construct::Isset(node) => Node::IssetConstruct(node),
                Construct::Empty(node) => Node::EmptyConstruct(node),
                Construct::Eval(node) => Node::EvalConstruct(node),
                Construct::Include(node) => Node::IncludeConstruct(node),
                Construct::IncludeOnce(node) => Node::IncludeOnceConstruct(node),
                Construct::Require(node) => Node::RequireConstruct(node),
                Construct::RequireOnce(node) => Node::RequireOnceConstruct(node),
                Construct::Print(node) => Node::PrintConstruct(node),
                Construct::Exit(node) => Node::ExitConstruct(node),
                Construct::Die(node) => Node::DieConstruct(node),
            }),
            Node::IssetConstruct(node) => {
                f(Node::Keyword(&node.isset));
                for e in node.values.iter() {
                    f(Node::Expression(e));
                }
            }
            Node::EmptyConstruct(node) => {
                f(Node::Keyword(&node.empty));
                f(Node::Expression(node.value));
            }
            Node::EvalConstruct(node) => {
                f(Node::Keyword(&node.eval));
                f(Node::Expression(node.value));
            }
            Node::IncludeConstruct(node) => {
                f(Node::Keyword(&node.include));
                f(Node::Expression(node.value));
            }
            Node::IncludeOnceConstruct(node) => {
                f(Node::Keyword(&node.include_once));
                f(Node::Expression(node.value));
            }
            Node::RequireConstruct(node) => {
                f(Node::Keyword(&node.require));
                f(Node::Expression(node.value));
            }
            Node::RequireOnceConstruct(node) => {
                f(Node::Keyword(&node.require_once));
                f(Node::Expression(node.value));
            }
            Node::PrintConstruct(node) => {
                f(Node::Keyword(&node.print));
                f(Node::Expression(node.value));
            }
            Node::ExitConstruct(node) => {
                f(Node::Keyword(&node.exit));
                if let Some(arguments) = &node.arguments {
                    f(Node::ArgumentList(arguments));
                }
            }
            Node::DieConstruct(node) => {
                f(Node::Keyword(&node.die));
                if let Some(arguments) = &node.arguments {
                    f(Node::ArgumentList(arguments));
                }
            }
            Node::If(node) => {
                f(Node::Keyword(&node.r#if));
                f(Node::Expression(node.condition));
                f(Node::IfBody(&node.body));
            }
            Node::IfBody(node) => match node {
                IfBody::Statement(statement_body) => f(Node::IfStatementBody(statement_body)),
                IfBody::ColonDelimited(colon_body) => f(Node::IfColonDelimitedBody(colon_body)),
            },
            Node::IfStatementBody(node) => {
                f(Node::Statement(node.statement));

                for item in node.else_if_clauses.iter() {
                    f(Node::IfStatementBodyElseIfClause(item));
                }
                if let Some(else_clause) = &node.else_clause {
                    f(Node::IfStatementBodyElseClause(else_clause));
                }
            }
            Node::IfStatementBodyElseIfClause(node) => {
                f(Node::Keyword(&node.elseif));
                f(Node::Expression(node.condition));
                f(Node::Statement(node.statement));
            }
            Node::IfStatementBodyElseClause(node) => {
                f(Node::Keyword(&node.r#else));
                f(Node::Statement(node.statement));
            }
            Node::IfColonDelimitedBody(node) => {
                for stmt in node.statements.as_slice() {
                    f(Node::Statement(stmt));
                }

                for item in node.else_if_clauses.iter() {
                    f(Node::IfColonDelimitedBodyElseIfClause(item));
                }

                if let Some(else_clause) = &node.else_clause {
                    f(Node::IfColonDelimitedBodyElseClause(else_clause));
                }

                f(Node::Keyword(&node.endif));
                f(Node::Terminator(&node.terminator));
            }
            Node::IfColonDelimitedBodyElseIfClause(node) => {
                f(Node::Keyword(&node.elseif));
                f(Node::Expression(node.condition));
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::IfColonDelimitedBodyElseClause(node) => {
                f(Node::Keyword(&node.r#else));

                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::Match(node) => {
                f(Node::Keyword(&node.r#match));
                f(Node::Expression(node.expression));
                for item in node.arms.iter() {
                    f(Node::MatchArm(item));
                }
            }
            Node::MatchArm(node) => match node {
                MatchArm::Expression(expr_arm) => f(Node::MatchExpressionArm(expr_arm)),
                MatchArm::Default(default_arm) => f(Node::MatchDefaultArm(default_arm)),
            },
            Node::MatchExpressionArm(node) => {
                for e in node.conditions.iter() {
                    f(Node::Expression(e));
                }
                f(Node::Expression(node.expression));
            }
            Node::MatchDefaultArm(node) => {
                f(Node::Keyword(&node.default));
                f(Node::Expression(node.expression));
            }
            Node::Switch(node) => {
                f(Node::Keyword(&node.switch));
                f(Node::Expression(node.expression));
                f(Node::SwitchBody(&node.body));
            }
            Node::SwitchBody(node) => match node {
                SwitchBody::BraceDelimited(body) => f(Node::SwitchBraceDelimitedBody(body)),
                SwitchBody::ColonDelimited(body) => f(Node::SwitchColonDelimitedBody(body)),
            },
            Node::SwitchBraceDelimitedBody(node) => {
                if let Some(terminator) = &node.optional_terminator {
                    f(Node::Terminator(terminator));
                }

                for item in node.cases.iter() {
                    f(Node::SwitchCase(item));
                }
            }
            Node::SwitchColonDelimitedBody(node) => {
                if let Some(terminator) = &node.optional_terminator {
                    f(Node::Terminator(terminator));
                }

                for item in node.cases.iter() {
                    f(Node::SwitchCase(item));
                }
                f(Node::Keyword(&node.end_switch));
                f(Node::Terminator(&node.terminator));
            }
            Node::SwitchCase(node) => match node {
                SwitchCase::Expression(expression_case) => {
                    f(Node::SwitchExpressionCase(expression_case));
                }
                SwitchCase::Default(default_case) => f(Node::SwitchDefaultCase(default_case)),
            },
            Node::SwitchExpressionCase(node) => {
                f(Node::Keyword(&node.case));
                f(Node::Expression(node.expression));
                f(Node::SwitchCaseSeparator(&node.separator));

                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::SwitchDefaultCase(node) => {
                f(Node::Keyword(&node.default));
                f(Node::SwitchCaseSeparator(&node.separator));
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::SwitchCaseSeparator(_) => {}
            Node::Declare(node) => {
                f(Node::Keyword(&node.declare));

                for item in node.items.iter() {
                    f(Node::DeclareItem(item));
                }
                f(Node::DeclareBody(&node.body));
            }
            Node::DeclareBody(node) => match node {
                DeclareBody::Statement(statement) => f(Node::Statement(statement)),
                DeclareBody::ColonDelimited(body) => f(Node::DeclareColonDelimitedBody(body)),
            },
            Node::DeclareColonDelimitedBody(node) => {
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }

                f(Node::Keyword(&node.end_declare));
                f(Node::Terminator(&node.terminator));
            }
            Node::DeclareItem(node) => {
                f(Node::LocalIdentifier(&node.name));
                f(Node::Expression(node.value));
            }
            Node::EchoTag(node) => {
                for e in node.values.iter() {
                    f(Node::Expression(e));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::Echo(node) => {
                f(Node::Keyword(&node.echo));
                for e in node.values.iter() {
                    f(Node::Expression(e));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::Parenthesized(node) => f(Node::Expression(node.expression)),
            Node::Expression(node) => {
                let child = match node {
                    Expression::Binary(node) => Node::Binary(node),
                    Expression::UnaryPrefix(node) => Node::UnaryPrefix(node),
                    Expression::ConstantAccess(node) => Node::ConstantAccess(node),
                    Expression::UnaryPostfix(node) => Node::UnaryPostfix(node),
                    Expression::Parenthesized(node) => Node::Parenthesized(node),
                    Expression::Literal(node) => Node::Literal(node),
                    Expression::CompositeString(node) => Node::CompositeString(node),
                    Expression::Assignment(node) => Node::Assignment(node),
                    Expression::Conditional(node) => Node::Conditional(node),
                    Expression::Array(node) => Node::Array(node),
                    Expression::LegacyArray(node) => Node::LegacyArray(node),
                    Expression::List(node) => Node::List(node),
                    Expression::ArrayAccess(node) => Node::ArrayAccess(node),
                    Expression::ArrayAppend(node) => Node::ArrayAppend(node),
                    Expression::AnonymousClass(node) => Node::AnonymousClass(node),
                    Expression::Closure(node) => Node::Closure(node),
                    Expression::ArrowFunction(node) => Node::ArrowFunction(node),
                    Expression::Variable(node) => Node::Variable(node),
                    Expression::Identifier(node) => Node::Identifier(node),
                    Expression::Match(node) => Node::Match(node),
                    Expression::Yield(node) => Node::Yield(node),
                    Expression::Construct(node) => Node::Construct(node),
                    Expression::Throw(node) => Node::Throw(node),
                    Expression::Clone(node) => Node::Clone(node),
                    Expression::Call(node) => Node::Call(node),
                    Expression::PartialApplication(node) => Node::PartialApplication(node),
                    Expression::Access(node) => Node::Access(node),
                    Expression::Parent(node) => Node::Keyword(node),
                    Expression::Static(node) => Node::Keyword(node),
                    Expression::Self_(node) => Node::Keyword(node),
                    Expression::Instantiation(node) => Node::Instantiation(node),
                    Expression::MagicConstant(node) => Node::MagicConstant(node),
                    Expression::Pipe(node) => Node::Pipe(node),
                    Expression::Error(span) => Node::Error(*span),
                };
                f(child);
            }
            Node::Binary(node) => {
                f(Node::Expression(node.lhs));
                f(Node::BinaryOperator(&node.operator));
                f(Node::Expression(node.rhs));
            }
            Node::BinaryOperator(operator) => match operator {
                BinaryOperator::Addition(_) => {}
                BinaryOperator::Subtraction(_) => {}
                BinaryOperator::Multiplication(_) => {}
                BinaryOperator::Division(_) => {}
                BinaryOperator::Modulo(_) => {}
                BinaryOperator::Exponentiation(_) => {}
                BinaryOperator::BitwiseAnd(_) => {}
                BinaryOperator::BitwiseOr(_) => {}
                BinaryOperator::BitwiseXor(_) => {}
                BinaryOperator::LeftShift(_) => {}
                BinaryOperator::RightShift(_) => {}
                BinaryOperator::NullCoalesce(_) => {}
                BinaryOperator::Equal(_) => {}
                BinaryOperator::NotEqual(_) => {}
                BinaryOperator::Identical(_) => {}
                BinaryOperator::NotIdentical(_) => {}
                BinaryOperator::AngledNotEqual(_) => {}
                BinaryOperator::LessThan(_) => {}
                BinaryOperator::LessThanOrEqual(_) => {}
                BinaryOperator::GreaterThan(_) => {}
                BinaryOperator::GreaterThanOrEqual(_) => {}
                BinaryOperator::Spaceship(_) => {}
                BinaryOperator::StringConcat(_) => {}
                BinaryOperator::And(_) => {}
                BinaryOperator::Or(_) => {}
                BinaryOperator::Instanceof(keyword) => f(Node::Keyword(keyword)),
                BinaryOperator::LowAnd(keyword) => f(Node::Keyword(keyword)),
                BinaryOperator::LowOr(keyword) => f(Node::Keyword(keyword)),
                BinaryOperator::LowXor(keyword) => f(Node::Keyword(keyword)),
            },
            Node::UnaryPrefix(node) => {
                f(Node::UnaryPrefixOperator(&node.operator));
                f(Node::Expression(node.operand));
            }
            Node::UnaryPostfix(node) => {
                f(Node::Expression(node.operand));
                f(Node::UnaryPostfixOperator(&node.operator));
            }
            Node::UnaryPrefixOperator(_) | Node::UnaryPostfixOperator(_) => {}
            Node::ArrowFunction(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                if let Some(r#static) = &node.r#static {
                    f(Node::Keyword(r#static));
                }
                f(Node::Keyword(&node.r#fn));
                f(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(return_type_hint) = &node.return_type_hint {
                    f(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }
                f(Node::Expression(node.expression));
            }
            Node::Closure(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.function));
                f(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(use_clause) = &node.use_clause {
                    f(Node::ClosureUseClause(use_clause));
                }
                if let Some(return_type_hint) = &node.return_type_hint {
                    f(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }
                f(Node::Block(&node.body));
            }
            Node::ClosureUseClause(node) => {
                f(Node::Keyword(&node.r#use));
                for item in node.variables.iter() {
                    f(Node::ClosureUseClauseVariable(item));
                }
            }
            Node::ClosureUseClauseVariable(node) => f(Node::DirectVariable(&node.variable)),
            Node::Function(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                f(Node::Keyword(&node.function));
                f(Node::LocalIdentifier(&node.name));
                f(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(return_type_hint) = &node.return_type_hint {
                    f(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }

                f(Node::Block(&node.body));
            }
            Node::FunctionLikeParameterList(node) => {
                for item in node.parameters.iter() {
                    f(Node::FunctionLikeParameter(item));
                }
            }
            Node::FunctionLikeParameter(node) => {
                for item in node.attribute_lists.iter() {
                    f(Node::AttributeList(item));
                }
                for item in node.modifiers.iter() {
                    f(Node::Modifier(item));
                }
                if let Some(hint) = &node.hint {
                    f(Node::Hint(hint));
                }
                f(Node::DirectVariable(&node.variable));
                if let Some(default_value) = &node.default_value {
                    f(Node::FunctionLikeParameterDefaultValue(default_value));
                }

                if let Some(hooks) = &node.hooks {
                    f(Node::PropertyHookList(hooks));
                }
            }
            Node::FunctionLikeParameterDefaultValue(node) => f(Node::Expression(node.value)),
            Node::FunctionLikeReturnTypeHint(hint) => f(Node::Hint(&hint.hint)),
            Node::Global(node) => {
                f(Node::Keyword(&node.r#global));
                for item in node.variables.iter() {
                    f(Node::Variable(item));
                }
            }
            Node::Goto(node) => {
                f(Node::Keyword(&node.r#goto));
                f(Node::LocalIdentifier(&node.label));
            }
            Node::Label(node) => {
                f(Node::LocalIdentifier(&node.name));
            }
            Node::HaltCompiler(node) => {
                f(Node::Keyword(&node.halt_compiler));
            }
            Node::FullyQualifiedIdentifier(_) => {}
            Node::Identifier(node) => f(match node {
                Identifier::Local(node) => Node::LocalIdentifier(node),
                Identifier::Qualified(node) => Node::QualifiedIdentifier(node),
                Identifier::FullyQualified(node) => Node::FullyQualifiedIdentifier(node),
            }),
            Node::LocalIdentifier(_) => {}
            Node::QualifiedIdentifier(_) => {}
            Node::Inline(_) => {}
            Node::Instantiation(node) => {
                f(Node::Keyword(&node.new));
                f(Node::Expression(node.class));

                if let Some(argument_list) = &node.argument_list {
                    f(Node::ArgumentList(argument_list));
                }
            }
            Node::Keyword(_) => {}
            Node::Literal(node) => f(match node {
                Literal::Float(node) => Node::LiteralFloat(node),
                Literal::Integer(node) => Node::LiteralInteger(node),
                Literal::String(node) => Node::LiteralString(node),
                Literal::True(node) => Node::Keyword(node),
                Literal::False(node) => Node::Keyword(node),
                Literal::Null(node) => Node::Keyword(node),
            }),
            Node::LiteralFloat(_) => {}
            Node::LiteralInteger(_) => {}
            Node::LiteralString(_) => {}
            Node::MagicConstant(node) => f(match node {
                MagicConstant::Class(node) => Node::LocalIdentifier(node),
                MagicConstant::Directory(node) => Node::LocalIdentifier(node),
                MagicConstant::File(node) => Node::LocalIdentifier(node),
                MagicConstant::Function(node) => Node::LocalIdentifier(node),
                MagicConstant::Line(node) => Node::LocalIdentifier(node),
                MagicConstant::Method(node) => Node::LocalIdentifier(node),
                MagicConstant::Namespace(node) => Node::LocalIdentifier(node),
                MagicConstant::Trait(node) => Node::LocalIdentifier(node),
                MagicConstant::Property(node) => Node::LocalIdentifier(node),
            }),
            Node::Modifier(node) => f(match node {
                Modifier::Abstract(node) => Node::Keyword(node),
                Modifier::Final(node) => Node::Keyword(node),
                Modifier::Private(node) => Node::Keyword(node),
                Modifier::Protected(node) => Node::Keyword(node),
                Modifier::Public(node) => Node::Keyword(node),
                Modifier::Static(node) => Node::Keyword(node),
                Modifier::Readonly(node) => Node::Keyword(node),
                Modifier::PrivateSet(node) => Node::Keyword(node),
                Modifier::ProtectedSet(node) => Node::Keyword(node),
                Modifier::PublicSet(node) => Node::Keyword(node),
            }),
            Node::Namespace(node) => {
                f(Node::Keyword(&node.r#namespace));

                if let Some(name) = &node.name {
                    f(Node::Identifier(name));
                }

                f(Node::NamespaceBody(&node.body));
            }
            Node::NamespaceBody(node) => {
                f(match node {
                    NamespaceBody::BraceDelimited(node) => Node::Block(node),
                    NamespaceBody::Implicit(node) => Node::NamespaceImplicitBody(node),
                });
            }
            Node::NamespaceImplicitBody(node) => {
                f(Node::Terminator(&node.terminator));

                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
            }
            Node::Assignment(node) => {
                f(Node::Expression(node.lhs));
                f(Node::AssignmentOperator(&node.operator));
                f(Node::Expression(node.rhs));
            }
            Node::AssignmentOperator(_) => {}
            Node::Conditional(node) => {
                f(Node::Expression(node.condition));

                if let Some(then) = &node.then {
                    f(Node::Expression(then));
                }

                f(Node::Expression(node.r#else));
            }
            Node::DoWhile(node) => {
                f(Node::Keyword(&node.r#do));
                f(Node::Statement(node.statement));
                f(Node::Keyword(&node.r#while));
                f(Node::Expression(node.condition));
                f(Node::Terminator(&node.terminator));
            }
            Node::Foreach(node) => {
                f(Node::Keyword(&node.r#foreach));
                f(Node::Expression(node.expression));
                f(Node::Keyword(&node.r#as));
                f(Node::ForeachTarget(&node.target));
                f(Node::ForeachBody(&node.body));
            }
            Node::ForeachBody(node) => f(match node {
                ForeachBody::Statement(node) => Node::Statement(node),
                ForeachBody::ColonDelimited(node) => Node::ForeachColonDelimitedBody(node),
            }),
            Node::ForeachColonDelimitedBody(node) => {
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }

                f(Node::Keyword(&node.end_foreach));
                f(Node::Terminator(&node.terminator));
            }
            Node::ForeachKeyValueTarget(node) => {
                f(Node::Expression(node.key));
                f(Node::Expression(node.value));
            }
            Node::ForeachTarget(node) => f(match node {
                ForeachTarget::KeyValue(node) => Node::ForeachKeyValueTarget(node),
                ForeachTarget::Value(node) => Node::ForeachValueTarget(node),
            }),
            Node::ForeachValueTarget(node) => f(Node::Expression(node.value)),
            Node::For(node) => {
                f(Node::Keyword(&node.r#for));

                for e in node.initializations.iter() {
                    f(Node::Expression(e));
                }
                for e in node.conditions.iter() {
                    f(Node::Expression(e));
                }
                for e in node.increments.iter() {
                    f(Node::Expression(e));
                }
                f(Node::ForBody(&node.body));
            }
            Node::ForBody(node) => match node {
                ForBody::Statement(statement) => f(Node::Statement(statement)),
                ForBody::ColonDelimited(body) => f(Node::ForColonDelimitedBody(body)),
            },
            Node::ForColonDelimitedBody(node) => {
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
                f(Node::Keyword(&node.end_for));
                f(Node::Terminator(&node.terminator));
            }
            Node::While(node) => {
                f(Node::Keyword(&node.r#while));
                f(Node::Expression(node.condition));
                f(Node::WhileBody(&node.body));
            }
            Node::WhileBody(node) => match node {
                WhileBody::Statement(statement) => f(Node::Statement(statement)),
                WhileBody::ColonDelimited(body) => f(Node::WhileColonDelimitedBody(body)),
            },
            Node::WhileColonDelimitedBody(node) => {
                for item in node.statements.iter() {
                    f(Node::Statement(item));
                }
                f(Node::Keyword(&node.end_while));
                f(Node::Terminator(&node.terminator));
            }
            Node::Break(node) => {
                f(Node::Keyword(&node.r#break));

                if let Some(level) = &node.level {
                    f(Node::Expression(level));
                }

                f(Node::Terminator(&node.terminator));
            }
            Node::Continue(node) => {
                f(Node::Keyword(&node.r#continue));

                if let Some(level) = &node.level {
                    f(Node::Expression(level));
                }

                f(Node::Terminator(&node.terminator));
            }
            Node::Return(node) => {
                f(Node::Keyword(&node.r#return));

                if let Some(value) = &node.value {
                    f(Node::Expression(value));
                }

                f(Node::Terminator(&node.terminator));
            }
            Node::Static(node) => {
                f(Node::Keyword(&node.r#static));

                for item in node.items.iter() {
                    f(Node::StaticItem(item));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::StaticItem(node) => f(match node {
                StaticItem::Abstract(item) => Node::StaticAbstractItem(item),
                StaticItem::Concrete(item) => Node::StaticConcreteItem(item),
            }),
            Node::StaticAbstractItem(node) => {
                f(Node::DirectVariable(&node.variable));
            }
            Node::StaticConcreteItem(node) => {
                f(Node::DirectVariable(&node.variable));
                f(Node::Expression(node.value));
            }
            Node::Try(node) => {
                f(Node::Keyword(&node.r#try));
                f(Node::Block(&node.block));
                for item in node.catch_clauses.iter() {
                    f(Node::TryCatchClause(item));
                }
                if let Some(finally) = &node.finally_clause {
                    f(Node::TryFinallyClause(finally));
                }
            }
            Node::TryCatchClause(node) => {
                f(Node::Keyword(&node.r#catch));
                f(Node::Hint(&node.hint));
                if let Some(variable) = &node.variable {
                    f(Node::DirectVariable(variable));
                }
                f(Node::Block(&node.block));
            }
            Node::TryFinallyClause(node) => {
                f(Node::Keyword(&node.r#finally));
                f(Node::Block(&node.block));
            }
            Node::MaybeTypedUseItem(node) => {
                if let Some(r#type) = &node.r#type {
                    f(Node::UseType(r#type));
                }

                f(Node::UseItem(&node.item));
            }
            Node::MixedUseItemList(node) => {
                f(Node::Identifier(&node.namespace));

                for item in node.items.iter() {
                    f(Node::MaybeTypedUseItem(item));
                }
            }
            Node::TypedUseItemList(node) => {
                f(Node::UseType(&node.r#type));
                f(Node::Identifier(&node.namespace));

                for item in node.items.iter() {
                    f(Node::UseItem(item));
                }
            }
            Node::TypedUseItemSequence(node) => {
                f(Node::UseType(&node.r#type));

                for item in node.items.iter() {
                    f(Node::UseItem(item));
                }
            }
            Node::Use(node) => {
                f(Node::Keyword(&node.r#use));
                f(Node::UseItems(&node.items));
                f(Node::Terminator(&node.terminator));
            }
            Node::UseItem(node) => {
                f(Node::Identifier(&node.name));

                if let Some(alias) = &node.alias {
                    f(Node::UseItemAlias(alias));
                }
            }
            Node::UseItemAlias(node) => {
                f(Node::Keyword(&node.r#as));
                f(Node::LocalIdentifier(&node.identifier));
            }
            Node::UseItemSequence(node) => {
                for item in &node.items {
                    f(Node::UseItem(item));
                }
            }
            Node::UseItems(node) => f(match node {
                UseItems::Sequence(node) => Node::UseItemSequence(node),
                UseItems::TypedList(node) => Node::TypedUseItemList(node),
                UseItems::MixedList(node) => Node::MixedUseItemList(node),
                UseItems::TypedSequence(node) => Node::TypedUseItemSequence(node),
            }),
            Node::UseType(node) => f(match node {
                UseType::Const(node) => Node::Keyword(node),
                UseType::Function(node) => Node::Keyword(node),
            }),
            Node::Yield(node) => f(match node {
                Yield::Value(node) => Node::YieldValue(node),
                Yield::Pair(node) => Node::YieldPair(node),
                Yield::From(node) => Node::YieldFrom(node),
            }),
            Node::YieldFrom(node) => {
                f(Node::Keyword(&node.r#yield));
                f(Node::Keyword(&node.from));
                f(Node::Expression(node.iterator));
            }
            Node::YieldPair(node) => {
                f(Node::Keyword(&node.r#yield));
                f(Node::Expression(node.key));
                f(Node::Expression(node.value));
            }
            Node::YieldValue(node) => {
                f(Node::Keyword(&node.r#yield));
                if let Some(value) = &node.value {
                    f(Node::Expression(value));
                }
            }
            Node::Statement(node) => match &node {
                Statement::OpeningTag(node) => f(Node::OpeningTag(node)),
                Statement::ClosingTag(node) => f(Node::ClosingTag(node)),
                Statement::Inline(node) => f(Node::Inline(node)),
                Statement::Namespace(node) => f(Node::Namespace(node)),
                Statement::Use(node) => f(Node::Use(node)),
                Statement::Class(node) => f(Node::Class(node)),
                Statement::Interface(node) => f(Node::Interface(node)),
                Statement::Trait(node) => f(Node::Trait(node)),
                Statement::Enum(node) => f(Node::Enum(node)),
                Statement::Block(node) => f(Node::Block(node)),
                Statement::Constant(node) => f(Node::Constant(node)),
                Statement::Function(node) => f(Node::Function(node)),
                Statement::Declare(node) => f(Node::Declare(node)),
                Statement::Goto(node) => f(Node::Goto(node)),
                Statement::Label(node) => f(Node::Label(node)),
                Statement::Try(node) => f(Node::Try(node)),
                Statement::Foreach(node) => f(Node::Foreach(node)),
                Statement::For(node) => f(Node::For(node)),
                Statement::While(node) => f(Node::While(node)),
                Statement::DoWhile(node) => f(Node::DoWhile(node)),
                Statement::Continue(node) => f(Node::Continue(node)),
                Statement::Break(node) => f(Node::Break(node)),
                Statement::Switch(node) => f(Node::Switch(node)),
                Statement::If(node) => f(Node::If(node)),
                Statement::Return(node) => f(Node::Return(node)),
                Statement::Expression(node) => f(Node::ExpressionStatement(node)),
                Statement::EchoTag(node) => f(Node::EchoTag(node)),
                Statement::Echo(node) => f(Node::Echo(node)),
                Statement::Global(node) => f(Node::Global(node)),
                Statement::Static(node) => f(Node::Static(node)),
                Statement::HaltCompiler(node) => f(Node::HaltCompiler(node)),
                Statement::Unset(node) => f(Node::Unset(node)),
                Statement::Noop(_) => {}
            },
            Node::ExpressionStatement(node) => {
                f(Node::Expression(node.expression));
                f(Node::Terminator(&node.terminator));
            }
            Node::BracedExpressionStringPart(node) => f(Node::Expression(node.expression)),
            Node::DocumentString(node) => {
                for part in node.parts.as_slice() {
                    f(Node::StringPart(part));
                }
            }
            Node::InterpolatedString(node) => {
                for part in node.parts.as_slice() {
                    f(Node::StringPart(part));
                }
            }
            Node::LiteralStringPart(_) => {}
            Node::ShellExecuteString(node) => {
                for part in node.parts.as_slice() {
                    f(Node::StringPart(part));
                }
            }
            Node::CompositeString(node) => f(match node {
                CompositeString::ShellExecute(node) => Node::ShellExecuteString(node),
                CompositeString::Interpolated(node) => Node::InterpolatedString(node),
                CompositeString::Document(node) => Node::DocumentString(node),
            }),
            Node::StringPart(node) => f(match node {
                StringPart::Literal(node) => Node::LiteralStringPart(node),
                StringPart::Expression(node) => Node::Expression(node),
                StringPart::BracedExpression(node) => Node::BracedExpressionStringPart(node),
            }),
            Node::ClosingTag(_) => {}
            Node::FullOpeningTag(_) => {}
            Node::OpeningTag(node) => match node {
                OpeningTag::Full(node) => f(Node::FullOpeningTag(node)),
                OpeningTag::Short(node) => f(Node::ShortOpeningTag(node)),
            },
            Node::ShortOpeningTag(_) => {}
            Node::Terminator(node) => match node {
                Terminator::Semicolon(_) => {}
                Terminator::ClosingTag(closing_tag) => f(Node::ClosingTag(closing_tag)),
                Terminator::TagPair(closing_tag, opening_tag) => {
                    f(Node::ClosingTag(closing_tag));
                    f(Node::OpeningTag(opening_tag));
                }
                Terminator::Missing(span) => f(Node::MissingTerminator(*span)),
            },
            Node::Throw(node) => {
                f(Node::Keyword(&node.throw));
                f(Node::Expression(node.exception));
            }
            Node::Hint(node) => match &node {
                Hint::Identifier(identifier) => f(Node::Identifier(identifier)),
                Hint::Parenthesized(parenthesized_hint) => {
                    f(Node::ParenthesizedHint(parenthesized_hint));
                }
                Hint::Nullable(nullable_hint) => f(Node::NullableHint(nullable_hint)),
                Hint::Union(union_hint) => f(Node::UnionHint(union_hint)),
                Hint::Intersection(intersection_hint) => f(Node::IntersectionHint(intersection_hint)),
                Hint::Null(keyword)
                | Hint::True(keyword)
                | Hint::False(keyword)
                | Hint::Array(keyword)
                | Hint::Callable(keyword)
                | Hint::Static(keyword)
                | Hint::Self_(keyword)
                | Hint::Parent(keyword) => f(Node::Keyword(keyword)),
                Hint::Void(local_identifier)
                | Hint::Never(local_identifier)
                | Hint::Float(local_identifier)
                | Hint::Bool(local_identifier)
                | Hint::Integer(local_identifier)
                | Hint::String(local_identifier)
                | Hint::Object(local_identifier)
                | Hint::Mixed(local_identifier)
                | Hint::Iterable(local_identifier) => f(Node::LocalIdentifier(local_identifier)),
            },
            Node::IntersectionHint(node) => {
                f(Node::Hint(node.left));
                f(Node::Hint(node.right));
            }
            Node::NullableHint(node) => f(Node::Hint(node.hint)),
            Node::ParenthesizedHint(node) => f(Node::Hint(node.hint)),
            Node::UnionHint(node) => {
                f(Node::Hint(node.left));
                f(Node::Hint(node.right));
            }
            Node::Unset(node) => {
                f(Node::Keyword(&node.unset));
                for e in node.values.iter() {
                    f(Node::Expression(e));
                }
                f(Node::Terminator(&node.terminator));
            }
            Node::DirectVariable(_) => {}
            Node::IndirectVariable(node) => f(Node::Expression(node.expression)),
            Node::NestedVariable(node) => {
                f(Node::Variable(node.variable));
            }
            Node::Variable(node) => match node {
                Variable::Direct(node) => f(Node::DirectVariable(node)),
                Variable::Indirect(node) => f(Node::IndirectVariable(node)),
                Variable::Nested(node) => f(Node::NestedVariable(node)),
            },
            Node::Pipe(pipe) => {
                f(Node::Expression(pipe.input));
                f(Node::Expression(pipe.callable));
            }
            Node::Error(_)
            | Node::MissingTerminator(_)
            | Node::ClassLikeMemberMissingSelector(_)
            | Node::ClassLikeConstantMissingSelector(_) => {}
        }
    }

    /// Returns all direct children as an owned `Vec`.
    ///
    /// This allocates on every call. Prefer [`Self::visit_children`] when you don't need a
    /// collected list — for example, when searching for a node or applying a transformation.
    #[inline]
    #[must_use]
    pub fn children(&self) -> Vec<Node<'ast, 'arena>> {
        let mut children = vec![];
        self.visit_children(|child| children.push(child));
        children
    }
}

impl HasSpan for Node<'_, '_> {
    fn span(&self) -> Span {
        match self {
            Self::Program(node) => node.span(),
            Self::Access(node) => node.span(),
            Self::ConstantAccess(node) => node.span(),
            Self::ClassConstantAccess(node) => node.span(),
            Self::NullSafePropertyAccess(node) => node.span(),
            Self::PropertyAccess(node) => node.span(),
            Self::StaticPropertyAccess(node) => node.span(),
            Self::Argument(node) => node.span(),
            Self::ArgumentList(node) => node.span(),
            Self::PartialArgument(node) => node.span(),
            Self::PartialArgumentList(node) => node.span(),
            Self::NamedArgument(node) => node.span(),
            Self::NamedPlaceholderArgument(node) => node.span(),
            Self::PlaceholderArgument(node) => node.span(),
            Self::PositionalArgument(node) => node.span(),
            Self::VariadicPlaceholderArgument(node) => node.span(),
            Self::Array(node) => node.span(),
            Self::ArrayAccess(node) => node.span(),
            Self::ArrayAppend(node) => node.span(),
            Self::ArrayElement(node) => node.span(),
            Self::KeyValueArrayElement(node) => node.span(),
            Self::LegacyArray(node) => node.span(),
            Self::List(node) => node.span(),
            Self::MissingArrayElement(node) => node.span(),
            Self::ValueArrayElement(node) => node.span(),
            Self::VariadicArrayElement(node) => node.span(),
            Self::Attribute(node) => node.span(),
            Self::AttributeList(node) => node.span(),
            Self::Block(node) => node.span(),
            Self::Call(node) => node.span(),
            Self::FunctionCall(node) => node.span(),
            Self::MethodCall(node) => node.span(),
            Self::NullSafeMethodCall(node) => node.span(),
            Self::StaticMethodCall(node) => node.span(),
            Self::PartialApplication(node) => node.span(),
            Self::FunctionPartialApplication(node) => node.span(),
            Self::MethodPartialApplication(node) => node.span(),
            Self::StaticMethodPartialApplication(node) => node.span(),
            Self::ClassLikeConstant(node) => node.span(),
            Self::ClassLikeConstantItem(node) => node.span(),
            Self::EnumCase(node) => node.span(),
            Self::EnumCaseBackedItem(node) => node.span(),
            Self::EnumCaseItem(node) => node.span(),
            Self::EnumCaseUnitItem(node) => node.span(),
            Self::Extends(node) => node.span(),
            Self::Implements(node) => node.span(),
            Self::ClassLikeConstantSelector(node) => node.span(),
            Self::ClassLikeMember(node) => node.span(),
            Self::ClassLikeMemberExpressionSelector(node) => node.span(),
            Self::ClassLikeMemberSelector(node) => node.span(),
            Self::Method(node) => node.span(),
            Self::MethodAbstractBody(node) => node.span(),
            Self::MethodBody(node) => node.span(),
            Self::HookedProperty(node) => node.span(),
            Self::PlainProperty(node) => node.span(),
            Self::Property(node) => node.span(),
            Self::PropertyAbstractItem(node) => node.span(),
            Self::PropertyConcreteItem(node) => node.span(),
            Self::PropertyHook(node) => node.span(),
            Self::PropertyHookAbstractBody(node) => node.span(),
            Self::PropertyHookBody(node) => node.span(),
            Self::PropertyHookConcreteBody(node) => node.span(),
            Self::PropertyHookConcreteExpressionBody(node) => node.span(),
            Self::PropertyHookList(node) => node.span(),
            Self::PropertyItem(node) => node.span(),
            Self::TraitUse(node) => node.span(),
            Self::TraitUseAbsoluteMethodReference(node) => node.span(),
            Self::TraitUseAbstractSpecification(node) => node.span(),
            Self::TraitUseAdaptation(node) => node.span(),
            Self::TraitUseAliasAdaptation(node) => node.span(),
            Self::TraitUseConcreteSpecification(node) => node.span(),
            Self::TraitUseMethodReference(node) => node.span(),
            Self::TraitUsePrecedenceAdaptation(node) => node.span(),
            Self::TraitUseSpecification(node) => node.span(),
            Self::AnonymousClass(node) => node.span(),
            Self::Class(node) => node.span(),
            Self::Enum(node) => node.span(),
            Self::EnumBackingTypeHint(node) => node.span(),
            Self::Interface(node) => node.span(),
            Self::Trait(node) => node.span(),
            Self::Clone(node) => node.span(),
            Self::Constant(node) => node.span(),
            Self::ConstantItem(node) => node.span(),
            Self::Construct(node) => node.span(),
            Self::DieConstruct(node) => node.span(),
            Self::EmptyConstruct(node) => node.span(),
            Self::EvalConstruct(node) => node.span(),
            Self::ExitConstruct(node) => node.span(),
            Self::IncludeConstruct(node) => node.span(),
            Self::IncludeOnceConstruct(node) => node.span(),
            Self::IssetConstruct(node) => node.span(),
            Self::PrintConstruct(node) => node.span(),
            Self::RequireConstruct(node) => node.span(),
            Self::RequireOnceConstruct(node) => node.span(),
            Self::If(node) => node.span(),
            Self::IfBody(node) => node.span(),
            Self::IfColonDelimitedBody(node) => node.span(),
            Self::IfColonDelimitedBodyElseClause(node) => node.span(),
            Self::IfColonDelimitedBodyElseIfClause(node) => node.span(),
            Self::IfStatementBody(node) => node.span(),
            Self::IfStatementBodyElseClause(node) => node.span(),
            Self::IfStatementBodyElseIfClause(node) => node.span(),
            Self::Match(node) => node.span(),
            Self::MatchArm(node) => node.span(),
            Self::MatchDefaultArm(node) => node.span(),
            Self::MatchExpressionArm(node) => node.span(),
            Self::Switch(node) => node.span(),
            Self::SwitchBody(node) => node.span(),
            Self::SwitchBraceDelimitedBody(node) => node.span(),
            Self::SwitchCase(node) => node.span(),
            Self::SwitchCaseSeparator(node) => node.span(),
            Self::SwitchColonDelimitedBody(node) => node.span(),
            Self::SwitchDefaultCase(node) => node.span(),
            Self::SwitchExpressionCase(node) => node.span(),
            Self::Declare(node) => node.span(),
            Self::DeclareBody(node) => node.span(),
            Self::DeclareColonDelimitedBody(node) => node.span(),
            Self::DeclareItem(node) => node.span(),
            Self::Echo(node) => node.span(),
            Self::Expression(node) => node.span(),
            Self::Binary(node) => node.span(),
            Self::BinaryOperator(node) => node.span(),
            Self::UnaryPrefix(node) => node.span(),
            Self::UnaryPrefixOperator(node) => node.span(),
            Self::UnaryPostfix(node) => node.span(),
            Self::UnaryPostfixOperator(node) => node.span(),
            Self::Parenthesized(node) => node.span(),
            Self::ArrowFunction(node) => node.span(),
            Self::Closure(node) => node.span(),
            Self::ClosureUseClause(node) => node.span(),
            Self::ClosureUseClauseVariable(node) => node.span(),
            Self::Function(node) => node.span(),
            Self::FunctionLikeParameter(node) => node.span(),
            Self::FunctionLikeParameterDefaultValue(node) => node.span(),
            Self::FunctionLikeParameterList(node) => node.span(),
            Self::FunctionLikeReturnTypeHint(node) => node.span(),
            Self::Global(node) => node.span(),
            Self::Goto(node) => node.span(),
            Self::Label(node) => node.span(),
            Self::HaltCompiler(node) => node.span(),
            Self::FullyQualifiedIdentifier(node) => node.span(),
            Self::Identifier(node) => node.span(),
            Self::LocalIdentifier(node) => node.span(),
            Self::QualifiedIdentifier(node) => node.span(),
            Self::Inline(node) => node.span(),
            Self::Instantiation(node) => node.span(),
            Self::Keyword(node) => node.span(),
            Self::Literal(node) => node.span(),
            Self::LiteralFloat(node) => node.span(),
            Self::LiteralInteger(node) => node.span(),
            Self::LiteralString(node) => node.span(),
            Self::MagicConstant(node) => node.span(),
            Self::Modifier(node) => node.span(),
            Self::Namespace(node) => node.span(),
            Self::NamespaceBody(node) => node.span(),
            Self::NamespaceImplicitBody(node) => node.span(),
            Self::Assignment(node) => node.span(),
            Self::AssignmentOperator(node) => node.span(),
            Self::Conditional(node) => node.span(),
            Self::DoWhile(node) => node.span(),
            Self::Foreach(node) => node.span(),
            Self::ForeachBody(node) => node.span(),
            Self::ForeachColonDelimitedBody(node) => node.span(),
            Self::ForeachKeyValueTarget(node) => node.span(),
            Self::ForeachTarget(node) => node.span(),
            Self::ForeachValueTarget(node) => node.span(),
            Self::For(node) => node.span(),
            Self::ForBody(node) => node.span(),
            Self::ForColonDelimitedBody(node) => node.span(),
            Self::While(node) => node.span(),
            Self::WhileBody(node) => node.span(),
            Self::WhileColonDelimitedBody(node) => node.span(),
            Self::Break(node) => node.span(),
            Self::Continue(node) => node.span(),
            Self::Return(node) => node.span(),
            Self::Static(node) => node.span(),
            Self::StaticAbstractItem(node) => node.span(),
            Self::StaticConcreteItem(node) => node.span(),
            Self::StaticItem(node) => node.span(),
            Self::Try(node) => node.span(),
            Self::TryCatchClause(node) => node.span(),
            Self::TryFinallyClause(node) => node.span(),
            Self::MaybeTypedUseItem(node) => node.span(),
            Self::MixedUseItemList(node) => node.span(),
            Self::TypedUseItemList(node) => node.span(),
            Self::TypedUseItemSequence(node) => node.span(),
            Self::Use(node) => node.span(),
            Self::UseItem(node) => node.span(),
            Self::UseItemAlias(node) => node.span(),
            Self::UseItemSequence(node) => node.span(),
            Self::UseItems(node) => node.span(),
            Self::UseType(node) => node.span(),
            Self::Yield(node) => node.span(),
            Self::YieldFrom(node) => node.span(),
            Self::YieldPair(node) => node.span(),
            Self::YieldValue(node) => node.span(),
            Self::Statement(node) => node.span(),
            Self::ExpressionStatement(node) => node.span(),
            Self::BracedExpressionStringPart(node) => node.span(),
            Self::DocumentString(node) => node.span(),
            Self::InterpolatedString(node) => node.span(),
            Self::LiteralStringPart(node) => node.span(),
            Self::ShellExecuteString(node) => node.span(),
            Self::CompositeString(node) => node.span(),
            Self::StringPart(node) => node.span(),
            Self::ClosingTag(node) => node.span(),
            Self::EchoTag(node) => node.span(),
            Self::FullOpeningTag(node) => node.span(),
            Self::OpeningTag(node) => node.span(),
            Self::ShortOpeningTag(node) => node.span(),
            Self::Terminator(node) => node.span(),
            Self::Throw(node) => node.span(),
            Self::Hint(node) => node.span(),
            Self::IntersectionHint(node) => node.span(),
            Self::NullableHint(node) => node.span(),
            Self::ParenthesizedHint(node) => node.span(),
            Self::UnionHint(node) => node.span(),
            Self::Unset(node) => node.span(),
            Self::DirectVariable(node) => node.span(),
            Self::IndirectVariable(node) => node.span(),
            Self::NestedVariable(node) => node.span(),
            Self::Variable(node) => node.span(),
            Self::Pipe(node) => node.span(),
            Self::Error(span)
            | Self::MissingTerminator(span)
            | Self::ClassLikeMemberMissingSelector(span)
            | Self::ClassLikeConstantMissingSelector(span) => *span,
        }
    }
}