Trait VisitAstPath

Source

pub trait VisitAstPath {
Show 299 methods    // Provided methods
    fn visit_accessibility<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Accessibility,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_array_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ArrayLit,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_array_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ArrayPat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_arrow_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ArrowExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_arrow_function_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ArrowFunctionBody,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_op<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignOp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignPat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_pat_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignPatProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_target<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignTarget,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_assign_target_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AssignTargetPat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_atom<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Atom,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_auto_accessor<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AutoAccessor,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_await_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast AwaitExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_big_int<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BigInt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_big_int_value<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BigIntValue,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_bin_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BinExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_binary_op<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BinaryOp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_binding_ident<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BindingIdent,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_block_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BlockStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_bool<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Bool,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_break_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast BreakStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_call_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast CallExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_callee<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Callee,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_catch_clause<'ast: 'r, 'r>(
        &mut self,
        node: &'ast CatchClause,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Class,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ClassDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ClassExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_member<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ClassMember,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_members<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ClassMember],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_method<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ClassMethod,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_class_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ClassProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_computed_prop_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ComputedPropName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_cond_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast CondExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_constructor<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Constructor,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_continue_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ContinueStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_debugger_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast DebuggerStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Decl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_decorator<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Decorator,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_decorators<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Decorator],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_default_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast DefaultDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_do_while_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast DoWhileStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_empty_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast EmptyStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_all<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportAll,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_default_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportDefaultDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_default_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportDefaultExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_default_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportDefaultSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_named_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportNamedSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportNamespaceSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExportSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_export_specifiers<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ExportSpecifier],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Expr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_expr_or_spread<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExprOrSpread,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_expr_or_spreads<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ExprOrSpread],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_expr_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ExprStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_exprs<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Box<Expr>],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_fn_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast FnDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_fn_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast FnExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_for_head<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ForHead,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_for_in_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ForInStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_for_of_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ForOfStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_for_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ForStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_function<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Function,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_function_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast FunctionBody,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_getter_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast GetterProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ident<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Ident,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ident_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast IdentName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_if_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast IfStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Import,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_default_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportDefaultSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_named_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportNamedSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_phase<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportPhase,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_specifiers<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ImportSpecifier],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportStarAsSpecifier,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_with<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportWith,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_with_item<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ImportWithItem,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_import_with_items<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ImportWithItem],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_invalid<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Invalid,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_attr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXAttr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_attr_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXAttrName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXAttrOrSpread,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [JSXAttrOrSpread],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_attr_value<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXAttrValue,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_closing_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXClosingElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXClosingFragment,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_element_child<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXElementChild,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_element_childs<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [JSXElementChild],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_element_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXElementName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXEmptyExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_expr_container<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXExprContainer,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_fragment<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXFragment,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_member_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXMemberExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXNamespacedName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_object<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXObject,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_opening_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXOpeningElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXOpeningFragment,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_spread_child<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXSpreadChild,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_jsx_text<'ast: 'r, 'r>(
        &mut self,
        node: &'ast JSXText,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_key<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Key,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast KeyValuePatProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_key_value_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast KeyValueProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_labeled_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast LabeledStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Lit,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_member_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MemberExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_member_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MemberProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_meta_prop_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MetaPropExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_meta_prop_kind<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MetaPropKind,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_method_kind<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MethodKind,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_method_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast MethodProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_module<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Module,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_module_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ModuleDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_module_export_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ModuleExportName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_module_item<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ModuleItem,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_module_items<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ModuleItem],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_named_export<'ast: 'r, 'r>(
        &mut self,
        node: &'ast NamedExport,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_new_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast NewExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_null<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Null,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_number<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Number,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_object_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ObjectLit,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_object_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ObjectPat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_object_pat_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ObjectPatProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_object_pat_props<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ObjectPatProp],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_accessibility<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Accessibility>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_atom<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Atom>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_block_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<BlockStmt>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_call<'ast: 'r, 'r>(
        &mut self,
        node: &'ast OptCall,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_catch_clause<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<CatchClause>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_chain_base<'ast: 'r, 'r>(
        &mut self,
        node: &'ast OptChainBase,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_chain_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast OptChainExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<Expr>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<ExprOrSpread>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Vec<ExprOrSpread>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_function_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<FunctionBody>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ident<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Ident>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<JSXAttrValue>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<JSXClosingElement>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_module_export_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<ModuleExportName>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_object_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<ObjectLit>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Pat>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_span<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Span>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<Stmt>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_str<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<Str>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<TruePlusMinus>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<TsEntityName>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_import_call_options<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<TsImportCallOptions>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<TsNamespaceBody>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_this_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<TsThisParam>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<TsType>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<TsTypeAnn>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<TsTypeParamDecl>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Box<TsTypeParamInstantiation>>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<VarDeclOrExpr>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Option<ExprOrSpread>],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_vec_pats<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Option<Pat>],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_opt_wtf_8_atom<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Option<Wtf8Atom>,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Param,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ParamOrTsParamProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [ParamOrTsParamProp],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_params<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Param],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_paren_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ParenExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Pat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_pats<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Pat],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_private_method<'ast: 'r, 'r>(
        &mut self,
        node: &'ast PrivateMethod,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_private_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast PrivateName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_private_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast PrivateProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_program<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Program,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Prop,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_prop_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast PropName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_prop_or_spread<'ast: 'r, 'r>(
        &mut self,
        node: &'ast PropOrSpread,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_prop_or_spreads<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [PropOrSpread],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_regex<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Regex,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_rest_pat<'ast: 'r, 'r>(
        &mut self,
        node: &'ast RestPat,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_return_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ReturnStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_script<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Script,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_seq_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SeqExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_setter_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SetterProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_simple_assign_target<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SimpleAssignTarget,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_span<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Span,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_spread_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SpreadElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_static_block<'ast: 'r, 'r>(
        &mut self,
        node: &'ast StaticBlock,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Stmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_stmts<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Stmt],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_str<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Str,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_super<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Super,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_super_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SuperProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_super_prop_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SuperPropExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_switch_case<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SwitchCase,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_switch_cases<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [SwitchCase],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_switch_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SwitchStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_syntax_context<'ast: 'r, 'r>(
        &mut self,
        node: &'ast SyntaxContext,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_tagged_tpl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TaggedTpl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_this_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ThisExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_throw_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast ThrowStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_tpl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Tpl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_tpl_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TplElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_tpl_elements<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TplElement],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_true_plus_minus<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TruePlusMinus,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_try_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TryStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_array_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsArrayType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_as_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsAsExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsCallSignatureDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_conditional_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsConditionalType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_const_assertion<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsConstAssertion,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsConstructSignatureDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_constructor_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsConstructorType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_entity_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsEntityName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_enum_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsEnumDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_enum_member<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsEnumMember,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsEnumMemberId,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_enum_members<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsEnumMember],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_export_assignment<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsExportAssignment,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsExprWithTypeArgs,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsExprWithTypeArgs],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsExternalModuleRef,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsFnOrConstructorType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_fn_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsFnParam,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_fn_params<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsFnParam],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_fn_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsFnType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_getter_signature<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsGetterSignature,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_import_call_options<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsImportCallOptions,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsImportEqualsDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_import_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsImportType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_index_signature<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsIndexSignature,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsIndexedAccessType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_infer_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsInferType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_instantiation<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsInstantiation,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_interface_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsInterfaceBody,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_interface_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsInterfaceDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_intersection_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsIntersectionType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_keyword_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsKeywordType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsKeywordTypeKind,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsLit,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_lit_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsLitType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_mapped_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsMappedType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_method_signature<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsMethodSignature,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_module_block<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsModuleBlock,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_module_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsModuleDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_module_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsModuleName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_module_ref<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsModuleRef,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_namespace_body<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsNamespaceBody,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsNamespaceDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsNamespaceExportDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsNonNullExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_optional_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsOptionalType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_param_prop<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsParamProp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsParamPropParam,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsParenthesizedType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_property_signature<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsPropertySignature,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_qualified_name<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsQualifiedName,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_rest_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsRestType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsSatisfiesExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_setter_signature<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsSetterSignature,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_this_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsThisParam,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_this_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsThisType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsThisTypeOrIdent,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTplLitType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_tuple_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTupleElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsTupleElement],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_tuple_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTupleType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeAliasDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_ann<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeAnn,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_assertion<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeAssertion,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_element<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeElement,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_elements<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsTypeElement],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_lit<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeLit,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_operator<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeOperator,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeOperatorOp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_param<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeParam,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeParamDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeParamInstantiation,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_params<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [TsTypeParam],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_predicate<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypePredicate,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_query<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeQuery,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeQueryExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_type_ref<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsTypeRef,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_types<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [Box<TsType>],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsUnionOrIntersectionType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_ts_union_type<'ast: 'r, 'r>(
        &mut self,
        node: &'ast TsUnionType,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_unary_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast UnaryExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_unary_op<'ast: 'r, 'r>(
        &mut self,
        node: &'ast UnaryOp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_update_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast UpdateExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_update_op<'ast: 'r, 'r>(
        &mut self,
        node: &'ast UpdateOp,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_using_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast UsingDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_var_decl<'ast: 'r, 'r>(
        &mut self,
        node: &'ast VarDecl,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_var_decl_kind<'ast: 'r, 'r>(
        &mut self,
        node: &'ast VarDeclKind,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast VarDeclOrExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_var_declarator<'ast: 'r, 'r>(
        &mut self,
        node: &'ast VarDeclarator,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_var_declarators<'ast: 'r, 'r>(
        &mut self,
        node: &'ast [VarDeclarator],
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_while_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast WhileStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_with_stmt<'ast: 'r, 'r>(
        &mut self,
        node: &'ast WithStmt,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_wtf_8_atom<'ast: 'r, 'r>(
        &mut self,
        node: &'ast Wtf8Atom,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
    fn visit_yield_expr<'ast: 'r, 'r>(
        &mut self,
        node: &'ast YieldExpr,
        __ast_path: &mut AstNodePath<'r>,
    ) { ... }
}

Expand description

A visitor trait for traversing the AST.

Provided Methods§

Source

fn visit_accessibility<'ast: 'r, 'r>( &mut self, node: &'ast Accessibility, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Accessibility.

By default, this method calls Accessibility::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_array_lit<'ast: 'r, 'r>( &mut self, node: &'ast ArrayLit, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ArrayLit.

By default, this method calls ArrayLit::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_array_pat<'ast: 'r, 'r>( &mut self, node: &'ast ArrayPat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ArrayPat.

By default, this method calls ArrayPat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_arrow_expr<'ast: 'r, 'r>( &mut self, node: &'ast ArrowExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ArrowExpr.

By default, this method calls ArrowExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_arrow_function_body<'ast: 'r, 'r>( &mut self, node: &'ast ArrowFunctionBody, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ArrowFunctionBody.

By default, this method calls ArrowFunctionBody::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_expr<'ast: 'r, 'r>( &mut self, node: &'ast AssignExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignExpr.

By default, this method calls AssignExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_op<'ast: 'r, 'r>( &mut self, node: &'ast AssignOp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignOp.

By default, this method calls AssignOp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_pat<'ast: 'r, 'r>( &mut self, node: &'ast AssignPat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignPat.

By default, this method calls AssignPat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_pat_prop<'ast: 'r, 'r>( &mut self, node: &'ast AssignPatProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignPatProp.

By default, this method calls AssignPatProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_prop<'ast: 'r, 'r>( &mut self, node: &'ast AssignProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignProp.

By default, this method calls AssignProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_target<'ast: 'r, 'r>( &mut self, node: &'ast AssignTarget, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignTarget.

By default, this method calls AssignTarget::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_assign_target_pat<'ast: 'r, 'r>( &mut self, node: &'ast AssignTargetPat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AssignTargetPat.

By default, this method calls AssignTargetPat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_atom<'ast: 'r, 'r>( &mut self, node: &'ast Atom, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type swc_atoms :: Atom.

By default, this method calls [swc_atoms :: Atom::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_auto_accessor<'ast: 'r, 'r>( &mut self, node: &'ast AutoAccessor, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AutoAccessor.

By default, this method calls AutoAccessor::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_await_expr<'ast: 'r, 'r>( &mut self, node: &'ast AwaitExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type AwaitExpr.

By default, this method calls AwaitExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_big_int<'ast: 'r, 'r>( &mut self, node: &'ast BigInt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BigInt.

By default, this method calls BigInt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_big_int_value<'ast: 'r, 'r>( &mut self, node: &'ast BigIntValue, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BigIntValue.

By default, this method calls BigIntValue::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_bin_expr<'ast: 'r, 'r>( &mut self, node: &'ast BinExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BinExpr.

By default, this method calls BinExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_binary_op<'ast: 'r, 'r>( &mut self, node: &'ast BinaryOp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BinaryOp.

By default, this method calls BinaryOp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_binding_ident<'ast: 'r, 'r>( &mut self, node: &'ast BindingIdent, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BindingIdent.

By default, this method calls BindingIdent::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_block_stmt<'ast: 'r, 'r>( &mut self, node: &'ast BlockStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BlockStmt.

By default, this method calls BlockStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_bool<'ast: 'r, 'r>( &mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Bool.

By default, this method calls Bool::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_break_stmt<'ast: 'r, 'r>( &mut self, node: &'ast BreakStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type BreakStmt.

By default, this method calls BreakStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_call_expr<'ast: 'r, 'r>( &mut self, node: &'ast CallExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type CallExpr.

By default, this method calls CallExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_callee<'ast: 'r, 'r>( &mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Callee.

By default, this method calls Callee::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_catch_clause<'ast: 'r, 'r>( &mut self, node: &'ast CatchClause, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type CatchClause.

By default, this method calls CatchClause::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class<'ast: 'r, 'r>( &mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Class.

By default, this method calls Class::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class_decl<'ast: 'r, 'r>( &mut self, node: &'ast ClassDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ClassDecl.

By default, this method calls ClassDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class_expr<'ast: 'r, 'r>( &mut self, node: &'ast ClassExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ClassExpr.

By default, this method calls ClassExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class_member<'ast: 'r, 'r>( &mut self, node: &'ast ClassMember, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ClassMember.

By default, this method calls ClassMember::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class_members<'ast: 'r, 'r>( &mut self, node: &'ast [ClassMember], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ClassMember >.

By default, this method calls [Vec < ClassMember >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_class_method<'ast: 'r, 'r>( &mut self, node: &'ast ClassMethod, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ClassMethod.

By default, this method calls ClassMethod::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_class_prop<'ast: 'r, 'r>( &mut self, node: &'ast ClassProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ClassProp.

By default, this method calls ClassProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_computed_prop_name<'ast: 'r, 'r>( &mut self, node: &'ast ComputedPropName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ComputedPropName.

By default, this method calls ComputedPropName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_cond_expr<'ast: 'r, 'r>( &mut self, node: &'ast CondExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type CondExpr.

By default, this method calls CondExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_constructor<'ast: 'r, 'r>( &mut self, node: &'ast Constructor, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Constructor.

By default, this method calls Constructor::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_continue_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ContinueStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ContinueStmt.

By default, this method calls ContinueStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_debugger_stmt<'ast: 'r, 'r>( &mut self, node: &'ast DebuggerStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type DebuggerStmt.

By default, this method calls DebuggerStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_decl<'ast: 'r, 'r>( &mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Decl.

By default, this method calls Decl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_decorator<'ast: 'r, 'r>( &mut self, node: &'ast Decorator, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Decorator.

By default, this method calls Decorator::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_decorators<'ast: 'r, 'r>( &mut self, node: &'ast [Decorator], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Decorator >.

By default, this method calls [Vec < Decorator >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_default_decl<'ast: 'r, 'r>( &mut self, node: &'ast DefaultDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type DefaultDecl.

By default, this method calls DefaultDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_do_while_stmt<'ast: 'r, 'r>( &mut self, node: &'ast DoWhileStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type DoWhileStmt.

By default, this method calls DoWhileStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_empty_stmt<'ast: 'r, 'r>( &mut self, node: &'ast EmptyStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type EmptyStmt.

By default, this method calls EmptyStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_all<'ast: 'r, 'r>( &mut self, node: &'ast ExportAll, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportAll.

By default, this method calls ExportAll::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_decl<'ast: 'r, 'r>( &mut self, node: &'ast ExportDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportDecl.

By default, this method calls ExportDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_default_decl<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportDefaultDecl.

By default, this method calls ExportDefaultDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_default_expr<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportDefaultExpr.

By default, this method calls ExportDefaultExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_default_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportDefaultSpecifier.

By default, this method calls ExportDefaultSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_named_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportNamedSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportNamedSpecifier.

By default, this method calls ExportNamedSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_namespace_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportNamespaceSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportNamespaceSpecifier.

By default, this method calls ExportNamespaceSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExportSpecifier.

By default, this method calls ExportSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_export_specifiers<'ast: 'r, 'r>( &mut self, node: &'ast [ExportSpecifier], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ExportSpecifier >.

By default, this method calls [Vec < ExportSpecifier >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_expr<'ast: 'r, 'r>( &mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Expr.

By default, this method calls Expr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_expr_or_spread<'ast: 'r, 'r>( &mut self, node: &'ast ExprOrSpread, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExprOrSpread.

By default, this method calls ExprOrSpread::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_expr_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast [ExprOrSpread], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ExprOrSpread >.

By default, this method calls [Vec < ExprOrSpread >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_expr_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ExprStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ExprStmt.

By default, this method calls ExprStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_exprs<'ast: 'r, 'r>( &mut self, node: &'ast [Box<Expr>], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Box < Expr > >.

By default, this method calls [Vec < Box < Expr > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_fn_decl<'ast: 'r, 'r>( &mut self, node: &'ast FnDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type FnDecl.

By default, this method calls FnDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_fn_expr<'ast: 'r, 'r>( &mut self, node: &'ast FnExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type FnExpr.

By default, this method calls FnExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_for_head<'ast: 'r, 'r>( &mut self, node: &'ast ForHead, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ForHead.

By default, this method calls ForHead::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_for_in_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForInStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ForInStmt.

By default, this method calls ForInStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_for_of_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForOfStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ForOfStmt.

By default, this method calls ForOfStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_for_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ForStmt.

By default, this method calls ForStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_function<'ast: 'r, 'r>( &mut self, node: &'ast Function, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Function.

By default, this method calls Function::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_function_body<'ast: 'r, 'r>( &mut self, node: &'ast FunctionBody, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type FunctionBody.

By default, this method calls FunctionBody::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_getter_prop<'ast: 'r, 'r>( &mut self, node: &'ast GetterProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type GetterProp.

By default, this method calls GetterProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ident<'ast: 'r, 'r>( &mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Ident.

By default, this method calls Ident::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ident_name<'ast: 'r, 'r>( &mut self, node: &'ast IdentName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type IdentName.

By default, this method calls IdentName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_if_stmt<'ast: 'r, 'r>( &mut self, node: &'ast IfStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type IfStmt.

By default, this method calls IfStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import<'ast: 'r, 'r>( &mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Import.

By default, this method calls Import::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_decl<'ast: 'r, 'r>( &mut self, node: &'ast ImportDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportDecl.

By default, this method calls ImportDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_default_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportDefaultSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportDefaultSpecifier.

By default, this method calls ImportDefaultSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_named_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportNamedSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportNamedSpecifier.

By default, this method calls ImportNamedSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_phase<'ast: 'r, 'r>( &mut self, node: &'ast ImportPhase, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportPhase.

By default, this method calls ImportPhase::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportSpecifier.

By default, this method calls ImportSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_specifiers<'ast: 'r, 'r>( &mut self, node: &'ast [ImportSpecifier], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ImportSpecifier >.

By default, this method calls [Vec < ImportSpecifier >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_import_star_as_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportStarAsSpecifier, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportStarAsSpecifier.

By default, this method calls ImportStarAsSpecifier::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_with<'ast: 'r, 'r>( &mut self, node: &'ast ImportWith, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportWith.

By default, this method calls ImportWith::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_with_item<'ast: 'r, 'r>( &mut self, node: &'ast ImportWithItem, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ImportWithItem.

By default, this method calls ImportWithItem::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_import_with_items<'ast: 'r, 'r>( &mut self, node: &'ast [ImportWithItem], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ImportWithItem >.

By default, this method calls [Vec < ImportWithItem >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_invalid<'ast: 'r, 'r>( &mut self, node: &'ast Invalid, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Invalid.

By default, this method calls Invalid::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_attr<'ast: 'r, 'r>( &mut self, node: &'ast JSXAttr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXAttr.

By default, this method calls JSXAttr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_attr_name<'ast: 'r, 'r>( &mut self, node: &'ast JSXAttrName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXAttrName.

By default, this method calls JSXAttrName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_attr_or_spread<'ast: 'r, 'r>( &mut self, node: &'ast JSXAttrOrSpread, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXAttrOrSpread.

By default, this method calls JSXAttrOrSpread::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast [JSXAttrOrSpread], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < JSXAttrOrSpread >.

By default, this method calls [Vec < JSXAttrOrSpread >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_attr_value<'ast: 'r, 'r>( &mut self, node: &'ast JSXAttrValue, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXAttrValue.

By default, this method calls JSXAttrValue::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_closing_element<'ast: 'r, 'r>( &mut self, node: &'ast JSXClosingElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXClosingElement.

By default, this method calls JSXClosingElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_closing_fragment<'ast: 'r, 'r>( &mut self, node: &'ast JSXClosingFragment, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXClosingFragment.

By default, this method calls JSXClosingFragment::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_element<'ast: 'r, 'r>( &mut self, node: &'ast JSXElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXElement.

By default, this method calls JSXElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_element_child<'ast: 'r, 'r>( &mut self, node: &'ast JSXElementChild, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXElementChild.

By default, this method calls JSXElementChild::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_element_childs<'ast: 'r, 'r>( &mut self, node: &'ast [JSXElementChild], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < JSXElementChild >.

By default, this method calls [Vec < JSXElementChild >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_element_name<'ast: 'r, 'r>( &mut self, node: &'ast JSXElementName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXElementName.

By default, this method calls JSXElementName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_empty_expr<'ast: 'r, 'r>( &mut self, node: &'ast JSXEmptyExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXEmptyExpr.

By default, this method calls JSXEmptyExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_expr<'ast: 'r, 'r>( &mut self, node: &'ast JSXExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXExpr.

By default, this method calls JSXExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_expr_container<'ast: 'r, 'r>( &mut self, node: &'ast JSXExprContainer, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXExprContainer.

By default, this method calls JSXExprContainer::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_fragment<'ast: 'r, 'r>( &mut self, node: &'ast JSXFragment, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXFragment.

By default, this method calls JSXFragment::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_member_expr<'ast: 'r, 'r>( &mut self, node: &'ast JSXMemberExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXMemberExpr.

By default, this method calls JSXMemberExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_namespaced_name<'ast: 'r, 'r>( &mut self, node: &'ast JSXNamespacedName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXNamespacedName.

By default, this method calls JSXNamespacedName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_object<'ast: 'r, 'r>( &mut self, node: &'ast JSXObject, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXObject.

By default, this method calls JSXObject::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_opening_element<'ast: 'r, 'r>( &mut self, node: &'ast JSXOpeningElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXOpeningElement.

By default, this method calls JSXOpeningElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_opening_fragment<'ast: 'r, 'r>( &mut self, node: &'ast JSXOpeningFragment, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXOpeningFragment.

By default, this method calls JSXOpeningFragment::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_spread_child<'ast: 'r, 'r>( &mut self, node: &'ast JSXSpreadChild, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXSpreadChild.

By default, this method calls JSXSpreadChild::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_jsx_text<'ast: 'r, 'r>( &mut self, node: &'ast JSXText, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type JSXText.

By default, this method calls JSXText::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_key<'ast: 'r, 'r>( &mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Key.

By default, this method calls Key::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_key_value_pat_prop<'ast: 'r, 'r>( &mut self, node: &'ast KeyValuePatProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type KeyValuePatProp.

By default, this method calls KeyValuePatProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_key_value_prop<'ast: 'r, 'r>( &mut self, node: &'ast KeyValueProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type KeyValueProp.

By default, this method calls KeyValueProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_labeled_stmt<'ast: 'r, 'r>( &mut self, node: &'ast LabeledStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type LabeledStmt.

By default, this method calls LabeledStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_lit<'ast: 'r, 'r>( &mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Lit.

By default, this method calls Lit::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_member_expr<'ast: 'r, 'r>( &mut self, node: &'ast MemberExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MemberExpr.

By default, this method calls MemberExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_member_prop<'ast: 'r, 'r>( &mut self, node: &'ast MemberProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MemberProp.

By default, this method calls MemberProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_meta_prop_expr<'ast: 'r, 'r>( &mut self, node: &'ast MetaPropExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MetaPropExpr.

By default, this method calls MetaPropExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_meta_prop_kind<'ast: 'r, 'r>( &mut self, node: &'ast MetaPropKind, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MetaPropKind.

By default, this method calls MetaPropKind::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_method_kind<'ast: 'r, 'r>( &mut self, node: &'ast MethodKind, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MethodKind.

By default, this method calls MethodKind::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_method_prop<'ast: 'r, 'r>( &mut self, node: &'ast MethodProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type MethodProp.

By default, this method calls MethodProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_module<'ast: 'r, 'r>( &mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Module.

By default, this method calls Module::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_module_decl<'ast: 'r, 'r>( &mut self, node: &'ast ModuleDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ModuleDecl.

By default, this method calls ModuleDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_module_export_name<'ast: 'r, 'r>( &mut self, node: &'ast ModuleExportName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ModuleExportName.

By default, this method calls ModuleExportName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_module_item<'ast: 'r, 'r>( &mut self, node: &'ast ModuleItem, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ModuleItem.

By default, this method calls ModuleItem::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_module_items<'ast: 'r, 'r>( &mut self, node: &'ast [ModuleItem], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ModuleItem >.

By default, this method calls [Vec < ModuleItem >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_named_export<'ast: 'r, 'r>( &mut self, node: &'ast NamedExport, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type NamedExport.

By default, this method calls NamedExport::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_new_expr<'ast: 'r, 'r>( &mut self, node: &'ast NewExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type NewExpr.

By default, this method calls NewExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_null<'ast: 'r, 'r>( &mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Null.

By default, this method calls Null::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_number<'ast: 'r, 'r>( &mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Number.

By default, this method calls Number::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_object_lit<'ast: 'r, 'r>( &mut self, node: &'ast ObjectLit, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ObjectLit.

By default, this method calls ObjectLit::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_object_pat<'ast: 'r, 'r>( &mut self, node: &'ast ObjectPat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ObjectPat.

By default, this method calls ObjectPat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_object_pat_prop<'ast: 'r, 'r>( &mut self, node: &'ast ObjectPatProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ObjectPatProp.

By default, this method calls ObjectPatProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_object_pat_props<'ast: 'r, 'r>( &mut self, node: &'ast [ObjectPatProp], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ObjectPatProp >.

By default, this method calls [Vec < ObjectPatProp >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_accessibility<'ast: 'r, 'r>( &mut self, node: &'ast Option<Accessibility>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Accessibility >.

By default, this method calls [Option < Accessibility >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_atom<'ast: 'r, 'r>( &mut self, node: &'ast Option<Atom>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < swc_atoms :: Atom >.

By default, this method calls [Option < swc_atoms :: Atom >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_block_stmt<'ast: 'r, 'r>( &mut self, node: &'ast Option<BlockStmt>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < BlockStmt >.

By default, this method calls [Option < BlockStmt >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_call<'ast: 'r, 'r>( &mut self, node: &'ast OptCall, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type OptCall.

By default, this method calls OptCall::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_opt_catch_clause<'ast: 'r, 'r>( &mut self, node: &'ast Option<CatchClause>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < CatchClause >.

By default, this method calls [Option < CatchClause >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_chain_base<'ast: 'r, 'r>( &mut self, node: &'ast OptChainBase, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type OptChainBase.

By default, this method calls OptChainBase::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_opt_chain_expr<'ast: 'r, 'r>( &mut self, node: &'ast OptChainExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type OptChainExpr.

By default, this method calls OptChainExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_opt_expr<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<Expr>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < Expr > >.

By default, this method calls [Option < Box < Expr > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_expr_or_spread<'ast: 'r, 'r>( &mut self, node: &'ast Option<ExprOrSpread>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < ExprOrSpread >.

By default, this method calls [Option < ExprOrSpread >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_expr_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast Option<Vec<ExprOrSpread>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Vec < ExprOrSpread > >.

By default, this method calls [Option < Vec < ExprOrSpread > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_function_body<'ast: 'r, 'r>( &mut self, node: &'ast Option<FunctionBody>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < FunctionBody >.

By default, this method calls [Option < FunctionBody >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ident<'ast: 'r, 'r>( &mut self, node: &'ast Option<Ident>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Ident >.

By default, this method calls [Option < Ident >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_jsx_attr_value<'ast: 'r, 'r>( &mut self, node: &'ast Option<JSXAttrValue>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < JSXAttrValue >.

By default, this method calls [Option < JSXAttrValue >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_jsx_closing_element<'ast: 'r, 'r>( &mut self, node: &'ast Option<JSXClosingElement>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < JSXClosingElement >.

By default, this method calls [Option < JSXClosingElement >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_module_export_name<'ast: 'r, 'r>( &mut self, node: &'ast Option<ModuleExportName>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < ModuleExportName >.

By default, this method calls [Option < ModuleExportName >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_object_lit<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<ObjectLit>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < ObjectLit > >.

By default, this method calls [Option < Box < ObjectLit > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_pat<'ast: 'r, 'r>( &mut self, node: &'ast Option<Pat>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Pat >.

By default, this method calls [Option < Pat >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_span<'ast: 'r, 'r>( &mut self, node: &'ast Option, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < swc_common :: Span >.

By default, this method calls [Option < swc_common :: Span >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_stmt<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<Stmt>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < Stmt > >.

By default, this method calls [Option < Box < Stmt > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_str<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<Str>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < Str > >.

By default, this method calls [Option < Box < Str > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_true_plus_minus<'ast: 'r, 'r>( &mut self, node: &'ast Option<TruePlusMinus>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < TruePlusMinus >.

By default, this method calls [Option < TruePlusMinus >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_entity_name<'ast: 'r, 'r>( &mut self, node: &'ast Option<TsEntityName>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < TsEntityName >.

By default, this method calls [Option < TsEntityName >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_import_call_options<'ast: 'r, 'r>( &mut self, node: &'ast Option<TsImportCallOptions>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < TsImportCallOptions >.

By default, this method calls [Option < TsImportCallOptions >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_namespace_body<'ast: 'r, 'r>( &mut self, node: &'ast Option<TsNamespaceBody>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < TsNamespaceBody >.

By default, this method calls [Option < TsNamespaceBody >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_this_param<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<TsThisParam>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < TsThisParam > >.

By default, this method calls [Option < Box < TsThisParam > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_type<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<TsType>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < TsType > >.

By default, this method calls [Option < Box < TsType > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_type_ann<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<TsTypeAnn>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < TsTypeAnn > >.

By default, this method calls [Option < Box < TsTypeAnn > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < TsTypeParamDecl > >.

By default, this method calls [Option < Box < TsTypeParamDecl > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>( &mut self, node: &'ast Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < Box < TsTypeParamInstantiation > >.

By default, this method calls [Option < Box < TsTypeParamInstantiation > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>( &mut self, node: &'ast Option<VarDeclOrExpr>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < VarDeclOrExpr >.

By default, this method calls [Option < VarDeclOrExpr >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast [Option<ExprOrSpread>], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Option < ExprOrSpread > >.

By default, this method calls [Vec < Option < ExprOrSpread > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_vec_pats<'ast: 'r, 'r>( &mut self, node: &'ast [Option<Pat>], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Option < Pat > >.

By default, this method calls [Vec < Option < Pat > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_opt_wtf_8_atom<'ast: 'r, 'r>( &mut self, node: &'ast Option<Wtf8Atom>, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Option < swc_atoms :: Wtf8Atom >.

By default, this method calls [Option < swc_atoms :: Wtf8Atom >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_param<'ast: 'r, 'r>( &mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Param.

By default, this method calls Param::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_param_or_ts_param_prop<'ast: 'r, 'r>( &mut self, node: &'ast ParamOrTsParamProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ParamOrTsParamProp.

By default, this method calls ParamOrTsParamProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_param_or_ts_param_props<'ast: 'r, 'r>( &mut self, node: &'ast [ParamOrTsParamProp], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < ParamOrTsParamProp >.

By default, this method calls [Vec < ParamOrTsParamProp >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_params<'ast: 'r, 'r>( &mut self, node: &'ast [Param], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Param >.

By default, this method calls [Vec < Param >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_paren_expr<'ast: 'r, 'r>( &mut self, node: &'ast ParenExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ParenExpr.

By default, this method calls ParenExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_pat<'ast: 'r, 'r>( &mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Pat.

By default, this method calls Pat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_pats<'ast: 'r, 'r>( &mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Pat >.

By default, this method calls [Vec < Pat >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_private_method<'ast: 'r, 'r>( &mut self, node: &'ast PrivateMethod, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type PrivateMethod.

By default, this method calls PrivateMethod::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_private_name<'ast: 'r, 'r>( &mut self, node: &'ast PrivateName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type PrivateName.

By default, this method calls PrivateName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_private_prop<'ast: 'r, 'r>( &mut self, node: &'ast PrivateProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type PrivateProp.

By default, this method calls PrivateProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_program<'ast: 'r, 'r>( &mut self, node: &'ast Program, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Program.

By default, this method calls Program::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_prop<'ast: 'r, 'r>( &mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Prop.

By default, this method calls Prop::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_prop_name<'ast: 'r, 'r>( &mut self, node: &'ast PropName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type PropName.

By default, this method calls PropName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_prop_or_spread<'ast: 'r, 'r>( &mut self, node: &'ast PropOrSpread, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type PropOrSpread.

By default, this method calls PropOrSpread::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_prop_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast [PropOrSpread], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < PropOrSpread >.

By default, this method calls [Vec < PropOrSpread >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_regex<'ast: 'r, 'r>( &mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Regex.

By default, this method calls Regex::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_rest_pat<'ast: 'r, 'r>( &mut self, node: &'ast RestPat, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type RestPat.

By default, this method calls RestPat::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_return_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ReturnStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ReturnStmt.

By default, this method calls ReturnStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_script<'ast: 'r, 'r>( &mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Script.

By default, this method calls Script::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_seq_expr<'ast: 'r, 'r>( &mut self, node: &'ast SeqExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SeqExpr.

By default, this method calls SeqExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_setter_prop<'ast: 'r, 'r>( &mut self, node: &'ast SetterProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SetterProp.

By default, this method calls SetterProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_simple_assign_target<'ast: 'r, 'r>( &mut self, node: &'ast SimpleAssignTarget, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SimpleAssignTarget.

By default, this method calls SimpleAssignTarget::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_span<'ast: 'r, 'r>( &mut self, node: &'ast Span, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type swc_common :: Span.

By default, this method calls [swc_common :: Span::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_spread_element<'ast: 'r, 'r>( &mut self, node: &'ast SpreadElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SpreadElement.

By default, this method calls SpreadElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_static_block<'ast: 'r, 'r>( &mut self, node: &'ast StaticBlock, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type StaticBlock.

By default, this method calls StaticBlock::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_stmt<'ast: 'r, 'r>( &mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Stmt.

By default, this method calls Stmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_stmts<'ast: 'r, 'r>( &mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Stmt >.

By default, this method calls [Vec < Stmt >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_str<'ast: 'r, 'r>( &mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Str.

By default, this method calls Str::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_super<'ast: 'r, 'r>( &mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Super.

By default, this method calls Super::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_super_prop<'ast: 'r, 'r>( &mut self, node: &'ast SuperProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SuperProp.

By default, this method calls SuperProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_super_prop_expr<'ast: 'r, 'r>( &mut self, node: &'ast SuperPropExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SuperPropExpr.

By default, this method calls SuperPropExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_switch_case<'ast: 'r, 'r>( &mut self, node: &'ast SwitchCase, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SwitchCase.

By default, this method calls SwitchCase::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_switch_cases<'ast: 'r, 'r>( &mut self, node: &'ast [SwitchCase], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < SwitchCase >.

By default, this method calls [Vec < SwitchCase >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_switch_stmt<'ast: 'r, 'r>( &mut self, node: &'ast SwitchStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type SwitchStmt.

By default, this method calls SwitchStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_syntax_context<'ast: 'r, 'r>( &mut self, node: &'ast SyntaxContext, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type swc_common :: SyntaxContext.

By default, this method calls [swc_common :: SyntaxContext::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_tagged_tpl<'ast: 'r, 'r>( &mut self, node: &'ast TaggedTpl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TaggedTpl.

By default, this method calls TaggedTpl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_this_expr<'ast: 'r, 'r>( &mut self, node: &'ast ThisExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ThisExpr.

By default, this method calls ThisExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_throw_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ThrowStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type ThrowStmt.

By default, this method calls ThrowStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_tpl<'ast: 'r, 'r>( &mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Tpl.

By default, this method calls Tpl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_tpl_element<'ast: 'r, 'r>( &mut self, node: &'ast TplElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TplElement.

By default, this method calls TplElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_tpl_elements<'ast: 'r, 'r>( &mut self, node: &'ast [TplElement], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TplElement >.

By default, this method calls [Vec < TplElement >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_true_plus_minus<'ast: 'r, 'r>( &mut self, node: &'ast TruePlusMinus, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TruePlusMinus.

By default, this method calls TruePlusMinus::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_try_stmt<'ast: 'r, 'r>( &mut self, node: &'ast TryStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TryStmt.

By default, this method calls TryStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_array_type<'ast: 'r, 'r>( &mut self, node: &'ast TsArrayType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsArrayType.

By default, this method calls TsArrayType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_as_expr<'ast: 'r, 'r>( &mut self, node: &'ast TsAsExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsAsExpr.

By default, this method calls TsAsExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_call_signature_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsCallSignatureDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsCallSignatureDecl.

By default, this method calls TsCallSignatureDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_conditional_type<'ast: 'r, 'r>( &mut self, node: &'ast TsConditionalType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsConditionalType.

By default, this method calls TsConditionalType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_const_assertion<'ast: 'r, 'r>( &mut self, node: &'ast TsConstAssertion, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsConstAssertion.

By default, this method calls TsConstAssertion::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_construct_signature_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsConstructSignatureDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsConstructSignatureDecl.

By default, this method calls TsConstructSignatureDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_constructor_type<'ast: 'r, 'r>( &mut self, node: &'ast TsConstructorType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsConstructorType.

By default, this method calls TsConstructorType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_entity_name<'ast: 'r, 'r>( &mut self, node: &'ast TsEntityName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsEntityName.

By default, this method calls TsEntityName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_enum_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsEnumDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsEnumDecl.

By default, this method calls TsEnumDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_enum_member<'ast: 'r, 'r>( &mut self, node: &'ast TsEnumMember, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsEnumMember.

By default, this method calls TsEnumMember::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_enum_member_id<'ast: 'r, 'r>( &mut self, node: &'ast TsEnumMemberId, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsEnumMemberId.

By default, this method calls TsEnumMemberId::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_enum_members<'ast: 'r, 'r>( &mut self, node: &'ast [TsEnumMember], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsEnumMember >.

By default, this method calls [Vec < TsEnumMember >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_export_assignment<'ast: 'r, 'r>( &mut self, node: &'ast TsExportAssignment, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsExportAssignment.

By default, this method calls TsExportAssignment::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_expr_with_type_args<'ast: 'r, 'r>( &mut self, node: &'ast TsExprWithTypeArgs, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsExprWithTypeArgs.

By default, this method calls TsExprWithTypeArgs::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>( &mut self, node: &'ast [TsExprWithTypeArgs], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsExprWithTypeArgs >.

By default, this method calls [Vec < TsExprWithTypeArgs >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_external_module_ref<'ast: 'r, 'r>( &mut self, node: &'ast TsExternalModuleRef, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsExternalModuleRef.

By default, this method calls TsExternalModuleRef::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>( &mut self, node: &'ast TsFnOrConstructorType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsFnOrConstructorType.

By default, this method calls TsFnOrConstructorType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_fn_param<'ast: 'r, 'r>( &mut self, node: &'ast TsFnParam, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsFnParam.

By default, this method calls TsFnParam::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_fn_params<'ast: 'r, 'r>( &mut self, node: &'ast [TsFnParam], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsFnParam >.

By default, this method calls [Vec < TsFnParam >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_fn_type<'ast: 'r, 'r>( &mut self, node: &'ast TsFnType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsFnType.

By default, this method calls TsFnType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_getter_signature<'ast: 'r, 'r>( &mut self, node: &'ast TsGetterSignature, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsGetterSignature.

By default, this method calls TsGetterSignature::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_import_call_options<'ast: 'r, 'r>( &mut self, node: &'ast TsImportCallOptions, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsImportCallOptions.

By default, this method calls TsImportCallOptions::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_import_equals_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsImportEqualsDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsImportEqualsDecl.

By default, this method calls TsImportEqualsDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_import_type<'ast: 'r, 'r>( &mut self, node: &'ast TsImportType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsImportType.

By default, this method calls TsImportType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_index_signature<'ast: 'r, 'r>( &mut self, node: &'ast TsIndexSignature, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsIndexSignature.

By default, this method calls TsIndexSignature::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_indexed_access_type<'ast: 'r, 'r>( &mut self, node: &'ast TsIndexedAccessType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsIndexedAccessType.

By default, this method calls TsIndexedAccessType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_infer_type<'ast: 'r, 'r>( &mut self, node: &'ast TsInferType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsInferType.

By default, this method calls TsInferType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_instantiation<'ast: 'r, 'r>( &mut self, node: &'ast TsInstantiation, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsInstantiation.

By default, this method calls TsInstantiation::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_interface_body<'ast: 'r, 'r>( &mut self, node: &'ast TsInterfaceBody, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsInterfaceBody.

By default, this method calls TsInterfaceBody::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_interface_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsInterfaceDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsInterfaceDecl.

By default, this method calls TsInterfaceDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_intersection_type<'ast: 'r, 'r>( &mut self, node: &'ast TsIntersectionType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsIntersectionType.

By default, this method calls TsIntersectionType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_keyword_type<'ast: 'r, 'r>( &mut self, node: &'ast TsKeywordType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsKeywordType.

By default, this method calls TsKeywordType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_keyword_type_kind<'ast: 'r, 'r>( &mut self, node: &'ast TsKeywordTypeKind, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsKeywordTypeKind.

By default, this method calls TsKeywordTypeKind::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_lit<'ast: 'r, 'r>( &mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsLit.

By default, this method calls TsLit::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_lit_type<'ast: 'r, 'r>( &mut self, node: &'ast TsLitType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsLitType.

By default, this method calls TsLitType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_mapped_type<'ast: 'r, 'r>( &mut self, node: &'ast TsMappedType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsMappedType.

By default, this method calls TsMappedType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_method_signature<'ast: 'r, 'r>( &mut self, node: &'ast TsMethodSignature, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsMethodSignature.

By default, this method calls TsMethodSignature::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_module_block<'ast: 'r, 'r>( &mut self, node: &'ast TsModuleBlock, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsModuleBlock.

By default, this method calls TsModuleBlock::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_module_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsModuleDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsModuleDecl.

By default, this method calls TsModuleDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_module_name<'ast: 'r, 'r>( &mut self, node: &'ast TsModuleName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsModuleName.

By default, this method calls TsModuleName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_module_ref<'ast: 'r, 'r>( &mut self, node: &'ast TsModuleRef, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsModuleRef.

By default, this method calls TsModuleRef::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_namespace_body<'ast: 'r, 'r>( &mut self, node: &'ast TsNamespaceBody, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsNamespaceBody.

By default, this method calls TsNamespaceBody::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_namespace_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsNamespaceDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsNamespaceDecl.

By default, this method calls TsNamespaceDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_namespace_export_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsNamespaceExportDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsNamespaceExportDecl.

By default, this method calls TsNamespaceExportDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_non_null_expr<'ast: 'r, 'r>( &mut self, node: &'ast TsNonNullExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsNonNullExpr.

By default, this method calls TsNonNullExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_optional_type<'ast: 'r, 'r>( &mut self, node: &'ast TsOptionalType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsOptionalType.

By default, this method calls TsOptionalType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_param_prop<'ast: 'r, 'r>( &mut self, node: &'ast TsParamProp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsParamProp.

By default, this method calls TsParamProp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_param_prop_param<'ast: 'r, 'r>( &mut self, node: &'ast TsParamPropParam, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsParamPropParam.

By default, this method calls TsParamPropParam::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_parenthesized_type<'ast: 'r, 'r>( &mut self, node: &'ast TsParenthesizedType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsParenthesizedType.

By default, this method calls TsParenthesizedType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_property_signature<'ast: 'r, 'r>( &mut self, node: &'ast TsPropertySignature, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsPropertySignature.

By default, this method calls TsPropertySignature::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_qualified_name<'ast: 'r, 'r>( &mut self, node: &'ast TsQualifiedName, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsQualifiedName.

By default, this method calls TsQualifiedName::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_rest_type<'ast: 'r, 'r>( &mut self, node: &'ast TsRestType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsRestType.

By default, this method calls TsRestType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_satisfies_expr<'ast: 'r, 'r>( &mut self, node: &'ast TsSatisfiesExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsSatisfiesExpr.

By default, this method calls TsSatisfiesExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_setter_signature<'ast: 'r, 'r>( &mut self, node: &'ast TsSetterSignature, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsSetterSignature.

By default, this method calls TsSetterSignature::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_this_param<'ast: 'r, 'r>( &mut self, node: &'ast TsThisParam, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsThisParam.

By default, this method calls TsThisParam::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_this_type<'ast: 'r, 'r>( &mut self, node: &'ast TsThisType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsThisType.

By default, this method calls TsThisType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_this_type_or_ident<'ast: 'r, 'r>( &mut self, node: &'ast TsThisTypeOrIdent, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsThisTypeOrIdent.

By default, this method calls TsThisTypeOrIdent::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_tpl_lit_type<'ast: 'r, 'r>( &mut self, node: &'ast TsTplLitType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTplLitType.

By default, this method calls TsTplLitType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_tuple_element<'ast: 'r, 'r>( &mut self, node: &'ast TsTupleElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTupleElement.

By default, this method calls TsTupleElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_tuple_elements<'ast: 'r, 'r>( &mut self, node: &'ast [TsTupleElement], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsTupleElement >.

By default, this method calls [Vec < TsTupleElement >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_tuple_type<'ast: 'r, 'r>( &mut self, node: &'ast TsTupleType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTupleType.

By default, this method calls TsTupleType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type<'ast: 'r, 'r>( &mut self, node: &'ast TsType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsType.

By default, this method calls TsType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_alias_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeAliasDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeAliasDecl.

By default, this method calls TsTypeAliasDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_ann<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeAnn, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeAnn.

By default, this method calls TsTypeAnn::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_assertion<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeAssertion, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeAssertion.

By default, this method calls TsTypeAssertion::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_element<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeElement, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeElement.

By default, this method calls TsTypeElement::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_elements<'ast: 'r, 'r>( &mut self, node: &'ast [TsTypeElement], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsTypeElement >.

By default, this method calls [Vec < TsTypeElement >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_lit<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeLit, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeLit.

By default, this method calls TsTypeLit::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_operator<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeOperator, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeOperator.

By default, this method calls TsTypeOperator::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_operator_op<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeOperatorOp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeOperatorOp.

By default, this method calls TsTypeOperatorOp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_param<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeParam, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeParam.

By default, this method calls TsTypeParam::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_param_decl<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeParamDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeParamDecl.

By default, this method calls TsTypeParamDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_param_instantiation<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeParamInstantiation, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeParamInstantiation.

By default, this method calls TsTypeParamInstantiation::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_params<'ast: 'r, 'r>( &mut self, node: &'ast [TsTypeParam], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < TsTypeParam >.

By default, this method calls [Vec < TsTypeParam >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_predicate<'ast: 'r, 'r>( &mut self, node: &'ast TsTypePredicate, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypePredicate.

By default, this method calls TsTypePredicate::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_query<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeQuery, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeQuery.

By default, this method calls TsTypeQuery::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_query_expr<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeQueryExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeQueryExpr.

By default, this method calls TsTypeQueryExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_type_ref<'ast: 'r, 'r>( &mut self, node: &'ast TsTypeRef, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsTypeRef.

By default, this method calls TsTypeRef::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_types<'ast: 'r, 'r>( &mut self, node: &'ast [Box<TsType>], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < Box < TsType > >.

By default, this method calls [Vec < Box < TsType > >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>( &mut self, node: &'ast TsUnionOrIntersectionType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsUnionOrIntersectionType.

By default, this method calls TsUnionOrIntersectionType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_ts_union_type<'ast: 'r, 'r>( &mut self, node: &'ast TsUnionType, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type TsUnionType.

By default, this method calls TsUnionType::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_unary_expr<'ast: 'r, 'r>( &mut self, node: &'ast UnaryExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type UnaryExpr.

By default, this method calls UnaryExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_unary_op<'ast: 'r, 'r>( &mut self, node: &'ast UnaryOp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type UnaryOp.

By default, this method calls UnaryOp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_update_expr<'ast: 'r, 'r>( &mut self, node: &'ast UpdateExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type UpdateExpr.

By default, this method calls UpdateExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_update_op<'ast: 'r, 'r>( &mut self, node: &'ast UpdateOp, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type UpdateOp.

By default, this method calls UpdateOp::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_using_decl<'ast: 'r, 'r>( &mut self, node: &'ast UsingDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type UsingDecl.

By default, this method calls UsingDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_var_decl<'ast: 'r, 'r>( &mut self, node: &'ast VarDecl, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type VarDecl.

By default, this method calls VarDecl::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_var_decl_kind<'ast: 'r, 'r>( &mut self, node: &'ast VarDeclKind, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type VarDeclKind.

By default, this method calls VarDeclKind::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_var_decl_or_expr<'ast: 'r, 'r>( &mut self, node: &'ast VarDeclOrExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type VarDeclOrExpr.

By default, this method calls VarDeclOrExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_var_declarator<'ast: 'r, 'r>( &mut self, node: &'ast VarDeclarator, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type VarDeclarator.

By default, this method calls VarDeclarator::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_var_declarators<'ast: 'r, 'r>( &mut self, node: &'ast [VarDeclarator], __ast_path: &mut AstNodePath<'r>, )

Visit a node of type Vec < VarDeclarator >.

By default, this method calls [Vec < VarDeclarator >::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_while_stmt<'ast: 'r, 'r>( &mut self, node: &'ast WhileStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type WhileStmt.

By default, this method calls WhileStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_with_stmt<'ast: 'r, 'r>( &mut self, node: &'ast WithStmt, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type WithStmt.

By default, this method calls WithStmt::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Source

fn visit_wtf_8_atom<'ast: 'r, 'r>( &mut self, node: &'ast Wtf8Atom, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type swc_atoms :: Wtf8Atom.

By default, this method calls [swc_atoms :: Wtf8Atom::visit_children_with_ast_path]. If you want to recurse, you need to call it manually.

Source

fn visit_yield_expr<'ast: 'r, 'r>( &mut self, node: &'ast YieldExpr, __ast_path: &mut AstNodePath<'r>, )

Visit a node of type YieldExpr.

By default, this method calls YieldExpr::visit_children_with_ast_path. If you want to recurse, you need to call it manually.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

VisitAstPath

Trait VisitAstPath Copy item path

Provided Methods§

fn visit_accessibility<'ast: 'r, 'r>( &mut self, node: &'ast Accessibility, __ast_path: &mut AstNodePath<'r>, )

fn visit_array_lit<'ast: 'r, 'r>( &mut self, node: &'ast ArrayLit, __ast_path: &mut AstNodePath<'r>, )

fn visit_array_pat<'ast: 'r, 'r>( &mut self, node: &'ast ArrayPat, __ast_path: &mut AstNodePath<'r>, )

fn visit_arrow_expr<'ast: 'r, 'r>( &mut self, node: &'ast ArrowExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_arrow_function_body<'ast: 'r, 'r>( &mut self, node: &'ast ArrowFunctionBody, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_expr<'ast: 'r, 'r>( &mut self, node: &'ast AssignExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_op<'ast: 'r, 'r>( &mut self, node: &'ast AssignOp, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_pat<'ast: 'r, 'r>( &mut self, node: &'ast AssignPat, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_pat_prop<'ast: 'r, 'r>( &mut self, node: &'ast AssignPatProp, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_prop<'ast: 'r, 'r>( &mut self, node: &'ast AssignProp, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_target<'ast: 'r, 'r>( &mut self, node: &'ast AssignTarget, __ast_path: &mut AstNodePath<'r>, )

fn visit_assign_target_pat<'ast: 'r, 'r>( &mut self, node: &'ast AssignTargetPat, __ast_path: &mut AstNodePath<'r>, )

fn visit_atom<'ast: 'r, 'r>( &mut self, node: &'ast Atom, __ast_path: &mut AstNodePath<'r>, )

fn visit_auto_accessor<'ast: 'r, 'r>( &mut self, node: &'ast AutoAccessor, __ast_path: &mut AstNodePath<'r>, )

fn visit_await_expr<'ast: 'r, 'r>( &mut self, node: &'ast AwaitExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_big_int<'ast: 'r, 'r>( &mut self, node: &'ast BigInt, __ast_path: &mut AstNodePath<'r>, )

fn visit_big_int_value<'ast: 'r, 'r>( &mut self, node: &'ast BigIntValue, __ast_path: &mut AstNodePath<'r>, )

fn visit_bin_expr<'ast: 'r, 'r>( &mut self, node: &'ast BinExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_binary_op<'ast: 'r, 'r>( &mut self, node: &'ast BinaryOp, __ast_path: &mut AstNodePath<'r>, )

fn visit_binding_ident<'ast: 'r, 'r>( &mut self, node: &'ast BindingIdent, __ast_path: &mut AstNodePath<'r>, )

fn visit_block_stmt<'ast: 'r, 'r>( &mut self, node: &'ast BlockStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_bool<'ast: 'r, 'r>( &mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>, )

fn visit_break_stmt<'ast: 'r, 'r>( &mut self, node: &'ast BreakStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_call_expr<'ast: 'r, 'r>( &mut self, node: &'ast CallExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_callee<'ast: 'r, 'r>( &mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>, )

fn visit_catch_clause<'ast: 'r, 'r>( &mut self, node: &'ast CatchClause, __ast_path: &mut AstNodePath<'r>, )

fn visit_class<'ast: 'r, 'r>( &mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>, )

fn visit_class_decl<'ast: 'r, 'r>( &mut self, node: &'ast ClassDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_class_expr<'ast: 'r, 'r>( &mut self, node: &'ast ClassExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_class_member<'ast: 'r, 'r>( &mut self, node: &'ast ClassMember, __ast_path: &mut AstNodePath<'r>, )

fn visit_class_members<'ast: 'r, 'r>( &mut self, node: &'ast [ClassMember], __ast_path: &mut AstNodePath<'r>, )

fn visit_class_method<'ast: 'r, 'r>( &mut self, node: &'ast ClassMethod, __ast_path: &mut AstNodePath<'r>, )

fn visit_class_prop<'ast: 'r, 'r>( &mut self, node: &'ast ClassProp, __ast_path: &mut AstNodePath<'r>, )

fn visit_computed_prop_name<'ast: 'r, 'r>( &mut self, node: &'ast ComputedPropName, __ast_path: &mut AstNodePath<'r>, )

fn visit_cond_expr<'ast: 'r, 'r>( &mut self, node: &'ast CondExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_constructor<'ast: 'r, 'r>( &mut self, node: &'ast Constructor, __ast_path: &mut AstNodePath<'r>, )

fn visit_continue_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ContinueStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_debugger_stmt<'ast: 'r, 'r>( &mut self, node: &'ast DebuggerStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_decl<'ast: 'r, 'r>( &mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>, )

fn visit_decorator<'ast: 'r, 'r>( &mut self, node: &'ast Decorator, __ast_path: &mut AstNodePath<'r>, )

fn visit_decorators<'ast: 'r, 'r>( &mut self, node: &'ast [Decorator], __ast_path: &mut AstNodePath<'r>, )

fn visit_default_decl<'ast: 'r, 'r>( &mut self, node: &'ast DefaultDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_do_while_stmt<'ast: 'r, 'r>( &mut self, node: &'ast DoWhileStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_empty_stmt<'ast: 'r, 'r>( &mut self, node: &'ast EmptyStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_all<'ast: 'r, 'r>( &mut self, node: &'ast ExportAll, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_decl<'ast: 'r, 'r>( &mut self, node: &'ast ExportDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_default_decl<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_default_expr<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_default_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportDefaultSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_named_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportNamedSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_namespace_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportNamespaceSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ExportSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_export_specifiers<'ast: 'r, 'r>( &mut self, node: &'ast [ExportSpecifier], __ast_path: &mut AstNodePath<'r>, )

fn visit_expr<'ast: 'r, 'r>( &mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>, )

fn visit_expr_or_spread<'ast: 'r, 'r>( &mut self, node: &'ast ExprOrSpread, __ast_path: &mut AstNodePath<'r>, )

fn visit_expr_or_spreads<'ast: 'r, 'r>( &mut self, node: &'ast [ExprOrSpread], __ast_path: &mut AstNodePath<'r>, )

fn visit_expr_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ExprStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_exprs<'ast: 'r, 'r>( &mut self, node: &'ast [Box<Expr>], __ast_path: &mut AstNodePath<'r>, )

fn visit_fn_decl<'ast: 'r, 'r>( &mut self, node: &'ast FnDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_fn_expr<'ast: 'r, 'r>( &mut self, node: &'ast FnExpr, __ast_path: &mut AstNodePath<'r>, )

fn visit_for_head<'ast: 'r, 'r>( &mut self, node: &'ast ForHead, __ast_path: &mut AstNodePath<'r>, )

fn visit_for_in_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForInStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_for_of_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForOfStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_for_stmt<'ast: 'r, 'r>( &mut self, node: &'ast ForStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_function<'ast: 'r, 'r>( &mut self, node: &'ast Function, __ast_path: &mut AstNodePath<'r>, )

fn visit_function_body<'ast: 'r, 'r>( &mut self, node: &'ast FunctionBody, __ast_path: &mut AstNodePath<'r>, )

fn visit_getter_prop<'ast: 'r, 'r>( &mut self, node: &'ast GetterProp, __ast_path: &mut AstNodePath<'r>, )

fn visit_ident<'ast: 'r, 'r>( &mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>, )

fn visit_ident_name<'ast: 'r, 'r>( &mut self, node: &'ast IdentName, __ast_path: &mut AstNodePath<'r>, )

fn visit_if_stmt<'ast: 'r, 'r>( &mut self, node: &'ast IfStmt, __ast_path: &mut AstNodePath<'r>, )

fn visit_import<'ast: 'r, 'r>( &mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_decl<'ast: 'r, 'r>( &mut self, node: &'ast ImportDecl, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_default_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportDefaultSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_named_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportNamedSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_phase<'ast: 'r, 'r>( &mut self, node: &'ast ImportPhase, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_specifier<'ast: 'r, 'r>( &mut self, node: &'ast ImportSpecifier, __ast_path: &mut AstNodePath<'r>, )

fn visit_import_specifiers<'ast: 'r, 'r>( &mut self, node: &'ast [ImportSpecifier], __ast_path: &mut AstNodePath<'r>, )

Trait VisitAstPath