//! ECMAScript Abstract Syntax Tree visitors.
//!
//! This module contains visitors which can be used to inspect or modify AST nodes. This allows for
//! fine-grained manipulation of ASTs for analysis, rewriting, or instrumentation.

use std::ops::ControlFlow;

use crate::{
    declaration::{
        Binding, Declaration, LexicalDeclaration, VarDeclaration, Variable, VariableList,
    },
    expression::{
        access::{
            PrivatePropertyAccess, PropertyAccess, PropertyAccessField, SimplePropertyAccess,
            SuperPropertyAccess,
        },
        literal::{ArrayLiteral, Literal, ObjectLiteral, TemplateElement, TemplateLiteral},
        operator::{
            assign::{Assign, AssignTarget},
            Binary, Conditional, Unary,
        },
        Await, Call, Expression, Identifier, New, Optional, OptionalOperation,
        OptionalOperationKind, Spread, SuperCall, TaggedTemplate, Yield,
    },
    function::{
        ArrowFunction, AsyncArrowFunction, AsyncFunction, AsyncGenerator, Class, ClassElement,
        FormalParameter, FormalParameterList, Function, Generator, PrivateName,
    },
    pattern::{ArrayPattern, ArrayPatternElement, ObjectPattern, ObjectPatternElement, Pattern},
    property::{MethodDefinition, PropertyDefinition, PropertyName},
    statement::{
        iteration::{
            Break, Continue, DoWhileLoop, ForInLoop, ForLoop, ForLoopInitializer, ForOfLoop,
            IterableLoopInitializer, WhileLoop,
        },
        Block, Case, Catch, Finally, If, Labelled, LabelledItem, Return, Statement, Switch, Throw,
        Try,
    },
    StatementList, StatementListItem,
};
use boa_interner::Sym;

/// `Try`-like conditional unwrapping of `ControlFlow`.
#[macro_export]
macro_rules! try_break {
    ($expr:expr) => {
        match $expr {
            core::ops::ControlFlow::Continue(c) => c,
            core::ops::ControlFlow::Break(b) => return core::ops::ControlFlow::Break(b),
        }
    };
}

/// Creates the default visit function implementation for a particular type
macro_rules! define_visit {
    ($fn_name:ident, $type_name:ident) => {
        #[doc = concat!("Visits a `", stringify!($type_name), "` with this visitor")]
        fn $fn_name(&mut self, node: &'ast $type_name) -> ControlFlow<Self::BreakTy> {
            node.visit_with(self)
        }
    };
}

/// Creates the default mutable visit function implementation for a particular type
macro_rules! define_visit_mut {
    ($fn_name:ident, $type_name:ident) => {
        #[doc = concat!("Visits a `", stringify!($type_name), "` with this visitor, mutably")]
        fn $fn_name(&mut self, node: &'ast mut $type_name) -> ControlFlow<Self::BreakTy> {
            node.visit_with_mut(self)
        }
    };
}

/// Generates the `NodeRef` and `NodeMutRef` enums from a list of variants.
macro_rules! node_ref {
    (
        $(
            $Variant:ident
        ),*
        $(,)?
    ) => {
        /// A reference to a node visitable by a [`Visitor`].
        #[derive(Debug, Clone, Copy)]
        #[allow(missing_docs)]
        pub enum NodeRef<'a> {
            $(
                $Variant(&'a $Variant)
            ),*
        }

        $(
            impl<'a> From<&'a $Variant> for NodeRef<'a> {
                fn from(node: &'a $Variant) -> NodeRef<'a> {
                    Self::$Variant(node)
                }
            }
        )*

        /// A mutable reference to a node visitable by a [`VisitorMut`].
        #[derive(Debug)]
        #[allow(missing_docs)]
        pub enum NodeRefMut<'a> {
            $(
                $Variant(&'a mut $Variant)
            ),*
        }

        $(
            impl<'a> From<&'a mut $Variant> for NodeRefMut<'a> {
                fn from(node: &'a mut $Variant) -> NodeRefMut<'a> {
                    Self::$Variant(node)
                }
            }
        )*
    }
}

