Trait binjs::specialized::es6::ast::Visitor

pub trait Visitor<E, G = ()> where
    G: WalkGuard<Self>, {
    fn enter_null(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Null
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_null(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Null
    ) -> Result<Option<Null>, E> { ... }
    fn enter_array_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayAssignmentTarget
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_array_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayAssignmentTarget
    ) -> Result<Option<ArrayAssignmentTarget>, E> { ... }
    fn enter_array_binding(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayBinding
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_array_binding(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayBinding
    ) -> Result<Option<ArrayBinding>, E> { ... }
    fn enter_array_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_array_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrayExpression
    ) -> Result<Option<ArrayExpression>, E> { ... }
    fn enter_arrow_expression_contents_with_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrowExpressionContentsWithExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_arrow_expression_contents_with_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrowExpressionContentsWithExpression
    ) -> Result<Option<ArrowExpressionContentsWithExpression>, E> { ... }
    fn enter_arrow_expression_contents_with_function_body(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrowExpressionContentsWithFunctionBody
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_arrow_expression_contents_with_function_body(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ArrowExpressionContentsWithFunctionBody
    ) -> Result<Option<ArrowExpressionContentsWithFunctionBody>, E> { ... }
    fn enter_asserted_block_scope(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBlockScope
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_block_scope(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBlockScope
    ) -> Result<Option<AssertedBlockScope>, E> { ... }
    fn enter_asserted_bound_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBoundName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_bound_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBoundName
    ) -> Result<Option<AssertedBoundName>, E> { ... }
    fn enter_asserted_bound_names_scope(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBoundNamesScope
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_bound_names_scope(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedBoundNamesScope
    ) -> Result<Option<AssertedBoundNamesScope>, E> { ... }
    fn enter_asserted_declared_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedDeclaredName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_declared_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedDeclaredName
    ) -> Result<Option<AssertedDeclaredName>, E> { ... }
    fn enter_asserted_parameter_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedParameterName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_parameter_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedParameterName
    ) -> Result<Option<AssertedParameterName>, E> { ... }
    fn enter_asserted_parameter_scope(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedParameterScope
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_parameter_scope(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedParameterScope
    ) -> Result<Option<AssertedParameterScope>, E> { ... }
    fn enter_asserted_positional_parameter_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedPositionalParameterName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_positional_parameter_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedPositionalParameterName
    ) -> Result<Option<AssertedPositionalParameterName>, E> { ... }
    fn enter_asserted_rest_parameter_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedRestParameterName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_rest_parameter_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedRestParameterName
    ) -> Result<Option<AssertedRestParameterName>, E> { ... }
    fn enter_asserted_script_global_scope(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedScriptGlobalScope
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_script_global_scope(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedScriptGlobalScope
    ) -> Result<Option<AssertedScriptGlobalScope>, E> { ... }
    fn enter_asserted_var_scope(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedVarScope
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_var_scope(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssertedVarScope
    ) -> Result<Option<AssertedVarScope>, E> { ... }
    fn enter_assignment_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentExpression
    ) -> Result<Option<AssignmentExpression>, E> { ... }
    fn enter_assignment_target_identifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetIdentifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_identifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetIdentifier
    ) -> Result<Option<AssignmentTargetIdentifier>, E> { ... }
    fn enter_assignment_target_property_identifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetPropertyIdentifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_property_identifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetPropertyIdentifier
    ) -> Result<Option<AssignmentTargetPropertyIdentifier>, E> { ... }
    fn enter_assignment_target_property_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetPropertyProperty
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_property_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetPropertyProperty
    ) -> Result<Option<AssignmentTargetPropertyProperty>, E> { ... }
    fn enter_assignment_target_with_initializer(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetWithInitializer
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_with_initializer(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AssignmentTargetWithInitializer
    ) -> Result<Option<AssignmentTargetWithInitializer>, E> { ... }
    fn enter_await_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut AwaitExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_await_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut AwaitExpression
    ) -> Result<Option<AwaitExpression>, E> { ... }
    fn enter_bin_ast_expression_with_probability_table(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BinASTExpressionWithProbabilityTable
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_bin_ast_expression_with_probability_table(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BinASTExpressionWithProbabilityTable
    ) -> Result<Option<BinASTExpressionWithProbabilityTable>, E> { ... }
    fn enter_binary_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BinaryExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binary_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BinaryExpression
    ) -> Result<Option<BinaryExpression>, E> { ... }
    fn enter_binding_identifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingIdentifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_identifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingIdentifier
    ) -> Result<Option<BindingIdentifier>, E> { ... }
    fn enter_binding_property_identifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingPropertyIdentifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_property_identifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingPropertyIdentifier
    ) -> Result<Option<BindingPropertyIdentifier>, E> { ... }
    fn enter_binding_property_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingPropertyProperty
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_property_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingPropertyProperty
    ) -> Result<Option<BindingPropertyProperty>, E> { ... }
    fn enter_binding_with_initializer(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingWithInitializer
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_with_initializer(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BindingWithInitializer
    ) -> Result<Option<BindingWithInitializer>, E> { ... }
    fn enter_block(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Block
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_block(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Block
    ) -> Result<Option<Block>, E> { ... }
    fn enter_break_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut BreakStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_break_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut BreakStatement
    ) -> Result<Option<BreakStatement>, E> { ... }
    fn enter_call_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut CallExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_call_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut CallExpression
    ) -> Result<Option<CallExpression>, E> { ... }
    fn enter_catch_clause(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut CatchClause
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_catch_clause(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut CatchClause
    ) -> Result<Option<CatchClause>, E> { ... }
    fn enter_class_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassDeclaration
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_class_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassDeclaration
    ) -> Result<Option<ClassDeclaration>, E> { ... }
    fn enter_class_element(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassElement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_class_element(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassElement
    ) -> Result<Option<ClassElement>, E> { ... }
    fn enter_class_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_class_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ClassExpression
    ) -> Result<Option<ClassExpression>, E> { ... }
    fn enter_compound_assignment_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut CompoundAssignmentExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_compound_assignment_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut CompoundAssignmentExpression
    ) -> Result<Option<CompoundAssignmentExpression>, E> { ... }
    fn enter_computed_member_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedMemberAssignmentTarget
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_computed_member_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedMemberAssignmentTarget
    ) -> Result<Option<ComputedMemberAssignmentTarget>, E> { ... }
    fn enter_computed_member_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedMemberExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_computed_member_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedMemberExpression
    ) -> Result<Option<ComputedMemberExpression>, E> { ... }
    fn enter_computed_property_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedPropertyName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_computed_property_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ComputedPropertyName
    ) -> Result<Option<ComputedPropertyName>, E> { ... }
    fn enter_conditional_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ConditionalExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_conditional_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ConditionalExpression
    ) -> Result<Option<ConditionalExpression>, E> { ... }
    fn enter_continue_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ContinueStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_continue_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ContinueStatement
    ) -> Result<Option<ContinueStatement>, E> { ... }
    fn enter_data_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut DataProperty
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_data_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut DataProperty
    ) -> Result<Option<DataProperty>, E> { ... }
    fn enter_debugger_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut DebuggerStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_debugger_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut DebuggerStatement
    ) -> Result<Option<DebuggerStatement>, E> { ... }
    fn enter_directive(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Directive
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_directive(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Directive
    ) -> Result<Option<Directive>, E> { ... }
    fn enter_do_while_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut DoWhileStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_do_while_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut DoWhileStatement
    ) -> Result<Option<DoWhileStatement>, E> { ... }
    fn enter_eager_arrow_expression_with_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerArrowExpressionWithExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_arrow_expression_with_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerArrowExpressionWithExpression
    ) -> Result<Option<EagerArrowExpressionWithExpression>, E> { ... }
    fn enter_eager_arrow_expression_with_function_body(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerArrowExpressionWithFunctionBody
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_arrow_expression_with_function_body(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerArrowExpressionWithFunctionBody
    ) -> Result<Option<EagerArrowExpressionWithFunctionBody>, E> { ... }
    fn enter_eager_function_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerFunctionDeclaration
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_function_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerFunctionDeclaration
    ) -> Result<Option<EagerFunctionDeclaration>, E> { ... }
    fn enter_eager_function_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerFunctionExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_function_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerFunctionExpression
    ) -> Result<Option<EagerFunctionExpression>, E> { ... }
    fn enter_eager_getter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerGetter
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_getter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerGetter
    ) -> Result<Option<EagerGetter>, E> { ... }
    fn enter_eager_method(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerMethod
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_method(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerMethod
    ) -> Result<Option<EagerMethod>, E> { ... }
    fn enter_eager_setter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerSetter
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_eager_setter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EagerSetter
    ) -> Result<Option<EagerSetter>, E> { ... }
    fn enter_empty_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut EmptyStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_empty_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut EmptyStatement
    ) -> Result<Option<EmptyStatement>, E> { ... }
    fn enter_export(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Export
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Export
    ) -> Result<Option<Export>, E> { ... }
    fn enter_export_all_from(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportAllFrom
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_all_from(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportAllFrom
    ) -> Result<Option<ExportAllFrom>, E> { ... }
    fn enter_export_default(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportDefault
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_default(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportDefault
    ) -> Result<Option<ExportDefault>, E> { ... }
    fn enter_export_from(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportFrom
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_from(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportFrom
    ) -> Result<Option<ExportFrom>, E> { ... }
    fn enter_export_from_specifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportFromSpecifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_from_specifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportFromSpecifier
    ) -> Result<Option<ExportFromSpecifier>, E> { ... }
    fn enter_export_local_specifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportLocalSpecifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_local_specifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportLocalSpecifier
    ) -> Result<Option<ExportLocalSpecifier>, E> { ... }
    fn enter_export_locals(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportLocals
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_locals(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExportLocals
    ) -> Result<Option<ExportLocals>, E> { ... }
    fn enter_expression_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ExpressionStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ExpressionStatement
    ) -> Result<Option<ExpressionStatement>, E> { ... }
    fn enter_for_in_of_binding(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ForInOfBinding
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_for_in_of_binding(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ForInOfBinding
    ) -> Result<Option<ForInOfBinding>, E> { ... }
    fn enter_for_in_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ForInStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_for_in_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ForInStatement
    ) -> Result<Option<ForInStatement>, E> { ... }
    fn enter_for_of_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ForOfStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_for_of_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ForOfStatement
    ) -> Result<Option<ForOfStatement>, E> { ... }
    fn enter_for_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ForStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_for_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ForStatement
    ) -> Result<Option<ForStatement>, E> { ... }
    fn enter_formal_parameters(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut FormalParameters
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_formal_parameters(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut FormalParameters
    ) -> Result<Option<FormalParameters>, E> { ... }
    fn enter_function_expression_contents(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut FunctionExpressionContents
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_function_expression_contents(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut FunctionExpressionContents
    ) -> Result<Option<FunctionExpressionContents>, E> { ... }
    fn enter_function_or_method_contents(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut FunctionOrMethodContents
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_function_or_method_contents(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut FunctionOrMethodContents
    ) -> Result<Option<FunctionOrMethodContents>, E> { ... }
    fn enter_getter_contents(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut GetterContents
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_getter_contents(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut GetterContents
    ) -> Result<Option<GetterContents>, E> { ... }
    fn enter_identifier_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut IdentifierExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_identifier_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut IdentifierExpression
    ) -> Result<Option<IdentifierExpression>, E> { ... }
    fn enter_if_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut IfStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_if_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut IfStatement
    ) -> Result<Option<IfStatement>, E> { ... }
    fn enter_import(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Import
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_import(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Import
    ) -> Result<Option<Import>, E> { ... }
    fn enter_import_namespace(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ImportNamespace
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_import_namespace(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ImportNamespace
    ) -> Result<Option<ImportNamespace>, E> { ... }
    fn enter_import_specifier(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ImportSpecifier
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_import_specifier(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ImportSpecifier
    ) -> Result<Option<ImportSpecifier>, E> { ... }
    fn enter_labelled_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LabelledStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_labelled_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LabelledStatement
    ) -> Result<Option<LabelledStatement>, E> { ... }
    fn enter_lazy_arrow_expression_with_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyArrowExpressionWithExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_arrow_expression_with_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyArrowExpressionWithExpression
    ) -> Result<Option<LazyArrowExpressionWithExpression>, E> { ... }
    fn enter_lazy_arrow_expression_with_function_body(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyArrowExpressionWithFunctionBody
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_arrow_expression_with_function_body(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyArrowExpressionWithFunctionBody
    ) -> Result<Option<LazyArrowExpressionWithFunctionBody>, E> { ... }
    fn enter_lazy_function_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyFunctionDeclaration
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_function_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyFunctionDeclaration
    ) -> Result<Option<LazyFunctionDeclaration>, E> { ... }
    fn enter_lazy_function_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyFunctionExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_function_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyFunctionExpression
    ) -> Result<Option<LazyFunctionExpression>, E> { ... }
    fn enter_lazy_getter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyGetter
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_getter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyGetter
    ) -> Result<Option<LazyGetter>, E> { ... }
    fn enter_lazy_method(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyMethod
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_method(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazyMethod
    ) -> Result<Option<LazyMethod>, E> { ... }
    fn enter_lazy_setter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LazySetter
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_lazy_setter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LazySetter
    ) -> Result<Option<LazySetter>, E> { ... }
    fn enter_literal_boolean_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralBooleanExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_boolean_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralBooleanExpression
    ) -> Result<Option<LiteralBooleanExpression>, E> { ... }
    fn enter_literal_infinity_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralInfinityExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_infinity_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralInfinityExpression
    ) -> Result<Option<LiteralInfinityExpression>, E> { ... }
    fn enter_literal_null_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralNullExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_null_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralNullExpression
    ) -> Result<Option<LiteralNullExpression>, E> { ... }
    fn enter_literal_numeric_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralNumericExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_numeric_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralNumericExpression
    ) -> Result<Option<LiteralNumericExpression>, E> { ... }
    fn enter_literal_property_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralPropertyName
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_property_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralPropertyName
    ) -> Result<Option<LiteralPropertyName>, E> { ... }
    fn enter_literal_reg_exp_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralRegExpExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_reg_exp_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralRegExpExpression
    ) -> Result<Option<LiteralRegExpExpression>, E> { ... }
    fn enter_literal_string_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralStringExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal_string_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut LiteralStringExpression
    ) -> Result<Option<LiteralStringExpression>, E> { ... }
    fn enter_module(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Module
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_module(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Module
    ) -> Result<Option<Module>, E> { ... }
    fn enter_new_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut NewExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_new_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut NewExpression
    ) -> Result<Option<NewExpression>, E> { ... }
    fn enter_new_target_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut NewTargetExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_new_target_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut NewTargetExpression
    ) -> Result<Option<NewTargetExpression>, E> { ... }
    fn enter_object_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectAssignmentTarget
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_object_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectAssignmentTarget
    ) -> Result<Option<ObjectAssignmentTarget>, E> { ... }
    fn enter_object_binding(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectBinding
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_object_binding(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectBinding
    ) -> Result<Option<ObjectBinding>, E> { ... }
    fn enter_object_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_object_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ObjectExpression
    ) -> Result<Option<ObjectExpression>, E> { ... }
    fn enter_return_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ReturnStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_return_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ReturnStatement
    ) -> Result<Option<ReturnStatement>, E> { ... }
    fn enter_script(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Script
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_script(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Script
    ) -> Result<Option<Script>, E> { ... }
    fn enter_setter_contents(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SetterContents
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_setter_contents(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SetterContents
    ) -> Result<Option<SetterContents>, E> { ... }
    fn enter_shorthand_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ShorthandProperty
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_shorthand_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ShorthandProperty
    ) -> Result<Option<ShorthandProperty>, E> { ... }
    fn enter_spread_element(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SpreadElement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_spread_element(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SpreadElement
    ) -> Result<Option<SpreadElement>, E> { ... }
    fn enter_static_member_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut StaticMemberAssignmentTarget
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_static_member_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut StaticMemberAssignmentTarget
    ) -> Result<Option<StaticMemberAssignmentTarget>, E> { ... }
    fn enter_static_member_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut StaticMemberExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_static_member_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut StaticMemberExpression
    ) -> Result<Option<StaticMemberExpression>, E> { ... }
    fn enter_super_(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut Super
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_super_(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Super
    ) -> Result<Option<Super>, E> { ... }
    fn enter_switch_case(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchCase
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_switch_case(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchCase
    ) -> Result<Option<SwitchCase>, E> { ... }
    fn enter_switch_default(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchDefault
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_switch_default(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchDefault
    ) -> Result<Option<SwitchDefault>, E> { ... }
    fn enter_switch_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_switch_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchStatement
    ) -> Result<Option<SwitchStatement>, E> { ... }
    fn enter_switch_statement_with_default(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchStatementWithDefault
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_switch_statement_with_default(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut SwitchStatementWithDefault
    ) -> Result<Option<SwitchStatementWithDefault>, E> { ... }
    fn enter_template_element(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut TemplateElement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_template_element(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut TemplateElement
    ) -> Result<Option<TemplateElement>, E> { ... }
    fn enter_template_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut TemplateExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_template_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut TemplateExpression
    ) -> Result<Option<TemplateExpression>, E> { ... }
    fn enter_this_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ThisExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_this_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ThisExpression
    ) -> Result<Option<ThisExpression>, E> { ... }
    fn enter_throw_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ThrowStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_throw_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ThrowStatement
    ) -> Result<Option<ThrowStatement>, E> { ... }
    fn enter_try_catch_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut TryCatchStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_try_catch_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut TryCatchStatement
    ) -> Result<Option<TryCatchStatement>, E> { ... }
    fn enter_try_finally_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut TryFinallyStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_try_finally_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut TryFinallyStatement
    ) -> Result<Option<TryFinallyStatement>, E> { ... }
    fn enter_unary_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut UnaryExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_unary_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut UnaryExpression
    ) -> Result<Option<UnaryExpression>, E> { ... }
    fn enter_update_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut UpdateExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_update_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut UpdateExpression
    ) -> Result<Option<UpdateExpression>, E> { ... }
    fn enter_variable_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut VariableDeclaration
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_variable_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut VariableDeclaration
    ) -> Result<Option<VariableDeclaration>, E> { ... }
    fn enter_variable_declarator(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut VariableDeclarator
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_variable_declarator(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut VariableDeclarator
    ) -> Result<Option<VariableDeclarator>, E> { ... }
    fn enter_while_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut WhileStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_while_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut WhileStatement
    ) -> Result<Option<WhileStatement>, E> { ... }
    fn enter_with_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut WithStatement
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_with_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut WithStatement
    ) -> Result<Option<WithStatement>, E> { ... }
    fn enter_yield_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut YieldExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_yield_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut YieldExpression
    ) -> Result<Option<YieldExpression>, E> { ... }
    fn enter_yield_star_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut YieldStarExpression
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_yield_star_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut YieldStarExpression
    ) -> Result<Option<YieldStarExpression>, E> { ... }
    fn enter_arrow_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutArrowExpression<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_arrow_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutArrowExpression<'a>
    ) -> Result<Option<ArrowExpression>, E> { ... }
    fn enter_asserted_maybe_positional_parameter_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssertedMaybePositionalParameterName<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_asserted_maybe_positional_parameter_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssertedMaybePositionalParameterName<'a>
    ) -> Result<Option<AssertedMaybePositionalParameterName>, E> { ... }
    fn enter_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTarget<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTarget<'a>
    ) -> Result<Option<AssignmentTarget>, E> { ... }
    fn enter_assignment_target_or_assignment_target_with_initializer(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_or_assignment_target_with_initializer(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a>
    ) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, E> { ... }
    fn enter_assignment_target_or_for_in_of_binding(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetOrForInOfBinding<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_or_for_in_of_binding(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetOrForInOfBinding<'a>
    ) -> Result<Option<AssignmentTargetOrForInOfBinding>, E> { ... }
    fn enter_assignment_target_pattern(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetPattern<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_pattern(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetPattern<'a>
    ) -> Result<Option<AssignmentTargetPattern>, E> { ... }
    fn enter_assignment_target_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetProperty<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_assignment_target_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutAssignmentTargetProperty<'a>
    ) -> Result<Option<AssignmentTargetProperty>, E> { ... }
    fn enter_binding(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBinding<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBinding<'a>
    ) -> Result<Option<Binding>, E> { ... }
    fn enter_binding_or_binding_with_initializer(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingOrBindingWithInitializer<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_or_binding_with_initializer(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingOrBindingWithInitializer<'a>
    ) -> Result<Option<BindingOrBindingWithInitializer>, E> { ... }
    fn enter_binding_pattern(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingPattern<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_pattern(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingPattern<'a>
    ) -> Result<Option<BindingPattern>, E> { ... }
    fn enter_binding_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingProperty<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_binding_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutBindingProperty<'a>
    ) -> Result<Option<BindingProperty>, E> { ... }
    fn enter_class_declaration_or_expression_or_function_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_class_declaration_or_expression_or_function_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a>
    ) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, E> { ... }
    fn enter_class_declaration_or_function_declaration_or_variable_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_class_declaration_or_function_declaration_or_variable_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a>
    ) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, E> { ... }
    fn enter_export_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExportDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExportDeclaration<'a>
    ) -> Result<Option<ExportDeclaration>, E> { ... }
    fn enter_export_declaration_or_import_declaration_or_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExportDeclarationOrImportDeclarationOrStatement<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_export_declaration_or_import_declaration_or_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExportDeclarationOrImportDeclarationOrStatement<'a>
    ) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, E> { ... }
    fn enter_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpression<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpression<'a>
    ) -> Result<Option<Expression>, E> { ... }
    fn enter_expression_or_spread_element(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrSpreadElement<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression_or_spread_element(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrSpreadElement<'a>
    ) -> Result<Option<ExpressionOrSpreadElement>, E> { ... }
    fn enter_expression_or_super(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrSuper<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression_or_super(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrSuper<'a>
    ) -> Result<Option<ExpressionOrSuper>, E> { ... }
    fn enter_expression_or_template_element(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrTemplateElement<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression_or_template_element(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrTemplateElement<'a>
    ) -> Result<Option<ExpressionOrTemplateElement>, E> { ... }
    fn enter_expression_or_variable_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrVariableDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_expression_or_variable_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutExpressionOrVariableDeclaration<'a>
    ) -> Result<Option<ExpressionOrVariableDeclaration>, E> { ... }
    fn enter_function_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutFunctionDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_function_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutFunctionDeclaration<'a>
    ) -> Result<Option<FunctionDeclaration>, E> { ... }
    fn enter_function_expression(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutFunctionExpression<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_function_expression(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutFunctionExpression<'a>
    ) -> Result<Option<FunctionExpression>, E> { ... }
    fn enter_getter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutGetter<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_getter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutGetter<'a>
    ) -> Result<Option<Getter>, E> { ... }
    fn enter_import_declaration(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutImportDeclaration<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_import_declaration(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutImportDeclaration<'a>
    ) -> Result<Option<ImportDeclaration>, E> { ... }
    fn enter_iteration_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutIterationStatement<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_iteration_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutIterationStatement<'a>
    ) -> Result<Option<IterationStatement>, E> { ... }
    fn enter_literal(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutLiteral<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_literal(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutLiteral<'a>
    ) -> Result<Option<Literal>, E> { ... }
    fn enter_method(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutMethod<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_method(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutMethod<'a>
    ) -> Result<Option<Method>, E> { ... }
    fn enter_method_definition(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutMethodDefinition<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_method_definition(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutMethodDefinition<'a>
    ) -> Result<Option<MethodDefinition>, E> { ... }
    fn enter_object_property(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutObjectProperty<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_object_property(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutObjectProperty<'a>
    ) -> Result<Option<ObjectProperty>, E> { ... }
    fn enter_parameter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutParameter<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_parameter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutParameter<'a>
    ) -> Result<Option<Parameter>, E> { ... }
    fn enter_program(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutProgram<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_program(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutProgram<'a>
    ) -> Result<Option<Program>, E> { ... }
    fn enter_property_name(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutPropertyName<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_property_name(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutPropertyName<'a>
    ) -> Result<Option<PropertyName>, E> { ... }
    fn enter_setter(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutSetter<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_setter(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutSetter<'a>
    ) -> Result<Option<Setter>, E> { ... }
    fn enter_simple_assignment_target(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutSimpleAssignmentTarget<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_simple_assignment_target(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutSimpleAssignmentTarget<'a>
    ) -> Result<Option<SimpleAssignmentTarget>, E> { ... }
    fn enter_statement(
        &mut self, 
        path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutStatement<'a>
    ) -> Result<VisitMe<G>, E> { ... }
    fn exit_statement(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut ViewMutStatement<'a>
    ) -> Result<Option<Statement>, E> { ... }
    fn visit_offset(
        &mut self, 
        _path: &Path<ASTNode, ASTField>, 
        _node: &mut Offset
    ) -> Result<(), E> { ... }
}

A set of callbacks used to inspect the contents of an AST in a strongly-typed manner. For each node Foo, enter_foo() will be called before visiting the children, giving the opportunity to alter the node, and enter_foo() will be called after visiting the children, giving the opportunity to alter it further.

Each of the nodes of this AST implements Walker and may be visited recursively using Visitor.

Type argument G is a type of guards.

Provided methods

fn enter_null(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Null
) -> Result<VisitMe<G>, E>

fn exit_null(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Null
) -> Result<Option<Null>, E>

fn enter_array_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayAssignmentTarget
) -> Result<VisitMe<G>, E>

fn exit_array_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayAssignmentTarget
) -> Result<Option<ArrayAssignmentTarget>, E>

fn enter_array_binding(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayBinding
) -> Result<VisitMe<G>, E>

fn exit_array_binding(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayBinding
) -> Result<Option<ArrayBinding>, E>

fn enter_array_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayExpression
) -> Result<VisitMe<G>, E>

fn exit_array_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ArrayExpression
) -> Result<Option<ArrayExpression>, E>

fn enter_arrow_expression_contents_with_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ArrowExpressionContentsWithExpression
) -> Result<VisitMe<G>, E>

fn exit_arrow_expression_contents_with_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ArrowExpressionContentsWithExpression
) -> Result<Option<ArrowExpressionContentsWithExpression>, E>

fn enter_arrow_expression_contents_with_function_body(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ArrowExpressionContentsWithFunctionBody
) -> Result<VisitMe<G>, E>

fn exit_arrow_expression_contents_with_function_body(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ArrowExpressionContentsWithFunctionBody
) -> Result<Option<ArrowExpressionContentsWithFunctionBody>, E>

fn enter_asserted_block_scope(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBlockScope
) -> Result<VisitMe<G>, E>

fn exit_asserted_block_scope(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBlockScope
) -> Result<Option<AssertedBlockScope>, E>

fn enter_asserted_bound_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBoundName
) -> Result<VisitMe<G>, E>

