mago_syntax/ast/

node.rs

use std::fmt::Debug;

use serde::Serialize;
use strum::Display;

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

use crate::ast::Program;
use crate::ast::ast::*;

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord, Display)]
#[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,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord, Display)]
#[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),
    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>),
}

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

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

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

        result
    }

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

    #[inline]
    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]
    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,
        }
    }

    #[inline]
    pub fn children(&self) -> Vec<Node<'ast, 'arena>> {
        match &self {
            Node::Program(node) => {
                let mut children = vec![];
                for node in node.statements.as_slice() {
                    children.push(Node::Statement(node));
                }

                children
            }
            Node::Access(node) => match &node {
                Access::Property(node) => vec![Node::PropertyAccess(node)],
                Access::NullSafeProperty(node) => vec![Node::NullSafePropertyAccess(node)],
                Access::StaticProperty(node) => vec![Node::StaticPropertyAccess(node)],
                Access::ClassConstant(node) => vec![Node::ClassConstantAccess(node)],
            },
            Node::ConstantAccess(node) => {
                vec![Node::Identifier(&node.name)]
            }
            Node::ClassConstantAccess(node) => {
                vec![Node::Expression(node.class), Node::ClassLikeConstantSelector(&node.constant)]
            }
            Node::NullSafePropertyAccess(node) => {
                vec![Node::Expression(node.object), Node::ClassLikeMemberSelector(&node.property)]
            }
            Node::PropertyAccess(node) => {
                vec![Node::Expression(node.object), Node::ClassLikeMemberSelector(&node.property)]
            }
            Node::StaticPropertyAccess(node) => {
                vec![Node::Expression(node.class), Node::Variable(&node.property)]
            }
            Node::Argument(node) => match &node {
                Argument::Named(node) => vec![Node::NamedArgument(node)],
                Argument::Positional(node) => vec![Node::PositionalArgument(node)],
            },
            Node::ArgumentList(node) => {
                let mut children = vec![];
                for node in node.arguments.as_slice() {
                    children.push(Node::Argument(node));
                }

                children
            }
            Node::PartialArgument(node) => match &node {
                PartialArgument::Named(node) => vec![Node::NamedArgument(node)],
                PartialArgument::NamedPlaceholder(node) => vec![Node::NamedPlaceholderArgument(node)],
                PartialArgument::Placeholder(node) => vec![Node::PlaceholderArgument(node)],
                PartialArgument::Positional(node) => vec![Node::PositionalArgument(node)],
                PartialArgument::VariadicPlaceholder(node) => vec![Node::VariadicPlaceholderArgument(node)],
            },
            Node::PartialArgumentList(node) => {
                let mut children = vec![];
                for node in node.arguments.as_slice() {
                    children.push(Node::PartialArgument(node));
                }

                children
            }
            Node::NamedArgument(node) => {
                vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
            }
            Node::NamedPlaceholderArgument(node) => {
                vec![Node::LocalIdentifier(&node.name)]
            }
            Node::PlaceholderArgument(_) => vec![],
            Node::PositionalArgument(node) => vec![Node::Expression(&node.value)],
            Node::VariadicPlaceholderArgument(_) => vec![],
            Node::Array(node) => {
                let mut children = vec![];
                for node in node.elements.as_slice() {
                    children.push(Node::ArrayElement(node));
                }

                children
            }
            Node::ArrayAccess(node) => {
                vec![Node::Expression(node.array), Node::Expression(node.index)]
            }
            Node::ArrayAppend(node) => {
                vec![Node::Expression(node.array)]
            }
            Node::ArrayElement(node) => match &node {
                ArrayElement::KeyValue(node) => vec![Node::KeyValueArrayElement(node)],
                ArrayElement::Missing(node) => vec![Node::MissingArrayElement(node)],
                ArrayElement::Value(node) => vec![Node::ValueArrayElement(node)],
                ArrayElement::Variadic(node) => vec![Node::VariadicArrayElement(node)],
            },
            Node::KeyValueArrayElement(node) => {
                vec![Node::Expression(node.key), Node::Expression(node.value)]
            }
            Node::LegacyArray(node) => Vec::from_iter(node.elements.iter().map(Node::ArrayElement)),
            Node::List(node) => Vec::from_iter(node.elements.iter().map(Node::ArrayElement)),
            Node::MissingArrayElement(_) => vec![],
            Node::ValueArrayElement(node) => vec![Node::Expression(node.value)],
            Node::VariadicArrayElement(node) => vec![Node::Expression(node.value)],
            Node::Attribute(node) => {
                let mut children = vec![Node::Identifier(&node.name)];
                if let Some(arguments) = &node.argument_list {
                    children.push(Node::ArgumentList(arguments));
                }

                children
            }
            Node::AttributeList(node) => Vec::from_iter(node.attributes.iter().map(Node::Attribute)),
            Node::Block(node) => Vec::from_iter(node.statements.iter().map(Node::Statement)),
            Node::Call(node) => match node {
                Call::Function(node) => vec![Node::FunctionCall(node)],
                Call::Method(node) => vec![Node::MethodCall(node)],
                Call::NullSafeMethod(node) => vec![Node::NullSafeMethodCall(node)],
                Call::StaticMethod(node) => vec![Node::StaticMethodCall(node)],
            },
            Node::FunctionCall(node) => {
                vec![Node::Expression(node.function), Node::ArgumentList(&node.argument_list)]
            }
            Node::MethodCall(node) => {
                vec![
                    Node::Expression(node.object),
                    Node::ClassLikeMemberSelector(&node.method),
                    Node::ArgumentList(&node.argument_list),
                ]
            }
            Node::NullSafeMethodCall(node) => {
                vec![
                    Node::Expression(node.object),
                    Node::ClassLikeMemberSelector(&node.method),
                    Node::ArgumentList(&node.argument_list),
                ]
            }
            Node::StaticMethodCall(node) => {
                vec![
                    Node::Expression(node.class),
                    Node::ClassLikeMemberSelector(&node.method),
                    Node::ArgumentList(&node.argument_list),
                ]
            }
            Node::PartialApplication(node) => match node {
                PartialApplication::Function(node) => vec![Node::FunctionPartialApplication(node)],
                PartialApplication::Method(node) => vec![Node::MethodPartialApplication(node)],
                PartialApplication::StaticMethod(node) => vec![Node::StaticMethodPartialApplication(node)],
            },
            Node::FunctionPartialApplication(node) => {
                vec![Node::Expression(node.function), Node::PartialArgumentList(&node.argument_list)]
            }
            Node::MethodPartialApplication(node) => {
                vec![
                    Node::Expression(node.object),
                    Node::ClassLikeMemberSelector(&node.method),
                    Node::PartialArgumentList(&node.argument_list),
                ]
            }
            Node::StaticMethodPartialApplication(node) => {
                vec![
                    Node::Expression(node.class),
                    Node::ClassLikeMemberSelector(&node.method),
                    Node::PartialArgumentList(&node.argument_list),
                ]
            }
            Node::ClassLikeConstant(node) => {
                let mut children = vec![];
                for attr in node.attribute_lists.iter() {
                    children.push(Node::AttributeList(attr));
                }

                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.push(Node::Keyword(&node.r#const));
                if let Some(hint) = &node.hint {
                    children.push(Node::Hint(hint));
                }

                children.extend(node.items.iter().map(Node::ClassLikeConstantItem));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::ClassLikeConstantItem(node) => {
                vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
            }
            Node::EnumCase(node) => {
                let mut children = vec![];
                for attr in node.attribute_lists.iter() {
                    children.push(Node::AttributeList(attr));
                }

                children.push(Node::Keyword(&node.case));
                children.push(Node::EnumCaseItem(&node.item));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::EnumCaseBackedItem(node) => {
                vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
            }
            Node::EnumCaseItem(node) => match &node {
                EnumCaseItem::Backed(node) => vec![Node::EnumCaseBackedItem(node)],
                EnumCaseItem::Unit(node) => vec![Node::EnumCaseUnitItem(node)],
            },
            Node::EnumCaseUnitItem(node) => vec![Node::LocalIdentifier(&node.name)],
            Node::Extends(node) => {
                let mut children = vec![];

                children.push(Node::Keyword(&node.extends));
                children.extend(node.types.iter().map(Node::Identifier));

                children
            }
            Node::Implements(node) => {
                let mut children = vec![];

                children.push(Node::Keyword(&node.implements));
                children.extend(node.types.iter().map(Node::Identifier));

                children
            }
            Node::ClassLikeConstantSelector(node) => match node {
                ClassLikeConstantSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
                ClassLikeConstantSelector::Expression(node) => {
                    vec![Node::ClassLikeMemberExpressionSelector(node)]
                }
            },
            Node::ClassLikeMember(node) => match node {
                ClassLikeMember::TraitUse(node) => vec![Node::TraitUse(node)],
                ClassLikeMember::Constant(node) => vec![Node::ClassLikeConstant(node)],
                ClassLikeMember::Property(node) => vec![Node::Property(node)],
                ClassLikeMember::EnumCase(node) => vec![Node::EnumCase(node)],
                ClassLikeMember::Method(node) => vec![Node::Method(node)],
            },
            Node::ClassLikeMemberExpressionSelector(node) => vec![Node::Expression(node.expression)],
            Node::ClassLikeMemberSelector(node) => match node {
                ClassLikeMemberSelector::Identifier(node) => vec![Node::LocalIdentifier(node)],
                ClassLikeMemberSelector::Variable(node) => vec![Node::Variable(node)],
                ClassLikeMemberSelector::Expression(node) => {
                    vec![Node::ClassLikeMemberExpressionSelector(node)]
                }
            },
            Node::Method(node) => {
                let mut children: Vec<Node> = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.push(Node::Keyword(&node.function));
                children.push(Node::LocalIdentifier(&node.name));
                children.push(Node::FunctionLikeParameterList(&node.parameter_list));
                children.extend(node.return_type_hint.iter().map(Node::FunctionLikeReturnTypeHint));
                children.push(Node::MethodBody(&node.body));

                children
            }
            Node::MethodAbstractBody(_) => vec![],
            Node::MethodBody(node) => match node {
                MethodBody::Abstract(node) => vec![Node::MethodAbstractBody(node)],
                MethodBody::Concrete(node) => vec![Node::Block(node)],
            },
            Node::HookedProperty(node) => {
                let mut children: Vec<Node> = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.var.iter().map(Node::Keyword));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.extend(node.hint.iter().map(Node::Hint));
                children.push(Node::PropertyItem(&node.item));
                children.push(Node::PropertyHookList(&node.hook_list));

                children
            }
            Node::PlainProperty(node) => {
                let mut children: Vec<Node> = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.var.iter().map(Node::Keyword));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.extend(node.hint.iter().map(Node::Hint));
                children.extend(node.items.iter().map(Node::PropertyItem));

                children
            }
            Node::Property(node) => match node {
                Property::Plain(node) => vec![Node::PlainProperty(node)],
                Property::Hooked(node) => vec![Node::HookedProperty(node)],
            },
            Node::PropertyAbstractItem(node) => {
                vec![Node::DirectVariable(&node.variable)]
            }
            Node::PropertyConcreteItem(node) => {
                vec![Node::DirectVariable(&node.variable), Node::Expression(&node.value)]
            }
            Node::PropertyHook(node) => {
                let mut children: Vec<Node> = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.push(Node::LocalIdentifier(&node.name));
                children.extend(node.parameter_list.iter().map(Node::FunctionLikeParameterList));
                children.push(Node::PropertyHookBody(&node.body));

                children
            }
            Node::PropertyHookAbstractBody(_) => {
                vec![]
            }
            Node::PropertyHookBody(node) => vec![match node {
                PropertyHookBody::Abstract(node) => Node::PropertyHookAbstractBody(node),
                PropertyHookBody::Concrete(node) => Node::PropertyHookConcreteBody(node),
            }],
            Node::PropertyHookConcreteBody(node) => vec![match node {
                PropertyHookConcreteBody::Expression(node) => Node::PropertyHookConcreteExpressionBody(node),
                PropertyHookConcreteBody::Block(node) => Node::Block(node),
            }],
            Node::PropertyHookConcreteExpressionBody(node) => vec![Node::Expression(&node.expression)],
            Node::PropertyHookList(node) => Vec::from_iter(node.hooks.iter().map(Node::PropertyHook)),
            Node::PropertyItem(node) => match node {
                PropertyItem::Abstract(node) => vec![Node::PropertyAbstractItem(node)],
                PropertyItem::Concrete(node) => vec![Node::PropertyConcreteItem(node)],
            },
            Node::TraitUse(node) => {
                let mut children: Vec<Node> = vec![];

                children.push(Node::Keyword(&node.r#use));
                children.extend(node.trait_names.iter().map(Node::Identifier));
                children.push(Node::TraitUseSpecification(&node.specification));

                children
            }
            Node::TraitUseAbsoluteMethodReference(node) => {
                vec![Node::Identifier(&node.trait_name), Node::LocalIdentifier(&node.method_name)]
            }
            Node::TraitUseAbstractSpecification(node) => vec![Node::Terminator(&node.0)],
            Node::TraitUseAdaptation(node) => match node {
                TraitUseAdaptation::Precedence(adaptation) => {
                    let mut children = vec![
                        Node::TraitUseAbsoluteMethodReference(&adaptation.method_reference),
                        Node::Keyword(&adaptation.insteadof),
                    ];

                    children.extend(adaptation.trait_names.iter().map(Node::Identifier));
                    children.push(Node::Terminator(&adaptation.terminator));

                    children
                }
                TraitUseAdaptation::Alias(adaptation) => {
                    let mut children = vec![
                        Node::TraitUseMethodReference(&adaptation.method_reference),
                        Node::Keyword(&adaptation.r#as),
                    ];

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

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

                    children.push(Node::Terminator(&adaptation.terminator));
                    children
                }
            },
            Node::TraitUseAliasAdaptation(node) => {
                let mut children =
                    vec![Node::TraitUseMethodReference(&node.method_reference), Node::Keyword(&node.r#as)];

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

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

                children.push(Node::Terminator(&node.terminator));
                children
            }
            Node::TraitUseConcreteSpecification(node) => {
                let mut children = vec![];
                for adaptation in node.adaptations.as_slice() {
                    children.push(Node::TraitUseAdaptation(adaptation));
                }

                children
            }
            Node::TraitUseMethodReference(node) => match node {
                TraitUseMethodReference::Identifier(identifier) => {
                    vec![Node::LocalIdentifier(identifier)]
                }
                TraitUseMethodReference::Absolute(reference) => {
                    vec![Node::TraitUseAbsoluteMethodReference(reference)]
                }
            },
            Node::TraitUsePrecedenceAdaptation(node) => {
                let mut children =
                    vec![Node::TraitUseAbsoluteMethodReference(&node.method_reference), Node::Keyword(&node.insteadof)];

                children.extend(node.trait_names.iter().map(Node::Identifier));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::TraitUseSpecification(node) => match node {
                TraitUseSpecification::Abstract(specification) => {
                    vec![Node::TraitUseAbstractSpecification(specification)]
                }
                TraitUseSpecification::Concrete(specification) => {
                    vec![Node::TraitUseConcreteSpecification(specification)]
                }
            },
            Node::AnonymousClass(node) => {
                let mut children = vec![Node::Keyword(&node.new)];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.push(Node::Keyword(&node.class));
                if let Some(argument_list) = &node.argument_list {
                    children.push(Node::ArgumentList(argument_list));
                }
                children.extend(node.extends.iter().map(Node::Extends));
                children.extend(node.implements.iter().map(Node::Implements));
                children.extend(node.members.iter().map(Node::ClassLikeMember));

                children
            }
            Node::Class(node) => {
                let mut children = vec![];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                children.push(Node::Keyword(&node.class));
                children.push(Node::LocalIdentifier(&node.name));
                children.extend(node.extends.iter().map(Node::Extends));
                children.extend(node.implements.iter().map(Node::Implements));
                children.extend(node.members.iter().map(Node::ClassLikeMember));

                children
            }
            Node::Enum(node) => {
                let mut children = vec![];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.r#enum));
                children.push(Node::LocalIdentifier(&node.name));
                children.extend(node.backing_type_hint.iter().map(Node::EnumBackingTypeHint));
                children.extend(node.implements.iter().map(Node::Implements));
                children.extend(node.members.iter().map(Node::ClassLikeMember));

                children
            }
            Node::EnumBackingTypeHint(node) => {
                vec![Node::Hint(&node.hint)]
            }
            Node::Interface(node) => {
                let mut children = vec![];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.interface));
                children.push(Node::LocalIdentifier(&node.name));
                children.extend(node.extends.iter().map(Node::Extends));
                children.extend(node.members.iter().map(Node::ClassLikeMember));

                children
            }
            Node::Trait(node) => {
                let mut children = vec![];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.r#trait));
                children.push(Node::LocalIdentifier(&node.name));
                children.extend(node.members.iter().map(Node::ClassLikeMember));

                children
            }
            Node::Clone(node) => {
                vec![Node::Keyword(&node.clone), Node::Expression(node.object)]
            }
            Node::Constant(node) => {
                let mut children = vec![];
                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.r#const));
                children.extend(node.items.iter().map(Node::ConstantItem));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::ConstantItem(node) => {
                vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
            }
            Node::Construct(node) => vec![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) => {
                let mut children = vec![Node::Keyword(&node.isset)];
                children.extend(node.values.iter().map(Node::Expression));

                children
            }
            Node::EmptyConstruct(node) => {
                vec![Node::Keyword(&node.empty), Node::Expression(node.value)]
            }
            Node::EvalConstruct(node) => {
                vec![Node::Keyword(&node.eval), Node::Expression(node.value)]
            }
            Node::IncludeConstruct(node) => {
                vec![Node::Keyword(&node.include), Node::Expression(node.value)]
            }
            Node::IncludeOnceConstruct(node) => {
                vec![Node::Keyword(&node.include_once), Node::Expression(node.value)]
            }
            Node::RequireConstruct(node) => {
                vec![Node::Keyword(&node.require), Node::Expression(node.value)]
            }
            Node::RequireOnceConstruct(node) => {
                vec![Node::Keyword(&node.require_once), Node::Expression(node.value)]
            }
            Node::PrintConstruct(node) => {
                vec![Node::Keyword(&node.print), Node::Expression(node.value)]
            }
            Node::ExitConstruct(node) => {
                let mut children = vec![Node::Keyword(&node.exit)];
                if let Some(arguments) = &node.arguments {
                    children.push(Node::ArgumentList(arguments));
                }
                children
            }
            Node::DieConstruct(node) => {
                let mut children = vec![Node::Keyword(&node.die)];
                if let Some(arguments) = &node.arguments {
                    children.push(Node::ArgumentList(arguments));
                }
                children
            }
            Node::If(node) => {
                vec![Node::Keyword(&node.r#if), Node::Expression(node.condition), Node::IfBody(&node.body)]
            }
            Node::IfBody(node) => match node {
                IfBody::Statement(statement_body) => vec![Node::IfStatementBody(statement_body)],
                IfBody::ColonDelimited(colon_body) => vec![Node::IfColonDelimitedBody(colon_body)],
            },
            Node::IfStatementBody(node) => {
                let mut children = vec![Node::Statement(node.statement)];

                children.extend(node.else_if_clauses.iter().map(Node::IfStatementBodyElseIfClause));
                if let Some(else_clause) = &node.else_clause {
                    children.push(Node::IfStatementBodyElseClause(else_clause));
                }

                children
            }
            Node::IfStatementBodyElseIfClause(node) => {
                vec![Node::Keyword(&node.elseif), Node::Expression(node.condition), Node::Statement(node.statement)]
            }
            Node::IfStatementBodyElseClause(node) => {
                vec![Node::Keyword(&node.r#else), Node::Statement(node.statement)]
            }
            Node::IfColonDelimitedBody(node) => {
                let mut children = vec![];
                for stmt in node.statements.as_slice() {
                    children.push(Node::Statement(stmt));
                }

                children.extend(node.else_if_clauses.iter().map(Node::IfColonDelimitedBodyElseIfClause));

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

                children.push(Node::Keyword(&node.endif));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::IfColonDelimitedBodyElseIfClause(node) => {
                let mut children = vec![Node::Keyword(&node.elseif), Node::Expression(node.condition)];
                children.extend(node.statements.iter().map(Node::Statement));

                children
            }
            Node::IfColonDelimitedBodyElseClause(node) => {
                let mut children = vec![Node::Keyword(&node.r#else)];

                children.extend(node.statements.iter().map(Node::Statement));

                children
            }
            Node::Match(node) => {
                let mut children = vec![Node::Keyword(&node.r#match), Node::Expression(node.expression)];
                children.extend(node.arms.iter().map(Node::MatchArm));

                children
            }
            Node::MatchArm(node) => match node {
                MatchArm::Expression(expr_arm) => vec![Node::MatchExpressionArm(expr_arm)],
                MatchArm::Default(default_arm) => vec![Node::MatchDefaultArm(default_arm)],
            },
            Node::MatchExpressionArm(node) => {
                let mut children = vec![];

                children.extend(node.conditions.iter().map(Node::Expression));
                children.push(Node::Expression(node.expression));

                children
            }
            Node::MatchDefaultArm(node) => {
                vec![Node::Keyword(&node.default), Node::Expression(node.expression)]
            }
            Node::Switch(node) => {
                vec![Node::Keyword(&node.switch), Node::Expression(node.expression), Node::SwitchBody(&node.body)]
            }
            Node::SwitchBody(node) => match node {
                SwitchBody::BraceDelimited(body) => vec![Node::SwitchBraceDelimitedBody(body)],
                SwitchBody::ColonDelimited(body) => vec![Node::SwitchColonDelimitedBody(body)],
            },
            Node::SwitchBraceDelimitedBody(node) => {
                let mut children = vec![];

                if let Some(terminator) = &node.optional_terminator {
                    children.push(Node::Terminator(terminator));
                }

                children.extend(node.cases.iter().map(Node::SwitchCase));

                children
            }
            Node::SwitchColonDelimitedBody(node) => {
                let mut children = vec![];

                if let Some(terminator) = &node.optional_terminator {
                    children.push(Node::Terminator(terminator));
                }

                children.extend(node.cases.iter().map(Node::SwitchCase));
                children.push(Node::Keyword(&node.end_switch));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::SwitchCase(node) => match node {
                SwitchCase::Expression(expression_case) => {
                    vec![Node::SwitchExpressionCase(expression_case)]
                }
                SwitchCase::Default(default_case) => vec![Node::SwitchDefaultCase(default_case)],
            },
            Node::SwitchExpressionCase(node) => {
                let mut children = vec![
                    Node::Keyword(&node.case),
                    Node::Expression(node.expression),
                    Node::SwitchCaseSeparator(&node.separator),
                ];

                children.extend(node.statements.iter().map(Node::Statement));

                children
            }
            Node::SwitchDefaultCase(node) => {
                let mut children = vec![Node::Keyword(&node.default), Node::SwitchCaseSeparator(&node.separator)];
                children.extend(node.statements.iter().map(Node::Statement));

                children
            }
            Node::SwitchCaseSeparator(_) => vec![],
            Node::Declare(node) => {
                let mut children = vec![Node::Keyword(&node.declare)];

                children.extend(node.items.iter().map(Node::DeclareItem));
                children.push(Node::DeclareBody(&node.body));

                children
            }
            Node::DeclareBody(node) => match node {
                DeclareBody::Statement(statement) => vec![Node::Statement(statement)],
                DeclareBody::ColonDelimited(body) => vec![Node::DeclareColonDelimitedBody(body)],
            },
            Node::DeclareColonDelimitedBody(node) => {
                let mut children = Vec::from_iter(node.statements.iter().map(Node::Statement));

                children.push(Node::Keyword(&node.end_declare));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::DeclareItem(node) => {
                vec![Node::LocalIdentifier(&node.name), Node::Expression(&node.value)]
            }
            Node::EchoTag(node) => {
                let mut children = vec![];
                children.extend(node.values.iter().map(Node::Expression));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Echo(node) => {
                let mut children = vec![Node::Keyword(&node.echo)];
                children.extend(node.values.iter().map(Node::Expression));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Parenthesized(node) => vec![Node::Expression(node.expression)],
            Node::Expression(node) => vec![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),
            }],
            Node::Binary(node) => {
                vec![Node::Expression(node.lhs), Node::BinaryOperator(&node.operator), Node::Expression(node.rhs)]
            }
            Node::BinaryOperator(operator) => match operator {
                BinaryOperator::Addition(_) => vec![],
                BinaryOperator::Subtraction(_) => vec![],
                BinaryOperator::Multiplication(_) => vec![],
                BinaryOperator::Division(_) => vec![],
                BinaryOperator::Modulo(_) => vec![],
                BinaryOperator::Exponentiation(_) => vec![],
                BinaryOperator::BitwiseAnd(_) => vec![],
                BinaryOperator::BitwiseOr(_) => vec![],
                BinaryOperator::BitwiseXor(_) => vec![],
                BinaryOperator::LeftShift(_) => vec![],
                BinaryOperator::RightShift(_) => vec![],
                BinaryOperator::NullCoalesce(_) => vec![],
                BinaryOperator::Equal(_) => vec![],
                BinaryOperator::NotEqual(_) => vec![],
                BinaryOperator::Identical(_) => vec![],
                BinaryOperator::NotIdentical(_) => vec![],
                BinaryOperator::AngledNotEqual(_) => vec![],
                BinaryOperator::LessThan(_) => vec![],
                BinaryOperator::LessThanOrEqual(_) => vec![],
                BinaryOperator::GreaterThan(_) => vec![],
                BinaryOperator::GreaterThanOrEqual(_) => vec![],
                BinaryOperator::Spaceship(_) => vec![],
                BinaryOperator::StringConcat(_) => vec![],
                BinaryOperator::And(_) => vec![],
                BinaryOperator::Or(_) => vec![],
                BinaryOperator::Instanceof(keyword) => vec![Node::Keyword(keyword)],
                BinaryOperator::LowAnd(keyword) => vec![Node::Keyword(keyword)],
                BinaryOperator::LowOr(keyword) => vec![Node::Keyword(keyword)],
                BinaryOperator::LowXor(keyword) => vec![Node::Keyword(keyword)],
            },
            Node::UnaryPrefix(node) => {
                vec![Node::UnaryPrefixOperator(&node.operator), Node::Expression(node.operand)]
            }
            Node::UnaryPostfix(node) => {
                vec![Node::Expression(node.operand), Node::UnaryPostfixOperator(&node.operator)]
            }
            Node::UnaryPrefixOperator(_) | Node::UnaryPostfixOperator(_) => vec![],
            Node::ArrowFunction(node) => {
                let mut children = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                if let Some(r#static) = &node.r#static {
                    children.push(Node::Keyword(r#static));
                }
                children.push(Node::Keyword(&node.r#fn));
                children.push(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(return_type_hint) = &node.return_type_hint {
                    children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }
                children.push(Node::Expression(node.expression));

                children
            }
            Node::Closure(node) => {
                let mut children = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.function));
                children.push(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(use_clause) = &node.use_clause {
                    children.push(Node::ClosureUseClause(use_clause));
                }
                if let Some(return_type_hint) = &node.return_type_hint {
                    children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }
                children.push(Node::Block(&node.body));

                children
            }
            Node::ClosureUseClause(node) => {
                let mut children = vec![Node::Keyword(&node.r#use)];
                children.extend(node.variables.iter().map(Node::ClosureUseClauseVariable));

                children
            }
            Node::ClosureUseClauseVariable(node) => vec![Node::DirectVariable(&node.variable)],
            Node::Function(node) => {
                let mut children = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.push(Node::Keyword(&node.function));
                children.push(Node::LocalIdentifier(&node.name));
                children.push(Node::FunctionLikeParameterList(&node.parameter_list));
                if let Some(return_type_hint) = &node.return_type_hint {
                    children.push(Node::FunctionLikeReturnTypeHint(return_type_hint));
                }

                children.push(Node::Block(&node.body));

                children
            }
            Node::FunctionLikeParameterList(node) => {
                Vec::from_iter(node.parameters.iter().map(Node::FunctionLikeParameter))
            }
            Node::FunctionLikeParameter(node) => {
                let mut children = vec![];

                children.extend(node.attribute_lists.iter().map(Node::AttributeList));
                children.extend(node.modifiers.iter().map(Node::Modifier));
                if let Some(hint) = &node.hint {
                    children.push(Node::Hint(hint));
                }
                children.push(Node::DirectVariable(&node.variable));
                if let Some(default_value) = &node.default_value {
                    children.push(Node::FunctionLikeParameterDefaultValue(default_value));
                }

                if let Some(hooks) = &node.hooks {
                    children.push(Node::PropertyHookList(hooks));
                }

                children
            }
            Node::FunctionLikeParameterDefaultValue(node) => vec![Node::Expression(&node.value)],
            Node::FunctionLikeReturnTypeHint(hint) => vec![Node::Hint(&hint.hint)],
            Node::Global(node) => {
                let mut children: Vec<Node> = vec![];

                children.push(Node::Keyword(&node.r#global));
                children.extend(node.variables.iter().map(Node::Variable));

                children
            }
            Node::Goto(node) => {
                vec![Node::Keyword(&node.r#goto), Node::LocalIdentifier(&node.label)]
            }
            Node::Label(node) => {
                vec![Node::LocalIdentifier(&node.name)]
            }
            Node::HaltCompiler(node) => {
                vec![Node::Keyword(&node.halt_compiler)]
            }
            Node::FullyQualifiedIdentifier(_) => vec![],
            Node::Identifier(node) => vec![match node {
                Identifier::Local(node) => Node::LocalIdentifier(node),
                Identifier::Qualified(node) => Node::QualifiedIdentifier(node),
                Identifier::FullyQualified(node) => Node::FullyQualifiedIdentifier(node),
            }],
            Node::LocalIdentifier(_) => vec![],
            Node::QualifiedIdentifier(_) => vec![],
            Node::Inline(_) => vec![],
            Node::Instantiation(node) => {
                let mut children = vec![Node::Keyword(&node.new), Node::Expression(node.class)];

                if let Some(argument_list) = &node.argument_list {
                    children.push(Node::ArgumentList(argument_list));
                }

                children
            }
            Node::Keyword(_) => vec![],
            Node::Literal(node) => vec![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(_) => vec![],
            Node::LiteralInteger(_) => vec![],
            Node::LiteralString(_) => vec![],
            Node::MagicConstant(node) => vec![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) => vec![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) => {
                let mut children = vec![Node::Keyword(&node.r#namespace)];

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

                children.push(Node::NamespaceBody(&node.body));

                children
            }
            Node::NamespaceBody(node) => {
                vec![match node {
                    NamespaceBody::BraceDelimited(node) => Node::Block(node),
                    NamespaceBody::Implicit(node) => Node::NamespaceImplicitBody(node),
                }]
            }
            Node::NamespaceImplicitBody(node) => {
                let mut children = vec![Node::Terminator(&node.terminator)];

                children.extend(node.statements.iter().map(Node::Statement));

                children
            }
            Node::Assignment(node) => {
                vec![Node::Expression(node.lhs), Node::AssignmentOperator(&node.operator), Node::Expression(node.rhs)]
            }
            Node::AssignmentOperator(_) => vec![],
            Node::Conditional(node) => {
                let mut children = vec![Node::Expression(node.condition)];

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

                children.push(Node::Expression(node.r#else));

                children
            }
            Node::DoWhile(node) => vec![
                Node::Keyword(&node.r#do),
                Node::Statement(node.statement),
                Node::Keyword(&node.r#while),
                Node::Expression(node.condition),
                Node::Terminator(&node.terminator),
            ],
            Node::Foreach(node) => vec![
                Node::Keyword(&node.r#foreach),
                Node::Expression(node.expression),
                Node::Keyword(&node.r#as),
                Node::ForeachTarget(&node.target),
                Node::ForeachBody(&node.body),
            ],
            Node::ForeachBody(node) => vec![match node {
                ForeachBody::Statement(node) => Node::Statement(node),
                ForeachBody::ColonDelimited(node) => Node::ForeachColonDelimitedBody(node),
            }],
            Node::ForeachColonDelimitedBody(node) => {
                let mut children = Vec::from_iter(node.statements.iter().map(Node::Statement));

                children.push(Node::Keyword(&node.end_foreach));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::ForeachKeyValueTarget(node) => {
                vec![Node::Expression(node.key), Node::Expression(node.value)]
            }
            Node::ForeachTarget(node) => vec![match node {
                ForeachTarget::KeyValue(node) => Node::ForeachKeyValueTarget(node),
                ForeachTarget::Value(node) => Node::ForeachValueTarget(node),
            }],
            Node::ForeachValueTarget(node) => vec![Node::Expression(node.value)],
            Node::For(node) => {
                let mut children = vec![Node::Keyword(&node.r#for)];

                children.extend(node.initializations.iter().map(Node::Expression));
                children.extend(node.conditions.iter().map(Node::Expression));
                children.extend(node.increments.iter().map(Node::Expression));
                children.push(Node::ForBody(&node.body));

                children
            }
            Node::ForBody(node) => match node {
                ForBody::Statement(statement) => vec![Node::Statement(statement)],
                ForBody::ColonDelimited(body) => vec![Node::ForColonDelimitedBody(body)],
            },
            Node::ForColonDelimitedBody(node) => {
                let mut children = vec![];

                children.extend(node.statements.iter().map(Node::Statement));
                children.push(Node::Keyword(&node.end_for));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::While(node) => {
                vec![Node::Keyword(&node.r#while), Node::Expression(node.condition), Node::WhileBody(&node.body)]
            }
            Node::WhileBody(node) => match node {
                WhileBody::Statement(statement) => vec![Node::Statement(statement)],
                WhileBody::ColonDelimited(body) => vec![Node::WhileColonDelimitedBody(body)],
            },
            Node::WhileColonDelimitedBody(node) => {
                let mut children = vec![];

                children.extend(node.statements.iter().map(Node::Statement));
                children.push(Node::Keyword(&node.end_while));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Break(node) => {
                let mut children = vec![Node::Keyword(&node.r#break)];

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

                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Continue(node) => {
                let mut children = vec![Node::Keyword(&node.r#continue)];

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

                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Return(node) => {
                let mut children = vec![Node::Keyword(&node.r#return)];

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

                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::Static(node) => {
                let mut children = vec![Node::Keyword(&node.r#static)];

                children.extend(node.items.iter().map(Node::StaticItem));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::StaticItem(node) => vec![match node {
                StaticItem::Abstract(item) => Node::StaticAbstractItem(item),
                StaticItem::Concrete(item) => Node::StaticConcreteItem(item),
            }],
            Node::StaticAbstractItem(node) => {
                vec![Node::DirectVariable(&node.variable)]
            }
            Node::StaticConcreteItem(node) => {
                vec![Node::DirectVariable(&node.variable), Node::Expression(&node.value)]
            }
            Node::Try(node) => {
                let mut children = vec![];

                children.push(Node::Keyword(&node.r#try));
                children.push(Node::Block(&node.block));
                children.extend(node.catch_clauses.iter().map(Node::TryCatchClause));
                if let Some(finally) = &node.finally_clause {
                    children.push(Node::TryFinallyClause(finally));
                }

                children
            }
            Node::TryCatchClause(node) => {
                let mut children = vec![Node::Keyword(&node.r#catch), Node::Hint(&node.hint)];
                if let Some(variable) = &node.variable {
                    children.push(Node::DirectVariable(variable));
                }
                children.push(Node::Block(&node.block));

                children
            }
            Node::TryFinallyClause(node) => {
                vec![Node::Keyword(&node.r#finally), Node::Block(&node.block)]
            }
            Node::MaybeTypedUseItem(node) => {
                let mut children = vec![];
                if let Some(r#type) = &node.r#type {
                    children.push(Node::UseType(r#type));
                }

                children.push(Node::UseItem(&node.item));

                children
            }
            Node::MixedUseItemList(node) => {
                let mut children = vec![Node::Identifier(&node.namespace)];

                children.extend(node.items.iter().map(Node::MaybeTypedUseItem));

                children
            }
            Node::TypedUseItemList(node) => {
                let mut children = vec![Node::UseType(&node.r#type), Node::Identifier(&node.namespace)];

                children.extend(node.items.iter().map(Node::UseItem));

                children
            }
            Node::TypedUseItemSequence(node) => {
                let mut children = vec![Node::UseType(&node.r#type)];

                children.extend(node.items.iter().map(Node::UseItem));
                children
            }
            Node::Use(node) => {
                vec![Node::Keyword(&node.r#use), Node::UseItems(&node.items), Node::Terminator(&node.terminator)]
            }
            Node::UseItem(node) => {
                let mut result = vec![Node::Identifier(&node.name)];

                if let Some(alias) = &node.alias {
                    result.push(Node::UseItemAlias(alias));
                }

                result
            }
            Node::UseItemAlias(node) => {
                vec![Node::Keyword(&node.r#as), Node::LocalIdentifier(&node.identifier)]
            }
            Node::UseItemSequence(node) => {
                let mut children = vec![];
                for item in node.items.iter() {
                    children.push(Node::UseItem(item));
                }

                children
            }
            Node::UseItems(node) => vec![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) => vec![match node {
                UseType::Const(node) => Node::Keyword(node),
                UseType::Function(node) => Node::Keyword(node),
            }],
            Node::Yield(node) => vec![match node {
                Yield::Value(node) => Node::YieldValue(node),
                Yield::Pair(node) => Node::YieldPair(node),
                Yield::From(node) => Node::YieldFrom(node),
            }],
            Node::YieldFrom(node) => {
                vec![Node::Keyword(&node.r#yield), Node::Keyword(&node.from), Node::Expression(node.iterator)]
            }
            Node::YieldPair(node) => {
                vec![Node::Keyword(&node.r#yield), Node::Expression(node.key), Node::Expression(node.value)]
            }
            Node::YieldValue(node) => match &node.value {
                Some(value) => vec![Node::Keyword(&node.r#yield), Node::Expression(value)],
                None => vec![Node::Keyword(&node.r#yield)],
            },
            Node::Statement(node) => match &node {
                Statement::OpeningTag(node) => vec![Node::OpeningTag(node)],
                Statement::ClosingTag(node) => vec![Node::ClosingTag(node)],
                Statement::Inline(node) => vec![Node::Inline(node)],
                Statement::Namespace(node) => vec![Node::Namespace(node)],
                Statement::Use(node) => vec![Node::Use(node)],
                Statement::Class(node) => vec![Node::Class(node)],
                Statement::Interface(node) => vec![Node::Interface(node)],
                Statement::Trait(node) => vec![Node::Trait(node)],
                Statement::Enum(node) => vec![Node::Enum(node)],
                Statement::Block(node) => vec![Node::Block(node)],
                Statement::Constant(node) => vec![Node::Constant(node)],
                Statement::Function(node) => vec![Node::Function(node)],
                Statement::Declare(node) => vec![Node::Declare(node)],
                Statement::Goto(node) => vec![Node::Goto(node)],
                Statement::Label(node) => vec![Node::Label(node)],
                Statement::Try(node) => vec![Node::Try(node)],
                Statement::Foreach(node) => vec![Node::Foreach(node)],
                Statement::For(node) => vec![Node::For(node)],
                Statement::While(node) => vec![Node::While(node)],
                Statement::DoWhile(node) => vec![Node::DoWhile(node)],
                Statement::Continue(node) => vec![Node::Continue(node)],
                Statement::Break(node) => vec![Node::Break(node)],
                Statement::Switch(node) => vec![Node::Switch(node)],
                Statement::If(node) => vec![Node::If(node)],
                Statement::Return(node) => vec![Node::Return(node)],
                Statement::Expression(node) => vec![Node::ExpressionStatement(node)],
                Statement::EchoTag(node) => vec![Node::EchoTag(node)],
                Statement::Echo(node) => vec![Node::Echo(node)],
                Statement::Global(node) => vec![Node::Global(node)],
                Statement::Static(node) => vec![Node::Static(node)],
                Statement::HaltCompiler(node) => vec![Node::HaltCompiler(node)],
                Statement::Unset(node) => vec![Node::Unset(node)],
                Statement::Noop(_) => vec![],
            },
            Node::ExpressionStatement(node) => {
                vec![Node::Expression(node.expression), Node::Terminator(&node.terminator)]
            }
            Node::BracedExpressionStringPart(node) => vec![Node::Expression(node.expression)],
            Node::DocumentString(node) => {
                let mut children = vec![];
                for part in node.parts.as_slice() {
                    children.push(Node::StringPart(part));
                }

                children
            }
            Node::InterpolatedString(node) => {
                let mut children = vec![];
                for part in node.parts.as_slice() {
                    children.push(Node::StringPart(part));
                }

                children
            }
            Node::LiteralStringPart(_) => vec![],
            Node::ShellExecuteString(node) => {
                let mut children = vec![];
                for part in node.parts.as_slice() {
                    children.push(Node::StringPart(part));
                }

                children
            }
            Node::CompositeString(node) => vec![match node {
                CompositeString::ShellExecute(node) => Node::ShellExecuteString(node),
                CompositeString::Interpolated(node) => Node::InterpolatedString(node),
                CompositeString::Document(node) => Node::DocumentString(node),
            }],
            Node::StringPart(node) => vec![match node {
                StringPart::Literal(node) => Node::LiteralStringPart(node),
                StringPart::Expression(node) => Node::Expression(node),
                StringPart::BracedExpression(node) => Node::BracedExpressionStringPart(node),
            }],
            Node::ClosingTag(_) => vec![],
            Node::FullOpeningTag(_) => vec![],
            Node::OpeningTag(node) => match node {
                OpeningTag::Full(node) => vec![Node::FullOpeningTag(node)],
                OpeningTag::Short(node) => vec![Node::ShortOpeningTag(node)],
            },
            Node::ShortOpeningTag(_) => vec![],
            Node::Terminator(node) => match node {
                Terminator::Semicolon(_) => vec![],
                Terminator::ClosingTag(closing_tag) => vec![Node::ClosingTag(closing_tag)],
                Terminator::TagPair(closing_tag, opening_tag) => {
                    vec![Node::ClosingTag(closing_tag), Node::OpeningTag(opening_tag)]
                }
            },
            Node::Throw(node) => vec![Node::Keyword(&node.throw), Node::Expression(node.exception)],
            Node::Hint(node) => match &node {
                Hint::Identifier(identifier) => vec![Node::Identifier(identifier)],
                Hint::Parenthesized(parenthesized_hint) => {
                    vec![Node::ParenthesizedHint(parenthesized_hint)]
                }
                Hint::Nullable(nullable_hint) => vec![Node::NullableHint(nullable_hint)],
                Hint::Union(union_hint) => vec![Node::UnionHint(union_hint)],
                Hint::Intersection(intersection_hint) => vec![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) => vec![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) => vec![Node::LocalIdentifier(local_identifier)],
            },
            Node::IntersectionHint(node) => vec![Node::Hint(node.left), Node::Hint(node.right)],
            Node::NullableHint(node) => vec![Node::Hint(node.hint)],
            Node::ParenthesizedHint(node) => vec![Node::Hint(node.hint)],
            Node::UnionHint(node) => vec![Node::Hint(node.left), Node::Hint(node.right)],
            Node::Unset(node) => {
                let mut children = vec![Node::Keyword(&node.unset)];
                children.extend(node.values.iter().map(Node::Expression));
                children.push(Node::Terminator(&node.terminator));

                children
            }
            Node::DirectVariable(_) => vec![],
            Node::IndirectVariable(node) => vec![Node::Expression(node.expression)],
            Node::NestedVariable(node) => {
                vec![Node::Variable(node.variable)]
            }
            Node::Variable(node) => match node {
                Variable::Direct(node) => vec![Node::DirectVariable(node)],
                Variable::Indirect(node) => vec![Node::IndirectVariable(node)],
                Variable::Nested(node) => vec![Node::NestedVariable(node)],
            },
            Node::Pipe(pipe) => {
                vec![Node::Expression(pipe.input), Node::Expression(pipe.callable)]
            }
        }
    }
}

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(),
        }
    }
}