Trait Fold 

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

A visitor trait for traversing the AST.

Provided Methods

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

Visit a node of type Accessibility.

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

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

Visit a node of type ArrayLit.

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

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

Visit a node of type ArrayPat.

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

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

Visit a node of type ArrowExpr.

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

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

Visit a node of type ArrowFunctionBody.

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

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

Visit a node of type AssignExpr.

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

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

Visit a node of type AssignOp.

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

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

Visit a node of type AssignPat.

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

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

Visit a node of type AssignPatProp.

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

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

Visit a node of type AssignProp.

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

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

Visit a node of type AssignTarget.

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

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

Visit a node of type AssignTargetPat.

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

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

Visit a node of type swc_atoms :: Atom.

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

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

Visit a node of type AutoAccessor.

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

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

Visit a node of type AwaitExpr.

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

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

Visit a node of type BigInt.

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

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

Visit a node of type BigIntValue.

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

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

Visit a node of type BinExpr.

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

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

Visit a node of type BinaryOp.

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

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

Visit a node of type BindingIdent.

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

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

Visit a node of type BlockStmt.

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

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

Visit a node of type Bool.

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

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

Visit a node of type BreakStmt.

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

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

Visit a node of type CallExpr.

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

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

Visit a node of type Callee.

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

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

Visit a node of type CatchClause.

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

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

Visit a node of type Class.

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

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

Visit a node of type ClassDecl.

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

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

Visit a node of type ClassExpr.

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

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

Visit a node of type ClassMember.

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

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

Visit a node of type Vec < ClassMember >.

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

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

Visit a node of type ClassMethod.

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

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

Visit a node of type ClassProp.

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

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

Visit a node of type ComputedPropName.

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

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

Visit a node of type CondExpr.

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

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

Visit a node of type Constructor.

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

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

Visit a node of type ContinueStmt.

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

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

Visit a node of type DebuggerStmt.

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

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

Visit a node of type Decl.

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

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

Visit a node of type Decorator.

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

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

Visit a node of type Vec < Decorator >.

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

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

Visit a node of type DefaultDecl.

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

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

Visit a node of type DoWhileStmt.

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

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

Visit a node of type EmptyStmt.

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

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

Visit a node of type ExportAll.

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

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

Visit a node of type ExportDecl.

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

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

Visit a node of type ExportDefaultDecl.

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

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

Visit a node of type ExportDefaultExpr.

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

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

Visit a node of type ExportDefaultSpecifier.

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

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

Visit a node of type ExportNamedSpecifier.

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

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

Visit a node of type ExportNamespaceSpecifier.

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

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

Visit a node of type ExportSpecifier.

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

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

Visit a node of type Vec < ExportSpecifier >.

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

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

Visit a node of type Expr.

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

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

Visit a node of type ExprOrSpread.

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

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

Visit a node of type Vec < ExprOrSpread >.

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

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

Visit a node of type ExprStmt.

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

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

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

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

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

Visit a node of type FnDecl.

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

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

Visit a node of type FnExpr.

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

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

Visit a node of type ForHead.

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

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

Visit a node of type ForInStmt.

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

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

Visit a node of type ForOfStmt.

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

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

Visit a node of type ForStmt.

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

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

Visit a node of type Function.

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

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

Visit a node of type FunctionBody.

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

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

Visit a node of type GetterProp.

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

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

Visit a node of type Ident.

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

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

Visit a node of type IdentName.

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

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

Visit a node of type IfStmt.

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

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

Visit a node of type Import.

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

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

Visit a node of type ImportDecl.

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

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

Visit a node of type ImportDefaultSpecifier.

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

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

Visit a node of type ImportNamedSpecifier.

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

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

Visit a node of type ImportPhase.

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

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

Visit a node of type ImportSpecifier.

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

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

Visit a node of type Vec < ImportSpecifier >.

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

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

Visit a node of type ImportStarAsSpecifier.

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

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

Visit a node of type ImportWith.

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

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

Visit a node of type ImportWithItem.

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

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

Visit a node of type Vec < ImportWithItem >.

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

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

Visit a node of type Invalid.

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

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

Visit a node of type JSXAttr.

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

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

Visit a node of type JSXAttrName.

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

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

Visit a node of type JSXAttrOrSpread.

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

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

Visit a node of type Vec < JSXAttrOrSpread >.

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

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

Visit a node of type JSXAttrValue.

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

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

Visit a node of type JSXClosingElement.

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

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

Visit a node of type JSXClosingFragment.

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

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

Visit a node of type JSXElement.

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

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

Visit a node of type JSXElementChild.

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

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

Visit a node of type Vec < JSXElementChild >.

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

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

Visit a node of type JSXElementName.

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

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

Visit a node of type JSXEmptyExpr.

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

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

Visit a node of type JSXExpr.

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

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

Visit a node of type JSXExprContainer.

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

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

Visit a node of type JSXFragment.

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

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

Visit a node of type JSXMemberExpr.

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

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

Visit a node of type JSXNamespacedName.

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

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

Visit a node of type JSXObject.

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

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

Visit a node of type JSXOpeningElement.

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

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

Visit a node of type JSXOpeningFragment.

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

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

Visit a node of type JSXSpreadChild.

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

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

Visit a node of type JSXText.

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

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

Visit a node of type Key.

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

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