fn exit_asserted_bound_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBoundName
) -> Result<Option<AssertedBoundName>, E>

fn enter_asserted_bound_names_scope(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBoundNamesScope
) -> Result<VisitMe<G>, E>

fn exit_asserted_bound_names_scope(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedBoundNamesScope
) -> Result<Option<AssertedBoundNamesScope>, E>

fn enter_asserted_declared_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedDeclaredName
) -> Result<VisitMe<G>, E>

fn exit_asserted_declared_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedDeclaredName
) -> Result<Option<AssertedDeclaredName>, E>

fn enter_asserted_parameter_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedParameterName
) -> Result<VisitMe<G>, E>

fn exit_asserted_parameter_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedParameterName
) -> Result<Option<AssertedParameterName>, E>

fn enter_asserted_parameter_scope(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedParameterScope
) -> Result<VisitMe<G>, E>

fn exit_asserted_parameter_scope(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedParameterScope
) -> Result<Option<AssertedParameterScope>, E>

fn enter_asserted_positional_parameter_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedPositionalParameterName
) -> Result<VisitMe<G>, E>

fn exit_asserted_positional_parameter_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedPositionalParameterName
) -> Result<Option<AssertedPositionalParameterName>, E>

fn enter_asserted_rest_parameter_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedRestParameterName
) -> Result<VisitMe<G>, E>

