Trait FoldAstPath 

pub trait FoldAstPath {
    // Provided methods
    fn fold_accessibility(
        &mut self,
        node: Accessibility,
        __ast_path: &mut AstKindPath,
    ) -> Accessibility { ... }
    fn fold_array_lit(
        &mut self,
        node: ArrayLit,
        __ast_path: &mut AstKindPath,
    ) -> ArrayLit { ... }
    fn fold_array_pat(
        &mut self,
        node: ArrayPat,
        __ast_path: &mut AstKindPath,
    ) -> ArrayPat { ... }
    fn fold_arrow_expr(
        &mut self,
        node: ArrowExpr,
        __ast_path: &mut AstKindPath,
    ) -> ArrowExpr { ... }
    fn fold_arrow_function_body(
        &mut self,
        node: ArrowFunctionBody,
        __ast_path: &mut AstKindPath,
    ) -> ArrowFunctionBody { ... }
    fn fold_assign_expr(
        &mut self,
        node: AssignExpr,
        __ast_path: &mut AstKindPath,
    ) -> AssignExpr { ... }
    fn fold_assign_op(
        &mut self,
        node: AssignOp,
        __ast_path: &mut AstKindPath,
    ) -> AssignOp { ... }
    fn fold_assign_pat(
        &mut self,
        node: AssignPat,
        __ast_path: &mut AstKindPath,
    ) -> AssignPat { ... }
    fn fold_assign_pat_prop(
        &mut self,
        node: AssignPatProp,
        __ast_path: &mut AstKindPath,
    ) -> AssignPatProp { ... }
    fn fold_assign_prop(
        &mut self,
        node: AssignProp,
        __ast_path: &mut AstKindPath,
    ) -> AssignProp { ... }
    fn fold_assign_target(
        &mut self,
        node: AssignTarget,
        __ast_path: &mut AstKindPath,
    ) -> AssignTarget { ... }
    fn fold_assign_target_pat(
        &mut self,
        node: AssignTargetPat,
        __ast_path: &mut AstKindPath,
    ) -> AssignTargetPat { ... }
    fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom { ... }
    fn fold_auto_accessor(
        &mut self,
        node: AutoAccessor,
        __ast_path: &mut AstKindPath,
    ) -> AutoAccessor { ... }
    fn fold_await_expr(
        &mut self,
        node: AwaitExpr,
        __ast_path: &mut AstKindPath,
    ) -> AwaitExpr { ... }
    fn fold_big_int(
        &mut self,
        node: BigInt,
        __ast_path: &mut AstKindPath,
    ) -> BigInt { ... }
    fn fold_big_int_value(
        &mut self,
        node: BigIntValue,
        __ast_path: &mut AstKindPath,
    ) -> BigIntValue { ... }
    fn fold_bin_expr(
        &mut self,
        node: BinExpr,
        __ast_path: &mut AstKindPath,
    ) -> BinExpr { ... }
    fn fold_binary_op(
        &mut self,
        node: BinaryOp,
        __ast_path: &mut AstKindPath,
    ) -> BinaryOp { ... }
    fn fold_binding_ident(
        &mut self,
        node: BindingIdent,
        __ast_path: &mut AstKindPath,
    ) -> BindingIdent { ... }
    fn fold_block_stmt(
        &mut self,
        node: BlockStmt,
        __ast_path: &mut AstKindPath,
    ) -> BlockStmt { ... }
    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool { ... }
    fn fold_break_stmt(
        &mut self,
        node: BreakStmt,
        __ast_path: &mut AstKindPath,
    ) -> BreakStmt { ... }
    fn fold_call_expr(
        &mut self,
        node: CallExpr,
        __ast_path: &mut AstKindPath,
    ) -> CallExpr { ... }
    fn fold_callee(
        &mut self,
        node: Callee,
        __ast_path: &mut AstKindPath,
    ) -> Callee { ... }
    fn fold_catch_clause(
        &mut self,
        node: CatchClause,
        __ast_path: &mut AstKindPath,
    ) -> CatchClause { ... }
    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class { ... }
    fn fold_class_decl(
        &mut self,
        node: ClassDecl,
        __ast_path: &mut AstKindPath,
    ) -> ClassDecl { ... }
    fn fold_class_expr(
        &mut self,
        node: ClassExpr,
        __ast_path: &mut AstKindPath,
    ) -> ClassExpr { ... }
    fn fold_class_member(
        &mut self,
        node: ClassMember,
        __ast_path: &mut AstKindPath,
    ) -> ClassMember { ... }
    fn fold_class_members(
        &mut self,
        node: Vec<ClassMember>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ClassMember> { ... }
    fn fold_class_method(
        &mut self,
        node: ClassMethod,
        __ast_path: &mut AstKindPath,
    ) -> ClassMethod { ... }
    fn fold_class_prop(
        &mut self,
        node: ClassProp,
        __ast_path: &mut AstKindPath,
    ) -> ClassProp { ... }
    fn fold_computed_prop_name(
        &mut self,
        node: ComputedPropName,
        __ast_path: &mut AstKindPath,
    ) -> ComputedPropName { ... }
    fn fold_cond_expr(
        &mut self,
        node: CondExpr,
        __ast_path: &mut AstKindPath,
    ) -> CondExpr { ... }
    fn fold_constructor(
        &mut self,
        node: Constructor,
        __ast_path: &mut AstKindPath,
    ) -> Constructor { ... }
    fn fold_continue_stmt(
        &mut self,
        node: ContinueStmt,
        __ast_path: &mut AstKindPath,
    ) -> ContinueStmt { ... }
    fn fold_debugger_stmt(
        &mut self,
        node: DebuggerStmt,
        __ast_path: &mut AstKindPath,
    ) -> DebuggerStmt { ... }
    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl { ... }
    fn fold_decorator(
        &mut self,
        node: Decorator,
        __ast_path: &mut AstKindPath,
    ) -> Decorator { ... }
    fn fold_decorators(
        &mut self,
        node: Vec<Decorator>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Decorator> { ... }
    fn fold_default_decl(
        &mut self,
        node: DefaultDecl,
        __ast_path: &mut AstKindPath,
    ) -> DefaultDecl { ... }
    fn fold_do_while_stmt(
        &mut self,
        node: DoWhileStmt,
        __ast_path: &mut AstKindPath,
    ) -> DoWhileStmt { ... }
    fn fold_empty_stmt(
        &mut self,
        node: EmptyStmt,
        __ast_path: &mut AstKindPath,
    ) -> EmptyStmt { ... }
    fn fold_export_all(
        &mut self,
        node: ExportAll,
        __ast_path: &mut AstKindPath,
    ) -> ExportAll { ... }
    fn fold_export_decl(
        &mut self,
        node: ExportDecl,
        __ast_path: &mut AstKindPath,
    ) -> ExportDecl { ... }
    fn fold_export_default_decl(
        &mut self,
        node: ExportDefaultDecl,
        __ast_path: &mut AstKindPath,
    ) -> ExportDefaultDecl { ... }
    fn fold_export_default_expr(
        &mut self,
        node: ExportDefaultExpr,
        __ast_path: &mut AstKindPath,
    ) -> ExportDefaultExpr { ... }
    fn fold_export_default_specifier(
        &mut self,
        node: ExportDefaultSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ExportDefaultSpecifier { ... }
    fn fold_export_named_specifier(
        &mut self,
        node: ExportNamedSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ExportNamedSpecifier { ... }
    fn fold_export_namespace_specifier(
        &mut self,
        node: ExportNamespaceSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ExportNamespaceSpecifier { ... }
    fn fold_export_specifier(
        &mut self,
        node: ExportSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ExportSpecifier { ... }
    fn fold_export_specifiers(
        &mut self,
        node: Vec<ExportSpecifier>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ExportSpecifier> { ... }
    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr { ... }
    fn fold_expr_or_spread(
        &mut self,
        node: ExprOrSpread,
        __ast_path: &mut AstKindPath,
    ) -> ExprOrSpread { ... }
    fn fold_expr_or_spreads(
        &mut self,
        node: Vec<ExprOrSpread>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ExprOrSpread> { ... }
    fn fold_expr_stmt(
        &mut self,
        node: ExprStmt,
        __ast_path: &mut AstKindPath,
    ) -> ExprStmt { ... }
    fn fold_exprs(
        &mut self,
        node: Vec<Box<Expr>>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Box<Expr>> { ... }
    fn fold_fn_decl(
        &mut self,
        node: FnDecl,
        __ast_path: &mut AstKindPath,
    ) -> FnDecl { ... }
    fn fold_fn_expr(
        &mut self,
        node: FnExpr,
        __ast_path: &mut AstKindPath,
    ) -> FnExpr { ... }
    fn fold_for_head(
        &mut self,
        node: ForHead,
        __ast_path: &mut AstKindPath,
    ) -> ForHead { ... }
    fn fold_for_in_stmt(
        &mut self,
        node: ForInStmt,
        __ast_path: &mut AstKindPath,
    ) -> ForInStmt { ... }
    fn fold_for_of_stmt(
        &mut self,
        node: ForOfStmt,
        __ast_path: &mut AstKindPath,
    ) -> ForOfStmt { ... }
    fn fold_for_stmt(
        &mut self,
        node: ForStmt,
        __ast_path: &mut AstKindPath,
    ) -> ForStmt { ... }
    fn fold_function(
        &mut self,
        node: Function,
        __ast_path: &mut AstKindPath,
    ) -> Function { ... }
    fn fold_function_body(
        &mut self,
        node: FunctionBody,
        __ast_path: &mut AstKindPath,
    ) -> FunctionBody { ... }
    fn fold_getter_prop(
        &mut self,
        node: GetterProp,
        __ast_path: &mut AstKindPath,
    ) -> GetterProp { ... }
    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident { ... }
    fn fold_ident_name(
        &mut self,
        node: IdentName,
        __ast_path: &mut AstKindPath,
    ) -> IdentName { ... }
    fn fold_if_stmt(
        &mut self,
        node: IfStmt,
        __ast_path: &mut AstKindPath,
    ) -> IfStmt { ... }
    fn fold_import(
        &mut self,
        node: Import,
        __ast_path: &mut AstKindPath,
    ) -> Import { ... }
    fn fold_import_decl(
        &mut self,
        node: ImportDecl,
        __ast_path: &mut AstKindPath,
    ) -> ImportDecl { ... }
    fn fold_import_default_specifier(
        &mut self,
        node: ImportDefaultSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ImportDefaultSpecifier { ... }
    fn fold_import_named_specifier(
        &mut self,
        node: ImportNamedSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ImportNamedSpecifier { ... }
    fn fold_import_phase(
        &mut self,
        node: ImportPhase,
        __ast_path: &mut AstKindPath,
    ) -> ImportPhase { ... }
    fn fold_import_specifier(
        &mut self,
        node: ImportSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ImportSpecifier { ... }
    fn fold_import_specifiers(
        &mut self,
        node: Vec<ImportSpecifier>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ImportSpecifier> { ... }
    fn fold_import_star_as_specifier(
        &mut self,
        node: ImportStarAsSpecifier,
        __ast_path: &mut AstKindPath,
    ) -> ImportStarAsSpecifier { ... }
    fn fold_import_with(
        &mut self,
        node: ImportWith,
        __ast_path: &mut AstKindPath,
    ) -> ImportWith { ... }
    fn fold_import_with_item(
        &mut self,
        node: ImportWithItem,
        __ast_path: &mut AstKindPath,
    ) -> ImportWithItem { ... }
    fn fold_import_with_items(
        &mut self,
        node: Vec<ImportWithItem>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ImportWithItem> { ... }
    fn fold_invalid(
        &mut self,
        node: Invalid,
        __ast_path: &mut AstKindPath,
    ) -> Invalid { ... }
    fn fold_jsx_attr(
        &mut self,
        node: JSXAttr,
        __ast_path: &mut AstKindPath,
    ) -> JSXAttr { ... }
    fn fold_jsx_attr_name(
        &mut self,
        node: JSXAttrName,
        __ast_path: &mut AstKindPath,
    ) -> JSXAttrName { ... }
    fn fold_jsx_attr_or_spread(
        &mut self,
        node: JSXAttrOrSpread,
        __ast_path: &mut AstKindPath,
    ) -> JSXAttrOrSpread { ... }
    fn fold_jsx_attr_or_spreads(
        &mut self,
        node: Vec<JSXAttrOrSpread>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<JSXAttrOrSpread> { ... }
    fn fold_jsx_attr_value(
        &mut self,
        node: JSXAttrValue,
        __ast_path: &mut AstKindPath,
    ) -> JSXAttrValue { ... }
    fn fold_jsx_closing_element(
        &mut self,
        node: JSXClosingElement,
        __ast_path: &mut AstKindPath,
    ) -> JSXClosingElement { ... }
    fn fold_jsx_closing_fragment(
        &mut self,
        node: JSXClosingFragment,
        __ast_path: &mut AstKindPath,
    ) -> JSXClosingFragment { ... }
    fn fold_jsx_element(
        &mut self,
        node: JSXElement,
        __ast_path: &mut AstKindPath,
    ) -> JSXElement { ... }
    fn fold_jsx_element_child(
        &mut self,
        node: JSXElementChild,
        __ast_path: &mut AstKindPath,
    ) -> JSXElementChild { ... }
    fn fold_jsx_element_childs(
        &mut self,
        node: Vec<JSXElementChild>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<JSXElementChild> { ... }
    fn fold_jsx_element_name(
        &mut self,
        node: JSXElementName,
        __ast_path: &mut AstKindPath,
    ) -> JSXElementName { ... }
    fn fold_jsx_empty_expr(
        &mut self,
        node: JSXEmptyExpr,
        __ast_path: &mut AstKindPath,
    ) -> JSXEmptyExpr { ... }
    fn fold_jsx_expr(
        &mut self,
        node: JSXExpr,
        __ast_path: &mut AstKindPath,
    ) -> JSXExpr { ... }
    fn fold_jsx_expr_container(
        &mut self,
        node: JSXExprContainer,
        __ast_path: &mut AstKindPath,
    ) -> JSXExprContainer { ... }
    fn fold_jsx_fragment(
        &mut self,
        node: JSXFragment,
        __ast_path: &mut AstKindPath,
    ) -> JSXFragment { ... }
    fn fold_jsx_member_expr(
        &mut self,
        node: JSXMemberExpr,
        __ast_path: &mut AstKindPath,
    ) -> JSXMemberExpr { ... }
    fn fold_jsx_namespaced_name(
        &mut self,
        node: JSXNamespacedName,
        __ast_path: &mut AstKindPath,
    ) -> JSXNamespacedName { ... }
    fn fold_jsx_object(
        &mut self,
        node: JSXObject,
        __ast_path: &mut AstKindPath,
    ) -> JSXObject { ... }
    fn fold_jsx_opening_element(
        &mut self,
        node: JSXOpeningElement,
        __ast_path: &mut AstKindPath,
    ) -> JSXOpeningElement { ... }
    fn fold_jsx_opening_fragment(
        &mut self,
        node: JSXOpeningFragment,
        __ast_path: &mut AstKindPath,
    ) -> JSXOpeningFragment { ... }
    fn fold_jsx_spread_child(
        &mut self,
        node: JSXSpreadChild,
        __ast_path: &mut AstKindPath,
    ) -> JSXSpreadChild { ... }
    fn fold_jsx_text(
        &mut self,
        node: JSXText,
        __ast_path: &mut AstKindPath,
    ) -> JSXText { ... }
    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key { ... }
    fn fold_key_value_pat_prop(
        &mut self,
        node: KeyValuePatProp,
        __ast_path: &mut AstKindPath,
    ) -> KeyValuePatProp { ... }
    fn fold_key_value_prop(
        &mut self,
        node: KeyValueProp,
        __ast_path: &mut AstKindPath,
    ) -> KeyValueProp { ... }
    fn fold_labeled_stmt(
        &mut self,
        node: LabeledStmt,
        __ast_path: &mut AstKindPath,
    ) -> LabeledStmt { ... }
    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit { ... }
    fn fold_member_expr(
        &mut self,
        node: MemberExpr,
        __ast_path: &mut AstKindPath,
    ) -> MemberExpr { ... }
    fn fold_member_prop(
        &mut self,
        node: MemberProp,
        __ast_path: &mut AstKindPath,
    ) -> MemberProp { ... }
    fn fold_meta_prop_expr(
        &mut self,
        node: MetaPropExpr,
        __ast_path: &mut AstKindPath,
    ) -> MetaPropExpr { ... }
    fn fold_meta_prop_kind(
        &mut self,
        node: MetaPropKind,
        __ast_path: &mut AstKindPath,
    ) -> MetaPropKind { ... }
    fn fold_method_kind(
        &mut self,
        node: MethodKind,
        __ast_path: &mut AstKindPath,
    ) -> MethodKind { ... }
    fn fold_method_prop(
        &mut self,
        node: MethodProp,
        __ast_path: &mut AstKindPath,
    ) -> MethodProp { ... }
    fn fold_module(
        &mut self,
        node: Module,
        __ast_path: &mut AstKindPath,
    ) -> Module { ... }
    fn fold_module_decl(
        &mut self,
        node: ModuleDecl,
        __ast_path: &mut AstKindPath,
    ) -> ModuleDecl { ... }
    fn fold_module_export_name(
        &mut self,
        node: ModuleExportName,
        __ast_path: &mut AstKindPath,
    ) -> ModuleExportName { ... }
    fn fold_module_item(
        &mut self,
        node: ModuleItem,
        __ast_path: &mut AstKindPath,
    ) -> ModuleItem { ... }
    fn fold_module_items(
        &mut self,
        node: Vec<ModuleItem>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ModuleItem> { ... }
    fn fold_named_export(
        &mut self,
        node: NamedExport,
        __ast_path: &mut AstKindPath,
    ) -> NamedExport { ... }
    fn fold_new_expr(
        &mut self,
        node: NewExpr,
        __ast_path: &mut AstKindPath,
    ) -> NewExpr { ... }
    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null { ... }
    fn fold_number(
        &mut self,
        node: Number,
        __ast_path: &mut AstKindPath,
    ) -> Number { ... }
    fn fold_object_lit(
        &mut self,
        node: ObjectLit,
        __ast_path: &mut AstKindPath,
    ) -> ObjectLit { ... }
    fn fold_object_pat(
        &mut self,
        node: ObjectPat,
        __ast_path: &mut AstKindPath,
    ) -> ObjectPat { ... }
    fn fold_object_pat_prop(
        &mut self,
        node: ObjectPatProp,
        __ast_path: &mut AstKindPath,
    ) -> ObjectPatProp { ... }
    fn fold_object_pat_props(
        &mut self,
        node: Vec<ObjectPatProp>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ObjectPatProp> { ... }
    fn fold_opt_accessibility(
        &mut self,
        node: Option<Accessibility>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Accessibility> { ... }
    fn fold_opt_atom(
        &mut self,
        node: Option<Atom>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Atom> { ... }
    fn fold_opt_block_stmt(
        &mut self,
        node: Option<BlockStmt>,
        __ast_path: &mut AstKindPath,
    ) -> Option<BlockStmt> { ... }
    fn fold_opt_call(
        &mut self,
        node: OptCall,
        __ast_path: &mut AstKindPath,
    ) -> OptCall { ... }
    fn fold_opt_catch_clause(
        &mut self,
        node: Option<CatchClause>,
        __ast_path: &mut AstKindPath,
    ) -> Option<CatchClause> { ... }
    fn fold_opt_chain_base(
        &mut self,
        node: OptChainBase,
        __ast_path: &mut AstKindPath,
    ) -> OptChainBase { ... }
    fn fold_opt_chain_expr(
        &mut self,
        node: OptChainExpr,
        __ast_path: &mut AstKindPath,
    ) -> OptChainExpr { ... }
    fn fold_opt_expr(
        &mut self,
        node: Option<Box<Expr>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<Expr>> { ... }
    fn fold_opt_expr_or_spread(
        &mut self,
        node: Option<ExprOrSpread>,
        __ast_path: &mut AstKindPath,
    ) -> Option<ExprOrSpread> { ... }
    fn fold_opt_expr_or_spreads(
        &mut self,
        node: Option<Vec<ExprOrSpread>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Vec<ExprOrSpread>> { ... }
    fn fold_opt_function_body(
        &mut self,
        node: Option<FunctionBody>,
        __ast_path: &mut AstKindPath,
    ) -> Option<FunctionBody> { ... }
    fn fold_opt_ident(
        &mut self,
        node: Option<Ident>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Ident> { ... }
    fn fold_opt_jsx_attr_value(
        &mut self,
        node: Option<JSXAttrValue>,
        __ast_path: &mut AstKindPath,
    ) -> Option<JSXAttrValue> { ... }
    fn fold_opt_jsx_closing_element(
        &mut self,
        node: Option<JSXClosingElement>,
        __ast_path: &mut AstKindPath,
    ) -> Option<JSXClosingElement> { ... }
    fn fold_opt_module_export_name(
        &mut self,
        node: Option<ModuleExportName>,
        __ast_path: &mut AstKindPath,
    ) -> Option<ModuleExportName> { ... }
    fn fold_opt_object_lit(
        &mut self,
        node: Option<Box<ObjectLit>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<ObjectLit>> { ... }
    fn fold_opt_pat(
        &mut self,
        node: Option<Pat>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Pat> { ... }
    fn fold_opt_span(
        &mut self,
        node: Option<Span>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Span> { ... }
    fn fold_opt_stmt(
        &mut self,
        node: Option<Box<Stmt>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<Stmt>> { ... }
    fn fold_opt_str(
        &mut self,
        node: Option<Box<Str>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<Str>> { ... }
    fn fold_opt_true_plus_minus(
        &mut self,
        node: Option<TruePlusMinus>,
        __ast_path: &mut AstKindPath,
    ) -> Option<TruePlusMinus> { ... }
    fn fold_opt_ts_entity_name(
        &mut self,
        node: Option<TsEntityName>,
        __ast_path: &mut AstKindPath,
    ) -> Option<TsEntityName> { ... }
    fn fold_opt_ts_import_call_options(
        &mut self,
        node: Option<TsImportCallOptions>,
        __ast_path: &mut AstKindPath,
    ) -> Option<TsImportCallOptions> { ... }
    fn fold_opt_ts_namespace_body(
        &mut self,
        node: Option<TsNamespaceBody>,
        __ast_path: &mut AstKindPath,
    ) -> Option<TsNamespaceBody> { ... }
    fn fold_opt_ts_this_param(
        &mut self,
        node: Option<Box<TsThisParam>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TsThisParam>> { ... }
    fn fold_opt_ts_type(
        &mut self,
        node: Option<Box<TsType>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TsType>> { ... }
    fn fold_opt_ts_type_ann(
        &mut self,
        node: Option<Box<TsTypeAnn>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TsTypeAnn>> { ... }
    fn fold_opt_ts_type_param_decl(
        &mut self,
        node: Option<Box<TsTypeParamDecl>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TsTypeParamDecl>> { ... }
    fn fold_opt_ts_type_param_instantiation(
        &mut self,
        node: Option<Box<TsTypeParamInstantiation>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TsTypeParamInstantiation>> { ... }
    fn fold_opt_var_decl_or_expr(
        &mut self,
        node: Option<VarDeclOrExpr>,
        __ast_path: &mut AstKindPath,
    ) -> Option<VarDeclOrExpr> { ... }
    fn fold_opt_vec_expr_or_spreads(
        &mut self,
        node: Vec<Option<ExprOrSpread>>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Option<ExprOrSpread>> { ... }
    fn fold_opt_vec_pats(
        &mut self,
        node: Vec<Option<Pat>>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Option<Pat>> { ... }
    fn fold_opt_wtf_8_atom(
        &mut self,
        node: Option<Wtf8Atom>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Wtf8Atom> { ... }
    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param { ... }
    fn fold_param_or_ts_param_prop(
        &mut self,
        node: ParamOrTsParamProp,
        __ast_path: &mut AstKindPath,
    ) -> ParamOrTsParamProp { ... }
    fn fold_param_or_ts_param_props(
        &mut self,
        node: Vec<ParamOrTsParamProp>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ParamOrTsParamProp> { ... }
    fn fold_params(
        &mut self,
        node: Vec<Param>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Param> { ... }
    fn fold_paren_expr(
        &mut self,
        node: ParenExpr,
        __ast_path: &mut AstKindPath,
    ) -> ParenExpr { ... }
    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat { ... }
    fn fold_pats(
        &mut self,
        node: Vec<Pat>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Pat> { ... }
    fn fold_private_method(
        &mut self,
        node: PrivateMethod,
        __ast_path: &mut AstKindPath,
    ) -> PrivateMethod { ... }
    fn fold_private_name(
        &mut self,
        node: PrivateName,
        __ast_path: &mut AstKindPath,
    ) -> PrivateName { ... }
    fn fold_private_prop(
        &mut self,
        node: PrivateProp,
        __ast_path: &mut AstKindPath,
    ) -> PrivateProp { ... }
    fn fold_program(
        &mut self,
        node: Program,
        __ast_path: &mut AstKindPath,
    ) -> Program { ... }
    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop { ... }
    fn fold_prop_name(
        &mut self,
        node: PropName,
        __ast_path: &mut AstKindPath,
    ) -> PropName { ... }
    fn fold_prop_or_spread(
        &mut self,
        node: PropOrSpread,
        __ast_path: &mut AstKindPath,
    ) -> PropOrSpread { ... }
    fn fold_prop_or_spreads(
        &mut self,
        node: Vec<PropOrSpread>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<PropOrSpread> { ... }
    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex { ... }
    fn fold_rest_pat(
        &mut self,
        node: RestPat,
        __ast_path: &mut AstKindPath,
    ) -> RestPat { ... }
    fn fold_return_stmt(
        &mut self,
        node: ReturnStmt,
        __ast_path: &mut AstKindPath,
    ) -> ReturnStmt { ... }
    fn fold_script(
        &mut self,
        node: Script,
        __ast_path: &mut AstKindPath,
    ) -> Script { ... }
    fn fold_seq_expr(
        &mut self,
        node: SeqExpr,
        __ast_path: &mut AstKindPath,
    ) -> SeqExpr { ... }
    fn fold_setter_prop(
        &mut self,
        node: SetterProp,
        __ast_path: &mut AstKindPath,
    ) -> SetterProp { ... }
    fn fold_simple_assign_target(
        &mut self,
        node: SimpleAssignTarget,
        __ast_path: &mut AstKindPath,
    ) -> SimpleAssignTarget { ... }
    fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span { ... }
    fn fold_spread_element(
        &mut self,
        node: SpreadElement,
        __ast_path: &mut AstKindPath,
    ) -> SpreadElement { ... }
    fn fold_static_block(
        &mut self,
        node: StaticBlock,
        __ast_path: &mut AstKindPath,
    ) -> StaticBlock { ... }
    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt { ... }
    fn fold_stmts(
        &mut self,
        node: Vec<Stmt>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Stmt> { ... }
    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str { ... }
    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super { ... }
    fn fold_super_prop(
        &mut self,
        node: SuperProp,
        __ast_path: &mut AstKindPath,
    ) -> SuperProp { ... }
    fn fold_super_prop_expr(
        &mut self,
        node: SuperPropExpr,
        __ast_path: &mut AstKindPath,
    ) -> SuperPropExpr { ... }
    fn fold_switch_case(
        &mut self,
        node: SwitchCase,
        __ast_path: &mut AstKindPath,
    ) -> SwitchCase { ... }
    fn fold_switch_cases(
        &mut self,
        node: Vec<SwitchCase>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<SwitchCase> { ... }
    fn fold_switch_stmt(
        &mut self,
        node: SwitchStmt,
        __ast_path: &mut AstKindPath,
    ) -> SwitchStmt { ... }
    fn fold_syntax_context(
        &mut self,
        node: SyntaxContext,
        __ast_path: &mut AstKindPath,
    ) -> SyntaxContext { ... }
    fn fold_tagged_tpl(
        &mut self,
        node: TaggedTpl,
        __ast_path: &mut AstKindPath,
    ) -> TaggedTpl { ... }
    fn fold_this_expr(
        &mut self,
        node: ThisExpr,
        __ast_path: &mut AstKindPath,
    ) -> ThisExpr { ... }
    fn fold_throw_stmt(
        &mut self,
        node: ThrowStmt,
        __ast_path: &mut AstKindPath,
    ) -> ThrowStmt { ... }
    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl { ... }
    fn fold_tpl_element(
        &mut self,
        node: TplElement,
        __ast_path: &mut AstKindPath,
    ) -> TplElement { ... }
    fn fold_tpl_elements(
        &mut self,
        node: Vec<TplElement>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TplElement> { ... }
    fn fold_true_plus_minus(
        &mut self,
        node: TruePlusMinus,
        __ast_path: &mut AstKindPath,
    ) -> TruePlusMinus { ... }
    fn fold_try_stmt(
        &mut self,
        node: TryStmt,
        __ast_path: &mut AstKindPath,
    ) -> TryStmt { ... }
    fn fold_ts_array_type(
        &mut self,
        node: TsArrayType,
        __ast_path: &mut AstKindPath,
    ) -> TsArrayType { ... }
    fn fold_ts_as_expr(
        &mut self,
        node: TsAsExpr,
        __ast_path: &mut AstKindPath,
    ) -> TsAsExpr { ... }
    fn fold_ts_call_signature_decl(
        &mut self,
        node: TsCallSignatureDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsCallSignatureDecl { ... }
    fn fold_ts_conditional_type(
        &mut self,
        node: TsConditionalType,
        __ast_path: &mut AstKindPath,
    ) -> TsConditionalType { ... }
    fn fold_ts_const_assertion(
        &mut self,
        node: TsConstAssertion,
        __ast_path: &mut AstKindPath,
    ) -> TsConstAssertion { ... }
    fn fold_ts_construct_signature_decl(
        &mut self,
        node: TsConstructSignatureDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsConstructSignatureDecl { ... }
    fn fold_ts_constructor_type(
        &mut self,
        node: TsConstructorType,
        __ast_path: &mut AstKindPath,
    ) -> TsConstructorType { ... }
    fn fold_ts_entity_name(
        &mut self,
        node: TsEntityName,
        __ast_path: &mut AstKindPath,
    ) -> TsEntityName { ... }
    fn fold_ts_enum_decl(
        &mut self,
        node: TsEnumDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsEnumDecl { ... }
    fn fold_ts_enum_member(
        &mut self,
        node: TsEnumMember,
        __ast_path: &mut AstKindPath,
    ) -> TsEnumMember { ... }
    fn fold_ts_enum_member_id(
        &mut self,
        node: TsEnumMemberId,
        __ast_path: &mut AstKindPath,
    ) -> TsEnumMemberId { ... }
    fn fold_ts_enum_members(
        &mut self,
        node: Vec<TsEnumMember>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsEnumMember> { ... }
    fn fold_ts_export_assignment(
        &mut self,
        node: TsExportAssignment,
        __ast_path: &mut AstKindPath,
    ) -> TsExportAssignment { ... }
    fn fold_ts_expr_with_type_args(
        &mut self,
        node: TsExprWithTypeArgs,
        __ast_path: &mut AstKindPath,
    ) -> TsExprWithTypeArgs { ... }
    fn fold_ts_expr_with_type_argss(
        &mut self,
        node: Vec<TsExprWithTypeArgs>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsExprWithTypeArgs> { ... }
    fn fold_ts_external_module_ref(
        &mut self,
        node: TsExternalModuleRef,
        __ast_path: &mut AstKindPath,
    ) -> TsExternalModuleRef { ... }
    fn fold_ts_fn_or_constructor_type(
        &mut self,
        node: TsFnOrConstructorType,
        __ast_path: &mut AstKindPath,
    ) -> TsFnOrConstructorType { ... }
    fn fold_ts_fn_param(
        &mut self,
        node: TsFnParam,
        __ast_path: &mut AstKindPath,
    ) -> TsFnParam { ... }
    fn fold_ts_fn_params(
        &mut self,
        node: Vec<TsFnParam>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsFnParam> { ... }
    fn fold_ts_fn_type(
        &mut self,
        node: TsFnType,
        __ast_path: &mut AstKindPath,
    ) -> TsFnType { ... }
    fn fold_ts_getter_signature(
        &mut self,
        node: TsGetterSignature,
        __ast_path: &mut AstKindPath,
    ) -> TsGetterSignature { ... }
    fn fold_ts_import_call_options(
        &mut self,
        node: TsImportCallOptions,
        __ast_path: &mut AstKindPath,
    ) -> TsImportCallOptions { ... }
    fn fold_ts_import_equals_decl(
        &mut self,
        node: TsImportEqualsDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsImportEqualsDecl { ... }
    fn fold_ts_import_type(
        &mut self,
        node: TsImportType,
        __ast_path: &mut AstKindPath,
    ) -> TsImportType { ... }
    fn fold_ts_index_signature(
        &mut self,
        node: TsIndexSignature,
        __ast_path: &mut AstKindPath,
    ) -> TsIndexSignature { ... }
    fn fold_ts_indexed_access_type(
        &mut self,
        node: TsIndexedAccessType,
        __ast_path: &mut AstKindPath,
    ) -> TsIndexedAccessType { ... }
    fn fold_ts_infer_type(
        &mut self,
        node: TsInferType,
        __ast_path: &mut AstKindPath,
    ) -> TsInferType { ... }
    fn fold_ts_instantiation(
        &mut self,
        node: TsInstantiation,
        __ast_path: &mut AstKindPath,
    ) -> TsInstantiation { ... }
    fn fold_ts_interface_body(
        &mut self,
        node: TsInterfaceBody,
        __ast_path: &mut AstKindPath,
    ) -> TsInterfaceBody { ... }
    fn fold_ts_interface_decl(
        &mut self,
        node: TsInterfaceDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsInterfaceDecl { ... }
    fn fold_ts_intersection_type(
        &mut self,
        node: TsIntersectionType,
        __ast_path: &mut AstKindPath,
    ) -> TsIntersectionType { ... }
    fn fold_ts_keyword_type(
        &mut self,
        node: TsKeywordType,
        __ast_path: &mut AstKindPath,
    ) -> TsKeywordType { ... }
    fn fold_ts_keyword_type_kind(
        &mut self,
        node: TsKeywordTypeKind,
        __ast_path: &mut AstKindPath,
    ) -> TsKeywordTypeKind { ... }
    fn fold_ts_lit(
        &mut self,
        node: TsLit,
        __ast_path: &mut AstKindPath,
    ) -> TsLit { ... }
    fn fold_ts_lit_type(
        &mut self,
        node: TsLitType,
        __ast_path: &mut AstKindPath,
    ) -> TsLitType { ... }
    fn fold_ts_mapped_type(
        &mut self,
        node: TsMappedType,
        __ast_path: &mut AstKindPath,
    ) -> TsMappedType { ... }
    fn fold_ts_method_signature(
        &mut self,
        node: TsMethodSignature,
        __ast_path: &mut AstKindPath,
    ) -> TsMethodSignature { ... }
    fn fold_ts_module_block(
        &mut self,
        node: TsModuleBlock,
        __ast_path: &mut AstKindPath,
    ) -> TsModuleBlock { ... }
    fn fold_ts_module_decl(
        &mut self,
        node: TsModuleDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsModuleDecl { ... }
    fn fold_ts_module_name(
        &mut self,
        node: TsModuleName,
        __ast_path: &mut AstKindPath,
    ) -> TsModuleName { ... }
    fn fold_ts_module_ref(
        &mut self,
        node: TsModuleRef,
        __ast_path: &mut AstKindPath,
    ) -> TsModuleRef { ... }
    fn fold_ts_namespace_body(
        &mut self,
        node: TsNamespaceBody,
        __ast_path: &mut AstKindPath,
    ) -> TsNamespaceBody { ... }
    fn fold_ts_namespace_decl(
        &mut self,
        node: TsNamespaceDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsNamespaceDecl { ... }
    fn fold_ts_namespace_export_decl(
        &mut self,
        node: TsNamespaceExportDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsNamespaceExportDecl { ... }
    fn fold_ts_non_null_expr(
        &mut self,
        node: TsNonNullExpr,
        __ast_path: &mut AstKindPath,
    ) -> TsNonNullExpr { ... }
    fn fold_ts_optional_type(
        &mut self,
        node: TsOptionalType,
        __ast_path: &mut AstKindPath,
    ) -> TsOptionalType { ... }
    fn fold_ts_param_prop(
        &mut self,
        node: TsParamProp,
        __ast_path: &mut AstKindPath,
    ) -> TsParamProp { ... }
    fn fold_ts_param_prop_param(
        &mut self,
        node: TsParamPropParam,
        __ast_path: &mut AstKindPath,
    ) -> TsParamPropParam { ... }
    fn fold_ts_parenthesized_type(
        &mut self,
        node: TsParenthesizedType,
        __ast_path: &mut AstKindPath,
    ) -> TsParenthesizedType { ... }
    fn fold_ts_property_signature(
        &mut self,
        node: TsPropertySignature,
        __ast_path: &mut AstKindPath,
    ) -> TsPropertySignature { ... }
    fn fold_ts_qualified_name(
        &mut self,
        node: TsQualifiedName,
        __ast_path: &mut AstKindPath,
    ) -> TsQualifiedName { ... }
    fn fold_ts_rest_type(
        &mut self,
        node: TsRestType,
        __ast_path: &mut AstKindPath,
    ) -> TsRestType { ... }
    fn fold_ts_satisfies_expr(
        &mut self,
        node: TsSatisfiesExpr,
        __ast_path: &mut AstKindPath,
    ) -> TsSatisfiesExpr { ... }
    fn fold_ts_setter_signature(
        &mut self,
        node: TsSetterSignature,
        __ast_path: &mut AstKindPath,
    ) -> TsSetterSignature { ... }
    fn fold_ts_this_param(
        &mut self,
        node: TsThisParam,
        __ast_path: &mut AstKindPath,
    ) -> TsThisParam { ... }
    fn fold_ts_this_type(
        &mut self,
        node: TsThisType,
        __ast_path: &mut AstKindPath,
    ) -> TsThisType { ... }
    fn fold_ts_this_type_or_ident(
        &mut self,
        node: TsThisTypeOrIdent,
        __ast_path: &mut AstKindPath,
    ) -> TsThisTypeOrIdent { ... }
    fn fold_ts_tpl_lit_type(
        &mut self,
        node: TsTplLitType,
        __ast_path: &mut AstKindPath,
    ) -> TsTplLitType { ... }
    fn fold_ts_tuple_element(
        &mut self,
        node: TsTupleElement,
        __ast_path: &mut AstKindPath,
    ) -> TsTupleElement { ... }
    fn fold_ts_tuple_elements(
        &mut self,
        node: Vec<TsTupleElement>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsTupleElement> { ... }
    fn fold_ts_tuple_type(
        &mut self,
        node: TsTupleType,
        __ast_path: &mut AstKindPath,
    ) -> TsTupleType { ... }
    fn fold_ts_type(
        &mut self,
        node: TsType,
        __ast_path: &mut AstKindPath,
    ) -> TsType { ... }
    fn fold_ts_type_alias_decl(
        &mut self,
        node: TsTypeAliasDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeAliasDecl { ... }
    fn fold_ts_type_ann(
        &mut self,
        node: TsTypeAnn,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeAnn { ... }
    fn fold_ts_type_assertion(
        &mut self,
        node: TsTypeAssertion,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeAssertion { ... }
    fn fold_ts_type_element(
        &mut self,
        node: TsTypeElement,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeElement { ... }
    fn fold_ts_type_elements(
        &mut self,
        node: Vec<TsTypeElement>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsTypeElement> { ... }
    fn fold_ts_type_lit(
        &mut self,
        node: TsTypeLit,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeLit { ... }
    fn fold_ts_type_operator(
        &mut self,
        node: TsTypeOperator,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeOperator { ... }
    fn fold_ts_type_operator_op(
        &mut self,
        node: TsTypeOperatorOp,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeOperatorOp { ... }
    fn fold_ts_type_param(
        &mut self,
        node: TsTypeParam,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeParam { ... }
    fn fold_ts_type_param_decl(
        &mut self,
        node: TsTypeParamDecl,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeParamDecl { ... }
    fn fold_ts_type_param_instantiation(
        &mut self,
        node: TsTypeParamInstantiation,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeParamInstantiation { ... }
    fn fold_ts_type_params(
        &mut self,
        node: Vec<TsTypeParam>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<TsTypeParam> { ... }
    fn fold_ts_type_predicate(
        &mut self,
        node: TsTypePredicate,
        __ast_path: &mut AstKindPath,
    ) -> TsTypePredicate { ... }
    fn fold_ts_type_query(
        &mut self,
        node: TsTypeQuery,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeQuery { ... }
    fn fold_ts_type_query_expr(
        &mut self,
        node: TsTypeQueryExpr,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeQueryExpr { ... }
    fn fold_ts_type_ref(
        &mut self,
        node: TsTypeRef,
        __ast_path: &mut AstKindPath,
    ) -> TsTypeRef { ... }
    fn fold_ts_types(
        &mut self,
        node: Vec<Box<TsType>>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Box<TsType>> { ... }
    fn fold_ts_union_or_intersection_type(
        &mut self,
        node: TsUnionOrIntersectionType,
        __ast_path: &mut AstKindPath,
    ) -> TsUnionOrIntersectionType { ... }
    fn fold_ts_union_type(
        &mut self,
        node: TsUnionType,
        __ast_path: &mut AstKindPath,
    ) -> TsUnionType { ... }
    fn fold_unary_expr(
        &mut self,
        node: UnaryExpr,
        __ast_path: &mut AstKindPath,
    ) -> UnaryExpr { ... }
    fn fold_unary_op(
        &mut self,
        node: UnaryOp,
        __ast_path: &mut AstKindPath,
    ) -> UnaryOp { ... }
    fn fold_update_expr(
        &mut self,
        node: UpdateExpr,
        __ast_path: &mut AstKindPath,
    ) -> UpdateExpr { ... }
    fn fold_update_op(
        &mut self,
        node: UpdateOp,
        __ast_path: &mut AstKindPath,
    ) -> UpdateOp { ... }
    fn fold_using_decl(
        &mut self,
        node: UsingDecl,
        __ast_path: &mut AstKindPath,
    ) -> UsingDecl { ... }
    fn fold_var_decl(
        &mut self,
        node: VarDecl,
        __ast_path: &mut AstKindPath,
    ) -> VarDecl { ... }
    fn fold_var_decl_kind(
        &mut self,
        node: VarDeclKind,
        __ast_path: &mut AstKindPath,
    ) -> VarDeclKind { ... }
    fn fold_var_decl_or_expr(
        &mut self,
        node: VarDeclOrExpr,
        __ast_path: &mut AstKindPath,
    ) -> VarDeclOrExpr { ... }
    fn fold_var_declarator(
        &mut self,
        node: VarDeclarator,
        __ast_path: &mut AstKindPath,
    ) -> VarDeclarator { ... }
    fn fold_var_declarators(
        &mut self,
        node: Vec<VarDeclarator>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<VarDeclarator> { ... }
    fn fold_while_stmt(
        &mut self,
        node: WhileStmt,
        __ast_path: &mut AstKindPath,
    ) -> WhileStmt { ... }
    fn fold_with_stmt(
        &mut self,
        node: WithStmt,
        __ast_path: &mut AstKindPath,
    ) -> WithStmt { ... }
    fn fold_wtf_8_atom(
        &mut self,
        node: Wtf8Atom,
        __ast_path: &mut AstKindPath,
    ) -> Wtf8Atom { ... }
    fn fold_yield_expr(
        &mut self,
        node: YieldExpr,
        __ast_path: &mut AstKindPath,
    ) -> YieldExpr { ... }
}

A visitor trait for traversing the AST.

Provided Methods

fn fold_accessibility( &mut self, node: Accessibility, __ast_path: &mut AstKindPath, ) -> Accessibility

Visit a node of type Accessibility.

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

fn fold_array_lit( &mut self, node: ArrayLit, __ast_path: &mut AstKindPath, ) -> ArrayLit

Visit a node of type ArrayLit.

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

fn fold_array_pat( &mut self, node: ArrayPat, __ast_path: &mut AstKindPath, ) -> ArrayPat

Visit a node of type ArrayPat.

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

fn fold_arrow_expr( &mut self, node: ArrowExpr, __ast_path: &mut AstKindPath, ) -> ArrowExpr

Visit a node of type ArrowExpr.

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

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, __ast_path: &mut AstKindPath, ) -> ArrowFunctionBody

Visit a node of type ArrowFunctionBody.

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

fn fold_assign_expr( &mut self, node: AssignExpr, __ast_path: &mut AstKindPath, ) -> AssignExpr

Visit a node of type AssignExpr.

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

fn fold_assign_op( &mut self, node: AssignOp, __ast_path: &mut AstKindPath, ) -> AssignOp

Visit a node of type AssignOp.

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

fn fold_assign_pat( &mut self, node: AssignPat, __ast_path: &mut AstKindPath, ) -> AssignPat

Visit a node of type AssignPat.

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

fn fold_assign_pat_prop( &mut self, node: AssignPatProp, __ast_path: &mut AstKindPath, ) -> AssignPatProp

Visit a node of type AssignPatProp.

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

fn fold_assign_prop( &mut self, node: AssignProp, __ast_path: &mut AstKindPath, ) -> AssignProp

Visit a node of type AssignProp.

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

fn fold_assign_target( &mut self, node: AssignTarget, __ast_path: &mut AstKindPath, ) -> AssignTarget

Visit a node of type AssignTarget.

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

fn fold_assign_target_pat( &mut self, node: AssignTargetPat, __ast_path: &mut AstKindPath, ) -> AssignTargetPat

Visit a node of type AssignTargetPat.

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

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

Visit a node of type swc_atoms :: Atom.

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

fn fold_auto_accessor( &mut self, node: AutoAccessor, __ast_path: &mut AstKindPath, ) -> AutoAccessor

Visit a node of type AutoAccessor.

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

fn fold_await_expr( &mut self, node: AwaitExpr, __ast_path: &mut AstKindPath, ) -> AwaitExpr

Visit a node of type AwaitExpr.

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

fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt

Visit a node of type BigInt.

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

fn fold_big_int_value( &mut self, node: BigIntValue, __ast_path: &mut AstKindPath, ) -> BigIntValue

Visit a node of type BigIntValue.

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

fn fold_bin_expr( &mut self, node: BinExpr, __ast_path: &mut AstKindPath, ) -> BinExpr

Visit a node of type BinExpr.

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

fn fold_binary_op( &mut self, node: BinaryOp, __ast_path: &mut AstKindPath, ) -> BinaryOp

Visit a node of type BinaryOp.

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

fn fold_binding_ident( &mut self, node: BindingIdent, __ast_path: &mut AstKindPath, ) -> BindingIdent

Visit a node of type BindingIdent.

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

fn fold_block_stmt( &mut self, node: BlockStmt, __ast_path: &mut AstKindPath, ) -> BlockStmt

Visit a node of type BlockStmt.

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

fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool

Visit a node of type Bool.

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

fn fold_break_stmt( &mut self, node: BreakStmt, __ast_path: &mut AstKindPath, ) -> BreakStmt

Visit a node of type BreakStmt.

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

fn fold_call_expr( &mut self, node: CallExpr, __ast_path: &mut AstKindPath, ) -> CallExpr

Visit a node of type CallExpr.

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

fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee

Visit a node of type Callee.

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

fn fold_catch_clause( &mut self, node: CatchClause, __ast_path: &mut AstKindPath, ) -> CatchClause

Visit a node of type CatchClause.

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

fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class

Visit a node of type Class.

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

fn fold_class_decl( &mut self, node: ClassDecl, __ast_path: &mut AstKindPath, ) -> ClassDecl

Visit a node of type ClassDecl.

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

fn fold_class_expr( &mut self, node: ClassExpr, __ast_path: &mut AstKindPath, ) -> ClassExpr

Visit a node of type ClassExpr.

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

fn fold_class_member( &mut self, node: ClassMember, __ast_path: &mut AstKindPath, ) -> ClassMember

Visit a node of type ClassMember.

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

fn fold_class_members( &mut self, node: Vec<ClassMember>, __ast_path: &mut AstKindPath, ) -> Vec<ClassMember>

Visit a node of type Vec < ClassMember >.

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

fn fold_class_method( &mut self, node: ClassMethod, __ast_path: &mut AstKindPath, ) -> ClassMethod

Visit a node of type ClassMethod.

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

fn fold_class_prop( &mut self, node: ClassProp, __ast_path: &mut AstKindPath, ) -> ClassProp

Visit a node of type ClassProp.

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

fn fold_computed_prop_name( &mut self, node: ComputedPropName, __ast_path: &mut AstKindPath, ) -> ComputedPropName

Visit a node of type ComputedPropName.

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

fn fold_cond_expr( &mut self, node: CondExpr, __ast_path: &mut AstKindPath, ) -> CondExpr

Visit a node of type CondExpr.

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

fn fold_constructor( &mut self, node: Constructor, __ast_path: &mut AstKindPath, ) -> Constructor

Visit a node of type Constructor.

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

fn fold_continue_stmt( &mut self, node: ContinueStmt, __ast_path: &mut AstKindPath, ) -> ContinueStmt

Visit a node of type ContinueStmt.

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

fn fold_debugger_stmt( &mut self, node: DebuggerStmt, __ast_path: &mut AstKindPath, ) -> DebuggerStmt

Visit a node of type DebuggerStmt.

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

fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl

Visit a node of type Decl.

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

fn fold_decorator( &mut self, node: Decorator, __ast_path: &mut AstKindPath, ) -> Decorator

Visit a node of type Decorator.

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

fn fold_decorators( &mut self, node: Vec<Decorator>, __ast_path: &mut AstKindPath, ) -> Vec<Decorator>

Visit a node of type Vec < Decorator >.

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

fn fold_default_decl( &mut self, node: DefaultDecl, __ast_path: &mut AstKindPath, ) -> DefaultDecl

Visit a node of type DefaultDecl.

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

fn fold_do_while_stmt( &mut self, node: DoWhileStmt, __ast_path: &mut AstKindPath, ) -> DoWhileStmt

Visit a node of type DoWhileStmt.

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

fn fold_empty_stmt( &mut self, node: EmptyStmt, __ast_path: &mut AstKindPath, ) -> EmptyStmt

Visit a node of type EmptyStmt.

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

fn fold_export_all( &mut self, node: ExportAll, __ast_path: &mut AstKindPath, ) -> ExportAll

Visit a node of type ExportAll.

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

fn fold_export_decl( &mut self, node: ExportDecl, __ast_path: &mut AstKindPath, ) -> ExportDecl

Visit a node of type ExportDecl.

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

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, __ast_path: &mut AstKindPath, ) -> ExportDefaultDecl

Visit a node of type ExportDefaultDecl.

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

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, __ast_path: &mut AstKindPath, ) -> ExportDefaultExpr

Visit a node of type ExportDefaultExpr.

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

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ExportDefaultSpecifier

Visit a node of type ExportDefaultSpecifier.

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

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamedSpecifier

Visit a node of type ExportNamedSpecifier.

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

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamespaceSpecifier

Visit a node of type ExportNamespaceSpecifier.

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

fn fold_export_specifier( &mut self, node: ExportSpecifier, __ast_path: &mut AstKindPath, ) -> ExportSpecifier

Visit a node of type ExportSpecifier.

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

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ExportSpecifier>

Visit a node of type Vec < ExportSpecifier >.

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

fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr

Visit a node of type Expr.

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

fn fold_expr_or_spread( &mut self, node: ExprOrSpread, __ast_path: &mut AstKindPath, ) -> ExprOrSpread

Visit a node of type ExprOrSpread.

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

fn fold_expr_or_spreads( &mut self, node: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<ExprOrSpread>

Visit a node of type Vec < ExprOrSpread >.

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

fn fold_expr_stmt( &mut self, node: ExprStmt, __ast_path: &mut AstKindPath, ) -> ExprStmt

Visit a node of type ExprStmt.

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

fn fold_exprs( &mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<Expr>>

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

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

fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

Visit a node of type FnDecl.

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

fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

Visit a node of type FnExpr.

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

fn fold_for_head( &mut self, node: ForHead, __ast_path: &mut AstKindPath, ) -> ForHead

Visit a node of type ForHead.

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

fn fold_for_in_stmt( &mut self, node: ForInStmt, __ast_path: &mut AstKindPath, ) -> ForInStmt

Visit a node of type ForInStmt.

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

fn fold_for_of_stmt( &mut self, node: ForOfStmt, __ast_path: &mut AstKindPath, ) -> ForOfStmt

Visit a node of type ForOfStmt.

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

fn fold_for_stmt( &mut self, node: ForStmt, __ast_path: &mut AstKindPath, ) -> ForStmt

Visit a node of type ForStmt.

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

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

Visit a node of type Function.

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

fn fold_function_body( &mut self, node: FunctionBody, __ast_path: &mut AstKindPath, ) -> FunctionBody

Visit a node of type FunctionBody.

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

fn fold_getter_prop( &mut self, node: GetterProp, __ast_path: &mut AstKindPath, ) -> GetterProp

Visit a node of type GetterProp.

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

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

Visit a node of type Ident.

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

fn fold_ident_name( &mut self, node: IdentName, __ast_path: &mut AstKindPath, ) -> IdentName

Visit a node of type IdentName.

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

fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

Visit a node of type IfStmt.

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

fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import

Visit a node of type Import.

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

fn fold_import_decl( &mut self, node: ImportDecl, __ast_path: &mut AstKindPath, ) -> ImportDecl

Visit a node of type ImportDecl.

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

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ImportDefaultSpecifier

Visit a node of type ImportDefaultSpecifier.

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

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ImportNamedSpecifier

Visit a node of type ImportNamedSpecifier.

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

fn fold_import_phase( &mut self, node: ImportPhase, __ast_path: &mut AstKindPath, ) -> ImportPhase

Visit a node of type ImportPhase.

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

fn fold_import_specifier( &mut self, node: ImportSpecifier, __ast_path: &mut AstKindPath, ) -> ImportSpecifier

Visit a node of type ImportSpecifier.

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

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ImportSpecifier>

Visit a node of type Vec < ImportSpecifier >.

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

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, __ast_path: &mut AstKindPath, ) -> ImportStarAsSpecifier

Visit a node of type ImportStarAsSpecifier.

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

fn fold_import_with( &mut self, node: ImportWith, __ast_path: &mut AstKindPath, ) -> ImportWith

Visit a node of type ImportWith.

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

fn fold_import_with_item( &mut self, node: ImportWithItem, __ast_path: &mut AstKindPath, ) -> ImportWithItem

Visit a node of type ImportWithItem.

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

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, __ast_path: &mut AstKindPath, ) -> Vec<ImportWithItem>

Visit a node of type Vec < ImportWithItem >.

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

fn fold_invalid( &mut self, node: Invalid, __ast_path: &mut AstKindPath, ) -> Invalid

Visit a node of type Invalid.

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

fn fold_jsx_attr( &mut self, node: JSXAttr, __ast_path: &mut AstKindPath, ) -> JSXAttr

Visit a node of type JSXAttr.

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

fn fold_jsx_attr_name( &mut self, node: JSXAttrName, __ast_path: &mut AstKindPath, ) -> JSXAttrName

Visit a node of type JSXAttrName.

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

fn fold_jsx_attr_or_spread( &mut self, node: JSXAttrOrSpread, __ast_path: &mut AstKindPath, ) -> JSXAttrOrSpread

Visit a node of type JSXAttrOrSpread.

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

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<JSXAttrOrSpread>

Visit a node of type Vec < JSXAttrOrSpread >.

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

fn fold_jsx_attr_value( &mut self, node: JSXAttrValue, __ast_path: &mut AstKindPath, ) -> JSXAttrValue

Visit a node of type JSXAttrValue.

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

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, __ast_path: &mut AstKindPath, ) -> JSXClosingElement

Visit a node of type JSXClosingElement.

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

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, __ast_path: &mut AstKindPath, ) -> JSXClosingFragment

Visit a node of type JSXClosingFragment.

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

fn fold_jsx_element( &mut self, node: JSXElement, __ast_path: &mut AstKindPath, ) -> JSXElement

Visit a node of type JSXElement.

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

fn fold_jsx_element_child( &mut self, node: JSXElementChild, __ast_path: &mut AstKindPath, ) -> JSXElementChild

Visit a node of type JSXElementChild.

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

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, __ast_path: &mut AstKindPath, ) -> Vec<JSXElementChild>

Visit a node of type Vec < JSXElementChild >.

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

fn fold_jsx_element_name( &mut self, node: JSXElementName, __ast_path: &mut AstKindPath, ) -> JSXElementName

Visit a node of type JSXElementName.

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

fn fold_jsx_empty_expr( &mut self, node: JSXEmptyExpr, __ast_path: &mut AstKindPath, ) -> JSXEmptyExpr

Visit a node of type JSXEmptyExpr.

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

fn fold_jsx_expr( &mut self, node: JSXExpr, __ast_path: &mut AstKindPath, ) -> JSXExpr

Visit a node of type JSXExpr.

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

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, __ast_path: &mut AstKindPath, ) -> JSXExprContainer

Visit a node of type JSXExprContainer.

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

fn fold_jsx_fragment( &mut self, node: JSXFragment, __ast_path: &mut AstKindPath, ) -> JSXFragment

Visit a node of type JSXFragment.

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

fn fold_jsx_member_expr( &mut self, node: JSXMemberExpr, __ast_path: &mut AstKindPath, ) -> JSXMemberExpr

Visit a node of type JSXMemberExpr.

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

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, __ast_path: &mut AstKindPath, ) -> JSXNamespacedName

Visit a node of type JSXNamespacedName.

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

fn fold_jsx_object( &mut self, node: JSXObject, __ast_path: &mut AstKindPath, ) -> JSXObject

Visit a node of type JSXObject.

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

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, __ast_path: &mut AstKindPath, ) -> JSXOpeningElement

Visit a node of type JSXOpeningElement.

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

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, __ast_path: &mut AstKindPath, ) -> JSXOpeningFragment

Visit a node of type JSXOpeningFragment.

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

fn fold_jsx_spread_child( &mut self, node: JSXSpreadChild, __ast_path: &mut AstKindPath, ) -> JSXSpreadChild

Visit a node of type JSXSpreadChild.

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

fn fold_jsx_text( &mut self, node: JSXText, __ast_path: &mut AstKindPath, ) -> JSXText

Visit a node of type JSXText.

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

fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key

Visit a node of type Key.

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

fn fold_key_value_pat_prop( &mut self, node: KeyValuePatProp, __ast_path: &mut AstKindPath, ) -> KeyValuePatProp

Visit a node of type KeyValuePatProp.

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

fn fold_key_value_prop( &mut self, node: KeyValueProp, __ast_path: &mut AstKindPath, ) -> KeyValueProp

Visit a node of type KeyValueProp.

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

fn fold_labeled_stmt( &mut self, node: LabeledStmt, __ast_path: &mut AstKindPath, ) -> LabeledStmt

Visit a node of type LabeledStmt.

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

fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit

Visit a node of type Lit.

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

fn fold_member_expr( &mut self, node: MemberExpr, __ast_path: &mut AstKindPath, ) -> MemberExpr

Visit a node of type MemberExpr.

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

fn fold_member_prop( &mut self, node: MemberProp, __ast_path: &mut AstKindPath, ) -> MemberProp

Visit a node of type MemberProp.

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

fn fold_meta_prop_expr( &mut self, node: MetaPropExpr, __ast_path: &mut AstKindPath, ) -> MetaPropExpr

Visit a node of type MetaPropExpr.

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

fn fold_meta_prop_kind( &mut self, node: MetaPropKind, __ast_path: &mut AstKindPath, ) -> MetaPropKind

Visit a node of type MetaPropKind.

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

fn fold_method_kind( &mut self, node: MethodKind, __ast_path: &mut AstKindPath, ) -> MethodKind

Visit a node of type MethodKind.

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

fn fold_method_prop( &mut self, node: MethodProp, __ast_path: &mut AstKindPath, ) -> MethodProp

Visit a node of type MethodProp.

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

fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module

Visit a node of type Module.

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

fn fold_module_decl( &mut self, node: ModuleDecl, __ast_path: &mut AstKindPath, ) -> ModuleDecl

Visit a node of type ModuleDecl.

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

fn fold_module_export_name( &mut self, node: ModuleExportName, __ast_path: &mut AstKindPath, ) -> ModuleExportName

Visit a node of type ModuleExportName.

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

fn fold_module_item( &mut self, node: ModuleItem, __ast_path: &mut AstKindPath, ) -> ModuleItem

Visit a node of type ModuleItem.

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

fn fold_module_items( &mut self, node: Vec<ModuleItem>, __ast_path: &mut AstKindPath, ) -> Vec<ModuleItem>

Visit a node of type Vec < ModuleItem >.

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

fn fold_named_export( &mut self, node: NamedExport, __ast_path: &mut AstKindPath, ) -> NamedExport

Visit a node of type NamedExport.

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

fn fold_new_expr( &mut self, node: NewExpr, __ast_path: &mut AstKindPath, ) -> NewExpr

Visit a node of type NewExpr.

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

fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null

Visit a node of type Null.

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

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

Visit a node of type Number.

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

fn fold_object_lit( &mut self, node: ObjectLit, __ast_path: &mut AstKindPath, ) -> ObjectLit

Visit a node of type ObjectLit.

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

fn fold_object_pat( &mut self, node: ObjectPat, __ast_path: &mut AstKindPath, ) -> ObjectPat

Visit a node of type ObjectPat.

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

fn fold_object_pat_prop( &mut self, node: ObjectPatProp, __ast_path: &mut AstKindPath, ) -> ObjectPatProp

Visit a node of type ObjectPatProp.

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

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, __ast_path: &mut AstKindPath, ) -> Vec<ObjectPatProp>

Visit a node of type Vec < ObjectPatProp >.

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

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, __ast_path: &mut AstKindPath, ) -> Option<Accessibility>

Visit a node of type Option < Accessibility >.

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

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

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

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

fn fold_opt_block_stmt( &mut self, node: Option<BlockStmt>, __ast_path: &mut AstKindPath, ) -> Option<BlockStmt>

Visit a node of type Option < BlockStmt >.

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

fn fold_opt_call( &mut self, node: OptCall, __ast_path: &mut AstKindPath, ) -> OptCall

Visit a node of type OptCall.

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

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, __ast_path: &mut AstKindPath, ) -> Option<CatchClause>

Visit a node of type Option < CatchClause >.

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

fn fold_opt_chain_base( &mut self, node: OptChainBase, __ast_path: &mut AstKindPath, ) -> OptChainBase

Visit a node of type OptChainBase.

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

fn fold_opt_chain_expr( &mut self, node: OptChainExpr, __ast_path: &mut AstKindPath, ) -> OptChainExpr

Visit a node of type OptChainExpr.

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

fn fold_opt_expr( &mut self, node: Option<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Expr>>

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

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

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Option<ExprOrSpread>

Visit a node of type Option < ExprOrSpread >.

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

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<ExprOrSpread>>

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

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

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, __ast_path: &mut AstKindPath, ) -> Option<FunctionBody>

Visit a node of type Option < FunctionBody >.

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

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

Visit a node of type Option < Ident >.

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

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, __ast_path: &mut AstKindPath, ) -> Option<JSXAttrValue>

Visit a node of type Option < JSXAttrValue >.

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

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, __ast_path: &mut AstKindPath, ) -> Option<JSXClosingElement>

Visit a node of type Option < JSXClosingElement >.

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

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, __ast_path: &mut AstKindPath, ) -> Option<ModuleExportName>

Visit a node of type Option < ModuleExportName >.

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

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ObjectLit>>

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

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

fn fold_opt_pat( &mut self, node: Option<Pat>, __ast_path: &mut AstKindPath, ) -> Option<Pat>

Visit a node of type Option < Pat >.

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

fn fold_opt_span( &mut self, node: Option<Span>, __ast_path: &mut AstKindPath, ) -> Option<Span>

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

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

fn fold_opt_stmt( &mut self, node: Option<Box<Stmt>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Stmt>>

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

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

fn fold_opt_str( &mut self, node: Option<Box<Str>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Str>>

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

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

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, __ast_path: &mut AstKindPath, ) -> Option<TruePlusMinus>

Visit a node of type Option < TruePlusMinus >.

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

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, __ast_path: &mut AstKindPath, ) -> Option<TsEntityName>

Visit a node of type Option < TsEntityName >.

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

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, __ast_path: &mut AstKindPath, ) -> Option<TsImportCallOptions>

Visit a node of type Option < TsImportCallOptions >.

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

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, __ast_path: &mut AstKindPath, ) -> Option<TsNamespaceBody>

Visit a node of type Option < TsNamespaceBody >.

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

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsThisParam>>

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

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

fn fold_opt_ts_type( &mut self, node: Option<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsType>>

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

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

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeAnn>>

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

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

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamDecl>>

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

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

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamInstantiation>>

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

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

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, __ast_path: &mut AstKindPath, ) -> Option<VarDeclOrExpr>

Visit a node of type Option < VarDeclOrExpr >.

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

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<ExprOrSpread>>

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

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

fn fold_opt_vec_pats( &mut self, node: Vec<Option<Pat>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<Pat>>

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

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

fn fold_opt_wtf_8_atom( &mut self, node: Option<Wtf8Atom>, __ast_path: &mut AstKindPath, ) -> Option<Wtf8Atom>

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

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

fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param

Visit a node of type Param.

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

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, __ast_path: &mut AstKindPath, ) -> ParamOrTsParamProp

Visit a node of type ParamOrTsParamProp.

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

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, __ast_path: &mut AstKindPath, ) -> Vec<ParamOrTsParamProp>

Visit a node of type Vec < ParamOrTsParamProp >.

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

fn fold_params( &mut self, node: Vec<Param>, __ast_path: &mut AstKindPath, ) -> Vec<Param>

Visit a node of type Vec < Param >.

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

fn fold_paren_expr( &mut self, node: ParenExpr, __ast_path: &mut AstKindPath, ) -> ParenExpr

Visit a node of type ParenExpr.

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

fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat

Visit a node of type Pat.

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

fn fold_pats( &mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath, ) -> Vec<Pat>

Visit a node of type Vec < Pat >.

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

fn fold_private_method( &mut self, node: PrivateMethod, __ast_path: &mut AstKindPath, ) -> PrivateMethod

Visit a node of type PrivateMethod.

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

fn fold_private_name( &mut self, node: PrivateName, __ast_path: &mut AstKindPath, ) -> PrivateName

Visit a node of type PrivateName.

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

fn fold_private_prop( &mut self, node: PrivateProp, __ast_path: &mut AstKindPath, ) -> PrivateProp

Visit a node of type PrivateProp.

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

fn fold_program( &mut self, node: Program, __ast_path: &mut AstKindPath, ) -> Program

Visit a node of type Program.

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

fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop

Visit a node of type Prop.

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

fn fold_prop_name( &mut self, node: PropName, __ast_path: &mut AstKindPath, ) -> PropName

Visit a node of type PropName.

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

fn fold_prop_or_spread( &mut self, node: PropOrSpread, __ast_path: &mut AstKindPath, ) -> PropOrSpread

Visit a node of type PropOrSpread.

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

fn fold_prop_or_spreads( &mut self, node: Vec<PropOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<PropOrSpread>

Visit a node of type Vec < PropOrSpread >.

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

fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex

Visit a node of type Regex.

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

fn fold_rest_pat( &mut self, node: RestPat, __ast_path: &mut AstKindPath, ) -> RestPat

Visit a node of type RestPat.

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

fn fold_return_stmt( &mut self, node: ReturnStmt, __ast_path: &mut AstKindPath, ) -> ReturnStmt

Visit a node of type ReturnStmt.

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

fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script

Visit a node of type Script.

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

fn fold_seq_expr( &mut self, node: SeqExpr, __ast_path: &mut AstKindPath, ) -> SeqExpr

Visit a node of type SeqExpr.

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

fn fold_setter_prop( &mut self, node: SetterProp, __ast_path: &mut AstKindPath, ) -> SetterProp

Visit a node of type SetterProp.

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

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, __ast_path: &mut AstKindPath, ) -> SimpleAssignTarget

Visit a node of type SimpleAssignTarget.

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

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

Visit a node of type swc_common :: Span.

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

fn fold_spread_element( &mut self, node: SpreadElement, __ast_path: &mut AstKindPath, ) -> SpreadElement

Visit a node of type SpreadElement.

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

fn fold_static_block( &mut self, node: StaticBlock, __ast_path: &mut AstKindPath, ) -> StaticBlock

Visit a node of type StaticBlock.

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

fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt

Visit a node of type Stmt.

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

fn fold_stmts( &mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath, ) -> Vec<Stmt>

Visit a node of type Vec < Stmt >.

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

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

Visit a node of type Str.

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

fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super

Visit a node of type Super.

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

fn fold_super_prop( &mut self, node: SuperProp, __ast_path: &mut AstKindPath, ) -> SuperProp

Visit a node of type SuperProp.

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

fn fold_super_prop_expr( &mut self, node: SuperPropExpr, __ast_path: &mut AstKindPath, ) -> SuperPropExpr

Visit a node of type SuperPropExpr.

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

fn fold_switch_case( &mut self, node: SwitchCase, __ast_path: &mut AstKindPath, ) -> SwitchCase

Visit a node of type SwitchCase.

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

fn fold_switch_cases( &mut self, node: Vec<SwitchCase>, __ast_path: &mut AstKindPath, ) -> Vec<SwitchCase>

Visit a node of type Vec < SwitchCase >.

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

fn fold_switch_stmt( &mut self, node: SwitchStmt, __ast_path: &mut AstKindPath, ) -> SwitchStmt

Visit a node of type SwitchStmt.

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

fn fold_syntax_context( &mut self, node: SyntaxContext, __ast_path: &mut AstKindPath, ) -> SyntaxContext

Visit a node of type swc_common :: SyntaxContext.

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

fn fold_tagged_tpl( &mut self, node: TaggedTpl, __ast_path: &mut AstKindPath, ) -> TaggedTpl

Visit a node of type TaggedTpl.

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

fn fold_this_expr( &mut self, node: ThisExpr, __ast_path: &mut AstKindPath, ) -> ThisExpr

Visit a node of type ThisExpr.

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

fn fold_throw_stmt( &mut self, node: ThrowStmt, __ast_path: &mut AstKindPath, ) -> ThrowStmt

Visit a node of type ThrowStmt.

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

fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl

Visit a node of type Tpl.

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

fn fold_tpl_element( &mut self, node: TplElement, __ast_path: &mut AstKindPath, ) -> TplElement

Visit a node of type TplElement.

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

fn fold_tpl_elements( &mut self, node: Vec<TplElement>, __ast_path: &mut AstKindPath, ) -> Vec<TplElement>

Visit a node of type Vec < TplElement >.

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

fn fold_true_plus_minus( &mut self, node: TruePlusMinus, __ast_path: &mut AstKindPath, ) -> TruePlusMinus

Visit a node of type TruePlusMinus.

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

fn fold_try_stmt( &mut self, node: TryStmt, __ast_path: &mut AstKindPath, ) -> TryStmt

Visit a node of type TryStmt.

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

fn fold_ts_array_type( &mut self, node: TsArrayType, __ast_path: &mut AstKindPath, ) -> TsArrayType

Visit a node of type TsArrayType.

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

fn fold_ts_as_expr( &mut self, node: TsAsExpr, __ast_path: &mut AstKindPath, ) -> TsAsExpr

Visit a node of type TsAsExpr.

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

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsCallSignatureDecl

Visit a node of type TsCallSignatureDecl.

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

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, __ast_path: &mut AstKindPath, ) -> TsConditionalType

Visit a node of type TsConditionalType.

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

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, __ast_path: &mut AstKindPath, ) -> TsConstAssertion

Visit a node of type TsConstAssertion.

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

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsConstructSignatureDecl

Visit a node of type TsConstructSignatureDecl.

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

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, __ast_path: &mut AstKindPath, ) -> TsConstructorType

Visit a node of type TsConstructorType.

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

fn fold_ts_entity_name( &mut self, node: TsEntityName, __ast_path: &mut AstKindPath, ) -> TsEntityName

Visit a node of type TsEntityName.

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

fn fold_ts_enum_decl( &mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath, ) -> TsEnumDecl

Visit a node of type TsEnumDecl.

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

fn fold_ts_enum_member( &mut self, node: TsEnumMember, __ast_path: &mut AstKindPath, ) -> TsEnumMember

Visit a node of type TsEnumMember.

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

fn fold_ts_enum_member_id( &mut self, node: TsEnumMemberId, __ast_path: &mut AstKindPath, ) -> TsEnumMemberId

Visit a node of type TsEnumMemberId.

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

fn fold_ts_enum_members( &mut self, node: Vec<TsEnumMember>, __ast_path: &mut AstKindPath, ) -> Vec<TsEnumMember>

Visit a node of type Vec < TsEnumMember >.

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

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, __ast_path: &mut AstKindPath, ) -> TsExportAssignment

Visit a node of type TsExportAssignment.

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

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, __ast_path: &mut AstKindPath, ) -> TsExprWithTypeArgs

Visit a node of type TsExprWithTypeArgs.

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

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, __ast_path: &mut AstKindPath, ) -> Vec<TsExprWithTypeArgs>

Visit a node of type Vec < TsExprWithTypeArgs >.

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

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, __ast_path: &mut AstKindPath, ) -> TsExternalModuleRef

Visit a node of type TsExternalModuleRef.

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

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, __ast_path: &mut AstKindPath, ) -> TsFnOrConstructorType

Visit a node of type TsFnOrConstructorType.

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

fn fold_ts_fn_param( &mut self, node: TsFnParam, __ast_path: &mut AstKindPath, ) -> TsFnParam

Visit a node of type TsFnParam.

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

fn fold_ts_fn_params( &mut self, node: Vec<TsFnParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsFnParam>

Visit a node of type Vec < TsFnParam >.

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

fn fold_ts_fn_type( &mut self, node: TsFnType, __ast_path: &mut AstKindPath, ) -> TsFnType

Visit a node of type TsFnType.

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

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, __ast_path: &mut AstKindPath, ) -> TsGetterSignature

Visit a node of type TsGetterSignature.

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

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, __ast_path: &mut AstKindPath, ) -> TsImportCallOptions

Visit a node of type TsImportCallOptions.

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

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, __ast_path: &mut AstKindPath, ) -> TsImportEqualsDecl

Visit a node of type TsImportEqualsDecl.

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

fn fold_ts_import_type( &mut self, node: TsImportType, __ast_path: &mut AstKindPath, ) -> TsImportType

Visit a node of type TsImportType.

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

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, __ast_path: &mut AstKindPath, ) -> TsIndexSignature

Visit a node of type TsIndexSignature.

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

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, __ast_path: &mut AstKindPath, ) -> TsIndexedAccessType

Visit a node of type TsIndexedAccessType.

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

fn fold_ts_infer_type( &mut self, node: TsInferType, __ast_path: &mut AstKindPath, ) -> TsInferType

Visit a node of type TsInferType.

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

fn fold_ts_instantiation( &mut self, node: TsInstantiation, __ast_path: &mut AstKindPath, ) -> TsInstantiation

Visit a node of type TsInstantiation.

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

fn fold_ts_interface_body( &mut self, node: TsInterfaceBody, __ast_path: &mut AstKindPath, ) -> TsInterfaceBody

Visit a node of type TsInterfaceBody.

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

fn fold_ts_interface_decl( &mut self, node: TsInterfaceDecl, __ast_path: &mut AstKindPath, ) -> TsInterfaceDecl

Visit a node of type TsInterfaceDecl.

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

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, __ast_path: &mut AstKindPath, ) -> TsIntersectionType

Visit a node of type TsIntersectionType.

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

fn fold_ts_keyword_type( &mut self, node: TsKeywordType, __ast_path: &mut AstKindPath, ) -> TsKeywordType

Visit a node of type TsKeywordType.

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

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, __ast_path: &mut AstKindPath, ) -> TsKeywordTypeKind

Visit a node of type TsKeywordTypeKind.

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

fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit

Visit a node of type TsLit.

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

fn fold_ts_lit_type( &mut self, node: TsLitType, __ast_path: &mut AstKindPath, ) -> TsLitType

Visit a node of type TsLitType.

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

fn fold_ts_mapped_type( &mut self, node: TsMappedType, __ast_path: &mut AstKindPath, ) -> TsMappedType

Visit a node of type TsMappedType.

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

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, __ast_path: &mut AstKindPath, ) -> TsMethodSignature

Visit a node of type TsMethodSignature.

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

fn fold_ts_module_block( &mut self, node: TsModuleBlock, __ast_path: &mut AstKindPath, ) -> TsModuleBlock

Visit a node of type TsModuleBlock.

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

fn fold_ts_module_decl( &mut self, node: TsModuleDecl, __ast_path: &mut AstKindPath, ) -> TsModuleDecl

Visit a node of type TsModuleDecl.

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

fn fold_ts_module_name( &mut self, node: TsModuleName, __ast_path: &mut AstKindPath, ) -> TsModuleName

Visit a node of type TsModuleName.

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

fn fold_ts_module_ref( &mut self, node: TsModuleRef, __ast_path: &mut AstKindPath, ) -> TsModuleRef

Visit a node of type TsModuleRef.

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

fn fold_ts_namespace_body( &mut self, node: TsNamespaceBody, __ast_path: &mut AstKindPath, ) -> TsNamespaceBody

Visit a node of type TsNamespaceBody.

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

fn fold_ts_namespace_decl( &mut self, node: TsNamespaceDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceDecl

Visit a node of type TsNamespaceDecl.

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

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceExportDecl

Visit a node of type TsNamespaceExportDecl.

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

fn fold_ts_non_null_expr( &mut self, node: TsNonNullExpr, __ast_path: &mut AstKindPath, ) -> TsNonNullExpr

Visit a node of type TsNonNullExpr.

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

fn fold_ts_optional_type( &mut self, node: TsOptionalType, __ast_path: &mut AstKindPath, ) -> TsOptionalType

Visit a node of type TsOptionalType.

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

fn fold_ts_param_prop( &mut self, node: TsParamProp, __ast_path: &mut AstKindPath, ) -> TsParamProp

Visit a node of type TsParamProp.

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

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, __ast_path: &mut AstKindPath, ) -> TsParamPropParam

Visit a node of type TsParamPropParam.

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

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, __ast_path: &mut AstKindPath, ) -> TsParenthesizedType

Visit a node of type TsParenthesizedType.

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

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, __ast_path: &mut AstKindPath, ) -> TsPropertySignature

Visit a node of type TsPropertySignature.

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

fn fold_ts_qualified_name( &mut self, node: TsQualifiedName, __ast_path: &mut AstKindPath, ) -> TsQualifiedName

Visit a node of type TsQualifiedName.

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

fn fold_ts_rest_type( &mut self, node: TsRestType, __ast_path: &mut AstKindPath, ) -> TsRestType

Visit a node of type TsRestType.

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

fn fold_ts_satisfies_expr( &mut self, node: TsSatisfiesExpr, __ast_path: &mut AstKindPath, ) -> TsSatisfiesExpr

Visit a node of type TsSatisfiesExpr.

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

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, __ast_path: &mut AstKindPath, ) -> TsSetterSignature

Visit a node of type TsSetterSignature.

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

fn fold_ts_this_param( &mut self, node: TsThisParam, __ast_path: &mut AstKindPath, ) -> TsThisParam

Visit a node of type TsThisParam.

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

fn fold_ts_this_type( &mut self, node: TsThisType, __ast_path: &mut AstKindPath, ) -> TsThisType

Visit a node of type TsThisType.

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

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, __ast_path: &mut AstKindPath, ) -> TsThisTypeOrIdent

Visit a node of type TsThisTypeOrIdent.

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

fn fold_ts_tpl_lit_type( &mut self, node: TsTplLitType, __ast_path: &mut AstKindPath, ) -> TsTplLitType

Visit a node of type TsTplLitType.

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

fn fold_ts_tuple_element( &mut self, node: TsTupleElement, __ast_path: &mut AstKindPath, ) -> TsTupleElement

Visit a node of type TsTupleElement.

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

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTupleElement>

Visit a node of type Vec < TsTupleElement >.

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

fn fold_ts_tuple_type( &mut self, node: TsTupleType, __ast_path: &mut AstKindPath, ) -> TsTupleType

Visit a node of type TsTupleType.

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

fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType

Visit a node of type TsType.

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

fn fold_ts_type_alias_decl( &mut self, node: TsTypeAliasDecl, __ast_path: &mut AstKindPath, ) -> TsTypeAliasDecl

Visit a node of type TsTypeAliasDecl.

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

fn fold_ts_type_ann( &mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath, ) -> TsTypeAnn

Visit a node of type TsTypeAnn.

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

fn fold_ts_type_assertion( &mut self, node: TsTypeAssertion, __ast_path: &mut AstKindPath, ) -> TsTypeAssertion

Visit a node of type TsTypeAssertion.

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

fn fold_ts_type_element( &mut self, node: TsTypeElement, __ast_path: &mut AstKindPath, ) -> TsTypeElement

Visit a node of type TsTypeElement.

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

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeElement>

Visit a node of type Vec < TsTypeElement >.

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

fn fold_ts_type_lit( &mut self, node: TsTypeLit, __ast_path: &mut AstKindPath, ) -> TsTypeLit

Visit a node of type TsTypeLit.

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

fn fold_ts_type_operator( &mut self, node: TsTypeOperator, __ast_path: &mut AstKindPath, ) -> TsTypeOperator

Visit a node of type TsTypeOperator.

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

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, __ast_path: &mut AstKindPath, ) -> TsTypeOperatorOp

Visit a node of type TsTypeOperatorOp.

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

fn fold_ts_type_param( &mut self, node: TsTypeParam, __ast_path: &mut AstKindPath, ) -> TsTypeParam

Visit a node of type TsTypeParam.

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

fn fold_ts_type_param_decl( &mut self, node: TsTypeParamDecl, __ast_path: &mut AstKindPath, ) -> TsTypeParamDecl

Visit a node of type TsTypeParamDecl.

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

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, __ast_path: &mut AstKindPath, ) -> TsTypeParamInstantiation

Visit a node of type TsTypeParamInstantiation.

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

fn fold_ts_type_params( &mut self, node: Vec<TsTypeParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeParam>

Visit a node of type Vec < TsTypeParam >.

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

fn fold_ts_type_predicate( &mut self, node: TsTypePredicate, __ast_path: &mut AstKindPath, ) -> TsTypePredicate

Visit a node of type TsTypePredicate.

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

fn fold_ts_type_query( &mut self, node: TsTypeQuery, __ast_path: &mut AstKindPath, ) -> TsTypeQuery

Visit a node of type TsTypeQuery.

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

fn fold_ts_type_query_expr( &mut self, node: TsTypeQueryExpr, __ast_path: &mut AstKindPath, ) -> TsTypeQueryExpr

Visit a node of type TsTypeQueryExpr.

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

fn fold_ts_type_ref( &mut self, node: TsTypeRef, __ast_path: &mut AstKindPath, ) -> TsTypeRef

Visit a node of type TsTypeRef.

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

fn fold_ts_types( &mut self, node: Vec<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<TsType>>

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

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

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, __ast_path: &mut AstKindPath, ) -> TsUnionOrIntersectionType

Visit a node of type TsUnionOrIntersectionType.

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

fn fold_ts_union_type( &mut self, node: TsUnionType, __ast_path: &mut AstKindPath, ) -> TsUnionType

Visit a node of type TsUnionType.

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

fn fold_unary_expr( &mut self, node: UnaryExpr, __ast_path: &mut AstKindPath, ) -> UnaryExpr

Visit a node of type UnaryExpr.

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

fn fold_unary_op( &mut self, node: UnaryOp, __ast_path: &mut AstKindPath, ) -> UnaryOp

Visit a node of type UnaryOp.

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

fn fold_update_expr( &mut self, node: UpdateExpr, __ast_path: &mut AstKindPath, ) -> UpdateExpr

Visit a node of type UpdateExpr.

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

fn fold_update_op( &mut self, node: UpdateOp, __ast_path: &mut AstKindPath, ) -> UpdateOp

Visit a node of type UpdateOp.

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

fn fold_using_decl( &mut self, node: UsingDecl, __ast_path: &mut AstKindPath, ) -> UsingDecl

Visit a node of type UsingDecl.

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

fn fold_var_decl( &mut self, node: VarDecl, __ast_path: &mut AstKindPath, ) -> VarDecl

Visit a node of type VarDecl.

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

fn fold_var_decl_kind( &mut self, node: VarDeclKind, __ast_path: &mut AstKindPath, ) -> VarDeclKind

Visit a node of type VarDeclKind.

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

fn fold_var_decl_or_expr( &mut self, node: VarDeclOrExpr, __ast_path: &mut AstKindPath, ) -> VarDeclOrExpr

Visit a node of type VarDeclOrExpr.

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

fn fold_var_declarator( &mut self, node: VarDeclarator, __ast_path: &mut AstKindPath, ) -> VarDeclarator

Visit a node of type VarDeclarator.

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

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, __ast_path: &mut AstKindPath, ) -> Vec<VarDeclarator>

Visit a node of type Vec < VarDeclarator >.

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

fn fold_while_stmt( &mut self, node: WhileStmt, __ast_path: &mut AstKindPath, ) -> WhileStmt

Visit a node of type WhileStmt.

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

fn fold_with_stmt( &mut self, node: WithStmt, __ast_path: &mut AstKindPath, ) -> WithStmt

Visit a node of type WithStmt.

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

fn fold_wtf_8_atom( &mut self, node: Wtf8Atom, __ast_path: &mut AstKindPath, ) -> Wtf8Atom

Visit a node of type swc_atoms :: Wtf8Atom.

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

fn fold_yield_expr( &mut self, node: YieldExpr, __ast_path: &mut AstKindPath, ) -> YieldExpr

Visit a node of type YieldExpr.

By default, this method calls YieldExpr::fold_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".

Implementations on Foreign Types

impl<A, B> FoldAstPath for Either<A, B>

where A: FoldAstPath, B: FoldAstPath,

Available on docsrs or crate feature path only.

fn fold_accessibility( &mut self, node: Accessibility, __ast_path: &mut AstKindPath, ) -> Accessibility

fn fold_array_lit( &mut self, node: ArrayLit, __ast_path: &mut AstKindPath, ) -> ArrayLit

fn fold_array_pat( &mut self, node: ArrayPat, __ast_path: &mut AstKindPath, ) -> ArrayPat

fn fold_arrow_expr( &mut self, node: ArrowExpr, __ast_path: &mut AstKindPath, ) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, __ast_path: &mut AstKindPath, ) -> ArrowFunctionBody

fn fold_assign_expr( &mut self, node: AssignExpr, __ast_path: &mut AstKindPath, ) -> AssignExpr

fn fold_assign_op( &mut self, node: AssignOp, __ast_path: &mut AstKindPath, ) -> AssignOp

fn fold_assign_pat( &mut self, node: AssignPat, __ast_path: &mut AstKindPath, ) -> AssignPat

fn fold_assign_pat_prop( &mut self, node: AssignPatProp, __ast_path: &mut AstKindPath, ) -> AssignPatProp

fn fold_assign_prop( &mut self, node: AssignProp, __ast_path: &mut AstKindPath, ) -> AssignProp

fn fold_assign_target( &mut self, node: AssignTarget, __ast_path: &mut AstKindPath, ) -> AssignTarget

fn fold_assign_target_pat( &mut self, node: AssignTargetPat, __ast_path: &mut AstKindPath, ) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_auto_accessor( &mut self, node: AutoAccessor, __ast_path: &mut AstKindPath, ) -> AutoAccessor

fn fold_await_expr( &mut self, node: AwaitExpr, __ast_path: &mut AstKindPath, ) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt

fn fold_big_int_value( &mut self, node: BigIntValue, __ast_path: &mut AstKindPath, ) -> BigIntValue

fn fold_bin_expr( &mut self, node: BinExpr, __ast_path: &mut AstKindPath, ) -> BinExpr

fn fold_binary_op( &mut self, node: BinaryOp, __ast_path: &mut AstKindPath, ) -> BinaryOp

fn fold_binding_ident( &mut self, node: BindingIdent, __ast_path: &mut AstKindPath, ) -> BindingIdent

fn fold_block_stmt( &mut self, node: BlockStmt, __ast_path: &mut AstKindPath, ) -> BlockStmt

fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool

fn fold_break_stmt( &mut self, node: BreakStmt, __ast_path: &mut AstKindPath, ) -> BreakStmt

fn fold_call_expr( &mut self, node: CallExpr, __ast_path: &mut AstKindPath, ) -> CallExpr

fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee

fn fold_catch_clause( &mut self, node: CatchClause, __ast_path: &mut AstKindPath, ) -> CatchClause

fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class

fn fold_class_decl( &mut self, node: ClassDecl, __ast_path: &mut AstKindPath, ) -> ClassDecl

fn fold_class_expr( &mut self, node: ClassExpr, __ast_path: &mut AstKindPath, ) -> ClassExpr

fn fold_class_member( &mut self, node: ClassMember, __ast_path: &mut AstKindPath, ) -> ClassMember

fn fold_class_members( &mut self, node: Vec<ClassMember>, __ast_path: &mut AstKindPath, ) -> Vec<ClassMember>

fn fold_class_method( &mut self, node: ClassMethod, __ast_path: &mut AstKindPath, ) -> ClassMethod

fn fold_class_prop( &mut self, node: ClassProp, __ast_path: &mut AstKindPath, ) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, __ast_path: &mut AstKindPath, ) -> ComputedPropName

fn fold_cond_expr( &mut self, node: CondExpr, __ast_path: &mut AstKindPath, ) -> CondExpr

fn fold_constructor( &mut self, node: Constructor, __ast_path: &mut AstKindPath, ) -> Constructor

fn fold_continue_stmt( &mut self, node: ContinueStmt, __ast_path: &mut AstKindPath, ) -> ContinueStmt

fn fold_debugger_stmt( &mut self, node: DebuggerStmt, __ast_path: &mut AstKindPath, ) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl

fn fold_decorator( &mut self, node: Decorator, __ast_path: &mut AstKindPath, ) -> Decorator

fn fold_decorators( &mut self, node: Vec<Decorator>, __ast_path: &mut AstKindPath, ) -> Vec<Decorator>

fn fold_default_decl( &mut self, node: DefaultDecl, __ast_path: &mut AstKindPath, ) -> DefaultDecl

fn fold_do_while_stmt( &mut self, node: DoWhileStmt, __ast_path: &mut AstKindPath, ) -> DoWhileStmt

fn fold_empty_stmt( &mut self, node: EmptyStmt, __ast_path: &mut AstKindPath, ) -> EmptyStmt

fn fold_export_all( &mut self, node: ExportAll, __ast_path: &mut AstKindPath, ) -> ExportAll

fn fold_export_decl( &mut self, node: ExportDecl, __ast_path: &mut AstKindPath, ) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, __ast_path: &mut AstKindPath, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, __ast_path: &mut AstKindPath, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamespaceSpecifier

fn fold_export_specifier( &mut self, node: ExportSpecifier, __ast_path: &mut AstKindPath, ) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr

fn fold_expr_or_spread( &mut self, node: ExprOrSpread, __ast_path: &mut AstKindPath, ) -> ExprOrSpread

fn fold_expr_or_spreads( &mut self, node: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<ExprOrSpread>

fn fold_expr_stmt( &mut self, node: ExprStmt, __ast_path: &mut AstKindPath, ) -> ExprStmt

fn fold_exprs( &mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

fn fold_for_head( &mut self, node: ForHead, __ast_path: &mut AstKindPath, ) -> ForHead

fn fold_for_in_stmt( &mut self, node: ForInStmt, __ast_path: &mut AstKindPath, ) -> ForInStmt

fn fold_for_of_stmt( &mut self, node: ForOfStmt, __ast_path: &mut AstKindPath, ) -> ForOfStmt

fn fold_for_stmt( &mut self, node: ForStmt, __ast_path: &mut AstKindPath, ) -> ForStmt

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_body( &mut self, node: FunctionBody, __ast_path: &mut AstKindPath, ) -> FunctionBody

fn fold_getter_prop( &mut self, node: GetterProp, __ast_path: &mut AstKindPath, ) -> GetterProp

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_ident_name( &mut self, node: IdentName, __ast_path: &mut AstKindPath, ) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import

fn fold_import_decl( &mut self, node: ImportDecl, __ast_path: &mut AstKindPath, ) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ImportNamedSpecifier

fn fold_import_phase( &mut self, node: ImportPhase, __ast_path: &mut AstKindPath, ) -> ImportPhase

fn fold_import_specifier( &mut self, node: ImportSpecifier, __ast_path: &mut AstKindPath, ) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, __ast_path: &mut AstKindPath, ) -> ImportStarAsSpecifier

fn fold_import_with( &mut self, node: ImportWith, __ast_path: &mut AstKindPath, ) -> ImportWith

fn fold_import_with_item( &mut self, node: ImportWithItem, __ast_path: &mut AstKindPath, ) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, __ast_path: &mut AstKindPath, ) -> Vec<ImportWithItem>

fn fold_invalid( &mut self, node: Invalid, __ast_path: &mut AstKindPath, ) -> Invalid

fn fold_jsx_attr( &mut self, node: JSXAttr, __ast_path: &mut AstKindPath, ) -> JSXAttr

fn fold_jsx_attr_name( &mut self, node: JSXAttrName, __ast_path: &mut AstKindPath, ) -> JSXAttrName

fn fold_jsx_attr_or_spread( &mut self, node: JSXAttrOrSpread, __ast_path: &mut AstKindPath, ) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value( &mut self, node: JSXAttrValue, __ast_path: &mut AstKindPath, ) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, __ast_path: &mut AstKindPath, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, __ast_path: &mut AstKindPath, ) -> JSXClosingFragment

fn fold_jsx_element( &mut self, node: JSXElement, __ast_path: &mut AstKindPath, ) -> JSXElement

fn fold_jsx_element_child( &mut self, node: JSXElementChild, __ast_path: &mut AstKindPath, ) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, __ast_path: &mut AstKindPath, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name( &mut self, node: JSXElementName, __ast_path: &mut AstKindPath, ) -> JSXElementName

fn fold_jsx_empty_expr( &mut self, node: JSXEmptyExpr, __ast_path: &mut AstKindPath, ) -> JSXEmptyExpr

fn fold_jsx_expr( &mut self, node: JSXExpr, __ast_path: &mut AstKindPath, ) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, __ast_path: &mut AstKindPath, ) -> JSXExprContainer

fn fold_jsx_fragment( &mut self, node: JSXFragment, __ast_path: &mut AstKindPath, ) -> JSXFragment

fn fold_jsx_member_expr( &mut self, node: JSXMemberExpr, __ast_path: &mut AstKindPath, ) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, __ast_path: &mut AstKindPath, ) -> JSXNamespacedName

fn fold_jsx_object( &mut self, node: JSXObject, __ast_path: &mut AstKindPath, ) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, __ast_path: &mut AstKindPath, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, __ast_path: &mut AstKindPath, ) -> JSXOpeningFragment

fn fold_jsx_spread_child( &mut self, node: JSXSpreadChild, __ast_path: &mut AstKindPath, ) -> JSXSpreadChild

fn fold_jsx_text( &mut self, node: JSXText, __ast_path: &mut AstKindPath, ) -> JSXText

fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key

fn fold_key_value_pat_prop( &mut self, node: KeyValuePatProp, __ast_path: &mut AstKindPath, ) -> KeyValuePatProp

fn fold_key_value_prop( &mut self, node: KeyValueProp, __ast_path: &mut AstKindPath, ) -> KeyValueProp

fn fold_labeled_stmt( &mut self, node: LabeledStmt, __ast_path: &mut AstKindPath, ) -> LabeledStmt

fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit

fn fold_member_expr( &mut self, node: MemberExpr, __ast_path: &mut AstKindPath, ) -> MemberExpr

fn fold_member_prop( &mut self, node: MemberProp, __ast_path: &mut AstKindPath, ) -> MemberProp

fn fold_meta_prop_expr( &mut self, node: MetaPropExpr, __ast_path: &mut AstKindPath, ) -> MetaPropExpr

fn fold_meta_prop_kind( &mut self, node: MetaPropKind, __ast_path: &mut AstKindPath, ) -> MetaPropKind

fn fold_method_kind( &mut self, node: MethodKind, __ast_path: &mut AstKindPath, ) -> MethodKind

fn fold_method_prop( &mut self, node: MethodProp, __ast_path: &mut AstKindPath, ) -> MethodProp

fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module

fn fold_module_decl( &mut self, node: ModuleDecl, __ast_path: &mut AstKindPath, ) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, __ast_path: &mut AstKindPath, ) -> ModuleExportName

fn fold_module_item( &mut self, node: ModuleItem, __ast_path: &mut AstKindPath, ) -> ModuleItem

fn fold_module_items( &mut self, node: Vec<ModuleItem>, __ast_path: &mut AstKindPath, ) -> Vec<ModuleItem>

fn fold_named_export( &mut self, node: NamedExport, __ast_path: &mut AstKindPath, ) -> NamedExport

fn fold_new_expr( &mut self, node: NewExpr, __ast_path: &mut AstKindPath, ) -> NewExpr

fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_object_lit( &mut self, node: ObjectLit, __ast_path: &mut AstKindPath, ) -> ObjectLit

fn fold_object_pat( &mut self, node: ObjectPat, __ast_path: &mut AstKindPath, ) -> ObjectPat

fn fold_object_pat_prop( &mut self, node: ObjectPatProp, __ast_path: &mut AstKindPath, ) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, __ast_path: &mut AstKindPath, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, __ast_path: &mut AstKindPath, ) -> Option<Accessibility>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_block_stmt( &mut self, node: Option<BlockStmt>, __ast_path: &mut AstKindPath, ) -> Option<BlockStmt>

fn fold_opt_call( &mut self, node: OptCall, __ast_path: &mut AstKindPath, ) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, __ast_path: &mut AstKindPath, ) -> Option<CatchClause>

fn fold_opt_chain_base( &mut self, node: OptChainBase, __ast_path: &mut AstKindPath, ) -> OptChainBase

fn fold_opt_chain_expr( &mut self, node: OptChainExpr, __ast_path: &mut AstKindPath, ) -> OptChainExpr

fn fold_opt_expr( &mut self, node: Option<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, __ast_path: &mut AstKindPath, ) -> Option<FunctionBody>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, __ast_path: &mut AstKindPath, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, __ast_path: &mut AstKindPath, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, __ast_path: &mut AstKindPath, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat( &mut self, node: Option<Pat>, __ast_path: &mut AstKindPath, ) -> Option<Pat>

fn fold_opt_span( &mut self, node: Option<Span>, __ast_path: &mut AstKindPath, ) -> Option<Span>

fn fold_opt_stmt( &mut self, node: Option<Box<Stmt>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Stmt>>

fn fold_opt_str( &mut self, node: Option<Box<Str>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, __ast_path: &mut AstKindPath, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, __ast_path: &mut AstKindPath, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, __ast_path: &mut AstKindPath, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, __ast_path: &mut AstKindPath, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type( &mut self, node: Option<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, __ast_path: &mut AstKindPath, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats( &mut self, node: Vec<Option<Pat>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom( &mut self, node: Option<Wtf8Atom>, __ast_path: &mut AstKindPath, ) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, __ast_path: &mut AstKindPath, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, __ast_path: &mut AstKindPath, ) -> Vec<ParamOrTsParamProp>

fn fold_params( &mut self, node: Vec<Param>, __ast_path: &mut AstKindPath, ) -> Vec<Param>

fn fold_paren_expr( &mut self, node: ParenExpr, __ast_path: &mut AstKindPath, ) -> ParenExpr

fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat

fn fold_pats( &mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath, ) -> Vec<Pat>

fn fold_private_method( &mut self, node: PrivateMethod, __ast_path: &mut AstKindPath, ) -> PrivateMethod

fn fold_private_name( &mut self, node: PrivateName, __ast_path: &mut AstKindPath, ) -> PrivateName

fn fold_private_prop( &mut self, node: PrivateProp, __ast_path: &mut AstKindPath, ) -> PrivateProp

fn fold_program( &mut self, node: Program, __ast_path: &mut AstKindPath, ) -> Program

fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop

fn fold_prop_name( &mut self, node: PropName, __ast_path: &mut AstKindPath, ) -> PropName

fn fold_prop_or_spread( &mut self, node: PropOrSpread, __ast_path: &mut AstKindPath, ) -> PropOrSpread

fn fold_prop_or_spreads( &mut self, node: Vec<PropOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex

fn fold_rest_pat( &mut self, node: RestPat, __ast_path: &mut AstKindPath, ) -> RestPat

fn fold_return_stmt( &mut self, node: ReturnStmt, __ast_path: &mut AstKindPath, ) -> ReturnStmt

fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script

fn fold_seq_expr( &mut self, node: SeqExpr, __ast_path: &mut AstKindPath, ) -> SeqExpr

fn fold_setter_prop( &mut self, node: SetterProp, __ast_path: &mut AstKindPath, ) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, __ast_path: &mut AstKindPath, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_spread_element( &mut self, node: SpreadElement, __ast_path: &mut AstKindPath, ) -> SpreadElement

fn fold_static_block( &mut self, node: StaticBlock, __ast_path: &mut AstKindPath, ) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt

fn fold_stmts( &mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath, ) -> Vec<Stmt>

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super

fn fold_super_prop( &mut self, node: SuperProp, __ast_path: &mut AstKindPath, ) -> SuperProp

fn fold_super_prop_expr( &mut self, node: SuperPropExpr, __ast_path: &mut AstKindPath, ) -> SuperPropExpr

fn fold_switch_case( &mut self, node: SwitchCase, __ast_path: &mut AstKindPath, ) -> SwitchCase

fn fold_switch_cases( &mut self, node: Vec<SwitchCase>, __ast_path: &mut AstKindPath, ) -> Vec<SwitchCase>

fn fold_switch_stmt( &mut self, node: SwitchStmt, __ast_path: &mut AstKindPath, ) -> SwitchStmt

fn fold_syntax_context( &mut self, node: SyntaxContext, __ast_path: &mut AstKindPath, ) -> SyntaxContext

fn fold_tagged_tpl( &mut self, node: TaggedTpl, __ast_path: &mut AstKindPath, ) -> TaggedTpl

fn fold_this_expr( &mut self, node: ThisExpr, __ast_path: &mut AstKindPath, ) -> ThisExpr

fn fold_throw_stmt( &mut self, node: ThrowStmt, __ast_path: &mut AstKindPath, ) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl

fn fold_tpl_element( &mut self, node: TplElement, __ast_path: &mut AstKindPath, ) -> TplElement

fn fold_tpl_elements( &mut self, node: Vec<TplElement>, __ast_path: &mut AstKindPath, ) -> Vec<TplElement>

fn fold_true_plus_minus( &mut self, node: TruePlusMinus, __ast_path: &mut AstKindPath, ) -> TruePlusMinus

fn fold_try_stmt( &mut self, node: TryStmt, __ast_path: &mut AstKindPath, ) -> TryStmt

fn fold_ts_array_type( &mut self, node: TsArrayType, __ast_path: &mut AstKindPath, ) -> TsArrayType

fn fold_ts_as_expr( &mut self, node: TsAsExpr, __ast_path: &mut AstKindPath, ) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, __ast_path: &mut AstKindPath, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, __ast_path: &mut AstKindPath, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, __ast_path: &mut AstKindPath, ) -> TsConstructorType

fn fold_ts_entity_name( &mut self, node: TsEntityName, __ast_path: &mut AstKindPath, ) -> TsEntityName

fn fold_ts_enum_decl( &mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath, ) -> TsEnumDecl

fn fold_ts_enum_member( &mut self, node: TsEnumMember, __ast_path: &mut AstKindPath, ) -> TsEnumMember

fn fold_ts_enum_member_id( &mut self, node: TsEnumMemberId, __ast_path: &mut AstKindPath, ) -> TsEnumMemberId

fn fold_ts_enum_members( &mut self, node: Vec<TsEnumMember>, __ast_path: &mut AstKindPath, ) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, __ast_path: &mut AstKindPath, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, __ast_path: &mut AstKindPath, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, __ast_path: &mut AstKindPath, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, __ast_path: &mut AstKindPath, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, __ast_path: &mut AstKindPath, ) -> TsFnOrConstructorType

fn fold_ts_fn_param( &mut self, node: TsFnParam, __ast_path: &mut AstKindPath, ) -> TsFnParam

fn fold_ts_fn_params( &mut self, node: Vec<TsFnParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsFnParam>

fn fold_ts_fn_type( &mut self, node: TsFnType, __ast_path: &mut AstKindPath, ) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, __ast_path: &mut AstKindPath, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, __ast_path: &mut AstKindPath, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, __ast_path: &mut AstKindPath, ) -> TsImportEqualsDecl

fn fold_ts_import_type( &mut self, node: TsImportType, __ast_path: &mut AstKindPath, ) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, __ast_path: &mut AstKindPath, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, __ast_path: &mut AstKindPath, ) -> TsIndexedAccessType

fn fold_ts_infer_type( &mut self, node: TsInferType, __ast_path: &mut AstKindPath, ) -> TsInferType

fn fold_ts_instantiation( &mut self, node: TsInstantiation, __ast_path: &mut AstKindPath, ) -> TsInstantiation

fn fold_ts_interface_body( &mut self, node: TsInterfaceBody, __ast_path: &mut AstKindPath, ) -> TsInterfaceBody

fn fold_ts_interface_decl( &mut self, node: TsInterfaceDecl, __ast_path: &mut AstKindPath, ) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, __ast_path: &mut AstKindPath, ) -> TsIntersectionType

fn fold_ts_keyword_type( &mut self, node: TsKeywordType, __ast_path: &mut AstKindPath, ) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, __ast_path: &mut AstKindPath, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit

fn fold_ts_lit_type( &mut self, node: TsLitType, __ast_path: &mut AstKindPath, ) -> TsLitType

fn fold_ts_mapped_type( &mut self, node: TsMappedType, __ast_path: &mut AstKindPath, ) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, __ast_path: &mut AstKindPath, ) -> TsMethodSignature

fn fold_ts_module_block( &mut self, node: TsModuleBlock, __ast_path: &mut AstKindPath, ) -> TsModuleBlock

fn fold_ts_module_decl( &mut self, node: TsModuleDecl, __ast_path: &mut AstKindPath, ) -> TsModuleDecl

fn fold_ts_module_name( &mut self, node: TsModuleName, __ast_path: &mut AstKindPath, ) -> TsModuleName

fn fold_ts_module_ref( &mut self, node: TsModuleRef, __ast_path: &mut AstKindPath, ) -> TsModuleRef

fn fold_ts_namespace_body( &mut self, node: TsNamespaceBody, __ast_path: &mut AstKindPath, ) -> TsNamespaceBody

fn fold_ts_namespace_decl( &mut self, node: TsNamespaceDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr( &mut self, node: TsNonNullExpr, __ast_path: &mut AstKindPath, ) -> TsNonNullExpr

fn fold_ts_optional_type( &mut self, node: TsOptionalType, __ast_path: &mut AstKindPath, ) -> TsOptionalType

fn fold_ts_param_prop( &mut self, node: TsParamProp, __ast_path: &mut AstKindPath, ) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, __ast_path: &mut AstKindPath, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, __ast_path: &mut AstKindPath, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, __ast_path: &mut AstKindPath, ) -> TsPropertySignature

fn fold_ts_qualified_name( &mut self, node: TsQualifiedName, __ast_path: &mut AstKindPath, ) -> TsQualifiedName

fn fold_ts_rest_type( &mut self, node: TsRestType, __ast_path: &mut AstKindPath, ) -> TsRestType

fn fold_ts_satisfies_expr( &mut self, node: TsSatisfiesExpr, __ast_path: &mut AstKindPath, ) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, __ast_path: &mut AstKindPath, ) -> TsSetterSignature

fn fold_ts_this_param( &mut self, node: TsThisParam, __ast_path: &mut AstKindPath, ) -> TsThisParam

fn fold_ts_this_type( &mut self, node: TsThisType, __ast_path: &mut AstKindPath, ) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, __ast_path: &mut AstKindPath, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type( &mut self, node: TsTplLitType, __ast_path: &mut AstKindPath, ) -> TsTplLitType

fn fold_ts_tuple_element( &mut self, node: TsTupleElement, __ast_path: &mut AstKindPath, ) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type( &mut self, node: TsTupleType, __ast_path: &mut AstKindPath, ) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType

fn fold_ts_type_alias_decl( &mut self, node: TsTypeAliasDecl, __ast_path: &mut AstKindPath, ) -> TsTypeAliasDecl

fn fold_ts_type_ann( &mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath, ) -> TsTypeAnn

fn fold_ts_type_assertion( &mut self, node: TsTypeAssertion, __ast_path: &mut AstKindPath, ) -> TsTypeAssertion

fn fold_ts_type_element( &mut self, node: TsTypeElement, __ast_path: &mut AstKindPath, ) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit( &mut self, node: TsTypeLit, __ast_path: &mut AstKindPath, ) -> TsTypeLit

fn fold_ts_type_operator( &mut self, node: TsTypeOperator, __ast_path: &mut AstKindPath, ) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, __ast_path: &mut AstKindPath, ) -> TsTypeOperatorOp

fn fold_ts_type_param( &mut self, node: TsTypeParam, __ast_path: &mut AstKindPath, ) -> TsTypeParam

fn fold_ts_type_param_decl( &mut self, node: TsTypeParamDecl, __ast_path: &mut AstKindPath, ) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, __ast_path: &mut AstKindPath, ) -> TsTypeParamInstantiation

fn fold_ts_type_params( &mut self, node: Vec<TsTypeParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeParam>

fn fold_ts_type_predicate( &mut self, node: TsTypePredicate, __ast_path: &mut AstKindPath, ) -> TsTypePredicate

fn fold_ts_type_query( &mut self, node: TsTypeQuery, __ast_path: &mut AstKindPath, ) -> TsTypeQuery

fn fold_ts_type_query_expr( &mut self, node: TsTypeQueryExpr, __ast_path: &mut AstKindPath, ) -> TsTypeQueryExpr

fn fold_ts_type_ref( &mut self, node: TsTypeRef, __ast_path: &mut AstKindPath, ) -> TsTypeRef

fn fold_ts_types( &mut self, node: Vec<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, __ast_path: &mut AstKindPath, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type( &mut self, node: TsUnionType, __ast_path: &mut AstKindPath, ) -> TsUnionType

fn fold_unary_expr( &mut self, node: UnaryExpr, __ast_path: &mut AstKindPath, ) -> UnaryExpr

fn fold_unary_op( &mut self, node: UnaryOp, __ast_path: &mut AstKindPath, ) -> UnaryOp

fn fold_update_expr( &mut self, node: UpdateExpr, __ast_path: &mut AstKindPath, ) -> UpdateExpr

fn fold_update_op( &mut self, node: UpdateOp, __ast_path: &mut AstKindPath, ) -> UpdateOp

fn fold_using_decl( &mut self, node: UsingDecl, __ast_path: &mut AstKindPath, ) -> UsingDecl

fn fold_var_decl( &mut self, node: VarDecl, __ast_path: &mut AstKindPath, ) -> VarDecl

fn fold_var_decl_kind( &mut self, node: VarDeclKind, __ast_path: &mut AstKindPath, ) -> VarDeclKind

fn fold_var_decl_or_expr( &mut self, node: VarDeclOrExpr, __ast_path: &mut AstKindPath, ) -> VarDeclOrExpr

fn fold_var_declarator( &mut self, node: VarDeclarator, __ast_path: &mut AstKindPath, ) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, __ast_path: &mut AstKindPath, ) -> Vec<VarDeclarator>

fn fold_while_stmt( &mut self, node: WhileStmt, __ast_path: &mut AstKindPath, ) -> WhileStmt

fn fold_with_stmt( &mut self, node: WithStmt, __ast_path: &mut AstKindPath, ) -> WithStmt

fn fold_wtf_8_atom( &mut self, node: Wtf8Atom, __ast_path: &mut AstKindPath, ) -> Wtf8Atom

fn fold_yield_expr( &mut self, node: YieldExpr, __ast_path: &mut AstKindPath, ) -> YieldExpr

impl<V> FoldAstPath for &mut V

where V: ?Sized + FoldAstPath,

Available on docsrs or crate feature path only.

fn fold_accessibility( &mut self, node: Accessibility, __ast_path: &mut AstKindPath, ) -> Accessibility

fn fold_array_lit( &mut self, node: ArrayLit, __ast_path: &mut AstKindPath, ) -> ArrayLit

fn fold_array_pat( &mut self, node: ArrayPat, __ast_path: &mut AstKindPath, ) -> ArrayPat

fn fold_arrow_expr( &mut self, node: ArrowExpr, __ast_path: &mut AstKindPath, ) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, __ast_path: &mut AstKindPath, ) -> ArrowFunctionBody

fn fold_assign_expr( &mut self, node: AssignExpr, __ast_path: &mut AstKindPath, ) -> AssignExpr

fn fold_assign_op( &mut self, node: AssignOp, __ast_path: &mut AstKindPath, ) -> AssignOp

fn fold_assign_pat( &mut self, node: AssignPat, __ast_path: &mut AstKindPath, ) -> AssignPat

fn fold_assign_pat_prop( &mut self, node: AssignPatProp, __ast_path: &mut AstKindPath, ) -> AssignPatProp

fn fold_assign_prop( &mut self, node: AssignProp, __ast_path: &mut AstKindPath, ) -> AssignProp

fn fold_assign_target( &mut self, node: AssignTarget, __ast_path: &mut AstKindPath, ) -> AssignTarget

fn fold_assign_target_pat( &mut self, node: AssignTargetPat, __ast_path: &mut AstKindPath, ) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_auto_accessor( &mut self, node: AutoAccessor, __ast_path: &mut AstKindPath, ) -> AutoAccessor

fn fold_await_expr( &mut self, node: AwaitExpr, __ast_path: &mut AstKindPath, ) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt

fn fold_big_int_value( &mut self, node: BigIntValue, __ast_path: &mut AstKindPath, ) -> BigIntValue

fn fold_bin_expr( &mut self, node: BinExpr, __ast_path: &mut AstKindPath, ) -> BinExpr

fn fold_binary_op( &mut self, node: BinaryOp, __ast_path: &mut AstKindPath, ) -> BinaryOp

fn fold_binding_ident( &mut self, node: BindingIdent, __ast_path: &mut AstKindPath, ) -> BindingIdent

fn fold_block_stmt( &mut self, node: BlockStmt, __ast_path: &mut AstKindPath, ) -> BlockStmt

fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool

fn fold_break_stmt( &mut self, node: BreakStmt, __ast_path: &mut AstKindPath, ) -> BreakStmt

fn fold_call_expr( &mut self, node: CallExpr, __ast_path: &mut AstKindPath, ) -> CallExpr

fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee

fn fold_catch_clause( &mut self, node: CatchClause, __ast_path: &mut AstKindPath, ) -> CatchClause

fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class

fn fold_class_decl( &mut self, node: ClassDecl, __ast_path: &mut AstKindPath, ) -> ClassDecl

fn fold_class_expr( &mut self, node: ClassExpr, __ast_path: &mut AstKindPath, ) -> ClassExpr

fn fold_class_member( &mut self, node: ClassMember, __ast_path: &mut AstKindPath, ) -> ClassMember

fn fold_class_members( &mut self, node: Vec<ClassMember>, __ast_path: &mut AstKindPath, ) -> Vec<ClassMember>

fn fold_class_method( &mut self, node: ClassMethod, __ast_path: &mut AstKindPath, ) -> ClassMethod

fn fold_class_prop( &mut self, node: ClassProp, __ast_path: &mut AstKindPath, ) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, __ast_path: &mut AstKindPath, ) -> ComputedPropName

fn fold_cond_expr( &mut self, node: CondExpr, __ast_path: &mut AstKindPath, ) -> CondExpr

fn fold_constructor( &mut self, node: Constructor, __ast_path: &mut AstKindPath, ) -> Constructor

fn fold_continue_stmt( &mut self, node: ContinueStmt, __ast_path: &mut AstKindPath, ) -> ContinueStmt

fn fold_debugger_stmt( &mut self, node: DebuggerStmt, __ast_path: &mut AstKindPath, ) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl

fn fold_decorator( &mut self, node: Decorator, __ast_path: &mut AstKindPath, ) -> Decorator

fn fold_decorators( &mut self, node: Vec<Decorator>, __ast_path: &mut AstKindPath, ) -> Vec<Decorator>

fn fold_default_decl( &mut self, node: DefaultDecl, __ast_path: &mut AstKindPath, ) -> DefaultDecl

fn fold_do_while_stmt( &mut self, node: DoWhileStmt, __ast_path: &mut AstKindPath, ) -> DoWhileStmt

fn fold_empty_stmt( &mut self, node: EmptyStmt, __ast_path: &mut AstKindPath, ) -> EmptyStmt

fn fold_export_all( &mut self, node: ExportAll, __ast_path: &mut AstKindPath, ) -> ExportAll

fn fold_export_decl( &mut self, node: ExportDecl, __ast_path: &mut AstKindPath, ) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, __ast_path: &mut AstKindPath, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, __ast_path: &mut AstKindPath, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamespaceSpecifier

fn fold_export_specifier( &mut self, node: ExportSpecifier, __ast_path: &mut AstKindPath, ) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr

fn fold_expr_or_spread( &mut self, node: ExprOrSpread, __ast_path: &mut AstKindPath, ) -> ExprOrSpread

fn fold_expr_or_spreads( &mut self, node: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<ExprOrSpread>

fn fold_expr_stmt( &mut self, node: ExprStmt, __ast_path: &mut AstKindPath, ) -> ExprStmt

fn fold_exprs( &mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

fn fold_for_head( &mut self, node: ForHead, __ast_path: &mut AstKindPath, ) -> ForHead

fn fold_for_in_stmt( &mut self, node: ForInStmt, __ast_path: &mut AstKindPath, ) -> ForInStmt

fn fold_for_of_stmt( &mut self, node: ForOfStmt, __ast_path: &mut AstKindPath, ) -> ForOfStmt

fn fold_for_stmt( &mut self, node: ForStmt, __ast_path: &mut AstKindPath, ) -> ForStmt

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_body( &mut self, node: FunctionBody, __ast_path: &mut AstKindPath, ) -> FunctionBody

fn fold_getter_prop( &mut self, node: GetterProp, __ast_path: &mut AstKindPath, ) -> GetterProp

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_ident_name( &mut self, node: IdentName, __ast_path: &mut AstKindPath, ) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import

fn fold_import_decl( &mut self, node: ImportDecl, __ast_path: &mut AstKindPath, ) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ImportNamedSpecifier

fn fold_import_phase( &mut self, node: ImportPhase, __ast_path: &mut AstKindPath, ) -> ImportPhase

fn fold_import_specifier( &mut self, node: ImportSpecifier, __ast_path: &mut AstKindPath, ) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, __ast_path: &mut AstKindPath, ) -> ImportStarAsSpecifier

fn fold_import_with( &mut self, node: ImportWith, __ast_path: &mut AstKindPath, ) -> ImportWith

fn fold_import_with_item( &mut self, node: ImportWithItem, __ast_path: &mut AstKindPath, ) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, __ast_path: &mut AstKindPath, ) -> Vec<ImportWithItem>

fn fold_invalid( &mut self, node: Invalid, __ast_path: &mut AstKindPath, ) -> Invalid

fn fold_jsx_attr( &mut self, node: JSXAttr, __ast_path: &mut AstKindPath, ) -> JSXAttr

fn fold_jsx_attr_name( &mut self, node: JSXAttrName, __ast_path: &mut AstKindPath, ) -> JSXAttrName

fn fold_jsx_attr_or_spread( &mut self, node: JSXAttrOrSpread, __ast_path: &mut AstKindPath, ) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value( &mut self, node: JSXAttrValue, __ast_path: &mut AstKindPath, ) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, __ast_path: &mut AstKindPath, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, __ast_path: &mut AstKindPath, ) -> JSXClosingFragment

fn fold_jsx_element( &mut self, node: JSXElement, __ast_path: &mut AstKindPath, ) -> JSXElement

fn fold_jsx_element_child( &mut self, node: JSXElementChild, __ast_path: &mut AstKindPath, ) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, __ast_path: &mut AstKindPath, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name( &mut self, node: JSXElementName, __ast_path: &mut AstKindPath, ) -> JSXElementName

fn fold_jsx_empty_expr( &mut self, node: JSXEmptyExpr, __ast_path: &mut AstKindPath, ) -> JSXEmptyExpr

fn fold_jsx_expr( &mut self, node: JSXExpr, __ast_path: &mut AstKindPath, ) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, __ast_path: &mut AstKindPath, ) -> JSXExprContainer

fn fold_jsx_fragment( &mut self, node: JSXFragment, __ast_path: &mut AstKindPath, ) -> JSXFragment

fn fold_jsx_member_expr( &mut self, node: JSXMemberExpr, __ast_path: &mut AstKindPath, ) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, __ast_path: &mut AstKindPath, ) -> JSXNamespacedName

fn fold_jsx_object( &mut self, node: JSXObject, __ast_path: &mut AstKindPath, ) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, __ast_path: &mut AstKindPath, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, __ast_path: &mut AstKindPath, ) -> JSXOpeningFragment

fn fold_jsx_spread_child( &mut self, node: JSXSpreadChild, __ast_path: &mut AstKindPath, ) -> JSXSpreadChild

fn fold_jsx_text( &mut self, node: JSXText, __ast_path: &mut AstKindPath, ) -> JSXText

fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key

fn fold_key_value_pat_prop( &mut self, node: KeyValuePatProp, __ast_path: &mut AstKindPath, ) -> KeyValuePatProp

fn fold_key_value_prop( &mut self, node: KeyValueProp, __ast_path: &mut AstKindPath, ) -> KeyValueProp

fn fold_labeled_stmt( &mut self, node: LabeledStmt, __ast_path: &mut AstKindPath, ) -> LabeledStmt

fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit

fn fold_member_expr( &mut self, node: MemberExpr, __ast_path: &mut AstKindPath, ) -> MemberExpr

fn fold_member_prop( &mut self, node: MemberProp, __ast_path: &mut AstKindPath, ) -> MemberProp

fn fold_meta_prop_expr( &mut self, node: MetaPropExpr, __ast_path: &mut AstKindPath, ) -> MetaPropExpr

fn fold_meta_prop_kind( &mut self, node: MetaPropKind, __ast_path: &mut AstKindPath, ) -> MetaPropKind

fn fold_method_kind( &mut self, node: MethodKind, __ast_path: &mut AstKindPath, ) -> MethodKind

fn fold_method_prop( &mut self, node: MethodProp, __ast_path: &mut AstKindPath, ) -> MethodProp

fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module

fn fold_module_decl( &mut self, node: ModuleDecl, __ast_path: &mut AstKindPath, ) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, __ast_path: &mut AstKindPath, ) -> ModuleExportName

fn fold_module_item( &mut self, node: ModuleItem, __ast_path: &mut AstKindPath, ) -> ModuleItem

fn fold_module_items( &mut self, node: Vec<ModuleItem>, __ast_path: &mut AstKindPath, ) -> Vec<ModuleItem>

fn fold_named_export( &mut self, node: NamedExport, __ast_path: &mut AstKindPath, ) -> NamedExport

fn fold_new_expr( &mut self, node: NewExpr, __ast_path: &mut AstKindPath, ) -> NewExpr

fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_object_lit( &mut self, node: ObjectLit, __ast_path: &mut AstKindPath, ) -> ObjectLit

fn fold_object_pat( &mut self, node: ObjectPat, __ast_path: &mut AstKindPath, ) -> ObjectPat

fn fold_object_pat_prop( &mut self, node: ObjectPatProp, __ast_path: &mut AstKindPath, ) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, __ast_path: &mut AstKindPath, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, __ast_path: &mut AstKindPath, ) -> Option<Accessibility>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_block_stmt( &mut self, node: Option<BlockStmt>, __ast_path: &mut AstKindPath, ) -> Option<BlockStmt>

fn fold_opt_call( &mut self, node: OptCall, __ast_path: &mut AstKindPath, ) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, __ast_path: &mut AstKindPath, ) -> Option<CatchClause>

fn fold_opt_chain_base( &mut self, node: OptChainBase, __ast_path: &mut AstKindPath, ) -> OptChainBase

fn fold_opt_chain_expr( &mut self, node: OptChainExpr, __ast_path: &mut AstKindPath, ) -> OptChainExpr

fn fold_opt_expr( &mut self, node: Option<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, __ast_path: &mut AstKindPath, ) -> Option<FunctionBody>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, __ast_path: &mut AstKindPath, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, __ast_path: &mut AstKindPath, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, __ast_path: &mut AstKindPath, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat( &mut self, node: Option<Pat>, __ast_path: &mut AstKindPath, ) -> Option<Pat>

fn fold_opt_span( &mut self, node: Option<Span>, __ast_path: &mut AstKindPath, ) -> Option<Span>

fn fold_opt_stmt( &mut self, node: Option<Box<Stmt>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Stmt>>

fn fold_opt_str( &mut self, node: Option<Box<Str>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, __ast_path: &mut AstKindPath, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, __ast_path: &mut AstKindPath, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, __ast_path: &mut AstKindPath, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, __ast_path: &mut AstKindPath, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type( &mut self, node: Option<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, __ast_path: &mut AstKindPath, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats( &mut self, node: Vec<Option<Pat>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom( &mut self, node: Option<Wtf8Atom>, __ast_path: &mut AstKindPath, ) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, __ast_path: &mut AstKindPath, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, __ast_path: &mut AstKindPath, ) -> Vec<ParamOrTsParamProp>

fn fold_params( &mut self, node: Vec<Param>, __ast_path: &mut AstKindPath, ) -> Vec<Param>

fn fold_paren_expr( &mut self, node: ParenExpr, __ast_path: &mut AstKindPath, ) -> ParenExpr

fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat

fn fold_pats( &mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath, ) -> Vec<Pat>

fn fold_private_method( &mut self, node: PrivateMethod, __ast_path: &mut AstKindPath, ) -> PrivateMethod

fn fold_private_name( &mut self, node: PrivateName, __ast_path: &mut AstKindPath, ) -> PrivateName

fn fold_private_prop( &mut self, node: PrivateProp, __ast_path: &mut AstKindPath, ) -> PrivateProp

fn fold_program( &mut self, node: Program, __ast_path: &mut AstKindPath, ) -> Program

fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop

fn fold_prop_name( &mut self, node: PropName, __ast_path: &mut AstKindPath, ) -> PropName

fn fold_prop_or_spread( &mut self, node: PropOrSpread, __ast_path: &mut AstKindPath, ) -> PropOrSpread

fn fold_prop_or_spreads( &mut self, node: Vec<PropOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex

fn fold_rest_pat( &mut self, node: RestPat, __ast_path: &mut AstKindPath, ) -> RestPat

fn fold_return_stmt( &mut self, node: ReturnStmt, __ast_path: &mut AstKindPath, ) -> ReturnStmt

fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script

fn fold_seq_expr( &mut self, node: SeqExpr, __ast_path: &mut AstKindPath, ) -> SeqExpr

fn fold_setter_prop( &mut self, node: SetterProp, __ast_path: &mut AstKindPath, ) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, __ast_path: &mut AstKindPath, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_spread_element( &mut self, node: SpreadElement, __ast_path: &mut AstKindPath, ) -> SpreadElement

fn fold_static_block( &mut self, node: StaticBlock, __ast_path: &mut AstKindPath, ) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt

fn fold_stmts( &mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath, ) -> Vec<Stmt>

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super

fn fold_super_prop( &mut self, node: SuperProp, __ast_path: &mut AstKindPath, ) -> SuperProp

fn fold_super_prop_expr( &mut self, node: SuperPropExpr, __ast_path: &mut AstKindPath, ) -> SuperPropExpr

fn fold_switch_case( &mut self, node: SwitchCase, __ast_path: &mut AstKindPath, ) -> SwitchCase

fn fold_switch_cases( &mut self, node: Vec<SwitchCase>, __ast_path: &mut AstKindPath, ) -> Vec<SwitchCase>

fn fold_switch_stmt( &mut self, node: SwitchStmt, __ast_path: &mut AstKindPath, ) -> SwitchStmt

fn fold_syntax_context( &mut self, node: SyntaxContext, __ast_path: &mut AstKindPath, ) -> SyntaxContext

fn fold_tagged_tpl( &mut self, node: TaggedTpl, __ast_path: &mut AstKindPath, ) -> TaggedTpl

fn fold_this_expr( &mut self, node: ThisExpr, __ast_path: &mut AstKindPath, ) -> ThisExpr

fn fold_throw_stmt( &mut self, node: ThrowStmt, __ast_path: &mut AstKindPath, ) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl

fn fold_tpl_element( &mut self, node: TplElement, __ast_path: &mut AstKindPath, ) -> TplElement

fn fold_tpl_elements( &mut self, node: Vec<TplElement>, __ast_path: &mut AstKindPath, ) -> Vec<TplElement>

fn fold_true_plus_minus( &mut self, node: TruePlusMinus, __ast_path: &mut AstKindPath, ) -> TruePlusMinus

fn fold_try_stmt( &mut self, node: TryStmt, __ast_path: &mut AstKindPath, ) -> TryStmt

fn fold_ts_array_type( &mut self, node: TsArrayType, __ast_path: &mut AstKindPath, ) -> TsArrayType

fn fold_ts_as_expr( &mut self, node: TsAsExpr, __ast_path: &mut AstKindPath, ) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, __ast_path: &mut AstKindPath, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, __ast_path: &mut AstKindPath, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, __ast_path: &mut AstKindPath, ) -> TsConstructorType

fn fold_ts_entity_name( &mut self, node: TsEntityName, __ast_path: &mut AstKindPath, ) -> TsEntityName

fn fold_ts_enum_decl( &mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath, ) -> TsEnumDecl

fn fold_ts_enum_member( &mut self, node: TsEnumMember, __ast_path: &mut AstKindPath, ) -> TsEnumMember

fn fold_ts_enum_member_id( &mut self, node: TsEnumMemberId, __ast_path: &mut AstKindPath, ) -> TsEnumMemberId

fn fold_ts_enum_members( &mut self, node: Vec<TsEnumMember>, __ast_path: &mut AstKindPath, ) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, __ast_path: &mut AstKindPath, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, __ast_path: &mut AstKindPath, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, __ast_path: &mut AstKindPath, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, __ast_path: &mut AstKindPath, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, __ast_path: &mut AstKindPath, ) -> TsFnOrConstructorType

fn fold_ts_fn_param( &mut self, node: TsFnParam, __ast_path: &mut AstKindPath, ) -> TsFnParam

fn fold_ts_fn_params( &mut self, node: Vec<TsFnParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsFnParam>

fn fold_ts_fn_type( &mut self, node: TsFnType, __ast_path: &mut AstKindPath, ) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, __ast_path: &mut AstKindPath, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, __ast_path: &mut AstKindPath, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, __ast_path: &mut AstKindPath, ) -> TsImportEqualsDecl

fn fold_ts_import_type( &mut self, node: TsImportType, __ast_path: &mut AstKindPath, ) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, __ast_path: &mut AstKindPath, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, __ast_path: &mut AstKindPath, ) -> TsIndexedAccessType

fn fold_ts_infer_type( &mut self, node: TsInferType, __ast_path: &mut AstKindPath, ) -> TsInferType

fn fold_ts_instantiation( &mut self, node: TsInstantiation, __ast_path: &mut AstKindPath, ) -> TsInstantiation

fn fold_ts_interface_body( &mut self, node: TsInterfaceBody, __ast_path: &mut AstKindPath, ) -> TsInterfaceBody

fn fold_ts_interface_decl( &mut self, node: TsInterfaceDecl, __ast_path: &mut AstKindPath, ) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, __ast_path: &mut AstKindPath, ) -> TsIntersectionType

fn fold_ts_keyword_type( &mut self, node: TsKeywordType, __ast_path: &mut AstKindPath, ) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, __ast_path: &mut AstKindPath, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit

fn fold_ts_lit_type( &mut self, node: TsLitType, __ast_path: &mut AstKindPath, ) -> TsLitType

fn fold_ts_mapped_type( &mut self, node: TsMappedType, __ast_path: &mut AstKindPath, ) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, __ast_path: &mut AstKindPath, ) -> TsMethodSignature

fn fold_ts_module_block( &mut self, node: TsModuleBlock, __ast_path: &mut AstKindPath, ) -> TsModuleBlock

fn fold_ts_module_decl( &mut self, node: TsModuleDecl, __ast_path: &mut AstKindPath, ) -> TsModuleDecl

fn fold_ts_module_name( &mut self, node: TsModuleName, __ast_path: &mut AstKindPath, ) -> TsModuleName

fn fold_ts_module_ref( &mut self, node: TsModuleRef, __ast_path: &mut AstKindPath, ) -> TsModuleRef

fn fold_ts_namespace_body( &mut self, node: TsNamespaceBody, __ast_path: &mut AstKindPath, ) -> TsNamespaceBody

fn fold_ts_namespace_decl( &mut self, node: TsNamespaceDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr( &mut self, node: TsNonNullExpr, __ast_path: &mut AstKindPath, ) -> TsNonNullExpr

fn fold_ts_optional_type( &mut self, node: TsOptionalType, __ast_path: &mut AstKindPath, ) -> TsOptionalType

fn fold_ts_param_prop( &mut self, node: TsParamProp, __ast_path: &mut AstKindPath, ) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, __ast_path: &mut AstKindPath, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, __ast_path: &mut AstKindPath, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, __ast_path: &mut AstKindPath, ) -> TsPropertySignature

fn fold_ts_qualified_name( &mut self, node: TsQualifiedName, __ast_path: &mut AstKindPath, ) -> TsQualifiedName

fn fold_ts_rest_type( &mut self, node: TsRestType, __ast_path: &mut AstKindPath, ) -> TsRestType

fn fold_ts_satisfies_expr( &mut self, node: TsSatisfiesExpr, __ast_path: &mut AstKindPath, ) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, __ast_path: &mut AstKindPath, ) -> TsSetterSignature

fn fold_ts_this_param( &mut self, node: TsThisParam, __ast_path: &mut AstKindPath, ) -> TsThisParam

fn fold_ts_this_type( &mut self, node: TsThisType, __ast_path: &mut AstKindPath, ) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, __ast_path: &mut AstKindPath, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type( &mut self, node: TsTplLitType, __ast_path: &mut AstKindPath, ) -> TsTplLitType

fn fold_ts_tuple_element( &mut self, node: TsTupleElement, __ast_path: &mut AstKindPath, ) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type( &mut self, node: TsTupleType, __ast_path: &mut AstKindPath, ) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType

fn fold_ts_type_alias_decl( &mut self, node: TsTypeAliasDecl, __ast_path: &mut AstKindPath, ) -> TsTypeAliasDecl

fn fold_ts_type_ann( &mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath, ) -> TsTypeAnn

fn fold_ts_type_assertion( &mut self, node: TsTypeAssertion, __ast_path: &mut AstKindPath, ) -> TsTypeAssertion

fn fold_ts_type_element( &mut self, node: TsTypeElement, __ast_path: &mut AstKindPath, ) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit( &mut self, node: TsTypeLit, __ast_path: &mut AstKindPath, ) -> TsTypeLit

fn fold_ts_type_operator( &mut self, node: TsTypeOperator, __ast_path: &mut AstKindPath, ) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, __ast_path: &mut AstKindPath, ) -> TsTypeOperatorOp

fn fold_ts_type_param( &mut self, node: TsTypeParam, __ast_path: &mut AstKindPath, ) -> TsTypeParam

fn fold_ts_type_param_decl( &mut self, node: TsTypeParamDecl, __ast_path: &mut AstKindPath, ) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, __ast_path: &mut AstKindPath, ) -> TsTypeParamInstantiation

fn fold_ts_type_params( &mut self, node: Vec<TsTypeParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeParam>

fn fold_ts_type_predicate( &mut self, node: TsTypePredicate, __ast_path: &mut AstKindPath, ) -> TsTypePredicate

fn fold_ts_type_query( &mut self, node: TsTypeQuery, __ast_path: &mut AstKindPath, ) -> TsTypeQuery

fn fold_ts_type_query_expr( &mut self, node: TsTypeQueryExpr, __ast_path: &mut AstKindPath, ) -> TsTypeQueryExpr

fn fold_ts_type_ref( &mut self, node: TsTypeRef, __ast_path: &mut AstKindPath, ) -> TsTypeRef

fn fold_ts_types( &mut self, node: Vec<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, __ast_path: &mut AstKindPath, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type( &mut self, node: TsUnionType, __ast_path: &mut AstKindPath, ) -> TsUnionType

fn fold_unary_expr( &mut self, node: UnaryExpr, __ast_path: &mut AstKindPath, ) -> UnaryExpr

fn fold_unary_op( &mut self, node: UnaryOp, __ast_path: &mut AstKindPath, ) -> UnaryOp

fn fold_update_expr( &mut self, node: UpdateExpr, __ast_path: &mut AstKindPath, ) -> UpdateExpr

fn fold_update_op( &mut self, node: UpdateOp, __ast_path: &mut AstKindPath, ) -> UpdateOp

fn fold_using_decl( &mut self, node: UsingDecl, __ast_path: &mut AstKindPath, ) -> UsingDecl

fn fold_var_decl( &mut self, node: VarDecl, __ast_path: &mut AstKindPath, ) -> VarDecl

fn fold_var_decl_kind( &mut self, node: VarDeclKind, __ast_path: &mut AstKindPath, ) -> VarDeclKind

fn fold_var_decl_or_expr( &mut self, node: VarDeclOrExpr, __ast_path: &mut AstKindPath, ) -> VarDeclOrExpr

fn fold_var_declarator( &mut self, node: VarDeclarator, __ast_path: &mut AstKindPath, ) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, __ast_path: &mut AstKindPath, ) -> Vec<VarDeclarator>

fn fold_while_stmt( &mut self, node: WhileStmt, __ast_path: &mut AstKindPath, ) -> WhileStmt

fn fold_with_stmt( &mut self, node: WithStmt, __ast_path: &mut AstKindPath, ) -> WithStmt

fn fold_wtf_8_atom( &mut self, node: Wtf8Atom, __ast_path: &mut AstKindPath, ) -> Wtf8Atom

fn fold_yield_expr( &mut self, node: YieldExpr, __ast_path: &mut AstKindPath, ) -> YieldExpr

impl<V> FoldAstPath for Box<V>

where V: ?Sized + FoldAstPath,

Available on docsrs or crate feature path only.

fn fold_accessibility( &mut self, node: Accessibility, __ast_path: &mut AstKindPath, ) -> Accessibility

fn fold_array_lit( &mut self, node: ArrayLit, __ast_path: &mut AstKindPath, ) -> ArrayLit

fn fold_array_pat( &mut self, node: ArrayPat, __ast_path: &mut AstKindPath, ) -> ArrayPat

fn fold_arrow_expr( &mut self, node: ArrowExpr, __ast_path: &mut AstKindPath, ) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, __ast_path: &mut AstKindPath, ) -> ArrowFunctionBody

fn fold_assign_expr( &mut self, node: AssignExpr, __ast_path: &mut AstKindPath, ) -> AssignExpr

fn fold_assign_op( &mut self, node: AssignOp, __ast_path: &mut AstKindPath, ) -> AssignOp

fn fold_assign_pat( &mut self, node: AssignPat, __ast_path: &mut AstKindPath, ) -> AssignPat

fn fold_assign_pat_prop( &mut self, node: AssignPatProp, __ast_path: &mut AstKindPath, ) -> AssignPatProp

fn fold_assign_prop( &mut self, node: AssignProp, __ast_path: &mut AstKindPath, ) -> AssignProp

fn fold_assign_target( &mut self, node: AssignTarget, __ast_path: &mut AstKindPath, ) -> AssignTarget

fn fold_assign_target_pat( &mut self, node: AssignTargetPat, __ast_path: &mut AstKindPath, ) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_auto_accessor( &mut self, node: AutoAccessor, __ast_path: &mut AstKindPath, ) -> AutoAccessor

fn fold_await_expr( &mut self, node: AwaitExpr, __ast_path: &mut AstKindPath, ) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt

fn fold_big_int_value( &mut self, node: BigIntValue, __ast_path: &mut AstKindPath, ) -> BigIntValue

fn fold_bin_expr( &mut self, node: BinExpr, __ast_path: &mut AstKindPath, ) -> BinExpr

fn fold_binary_op( &mut self, node: BinaryOp, __ast_path: &mut AstKindPath, ) -> BinaryOp

fn fold_binding_ident( &mut self, node: BindingIdent, __ast_path: &mut AstKindPath, ) -> BindingIdent

fn fold_block_stmt( &mut self, node: BlockStmt, __ast_path: &mut AstKindPath, ) -> BlockStmt

fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool

fn fold_break_stmt( &mut self, node: BreakStmt, __ast_path: &mut AstKindPath, ) -> BreakStmt

fn fold_call_expr( &mut self, node: CallExpr, __ast_path: &mut AstKindPath, ) -> CallExpr

fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee

fn fold_catch_clause( &mut self, node: CatchClause, __ast_path: &mut AstKindPath, ) -> CatchClause

fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class

fn fold_class_decl( &mut self, node: ClassDecl, __ast_path: &mut AstKindPath, ) -> ClassDecl

fn fold_class_expr( &mut self, node: ClassExpr, __ast_path: &mut AstKindPath, ) -> ClassExpr

fn fold_class_member( &mut self, node: ClassMember, __ast_path: &mut AstKindPath, ) -> ClassMember

fn fold_class_members( &mut self, node: Vec<ClassMember>, __ast_path: &mut AstKindPath, ) -> Vec<ClassMember>

fn fold_class_method( &mut self, node: ClassMethod, __ast_path: &mut AstKindPath, ) -> ClassMethod

fn fold_class_prop( &mut self, node: ClassProp, __ast_path: &mut AstKindPath, ) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, __ast_path: &mut AstKindPath, ) -> ComputedPropName

fn fold_cond_expr( &mut self, node: CondExpr, __ast_path: &mut AstKindPath, ) -> CondExpr

fn fold_constructor( &mut self, node: Constructor, __ast_path: &mut AstKindPath, ) -> Constructor

fn fold_continue_stmt( &mut self, node: ContinueStmt, __ast_path: &mut AstKindPath, ) -> ContinueStmt

fn fold_debugger_stmt( &mut self, node: DebuggerStmt, __ast_path: &mut AstKindPath, ) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl

fn fold_decorator( &mut self, node: Decorator, __ast_path: &mut AstKindPath, ) -> Decorator

fn fold_decorators( &mut self, node: Vec<Decorator>, __ast_path: &mut AstKindPath, ) -> Vec<Decorator>

fn fold_default_decl( &mut self, node: DefaultDecl, __ast_path: &mut AstKindPath, ) -> DefaultDecl

fn fold_do_while_stmt( &mut self, node: DoWhileStmt, __ast_path: &mut AstKindPath, ) -> DoWhileStmt

fn fold_empty_stmt( &mut self, node: EmptyStmt, __ast_path: &mut AstKindPath, ) -> EmptyStmt

fn fold_export_all( &mut self, node: ExportAll, __ast_path: &mut AstKindPath, ) -> ExportAll

fn fold_export_decl( &mut self, node: ExportDecl, __ast_path: &mut AstKindPath, ) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, __ast_path: &mut AstKindPath, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, __ast_path: &mut AstKindPath, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamespaceSpecifier

fn fold_export_specifier( &mut self, node: ExportSpecifier, __ast_path: &mut AstKindPath, ) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr

fn fold_expr_or_spread( &mut self, node: ExprOrSpread, __ast_path: &mut AstKindPath, ) -> ExprOrSpread

fn fold_expr_or_spreads( &mut self, node: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<ExprOrSpread>

fn fold_expr_stmt( &mut self, node: ExprStmt, __ast_path: &mut AstKindPath, ) -> ExprStmt

fn fold_exprs( &mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

fn fold_for_head( &mut self, node: ForHead, __ast_path: &mut AstKindPath, ) -> ForHead

fn fold_for_in_stmt( &mut self, node: ForInStmt, __ast_path: &mut AstKindPath, ) -> ForInStmt

fn fold_for_of_stmt( &mut self, node: ForOfStmt, __ast_path: &mut AstKindPath, ) -> ForOfStmt

fn fold_for_stmt( &mut self, node: ForStmt, __ast_path: &mut AstKindPath, ) -> ForStmt

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_body( &mut self, node: FunctionBody, __ast_path: &mut AstKindPath, ) -> FunctionBody

fn fold_getter_prop( &mut self, node: GetterProp, __ast_path: &mut AstKindPath, ) -> GetterProp

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_ident_name( &mut self, node: IdentName, __ast_path: &mut AstKindPath, ) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import

fn fold_import_decl( &mut self, node: ImportDecl, __ast_path: &mut AstKindPath, ) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ImportNamedSpecifier

fn fold_import_phase( &mut self, node: ImportPhase, __ast_path: &mut AstKindPath, ) -> ImportPhase

fn fold_import_specifier( &mut self, node: ImportSpecifier, __ast_path: &mut AstKindPath, ) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, __ast_path: &mut AstKindPath, ) -> ImportStarAsSpecifier

fn fold_import_with( &mut self, node: ImportWith, __ast_path: &mut AstKindPath, ) -> ImportWith

fn fold_import_with_item( &mut self, node: ImportWithItem, __ast_path: &mut AstKindPath, ) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, __ast_path: &mut AstKindPath, ) -> Vec<ImportWithItem>

fn fold_invalid( &mut self, node: Invalid, __ast_path: &mut AstKindPath, ) -> Invalid

fn fold_jsx_attr( &mut self, node: JSXAttr, __ast_path: &mut AstKindPath, ) -> JSXAttr

fn fold_jsx_attr_name( &mut self, node: JSXAttrName, __ast_path: &mut AstKindPath, ) -> JSXAttrName

fn fold_jsx_attr_or_spread( &mut self, node: JSXAttrOrSpread, __ast_path: &mut AstKindPath, ) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value( &mut self, node: JSXAttrValue, __ast_path: &mut AstKindPath, ) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, __ast_path: &mut AstKindPath, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, __ast_path: &mut AstKindPath, ) -> JSXClosingFragment

fn fold_jsx_element( &mut self, node: JSXElement, __ast_path: &mut AstKindPath, ) -> JSXElement

fn fold_jsx_element_child( &mut self, node: JSXElementChild, __ast_path: &mut AstKindPath, ) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, __ast_path: &mut AstKindPath, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name( &mut self, node: JSXElementName, __ast_path: &mut AstKindPath, ) -> JSXElementName

fn fold_jsx_empty_expr( &mut self, node: JSXEmptyExpr, __ast_path: &mut AstKindPath, ) -> JSXEmptyExpr

fn fold_jsx_expr( &mut self, node: JSXExpr, __ast_path: &mut AstKindPath, ) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, __ast_path: &mut AstKindPath, ) -> JSXExprContainer

fn fold_jsx_fragment( &mut self, node: JSXFragment, __ast_path: &mut AstKindPath, ) -> JSXFragment

fn fold_jsx_member_expr( &mut self, node: JSXMemberExpr, __ast_path: &mut AstKindPath, ) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, __ast_path: &mut AstKindPath, ) -> JSXNamespacedName

fn fold_jsx_object( &mut self, node: JSXObject, __ast_path: &mut AstKindPath, ) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, __ast_path: &mut AstKindPath, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, __ast_path: &mut AstKindPath, ) -> JSXOpeningFragment

fn fold_jsx_spread_child( &mut self, node: JSXSpreadChild, __ast_path: &mut AstKindPath, ) -> JSXSpreadChild

fn fold_jsx_text( &mut self, node: JSXText, __ast_path: &mut AstKindPath, ) -> JSXText

fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key

fn fold_key_value_pat_prop( &mut self, node: KeyValuePatProp, __ast_path: &mut AstKindPath, ) -> KeyValuePatProp

fn fold_key_value_prop( &mut self, node: KeyValueProp, __ast_path: &mut AstKindPath, ) -> KeyValueProp

fn fold_labeled_stmt( &mut self, node: LabeledStmt, __ast_path: &mut AstKindPath, ) -> LabeledStmt

fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit

fn fold_member_expr( &mut self, node: MemberExpr, __ast_path: &mut AstKindPath, ) -> MemberExpr

fn fold_member_prop( &mut self, node: MemberProp, __ast_path: &mut AstKindPath, ) -> MemberProp

fn fold_meta_prop_expr( &mut self, node: MetaPropExpr, __ast_path: &mut AstKindPath, ) -> MetaPropExpr

fn fold_meta_prop_kind( &mut self, node: MetaPropKind, __ast_path: &mut AstKindPath, ) -> MetaPropKind

fn fold_method_kind( &mut self, node: MethodKind, __ast_path: &mut AstKindPath, ) -> MethodKind

fn fold_method_prop( &mut self, node: MethodProp, __ast_path: &mut AstKindPath, ) -> MethodProp

fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module

fn fold_module_decl( &mut self, node: ModuleDecl, __ast_path: &mut AstKindPath, ) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, __ast_path: &mut AstKindPath, ) -> ModuleExportName