node_ref! {
    StatementList,
    StatementListItem,
    Statement,
    Declaration,
    Function,
    Generator,
    AsyncFunction,
    AsyncGenerator,
    Class,
    LexicalDeclaration,
    Block,
    VarDeclaration,
    Expression,
    If,
    DoWhileLoop,
    WhileLoop,
    ForLoop,
    ForInLoop,
    ForOfLoop,
    Switch,
    Continue,
    Break,
    Return,
    Labelled,
    Throw,
    Try,
    Identifier,
    FormalParameterList,
    ClassElement,
    PrivateName,
    VariableList,
    Variable,
    Binding,
    Pattern,
    Literal,
    ArrayLiteral,
    ObjectLiteral,
    Spread,
    ArrowFunction,
    AsyncArrowFunction,
    TemplateLiteral,
    PropertyAccess,
    New,
    Call,
    SuperCall,
    Optional,
    TaggedTemplate,
    Assign,
    Unary,
    Binary,
    Conditional,
    Await,
    Yield,
    ForLoopInitializer,
    IterableLoopInitializer,
    Case,
    Sym,
    LabelledItem,
    Catch,
    Finally,
    FormalParameter,
    PropertyName,
    MethodDefinition,
    ObjectPattern,
    ArrayPattern,
    PropertyDefinition,
    TemplateElement,
    SimplePropertyAccess,
    PrivatePropertyAccess,
    SuperPropertyAccess,
    OptionalOperation,
    AssignTarget,
    ObjectPatternElement,
    ArrayPatternElement,
    PropertyAccessField,
    OptionalOperationKind,
}