Visit a node of type KeyValuePatProp.

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

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

Visit a node of type KeyValueProp.

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

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

Visit a node of type LabeledStmt.

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

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

Visit a node of type Lit.

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

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

Visit a node of type MemberExpr.

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

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

Visit a node of type MemberProp.

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

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

Visit a node of type MetaPropExpr.

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

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

Visit a node of type MetaPropKind.

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

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

Visit a node of type MethodKind.

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

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

Visit a node of type MethodProp.

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

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

Visit a node of type Module.

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

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

Visit a node of type ModuleDecl.

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

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

Visit a node of type ModuleExportName.

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

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

Visit a node of type ModuleItem.

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

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

Visit a node of type Vec < ModuleItem >.

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

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

Visit a node of type NamedExport.

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

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

Visit a node of type NewExpr.

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

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

Visit a node of type Null.

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

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

Visit a node of type Number.

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

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

Visit a node of type ObjectLit.

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

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

Visit a node of type ObjectPat.

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

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

Visit a node of type ObjectPatProp.

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

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

Visit a node of type Vec < ObjectPatProp >.

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

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

Visit a node of type Option < Accessibility >.

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

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

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

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

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

Visit a node of type Option < BlockStmt >.

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

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

Visit a node of type OptCall.

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

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

Visit a node of type Option < CatchClause >.

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

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

Visit a node of type OptChainBase.

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

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

Visit a node of type OptChainExpr.

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

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

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

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

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

Visit a node of type Option < ExprOrSpread >.

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

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

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

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

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

Visit a node of type Option < FunctionBody >.

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

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

Visit a node of type Option < Ident >.

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

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

Visit a node of type Option < JSXAttrValue >.

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

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

Visit a node of type Option < JSXClosingElement >.

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

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

Visit a node of type Option < ModuleExportName >.

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

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

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

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

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

Visit a node of type Option < Pat >.

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

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

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

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

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

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

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

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

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

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

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

Visit a node of type Option < TruePlusMinus >.

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

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

Visit a node of type Option < TsEntityName >.

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

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

Visit a node of type Option < TsImportCallOptions >.

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

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

Visit a node of type Option < TsNamespaceBody >.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Visit a node of type Option < VarDeclOrExpr >.

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

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

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

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

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

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

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

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

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

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

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

Visit a node of type Param.

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

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

Visit a node of type ParamOrTsParamProp.

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

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

Visit a node of type Vec < ParamOrTsParamProp >.

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

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

Visit a node of type Vec < Param >.

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

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

Visit a node of type ParenExpr.

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

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

Visit a node of type Pat.

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

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

Visit a node of type Vec < Pat >.

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

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

Visit a node of type PrivateMethod.

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

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

Visit a node of type PrivateName.

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

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

Visit a node of type PrivateProp.

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

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

Visit a node of type Program.

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

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

Visit a node of type Prop.

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

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

Visit a node of type PropName.

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

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

Visit a node of type PropOrSpread.

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

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

Visit a node of type Vec < PropOrSpread >.

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

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

Visit a node of type Regex.

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

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

Visit a node of type RestPat.

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

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

Visit a node of type ReturnStmt.

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

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

Visit a node of type Script.

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

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

Visit a node of type SeqExpr.

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

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

Visit a node of type SetterProp.

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

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

Visit a node of type SimpleAssignTarget.

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

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

Visit a node of type swc_common :: Span.

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

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

Visit a node of type SpreadElement.

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

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

Visit a node of type StaticBlock.

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

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

Visit a node of type Stmt.

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

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

Visit a node of type Vec < Stmt >.

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

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

Visit a node of type Str.

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

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

Visit a node of type Super.

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

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

Visit a node of type SuperProp.

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

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

Visit a node of type SuperPropExpr.

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

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

Visit a node of type SwitchCase.

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

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

Visit a node of type Vec < SwitchCase >.

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

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

Visit a node of type SwitchStmt.

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

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

Visit a node of type swc_common :: SyntaxContext.

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

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

Visit a node of type TaggedTpl.

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

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

Visit a node of type ThisExpr.

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

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

Visit a node of type ThrowStmt.

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

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

Visit a node of type Tpl.

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

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

Visit a node of type TplElement.

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

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

Visit a node of type Vec < TplElement >.

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

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

Visit a node of type TruePlusMinus.

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

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

Visit a node of type TryStmt.

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

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

Visit a node of type TsArrayType.

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

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

Visit a node of type TsAsExpr.

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

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

Visit a node of type TsCallSignatureDecl.

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

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

Visit a node of type TsConditionalType.

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

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

Visit a node of type TsConstAssertion.

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

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

Visit a node of type TsConstructSignatureDecl.

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

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

Visit a node of type TsConstructorType.

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

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

Visit a node of type TsEntityName.

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

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

Visit a node of type TsEnumDecl.

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

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

Visit a node of type TsEnumMember.

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

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

Visit a node of type TsEnumMemberId.

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

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

Visit a node of type Vec < TsEnumMember >.

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

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

Visit a node of type TsExportAssignment.

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

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

Visit a node of type TsExprWithTypeArgs.

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

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

Visit a node of type Vec < TsExprWithTypeArgs >.

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

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

Visit a node of type TsExternalModuleRef.

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

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

Visit a node of type TsFnOrConstructorType.

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

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