fn fold_module_item( &mut self, node: ModuleItem, __ast_path: &mut AstKindPath, ) -> ModuleItem

fn fold_module_items( &mut self, node: Vec<ModuleItem>, __ast_path: &mut AstKindPath, ) -> Vec<ModuleItem>

fn fold_named_export( &mut self, node: NamedExport, __ast_path: &mut AstKindPath, ) -> NamedExport

fn fold_new_expr( &mut self, node: NewExpr, __ast_path: &mut AstKindPath, ) -> NewExpr

fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_object_lit( &mut self, node: ObjectLit, __ast_path: &mut AstKindPath, ) -> ObjectLit

fn fold_object_pat( &mut self, node: ObjectPat, __ast_path: &mut AstKindPath, ) -> ObjectPat

fn fold_object_pat_prop( &mut self, node: ObjectPatProp, __ast_path: &mut AstKindPath, ) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, __ast_path: &mut AstKindPath, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, __ast_path: &mut AstKindPath, ) -> Option<Accessibility>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_block_stmt( &mut self, node: Option<BlockStmt>, __ast_path: &mut AstKindPath, ) -> Option<BlockStmt>

fn fold_opt_call( &mut self, node: OptCall, __ast_path: &mut AstKindPath, ) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, __ast_path: &mut AstKindPath, ) -> Option<CatchClause>