fn exit_asserted_rest_parameter_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedRestParameterName
) -> Result<Option<AssertedRestParameterName>, E>

fn enter_asserted_script_global_scope(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedScriptGlobalScope
) -> Result<VisitMe<G>, E>

fn exit_asserted_script_global_scope(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedScriptGlobalScope
) -> Result<Option<AssertedScriptGlobalScope>, E>

fn enter_asserted_var_scope(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedVarScope
) -> Result<VisitMe<G>, E>

fn exit_asserted_var_scope(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssertedVarScope
) -> Result<Option<AssertedVarScope>, E>

fn enter_assignment_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentExpression
) -> Result<VisitMe<G>, E>

fn exit_assignment_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentExpression
) -> Result<Option<AssignmentExpression>, E>

fn enter_assignment_target_identifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetIdentifier
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_identifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetIdentifier
) -> Result<Option<AssignmentTargetIdentifier>, E>

fn enter_assignment_target_property_identifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetPropertyIdentifier
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_property_identifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetPropertyIdentifier
) -> Result<Option<AssignmentTargetPropertyIdentifier>, E>

fn enter_assignment_target_property_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetPropertyProperty
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_property_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetPropertyProperty
) -> Result<Option<AssignmentTargetPropertyProperty>, E>

fn enter_assignment_target_with_initializer(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetWithInitializer
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_with_initializer(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AssignmentTargetWithInitializer
) -> Result<Option<AssignmentTargetWithInitializer>, E>

fn enter_await_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut AwaitExpression
) -> Result<VisitMe<G>, E>