Visit a node of type TsFnParam.

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

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

Visit a node of type Vec < TsFnParam >.

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

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

Visit a node of type TsFnType.

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

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

Visit a node of type TsGetterSignature.

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

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

Visit a node of type TsImportCallOptions.

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

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

Visit a node of type TsImportEqualsDecl.

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

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

Visit a node of type TsImportType.

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

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

Visit a node of type TsIndexSignature.

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

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

Visit a node of type TsIndexedAccessType.

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

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

Visit a node of type TsInferType.

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

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

Visit a node of type TsInstantiation.

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

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

Visit a node of type TsInterfaceBody.

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

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

Visit a node of type TsInterfaceDecl.

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

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

Visit a node of type TsIntersectionType.

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

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

Visit a node of type TsKeywordType.

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

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

Visit a node of type TsKeywordTypeKind.

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

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

Visit a node of type TsLit.

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

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

Visit a node of type TsLitType.

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

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

Visit a node of type TsMappedType.

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

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

Visit a node of type TsMethodSignature.

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

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

Visit a node of type TsModuleBlock.

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

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

Visit a node of type TsModuleDecl.

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

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

Visit a node of type TsModuleName.

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

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

Visit a node of type TsModuleRef.

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

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

Visit a node of type TsNamespaceBody.

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

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

Visit a node of type TsNamespaceDecl.

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

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

Visit a node of type TsNamespaceExportDecl.

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

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

Visit a node of type TsNonNullExpr.

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

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

Visit a node of type TsOptionalType.

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

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

Visit a node of type TsParamProp.

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

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

Visit a node of type TsParamPropParam.

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

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

Visit a node of type TsParenthesizedType.

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

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

Visit a node of type TsPropertySignature.

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

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

Visit a node of type TsQualifiedName.

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

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

Visit a node of type TsRestType.

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

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

Visit a node of type TsSatisfiesExpr.

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

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

Visit a node of type TsSetterSignature.

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

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

Visit a node of type TsThisParam.

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

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

Visit a node of type TsThisType.

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

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

Visit a node of type TsThisTypeOrIdent.

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

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

Visit a node of type TsTplLitType.

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

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

Visit a node of type TsTupleElement.

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

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

Visit a node of type Vec < TsTupleElement >.

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

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

Visit a node of type TsTupleType.

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

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

Visit a node of type TsType.

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

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

Visit a node of type TsTypeAliasDecl.

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

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

Visit a node of type TsTypeAnn.

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

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

Visit a node of type TsTypeAssertion.

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

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

Visit a node of type TsTypeElement.

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

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

Visit a node of type Vec < TsTypeElement >.

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

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

Visit a node of type TsTypeLit.

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

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

Visit a node of type TsTypeOperator.

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

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

Visit a node of type TsTypeOperatorOp.

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

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

Visit a node of type TsTypeParam.

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

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

Visit a node of type TsTypeParamDecl.

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

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

Visit a node of type TsTypeParamInstantiation.

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

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

Visit a node of type Vec < TsTypeParam >.

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

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

Visit a node of type TsTypePredicate.

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

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

Visit a node of type TsTypeQuery.

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

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

Visit a node of type TsTypeQueryExpr.

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

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

Visit a node of type TsTypeRef.

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

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

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

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

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

Visit a node of type TsUnionOrIntersectionType.

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

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

Visit a node of type TsUnionType.

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

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

Visit a node of type UnaryExpr.

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

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

Visit a node of type UnaryOp.

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

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

Visit a node of type UpdateExpr.

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

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

Visit a node of type UpdateOp.

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

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

Visit a node of type UsingDecl.

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

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

Visit a node of type VarDecl.

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

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

Visit a node of type VarDeclKind.

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

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

Visit a node of type VarDeclOrExpr.

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

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

Visit a node of type VarDeclarator.

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

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

Visit a node of type Vec < VarDeclarator >.

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

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

Visit a node of type WhileStmt.

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

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

Visit a node of type WithStmt.

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

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

Visit a node of type swc_atoms :: Wtf8Atom.

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

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

Visit a node of type YieldExpr.

By default, this method calls YieldExpr::fold_children_with. 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> Fold for Either<A, B>

where A: Fold, B: Fold,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt) -> Stmt

fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt>

fn fold_str(&mut self, node: Str) -> Str

fn fold_super(&mut self, node: Super) -> Super

fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp

fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr

fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase

fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase>

fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt

fn fold_syntax_context(&mut self, node: SyntaxContext) -> SyntaxContext

fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl

fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr

fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl) -> Tpl

fn fold_tpl_element(&mut self, node: TplElement) -> TplElement

fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement>

fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus

fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt

fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType

fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, ) -> TsConstructorType

fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName

fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl

fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember

fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId

fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, ) -> TsFnOrConstructorType

fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam

fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam>

fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, ) -> TsImportEqualsDecl

fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, ) -> TsIndexedAccessType

fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType

fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation

fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody

fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, ) -> TsIntersectionType

fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit) -> TsLit

fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType

fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, ) -> TsMethodSignature

fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock

fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl

fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName

fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef

fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody

fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr

fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType

fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, ) -> TsPropertySignature

fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName

fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType

fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, ) -> TsSetterSignature