/// Represents an AST visitor.
///
/// This implementation is based largely on [chalk](https://github.com/rust-lang/chalk/blob/23d39c90ceb9242fbd4c43e9368e813e7c2179f7/chalk-ir/src/visit.rs)'s
/// visitor pattern.
pub trait Visitor<'ast>: Sized {
    /// Type which will be propagated from the visitor if completing early.
    type BreakTy;

    define_visit!(visit_statement_list, StatementList);
    define_visit!(visit_statement_list_item, StatementListItem);
    define_visit!(visit_statement, Statement);
    define_visit!(visit_declaration, Declaration);
    define_visit!(visit_function, Function);
    define_visit!(visit_generator, Generator);
    define_visit!(visit_async_function, AsyncFunction);
    define_visit!(visit_async_generator, AsyncGenerator);
    define_visit!(visit_class, Class);
    define_visit!(visit_lexical_declaration, LexicalDeclaration);
    define_visit!(visit_block, Block);
    define_visit!(visit_var_declaration, VarDeclaration);
    define_visit!(visit_expression, Expression);
    define_visit!(visit_if, If);
    define_visit!(visit_do_while_loop, DoWhileLoop);
    define_visit!(visit_while_loop, WhileLoop);
    define_visit!(visit_for_loop, ForLoop);
    define_visit!(visit_for_in_loop, ForInLoop);
    define_visit!(visit_for_of_loop, ForOfLoop);
    define_visit!(visit_switch, Switch);
    define_visit!(visit_continue, Continue);
    define_visit!(visit_break, Break);
    define_visit!(visit_return, Return);
    define_visit!(visit_labelled, Labelled);
    define_visit!(visit_throw, Throw);
    define_visit!(visit_try, Try);
    define_visit!(visit_identifier, Identifier);
    define_visit!(visit_formal_parameter_list, FormalParameterList);
    define_visit!(visit_class_element, ClassElement);
    define_visit!(visit_private_name, PrivateName);
    define_visit!(visit_variable_list, VariableList);
    define_visit!(visit_variable, Variable);
    define_visit!(visit_binding, Binding);
    define_visit!(visit_pattern, Pattern);
    define_visit!(visit_literal, Literal);
    define_visit!(visit_array_literal, ArrayLiteral);
    define_visit!(visit_object_literal, ObjectLiteral);
    define_visit!(visit_spread, Spread);
    define_visit!(visit_arrow_function, ArrowFunction);
    define_visit!(visit_async_arrow_function, AsyncArrowFunction);
    define_visit!(visit_template_literal, TemplateLiteral);
    define_visit!(visit_property_access, PropertyAccess);
    define_visit!(visit_new, New);
    define_visit!(visit_call, Call);
    define_visit!(visit_super_call, SuperCall);
    define_visit!(visit_optional, Optional);
    define_visit!(visit_tagged_template, TaggedTemplate);
    define_visit!(visit_assign, Assign);
    define_visit!(visit_unary, Unary);
    define_visit!(visit_binary, Binary);
    define_visit!(visit_conditional, Conditional);
    define_visit!(visit_await, Await);
    define_visit!(visit_yield, Yield);
    define_visit!(visit_for_loop_initializer, ForLoopInitializer);
    define_visit!(visit_iterable_loop_initializer, IterableLoopInitializer);
    define_visit!(visit_case, Case);
    define_visit!(visit_sym, Sym);
    define_visit!(visit_labelled_item, LabelledItem);
    define_visit!(visit_catch, Catch);
    define_visit!(visit_finally, Finally);
    define_visit!(visit_formal_parameter, FormalParameter);
    define_visit!(visit_property_name, PropertyName);
    define_visit!(visit_method_definition, MethodDefinition);
    define_visit!(visit_object_pattern, ObjectPattern);
    define_visit!(visit_array_pattern, ArrayPattern);
    define_visit!(visit_property_definition, PropertyDefinition);
    define_visit!(visit_template_element, TemplateElement);
    define_visit!(visit_simple_property_access, SimplePropertyAccess);
    define_visit!(visit_private_property_access, PrivatePropertyAccess);
    define_visit!(visit_super_property_access, SuperPropertyAccess);
    define_visit!(visit_optional_operation, OptionalOperation);
    define_visit!(visit_assign_target, AssignTarget);
    define_visit!(visit_object_pattern_element, ObjectPatternElement);
    define_visit!(visit_array_pattern_element, ArrayPatternElement);
    define_visit!(visit_property_access_field, PropertyAccessField);
    define_visit!(visit_optional_operation_kind, OptionalOperationKind);

    /// Generic entry point for a node that is visitable by a `Visitor`.
    ///
    /// This is usually used for generic functions that need to visit an unnamed AST node.
    fn visit<N: Into<NodeRef<'ast>>>(&mut self, node: N) -> ControlFlow<Self::BreakTy> {
        let node = node.into();
        match node {
            NodeRef::StatementList(n) => self.visit_statement_list(n),
            NodeRef::StatementListItem(n) => self.visit_statement_list_item(n),
            NodeRef::Statement(n) => self.visit_statement(n),
            NodeRef::Declaration(n) => self.visit_declaration(n),
            NodeRef::Function(n) => self.visit_function(n),
            NodeRef::Generator(n) => self.visit_generator(n),
            NodeRef::AsyncFunction(n) => self.visit_async_function(n),
            NodeRef::AsyncGenerator(n) => self.visit_async_generator(n),
            NodeRef::Class(n) => self.visit_class(n),
            NodeRef::LexicalDeclaration(n) => self.visit_lexical_declaration(n),
            NodeRef::Block(n) => self.visit_block(n),
            NodeRef::VarDeclaration(n) => self.visit_var_declaration(n),
            NodeRef::Expression(n) => self.visit_expression(n),
            NodeRef::If(n) => self.visit_if(n),
            NodeRef::DoWhileLoop(n) => self.visit_do_while_loop(n),
            NodeRef::WhileLoop(n) => self.visit_while_loop(n),
            NodeRef::ForLoop(n) => self.visit_for_loop(n),
            NodeRef::ForInLoop(n) => self.visit_for_in_loop(n),
            NodeRef::ForOfLoop(n) => self.visit_for_of_loop(n),
            NodeRef::Switch(n) => self.visit_switch(n),
            NodeRef::Continue(n) => self.visit_continue(n),
            NodeRef::Break(n) => self.visit_break(n),
            NodeRef::Return(n) => self.visit_return(n),
            NodeRef::Labelled(n) => self.visit_labelled(n),
            NodeRef::Throw(n) => self.visit_throw(n),
            NodeRef::Try(n) => self.visit_try(n),
            NodeRef::Identifier(n) => self.visit_identifier(n),
            NodeRef::FormalParameterList(n) => self.visit_formal_parameter_list(n),
            NodeRef::ClassElement(n) => self.visit_class_element(n),
            NodeRef::PrivateName(n) => self.visit_private_name(n),
            NodeRef::VariableList(n) => self.visit_variable_list(n),
            NodeRef::Variable(n) => self.visit_variable(n),
            NodeRef::Binding(n) => self.visit_binding(n),
            NodeRef::Pattern(n) => self.visit_pattern(n),
            NodeRef::Literal(n) => self.visit_literal(n),
            NodeRef::ArrayLiteral(n) => self.visit_array_literal(n),
            NodeRef::ObjectLiteral(n) => self.visit_object_literal(n),
            NodeRef::Spread(n) => self.visit_spread(n),
            NodeRef::ArrowFunction(n) => self.visit_arrow_function(n),
            NodeRef::AsyncArrowFunction(n) => self.visit_async_arrow_function(n),
            NodeRef::TemplateLiteral(n) => self.visit_template_literal(n),
            NodeRef::PropertyAccess(n) => self.visit_property_access(n),
            NodeRef::New(n) => self.visit_new(n),
            NodeRef::Call(n) => self.visit_call(n),
            NodeRef::SuperCall(n) => self.visit_super_call(n),
            NodeRef::Optional(n) => self.visit_optional(n),
            NodeRef::TaggedTemplate(n) => self.visit_tagged_template(n),
            NodeRef::Assign(n) => self.visit_assign(n),
            NodeRef::Unary(n) => self.visit_unary(n),
            NodeRef::Binary(n) => self.visit_binary(n),
            NodeRef::Conditional(n) => self.visit_conditional(n),
            NodeRef::Await(n) => self.visit_await(n),
            NodeRef::Yield(n) => self.visit_yield(n),
            NodeRef::ForLoopInitializer(n) => self.visit_for_loop_initializer(n),
            NodeRef::IterableLoopInitializer(n) => self.visit_iterable_loop_initializer(n),
            NodeRef::Case(n) => self.visit_case(n),
            NodeRef::Sym(n) => self.visit_sym(n),
            NodeRef::LabelledItem(n) => self.visit_labelled_item(n),
            NodeRef::Catch(n) => self.visit_catch(n),
            NodeRef::Finally(n) => self.visit_finally(n),
            NodeRef::FormalParameter(n) => self.visit_formal_parameter(n),
            NodeRef::PropertyName(n) => self.visit_property_name(n),
            NodeRef::MethodDefinition(n) => self.visit_method_definition(n),
            NodeRef::ObjectPattern(n) => self.visit_object_pattern(n),
            NodeRef::ArrayPattern(n) => self.visit_array_pattern(n),
            NodeRef::PropertyDefinition(n) => self.visit_property_definition(n),
            NodeRef::TemplateElement(n) => self.visit_template_element(n),
            NodeRef::SimplePropertyAccess(n) => self.visit_simple_property_access(n),
            NodeRef::PrivatePropertyAccess(n) => self.visit_private_property_access(n),
            NodeRef::SuperPropertyAccess(n) => self.visit_super_property_access(n),
            NodeRef::OptionalOperation(n) => self.visit_optional_operation(n),
            NodeRef::AssignTarget(n) => self.visit_assign_target(n),
            NodeRef::ObjectPatternElement(n) => self.visit_object_pattern_element(n),
            NodeRef::ArrayPatternElement(n) => self.visit_array_pattern_element(n),
            NodeRef::PropertyAccessField(n) => self.visit_property_access_field(n),
            NodeRef::OptionalOperationKind(n) => self.visit_optional_operation_kind(n),
        }
    }
}