fn exit_await_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut AwaitExpression
) -> Result<Option<AwaitExpression>, E>

fn enter_bin_ast_expression_with_probability_table(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BinASTExpressionWithProbabilityTable
) -> Result<VisitMe<G>, E>

fn exit_bin_ast_expression_with_probability_table(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BinASTExpressionWithProbabilityTable
) -> Result<Option<BinASTExpressionWithProbabilityTable>, E>

fn enter_binary_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BinaryExpression
) -> Result<VisitMe<G>, E>

fn exit_binary_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BinaryExpression
) -> Result<Option<BinaryExpression>, E>

fn enter_binding_identifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BindingIdentifier
) -> Result<VisitMe<G>, E>

fn exit_binding_identifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BindingIdentifier
) -> Result<Option<BindingIdentifier>, E>

fn enter_binding_property_identifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BindingPropertyIdentifier
) -> Result<VisitMe<G>, E>

fn exit_binding_property_identifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BindingPropertyIdentifier
) -> Result<Option<BindingPropertyIdentifier>, E>

fn enter_binding_property_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BindingPropertyProperty
) -> Result<VisitMe<G>, E>

fn exit_binding_property_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BindingPropertyProperty
) -> Result<Option<BindingPropertyProperty>, E>

fn enter_binding_with_initializer(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BindingWithInitializer
) -> Result<VisitMe<G>, E>