fn fold_ts_this_param(&mut self, node: TsThisParam) -> TsThisParam

fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType

fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType) -> TsType

fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl

fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn

fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion

fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit

fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, ) -> TsTypeOperatorOp

fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam

fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, ) -> TsTypeParamInstantiation

fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam>

fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate

fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery

fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr

fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef

fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType

fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr

fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp

fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr

fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp

fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl

fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl

fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind

fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr

fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, ) -> Vec<VarDeclarator>

fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt

fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt

fn fold_wtf_8_atom(&mut self, node: Wtf8Atom) -> Wtf8Atom

fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr

impl<V> Fold for &mut V

where V: ?Sized + Fold,

fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility

fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit

fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat

fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, ) -> ArrowFunctionBody

fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr

fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp

fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat

fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp

fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp

fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget

fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom) -> Atom

fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor

fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt) -> BigInt

fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue

fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr

fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp

fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent

fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt

fn fold_bool(&mut self, node: Bool) -> Bool

fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt

fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr

fn fold_callee(&mut self, node: Callee) -> Callee

fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause

fn fold_class(&mut self, node: Class) -> Class

fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl

fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr

fn fold_class_member(&mut self, node: ClassMember) -> ClassMember

fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember>

fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod

fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, ) -> ComputedPropName

fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr

fn fold_constructor(&mut self, node: Constructor) -> Constructor

fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt

fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl) -> Decl

fn fold_decorator(&mut self, node: Decorator) -> Decorator

fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator>

fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl

fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt

fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt

fn fold_export_all(&mut self, node: ExportAll) -> ExportAll

fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, ) -> ExportNamespaceSpecifier

fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr) -> Expr

fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread

fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>

fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt

fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr

fn fold_for_head(&mut self, node: ForHead) -> ForHead

fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt

fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt

fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt

fn fold_function(&mut self, node: Function) -> Function

fn fold_function_body(&mut self, node: FunctionBody) -> FunctionBody

fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp

fn fold_ident(&mut self, node: Ident) -> Ident

fn fold_ident_name(&mut self, node: IdentName) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt

fn fold_import(&mut self, node: Import) -> Import

fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, ) -> ImportNamedSpecifier

fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase

fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, ) -> ImportStarAsSpecifier

fn fold_import_with(&mut self, node: ImportWith) -> ImportWith

fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, ) -> Vec<ImportWithItem>

fn fold_invalid(&mut self, node: Invalid) -> Invalid

fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr

fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName

fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, ) -> JSXClosingFragment

fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement

fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName

fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr

fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, ) -> JSXExprContainer

fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment

fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, ) -> JSXNamespacedName

fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, ) -> JSXOpeningFragment

fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild

fn fold_jsx_text(&mut self, node: JSXText) -> JSXText

fn fold_key(&mut self, node: Key) -> Key

fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp

fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp

fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt

fn fold_lit(&mut self, node: Lit) -> Lit

fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr

fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp

fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr

fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind

fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind

fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp

fn fold_module(&mut self, node: Module) -> Module

fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, ) -> ModuleExportName

fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem

fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem>

fn fold_named_export(&mut self, node: NamedExport) -> NamedExport

fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr

fn fold_null(&mut self, node: Null) -> Null

fn fold_number(&mut self, node: Number) -> Number

fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit

fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat

fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, ) -> Option<Accessibility>

fn fold_opt_atom(&mut self, node: Option<Atom>) -> Option<Atom>

fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt>

fn fold_opt_call(&mut self, node: OptCall) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, ) -> Option<CatchClause>

fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase

fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr

fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, ) -> Option<FunctionBody>

fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat>

fn fold_opt_span(&mut self, node: Option<Span>) -> Option<Span>

fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>>

fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom(&mut self, node: Option<Wtf8Atom>) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, ) -> Vec<ParamOrTsParamProp>

fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param>

fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr

fn fold_pat(&mut self, node: Pat) -> Pat

fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat>

fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod

fn fold_private_name(&mut self, node: PrivateName) -> PrivateName

fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp

fn fold_program(&mut self, node: Program) -> Program

fn fold_prop(&mut self, node: Prop) -> Prop

fn fold_prop_name(&mut self, node: PropName) -> PropName

fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread

fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex) -> Regex

fn fold_rest_pat(&mut self, node: RestPat) -> RestPat

fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt

fn fold_script(&mut self, node: Script) -> Script

fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr

fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span) -> Span

fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement

fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt) -> Stmt

fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt>

fn fold_str(&mut self, node: Str) -> Str

fn fold_super(&mut self, node: Super) -> Super

fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp

fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr

fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase

fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase>

fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt

fn fold_syntax_context(&mut self, node: SyntaxContext) -> SyntaxContext

fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl

fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr

fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl) -> Tpl

fn fold_tpl_element(&mut self, node: TplElement) -> TplElement

fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement>

fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus

fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt

fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType

fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, ) -> TsConstructorType

fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName

fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl

fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember

fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId

fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, ) -> TsFnOrConstructorType

fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam

fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam>

fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, ) -> TsImportEqualsDecl

fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, ) -> TsIndexedAccessType

fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType

fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation

fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody

fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, ) -> TsIntersectionType

fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit) -> TsLit

fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType

fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, ) -> TsMethodSignature

fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock

fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl

fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName

fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef

fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody

fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr

fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType

fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, ) -> TsPropertySignature

fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName

fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType

fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, ) -> TsSetterSignature

fn fold_ts_this_param(&mut self, node: TsThisParam) -> TsThisParam

fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType

fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType) -> TsType

fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl

fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn

fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion

fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit

fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, ) -> TsTypeOperatorOp

fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam

fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, ) -> TsTypeParamInstantiation

fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam>

fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate

fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery

fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr

fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef

fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType

fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr

fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp

fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr

fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp

fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl

fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl

fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind

fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr

fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, ) -> Vec<VarDeclarator>

fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt

fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt

fn fold_wtf_8_atom(&mut self, node: Wtf8Atom) -> Wtf8Atom

fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr

impl<V> Fold for Box<V>

where V: ?Sized + Fold,

fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility

fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit

fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat

fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, ) -> ArrowFunctionBody

fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr

fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp

fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat

fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp

fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp

fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget

fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom) -> Atom

fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor

fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt) -> BigInt

fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue

fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr

fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp

fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent

fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt

fn fold_bool(&mut self, node: Bool) -> Bool

fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt

fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr

fn fold_callee(&mut self, node: Callee) -> Callee

fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause

fn fold_class(&mut self, node: Class) -> Class

fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl

fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr

fn fold_class_member(&mut self, node: ClassMember) -> ClassMember

fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember>

fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod

fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, ) -> ComputedPropName

fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr

fn fold_constructor(&mut self, node: Constructor) -> Constructor

fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt

fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl) -> Decl

fn fold_decorator(&mut self, node: Decorator) -> Decorator

fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator>

fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl

fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt

fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt

fn fold_export_all(&mut self, node: ExportAll) -> ExportAll

fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, ) -> ExportNamespaceSpecifier

fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr) -> Expr

fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread

fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>

fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt

fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr

fn fold_for_head(&mut self, node: ForHead) -> ForHead

fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt

fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt

fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt

fn fold_function(&mut self, node: Function) -> Function

fn fold_function_body(&mut self, node: FunctionBody) -> FunctionBody

fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp

fn fold_ident(&mut self, node: Ident) -> Ident

fn fold_ident_name(&mut self, node: IdentName) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt

fn fold_import(&mut self, node: Import) -> Import

fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, ) -> ImportNamedSpecifier

fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase

fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, ) -> ImportStarAsSpecifier

fn fold_import_with(&mut self, node: ImportWith) -> ImportWith

fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, ) -> Vec<ImportWithItem>

fn fold_invalid(&mut self, node: Invalid) -> Invalid

fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr

fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName

fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, ) -> JSXClosingFragment

fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement

fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName

fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr

fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, ) -> JSXExprContainer

fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment

fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, ) -> JSXNamespacedName

fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, ) -> JSXOpeningFragment

fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild

fn fold_jsx_text(&mut self, node: JSXText) -> JSXText

fn fold_key(&mut self, node: Key) -> Key

fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp

fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp

fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt

fn fold_lit(&mut self, node: Lit) -> Lit

fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr

fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp

fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr

fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind

fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind

fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp

fn fold_module(&mut self, node: Module) -> Module

fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, ) -> ModuleExportName

fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem

fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem>

fn fold_named_export(&mut self, node: NamedExport) -> NamedExport

fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr

fn fold_null(&mut self, node: Null) -> Null

fn fold_number(&mut self, node: Number) -> Number

fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit

fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat

fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, ) -> Option<Accessibility>

fn fold_opt_atom(&mut self, node: Option<Atom>) -> Option<Atom>

fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt>

fn fold_opt_call(&mut self, node: OptCall) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, ) -> Option<CatchClause>

fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase

fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr

fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, ) -> Option<FunctionBody>

fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat>

fn fold_opt_span(&mut self, node: Option<Span>) -> Option<Span>

fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>>

fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom(&mut self, node: Option<Wtf8Atom>) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, ) -> Vec<ParamOrTsParamProp>

fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param>

fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr

fn fold_pat(&mut self, node: Pat) -> Pat

fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat>

fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod

fn fold_private_name(&mut self, node: PrivateName) -> PrivateName

fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp

fn fold_program(&mut self, node: Program) -> Program

fn fold_prop(&mut self, node: Prop) -> Prop

fn fold_prop_name(&mut self, node: PropName) -> PropName

fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread

fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex) -> Regex

fn fold_rest_pat(&mut self, node: RestPat) -> RestPat

fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt

fn fold_script(&mut self, node: Script) -> Script

fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr

fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span) -> Span

fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement

fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt) -> Stmt

fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt>

fn fold_str(&mut self, node: Str) -> Str

fn fold_super(&mut self, node: Super) -> Super

fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp

fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr

fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase

fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase>

fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt

fn fold_syntax_context(&mut self, node: SyntaxContext) -> SyntaxContext

fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl

fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr

fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl) -> Tpl

fn fold_tpl_element(&mut self, node: TplElement) -> TplElement

fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement>

fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus

fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt

fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType

fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, ) -> TsConstructorType

fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName

fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl

fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember

fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId

fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, ) -> TsFnOrConstructorType

fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam

fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam>

fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, ) -> TsImportEqualsDecl

fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, ) -> TsIndexedAccessType

fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType

fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation

fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody

fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, ) -> TsIntersectionType

fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit) -> TsLit

fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType

fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, ) -> TsMethodSignature

fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock

fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl

fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName

fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef

fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody

fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr

fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType

fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, ) -> TsPropertySignature

fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName

fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType

fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, ) -> TsSetterSignature

fn fold_ts_this_param(&mut self, node: TsThisParam) -> TsThisParam

fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType

fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType) -> TsType

fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl

fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn

fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion

fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit

fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, ) -> TsTypeOperatorOp

fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam

fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, ) -> TsTypeParamInstantiation

fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam>

fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate

fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery

fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr

fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef

fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType

fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr

fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp

fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr

fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp

fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl

fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl

fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind

fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr

fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, ) -> Vec<VarDeclarator>

fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt

fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt

fn fold_wtf_8_atom(&mut self, node: Wtf8Atom) -> Wtf8Atom

fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr

impl<V> Fold for Optional<V>

where V: Fold,

fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility

fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit

fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat

fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr

fn fold_arrow_function_body( &mut self, node: ArrowFunctionBody, ) -> ArrowFunctionBody

fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr

fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp

fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat

fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp

fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp

fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget

fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat

fn fold_atom(&mut self, node: Atom) -> Atom

fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor

fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr

fn fold_big_int(&mut self, node: BigInt) -> BigInt

fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue

fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr

fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp

fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent

fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt

fn fold_bool(&mut self, node: Bool) -> Bool

fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt

fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr

fn fold_callee(&mut self, node: Callee) -> Callee

fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause

fn fold_class(&mut self, node: Class) -> Class

fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl

fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr

fn fold_class_member(&mut self, node: ClassMember) -> ClassMember

fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember>

fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod

fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp

fn fold_computed_prop_name( &mut self, node: ComputedPropName, ) -> ComputedPropName

fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr

fn fold_constructor(&mut self, node: Constructor) -> Constructor

fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt

fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt

fn fold_decl(&mut self, node: Decl) -> Decl

fn fold_decorator(&mut self, node: Decorator) -> Decorator

fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator>

fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl

fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt

fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt

fn fold_export_all(&mut self, node: ExportAll) -> ExportAll

fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl

fn fold_export_default_decl( &mut self, node: ExportDefaultDecl, ) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, node: ExportDefaultExpr, ) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, node: ExportDefaultSpecifier, ) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, node: ExportNamedSpecifier, ) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, node: ExportNamespaceSpecifier, ) -> ExportNamespaceSpecifier

fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier

fn fold_export_specifiers( &mut self, node: Vec<ExportSpecifier>, ) -> Vec<ExportSpecifier>

fn fold_expr(&mut self, node: Expr) -> Expr

fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread

fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread>

fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt

fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>>

fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl

fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr

fn fold_for_head(&mut self, node: ForHead) -> ForHead

fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt

fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt

fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt

fn fold_function(&mut self, node: Function) -> Function

fn fold_function_body(&mut self, node: FunctionBody) -> FunctionBody

fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp

fn fold_ident(&mut self, node: Ident) -> Ident

fn fold_ident_name(&mut self, node: IdentName) -> IdentName

fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt

fn fold_import(&mut self, node: Import) -> Import

fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl

fn fold_import_default_specifier( &mut self, node: ImportDefaultSpecifier, ) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, node: ImportNamedSpecifier, ) -> ImportNamedSpecifier

fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase

fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier

fn fold_import_specifiers( &mut self, node: Vec<ImportSpecifier>, ) -> Vec<ImportSpecifier>

fn fold_import_star_as_specifier( &mut self, node: ImportStarAsSpecifier, ) -> ImportStarAsSpecifier

fn fold_import_with(&mut self, node: ImportWith) -> ImportWith

fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem

fn fold_import_with_items( &mut self, node: Vec<ImportWithItem>, ) -> Vec<ImportWithItem>

fn fold_invalid(&mut self, node: Invalid) -> Invalid

fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr

fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName

fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, node: Vec<JSXAttrOrSpread>, ) -> Vec<JSXAttrOrSpread>

fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue

fn fold_jsx_closing_element( &mut self, node: JSXClosingElement, ) -> JSXClosingElement

fn fold_jsx_closing_fragment( &mut self, node: JSXClosingFragment, ) -> JSXClosingFragment

fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement

fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild

fn fold_jsx_element_childs( &mut self, node: Vec<JSXElementChild>, ) -> Vec<JSXElementChild>

fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName

fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr

fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr

fn fold_jsx_expr_container( &mut self, node: JSXExprContainer, ) -> JSXExprContainer

fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment

fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr

fn fold_jsx_namespaced_name( &mut self, node: JSXNamespacedName, ) -> JSXNamespacedName

fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject

fn fold_jsx_opening_element( &mut self, node: JSXOpeningElement, ) -> JSXOpeningElement

fn fold_jsx_opening_fragment( &mut self, node: JSXOpeningFragment, ) -> JSXOpeningFragment

fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild

fn fold_jsx_text(&mut self, node: JSXText) -> JSXText