fn fold_opt_chain_base( &mut self, node: OptChainBase, __ast_path: &mut AstKindPath, ) -> OptChainBase

fn fold_opt_chain_expr( &mut self, node: OptChainExpr, __ast_path: &mut AstKindPath, ) -> OptChainExpr

fn fold_opt_expr( &mut self, node: Option<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, __ast_path: &mut AstKindPath, ) -> Option<FunctionBody>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, __ast_path: &mut AstKindPath, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, __ast_path: &mut AstKindPath, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, __ast_path: &mut AstKindPath, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat( &mut self, node: Option<Pat>, __ast_path: &mut AstKindPath, ) -> Option<Pat>

fn fold_opt_span( &mut self, node: Option<Span>, __ast_path: &mut AstKindPath, ) -> Option<Span>

fn fold_opt_stmt( &mut self, node: Option<Box<Stmt>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Stmt>>

fn fold_opt_str( &mut self, node: Option<Box<Str>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, __ast_path: &mut AstKindPath, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, __ast_path: &mut AstKindPath, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, __ast_path: &mut AstKindPath, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, __ast_path: &mut AstKindPath, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type( &mut self, node: Option<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, __ast_path: &mut AstKindPath, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats( &mut self, node: Vec<Option<Pat>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom( &mut self, node: Option<Wtf8Atom>, __ast_path: &mut AstKindPath, ) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, __ast_path: &mut AstKindPath, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, __ast_path: &mut AstKindPath, ) -> Vec<ParamOrTsParamProp>

fn fold_params( &mut self, node: Vec<Param>, __ast_path: &mut AstKindPath, ) -> Vec<Param>

fn fold_paren_expr( &mut self, node: ParenExpr, __ast_path: &mut AstKindPath, ) -> ParenExpr

fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat

fn fold_pats( &mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath, ) -> Vec<Pat>

fn fold_private_method( &mut self, node: PrivateMethod, __ast_path: &mut AstKindPath, ) -> PrivateMethod

fn fold_private_name( &mut self, node: PrivateName, __ast_path: &mut AstKindPath, ) -> PrivateName

fn fold_private_prop( &mut self, node: PrivateProp, __ast_path: &mut AstKindPath, ) -> PrivateProp

fn fold_program( &mut self, node: Program, __ast_path: &mut AstKindPath, ) -> Program

fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop

fn fold_prop_name( &mut self, node: PropName, __ast_path: &mut AstKindPath, ) -> PropName

fn fold_prop_or_spread( &mut self, node: PropOrSpread, __ast_path: &mut AstKindPath, ) -> PropOrSpread

fn fold_prop_or_spreads( &mut self, node: Vec<PropOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex

fn fold_rest_pat( &mut self, node: RestPat, __ast_path: &mut AstKindPath, ) -> RestPat

fn fold_return_stmt( &mut self, node: ReturnStmt, __ast_path: &mut AstKindPath, ) -> ReturnStmt

fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script

fn fold_seq_expr( &mut self, node: SeqExpr, __ast_path: &mut AstKindPath, ) -> SeqExpr

fn fold_setter_prop( &mut self, node: SetterProp, __ast_path: &mut AstKindPath, ) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, __ast_path: &mut AstKindPath, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_spread_element( &mut self, node: SpreadElement, __ast_path: &mut AstKindPath, ) -> SpreadElement

fn fold_static_block( &mut self, node: StaticBlock, __ast_path: &mut AstKindPath, ) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt

fn fold_stmts( &mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath, ) -> Vec<Stmt>

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super

fn fold_super_prop( &mut self, node: SuperProp, __ast_path: &mut AstKindPath, ) -> SuperProp

fn fold_super_prop_expr( &mut self, node: SuperPropExpr, __ast_path: &mut AstKindPath, ) -> SuperPropExpr

fn fold_switch_case( &mut self, node: SwitchCase, __ast_path: &mut AstKindPath, ) -> SwitchCase

fn fold_switch_cases( &mut self, node: Vec<SwitchCase>, __ast_path: &mut AstKindPath, ) -> Vec<SwitchCase>

fn fold_switch_stmt( &mut self, node: SwitchStmt, __ast_path: &mut AstKindPath, ) -> SwitchStmt

fn fold_syntax_context( &mut self, node: SyntaxContext, __ast_path: &mut AstKindPath, ) -> SyntaxContext

fn fold_tagged_tpl( &mut self, node: TaggedTpl, __ast_path: &mut AstKindPath, ) -> TaggedTpl

fn fold_this_expr( &mut self, node: ThisExpr, __ast_path: &mut AstKindPath, ) -> ThisExpr

fn fold_throw_stmt( &mut self, node: ThrowStmt, __ast_path: &mut AstKindPath, ) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl

fn fold_tpl_element( &mut self, node: TplElement, __ast_path: &mut AstKindPath, ) -> TplElement

fn fold_tpl_elements( &mut self, node: Vec<TplElement>, __ast_path: &mut AstKindPath, ) -> Vec<TplElement>

fn fold_true_plus_minus( &mut self, node: TruePlusMinus, __ast_path: &mut AstKindPath, ) -> TruePlusMinus

fn fold_try_stmt( &mut self, node: TryStmt, __ast_path: &mut AstKindPath, ) -> TryStmt

fn fold_ts_array_type( &mut self, node: TsArrayType, __ast_path: &mut AstKindPath, ) -> TsArrayType

fn fold_ts_as_expr( &mut self, node: TsAsExpr, __ast_path: &mut AstKindPath, ) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, __ast_path: &mut AstKindPath, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, __ast_path: &mut AstKindPath, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, __ast_path: &mut AstKindPath, ) -> TsConstructorType

fn fold_ts_entity_name( &mut self, node: TsEntityName, __ast_path: &mut AstKindPath, ) -> TsEntityName

fn fold_ts_enum_decl( &mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath, ) -> TsEnumDecl

fn fold_ts_enum_member( &mut self, node: TsEnumMember, __ast_path: &mut AstKindPath, ) -> TsEnumMember

fn fold_ts_enum_member_id( &mut self, node: TsEnumMemberId, __ast_path: &mut AstKindPath, ) -> TsEnumMemberId

fn fold_ts_enum_members( &mut self, node: Vec<TsEnumMember>, __ast_path: &mut AstKindPath, ) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, __ast_path: &mut AstKindPath, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, __ast_path: &mut AstKindPath, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, __ast_path: &mut AstKindPath, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, __ast_path: &mut AstKindPath, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, __ast_path: &mut AstKindPath, ) -> TsFnOrConstructorType

fn fold_ts_fn_param( &mut self, node: TsFnParam, __ast_path: &mut AstKindPath, ) -> TsFnParam

fn fold_ts_fn_params( &mut self, node: Vec<TsFnParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsFnParam>

fn fold_ts_fn_type( &mut self, node: TsFnType, __ast_path: &mut AstKindPath, ) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, __ast_path: &mut AstKindPath, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, __ast_path: &mut AstKindPath, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, __ast_path: &mut AstKindPath, ) -> TsImportEqualsDecl

fn fold_ts_import_type( &mut self, node: TsImportType, __ast_path: &mut AstKindPath, ) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, __ast_path: &mut AstKindPath, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, __ast_path: &mut AstKindPath, ) -> TsIndexedAccessType

fn fold_ts_infer_type( &mut self, node: TsInferType, __ast_path: &mut AstKindPath, ) -> TsInferType

fn fold_ts_instantiation( &mut self, node: TsInstantiation, __ast_path: &mut AstKindPath, ) -> TsInstantiation

fn fold_ts_interface_body( &mut self, node: TsInterfaceBody, __ast_path: &mut AstKindPath, ) -> TsInterfaceBody

fn fold_ts_interface_decl( &mut self, node: TsInterfaceDecl, __ast_path: &mut AstKindPath, ) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, __ast_path: &mut AstKindPath, ) -> TsIntersectionType