fn exit_binding_with_initializer(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BindingWithInitializer
) -> Result<Option<BindingWithInitializer>, E>

fn enter_block(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Block
) -> Result<VisitMe<G>, E>

fn exit_block(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Block
) -> Result<Option<Block>, E>

fn enter_break_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut BreakStatement
) -> Result<VisitMe<G>, E>

fn exit_break_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut BreakStatement
) -> Result<Option<BreakStatement>, E>

fn enter_call_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut CallExpression
) -> Result<VisitMe<G>, E>

fn exit_call_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut CallExpression
) -> Result<Option<CallExpression>, E>

fn enter_catch_clause(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut CatchClause
) -> Result<VisitMe<G>, E>

fn exit_catch_clause(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut CatchClause
) -> Result<Option<CatchClause>, E>

fn enter_class_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ClassDeclaration
) -> Result<VisitMe<G>, E>

fn exit_class_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ClassDeclaration
) -> Result<Option<ClassDeclaration>, E>

fn enter_class_element(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ClassElement
) -> Result<VisitMe<G>, E>

fn exit_class_element(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ClassElement
) -> Result<Option<ClassElement>, E>

fn enter_class_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ClassExpression
) -> Result<VisitMe<G>, E>

fn exit_class_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ClassExpression
) -> Result<Option<ClassExpression>, E>

fn enter_compound_assignment_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut CompoundAssignmentExpression
) -> Result<VisitMe<G>, E>

fn exit_compound_assignment_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut CompoundAssignmentExpression
) -> Result<Option<CompoundAssignmentExpression>, E>

fn enter_computed_member_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedMemberAssignmentTarget
) -> Result<VisitMe<G>, E>

fn exit_computed_member_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedMemberAssignmentTarget
) -> Result<Option<ComputedMemberAssignmentTarget>, E>

fn enter_computed_member_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedMemberExpression
) -> Result<VisitMe<G>, E>

fn exit_computed_member_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedMemberExpression
) -> Result<Option<ComputedMemberExpression>, E>

fn enter_computed_property_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedPropertyName
) -> Result<VisitMe<G>, E>

fn exit_computed_property_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ComputedPropertyName
) -> Result<Option<ComputedPropertyName>, E>

fn enter_conditional_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ConditionalExpression
) -> Result<VisitMe<G>, E>

fn exit_conditional_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ConditionalExpression
) -> Result<Option<ConditionalExpression>, E>

fn enter_continue_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ContinueStatement
) -> Result<VisitMe<G>, E>

fn exit_continue_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ContinueStatement
) -> Result<Option<ContinueStatement>, E>

fn enter_data_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut DataProperty
) -> Result<VisitMe<G>, E>

fn exit_data_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut DataProperty
) -> Result<Option<DataProperty>, E>

fn enter_debugger_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut DebuggerStatement
) -> Result<VisitMe<G>, E>

fn exit_debugger_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut DebuggerStatement
) -> Result<Option<DebuggerStatement>, E>

fn enter_directive(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Directive
) -> Result<VisitMe<G>, E>

fn exit_directive(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Directive
) -> Result<Option<Directive>, E>

fn enter_do_while_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut DoWhileStatement
) -> Result<VisitMe<G>, E>

fn exit_do_while_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut DoWhileStatement
) -> Result<Option<DoWhileStatement>, E>

fn enter_eager_arrow_expression_with_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerArrowExpressionWithExpression
) -> Result<VisitMe<G>, E>

fn exit_eager_arrow_expression_with_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerArrowExpressionWithExpression
) -> Result<Option<EagerArrowExpressionWithExpression>, E>

fn enter_eager_arrow_expression_with_function_body(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerArrowExpressionWithFunctionBody
) -> Result<VisitMe<G>, E>