fn fold_key(&mut self, node: Key) -> Key

fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp

fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp

fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt

fn fold_lit(&mut self, node: Lit) -> Lit

fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr

fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp

fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr

fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind

fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind

fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp

fn fold_module(&mut self, node: Module) -> Module

fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl

fn fold_module_export_name( &mut self, node: ModuleExportName, ) -> ModuleExportName

fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem

fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem>

fn fold_named_export(&mut self, node: NamedExport) -> NamedExport

fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr

fn fold_null(&mut self, node: Null) -> Null

fn fold_number(&mut self, node: Number) -> Number

fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit

fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat

fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp

fn fold_object_pat_props( &mut self, node: Vec<ObjectPatProp>, ) -> Vec<ObjectPatProp>

fn fold_opt_accessibility( &mut self, node: Option<Accessibility>, ) -> Option<Accessibility>

fn fold_opt_atom(&mut self, node: Option<Atom>) -> Option<Atom>

fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt>

fn fold_opt_call(&mut self, node: OptCall) -> OptCall

fn fold_opt_catch_clause( &mut self, node: Option<CatchClause>, ) -> Option<CatchClause>

fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase

fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr

fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>>

fn fold_opt_expr_or_spread( &mut self, node: Option<ExprOrSpread>, ) -> Option<ExprOrSpread>

fn fold_opt_expr_or_spreads( &mut self, node: Option<Vec<ExprOrSpread>>, ) -> Option<Vec<ExprOrSpread>>

fn fold_opt_function_body( &mut self, node: Option<FunctionBody>, ) -> Option<FunctionBody>

fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident>

fn fold_opt_jsx_attr_value( &mut self, node: Option<JSXAttrValue>, ) -> Option<JSXAttrValue>

fn fold_opt_jsx_closing_element( &mut self, node: Option<JSXClosingElement>, ) -> Option<JSXClosingElement>

fn fold_opt_module_export_name( &mut self, node: Option<ModuleExportName>, ) -> Option<ModuleExportName>

fn fold_opt_object_lit( &mut self, node: Option<Box<ObjectLit>>, ) -> Option<Box<ObjectLit>>

fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat>

fn fold_opt_span(&mut self, node: Option<Span>) -> Option<Span>

fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>>

fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>>

fn fold_opt_true_plus_minus( &mut self, node: Option<TruePlusMinus>, ) -> Option<TruePlusMinus>

fn fold_opt_ts_entity_name( &mut self, node: Option<TsEntityName>, ) -> Option<TsEntityName>

fn fold_opt_ts_import_call_options( &mut self, node: Option<TsImportCallOptions>, ) -> Option<TsImportCallOptions>

fn fold_opt_ts_namespace_body( &mut self, node: Option<TsNamespaceBody>, ) -> Option<TsNamespaceBody>

fn fold_opt_ts_this_param( &mut self, node: Option<Box<TsThisParam>>, ) -> Option<Box<TsThisParam>>

fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>>

fn fold_opt_ts_type_ann( &mut self, node: Option<Box<TsTypeAnn>>, ) -> Option<Box<TsTypeAnn>>

fn fold_opt_ts_type_param_decl( &mut self, node: Option<Box<TsTypeParamDecl>>, ) -> Option<Box<TsTypeParamDecl>>

fn fold_opt_ts_type_param_instantiation( &mut self, node: Option<Box<TsTypeParamInstantiation>>, ) -> Option<Box<TsTypeParamInstantiation>>

fn fold_opt_var_decl_or_expr( &mut self, node: Option<VarDeclOrExpr>, ) -> Option<VarDeclOrExpr>

fn fold_opt_vec_expr_or_spreads( &mut self, node: Vec<Option<ExprOrSpread>>, ) -> Vec<Option<ExprOrSpread>>

fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>>

fn fold_opt_wtf_8_atom(&mut self, node: Option<Wtf8Atom>) -> Option<Wtf8Atom>

fn fold_param(&mut self, node: Param) -> Param

fn fold_param_or_ts_param_prop( &mut self, node: ParamOrTsParamProp, ) -> ParamOrTsParamProp

fn fold_param_or_ts_param_props( &mut self, node: Vec<ParamOrTsParamProp>, ) -> Vec<ParamOrTsParamProp>

fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param>

fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr

fn fold_pat(&mut self, node: Pat) -> Pat

fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat>

fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod

fn fold_private_name(&mut self, node: PrivateName) -> PrivateName

fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp

fn fold_program(&mut self, node: Program) -> Program

fn fold_prop(&mut self, node: Prop) -> Prop

fn fold_prop_name(&mut self, node: PropName) -> PropName

fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread

fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread>

fn fold_regex(&mut self, node: Regex) -> Regex

fn fold_rest_pat(&mut self, node: RestPat) -> RestPat

fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt

fn fold_script(&mut self, node: Script) -> Script

fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr

fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp

fn fold_simple_assign_target( &mut self, node: SimpleAssignTarget, ) -> SimpleAssignTarget

fn fold_span(&mut self, node: Span) -> Span

fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement

fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock

fn fold_stmt(&mut self, node: Stmt) -> Stmt

fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt>

fn fold_str(&mut self, node: Str) -> Str

fn fold_super(&mut self, node: Super) -> Super

fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp

fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr

fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase

fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase>

fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt

fn fold_syntax_context(&mut self, node: SyntaxContext) -> SyntaxContext

fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl

fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr

fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt

fn fold_tpl(&mut self, node: Tpl) -> Tpl

fn fold_tpl_element(&mut self, node: TplElement) -> TplElement

fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement>

fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus

fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt

fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType

fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr

fn fold_ts_call_signature_decl( &mut self, node: TsCallSignatureDecl, ) -> TsCallSignatureDecl

fn fold_ts_conditional_type( &mut self, node: TsConditionalType, ) -> TsConditionalType

fn fold_ts_const_assertion( &mut self, node: TsConstAssertion, ) -> TsConstAssertion

fn fold_ts_construct_signature_decl( &mut self, node: TsConstructSignatureDecl, ) -> TsConstructSignatureDecl

fn fold_ts_constructor_type( &mut self, node: TsConstructorType, ) -> TsConstructorType

fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName

fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl

fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember

fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId

fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember>

fn fold_ts_export_assignment( &mut self, node: TsExportAssignment, ) -> TsExportAssignment

fn fold_ts_expr_with_type_args( &mut self, node: TsExprWithTypeArgs, ) -> TsExprWithTypeArgs

fn fold_ts_expr_with_type_argss( &mut self, node: Vec<TsExprWithTypeArgs>, ) -> Vec<TsExprWithTypeArgs>

fn fold_ts_external_module_ref( &mut self, node: TsExternalModuleRef, ) -> TsExternalModuleRef

fn fold_ts_fn_or_constructor_type( &mut self, node: TsFnOrConstructorType, ) -> TsFnOrConstructorType

fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam

fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam>

fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType

fn fold_ts_getter_signature( &mut self, node: TsGetterSignature, ) -> TsGetterSignature

fn fold_ts_import_call_options( &mut self, node: TsImportCallOptions, ) -> TsImportCallOptions

fn fold_ts_import_equals_decl( &mut self, node: TsImportEqualsDecl, ) -> TsImportEqualsDecl

fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType

fn fold_ts_index_signature( &mut self, node: TsIndexSignature, ) -> TsIndexSignature

fn fold_ts_indexed_access_type( &mut self, node: TsIndexedAccessType, ) -> TsIndexedAccessType

fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType

fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation

fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody

fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl

fn fold_ts_intersection_type( &mut self, node: TsIntersectionType, ) -> TsIntersectionType

fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType

fn fold_ts_keyword_type_kind( &mut self, node: TsKeywordTypeKind, ) -> TsKeywordTypeKind

fn fold_ts_lit(&mut self, node: TsLit) -> TsLit

fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType

fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType

fn fold_ts_method_signature( &mut self, node: TsMethodSignature, ) -> TsMethodSignature

fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock

fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl

fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName

fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef

fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody

fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl

fn fold_ts_namespace_export_decl( &mut self, node: TsNamespaceExportDecl, ) -> TsNamespaceExportDecl

fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr

fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType

fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp

fn fold_ts_param_prop_param( &mut self, node: TsParamPropParam, ) -> TsParamPropParam

fn fold_ts_parenthesized_type( &mut self, node: TsParenthesizedType, ) -> TsParenthesizedType

fn fold_ts_property_signature( &mut self, node: TsPropertySignature, ) -> TsPropertySignature

fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName

fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType

fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr

fn fold_ts_setter_signature( &mut self, node: TsSetterSignature, ) -> TsSetterSignature

fn fold_ts_this_param(&mut self, node: TsThisParam) -> TsThisParam

fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType

fn fold_ts_this_type_or_ident( &mut self, node: TsThisTypeOrIdent, ) -> TsThisTypeOrIdent

fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType

fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement

fn fold_ts_tuple_elements( &mut self, node: Vec<TsTupleElement>, ) -> Vec<TsTupleElement>

fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType

fn fold_ts_type(&mut self, node: TsType) -> TsType

fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl

fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn

fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion

fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement

fn fold_ts_type_elements( &mut self, node: Vec<TsTypeElement>, ) -> Vec<TsTypeElement>

fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit

fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator

fn fold_ts_type_operator_op( &mut self, node: TsTypeOperatorOp, ) -> TsTypeOperatorOp

fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam

fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl

fn fold_ts_type_param_instantiation( &mut self, node: TsTypeParamInstantiation, ) -> TsTypeParamInstantiation

fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam>

fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate

fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery

fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr

fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef

fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>>

fn fold_ts_union_or_intersection_type( &mut self, node: TsUnionOrIntersectionType, ) -> TsUnionOrIntersectionType

fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType

fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr

fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp

fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr

fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp

fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl

fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl

fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind

fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr

fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator

fn fold_var_declarators( &mut self, node: Vec<VarDeclarator>, ) -> Vec<VarDeclarator>

fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt

fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt

fn fold_wtf_8_atom(&mut self, node: Wtf8Atom) -> Wtf8Atom

fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr

impl<V> Fold for Repeat<V>

where V: Fold + Repeated,

fn fold_program(&mut self, node: Program) -> Program

fn fold_module(&mut self, node: Module) -> Module

fn fold_script(&mut self, node: Script) -> Script

Implementors

impl<V> Fold for FoldPass<V>

where V: Fold,