Quelle  visit_generated.rs   Sprache: unbekannt

// WARNING: This file is auto-generated.

#![allow(unused_mut)]
#![allow(unused_parens)]
#![allow(unused_variables)]
#![allow(dead_code)]

use crate::arena;
use crate::source_atom_set::SourceAtomSetIndex;
use crate::source_slice_list::SourceSliceIndex;
use crate::types::*;

pub trait Pass<'alloc> {
    fn visit_argument(&mut self, ast: &'alloc Argument<'alloc>) {
        self.enter_argument(ast);
        match ast {
            Argument::SpreadElement(ast) => {
                self.visit_enum_argument_variant_spread_element(ast)
            }
            Argument::Expression(ast) => {
                self.visit_enum_argument_variant_expression(ast)
            }
        }
        self.leave_argument(ast);
    }

    fn enter_argument(&mut self, ast: &'alloc Argument<'alloc>) {
    }

    fn leave_argument(&mut self, ast: &'alloc Argument<'alloc>) {
    }

    fn visit_enum_argument_variant_spread_element(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_argument_variant_spread_element(ast);
        self.visit_expression(ast);
        self.leave_enum_argument_variant_spread_element(ast);
    }

    fn enter_enum_argument_variant_spread_element(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_argument_variant_spread_element(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_argument_variant_expression(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_argument_variant_expression(ast);
        self.visit_expression(ast);
        self.leave_enum_argument_variant_expression(ast);
    }

    fn enter_enum_argument_variant_expression(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_argument_variant_expression(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_arguments(&mut self, ast: &'alloc Arguments<'alloc>) {
        self.enter_arguments(ast);
        for item in &ast.args {
            self.visit_argument(item);
        }
        self.leave_arguments(ast);
    }

    fn enter_arguments(&mut self, ast: &'alloc Arguments<'alloc>) {
    }

    fn leave_arguments(&mut self, ast: &'alloc Arguments<'alloc>) {
    }

    fn visit_identifier(&mut self, ast: &'alloc Identifier) {
        self.enter_identifier(ast);
        self.leave_identifier(ast);
    }

    fn enter_identifier(&mut self, ast: &'alloc Identifier) {
    }

    fn leave_identifier(&mut self, ast: &'alloc Identifier) {
    }

    fn visit_identifier_name(&mut self, ast: &'alloc IdentifierName) {
        self.enter_identifier_name(ast);
        self.leave_identifier_name(ast);
    }

    fn enter_identifier_name(&mut self, ast: &'alloc IdentifierName) {
    }

    fn leave_identifier_name(&mut self, ast: &'alloc IdentifierName) {
    }

    fn visit_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) {
        self.enter_private_identifier(ast);
        self.leave_private_identifier(ast);
    }

    fn enter_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) {
    }

    fn leave_private_identifier(&mut self, ast: &'alloc PrivateIdentifier) {
    }

    fn visit_label(&mut self, ast: &'alloc Label) {
        self.enter_label(ast);
        self.leave_label(ast);
    }

    fn enter_label(&mut self, ast: &'alloc Label) {
    }

    fn leave_label(&mut self, ast: &'alloc Label) {
    }

    fn visit_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) {
        self.enter_variable_declaration_kind(ast);
        match ast {
            VariableDeclarationKind::Var { .. } => {
                self.visit_enum_variable_declaration_kind_variant_var()
            }
            VariableDeclarationKind::Let { .. } => {
                self.visit_enum_variable_declaration_kind_variant_let()
            }
            VariableDeclarationKind::Const { .. } => {
                self.visit_enum_variable_declaration_kind_variant_const()
            }
        }
        self.leave_variable_declaration_kind(ast);
    }

    fn enter_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) {
    }

    fn leave_variable_declaration_kind(&mut self, ast: &'alloc VariableDeclarationKind) {
    }

    fn visit_enum_variable_declaration_kind_variant_var(&mut self) {
    }

    fn visit_enum_variable_declaration_kind_variant_let(&mut self) {
    }

    fn visit_enum_variable_declaration_kind_variant_const(&mut self) {
    }

    fn visit_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) {
        self.enter_compound_assignment_operator(ast);
        match ast {
            CompoundAssignmentOperator::LogicalOr { .. } => {
                self.visit_enum_compound_assignment_operator_variant_logical_or()
            }
            CompoundAssignmentOperator::LogicalAnd { .. } => {
                self.visit_enum_compound_assignment_operator_variant_logical_and()
            }
            CompoundAssignmentOperator::Coalesce { .. } => {
                self.visit_enum_compound_assignment_operator_variant_coalesce()
            }
            CompoundAssignmentOperator::Add { .. } => {
                self.visit_enum_compound_assignment_operator_variant_add()
            }
            CompoundAssignmentOperator::Sub { .. } => {
                self.visit_enum_compound_assignment_operator_variant_sub()
            }
            CompoundAssignmentOperator::Mul { .. } => {
                self.visit_enum_compound_assignment_operator_variant_mul()
            }
            CompoundAssignmentOperator::Div { .. } => {
                self.visit_enum_compound_assignment_operator_variant_div()
            }
            CompoundAssignmentOperator::Mod { .. } => {
                self.visit_enum_compound_assignment_operator_variant_mod()
            }
            CompoundAssignmentOperator::Pow { .. } => {
                self.visit_enum_compound_assignment_operator_variant_pow()
            }
            CompoundAssignmentOperator::LeftShift { .. } => {
                self.visit_enum_compound_assignment_operator_variant_left_shift()
            }
            CompoundAssignmentOperator::RightShift { .. } => {
                self.visit_enum_compound_assignment_operator_variant_right_shift()
            }
            CompoundAssignmentOperator::RightShiftExt { .. } => {
                self.visit_enum_compound_assignment_operator_variant_right_shift_ext()
            }
            CompoundAssignmentOperator::Or { .. } => {
                self.visit_enum_compound_assignment_operator_variant_or()
            }
            CompoundAssignmentOperator::Xor { .. } => {
                self.visit_enum_compound_assignment_operator_variant_xor()
            }
            CompoundAssignmentOperator::And { .. } => {
                self.visit_enum_compound_assignment_operator_variant_and()
            }
        }
        self.leave_compound_assignment_operator(ast);
    }

    fn enter_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) {
    }

    fn leave_compound_assignment_operator(&mut self, ast: &'alloc CompoundAssignmentOperator) {
    }

    fn visit_enum_compound_assignment_operator_variant_logical_or(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_logical_and(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_coalesce(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_add(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_sub(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_mul(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_div(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_mod(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_pow(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_left_shift(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_right_shift(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_right_shift_ext(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_or(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_xor(&mut self) {
    }

    fn visit_enum_compound_assignment_operator_variant_and(&mut self) {
    }

    fn visit_binary_operator(&mut self, ast: &'alloc BinaryOperator) {
        self.enter_binary_operator(ast);
        match ast {
            BinaryOperator::Equals { .. } => {
                self.visit_enum_binary_operator_variant_equals()
            }
            BinaryOperator::NotEquals { .. } => {
                self.visit_enum_binary_operator_variant_not_equals()
            }
            BinaryOperator::StrictEquals { .. } => {
                self.visit_enum_binary_operator_variant_strict_equals()
            }
            BinaryOperator::StrictNotEquals { .. } => {
                self.visit_enum_binary_operator_variant_strict_not_equals()
            }
            BinaryOperator::LessThan { .. } => {
                self.visit_enum_binary_operator_variant_less_than()
            }
            BinaryOperator::LessThanOrEqual { .. } => {
                self.visit_enum_binary_operator_variant_less_than_or_equal()
            }
            BinaryOperator::GreaterThan { .. } => {
                self.visit_enum_binary_operator_variant_greater_than()
            }
            BinaryOperator::GreaterThanOrEqual { .. } => {
                self.visit_enum_binary_operator_variant_greater_than_or_equal()
            }
            BinaryOperator::In { .. } => {
                self.visit_enum_binary_operator_variant_in()
            }
            BinaryOperator::Instanceof { .. } => {
                self.visit_enum_binary_operator_variant_instanceof()
            }
            BinaryOperator::LeftShift { .. } => {
                self.visit_enum_binary_operator_variant_left_shift()
            }
            BinaryOperator::RightShift { .. } => {
                self.visit_enum_binary_operator_variant_right_shift()
            }
            BinaryOperator::RightShiftExt { .. } => {
                self.visit_enum_binary_operator_variant_right_shift_ext()
            }
            BinaryOperator::Add { .. } => {
                self.visit_enum_binary_operator_variant_add()
            }
            BinaryOperator::Sub { .. } => {
                self.visit_enum_binary_operator_variant_sub()
            }
            BinaryOperator::Mul { .. } => {
                self.visit_enum_binary_operator_variant_mul()
            }
            BinaryOperator::Div { .. } => {
                self.visit_enum_binary_operator_variant_div()
            }
            BinaryOperator::Mod { .. } => {
                self.visit_enum_binary_operator_variant_mod()
            }
            BinaryOperator::Pow { .. } => {
                self.visit_enum_binary_operator_variant_pow()
            }
            BinaryOperator::Comma { .. } => {
                self.visit_enum_binary_operator_variant_comma()
            }
            BinaryOperator::Coalesce { .. } => {
                self.visit_enum_binary_operator_variant_coalesce()
            }
            BinaryOperator::LogicalOr { .. } => {
                self.visit_enum_binary_operator_variant_logical_or()
            }
            BinaryOperator::LogicalAnd { .. } => {
                self.visit_enum_binary_operator_variant_logical_and()
            }
            BinaryOperator::BitwiseOr { .. } => {
                self.visit_enum_binary_operator_variant_bitwise_or()
            }
            BinaryOperator::BitwiseXor { .. } => {
                self.visit_enum_binary_operator_variant_bitwise_xor()
            }
            BinaryOperator::BitwiseAnd { .. } => {
                self.visit_enum_binary_operator_variant_bitwise_and()
            }
        }
        self.leave_binary_operator(ast);
    }

    fn enter_binary_operator(&mut self, ast: &'alloc BinaryOperator) {
    }

    fn leave_binary_operator(&mut self, ast: &'alloc BinaryOperator) {
    }

    fn visit_enum_binary_operator_variant_equals(&mut self) {
    }

    fn visit_enum_binary_operator_variant_not_equals(&mut self) {
    }

    fn visit_enum_binary_operator_variant_strict_equals(&mut self) {
    }

    fn visit_enum_binary_operator_variant_strict_not_equals(&mut self) {
    }

    fn visit_enum_binary_operator_variant_less_than(&mut self) {
    }

    fn visit_enum_binary_operator_variant_less_than_or_equal(&mut self) {
    }

    fn visit_enum_binary_operator_variant_greater_than(&mut self) {
    }

    fn visit_enum_binary_operator_variant_greater_than_or_equal(&mut self) {
    }

    fn visit_enum_binary_operator_variant_in(&mut self) {
    }

    fn visit_enum_binary_operator_variant_instanceof(&mut self) {
    }

    fn visit_enum_binary_operator_variant_left_shift(&mut self) {
    }

    fn visit_enum_binary_operator_variant_right_shift(&mut self) {
    }

    fn visit_enum_binary_operator_variant_right_shift_ext(&mut self) {
    }

    fn visit_enum_binary_operator_variant_add(&mut self) {
    }

    fn visit_enum_binary_operator_variant_sub(&mut self) {
    }

    fn visit_enum_binary_operator_variant_mul(&mut self) {
    }

    fn visit_enum_binary_operator_variant_div(&mut self) {
    }

    fn visit_enum_binary_operator_variant_mod(&mut self) {
    }

    fn visit_enum_binary_operator_variant_pow(&mut self) {
    }

    fn visit_enum_binary_operator_variant_comma(&mut self) {
    }

    fn visit_enum_binary_operator_variant_coalesce(&mut self) {
    }

    fn visit_enum_binary_operator_variant_logical_or(&mut self) {
    }

    fn visit_enum_binary_operator_variant_logical_and(&mut self) {
    }

    fn visit_enum_binary_operator_variant_bitwise_or(&mut self) {
    }

    fn visit_enum_binary_operator_variant_bitwise_xor(&mut self) {
    }

    fn visit_enum_binary_operator_variant_bitwise_and(&mut self) {
    }

    fn visit_unary_operator(&mut self, ast: &'alloc UnaryOperator) {
        self.enter_unary_operator(ast);
        match ast {
            UnaryOperator::Plus { .. } => {
                self.visit_enum_unary_operator_variant_plus()
            }
            UnaryOperator::Minus { .. } => {
                self.visit_enum_unary_operator_variant_minus()
            }
            UnaryOperator::LogicalNot { .. } => {
                self.visit_enum_unary_operator_variant_logical_not()
            }
            UnaryOperator::BitwiseNot { .. } => {
                self.visit_enum_unary_operator_variant_bitwise_not()
            }
            UnaryOperator::Typeof { .. } => {
                self.visit_enum_unary_operator_variant_typeof()
            }
            UnaryOperator::Void { .. } => {
                self.visit_enum_unary_operator_variant_void()
            }
            UnaryOperator::Delete { .. } => {
                self.visit_enum_unary_operator_variant_delete()
            }
        }
        self.leave_unary_operator(ast);
    }

    fn enter_unary_operator(&mut self, ast: &'alloc UnaryOperator) {
    }

    fn leave_unary_operator(&mut self, ast: &'alloc UnaryOperator) {
    }

    fn visit_enum_unary_operator_variant_plus(&mut self) {
    }

    fn visit_enum_unary_operator_variant_minus(&mut self) {
    }

    fn visit_enum_unary_operator_variant_logical_not(&mut self) {
    }

    fn visit_enum_unary_operator_variant_bitwise_not(&mut self) {
    }

    fn visit_enum_unary_operator_variant_typeof(&mut self) {
    }

    fn visit_enum_unary_operator_variant_void(&mut self) {
    }

    fn visit_enum_unary_operator_variant_delete(&mut self) {
    }

    fn visit_update_operator(&mut self, ast: &'alloc UpdateOperator) {
        self.enter_update_operator(ast);
        match ast {
            UpdateOperator::Increment { .. } => {
                self.visit_enum_update_operator_variant_increment()
            }
            UpdateOperator::Decrement { .. } => {
                self.visit_enum_update_operator_variant_decrement()
            }
        }
        self.leave_update_operator(ast);
    }

    fn enter_update_operator(&mut self, ast: &'alloc UpdateOperator) {
    }

    fn leave_update_operator(&mut self, ast: &'alloc UpdateOperator) {
    }

    fn visit_enum_update_operator_variant_increment(&mut self) {
    }

    fn visit_enum_update_operator_variant_decrement(&mut self) {
    }

    fn visit_function(&mut self, ast: &'alloc Function<'alloc>) {
        self.enter_function(ast);
        if let Some(item) = &ast.name {
            self.visit_binding_identifier(item);
        }
        self.visit_formal_parameters(&ast.params);
        self.visit_function_body(&ast.body);
        self.leave_function(ast);
    }

    fn enter_function(&mut self, ast: &'alloc Function<'alloc>) {
    }

    fn leave_function(&mut self, ast: &'alloc Function<'alloc>) {
    }

    fn visit_program(&mut self, ast: &'alloc Program<'alloc>) {
        self.enter_program(ast);
        match ast {
            Program::Module(ast) => {
                self.visit_enum_program_variant_module(ast)
            }
            Program::Script(ast) => {
                self.visit_enum_program_variant_script(ast)
            }
        }
        self.leave_program(ast);
    }

    fn enter_program(&mut self, ast: &'alloc Program<'alloc>) {
    }

    fn leave_program(&mut self, ast: &'alloc Program<'alloc>) {
    }

    fn visit_enum_program_variant_module(
        &mut self,
        ast: &'alloc Module<'alloc>,
    ) {
        self.enter_enum_program_variant_module(ast);
        self.visit_module(ast);
        self.leave_enum_program_variant_module(ast);
    }

    fn enter_enum_program_variant_module(
        &mut self,
        ast: &'alloc Module<'alloc>,
    ) {
    }

    fn leave_enum_program_variant_module(
        &mut self,
        ast: &'alloc Module<'alloc>,
    ) {
    }

    fn visit_enum_program_variant_script(
        &mut self,
        ast: &'alloc Script<'alloc>,
    ) {
        self.enter_enum_program_variant_script(ast);
        self.visit_script(ast);
        self.leave_enum_program_variant_script(ast);
    }

    fn enter_enum_program_variant_script(
        &mut self,
        ast: &'alloc Script<'alloc>,
    ) {
    }

    fn leave_enum_program_variant_script(
        &mut self,
        ast: &'alloc Script<'alloc>,
    ) {
    }

    fn visit_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) {
        self.enter_if_statement(ast);
        self.visit_expression(&ast.test);
        self.visit_statement(&ast.consequent);
        if let Some(item) = &ast.alternate {
            self.visit_statement(item);
        }
        self.leave_if_statement(ast);
    }

    fn enter_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) {
    }

    fn leave_if_statement(&mut self, ast: &'alloc IfStatement<'alloc>) {
    }

    fn visit_statement(&mut self, ast: &'alloc Statement<'alloc>) {
        self.enter_statement(ast);
        match ast {
            Statement::BlockStatement { block, .. } => {
                self.visit_enum_statement_variant_block_statement(
                    block,
                )
            }
            Statement::BreakStatement { label, .. } => {
                self.visit_enum_statement_variant_break_statement(
                    label,
                )
            }
            Statement::ContinueStatement { label, .. } => {
                self.visit_enum_statement_variant_continue_statement(
                    label,
                )
            }
            Statement::DebuggerStatement { .. } => {
                self.visit_enum_statement_variant_debugger_statement()
            }
            Statement::DoWhileStatement { block, test, .. } => {
                self.visit_enum_statement_variant_do_while_statement(
                    block,
                    test,
                )
            }
            Statement::EmptyStatement { .. } => {
                self.visit_enum_statement_variant_empty_statement()
            }
            Statement::ExpressionStatement(ast) => {
                self.visit_enum_statement_variant_expression_statement(ast)
            }
            Statement::ForInStatement { left, right, block, .. } => {
                self.visit_enum_statement_variant_for_in_statement(
                    left,
                    right,
                    block,
                )
            }
            Statement::ForOfStatement { left, right, block, .. } => {
                self.visit_enum_statement_variant_for_of_statement(
                    left,
                    right,
                    block,
                )
            }
            Statement::ForStatement { init, test, update, block, .. } => {
                self.visit_enum_statement_variant_for_statement(
                    init,
                    test,
                    update,
                    block,
                )
            }
            Statement::IfStatement(ast) => {
                self.visit_enum_statement_variant_if_statement(ast)
            }
            Statement::LabelledStatement { label, body, .. } => {
                self.visit_enum_statement_variant_labelled_statement(
                    label,
                    body,
                )
            }
            Statement::ReturnStatement { expression, .. } => {
                self.visit_enum_statement_variant_return_statement(
                    expression,
                )
            }
            Statement::SwitchStatement { discriminant, cases, .. } => {
                self.visit_enum_statement_variant_switch_statement(
                    discriminant,
                    cases,
                )
            }
            Statement::SwitchStatementWithDefault { discriminant, pre_default_cases, default_case, post_default_cases, .. } => {
                self.visit_enum_statement_variant_switch_statement_with_default(
                    discriminant,
                    pre_default_cases,
                    default_case,
                    post_default_cases,
                )
            }
            Statement::ThrowStatement { expression, .. } => {
                self.visit_enum_statement_variant_throw_statement(
                    expression,
                )
            }
            Statement::TryCatchStatement { body, catch_clause, .. } => {
                self.visit_enum_statement_variant_try_catch_statement(
                    body,
                    catch_clause,
                )
            }
            Statement::TryFinallyStatement { body, catch_clause, finalizer, .. } => {
                self.visit_enum_statement_variant_try_finally_statement(
                    body,
                    catch_clause,
                    finalizer,
                )
            }
            Statement::WhileStatement { test, block, .. } => {
                self.visit_enum_statement_variant_while_statement(
                    test,
                    block,
                )
            }
            Statement::WithStatement { object, body, .. } => {
                self.visit_enum_statement_variant_with_statement(
                    object,
                    body,
                )
            }
            Statement::VariableDeclarationStatement(ast) => {
                self.visit_enum_statement_variant_variable_declaration_statement(ast)
            }
            Statement::FunctionDeclaration(ast) => {
                self.visit_enum_statement_variant_function_declaration(ast)
            }
            Statement::ClassDeclaration(ast) => {
                self.visit_enum_statement_variant_class_declaration(ast)
            }
        }
        self.leave_statement(ast);
    }

    fn enter_statement(&mut self, ast: &'alloc Statement<'alloc>) {
    }

    fn leave_statement(&mut self, ast: &'alloc Statement<'alloc>) {
    }

    fn visit_enum_statement_variant_block_statement(
        &mut self,
        block: &'alloc Block<'alloc>,
    ) {
        self.enter_enum_statement_variant_block_statement(
            block,
        );
        self.visit_block(block);
        self.leave_enum_statement_variant_block_statement(
            block,
        );
    }

    fn enter_enum_statement_variant_block_statement(
        &mut self,
        block: &'alloc Block<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_block_statement(
        &mut self,
        block: &'alloc Block<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_break_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
        self.enter_enum_statement_variant_break_statement(
            label,
        );
        if let Some(item) = label {
            self.visit_label(item);
        }
        self.leave_enum_statement_variant_break_statement(
            label,
        );
    }

    fn enter_enum_statement_variant_break_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
    }

    fn leave_enum_statement_variant_break_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
    }

    fn visit_enum_statement_variant_continue_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
        self.enter_enum_statement_variant_continue_statement(
            label,
        );
        if let Some(item) = label {
            self.visit_label(item);
        }
        self.leave_enum_statement_variant_continue_statement(
            label,
        );
    }

    fn enter_enum_statement_variant_continue_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
    }

    fn leave_enum_statement_variant_continue_statement(
        &mut self,
        label: &'alloc Option<Label>,
    ) {
    }

    fn visit_enum_statement_variant_debugger_statement(&mut self) {
    }

    fn visit_enum_statement_variant_do_while_statement(
        &mut self,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_statement_variant_do_while_statement(
            block,
            test,
        );
        self.visit_statement(block);
        self.visit_expression(test);
        self.leave_enum_statement_variant_do_while_statement(
            block,
            test,
        );
    }

    fn enter_enum_statement_variant_do_while_statement(
        &mut self,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_do_while_statement(
        &mut self,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_empty_statement(&mut self) {
    }

    fn visit_enum_statement_variant_expression_statement(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_statement_variant_expression_statement(ast);
        self.visit_expression(ast);
        self.leave_enum_statement_variant_expression_statement(ast);
    }

    fn enter_enum_statement_variant_expression_statement(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_expression_statement(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_for_in_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_for_in_statement(
            left,
            right,
            block,
        );
        self.visit_variable_declaration_or_assignment_target(left);
        self.visit_expression(right);
        self.visit_statement(block);
        self.leave_enum_statement_variant_for_in_statement(
            left,
            right,
            block,
        );
    }

    fn enter_enum_statement_variant_for_in_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_for_in_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_for_of_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_for_of_statement(
            left,
            right,
            block,
        );
        self.visit_variable_declaration_or_assignment_target(left);
        self.visit_expression(right);
        self.visit_statement(block);
        self.leave_enum_statement_variant_for_of_statement(
            left,
            right,
            block,
        );
    }

    fn enter_enum_statement_variant_for_of_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_for_of_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_for_statement(
        &mut self,
        init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>,
        test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_for_statement(
            init,
            test,
            update,
            block,
        );
        if let Some(item) = init {
            self.visit_variable_declaration_or_expression(item);
        }
        if let Some(item) = test {
            self.visit_expression(item);
        }
        if let Some(item) = update {
            self.visit_expression(item);
        }
        self.visit_statement(block);
        self.leave_enum_statement_variant_for_statement(
            init,
            test,
            update,
            block,
        );
    }

    fn enter_enum_statement_variant_for_statement(
        &mut self,
        init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>,
        test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_for_statement(
        &mut self,
        init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>,
        test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_if_statement(
        &mut self,
        ast: &'alloc IfStatement<'alloc>,
    ) {
        self.enter_enum_statement_variant_if_statement(ast);
        self.visit_if_statement(ast);
        self.leave_enum_statement_variant_if_statement(ast);
    }

    fn enter_enum_statement_variant_if_statement(
        &mut self,
        ast: &'alloc IfStatement<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_if_statement(
        &mut self,
        ast: &'alloc IfStatement<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_labelled_statement(
        &mut self,
        label: &'alloc Label,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_labelled_statement(
            label,
            body,
        );
        self.visit_label(label);
        self.visit_statement(body);
        self.leave_enum_statement_variant_labelled_statement(
            label,
            body,
        );
    }

    fn enter_enum_statement_variant_labelled_statement(
        &mut self,
        label: &'alloc Label,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_labelled_statement(
        &mut self,
        label: &'alloc Label,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_return_statement(
        &mut self,
        expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
    ) {
        self.enter_enum_statement_variant_return_statement(
            expression,
        );
        if let Some(item) = expression {
            self.visit_expression(item);
        }
        self.leave_enum_statement_variant_return_statement(
            expression,
        );
    }

    fn enter_enum_statement_variant_return_statement(
        &mut self,
        expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
    ) {
    }

    fn leave_enum_statement_variant_return_statement(
        &mut self,
        expression: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
    ) {
    }

    fn visit_enum_statement_variant_switch_statement(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
        self.enter_enum_statement_variant_switch_statement(
            discriminant,
            cases,
        );
        self.visit_expression(discriminant);
        for item in cases.iter() {
            self.visit_switch_case(item);
        }
        self.leave_enum_statement_variant_switch_statement(
            discriminant,
            cases,
        );
    }

    fn enter_enum_statement_variant_switch_statement(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_switch_statement(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_switch_statement_with_default(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
        default_case: &'alloc SwitchDefault<'alloc>,
        post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
        self.enter_enum_statement_variant_switch_statement_with_default(
            discriminant,
            pre_default_cases,
            default_case,
            post_default_cases,
        );
        self.visit_expression(discriminant);
        for item in pre_default_cases.iter() {
            self.visit_switch_case(item);
        }
        self.visit_switch_default(default_case);
        for item in post_default_cases.iter() {
            self.visit_switch_case(item);
        }
        self.leave_enum_statement_variant_switch_statement_with_default(
            discriminant,
            pre_default_cases,
            default_case,
            post_default_cases,
        );
    }

    fn enter_enum_statement_variant_switch_statement_with_default(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
        default_case: &'alloc SwitchDefault<'alloc>,
        post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_switch_statement_with_default(
        &mut self,
        discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        pre_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
        default_case: &'alloc SwitchDefault<'alloc>,
        post_default_cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_throw_statement(
        &mut self,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_statement_variant_throw_statement(
            expression,
        );
        self.visit_expression(expression);
        self.leave_enum_statement_variant_throw_statement(
            expression,
        );
    }

    fn enter_enum_statement_variant_throw_statement(
        &mut self,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_throw_statement(
        &mut self,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_try_catch_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc CatchClause<'alloc>,
    ) {
        self.enter_enum_statement_variant_try_catch_statement(
            body,
            catch_clause,
        );
        self.visit_block(body);
        self.visit_catch_clause(catch_clause);
        self.leave_enum_statement_variant_try_catch_statement(
            body,
            catch_clause,
        );
    }

    fn enter_enum_statement_variant_try_catch_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc CatchClause<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_try_catch_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc CatchClause<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_try_finally_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc Option<CatchClause<'alloc>>,
        finalizer: &'alloc Block<'alloc>,
    ) {
        self.enter_enum_statement_variant_try_finally_statement(
            body,
            catch_clause,
            finalizer,
        );
        self.visit_block(body);
        if let Some(item) = catch_clause {
            self.visit_catch_clause(item);
        }
        self.visit_block(finalizer);
        self.leave_enum_statement_variant_try_finally_statement(
            body,
            catch_clause,
            finalizer,
        );
    }

    fn enter_enum_statement_variant_try_finally_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc Option<CatchClause<'alloc>>,
        finalizer: &'alloc Block<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_try_finally_statement(
        &mut self,
        body: &'alloc Block<'alloc>,
        catch_clause: &'alloc Option<CatchClause<'alloc>>,
        finalizer: &'alloc Block<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_while_statement(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_while_statement(
            test,
            block,
        );
        self.visit_expression(test);
        self.visit_statement(block);
        self.leave_enum_statement_variant_while_statement(
            test,
            block,
        );
    }

    fn enter_enum_statement_variant_while_statement(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_while_statement(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_with_statement(
        &mut self,
        object: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.enter_enum_statement_variant_with_statement(
            object,
            body,
        );
        self.visit_expression(object);
        self.visit_statement(body);
        self.leave_enum_statement_variant_with_statement(
            object,
            body,
        );
    }

    fn enter_enum_statement_variant_with_statement(
        &mut self,
        object: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn leave_enum_statement_variant_with_statement(
        &mut self,
        object: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
    }

    fn visit_enum_statement_variant_variable_declaration_statement(
        &mut self,
        ast: &'alloc VariableDeclaration<'alloc>,
    ) {
        self.enter_enum_statement_variant_variable_declaration_statement(ast);
        self.visit_variable_declaration(ast);
        self.leave_enum_statement_variant_variable_declaration_statement(ast);
    }

    fn enter_enum_statement_variant_variable_declaration_statement(
        &mut self,
        ast: &'alloc VariableDeclaration<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_variable_declaration_statement(
        &mut self,
        ast: &'alloc VariableDeclaration<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_function_declaration(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
        self.enter_enum_statement_variant_function_declaration(ast);
        self.visit_function(ast);
        self.leave_enum_statement_variant_function_declaration(ast);
    }

    fn enter_enum_statement_variant_function_declaration(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_function_declaration(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
    }

    fn visit_enum_statement_variant_class_declaration(
        &mut self,
        ast: &'alloc ClassDeclaration<'alloc>,
    ) {
        self.enter_enum_statement_variant_class_declaration(ast);
        self.visit_class_declaration(ast);
        self.leave_enum_statement_variant_class_declaration(ast);
    }

    fn enter_enum_statement_variant_class_declaration(
        &mut self,
        ast: &'alloc ClassDeclaration<'alloc>,
    ) {
    }

    fn leave_enum_statement_variant_class_declaration(
        &mut self,
        ast: &'alloc ClassDeclaration<'alloc>,
    ) {
    }

    fn visit_expression(&mut self, ast: &'alloc Expression<'alloc>) {
        self.enter_expression(ast);
        match ast {
            Expression::MemberExpression(ast) => {
                self.visit_enum_expression_variant_member_expression(ast)
            }
            Expression::ClassExpression(ast) => {
                self.visit_enum_expression_variant_class_expression(ast)
            }
            Expression::LiteralBooleanExpression { value, .. } => {
                self.visit_enum_expression_variant_literal_boolean_expression(
                    value,
                )
            }
            Expression::LiteralInfinityExpression { .. } => {
                self.visit_enum_expression_variant_literal_infinity_expression()
            }
            Expression::LiteralNullExpression { .. } => {
                self.visit_enum_expression_variant_literal_null_expression()
            }
            Expression::LiteralNumericExpression(ast) => {
                self.visit_enum_expression_variant_literal_numeric_expression(ast)
            }
            Expression::LiteralRegExpExpression { pattern, global, ignore_case, multi_line, dot_all, sticky, unicode, .. } => {
                self.visit_enum_expression_variant_literal_reg_exp_expression(
                    pattern,
                    global,
                    ignore_case,
                    multi_line,
                    dot_all,
                    sticky,
                    unicode,
                )
            }
            Expression::LiteralStringExpression { value, .. } => {
                self.visit_enum_expression_variant_literal_string_expression(
                    value,
                )
            }
            Expression::ArrayExpression(ast) => {
                self.visit_enum_expression_variant_array_expression(ast)
            }
            Expression::ArrowExpression { is_async, params, body, .. } => {
                self.visit_enum_expression_variant_arrow_expression(
                    is_async,
                    params,
                    body,
                )
            }
            Expression::AssignmentExpression { binding, expression, .. } => {
                self.visit_enum_expression_variant_assignment_expression(
                    binding,
                    expression,
                )
            }
            Expression::BinaryExpression { operator, left, right, .. } => {
                self.visit_enum_expression_variant_binary_expression(
                    operator,
                    left,
                    right,
                )
            }
            Expression::CallExpression(ast) => {
                self.visit_enum_expression_variant_call_expression(ast)
            }
            Expression::CompoundAssignmentExpression { operator, binding, expression, .. } => {
                self.visit_enum_expression_variant_compound_assignment_expression(
                    operator,
                    binding,
                    expression,
                )
            }
            Expression::ConditionalExpression { test, consequent, alternate, .. } => {
                self.visit_enum_expression_variant_conditional_expression(
                    test,
                    consequent,
                    alternate,
                )
            }
            Expression::FunctionExpression(ast) => {
                self.visit_enum_expression_variant_function_expression(ast)
            }
            Expression::IdentifierExpression(ast) => {
                self.visit_enum_expression_variant_identifier_expression(ast)
            }
            Expression::NewExpression { callee, arguments, .. } => {
                self.visit_enum_expression_variant_new_expression(
                    callee,
                    arguments,
                )
            }
            Expression::NewTargetExpression { .. } => {
                self.visit_enum_expression_variant_new_target_expression()
            }
            Expression::ObjectExpression(ast) => {
                self.visit_enum_expression_variant_object_expression(ast)
            }
            Expression::OptionalExpression { object, tail, .. } => {
                self.visit_enum_expression_variant_optional_expression(
                    object,
                    tail,
                )
            }
            Expression::OptionalChain(ast) => {
                self.visit_enum_expression_variant_optional_chain(ast)
            }
            Expression::UnaryExpression { operator, operand, .. } => {
                self.visit_enum_expression_variant_unary_expression(
                    operator,
                    operand,
                )
            }
            Expression::TemplateExpression(ast) => {
                self.visit_enum_expression_variant_template_expression(ast)
            }
            Expression::ThisExpression { .. } => {
                self.visit_enum_expression_variant_this_expression()
            }
            Expression::UpdateExpression { is_prefix, operator, operand, .. } => {
                self.visit_enum_expression_variant_update_expression(
                    is_prefix,
                    operator,
                    operand,
                )
            }
            Expression::YieldExpression { expression, .. } => {
                self.visit_enum_expression_variant_yield_expression(
                    expression,
                )
            }
            Expression::YieldGeneratorExpression { expression, .. } => {
                self.visit_enum_expression_variant_yield_generator_expression(
                    expression,
                )
            }
            Expression::AwaitExpression { expression, .. } => {
                self.visit_enum_expression_variant_await_expression(
                    expression,
                )
            }
            Expression::ImportCallExpression { argument, .. } => {
                self.visit_enum_expression_variant_import_call_expression(
                    argument,
                )
            }
        }
        self.leave_expression(ast);
    }

    fn enter_expression(&mut self, ast: &'alloc Expression<'alloc>) {
    }

    fn leave_expression(&mut self, ast: &'alloc Expression<'alloc>) {
    }

    fn visit_enum_expression_variant_member_expression(
        &mut self,
        ast: &'alloc MemberExpression<'alloc>,
    ) {
        self.enter_enum_expression_variant_member_expression(ast);
        self.visit_member_expression(ast);
        self.leave_enum_expression_variant_member_expression(ast);
    }

    fn enter_enum_expression_variant_member_expression(
        &mut self,
        ast: &'alloc MemberExpression<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_member_expression(
        &mut self,
        ast: &'alloc MemberExpression<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_class_expression(
        &mut self,
        ast: &'alloc ClassExpression<'alloc>,
    ) {
        self.enter_enum_expression_variant_class_expression(ast);
        self.visit_class_expression(ast);
        self.leave_enum_expression_variant_class_expression(ast);
    }

    fn enter_enum_expression_variant_class_expression(
        &mut self,
        ast: &'alloc ClassExpression<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_class_expression(
        &mut self,
        ast: &'alloc ClassExpression<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_literal_boolean_expression(
        &mut self,
        value: &'alloc bool,
    ) {
        self.enter_enum_expression_variant_literal_boolean_expression(
            value,
        );
        self.leave_enum_expression_variant_literal_boolean_expression(
            value,
        );
    }

    fn enter_enum_expression_variant_literal_boolean_expression(
        &mut self,
        value: &'alloc bool,
    ) {
    }

    fn leave_enum_expression_variant_literal_boolean_expression(
        &mut self,
        value: &'alloc bool,
    ) {
    }

    fn visit_enum_expression_variant_literal_infinity_expression(&mut self) {
    }

    fn visit_enum_expression_variant_literal_null_expression(&mut self) {
    }

    fn visit_enum_expression_variant_literal_numeric_expression(
        &mut self,
        ast: &'alloc NumericLiteral,
    ) {
        self.enter_enum_expression_variant_literal_numeric_expression(ast);
        self.visit_numeric_literal(ast);
        self.leave_enum_expression_variant_literal_numeric_expression(ast);
    }

    fn enter_enum_expression_variant_literal_numeric_expression(
        &mut self,
        ast: &'alloc NumericLiteral,
    ) {
    }

    fn leave_enum_expression_variant_literal_numeric_expression(
        &mut self,
        ast: &'alloc NumericLiteral,
    ) {
    }

    fn visit_enum_expression_variant_literal_reg_exp_expression(
        &mut self,
        pattern: &'alloc SourceSliceIndex,
        global: &'alloc bool,
        ignore_case: &'alloc bool,
        multi_line: &'alloc bool,
        dot_all: &'alloc bool,
        sticky: &'alloc bool,
        unicode: &'alloc bool,
    ) {
        self.enter_enum_expression_variant_literal_reg_exp_expression(
            pattern,
            global,
            ignore_case,
            multi_line,
            dot_all,
            sticky,
            unicode,
        );
        self.leave_enum_expression_variant_literal_reg_exp_expression(
            pattern,
            global,
            ignore_case,
            multi_line,
            dot_all,
            sticky,
            unicode,
        );
    }

    fn enter_enum_expression_variant_literal_reg_exp_expression(
        &mut self,
        pattern: &'alloc SourceSliceIndex,
        global: &'alloc bool,
        ignore_case: &'alloc bool,
        multi_line: &'alloc bool,
        dot_all: &'alloc bool,
        sticky: &'alloc bool,
        unicode: &'alloc bool,
    ) {
    }

    fn leave_enum_expression_variant_literal_reg_exp_expression(
        &mut self,
        pattern: &'alloc SourceSliceIndex,
        global: &'alloc bool,
        ignore_case: &'alloc bool,
        multi_line: &'alloc bool,
        dot_all: &'alloc bool,
        sticky: &'alloc bool,
        unicode: &'alloc bool,
    ) {
    }

    fn visit_enum_expression_variant_literal_string_expression(
        &mut self,
        value: &'alloc SourceAtomSetIndex,
    ) {
        self.enter_enum_expression_variant_literal_string_expression(
            value,
        );
        self.leave_enum_expression_variant_literal_string_expression(
            value,
        );
    }

    fn enter_enum_expression_variant_literal_string_expression(
        &mut self,
        value: &'alloc SourceAtomSetIndex,
    ) {
    }

    fn leave_enum_expression_variant_literal_string_expression(
        &mut self,
        value: &'alloc SourceAtomSetIndex,
    ) {
    }

    fn visit_enum_expression_variant_array_expression(
        &mut self,
        ast: &'alloc ArrayExpression<'alloc>,
    ) {
        self.enter_enum_expression_variant_array_expression(ast);
        self.visit_array_expression(ast);
        self.leave_enum_expression_variant_array_expression(ast);
    }

    fn enter_enum_expression_variant_array_expression(
        &mut self,
        ast: &'alloc ArrayExpression<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_array_expression(
        &mut self,
        ast: &'alloc ArrayExpression<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_arrow_expression(
        &mut self,
        is_async: &'alloc bool,
        params: &'alloc FormalParameters<'alloc>,
        body: &'alloc ArrowExpressionBody<'alloc>,
    ) {
        self.enter_enum_expression_variant_arrow_expression(
            is_async,
            params,
            body,
        );
        self.visit_formal_parameters(params);
        self.visit_arrow_expression_body(body);
        self.leave_enum_expression_variant_arrow_expression(
            is_async,
            params,
            body,
        );
    }

    fn enter_enum_expression_variant_arrow_expression(
        &mut self,
        is_async: &'alloc bool,
        params: &'alloc FormalParameters<'alloc>,
        body: &'alloc ArrowExpressionBody<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_arrow_expression(
        &mut self,
        is_async: &'alloc bool,
        params: &'alloc FormalParameters<'alloc>,
        body: &'alloc ArrowExpressionBody<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_assignment_expression(
        &mut self,
        binding: &'alloc AssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_expression_variant_assignment_expression(
            binding,
            expression,
        );
        self.visit_assignment_target(binding);
        self.visit_expression(expression);
        self.leave_enum_expression_variant_assignment_expression(
            binding,
            expression,
        );
    }

    fn enter_enum_expression_variant_assignment_expression(
        &mut self,
        binding: &'alloc AssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_expression_variant_assignment_expression(
        &mut self,
        binding: &'alloc AssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_expression_variant_binary_expression(
        &mut self,
        operator: &'alloc BinaryOperator,
        left: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_expression_variant_binary_expression(
            operator,
            left,
            right,
        );
        self.visit_binary_operator(operator);
        self.visit_expression(left);
        self.visit_expression(right);
        self.leave_enum_expression_variant_binary_expression(
            operator,
            left,
            right,
        );
    }

    fn enter_enum_expression_variant_binary_expression(
        &mut self,
        operator: &'alloc BinaryOperator,
        left: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_expression_variant_binary_expression(
        &mut self,
        operator: &'alloc BinaryOperator,
        left: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_expression_variant_call_expression(
        &mut self,
        ast: &'alloc CallExpression<'alloc>,
    ) {
        self.enter_enum_expression_variant_call_expression(ast);
        self.visit_call_expression(ast);
        self.leave_enum_expression_variant_call_expression(ast);
    }

    fn enter_enum_expression_variant_call_expression(
        &mut self,
        ast: &'alloc CallExpression<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_call_expression(
        &mut self,
        ast: &'alloc CallExpression<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_compound_assignment_expression(
        &mut self,
        operator: &'alloc CompoundAssignmentOperator,
        binding: &'alloc SimpleAssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_expression_variant_compound_assignment_expression(
            operator,
            binding,
            expression,
        );
        self.visit_compound_assignment_operator(operator);
        self.visit_simple_assignment_target(binding);
        self.visit_expression(expression);
        self.leave_enum_expression_variant_compound_assignment_expression(
            operator,
            binding,
            expression,
        );
    }

    fn enter_enum_expression_variant_compound_assignment_expression(
        &mut self,
        operator: &'alloc CompoundAssignmentOperator,
        binding: &'alloc SimpleAssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_expression_variant_compound_assignment_expression(
        &mut self,
        operator: &'alloc CompoundAssignmentOperator,
        binding: &'alloc SimpleAssignmentTarget<'alloc>,
        expression: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_expression_variant_conditional_expression(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_expression_variant_conditional_expression(
            test,
            consequent,
            alternate,
        );
        self.visit_expression(test);
        self.visit_expression(consequent);
        self.visit_expression(alternate);
        self.leave_enum_expression_variant_conditional_expression(
            test,
            consequent,
            alternate,
        );
    }

    fn enter_enum_expression_variant_conditional_expression(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_expression_variant_conditional_expression(
        &mut self,
        test: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        consequent: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        alternate: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_expression_variant_function_expression(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
        self.enter_enum_expression_variant_function_expression(ast);
        self.visit_function(ast);
        self.leave_enum_expression_variant_function_expression(ast);
    }

    fn enter_enum_expression_variant_function_expression(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_function_expression(
        &mut self,
        ast: &'alloc Function<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_identifier_expression(
        &mut self,
        ast: &'alloc IdentifierExpression,
    ) {
        self.enter_enum_expression_variant_identifier_expression(ast);
        self.visit_identifier_expression(ast);
        self.leave_enum_expression_variant_identifier_expression(ast);
    }

    fn enter_enum_expression_variant_identifier_expression(
        &mut self,
        ast: &'alloc IdentifierExpression,
    ) {
    }

    fn leave_enum_expression_variant_identifier_expression(
        &mut self,
        ast: &'alloc IdentifierExpression,
    ) {
    }

    fn visit_enum_expression_variant_new_expression(
        &mut self,
        callee: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        arguments: &'alloc Arguments<'alloc>,
    ) {
        self.enter_enum_expression_variant_new_expression(
            callee,
            arguments,
        );
        self.visit_expression(callee);
        self.visit_arguments(arguments);
        self.leave_enum_expression_variant_new_expression(
            callee,
            arguments,
        );
    }

    fn enter_enum_expression_variant_new_expression(
        &mut self,
        callee: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        arguments: &'alloc Arguments<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_new_expression(
        &mut self,
        callee: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        arguments: &'alloc Arguments<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_new_target_expression(&mut self) {
    }

    fn visit_enum_expression_variant_object_expression(
        &mut self,
        ast: &'alloc ObjectExpression<'alloc>,
    ) {
        self.enter_enum_expression_variant_object_expression(ast);
        self.visit_object_expression(ast);
        self.leave_enum_expression_variant_object_expression(ast);
    }

    fn enter_enum_expression_variant_object_expression(
        &mut self,
        ast: &'alloc ObjectExpression<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_object_expression(
        &mut self,
        ast: &'alloc ObjectExpression<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_optional_expression(
        &mut self,
        object: &'alloc ExpressionOrSuper<'alloc>,
        tail: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.enter_enum_expression_variant_optional_expression(
            object,
            tail,
        );
        self.visit_expression_or_super(object);
        self.visit_expression(tail);
        self.leave_enum_expression_variant_optional_expression(
            object,
            tail,
        );
    }

    fn enter_enum_expression_variant_optional_expression(
        &mut self,
        object: &'alloc ExpressionOrSuper<'alloc>,
        tail: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn leave_enum_expression_variant_optional_expression(
        &mut self,
        object: &'alloc ExpressionOrSuper<'alloc>,
        tail: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
    }

    fn visit_enum_expression_variant_optional_chain(
        &mut self,
        ast: &'alloc OptionalChain<'alloc>,
    ) {
        self.enter_enum_expression_variant_optional_chain(ast);
        self.visit_optional_chain(ast);
        self.leave_enum_expression_variant_optional_chain(ast);
    }

    fn enter_enum_expression_variant_optional_chain(
        &mut self,
        ast: &'alloc OptionalChain<'alloc>,
    ) {
    }

    fn leave_enum_expression_variant_optional_chain(
        &mut self,
        ast: &'alloc OptionalChain<'alloc>,
    ) {
    }

    fn visit_enum_expression_variant_unary_expression(
        &mut self,
        operator: &'alloc UnaryOperator,
        operand: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
--> --------------------

--> maximum size reached

--> --------------------