fn exit_eager_arrow_expression_with_function_body(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerArrowExpressionWithFunctionBody
) -> Result<Option<EagerArrowExpressionWithFunctionBody>, E>

fn enter_eager_function_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerFunctionDeclaration
) -> Result<VisitMe<G>, E>

fn exit_eager_function_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerFunctionDeclaration
) -> Result<Option<EagerFunctionDeclaration>, E>

fn enter_eager_function_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerFunctionExpression
) -> Result<VisitMe<G>, E>

fn exit_eager_function_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerFunctionExpression
) -> Result<Option<EagerFunctionExpression>, E>

fn enter_eager_getter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerGetter
) -> Result<VisitMe<G>, E>

fn exit_eager_getter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerGetter
) -> Result<Option<EagerGetter>, E>

fn enter_eager_method(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerMethod
) -> Result<VisitMe<G>, E>

fn exit_eager_method(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerMethod
) -> Result<Option<EagerMethod>, E>

fn enter_eager_setter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EagerSetter
) -> Result<VisitMe<G>, E>

fn exit_eager_setter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EagerSetter
) -> Result<Option<EagerSetter>, E>

fn enter_empty_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut EmptyStatement
) -> Result<VisitMe<G>, E>

fn exit_empty_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut EmptyStatement
) -> Result<Option<EmptyStatement>, E>

fn enter_export(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Export
) -> Result<VisitMe<G>, E>

fn exit_export(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Export
) -> Result<Option<Export>, E>

fn enter_export_all_from(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportAllFrom
) -> Result<VisitMe<G>, E>

fn exit_export_all_from(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportAllFrom
) -> Result<Option<ExportAllFrom>, E>

fn enter_export_default(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportDefault
) -> Result<VisitMe<G>, E>

fn exit_export_default(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportDefault
) -> Result<Option<ExportDefault>, E>

fn enter_export_from(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportFrom
) -> Result<VisitMe<G>, E>

fn exit_export_from(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportFrom
) -> Result<Option<ExportFrom>, E>

fn enter_export_from_specifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportFromSpecifier
) -> Result<VisitMe<G>, E>

fn exit_export_from_specifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportFromSpecifier
) -> Result<Option<ExportFromSpecifier>, E>

fn enter_export_local_specifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportLocalSpecifier
) -> Result<VisitMe<G>, E>

fn exit_export_local_specifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportLocalSpecifier
) -> Result<Option<ExportLocalSpecifier>, E>

fn enter_export_locals(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExportLocals
) -> Result<VisitMe<G>, E>

fn exit_export_locals(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExportLocals
) -> Result<Option<ExportLocals>, E>

fn enter_expression_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ExpressionStatement
) -> Result<VisitMe<G>, E>

fn exit_expression_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ExpressionStatement
) -> Result<Option<ExpressionStatement>, E>

fn enter_for_in_of_binding(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ForInOfBinding
) -> Result<VisitMe<G>, E>

fn exit_for_in_of_binding(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ForInOfBinding
) -> Result<Option<ForInOfBinding>, E>

fn enter_for_in_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ForInStatement
) -> Result<VisitMe<G>, E>

fn exit_for_in_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ForInStatement
) -> Result<Option<ForInStatement>, E>

fn enter_for_of_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ForOfStatement
) -> Result<VisitMe<G>, E>

fn exit_for_of_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ForOfStatement
) -> Result<Option<ForOfStatement>, E>

fn enter_for_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ForStatement
) -> Result<VisitMe<G>, E>

fn exit_for_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ForStatement
) -> Result<Option<ForStatement>, E>

fn enter_formal_parameters(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut FormalParameters
) -> Result<VisitMe<G>, E>

fn exit_formal_parameters(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut FormalParameters
) -> Result<Option<FormalParameters>, E>

fn enter_function_expression_contents(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut FunctionExpressionContents
) -> Result<VisitMe<G>, E>

fn exit_function_expression_contents(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut FunctionExpressionContents
) -> Result<Option<FunctionExpressionContents>, E>

fn enter_function_or_method_contents(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut FunctionOrMethodContents
) -> Result<VisitMe<G>, E>

fn exit_function_or_method_contents(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut FunctionOrMethodContents
) -> Result<Option<FunctionOrMethodContents>, E>

fn enter_getter_contents(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut GetterContents
) -> Result<VisitMe<G>, E>

fn exit_getter_contents(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut GetterContents
) -> Result<Option<GetterContents>, E>

fn enter_identifier_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut IdentifierExpression
) -> Result<VisitMe<G>, E>

fn exit_identifier_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut IdentifierExpression
) -> Result<Option<IdentifierExpression>, E>

fn enter_if_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut IfStatement
) -> Result<VisitMe<G>, E>

fn exit_if_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut IfStatement
) -> Result<Option<IfStatement>, E>

fn enter_import(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Import
) -> Result<VisitMe<G>, E>

fn exit_import(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Import
) -> Result<Option<Import>, E>

fn enter_import_namespace(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ImportNamespace
) -> Result<VisitMe<G>, E>

fn exit_import_namespace(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ImportNamespace
) -> Result<Option<ImportNamespace>, E>

fn enter_import_specifier(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ImportSpecifier
) -> Result<VisitMe<G>, E>

fn exit_import_specifier(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ImportSpecifier
) -> Result<Option<ImportSpecifier>, E>

fn enter_labelled_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LabelledStatement
) -> Result<VisitMe<G>, E>

fn exit_labelled_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LabelledStatement
) -> Result<Option<LabelledStatement>, E>

fn enter_lazy_arrow_expression_with_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyArrowExpressionWithExpression
) -> Result<VisitMe<G>, E>

fn exit_lazy_arrow_expression_with_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyArrowExpressionWithExpression
) -> Result<Option<LazyArrowExpressionWithExpression>, E>

fn enter_lazy_arrow_expression_with_function_body(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyArrowExpressionWithFunctionBody
) -> Result<VisitMe<G>, E>

fn exit_lazy_arrow_expression_with_function_body(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyArrowExpressionWithFunctionBody
) -> Result<Option<LazyArrowExpressionWithFunctionBody>, E>

fn enter_lazy_function_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyFunctionDeclaration
) -> Result<VisitMe<G>, E>

fn exit_lazy_function_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyFunctionDeclaration
) -> Result<Option<LazyFunctionDeclaration>, E>

fn enter_lazy_function_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyFunctionExpression
) -> Result<VisitMe<G>, E>

fn exit_lazy_function_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyFunctionExpression
) -> Result<Option<LazyFunctionExpression>, E>

fn enter_lazy_getter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyGetter
) -> Result<VisitMe<G>, E>

fn exit_lazy_getter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyGetter
) -> Result<Option<LazyGetter>, E>

fn enter_lazy_method(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazyMethod
) -> Result<VisitMe<G>, E>

fn exit_lazy_method(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazyMethod
) -> Result<Option<LazyMethod>, E>

fn enter_lazy_setter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LazySetter
) -> Result<VisitMe<G>, E>

fn exit_lazy_setter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LazySetter
) -> Result<Option<LazySetter>, E>

fn enter_literal_boolean_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralBooleanExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_boolean_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralBooleanExpression
) -> Result<Option<LiteralBooleanExpression>, E>