fn fold_ts_keyword_type( &mut self, node: TsKeywordType, __ast_path: &mut AstKindPath, ) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, __ast_path: &mut AstKindPath, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit

fn fold_ts_lit_type( &mut self, node: TsLitType, __ast_path: &mut AstKindPath, ) -> TsLitType

fn fold_ts_mapped_type( &mut self, node: TsMappedType, __ast_path: &mut AstKindPath, ) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, __ast_path: &mut AstKindPath, ) -> TsMethodSignature

fn fold_ts_module_block( &mut self, node: TsModuleBlock, __ast_path: &mut AstKindPath, ) -> TsModuleBlock

fn fold_ts_module_decl( &mut self, node: TsModuleDecl, __ast_path: &mut AstKindPath, ) -> TsModuleDecl

fn fold_ts_module_name( &mut self, node: TsModuleName, __ast_path: &mut AstKindPath, ) -> TsModuleName

fn fold_ts_module_ref( &mut self, node: TsModuleRef, __ast_path: &mut AstKindPath, ) -> TsModuleRef

fn fold_ts_namespace_body( &mut self, node: TsNamespaceBody, __ast_path: &mut AstKindPath, ) -> TsNamespaceBody

fn fold_ts_namespace_decl( &mut self, node: TsNamespaceDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr( &mut self, node: TsNonNullExpr, __ast_path: &mut AstKindPath, ) -> TsNonNullExpr

fn fold_ts_optional_type( &mut self, node: TsOptionalType, __ast_path: &mut AstKindPath, ) -> TsOptionalType

fn fold_ts_param_prop( &mut self, node: TsParamProp, __ast_path: &mut AstKindPath, ) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, __ast_path: &mut AstKindPath, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, __ast_path: &mut AstKindPath, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, __ast_path: &mut AstKindPath, ) -> TsPropertySignature