/// Represents an AST visitor which can modify AST content.
///
/// This implementation is based largely on [chalk](https://github.com/rust-lang/chalk/blob/23d39c90ceb9242fbd4c43e9368e813e7c2179f7/chalk-ir/src/visit.rs)'s
/// visitor pattern.
pub trait VisitorMut<'ast>: Sized {
    /// Type which will be propagated from the visitor if completing early.
    type BreakTy;

    define_visit_mut!(visit_statement_list_mut, StatementList);
    define_visit_mut!(visit_statement_list_item_mut, StatementListItem);
    define_visit_mut!(visit_statement_mut, Statement);
    define_visit_mut!(visit_declaration_mut, Declaration);
    define_visit_mut!(visit_function_mut, Function);
    define_visit_mut!(visit_generator_mut, Generator);
    define_visit_mut!(visit_async_function_mut, AsyncFunction);
    define_visit_mut!(visit_async_generator_mut, AsyncGenerator);
    define_visit_mut!(visit_class_mut, Class);
    define_visit_mut!(visit_lexical_declaration_mut, LexicalDeclaration);
    define_visit_mut!(visit_block_mut, Block);
    define_visit_mut!(visit_var_declaration_mut, VarDeclaration);
    define_visit_mut!(visit_expression_mut, Expression);
    define_visit_mut!(visit_if_mut, If);
    define_visit_mut!(visit_do_while_loop_mut, DoWhileLoop);
    define_visit_mut!(visit_while_loop_mut, WhileLoop);
    define_visit_mut!(visit_for_loop_mut, ForLoop);
    define_visit_mut!(visit_for_in_loop_mut, ForInLoop);
    define_visit_mut!(visit_for_of_loop_mut, ForOfLoop);
    define_visit_mut!(visit_switch_mut, Switch);
    define_visit_mut!(visit_continue_mut, Continue);
    define_visit_mut!(visit_break_mut, Break);
    define_visit_mut!(visit_return_mut, Return);
    define_visit_mut!(visit_labelled_mut, Labelled);
    define_visit_mut!(visit_throw_mut, Throw);
    define_visit_mut!(visit_try_mut, Try);
    define_visit_mut!(visit_identifier_mut, Identifier);
    define_visit_mut!(visit_formal_parameter_list_mut, FormalParameterList);
    define_visit_mut!(visit_class_element_mut, ClassElement);
    define_visit_mut!(visit_private_name_mut, PrivateName);
    define_visit_mut!(visit_variable_list_mut, VariableList);
    define_visit_mut!(visit_variable_mut, Variable);
    define_visit_mut!(visit_binding_mut, Binding);
    define_visit_mut!(visit_pattern_mut, Pattern);
    define_visit_mut!(visit_literal_mut, Literal);
    define_visit_mut!(visit_array_literal_mut, ArrayLiteral);
    define_visit_mut!(visit_object_literal_mut, ObjectLiteral);
    define_visit_mut!(visit_spread_mut, Spread);
    define_visit_mut!(visit_arrow_function_mut, ArrowFunction);
    define_visit_mut!(visit_async_arrow_function_mut, AsyncArrowFunction);
    define_visit_mut!(visit_template_literal_mut, TemplateLiteral);
    define_visit_mut!(visit_property_access_mut, PropertyAccess);
    define_visit_mut!(visit_new_mut, New);
    define_visit_mut!(visit_call_mut, Call);
    define_visit_mut!(visit_super_call_mut, SuperCall);
    define_visit_mut!(visit_optional_mut, Optional);
    define_visit_mut!(visit_tagged_template_mut, TaggedTemplate);
    define_visit_mut!(visit_assign_mut, Assign);
    define_visit_mut!(visit_unary_mut, Unary);
    define_visit_mut!(visit_binary_mut, Binary);
    define_visit_mut!(visit_conditional_mut, Conditional);
    define_visit_mut!(visit_await_mut, Await);
    define_visit_mut!(visit_yield_mut, Yield);
    define_visit_mut!(visit_for_loop_initializer_mut, ForLoopInitializer);
    define_visit_mut!(visit_iterable_loop_initializer_mut, IterableLoopInitializer);
    define_visit_mut!(visit_case_mut, Case);
    define_visit_mut!(visit_sym_mut, Sym);
    define_visit_mut!(visit_labelled_item_mut, LabelledItem);
    define_visit_mut!(visit_catch_mut, Catch);
    define_visit_mut!(visit_finally_mut, Finally);
    define_visit_mut!(visit_formal_parameter_mut, FormalParameter);
    define_visit_mut!(visit_property_name_mut, PropertyName);
    define_visit_mut!(visit_method_definition_mut, MethodDefinition);
    define_visit_mut!(visit_object_pattern_mut, ObjectPattern);
    define_visit_mut!(visit_array_pattern_mut, ArrayPattern);
    define_visit_mut!(visit_property_definition_mut, PropertyDefinition);
    define_visit_mut!(visit_template_element_mut, TemplateElement);
    define_visit_mut!(visit_simple_property_access_mut, SimplePropertyAccess);
    define_visit_mut!(visit_private_property_access_mut, PrivatePropertyAccess);
    define_visit_mut!(visit_super_property_access_mut, SuperPropertyAccess);
    define_visit_mut!(visit_optional_operation_mut, OptionalOperation);
    define_visit_mut!(visit_assign_target_mut, AssignTarget);
    define_visit_mut!(visit_object_pattern_element_mut, ObjectPatternElement);
    define_visit_mut!(visit_array_pattern_element_mut, ArrayPatternElement);
    define_visit_mut!(visit_property_access_field_mut, PropertyAccessField);
    define_visit_mut!(visit_optional_operation_kind_mut, OptionalOperationKind);

    /// Generic entry point for a node that is visitable by a `VisitorMut`.
    ///
    /// This is usually used for generic functions that need to visit an unnamed AST node.
    fn visit<N: Into<NodeRefMut<'ast>>>(&mut self, node: N) -> ControlFlow<Self::BreakTy> {
        let node = node.into();
        match node {
            NodeRefMut::StatementList(n) => self.visit_statement_list_mut(n),
            NodeRefMut::StatementListItem(n) => self.visit_statement_list_item_mut(n),
            NodeRefMut::Statement(n) => self.visit_statement_mut(n),
            NodeRefMut::Declaration(n) => self.visit_declaration_mut(n),
            NodeRefMut::Function(n) => self.visit_function_mut(n),
            NodeRefMut::Generator(n) => self.visit_generator_mut(n),
            NodeRefMut::AsyncFunction(n) => self.visit_async_function_mut(n),
            NodeRefMut::AsyncGenerator(n) => self.visit_async_generator_mut(n),
            NodeRefMut::Class(n) => self.visit_class_mut(n),
            NodeRefMut::LexicalDeclaration(n) => self.visit_lexical_declaration_mut(n),
            NodeRefMut::Block(n) => self.visit_block_mut(n),
            NodeRefMut::VarDeclaration(n) => self.visit_var_declaration_mut(n),
            NodeRefMut::Expression(n) => self.visit_expression_mut(n),
            NodeRefMut::If(n) => self.visit_if_mut(n),
            NodeRefMut::DoWhileLoop(n) => self.visit_do_while_loop_mut(n),
            NodeRefMut::WhileLoop(n) => self.visit_while_loop_mut(n),
            NodeRefMut::ForLoop(n) => self.visit_for_loop_mut(n),
            NodeRefMut::ForInLoop(n) => self.visit_for_in_loop_mut(n),
            NodeRefMut::ForOfLoop(n) => self.visit_for_of_loop_mut(n),
            NodeRefMut::Switch(n) => self.visit_switch_mut(n),
            NodeRefMut::Continue(n) => self.visit_continue_mut(n),
            NodeRefMut::Break(n) => self.visit_break_mut(n),
            NodeRefMut::Return(n) => self.visit_return_mut(n),
            NodeRefMut::Labelled(n) => self.visit_labelled_mut(n),
            NodeRefMut::Throw(n) => self.visit_throw_mut(n),
            NodeRefMut::Try(n) => self.visit_try_mut(n),
            NodeRefMut::Identifier(n) => self.visit_identifier_mut(n),
            NodeRefMut::FormalParameterList(n) => self.visit_formal_parameter_list_mut(n),
            NodeRefMut::ClassElement(n) => self.visit_class_element_mut(n),
            NodeRefMut::PrivateName(n) => self.visit_private_name_mut(n),
            NodeRefMut::VariableList(n) => self.visit_variable_list_mut(n),
            NodeRefMut::Variable(n) => self.visit_variable_mut(n),
            NodeRefMut::Binding(n) => self.visit_binding_mut(n),
            NodeRefMut::Pattern(n) => self.visit_pattern_mut(n),
            NodeRefMut::Literal(n) => self.visit_literal_mut(n),
            NodeRefMut::ArrayLiteral(n) => self.visit_array_literal_mut(n),
            NodeRefMut::ObjectLiteral(n) => self.visit_object_literal_mut(n),
            NodeRefMut::Spread(n) => self.visit_spread_mut(n),
            NodeRefMut::ArrowFunction(n) => self.visit_arrow_function_mut(n),
            NodeRefMut::AsyncArrowFunction(n) => self.visit_async_arrow_function_mut(n),
            NodeRefMut::TemplateLiteral(n) => self.visit_template_literal_mut(n),
            NodeRefMut::PropertyAccess(n) => self.visit_property_access_mut(n),
            NodeRefMut::New(n) => self.visit_new_mut(n),
            NodeRefMut::Call(n) => self.visit_call_mut(n),
            NodeRefMut::SuperCall(n) => self.visit_super_call_mut(n),
            NodeRefMut::Optional(n) => self.visit_optional_mut(n),
            NodeRefMut::TaggedTemplate(n) => self.visit_tagged_template_mut(n),
            NodeRefMut::Assign(n) => self.visit_assign_mut(n),
            NodeRefMut::Unary(n) => self.visit_unary_mut(n),
            NodeRefMut::Binary(n) => self.visit_binary_mut(n),
            NodeRefMut::Conditional(n) => self.visit_conditional_mut(n),
            NodeRefMut::Await(n) => self.visit_await_mut(n),
            NodeRefMut::Yield(n) => self.visit_yield_mut(n),
            NodeRefMut::ForLoopInitializer(n) => self.visit_for_loop_initializer_mut(n),
            NodeRefMut::IterableLoopInitializer(n) => self.visit_iterable_loop_initializer_mut(n),
            NodeRefMut::Case(n) => self.visit_case_mut(n),
            NodeRefMut::Sym(n) => self.visit_sym_mut(n),
            NodeRefMut::LabelledItem(n) => self.visit_labelled_item_mut(n),
            NodeRefMut::Catch(n) => self.visit_catch_mut(n),
            NodeRefMut::Finally(n) => self.visit_finally_mut(n),
            NodeRefMut::FormalParameter(n) => self.visit_formal_parameter_mut(n),
            NodeRefMut::PropertyName(n) => self.visit_property_name_mut(n),
            NodeRefMut::MethodDefinition(n) => self.visit_method_definition_mut(n),
            NodeRefMut::ObjectPattern(n) => self.visit_object_pattern_mut(n),
            NodeRefMut::ArrayPattern(n) => self.visit_array_pattern_mut(n),
            NodeRefMut::PropertyDefinition(n) => self.visit_property_definition_mut(n),
            NodeRefMut::TemplateElement(n) => self.visit_template_element_mut(n),
            NodeRefMut::SimplePropertyAccess(n) => self.visit_simple_property_access_mut(n),
            NodeRefMut::PrivatePropertyAccess(n) => self.visit_private_property_access_mut(n),
            NodeRefMut::SuperPropertyAccess(n) => self.visit_super_property_access_mut(n),
            NodeRefMut::OptionalOperation(n) => self.visit_optional_operation_mut(n),
            NodeRefMut::AssignTarget(n) => self.visit_assign_target_mut(n),
            NodeRefMut::ObjectPatternElement(n) => self.visit_object_pattern_element_mut(n),
            NodeRefMut::ArrayPatternElement(n) => self.visit_array_pattern_element_mut(n),
            NodeRefMut::PropertyAccessField(n) => self.visit_property_access_field_mut(n),
            NodeRefMut::OptionalOperationKind(n) => self.visit_optional_operation_kind_mut(n),
        }
    }
}

/// Denotes that a type may be visited, providing a method which allows a visitor to traverse its
/// private fields.
pub trait VisitWith {
    /// Visit this node with the provided visitor.
    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
    where
        V: Visitor<'a>;

    /// Visit this node with the provided visitor mutably, allowing the visitor to modify private
    /// fields.
    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
    where
        V: VisitorMut<'a>;
}

// implementation for Sym as it is out-of-crate
impl VisitWith for Sym {
    fn visit_with<'a, V>(&'a self, _visitor: &mut V) -> ControlFlow<V::BreakTy>
    where
        V: Visitor<'a>,
    {
        core::ops::ControlFlow::Continue(())
    }

    fn visit_with_mut<'a, V>(&'a mut self, _visitor: &mut V) -> ControlFlow<V::BreakTy>
    where
        V: VisitorMut<'a>,
    {
        core::ops::ControlFlow::Continue(())
    }
}