fn enter_literal_infinity_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralInfinityExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_infinity_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralInfinityExpression
) -> Result<Option<LiteralInfinityExpression>, E>

fn enter_literal_null_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralNullExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_null_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralNullExpression
) -> Result<Option<LiteralNullExpression>, E>

fn enter_literal_numeric_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralNumericExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_numeric_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralNumericExpression
) -> Result<Option<LiteralNumericExpression>, E>

fn enter_literal_property_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralPropertyName
) -> Result<VisitMe<G>, E>

fn exit_literal_property_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralPropertyName
) -> Result<Option<LiteralPropertyName>, E>

fn enter_literal_reg_exp_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralRegExpExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_reg_exp_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralRegExpExpression
) -> Result<Option<LiteralRegExpExpression>, E>

fn enter_literal_string_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralStringExpression
) -> Result<VisitMe<G>, E>

fn exit_literal_string_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut LiteralStringExpression
) -> Result<Option<LiteralStringExpression>, E>

fn enter_module(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Module
) -> Result<VisitMe<G>, E>

fn exit_module(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Module
) -> Result<Option<Module>, E>

fn enter_new_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut NewExpression
) -> Result<VisitMe<G>, E>

fn exit_new_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut NewExpression
) -> Result<Option<NewExpression>, E>

fn enter_new_target_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut NewTargetExpression
) -> Result<VisitMe<G>, E>

fn exit_new_target_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut NewTargetExpression
) -> Result<Option<NewTargetExpression>, E>

fn enter_object_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectAssignmentTarget
) -> Result<VisitMe<G>, E>

fn exit_object_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectAssignmentTarget
) -> Result<Option<ObjectAssignmentTarget>, E>

fn enter_object_binding(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectBinding
) -> Result<VisitMe<G>, E>

fn exit_object_binding(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectBinding
) -> Result<Option<ObjectBinding>, E>

fn enter_object_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectExpression
) -> Result<VisitMe<G>, E>

fn exit_object_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ObjectExpression
) -> Result<Option<ObjectExpression>, E>

fn enter_return_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ReturnStatement
) -> Result<VisitMe<G>, E>

fn exit_return_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ReturnStatement
) -> Result<Option<ReturnStatement>, E>

fn enter_script(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Script
) -> Result<VisitMe<G>, E>

fn exit_script(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Script
) -> Result<Option<Script>, E>

fn enter_setter_contents(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SetterContents
) -> Result<VisitMe<G>, E>

fn exit_setter_contents(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SetterContents
) -> Result<Option<SetterContents>, E>

fn enter_shorthand_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ShorthandProperty
) -> Result<VisitMe<G>, E>

fn exit_shorthand_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ShorthandProperty
) -> Result<Option<ShorthandProperty>, E>

fn enter_spread_element(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SpreadElement
) -> Result<VisitMe<G>, E>

fn exit_spread_element(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SpreadElement
) -> Result<Option<SpreadElement>, E>

fn enter_static_member_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut StaticMemberAssignmentTarget
) -> Result<VisitMe<G>, E>

fn exit_static_member_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut StaticMemberAssignmentTarget
) -> Result<Option<StaticMemberAssignmentTarget>, E>

fn enter_static_member_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut StaticMemberExpression
) -> Result<VisitMe<G>, E>

fn exit_static_member_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut StaticMemberExpression
) -> Result<Option<StaticMemberExpression>, E>

fn enter_super_(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut Super
) -> Result<VisitMe<G>, E>

fn exit_super_(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Super
) -> Result<Option<Super>, E>

fn enter_switch_case(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchCase
) -> Result<VisitMe<G>, E>

fn exit_switch_case(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchCase
) -> Result<Option<SwitchCase>, E>

fn enter_switch_default(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchDefault
) -> Result<VisitMe<G>, E>

fn exit_switch_default(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchDefault
) -> Result<Option<SwitchDefault>, E>

fn enter_switch_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchStatement
) -> Result<VisitMe<G>, E>

fn exit_switch_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchStatement
) -> Result<Option<SwitchStatement>, E>

fn enter_switch_statement_with_default(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchStatementWithDefault
) -> Result<VisitMe<G>, E>

fn exit_switch_statement_with_default(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut SwitchStatementWithDefault
) -> Result<Option<SwitchStatementWithDefault>, E>

fn enter_template_element(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut TemplateElement
) -> Result<VisitMe<G>, E>

fn exit_template_element(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut TemplateElement
) -> Result<Option<TemplateElement>, E>

fn enter_template_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut TemplateExpression
) -> Result<VisitMe<G>, E>

fn exit_template_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut TemplateExpression
) -> Result<Option<TemplateExpression>, E>

fn enter_this_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ThisExpression
) -> Result<VisitMe<G>, E>

fn exit_this_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ThisExpression
) -> Result<Option<ThisExpression>, E>

fn enter_throw_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ThrowStatement
) -> Result<VisitMe<G>, E>

fn exit_throw_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ThrowStatement
) -> Result<Option<ThrowStatement>, E>

fn enter_try_catch_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut TryCatchStatement
) -> Result<VisitMe<G>, E>

fn exit_try_catch_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut TryCatchStatement
) -> Result<Option<TryCatchStatement>, E>

fn enter_try_finally_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut TryFinallyStatement
) -> Result<VisitMe<G>, E>

fn exit_try_finally_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut TryFinallyStatement
) -> Result<Option<TryFinallyStatement>, E>

fn enter_unary_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut UnaryExpression
) -> Result<VisitMe<G>, E>

fn exit_unary_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut UnaryExpression
) -> Result<Option<UnaryExpression>, E>

fn enter_update_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut UpdateExpression
) -> Result<VisitMe<G>, E>

fn exit_update_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut UpdateExpression
) -> Result<Option<UpdateExpression>, E>

fn enter_variable_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut VariableDeclaration
) -> Result<VisitMe<G>, E>

fn exit_variable_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut VariableDeclaration
) -> Result<Option<VariableDeclaration>, E>

fn enter_variable_declarator(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut VariableDeclarator
) -> Result<VisitMe<G>, E>

fn exit_variable_declarator(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut VariableDeclarator
) -> Result<Option<VariableDeclarator>, E>

fn enter_while_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut WhileStatement
) -> Result<VisitMe<G>, E>

fn exit_while_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut WhileStatement
) -> Result<Option<WhileStatement>, E>

fn enter_with_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut WithStatement
) -> Result<VisitMe<G>, E>

fn exit_with_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut WithStatement
) -> Result<Option<WithStatement>, E>

fn enter_yield_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut YieldExpression
) -> Result<VisitMe<G>, E>

fn exit_yield_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut YieldExpression
) -> Result<Option<YieldExpression>, E>

fn enter_yield_star_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut YieldStarExpression
) -> Result<VisitMe<G>, E>

fn exit_yield_star_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut YieldStarExpression
) -> Result<Option<YieldStarExpression>, E>

fn enter_arrow_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutArrowExpression<'a>
) -> Result<VisitMe<G>, E>