fn fold_ts_qualified_name( &mut self, node: TsQualifiedName, __ast_path: &mut AstKindPath, ) -> TsQualifiedName

fn fold_ts_rest_type( &mut self, node: TsRestType, __ast_path: &mut AstKindPath, ) -> TsRestType

fn fold_ts_satisfies_expr( &mut self, node: TsSatisfiesExpr, __ast_path: &mut AstKindPath, ) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, __ast_path: &mut AstKindPath, ) -> TsSetterSignature

fn fold_ts_this_param( &mut self, node: TsThisParam, __ast_path: &mut AstKindPath, ) -> TsThisParam

fn fold_ts_this_type( &mut self, node: TsThisType, __ast_path: &mut AstKindPath, ) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, __ast_path: &mut AstKindPath, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type( &mut self, node: TsTplLitType, __ast_path: &mut AstKindPath, ) -> TsTplLitType

fn fold_ts_tuple_element( &mut self, node: TsTupleElement, __ast_path: &mut AstKindPath, ) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type( &mut self, node: TsTupleType, __ast_path: &mut AstKindPath, ) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType

fn fold_ts_type_alias_decl( &mut self, node: TsTypeAliasDecl, __ast_path: &mut AstKindPath, ) -> TsTypeAliasDecl

fn fold_ts_type_ann( &mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath, ) -> TsTypeAnn

fn fold_ts_type_assertion( &mut self, node: TsTypeAssertion, __ast_path: &mut AstKindPath, ) -> TsTypeAssertion

fn fold_ts_type_element( &mut self, node: TsTypeElement, __ast_path: &mut AstKindPath, ) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit( &mut self, node: TsTypeLit, __ast_path: &mut AstKindPath, ) -> TsTypeLit

fn fold_ts_type_operator( &mut self, node: TsTypeOperator, __ast_path: &mut AstKindPath, ) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, __ast_path: &mut AstKindPath, ) -> TsTypeOperatorOp

fn fold_ts_type_param( &mut self, node: TsTypeParam, __ast_path: &mut AstKindPath, ) -> TsTypeParam

fn fold_ts_type_param_decl( &mut self, node: TsTypeParamDecl, __ast_path: &mut AstKindPath, ) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, __ast_path: &mut AstKindPath, ) -> TsTypeParamInstantiation

fn fold_ts_type_params( &mut self, node: Vec<TsTypeParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeParam>

fn fold_ts_type_predicate( &mut self, node: TsTypePredicate, __ast_path: &mut AstKindPath, ) -> TsTypePredicate

fn fold_ts_type_query( &mut self, node: TsTypeQuery, __ast_path: &mut AstKindPath, ) -> TsTypeQuery

fn fold_ts_type_query_expr( &mut self, node: TsTypeQueryExpr, __ast_path: &mut AstKindPath, ) -> TsTypeQueryExpr

fn fold_ts_type_ref( &mut self, node: TsTypeRef, __ast_path: &mut AstKindPath, ) -> TsTypeRef

fn fold_ts_types( &mut self, node: Vec<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, __ast_path: &mut AstKindPath, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type( &mut self, node: TsUnionType, __ast_path: &mut AstKindPath, ) -> TsUnionType

fn fold_unary_expr( &mut self, node: UnaryExpr, __ast_path: &mut AstKindPath, ) -> UnaryExpr

fn fold_unary_op( &mut self, node: UnaryOp, __ast_path: &mut AstKindPath, ) -> UnaryOp

fn fold_update_expr( &mut self, node: UpdateExpr, __ast_path: &mut AstKindPath, ) -> UpdateExpr

fn fold_update_op( &mut self, node: UpdateOp, __ast_path: &mut AstKindPath, ) -> UpdateOp

fn fold_using_decl( &mut self, node: UsingDecl, __ast_path: &mut AstKindPath, ) -> UsingDecl

fn fold_var_decl( &mut self, node: VarDecl, __ast_path: &mut AstKindPath, ) -> VarDecl

fn fold_var_decl_kind( &mut self, node: VarDeclKind, __ast_path: &mut AstKindPath, ) -> VarDeclKind

fn fold_var_decl_or_expr( &mut self, node: VarDeclOrExpr, __ast_path: &mut AstKindPath, ) -> VarDeclOrExpr

fn fold_var_declarator( &mut self, node: VarDeclarator, __ast_path: &mut AstKindPath, ) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, __ast_path: &mut AstKindPath, ) -> Vec<VarDeclarator>

fn fold_while_stmt( &mut self, node: WhileStmt, __ast_path: &mut AstKindPath, ) -> WhileStmt

fn fold_with_stmt( &mut self, node: WithStmt, __ast_path: &mut AstKindPath, ) -> WithStmt

fn fold_wtf_8_atom( &mut self, node: Wtf8Atom, __ast_path: &mut AstKindPath, ) -> Wtf8Atom

fn fold_yield_expr( &mut self, node: YieldExpr, __ast_path: &mut AstKindPath, ) -> YieldExpr

impl<V> FoldAstPath for Optional<V>

where V: FoldAstPath,

Available on docsrs or crate feature path only.

fn fold_accessibility( &mut self, node: Accessibility, __ast_path: &mut AstKindPath, ) -> Accessibility

fn fold_array_lit( &mut self, node: ArrayLit, __ast_path: &mut AstKindPath, ) -> ArrayLit

fn fold_array_pat( &mut self, node: ArrayPat, __ast_path: &mut AstKindPath, ) -> ArrayPat

fn fold_arrow_expr( &mut self, node: ArrowExpr, __ast_path: &mut AstKindPath, ) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, __ast_path: &mut AstKindPath, ) -> ArrowFunctionBody