fn exit_arrow_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutArrowExpression<'a>
) -> Result<Option<ArrowExpression>, E>

fn enter_asserted_maybe_positional_parameter_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssertedMaybePositionalParameterName<'a>
) -> Result<VisitMe<G>, E>

fn exit_asserted_maybe_positional_parameter_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssertedMaybePositionalParameterName<'a>
) -> Result<Option<AssertedMaybePositionalParameterName>, E>

fn enter_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTarget<'a>
) -> Result<VisitMe<G>, E>

fn exit_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTarget<'a>
) -> Result<Option<AssignmentTarget>, E>

fn enter_assignment_target_or_assignment_target_with_initializer(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a>
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_or_assignment_target_with_initializer(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a>
) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, E>

fn enter_assignment_target_or_for_in_of_binding(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetOrForInOfBinding<'a>
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_or_for_in_of_binding(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetOrForInOfBinding<'a>
) -> Result<Option<AssignmentTargetOrForInOfBinding>, E>

fn enter_assignment_target_pattern(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetPattern<'a>
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_pattern(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetPattern<'a>
) -> Result<Option<AssignmentTargetPattern>, E>

fn enter_assignment_target_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetProperty<'a>
) -> Result<VisitMe<G>, E>

fn exit_assignment_target_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutAssignmentTargetProperty<'a>
) -> Result<Option<AssignmentTargetProperty>, E>

fn enter_binding(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBinding<'a>
) -> Result<VisitMe<G>, E>

fn exit_binding(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBinding<'a>
) -> Result<Option<Binding>, E>

fn enter_binding_or_binding_with_initializer(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingOrBindingWithInitializer<'a>
) -> Result<VisitMe<G>, E>

fn exit_binding_or_binding_with_initializer(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingOrBindingWithInitializer<'a>
) -> Result<Option<BindingOrBindingWithInitializer>, E>

fn enter_binding_pattern(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingPattern<'a>
) -> Result<VisitMe<G>, E>

fn exit_binding_pattern(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingPattern<'a>
) -> Result<Option<BindingPattern>, E>

fn enter_binding_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingProperty<'a>
) -> Result<VisitMe<G>, E>

fn exit_binding_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutBindingProperty<'a>
) -> Result<Option<BindingProperty>, E>

fn enter_class_declaration_or_expression_or_function_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_class_declaration_or_expression_or_function_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a>
) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, E>

fn enter_class_declaration_or_function_declaration_or_variable_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_class_declaration_or_function_declaration_or_variable_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a>
) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, E>

fn enter_export_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExportDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_export_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExportDeclaration<'a>
) -> Result<Option<ExportDeclaration>, E>

fn enter_export_declaration_or_import_declaration_or_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExportDeclarationOrImportDeclarationOrStatement<'a>
) -> Result<VisitMe<G>, E>

fn exit_export_declaration_or_import_declaration_or_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExportDeclarationOrImportDeclarationOrStatement<'a>
) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, E>

fn enter_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpression<'a>
) -> Result<VisitMe<G>, E>

fn exit_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpression<'a>
) -> Result<Option<Expression>, E>

fn enter_expression_or_spread_element(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrSpreadElement<'a>
) -> Result<VisitMe<G>, E>

fn exit_expression_or_spread_element(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrSpreadElement<'a>
) -> Result<Option<ExpressionOrSpreadElement>, E>

fn enter_expression_or_super(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrSuper<'a>
) -> Result<VisitMe<G>, E>

fn exit_expression_or_super(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrSuper<'a>
) -> Result<Option<ExpressionOrSuper>, E>

fn enter_expression_or_template_element(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrTemplateElement<'a>
) -> Result<VisitMe<G>, E>

fn exit_expression_or_template_element(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrTemplateElement<'a>
) -> Result<Option<ExpressionOrTemplateElement>, E>

fn enter_expression_or_variable_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrVariableDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_expression_or_variable_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutExpressionOrVariableDeclaration<'a>
) -> Result<Option<ExpressionOrVariableDeclaration>, E>

fn enter_function_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutFunctionDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_function_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutFunctionDeclaration<'a>
) -> Result<Option<FunctionDeclaration>, E>

fn enter_function_expression(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutFunctionExpression<'a>
) -> Result<VisitMe<G>, E>

fn exit_function_expression(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutFunctionExpression<'a>
) -> Result<Option<FunctionExpression>, E>

fn enter_getter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutGetter<'a>
) -> Result<VisitMe<G>, E>

fn exit_getter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutGetter<'a>
) -> Result<Option<Getter>, E>

fn enter_import_declaration(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutImportDeclaration<'a>
) -> Result<VisitMe<G>, E>

fn exit_import_declaration(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutImportDeclaration<'a>
) -> Result<Option<ImportDeclaration>, E>

fn enter_iteration_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutIterationStatement<'a>
) -> Result<VisitMe<G>, E>

fn exit_iteration_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutIterationStatement<'a>
) -> Result<Option<IterationStatement>, E>

fn enter_literal(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutLiteral<'a>
) -> Result<VisitMe<G>, E>

fn exit_literal(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutLiteral<'a>
) -> Result<Option<Literal>, E>

fn enter_method(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutMethod<'a>
) -> Result<VisitMe<G>, E>

fn exit_method(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutMethod<'a>
) -> Result<Option<Method>, E>

fn enter_method_definition(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutMethodDefinition<'a>
) -> Result<VisitMe<G>, E>

fn exit_method_definition(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutMethodDefinition<'a>
) -> Result<Option<MethodDefinition>, E>

fn enter_object_property(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutObjectProperty<'a>
) -> Result<VisitMe<G>, E>

fn exit_object_property(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutObjectProperty<'a>
) -> Result<Option<ObjectProperty>, E>

fn enter_parameter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutParameter<'a>
) -> Result<VisitMe<G>, E>

fn exit_parameter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutParameter<'a>
) -> Result<Option<Parameter>, E>

fn enter_program(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutProgram<'a>
) -> Result<VisitMe<G>, E>

fn exit_program(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutProgram<'a>
) -> Result<Option<Program>, E>

fn enter_property_name(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutPropertyName<'a>
) -> Result<VisitMe<G>, E>

fn exit_property_name(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutPropertyName<'a>
) -> Result<Option<PropertyName>, E>

fn enter_setter(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutSetter<'a>
) -> Result<VisitMe<G>, E>

fn exit_setter(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutSetter<'a>
) -> Result<Option<Setter>, E>

fn enter_simple_assignment_target(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutSimpleAssignmentTarget<'a>
) -> Result<VisitMe<G>, E>

fn exit_simple_assignment_target(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutSimpleAssignmentTarget<'a>
) -> Result<Option<SimpleAssignmentTarget>, E>

fn enter_statement(
    &mut self,
    path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutStatement<'a>
) -> Result<VisitMe<G>, E>

fn exit_statement(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut ViewMutStatement<'a>
) -> Result<Option<Statement>, E>

fn visit_offset(
    &mut self,
    _path: &Path<ASTNode, ASTField>,
    _node: &mut Offset
) -> Result<(), E>

Loading content...

Implementors

Loading content...