fn fold_assign_expr( &mut self, node: AssignExpr, __ast_path: &mut AstKindPath, ) -> AssignExpr

fn fold_assign_op( &mut self, node: AssignOp, __ast_path: &mut AstKindPath, ) -> AssignOp

fn fold_assign_pat( &mut self, node: AssignPat, __ast_path: &mut AstKindPath, ) -> AssignPat

fn fold_assign_pat_prop( &mut self, node: AssignPatProp, __ast_path: &mut AstKindPath, ) -> AssignPatProp

fn fold_assign_prop( &mut self, node: AssignProp, __ast_path: &mut AstKindPath, ) -> AssignProp

fn fold_assign_target( &mut self, node: AssignTarget, __ast_path: &mut AstKindPath, ) -> AssignTarget

fn fold_assign_target_pat( &mut self, node: AssignTargetPat, __ast_path: &mut AstKindPath, ) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_auto_accessor( &mut self, node: AutoAccessor, __ast_path: &mut AstKindPath, ) -> AutoAccessor

fn fold_await_expr( &mut self, node: AwaitExpr, __ast_path: &mut AstKindPath, ) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt

fn fold_big_int_value( &mut self, node: BigIntValue, __ast_path: &mut AstKindPath, ) -> BigIntValue

fn fold_bin_expr( &mut self, node: BinExpr, __ast_path: &mut AstKindPath, ) -> BinExpr

fn fold_binary_op( &mut self, node: BinaryOp, __ast_path: &mut AstKindPath, ) -> BinaryOp

fn fold_binding_ident( &mut self, node: BindingIdent, __ast_path: &mut AstKindPath, ) -> BindingIdent

fn fold_block_stmt( &mut self, node: BlockStmt, __ast_path: &mut AstKindPath, ) -> BlockStmt

fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool

fn fold_break_stmt( &mut self, node: BreakStmt, __ast_path: &mut AstKindPath, ) -> BreakStmt

fn fold_call_expr( &mut self, node: CallExpr, __ast_path: &mut AstKindPath, ) -> CallExpr

fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee

fn fold_catch_clause( &mut self, node: CatchClause, __ast_path: &mut AstKindPath, ) -> CatchClause

fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class

fn fold_class_decl( &mut self, node: ClassDecl, __ast_path: &mut AstKindPath, ) -> ClassDecl

fn fold_class_expr( &mut self, node: ClassExpr, __ast_path: &mut AstKindPath, ) -> ClassExpr

fn fold_class_member( &mut self, node: ClassMember, __ast_path: &mut AstKindPath, ) -> ClassMember

fn fold_class_members( &mut self, node: Vec<ClassMember>, __ast_path: &mut AstKindPath, ) -> Vec<ClassMember>

fn fold_class_method( &mut self, node: ClassMethod, __ast_path: &mut AstKindPath, ) -> ClassMethod

fn fold_class_prop( &mut self, node: ClassProp, __ast_path: &mut AstKindPath, ) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, __ast_path: &mut AstKindPath, ) -> ComputedPropName

fn fold_cond_expr( &mut self, node: CondExpr, __ast_path: &mut AstKindPath, ) -> CondExpr

fn fold_constructor( &mut self, node: Constructor, __ast_path: &mut AstKindPath, ) -> Constructor

fn fold_continue_stmt( &mut self, node: ContinueStmt, __ast_path: &mut AstKindPath, ) -> ContinueStmt

fn fold_debugger_stmt( &mut self, node: DebuggerStmt, __ast_path: &mut AstKindPath, ) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl

fn fold_decorator( &mut self, node: Decorator, __ast_path: &mut AstKindPath, ) -> Decorator

fn fold_decorators( &mut self, node: Vec<Decorator>, __ast_path: &mut AstKindPath, ) -> Vec<Decorator>

fn fold_default_decl( &mut self, node: DefaultDecl, __ast_path: &mut AstKindPath, ) -> DefaultDecl

fn fold_do_while_stmt( &mut self, node: DoWhileStmt, __ast_path: &mut AstKindPath, ) -> DoWhileStmt

fn fold_empty_stmt( &mut self, node: EmptyStmt, __ast_path: &mut AstKindPath, ) -> EmptyStmt

fn fold_export_all( &mut self, node: ExportAll, __ast_path: &mut AstKindPath, ) -> ExportAll

fn fold_export_decl( &mut self, node: ExportDecl, __ast_path: &mut AstKindPath, ) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, __ast_path: &mut AstKindPath, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, __ast_path: &mut AstKindPath, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath, ) -> ExportNamespaceSpecifier

fn fold_export_specifier( &mut self, node: ExportSpecifier, __ast_path: &mut AstKindPath, ) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr

fn fold_expr_or_spread( &mut self, node: ExprOrSpread, __ast_path: &mut AstKindPath, ) -> ExprOrSpread

fn fold_expr_or_spreads( &mut self, node: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<ExprOrSpread>

fn fold_expr_stmt( &mut self, node: ExprStmt, __ast_path: &mut AstKindPath, ) -> ExprStmt

fn fold_exprs( &mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

fn fold_for_head( &mut self, node: ForHead, __ast_path: &mut AstKindPath, ) -> ForHead

fn fold_for_in_stmt( &mut self, node: ForInStmt, __ast_path: &mut AstKindPath, ) -> ForInStmt

fn fold_for_of_stmt( &mut self, node: ForOfStmt, __ast_path: &mut AstKindPath, ) -> ForOfStmt

fn fold_for_stmt( &mut self, node: ForStmt, __ast_path: &mut AstKindPath, ) -> ForStmt

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_body( &mut self, node: FunctionBody, __ast_path: &mut AstKindPath, ) -> FunctionBody

fn fold_getter_prop( &mut self, node: GetterProp, __ast_path: &mut AstKindPath, ) -> GetterProp

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_ident_name( &mut self, node: IdentName, __ast_path: &mut AstKindPath, ) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import

fn fold_import_decl( &mut self, node: ImportDecl, __ast_path: &mut AstKindPath, ) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, __ast_path: &mut AstKindPath, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, __ast_path: &mut AstKindPath, ) -> ImportNamedSpecifier

fn fold_import_phase( &mut self, node: ImportPhase, __ast_path: &mut AstKindPath, ) -> ImportPhase

fn fold_import_specifier( &mut self, node: ImportSpecifier, __ast_path: &mut AstKindPath, ) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, __ast_path: &mut AstKindPath, ) -> ImportStarAsSpecifier

fn fold_import_with( &mut self, node: ImportWith, __ast_path: &mut AstKindPath, ) -> ImportWith

fn fold_import_with_item( &mut self, node: ImportWithItem, __ast_path: &mut AstKindPath, ) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, __ast_path: &mut AstKindPath, ) -> Vec<ImportWithItem>

fn fold_invalid( &mut self, node: Invalid, __ast_path: &mut AstKindPath, ) -> Invalid

fn fold_jsx_attr( &mut self, node: JSXAttr, __ast_path: &mut AstKindPath, ) -> JSXAttr

fn fold_jsx_attr_name( &mut self, node: JSXAttrName, __ast_path: &mut AstKindPath, ) -> JSXAttrName

fn fold_jsx_attr_or_spread( &mut self, node: JSXAttrOrSpread, __ast_path: &mut AstKindPath, ) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value( &mut self, node: JSXAttrValue, __ast_path: &mut AstKindPath, ) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, __ast_path: &mut AstKindPath, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, __ast_path: &mut AstKindPath, ) -> JSXClosingFragment

fn fold_jsx_element( &mut self, node: JSXElement, __ast_path: &mut AstKindPath, ) -> JSXElement

fn fold_jsx_element_child( &mut self, node: JSXElementChild, __ast_path: &mut AstKindPath, ) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, __ast_path: &mut AstKindPath, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name( &mut self, node: JSXElementName, __ast_path: &mut AstKindPath, ) -> JSXElementName

fn fold_jsx_empty_expr( &mut self, node: JSXEmptyExpr, __ast_path: &mut AstKindPath, ) -> JSXEmptyExpr

fn fold_jsx_expr( &mut self, node: JSXExpr, __ast_path: &mut AstKindPath, ) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, __ast_path: &mut AstKindPath, ) -> JSXExprContainer

fn fold_jsx_fragment( &mut self, node: JSXFragment, __ast_path: &mut AstKindPath, ) -> JSXFragment

fn fold_jsx_member_expr( &mut self, node: JSXMemberExpr, __ast_path: &mut AstKindPath, ) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, __ast_path: &mut AstKindPath, ) -> JSXNamespacedName

fn fold_jsx_object( &mut self, node: JSXObject, __ast_path: &mut AstKindPath, ) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, __ast_path: &mut AstKindPath, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, __ast_path: &mut AstKindPath, ) -> JSXOpeningFragment

fn fold_jsx_spread_child( &mut self, node: JSXSpreadChild, __ast_path: &mut AstKindPath, ) -> JSXSpreadChild

fn fold_jsx_text( &mut self, node: JSXText, __ast_path: &mut AstKindPath, ) -> JSXText

fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key

fn fold_key_value_pat_prop( &mut self, node: KeyValuePatProp, __ast_path: &mut AstKindPath, ) -> KeyValuePatProp

fn fold_key_value_prop( &mut self, node: KeyValueProp, __ast_path: &mut AstKindPath, ) -> KeyValueProp

fn fold_labeled_stmt( &mut self, node: LabeledStmt, __ast_path: &mut AstKindPath, ) -> LabeledStmt

fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit

fn fold_member_expr( &mut self, node: MemberExpr, __ast_path: &mut AstKindPath, ) -> MemberExpr

fn fold_member_prop( &mut self, node: MemberProp, __ast_path: &mut AstKindPath, ) -> MemberProp

fn fold_meta_prop_expr( &mut self, node: MetaPropExpr, __ast_path: &mut AstKindPath, ) -> MetaPropExpr

fn fold_meta_prop_kind( &mut self, node: MetaPropKind, __ast_path: &mut AstKindPath, ) -> MetaPropKind

fn fold_method_kind( &mut self, node: MethodKind, __ast_path: &mut AstKindPath, ) -> MethodKind

fn fold_method_prop( &mut self, node: MethodProp, __ast_path: &mut AstKindPath, ) -> MethodProp

fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module

fn fold_module_decl( &mut self, node: ModuleDecl, __ast_path: &mut AstKindPath, ) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, __ast_path: &mut AstKindPath, ) -> ModuleExportName

fn fold_module_item( &mut self, node: ModuleItem, __ast_path: &mut AstKindPath, ) -> ModuleItem

fn fold_module_items( &mut self, node: Vec<ModuleItem>, __ast_path: &mut AstKindPath, ) -> Vec<ModuleItem>

fn fold_named_export( &mut self, node: NamedExport, __ast_path: &mut AstKindPath, ) -> NamedExport

fn fold_new_expr( &mut self, node: NewExpr, __ast_path: &mut AstKindPath, ) -> NewExpr

fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_object_lit( &mut self, node: ObjectLit, __ast_path: &mut AstKindPath, ) -> ObjectLit

fn fold_object_pat( &mut self, node: ObjectPat, __ast_path: &mut AstKindPath, ) -> ObjectPat

fn fold_object_pat_prop( &mut self, node: ObjectPatProp, __ast_path: &mut AstKindPath, ) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, __ast_path: &mut AstKindPath, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, __ast_path: &mut AstKindPath, ) -> Option<Accessibility>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_block_stmt( &mut self, node: Option<BlockStmt>, __ast_path: &mut AstKindPath, ) -> Option<BlockStmt>

fn fold_opt_call( &mut self, node: OptCall, __ast_path: &mut AstKindPath, ) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, __ast_path: &mut AstKindPath, ) -> Option<CatchClause>

fn fold_opt_chain_base( &mut self, node: OptChainBase, __ast_path: &mut AstKindPath, ) -> OptChainBase

fn fold_opt_chain_expr( &mut self, node: OptChainExpr, __ast_path: &mut AstKindPath, ) -> OptChainExpr

fn fold_opt_expr( &mut self, node: Option<Box<Expr>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, __ast_path: &mut AstKindPath, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, __ast_path: &mut AstKindPath, ) -> Option<FunctionBody>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, __ast_path: &mut AstKindPath, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, __ast_path: &mut AstKindPath, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, __ast_path: &mut AstKindPath, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat( &mut self, node: Option<Pat>, __ast_path: &mut AstKindPath, ) -> Option<Pat>

fn fold_opt_span( &mut self, node: Option<Span>, __ast_path: &mut AstKindPath, ) -> Option<Span>

fn fold_opt_stmt( &mut self, node: Option<Box<Stmt>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Stmt>>

fn fold_opt_str( &mut self, node: Option<Box<Str>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, __ast_path: &mut AstKindPath, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, __ast_path: &mut AstKindPath, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, __ast_path: &mut AstKindPath, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, __ast_path: &mut AstKindPath, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type( &mut self, node: Option<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, __ast_path: &mut AstKindPath, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats( &mut self, node: Vec<Option<Pat>>, __ast_path: &mut AstKindPath, ) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom( &mut self, node: Option<Wtf8Atom>, __ast_path: &mut AstKindPath, ) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, __ast_path: &mut AstKindPath, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, __ast_path: &mut AstKindPath, ) -> Vec<ParamOrTsParamProp>

fn fold_params( &mut self, node: Vec<Param>, __ast_path: &mut AstKindPath, ) -> Vec<Param>

fn fold_paren_expr( &mut self, node: ParenExpr, __ast_path: &mut AstKindPath, ) -> ParenExpr

fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat

fn fold_pats( &mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath, ) -> Vec<Pat>

fn fold_private_method( &mut self, node: PrivateMethod, __ast_path: &mut AstKindPath, ) -> PrivateMethod

fn fold_private_name( &mut self, node: PrivateName, __ast_path: &mut AstKindPath, ) -> PrivateName

fn fold_private_prop( &mut self, node: PrivateProp, __ast_path: &mut AstKindPath, ) -> PrivateProp

fn fold_program( &mut self, node: Program, __ast_path: &mut AstKindPath, ) -> Program

fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop

fn fold_prop_name( &mut self, node: PropName, __ast_path: &mut AstKindPath, ) -> PropName

fn fold_prop_or_spread( &mut self, node: PropOrSpread, __ast_path: &mut AstKindPath, ) -> PropOrSpread

fn fold_prop_or_spreads( &mut self, node: Vec<PropOrSpread>, __ast_path: &mut AstKindPath, ) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex

fn fold_rest_pat( &mut self, node: RestPat, __ast_path: &mut AstKindPath, ) -> RestPat

fn fold_return_stmt( &mut self, node: ReturnStmt, __ast_path: &mut AstKindPath, ) -> ReturnStmt

fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script

fn fold_seq_expr( &mut self, node: SeqExpr, __ast_path: &mut AstKindPath, ) -> SeqExpr

fn fold_setter_prop( &mut self, node: SetterProp, __ast_path: &mut AstKindPath, ) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, __ast_path: &mut AstKindPath, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_spread_element( &mut self, node: SpreadElement, __ast_path: &mut AstKindPath, ) -> SpreadElement

fn fold_static_block( &mut self, node: StaticBlock, __ast_path: &mut AstKindPath, ) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt

fn fold_stmts( &mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath, ) -> Vec<Stmt>

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super

fn fold_super_prop( &mut self, node: SuperProp, __ast_path: &mut AstKindPath, ) -> SuperProp

fn fold_super_prop_expr( &mut self, node: SuperPropExpr, __ast_path: &mut AstKindPath, ) -> SuperPropExpr

fn fold_switch_case( &mut self, node: SwitchCase, __ast_path: &mut AstKindPath, ) -> SwitchCase

fn fold_switch_cases( &mut self, node: Vec<SwitchCase>, __ast_path: &mut AstKindPath, ) -> Vec<SwitchCase>

fn fold_switch_stmt( &mut self, node: SwitchStmt, __ast_path: &mut AstKindPath, ) -> SwitchStmt

fn fold_syntax_context( &mut self, node: SyntaxContext, __ast_path: &mut AstKindPath, ) -> SyntaxContext

fn fold_tagged_tpl( &mut self, node: TaggedTpl, __ast_path: &mut AstKindPath, ) -> TaggedTpl

fn fold_this_expr( &mut self, node: ThisExpr, __ast_path: &mut AstKindPath, ) -> ThisExpr

fn fold_throw_stmt( &mut self, node: ThrowStmt, __ast_path: &mut AstKindPath, ) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl

fn fold_tpl_element( &mut self, node: TplElement, __ast_path: &mut AstKindPath, ) -> TplElement

fn fold_tpl_elements( &mut self, node: Vec<TplElement>, __ast_path: &mut AstKindPath, ) -> Vec<TplElement>

fn fold_true_plus_minus( &mut self, node: TruePlusMinus, __ast_path: &mut AstKindPath, ) -> TruePlusMinus

fn fold_try_stmt( &mut self, node: TryStmt, __ast_path: &mut AstKindPath, ) -> TryStmt

fn fold_ts_array_type( &mut self, node: TsArrayType, __ast_path: &mut AstKindPath, ) -> TsArrayType

fn fold_ts_as_expr( &mut self, node: TsAsExpr, __ast_path: &mut AstKindPath, ) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, __ast_path: &mut AstKindPath, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, __ast_path: &mut AstKindPath, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, __ast_path: &mut AstKindPath, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, __ast_path: &mut AstKindPath, ) -> TsConstructorType

fn fold_ts_entity_name( &mut self, node: TsEntityName, __ast_path: &mut AstKindPath, ) -> TsEntityName

fn fold_ts_enum_decl( &mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath, ) -> TsEnumDecl

fn fold_ts_enum_member( &mut self, node: TsEnumMember, __ast_path: &mut AstKindPath, ) -> TsEnumMember

fn fold_ts_enum_member_id( &mut self, node: TsEnumMemberId, __ast_path: &mut AstKindPath, ) -> TsEnumMemberId

fn fold_ts_enum_members( &mut self, node: Vec<TsEnumMember>, __ast_path: &mut AstKindPath, ) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, __ast_path: &mut AstKindPath, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, __ast_path: &mut AstKindPath, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, __ast_path: &mut AstKindPath, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, __ast_path: &mut AstKindPath, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, __ast_path: &mut AstKindPath, ) -> TsFnOrConstructorType

fn fold_ts_fn_param( &mut self, node: TsFnParam, __ast_path: &mut AstKindPath, ) -> TsFnParam

fn fold_ts_fn_params( &mut self, node: Vec<TsFnParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsFnParam>

fn fold_ts_fn_type( &mut self, node: TsFnType, __ast_path: &mut AstKindPath, ) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, __ast_path: &mut AstKindPath, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, __ast_path: &mut AstKindPath, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, __ast_path: &mut AstKindPath, ) -> TsImportEqualsDecl

fn fold_ts_import_type( &mut self, node: TsImportType, __ast_path: &mut AstKindPath, ) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, __ast_path: &mut AstKindPath, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, __ast_path: &mut AstKindPath, ) -> TsIndexedAccessType

fn fold_ts_infer_type( &mut self, node: TsInferType, __ast_path: &mut AstKindPath, ) -> TsInferType

fn fold_ts_instantiation( &mut self, node: TsInstantiation, __ast_path: &mut AstKindPath, ) -> TsInstantiation

fn fold_ts_interface_body( &mut self, node: TsInterfaceBody, __ast_path: &mut AstKindPath, ) -> TsInterfaceBody

fn fold_ts_interface_decl( &mut self, node: TsInterfaceDecl, __ast_path: &mut AstKindPath, ) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, __ast_path: &mut AstKindPath, ) -> TsIntersectionType

fn fold_ts_keyword_type( &mut self, node: TsKeywordType, __ast_path: &mut AstKindPath, ) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, __ast_path: &mut AstKindPath, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit

fn fold_ts_lit_type( &mut self, node: TsLitType, __ast_path: &mut AstKindPath, ) -> TsLitType

fn fold_ts_mapped_type( &mut self, node: TsMappedType, __ast_path: &mut AstKindPath, ) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, __ast_path: &mut AstKindPath, ) -> TsMethodSignature

fn fold_ts_module_block( &mut self, node: TsModuleBlock, __ast_path: &mut AstKindPath, ) -> TsModuleBlock

fn fold_ts_module_decl( &mut self, node: TsModuleDecl, __ast_path: &mut AstKindPath, ) -> TsModuleDecl

fn fold_ts_module_name( &mut self, node: TsModuleName, __ast_path: &mut AstKindPath, ) -> TsModuleName

fn fold_ts_module_ref( &mut self, node: TsModuleRef, __ast_path: &mut AstKindPath, ) -> TsModuleRef

fn fold_ts_namespace_body( &mut self, node: TsNamespaceBody, __ast_path: &mut AstKindPath, ) -> TsNamespaceBody

fn fold_ts_namespace_decl( &mut self, node: TsNamespaceDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, __ast_path: &mut AstKindPath, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr( &mut self, node: TsNonNullExpr, __ast_path: &mut AstKindPath, ) -> TsNonNullExpr

fn fold_ts_optional_type( &mut self, node: TsOptionalType, __ast_path: &mut AstKindPath, ) -> TsOptionalType

fn fold_ts_param_prop( &mut self, node: TsParamProp, __ast_path: &mut AstKindPath, ) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, __ast_path: &mut AstKindPath, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, __ast_path: &mut AstKindPath, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, __ast_path: &mut AstKindPath, ) -> TsPropertySignature

fn fold_ts_qualified_name( &mut self, node: TsQualifiedName, __ast_path: &mut AstKindPath, ) -> TsQualifiedName

fn fold_ts_rest_type( &mut self, node: TsRestType, __ast_path: &mut AstKindPath, ) -> TsRestType

fn fold_ts_satisfies_expr( &mut self, node: TsSatisfiesExpr, __ast_path: &mut AstKindPath, ) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, __ast_path: &mut AstKindPath, ) -> TsSetterSignature

fn fold_ts_this_param( &mut self, node: TsThisParam, __ast_path: &mut AstKindPath, ) -> TsThisParam

fn fold_ts_this_type( &mut self, node: TsThisType, __ast_path: &mut AstKindPath, ) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, __ast_path: &mut AstKindPath, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type( &mut self, node: TsTplLitType, __ast_path: &mut AstKindPath, ) -> TsTplLitType

fn fold_ts_tuple_element( &mut self, node: TsTupleElement, __ast_path: &mut AstKindPath, ) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type( &mut self, node: TsTupleType, __ast_path: &mut AstKindPath, ) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType

fn fold_ts_type_alias_decl( &mut self, node: TsTypeAliasDecl, __ast_path: &mut AstKindPath, ) -> TsTypeAliasDecl

fn fold_ts_type_ann( &mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath, ) -> TsTypeAnn

fn fold_ts_type_assertion( &mut self, node: TsTypeAssertion, __ast_path: &mut AstKindPath, ) -> TsTypeAssertion

fn fold_ts_type_element( &mut self, node: TsTypeElement, __ast_path: &mut AstKindPath, ) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit( &mut self, node: TsTypeLit, __ast_path: &mut AstKindPath, ) -> TsTypeLit

fn fold_ts_type_operator( &mut self, node: TsTypeOperator, __ast_path: &mut AstKindPath, ) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, __ast_path: &mut AstKindPath, ) -> TsTypeOperatorOp

fn fold_ts_type_param( &mut self, node: TsTypeParam, __ast_path: &mut AstKindPath, ) -> TsTypeParam

fn fold_ts_type_param_decl( &mut self, node: TsTypeParamDecl, __ast_path: &mut AstKindPath, ) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, __ast_path: &mut AstKindPath, ) -> TsTypeParamInstantiation

fn fold_ts_type_params( &mut self, node: Vec<TsTypeParam>, __ast_path: &mut AstKindPath, ) -> Vec<TsTypeParam>

fn fold_ts_type_predicate( &mut self, node: TsTypePredicate, __ast_path: &mut AstKindPath, ) -> TsTypePredicate

fn fold_ts_type_query( &mut self, node: TsTypeQuery, __ast_path: &mut AstKindPath, ) -> TsTypeQuery

fn fold_ts_type_query_expr( &mut self, node: TsTypeQueryExpr, __ast_path: &mut AstKindPath, ) -> TsTypeQueryExpr

fn fold_ts_type_ref( &mut self, node: TsTypeRef, __ast_path: &mut AstKindPath, ) -> TsTypeRef

fn fold_ts_types( &mut self, node: Vec<Box<TsType>>, __ast_path: &mut AstKindPath, ) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, __ast_path: &mut AstKindPath, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type( &mut self, node: TsUnionType, __ast_path: &mut AstKindPath, ) -> TsUnionType

fn fold_unary_expr( &mut self, node: UnaryExpr, __ast_path: &mut AstKindPath, ) -> UnaryExpr

fn fold_unary_op( &mut self, node: UnaryOp, __ast_path: &mut AstKindPath, ) -> UnaryOp

fn fold_update_expr( &mut self, node: UpdateExpr, __ast_path: &mut AstKindPath, ) -> UpdateExpr

fn fold_update_op( &mut self, node: UpdateOp, __ast_path: &mut AstKindPath, ) -> UpdateOp

fn fold_using_decl( &mut self, node: UsingDecl, __ast_path: &mut AstKindPath, ) -> UsingDecl

fn fold_var_decl( &mut self, node: VarDecl, __ast_path: &mut AstKindPath, ) -> VarDecl

fn fold_var_decl_kind( &mut self, node: VarDeclKind, __ast_path: &mut AstKindPath, ) -> VarDeclKind

fn fold_var_decl_or_expr( &mut self, node: VarDeclOrExpr, __ast_path: &mut AstKindPath, ) -> VarDeclOrExpr

fn fold_var_declarator( &mut self, node: VarDeclarator, __ast_path: &mut AstKindPath, ) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, __ast_path: &mut AstKindPath, ) -> Vec<VarDeclarator>

fn fold_while_stmt( &mut self, node: WhileStmt, __ast_path: &mut AstKindPath, ) -> WhileStmt

fn fold_with_stmt( &mut self, node: WithStmt, __ast_path: &mut AstKindPath, ) -> WithStmt

fn fold_wtf_8_atom( &mut self, node: Wtf8Atom, __ast_path: &mut AstKindPath, ) -> Wtf8Atom

fn fold_yield_expr( &mut self, node: YieldExpr, __ast_path: &mut AstKindPath, ) -> YieldExpr

Implementors