Trait swc_ecma_visit::FoldAstPath

source · [−]

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

Available on crate feature path only.

Provided Methods

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_block_stmt_or_expr(
    &mut self,
    n: BlockStmtOrExpr,
    __ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_class_members(
 &mut self,
 n: Vec<ClassMember>,
 __ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_decorators(
 &mut self,
 n: Vec<Decorator>,
 __ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_export_specifiers(
 &mut self,
 n: Vec<ExportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_expr_or_spreads(
 &mut self,
 n: Vec<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_exprs(
 &mut self,
 n: Vec<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_import_specifiers(
 &mut self,
 n: Vec<ImportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_jsx_attr_or_spreads(
 &mut self,
 n: Vec<JSXAttrOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_jsx_element_children(
 &mut self,
 n: Vec<JSXElementChild>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_module_items(
 &mut self,
 n: Vec<ModuleItem>,
 __ast_path: &mut AstKindPath
) -> Vec<ModuleItem>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_object_pat_props(
 &mut self,
 n: Vec<ObjectPatProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ObjectPatProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_module_items(
 &mut self,
 n: Option<Vec<ModuleItem>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ModuleItem>>

source

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

source

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

source

fn fold_opt_span(
 &mut self,
 n: Option,
 __ast_path: &mut AstKindPath
) -> Option

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_vec_expr_or_spreads(
 &mut self,
 n: Vec<Option<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<ExprOrSpread>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_vec_pats(
 &mut self,
 n: Vec<Option<Pat>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<Pat>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_param_or_ts_param_props(
 &mut self,
 n: Vec<ParamOrTsParamProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ParamOrTsParamProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_params(
 &mut self,
 n: Vec<Param>,
 __ast_path: &mut AstKindPath
) -> Vec<Param>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_pat_or_expr(
    &mut self,
    n: PatOrExpr,
    __ast_path: &mut AstKindPath
) -> PatOrExpr

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_pats(&mut self, n: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_prop_or_spreads(
 &mut self,
 n: Vec<PropOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<PropOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_reserved_unused(
    &mut self,
    n: ReservedUnused,
    __ast_path: &mut AstKindPath
) -> ReservedUnused

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_stmts(&mut self, n: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_switch_cases(
 &mut self,
 n: Vec<SwitchCase>,
 __ast_path: &mut AstKindPath
) -> Vec<SwitchCase>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_tpl_elements(
 &mut self,
 n: Vec<TplElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TplElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_enum_members(
 &mut self,
 n: Vec<TsEnumMember>,
 __ast_path: &mut AstKindPath
) -> Vec<TsEnumMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_expr_with_type_args_vec(
 &mut self,
 n: Vec<TsExprWithTypeArgs>,
 __ast_path: &mut AstKindPath
) -> Vec<TsExprWithTypeArgs>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_fn_params(
 &mut self,
 n: Vec<TsFnParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsFnParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_tuple_elements(
 &mut self,
 n: Vec<TsTupleElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTupleElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_type_elements(
 &mut self,
 n: Vec<TsTypeElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_type_params(
 &mut self,
 n: Vec<TsTypeParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_ts_types(
 &mut self,
 n: Vec<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<TsType>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_var_decl_or_pat(
    &mut self,
    n: VarDeclOrPat,
    __ast_path: &mut AstKindPath
) -> VarDeclOrPat

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

fn fold_var_declarators(
 &mut self,
 n: Vec<VarDeclarator>,
 __ast_path: &mut AstKindPath
) -> Vec<VarDeclarator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

source

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

This method can be overriden to customize the visitor behavior.

This calls FoldWithPath::fold_children_with_path on n by default. The default method visit children nodes with self.

Implementations on Foreign Types

source

impl<'a, V> FoldAstPath for &'a mut Vwhere
V: ?Sized + FoldAstPath,

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_block_stmt_or_expr(
    &mut self,
    n: BlockStmtOrExpr,
    __ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_class_members(
 &mut self,
 n: Vec<ClassMember>,
 __ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_decorators(
 &mut self,
 n: Vec<Decorator>,
 __ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_export_specifiers(
 &mut self,
 n: Vec<ExportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_expr_or_spreads(
 &mut self,
 n: Vec<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

fn fold_exprs(
 &mut self,
 n: Vec<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_import_specifiers(
 &mut self,
 n: Vec<ImportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

source

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

source

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

source

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

source

fn fold_jsx_attr_or_spreads(
 &mut self,
 n: Vec<JSXAttrOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

fn fold_jsx_element_children(
 &mut self,
 n: Vec<JSXElementChild>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_module_items(
 &mut self,
 n: Vec<ModuleItem>,
 __ast_path: &mut AstKindPath
) -> Vec<ModuleItem>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_object_pat_props(
 &mut self,
 n: Vec<ObjectPatProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ObjectPatProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_module_items(
 &mut self,
 n: Option<Vec<ModuleItem>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ModuleItem>>

source

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

source

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

source

fn fold_opt_span(
 &mut self,
 n: Option,
 __ast_path: &mut AstKindPath
) -> Option

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_vec_expr_or_spreads(
 &mut self,
 n: Vec<Option<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<ExprOrSpread>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_vec_pats(
 &mut self,
 n: Vec<Option<Pat>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<Pat>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_param_or_ts_param_props(
 &mut self,
 n: Vec<ParamOrTsParamProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ParamOrTsParamProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_params(
 &mut self,
 n: Vec<Param>,
 __ast_path: &mut AstKindPath
) -> Vec<Param>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_pat_or_expr(
    &mut self,
    n: PatOrExpr,
    __ast_path: &mut AstKindPath
) -> PatOrExpr

source

fn fold_pats(&mut self, n: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_prop_or_spreads(
 &mut self,
 n: Vec<PropOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<PropOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

fn fold_reserved_unused(
    &mut self,
    n: ReservedUnused,
    __ast_path: &mut AstKindPath
) -> ReservedUnused

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_stmts(&mut self, n: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

fn fold_switch_cases(
 &mut self,
 n: Vec<SwitchCase>,
 __ast_path: &mut AstKindPath
) -> Vec<SwitchCase>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_tpl_elements(
 &mut self,
 n: Vec<TplElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TplElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_enum_members(
 &mut self,
 n: Vec<TsEnumMember>,
 __ast_path: &mut AstKindPath
) -> Vec<TsEnumMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_ts_expr_with_type_args_vec(
 &mut self,
 n: Vec<TsExprWithTypeArgs>,
 __ast_path: &mut AstKindPath
) -> Vec<TsExprWithTypeArgs>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

fn fold_ts_fn_params(
 &mut self,
 n: Vec<TsFnParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsFnParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_tuple_elements(
 &mut self,
 n: Vec<TsTupleElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTupleElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_type_elements(
 &mut self,
 n: Vec<TsTypeElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_type_params(
 &mut self,
 n: Vec<TsTypeParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

fn fold_ts_types(
 &mut self,
 n: Vec<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<TsType>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_var_decl_or_pat(
    &mut self,
    n: VarDeclOrPat,
    __ast_path: &mut AstKindPath
) -> VarDeclOrPat

source

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

source

fn fold_var_declarators(
 &mut self,
 n: Vec<VarDeclarator>,
 __ast_path: &mut AstKindPath
) -> Vec<VarDeclarator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

impl<V> FoldAstPath for Box<V>where
V: ?Sized + FoldAstPath,

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_block_stmt_or_expr(
    &mut self,
    n: BlockStmtOrExpr,
    __ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_class_members(
 &mut self,
 n: Vec<ClassMember>,
 __ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_decorators(
 &mut self,
 n: Vec<Decorator>,
 __ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_export_specifiers(
 &mut self,
 n: Vec<ExportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_expr_or_spreads(
 &mut self,
 n: Vec<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

fn fold_exprs(
 &mut self,
 n: Vec<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_import_specifiers(
 &mut self,
 n: Vec<ImportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

source

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

source

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

source

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

source

fn fold_jsx_attr_or_spreads(
 &mut self,
 n: Vec<JSXAttrOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

fn fold_jsx_element_children(
 &mut self,
 n: Vec<JSXElementChild>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_module_items(
 &mut self,
 n: Vec<ModuleItem>,
 __ast_path: &mut AstKindPath
) -> Vec<ModuleItem>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_object_pat_props(
 &mut self,
 n: Vec<ObjectPatProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ObjectPatProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_module_items(
 &mut self,
 n: Option<Vec<ModuleItem>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ModuleItem>>

source

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

source

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

source

fn fold_opt_span(
 &mut self,
 n: Option,
 __ast_path: &mut AstKindPath
) -> Option

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_opt_vec_expr_or_spreads(
 &mut self,
 n: Vec<Option<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<ExprOrSpread>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_vec_pats(
 &mut self,
 n: Vec<Option<Pat>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<Pat>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_param_or_ts_param_props(
 &mut self,
 n: Vec<ParamOrTsParamProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ParamOrTsParamProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_params(
 &mut self,
 n: Vec<Param>,
 __ast_path: &mut AstKindPath
) -> Vec<Param>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_pat_or_expr(
    &mut self,
    n: PatOrExpr,
    __ast_path: &mut AstKindPath
) -> PatOrExpr

source

fn fold_pats(&mut self, n: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_prop_or_spreads(
 &mut self,
 n: Vec<PropOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<PropOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

fn fold_reserved_unused(
    &mut self,
    n: ReservedUnused,
    __ast_path: &mut AstKindPath
) -> ReservedUnused

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_stmts(&mut self, n: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

fn fold_switch_cases(
 &mut self,
 n: Vec<SwitchCase>,
 __ast_path: &mut AstKindPath
) -> Vec<SwitchCase>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_tpl_elements(
 &mut self,
 n: Vec<TplElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TplElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_enum_members(
 &mut self,
 n: Vec<TsEnumMember>,
 __ast_path: &mut AstKindPath
) -> Vec<TsEnumMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_ts_expr_with_type_args_vec(
 &mut self,
 n: Vec<TsExprWithTypeArgs>,
 __ast_path: &mut AstKindPath
) -> Vec<TsExprWithTypeArgs>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

fn fold_ts_fn_params(
 &mut self,
 n: Vec<TsFnParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsFnParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_tuple_elements(
 &mut self,
 n: Vec<TsTupleElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTupleElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_type_elements(
 &mut self,
 n: Vec<TsTypeElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_ts_type_params(
 &mut self,
 n: Vec<TsTypeParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

fn fold_ts_types(
 &mut self,
 n: Vec<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<TsType>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_var_decl_or_pat(
    &mut self,
    n: VarDeclOrPat,
    __ast_path: &mut AstKindPath
) -> VarDeclOrPat

source

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

source

fn fold_var_declarators(
 &mut self,
 n: Vec<VarDeclarator>,
 __ast_path: &mut AstKindPath
) -> Vec<VarDeclarator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

impl<V> FoldAstPath for Optional<V>where
V: FoldAstPath,

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_block_stmt_or_expr(
    &mut self,
    n: BlockStmtOrExpr,
    __ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_class_members(
 &mut self,
 n: Vec<ClassMember>,
 __ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_decorators(
 &mut self,
 n: Vec<Decorator>,
 __ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_export_specifiers(
 &mut self,
 n: Vec<ExportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

fn fold_expr_or_spreads(
 &mut self,
 n: Vec<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

fn fold_exprs(
 &mut self,
 n: Vec<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn fold_import(&mut self, n: Import, __ast_path: &mut AstKindPath) -> Import

source

fn fold_import_decl(
    &mut self,
    n: ImportDecl,
    __ast_path: &mut AstKindPath
) -> ImportDecl

source

fn fold_import_default_specifier(
    &mut self,
    n: ImportDefaultSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportDefaultSpecifier

source

fn fold_import_named_specifier(
    &mut self,
    n: ImportNamedSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportNamedSpecifier

source

fn fold_import_specifier(
    &mut self,
    n: ImportSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportSpecifier

source

fn fold_import_specifiers(
 &mut self,
 n: Vec<ImportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_import_star_as_specifier(
    &mut self,
    n: ImportStarAsSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportStarAsSpecifier

source

fn fold_invalid(&mut self, n: Invalid, __ast_path: &mut AstKindPath) -> Invalid

source

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

source

fn fold_jsx_attr(&mut self, n: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr

source

fn fold_jsx_attr_name(
    &mut self,
    n: JSXAttrName,
    __ast_path: &mut AstKindPath
) -> JSXAttrName

source

fn fold_jsx_attr_or_spread(
    &mut self,
    n: JSXAttrOrSpread,
    __ast_path: &mut AstKindPath
) -> JSXAttrOrSpread

source

fn fold_jsx_attr_or_spreads(
 &mut self,
 n: Vec<JSXAttrOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_jsx_attr_value(
    &mut self,
    n: JSXAttrValue,
    __ast_path: &mut AstKindPath
) -> JSXAttrValue

source

fn fold_jsx_closing_element(
    &mut self,
    n: JSXClosingElement,
    __ast_path: &mut AstKindPath
) -> JSXClosingElement

source

fn fold_jsx_closing_fragment(
    &mut self,
    n: JSXClosingFragment,
    __ast_path: &mut AstKindPath
) -> JSXClosingFragment

source

fn fold_jsx_element(
    &mut self,
    n: JSXElement,
    __ast_path: &mut AstKindPath
) -> JSXElement

source

fn fold_jsx_element_child(
    &mut self,
    n: JSXElementChild,
    __ast_path: &mut AstKindPath
) -> JSXElementChild

source

fn fold_jsx_element_children(
 &mut self,
 n: Vec<JSXElementChild>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_jsx_element_name(
    &mut self,
    n: JSXElementName,
    __ast_path: &mut AstKindPath
) -> JSXElementName

source

fn fold_jsx_empty_expr(
    &mut self,
    n: JSXEmptyExpr,
    __ast_path: &mut AstKindPath
) -> JSXEmptyExpr

source

fn fold_jsx_expr(&mut self, n: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr

source

fn fold_jsx_expr_container(
    &mut self,
    n: JSXExprContainer,
    __ast_path: &mut AstKindPath
) -> JSXExprContainer

source

fn fold_jsx_fragment(
    &mut self,
    n: JSXFragment,
    __ast_path: &mut AstKindPath
) -> JSXFragment

source

fn fold_jsx_member_expr(
    &mut self,
    n: JSXMemberExpr,
    __ast_path: &mut AstKindPath
) -> JSXMemberExpr

source

fn fold_jsx_namespaced_name(
    &mut self,
    n: JSXNamespacedName,
    __ast_path: &mut AstKindPath
) -> JSXNamespacedName

source

fn fold_jsx_object(
    &mut self,
    n: JSXObject,
    __ast_path: &mut AstKindPath
) -> JSXObject

source

fn fold_jsx_opening_element(
    &mut self,
    n: JSXOpeningElement,
    __ast_path: &mut AstKindPath
) -> JSXOpeningElement

source

fn fold_jsx_opening_fragment(
    &mut self,
    n: JSXOpeningFragment,
    __ast_path: &mut AstKindPath
) -> JSXOpeningFragment

source

fn fold_jsx_spread_child(
    &mut self,
    n: JSXSpreadChild,
    __ast_path: &mut AstKindPath
) -> JSXSpreadChild

source

fn fold_jsx_text(&mut self, n: JSXText, __ast_path: &mut AstKindPath) -> JSXText

source

fn fold_key_value_pat_prop(
    &mut self,
    n: KeyValuePatProp,
    __ast_path: &mut AstKindPath
) -> KeyValuePatProp

source

fn fold_key_value_prop(
    &mut self,
    n: KeyValueProp,
    __ast_path: &mut AstKindPath
) -> KeyValueProp

source

fn fold_labeled_stmt(
    &mut self,
    n: LabeledStmt,
    __ast_path: &mut AstKindPath
) -> LabeledStmt

source

fn fold_lit(&mut self, n: Lit, __ast_path: &mut AstKindPath) -> Lit

source

fn fold_member_expr(
    &mut self,
    n: MemberExpr,
    __ast_path: &mut AstKindPath
) -> MemberExpr

source

fn fold_member_prop(
    &mut self,
    n: MemberProp,
    __ast_path: &mut AstKindPath
) -> MemberProp

source

fn fold_meta_prop_expr(
    &mut self,
    n: MetaPropExpr,
    __ast_path: &mut AstKindPath
) -> MetaPropExpr

source

fn fold_meta_prop_kind(
    &mut self,
    n: MetaPropKind,
    __ast_path: &mut AstKindPath
) -> MetaPropKind

source

fn fold_method_kind(
    &mut self,
    n: MethodKind,
    __ast_path: &mut AstKindPath
) -> MethodKind

source

fn fold_method_prop(
    &mut self,
    n: MethodProp,
    __ast_path: &mut AstKindPath
) -> MethodProp

source

fn fold_module(&mut self, n: Module, __ast_path: &mut AstKindPath) -> Module

source

fn fold_module_decl(
    &mut self,
    n: ModuleDecl,
    __ast_path: &mut AstKindPath
) -> ModuleDecl

source

fn fold_module_export_name(
    &mut self,
    n: ModuleExportName,
    __ast_path: &mut AstKindPath
) -> ModuleExportName

source

fn fold_module_item(
    &mut self,
    n: ModuleItem,
    __ast_path: &mut AstKindPath
) -> ModuleItem

source

fn fold_module_items(
 &mut self,
 n: Vec<ModuleItem>,
 __ast_path: &mut AstKindPath
) -> Vec<ModuleItem>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_named_export(
    &mut self,
    n: NamedExport,
    __ast_path: &mut AstKindPath
) -> NamedExport

source

fn fold_new_expr(&mut self, n: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr

source

fn fold_null(&mut self, n: Null, __ast_path: &mut AstKindPath) -> Null

source

fn fold_number(&mut self, n: Number, __ast_path: &mut AstKindPath) -> Number

source

fn fold_object_lit(
    &mut self,
    n: ObjectLit,
    __ast_path: &mut AstKindPath
) -> ObjectLit

source

fn fold_object_pat(
    &mut self,
    n: ObjectPat,
    __ast_path: &mut AstKindPath
) -> ObjectPat

source

fn fold_object_pat_prop(
    &mut self,
    n: ObjectPatProp,
    __ast_path: &mut AstKindPath
) -> ObjectPatProp

source

fn fold_object_pat_props(
 &mut self,
 n: Vec<ObjectPatProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ObjectPatProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_accessibility(
 &mut self,
 n: Option<Accessibility>,
 __ast_path: &mut AstKindPath
) -> Option<Accessibility>

source

fn fold_opt_atom(
 &mut self,
 n: Option<Atom>,
 __ast_path: &mut AstKindPath
) -> Option<Atom>

source

fn fold_opt_block_stmt(
 &mut self,
 n: Option<BlockStmt>,
 __ast_path: &mut AstKindPath
) -> Option<BlockStmt>

source

fn fold_opt_call(&mut self, n: OptCall, __ast_path: &mut AstKindPath) -> OptCall

source

fn fold_opt_catch_clause(
 &mut self,
 n: Option<CatchClause>,
 __ast_path: &mut AstKindPath
) -> Option<CatchClause>

source

fn fold_opt_chain_base(
    &mut self,
    n: OptChainBase,
    __ast_path: &mut AstKindPath
) -> OptChainBase

source

fn fold_opt_chain_expr(
    &mut self,
    n: OptChainExpr,
    __ast_path: &mut AstKindPath
) -> OptChainExpr

source

fn fold_opt_expr(
 &mut self,
 n: Option<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<Expr>>

source

fn fold_opt_expr_or_spread(
 &mut self,
 n: Option<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Option<ExprOrSpread>

source

fn fold_opt_expr_or_spreads(
 &mut self,
 n: Option<Vec<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ExprOrSpread>>

source

fn fold_opt_ident(
 &mut self,
 n: Option<Ident>,
 __ast_path: &mut AstKindPath
) -> Option<Ident>

source

fn fold_opt_jsx_attr_value(
 &mut self,
 n: Option<JSXAttrValue>,
 __ast_path: &mut AstKindPath
) -> Option<JSXAttrValue>

source

fn fold_opt_jsx_closing_element(
 &mut self,
 n: Option<JSXClosingElement>,
 __ast_path: &mut AstKindPath
) -> Option<JSXClosingElement>

source

fn fold_opt_module_export_name(
 &mut self,
 n: Option<ModuleExportName>,
 __ast_path: &mut AstKindPath
) -> Option<ModuleExportName>

source

fn fold_opt_module_items(
 &mut self,
 n: Option<Vec<ModuleItem>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ModuleItem>>

source

fn fold_opt_object_lit(
 &mut self,
 n: Option<ObjectLit>,
 __ast_path: &mut AstKindPath
) -> Option<ObjectLit>

source

fn fold_opt_pat(
 &mut self,
 n: Option<Pat>,
 __ast_path: &mut AstKindPath
) -> Option<Pat>

source

fn fold_opt_span(
 &mut self,
 n: Option,
 __ast_path: &mut AstKindPath
) -> Option

source

fn fold_opt_stmt(
 &mut self,
 n: Option<Box<Stmt>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<Stmt>>

source

fn fold_opt_str(
 &mut self,
 n: Option<Str>,
 __ast_path: &mut AstKindPath
) -> Option<Str>

source

fn fold_opt_true_plus_minus(
 &mut self,
 n: Option<TruePlusMinus>,
 __ast_path: &mut AstKindPath
) -> Option<TruePlusMinus>

source

fn fold_opt_ts_entity_name(
 &mut self,
 n: Option<TsEntityName>,
 __ast_path: &mut AstKindPath
) -> Option<TsEntityName>

source

fn fold_opt_ts_namespace_body(
 &mut self,
 n: Option<TsNamespaceBody>,
 __ast_path: &mut AstKindPath
) -> Option<TsNamespaceBody>

source

fn fold_opt_ts_type(
 &mut self,
 n: Option<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<TsType>>

source

fn fold_opt_ts_type_ann(
 &mut self,
 n: Option<TsTypeAnn>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeAnn>

source

fn fold_opt_ts_type_param_decl(
 &mut self,
 n: Option<TsTypeParamDecl>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeParamDecl>

source

fn fold_opt_ts_type_param_instantiation(
 &mut self,
 n: Option<TsTypeParamInstantiation>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeParamInstantiation>

source

fn fold_opt_var_decl_or_expr(
 &mut self,
 n: Option<VarDeclOrExpr>,
 __ast_path: &mut AstKindPath
) -> Option<VarDeclOrExpr>

source

fn fold_opt_vec_expr_or_spreads(
 &mut self,
 n: Vec<Option<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<ExprOrSpread>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_vec_pats(
 &mut self,
 n: Vec<Option<Pat>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<Pat>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_param(&mut self, n: Param, __ast_path: &mut AstKindPath) -> Param

source

fn fold_param_or_ts_param_prop(
    &mut self,
    n: ParamOrTsParamProp,
    __ast_path: &mut AstKindPath
) -> ParamOrTsParamProp

source

fn fold_param_or_ts_param_props(
 &mut self,
 n: Vec<ParamOrTsParamProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ParamOrTsParamProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_params(
 &mut self,
 n: Vec<Param>,
 __ast_path: &mut AstKindPath
) -> Vec<Param>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_paren_expr(
    &mut self,
    n: ParenExpr,
    __ast_path: &mut AstKindPath
) -> ParenExpr

source

fn fold_pat(&mut self, n: Pat, __ast_path: &mut AstKindPath) -> Pat

source

fn fold_pat_or_expr(
    &mut self,
    n: PatOrExpr,
    __ast_path: &mut AstKindPath
) -> PatOrExpr

source

fn fold_pats(&mut self, n: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_private_method(
    &mut self,
    n: PrivateMethod,
    __ast_path: &mut AstKindPath
) -> PrivateMethod

source

fn fold_private_name(
    &mut self,
    n: PrivateName,
    __ast_path: &mut AstKindPath
) -> PrivateName

source

fn fold_private_prop(
    &mut self,
    n: PrivateProp,
    __ast_path: &mut AstKindPath
) -> PrivateProp

source

fn fold_program(&mut self, n: Program, __ast_path: &mut AstKindPath) -> Program

source

fn fold_prop(&mut self, n: Prop, __ast_path: &mut AstKindPath) -> Prop

source

fn fold_prop_name(
    &mut self,
    n: PropName,
    __ast_path: &mut AstKindPath
) -> PropName

source

fn fold_prop_or_spread(
    &mut self,
    n: PropOrSpread,
    __ast_path: &mut AstKindPath
) -> PropOrSpread

source

fn fold_prop_or_spreads(
 &mut self,
 n: Vec<PropOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<PropOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_regex(&mut self, n: Regex, __ast_path: &mut AstKindPath) -> Regex

source

fn fold_reserved_unused(
    &mut self,
    n: ReservedUnused,
    __ast_path: &mut AstKindPath
) -> ReservedUnused

source

fn fold_rest_pat(&mut self, n: RestPat, __ast_path: &mut AstKindPath) -> RestPat

source

fn fold_return_stmt(
    &mut self,
    n: ReturnStmt,
    __ast_path: &mut AstKindPath
) -> ReturnStmt

source

fn fold_script(&mut self, n: Script, __ast_path: &mut AstKindPath) -> Script

source

fn fold_seq_expr(&mut self, n: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr

source

fn fold_setter_prop(
    &mut self,
    n: SetterProp,
    __ast_path: &mut AstKindPath
) -> SetterProp

source

fn fold_span(&mut self, n: Span, __ast_path: &mut AstKindPath) -> Span

source

fn fold_spread_element(
    &mut self,
    n: SpreadElement,
    __ast_path: &mut AstKindPath
) -> SpreadElement

source

fn fold_static_block(
    &mut self,
    n: StaticBlock,
    __ast_path: &mut AstKindPath
) -> StaticBlock

source

fn fold_stmt(&mut self, n: Stmt, __ast_path: &mut AstKindPath) -> Stmt

source

fn fold_stmts(&mut self, n: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_str(&mut self, n: Str, __ast_path: &mut AstKindPath) -> Str

source

fn fold_super(&mut self, n: Super, __ast_path: &mut AstKindPath) -> Super

source

fn fold_super_prop(
    &mut self,
    n: SuperProp,
    __ast_path: &mut AstKindPath
) -> SuperProp

source

fn fold_super_prop_expr(
    &mut self,
    n: SuperPropExpr,
    __ast_path: &mut AstKindPath
) -> SuperPropExpr

source

fn fold_switch_case(
    &mut self,
    n: SwitchCase,
    __ast_path: &mut AstKindPath
) -> SwitchCase

source

fn fold_switch_cases(
 &mut self,
 n: Vec<SwitchCase>,
 __ast_path: &mut AstKindPath
) -> Vec<SwitchCase>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_switch_stmt(
    &mut self,
    n: SwitchStmt,
    __ast_path: &mut AstKindPath
) -> SwitchStmt

source

fn fold_tagged_tpl(
    &mut self,
    n: TaggedTpl,
    __ast_path: &mut AstKindPath
) -> TaggedTpl

source

fn fold_this_expr(
    &mut self,
    n: ThisExpr,
    __ast_path: &mut AstKindPath
) -> ThisExpr

source

fn fold_throw_stmt(
    &mut self,
    n: ThrowStmt,
    __ast_path: &mut AstKindPath
) -> ThrowStmt

source

fn fold_tpl(&mut self, n: Tpl, __ast_path: &mut AstKindPath) -> Tpl

source

fn fold_tpl_element(
    &mut self,
    n: TplElement,
    __ast_path: &mut AstKindPath
) -> TplElement

source

fn fold_tpl_elements(
 &mut self,
 n: Vec<TplElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TplElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_true_plus_minus(
    &mut self,
    n: TruePlusMinus,
    __ast_path: &mut AstKindPath
) -> TruePlusMinus

source

fn fold_try_stmt(&mut self, n: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt

source

fn fold_ts_array_type(
    &mut self,
    n: TsArrayType,
    __ast_path: &mut AstKindPath
) -> TsArrayType

source

fn fold_ts_as_expr(
    &mut self,
    n: TsAsExpr,
    __ast_path: &mut AstKindPath
) -> TsAsExpr

source

fn fold_ts_call_signature_decl(
    &mut self,
    n: TsCallSignatureDecl,
    __ast_path: &mut AstKindPath
) -> TsCallSignatureDecl

source

fn fold_ts_conditional_type(
    &mut self,
    n: TsConditionalType,
    __ast_path: &mut AstKindPath
) -> TsConditionalType

source

fn fold_ts_const_assertion(
    &mut self,
    n: TsConstAssertion,
    __ast_path: &mut AstKindPath
) -> TsConstAssertion

source

fn fold_ts_construct_signature_decl(
    &mut self,
    n: TsConstructSignatureDecl,
    __ast_path: &mut AstKindPath
) -> TsConstructSignatureDecl

source

fn fold_ts_constructor_type(
    &mut self,
    n: TsConstructorType,
    __ast_path: &mut AstKindPath
) -> TsConstructorType

source

fn fold_ts_entity_name(
    &mut self,
    n: TsEntityName,
    __ast_path: &mut AstKindPath
) -> TsEntityName

source

fn fold_ts_enum_decl(
    &mut self,
    n: TsEnumDecl,
    __ast_path: &mut AstKindPath
) -> TsEnumDecl

source

fn fold_ts_enum_member(
    &mut self,
    n: TsEnumMember,
    __ast_path: &mut AstKindPath
) -> TsEnumMember

source

fn fold_ts_enum_member_id(
    &mut self,
    n: TsEnumMemberId,
    __ast_path: &mut AstKindPath
) -> TsEnumMemberId

source

fn fold_ts_enum_members(
 &mut self,
 n: Vec<TsEnumMember>,
 __ast_path: &mut AstKindPath
) -> Vec<TsEnumMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_export_assignment(
    &mut self,
    n: TsExportAssignment,
    __ast_path: &mut AstKindPath
) -> TsExportAssignment

source

fn fold_ts_expr_with_type_args(
    &mut self,
    n: TsExprWithTypeArgs,
    __ast_path: &mut AstKindPath
) -> TsExprWithTypeArgs

source

fn fold_ts_expr_with_type_args_vec(
 &mut self,
 n: Vec<TsExprWithTypeArgs>,
 __ast_path: &mut AstKindPath
) -> Vec<TsExprWithTypeArgs>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_external_module_ref(
    &mut self,
    n: TsExternalModuleRef,
    __ast_path: &mut AstKindPath
) -> TsExternalModuleRef

source

fn fold_ts_fn_or_constructor_type(
    &mut self,
    n: TsFnOrConstructorType,
    __ast_path: &mut AstKindPath
) -> TsFnOrConstructorType

source

fn fold_ts_fn_param(
    &mut self,
    n: TsFnParam,
    __ast_path: &mut AstKindPath
) -> TsFnParam

source

fn fold_ts_fn_params(
 &mut self,
 n: Vec<TsFnParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsFnParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_fn_type(
    &mut self,
    n: TsFnType,
    __ast_path: &mut AstKindPath
) -> TsFnType

source

fn fold_ts_getter_signature(
    &mut self,
    n: TsGetterSignature,
    __ast_path: &mut AstKindPath
) -> TsGetterSignature

source

fn fold_ts_import_equals_decl(
    &mut self,
    n: TsImportEqualsDecl,
    __ast_path: &mut AstKindPath
) -> TsImportEqualsDecl

source

fn fold_ts_import_type(
    &mut self,
    n: TsImportType,
    __ast_path: &mut AstKindPath
) -> TsImportType

source

fn fold_ts_index_signature(
    &mut self,
    n: TsIndexSignature,
    __ast_path: &mut AstKindPath
) -> TsIndexSignature

source

fn fold_ts_indexed_access_type(
    &mut self,
    n: TsIndexedAccessType,
    __ast_path: &mut AstKindPath
) -> TsIndexedAccessType

source

fn fold_ts_infer_type(
    &mut self,
    n: TsInferType,
    __ast_path: &mut AstKindPath
) -> TsInferType

source

fn fold_ts_instantiation(
    &mut self,
    n: TsInstantiation,
    __ast_path: &mut AstKindPath
) -> TsInstantiation

source

fn fold_ts_interface_body(
    &mut self,
    n: TsInterfaceBody,
    __ast_path: &mut AstKindPath
) -> TsInterfaceBody

source

fn fold_ts_interface_decl(
    &mut self,
    n: TsInterfaceDecl,
    __ast_path: &mut AstKindPath
) -> TsInterfaceDecl

source

fn fold_ts_intersection_type(
    &mut self,
    n: TsIntersectionType,
    __ast_path: &mut AstKindPath
) -> TsIntersectionType

source

fn fold_ts_keyword_type(
    &mut self,
    n: TsKeywordType,
    __ast_path: &mut AstKindPath
) -> TsKeywordType

source

fn fold_ts_keyword_type_kind(
    &mut self,
    n: TsKeywordTypeKind,
    __ast_path: &mut AstKindPath
) -> TsKeywordTypeKind

source

fn fold_ts_lit(&mut self, n: TsLit, __ast_path: &mut AstKindPath) -> TsLit

source

fn fold_ts_lit_type(
    &mut self,
    n: TsLitType,
    __ast_path: &mut AstKindPath
) -> TsLitType

source

fn fold_ts_mapped_type(
    &mut self,
    n: TsMappedType,
    __ast_path: &mut AstKindPath
) -> TsMappedType

source

fn fold_ts_method_signature(
    &mut self,
    n: TsMethodSignature,
    __ast_path: &mut AstKindPath
) -> TsMethodSignature

source

fn fold_ts_module_block(
    &mut self,
    n: TsModuleBlock,
    __ast_path: &mut AstKindPath
) -> TsModuleBlock

source

fn fold_ts_module_decl(
    &mut self,
    n: TsModuleDecl,
    __ast_path: &mut AstKindPath
) -> TsModuleDecl

source

fn fold_ts_module_name(
    &mut self,
    n: TsModuleName,
    __ast_path: &mut AstKindPath
) -> TsModuleName

source

fn fold_ts_module_ref(
    &mut self,
    n: TsModuleRef,
    __ast_path: &mut AstKindPath
) -> TsModuleRef

source

fn fold_ts_namespace_body(
    &mut self,
    n: TsNamespaceBody,
    __ast_path: &mut AstKindPath
) -> TsNamespaceBody

source

fn fold_ts_namespace_decl(
    &mut self,
    n: TsNamespaceDecl,
    __ast_path: &mut AstKindPath
) -> TsNamespaceDecl

source

fn fold_ts_namespace_export_decl(
    &mut self,
    n: TsNamespaceExportDecl,
    __ast_path: &mut AstKindPath
) -> TsNamespaceExportDecl

source

fn fold_ts_non_null_expr(
    &mut self,
    n: TsNonNullExpr,
    __ast_path: &mut AstKindPath
) -> TsNonNullExpr

source

fn fold_ts_optional_type(
    &mut self,
    n: TsOptionalType,
    __ast_path: &mut AstKindPath
) -> TsOptionalType

source

fn fold_ts_param_prop(
    &mut self,
    n: TsParamProp,
    __ast_path: &mut AstKindPath
) -> TsParamProp

source

fn fold_ts_param_prop_param(
    &mut self,
    n: TsParamPropParam,
    __ast_path: &mut AstKindPath
) -> TsParamPropParam

source

fn fold_ts_parenthesized_type(
    &mut self,
    n: TsParenthesizedType,
    __ast_path: &mut AstKindPath
) -> TsParenthesizedType

source

fn fold_ts_property_signature(
    &mut self,
    n: TsPropertySignature,
    __ast_path: &mut AstKindPath
) -> TsPropertySignature

source

fn fold_ts_qualified_name(
    &mut self,
    n: TsQualifiedName,
    __ast_path: &mut AstKindPath
) -> TsQualifiedName

source

fn fold_ts_rest_type(
    &mut self,
    n: TsRestType,
    __ast_path: &mut AstKindPath
) -> TsRestType

source

fn fold_ts_setter_signature(
    &mut self,
    n: TsSetterSignature,
    __ast_path: &mut AstKindPath
) -> TsSetterSignature

source

fn fold_ts_this_type(
    &mut self,
    n: TsThisType,
    __ast_path: &mut AstKindPath
) -> TsThisType

source

fn fold_ts_this_type_or_ident(
    &mut self,
    n: TsThisTypeOrIdent,
    __ast_path: &mut AstKindPath
) -> TsThisTypeOrIdent

source

fn fold_ts_tpl_lit_type(
    &mut self,
    n: TsTplLitType,
    __ast_path: &mut AstKindPath
) -> TsTplLitType

source

fn fold_ts_tuple_element(
    &mut self,
    n: TsTupleElement,
    __ast_path: &mut AstKindPath
) -> TsTupleElement

source

fn fold_ts_tuple_elements(
 &mut self,
 n: Vec<TsTupleElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTupleElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_tuple_type(
    &mut self,
    n: TsTupleType,
    __ast_path: &mut AstKindPath
) -> TsTupleType

source

fn fold_ts_type(&mut self, n: TsType, __ast_path: &mut AstKindPath) -> TsType

source

fn fold_ts_type_alias_decl(
    &mut self,
    n: TsTypeAliasDecl,
    __ast_path: &mut AstKindPath
) -> TsTypeAliasDecl

source

fn fold_ts_type_ann(
    &mut self,
    n: TsTypeAnn,
    __ast_path: &mut AstKindPath
) -> TsTypeAnn

source

fn fold_ts_type_assertion(
    &mut self,
    n: TsTypeAssertion,
    __ast_path: &mut AstKindPath
) -> TsTypeAssertion

source

fn fold_ts_type_element(
    &mut self,
    n: TsTypeElement,
    __ast_path: &mut AstKindPath
) -> TsTypeElement

source

fn fold_ts_type_elements(
 &mut self,
 n: Vec<TsTypeElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_type_lit(
    &mut self,
    n: TsTypeLit,
    __ast_path: &mut AstKindPath
) -> TsTypeLit

source

fn fold_ts_type_operator(
    &mut self,
    n: TsTypeOperator,
    __ast_path: &mut AstKindPath
) -> TsTypeOperator

source

fn fold_ts_type_operator_op(
    &mut self,
    n: TsTypeOperatorOp,
    __ast_path: &mut AstKindPath
) -> TsTypeOperatorOp

source

fn fold_ts_type_param(
    &mut self,
    n: TsTypeParam,
    __ast_path: &mut AstKindPath
) -> TsTypeParam

source

fn fold_ts_type_param_decl(
    &mut self,
    n: TsTypeParamDecl,
    __ast_path: &mut AstKindPath
) -> TsTypeParamDecl

source

fn fold_ts_type_param_instantiation(
    &mut self,
    n: TsTypeParamInstantiation,
    __ast_path: &mut AstKindPath
) -> TsTypeParamInstantiation

source

fn fold_ts_type_params(
 &mut self,
 n: Vec<TsTypeParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_type_predicate(
    &mut self,
    n: TsTypePredicate,
    __ast_path: &mut AstKindPath
) -> TsTypePredicate

source

fn fold_ts_type_query(
    &mut self,
    n: TsTypeQuery,
    __ast_path: &mut AstKindPath
) -> TsTypeQuery

source

fn fold_ts_type_query_expr(
    &mut self,
    n: TsTypeQueryExpr,
    __ast_path: &mut AstKindPath
) -> TsTypeQueryExpr

source

fn fold_ts_type_ref(
    &mut self,
    n: TsTypeRef,
    __ast_path: &mut AstKindPath
) -> TsTypeRef

source

fn fold_ts_types(
 &mut self,
 n: Vec<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<TsType>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_union_or_intersection_type(
    &mut self,
    n: TsUnionOrIntersectionType,
    __ast_path: &mut AstKindPath
) -> TsUnionOrIntersectionType

source

fn fold_ts_union_type(
    &mut self,
    n: TsUnionType,
    __ast_path: &mut AstKindPath
) -> TsUnionType

source

fn fold_unary_expr(
    &mut self,
    n: UnaryExpr,
    __ast_path: &mut AstKindPath
) -> UnaryExpr

source

fn fold_unary_op(&mut self, n: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp

source

fn fold_update_expr(
    &mut self,
    n: UpdateExpr,
    __ast_path: &mut AstKindPath
) -> UpdateExpr

source

fn fold_update_op(
    &mut self,
    n: UpdateOp,
    __ast_path: &mut AstKindPath
) -> UpdateOp

source

fn fold_var_decl(&mut self, n: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl

source

fn fold_var_decl_kind(
    &mut self,
    n: VarDeclKind,
    __ast_path: &mut AstKindPath
) -> VarDeclKind

source

fn fold_var_decl_or_expr(
    &mut self,
    n: VarDeclOrExpr,
    __ast_path: &mut AstKindPath
) -> VarDeclOrExpr

source

fn fold_var_decl_or_pat(
    &mut self,
    n: VarDeclOrPat,
    __ast_path: &mut AstKindPath
) -> VarDeclOrPat

source

fn fold_var_declarator(
    &mut self,
    n: VarDeclarator,
    __ast_path: &mut AstKindPath
) -> VarDeclarator

source

fn fold_var_declarators(
 &mut self,
 n: Vec<VarDeclarator>,
 __ast_path: &mut AstKindPath
) -> Vec<VarDeclarator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_while_stmt(
    &mut self,
    n: WhileStmt,
    __ast_path: &mut AstKindPath
) -> WhileStmt

source

fn fold_with_stmt(
    &mut self,
    n: WithStmt,
    __ast_path: &mut AstKindPath
) -> WithStmt

source

fn fold_yield_expr(
    &mut self,
    n: YieldExpr,
    __ast_path: &mut AstKindPath
) -> YieldExpr

source

impl<A, B> FoldAstPath for Either<A, B>where
A: FoldAstPath,
B: FoldAstPath,

source

fn fold_accessibility(
    &mut self,
    n: Accessibility,
    __ast_path: &mut AstKindPath
) -> Accessibility

source

fn fold_array_lit(
    &mut self,
    n: ArrayLit,
    __ast_path: &mut AstKindPath
) -> ArrayLit

source

fn fold_array_pat(
    &mut self,
    n: ArrayPat,
    __ast_path: &mut AstKindPath
) -> ArrayPat

source

fn fold_arrow_expr(
    &mut self,
    n: ArrowExpr,
    __ast_path: &mut AstKindPath
) -> ArrowExpr

source

fn fold_assign_expr(
    &mut self,
    n: AssignExpr,
    __ast_path: &mut AstKindPath
) -> AssignExpr

source

fn fold_assign_op(
    &mut self,
    n: AssignOp,
    __ast_path: &mut AstKindPath
) -> AssignOp

source

fn fold_assign_pat(
    &mut self,
    n: AssignPat,
    __ast_path: &mut AstKindPath
) -> AssignPat

source

fn fold_assign_pat_prop(
    &mut self,
    n: AssignPatProp,
    __ast_path: &mut AstKindPath
) -> AssignPatProp

source

fn fold_assign_prop(
    &mut self,
    n: AssignProp,
    __ast_path: &mut AstKindPath
) -> AssignProp

source

fn fold_atom(&mut self, n: Atom, __ast_path: &mut AstKindPath) -> Atom

source

fn fold_await_expr(
    &mut self,
    n: AwaitExpr,
    __ast_path: &mut AstKindPath
) -> AwaitExpr

source

fn fold_big_int(&mut self, n: BigInt, __ast_path: &mut AstKindPath) -> BigInt

source

fn fold_big_int_value(
    &mut self,
    n: BigIntValue,
    __ast_path: &mut AstKindPath
) -> BigIntValue

source

fn fold_bin_expr(&mut self, n: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr

source

fn fold_binary_op(
    &mut self,
    n: BinaryOp,
    __ast_path: &mut AstKindPath
) -> BinaryOp

source

fn fold_binding_ident(
    &mut self,
    n: BindingIdent,
    __ast_path: &mut AstKindPath
) -> BindingIdent

source

fn fold_block_stmt(
    &mut self,
    n: BlockStmt,
    __ast_path: &mut AstKindPath
) -> BlockStmt

source

fn fold_block_stmt_or_expr(
    &mut self,
    n: BlockStmtOrExpr,
    __ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

source

fn fold_bool(&mut self, n: Bool, __ast_path: &mut AstKindPath) -> Bool

source

fn fold_break_stmt(
    &mut self,
    n: BreakStmt,
    __ast_path: &mut AstKindPath
) -> BreakStmt

source

fn fold_call_expr(
    &mut self,
    n: CallExpr,
    __ast_path: &mut AstKindPath
) -> CallExpr

source

fn fold_callee(&mut self, n: Callee, __ast_path: &mut AstKindPath) -> Callee

source

fn fold_catch_clause(
    &mut self,
    n: CatchClause,
    __ast_path: &mut AstKindPath
) -> CatchClause

source

fn fold_class(&mut self, n: Class, __ast_path: &mut AstKindPath) -> Class

source

fn fold_class_decl(
    &mut self,
    n: ClassDecl,
    __ast_path: &mut AstKindPath
) -> ClassDecl

source

fn fold_class_expr(
    &mut self,
    n: ClassExpr,
    __ast_path: &mut AstKindPath
) -> ClassExpr

source

fn fold_class_member(
    &mut self,
    n: ClassMember,
    __ast_path: &mut AstKindPath
) -> ClassMember

source

fn fold_class_members(
 &mut self,
 n: Vec<ClassMember>,
 __ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_class_method(
    &mut self,
    n: ClassMethod,
    __ast_path: &mut AstKindPath
) -> ClassMethod

source

fn fold_class_prop(
    &mut self,
    n: ClassProp,
    __ast_path: &mut AstKindPath
) -> ClassProp

source

fn fold_computed_prop_name(
    &mut self,
    n: ComputedPropName,
    __ast_path: &mut AstKindPath
) -> ComputedPropName

source

fn fold_cond_expr(
    &mut self,
    n: CondExpr,
    __ast_path: &mut AstKindPath
) -> CondExpr

source

fn fold_constructor(
    &mut self,
    n: Constructor,
    __ast_path: &mut AstKindPath
) -> Constructor

source

fn fold_continue_stmt(
    &mut self,
    n: ContinueStmt,
    __ast_path: &mut AstKindPath
) -> ContinueStmt

source

fn fold_debugger_stmt(
    &mut self,
    n: DebuggerStmt,
    __ast_path: &mut AstKindPath
) -> DebuggerStmt

source

fn fold_decl(&mut self, n: Decl, __ast_path: &mut AstKindPath) -> Decl

source

fn fold_decorator(
    &mut self,
    n: Decorator,
    __ast_path: &mut AstKindPath
) -> Decorator

source

fn fold_decorators(
 &mut self,
 n: Vec<Decorator>,
 __ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_default_decl(
    &mut self,
    n: DefaultDecl,
    __ast_path: &mut AstKindPath
) -> DefaultDecl

source

fn fold_do_while_stmt(
    &mut self,
    n: DoWhileStmt,
    __ast_path: &mut AstKindPath
) -> DoWhileStmt

source

fn fold_empty_stmt(
    &mut self,
    n: EmptyStmt,
    __ast_path: &mut AstKindPath
) -> EmptyStmt

source

fn fold_export_all(
    &mut self,
    n: ExportAll,
    __ast_path: &mut AstKindPath
) -> ExportAll

source

fn fold_export_decl(
    &mut self,
    n: ExportDecl,
    __ast_path: &mut AstKindPath
) -> ExportDecl

source

fn fold_export_default_decl(
    &mut self,
    n: ExportDefaultDecl,
    __ast_path: &mut AstKindPath
) -> ExportDefaultDecl

source

fn fold_export_default_expr(
    &mut self,
    n: ExportDefaultExpr,
    __ast_path: &mut AstKindPath
) -> ExportDefaultExpr

source

fn fold_export_default_specifier(
    &mut self,
    n: ExportDefaultSpecifier,
    __ast_path: &mut AstKindPath
) -> ExportDefaultSpecifier

source

fn fold_export_named_specifier(
    &mut self,
    n: ExportNamedSpecifier,
    __ast_path: &mut AstKindPath
) -> ExportNamedSpecifier

source

fn fold_export_namespace_specifier(
    &mut self,
    n: ExportNamespaceSpecifier,
    __ast_path: &mut AstKindPath
) -> ExportNamespaceSpecifier

source

fn fold_export_specifier(
    &mut self,
    n: ExportSpecifier,
    __ast_path: &mut AstKindPath
) -> ExportSpecifier

source

fn fold_export_specifiers(
 &mut self,
 n: Vec<ExportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_expr(&mut self, n: Expr, __ast_path: &mut AstKindPath) -> Expr

source

fn fold_expr_or_spread(
    &mut self,
    n: ExprOrSpread,
    __ast_path: &mut AstKindPath
) -> ExprOrSpread

source

fn fold_expr_or_spreads(
 &mut self,
 n: Vec<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_expr_stmt(
    &mut self,
    n: ExprStmt,
    __ast_path: &mut AstKindPath
) -> ExprStmt

source

fn fold_exprs(
 &mut self,
 n: Vec<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_fn_decl(&mut self, n: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

source

fn fold_fn_expr(&mut self, n: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

source

fn fold_for_in_stmt(
    &mut self,
    n: ForInStmt,
    __ast_path: &mut AstKindPath
) -> ForInStmt

source

fn fold_for_of_stmt(
    &mut self,
    n: ForOfStmt,
    __ast_path: &mut AstKindPath
) -> ForOfStmt

source

fn fold_for_stmt(&mut self, n: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt

source

fn fold_function(&mut self, n: Function, __ast_path: &mut AstKindPath) -> Function

source

fn fold_getter_prop(
    &mut self,
    n: GetterProp,
    __ast_path: &mut AstKindPath
) -> GetterProp

source

fn fold_ident(&mut self, n: Ident, __ast_path: &mut AstKindPath) -> Ident

source

fn fold_if_stmt(&mut self, n: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

source

fn fold_import(&mut self, n: Import, __ast_path: &mut AstKindPath) -> Import

source

fn fold_import_decl(
    &mut self,
    n: ImportDecl,
    __ast_path: &mut AstKindPath
) -> ImportDecl

source

fn fold_import_default_specifier(
    &mut self,
    n: ImportDefaultSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportDefaultSpecifier

source

fn fold_import_named_specifier(
    &mut self,
    n: ImportNamedSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportNamedSpecifier

source

fn fold_import_specifier(
    &mut self,
    n: ImportSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportSpecifier

source

fn fold_import_specifiers(
 &mut self,
 n: Vec<ImportSpecifier>,
 __ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_import_star_as_specifier(
    &mut self,
    n: ImportStarAsSpecifier,
    __ast_path: &mut AstKindPath
) -> ImportStarAsSpecifier

source

fn fold_invalid(&mut self, n: Invalid, __ast_path: &mut AstKindPath) -> Invalid

source

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

source

fn fold_jsx_attr(&mut self, n: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr

source

fn fold_jsx_attr_name(
    &mut self,
    n: JSXAttrName,
    __ast_path: &mut AstKindPath
) -> JSXAttrName

source

fn fold_jsx_attr_or_spread(
    &mut self,
    n: JSXAttrOrSpread,
    __ast_path: &mut AstKindPath
) -> JSXAttrOrSpread

source

fn fold_jsx_attr_or_spreads(
 &mut self,
 n: Vec<JSXAttrOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_jsx_attr_value(
    &mut self,
    n: JSXAttrValue,
    __ast_path: &mut AstKindPath
) -> JSXAttrValue

source

fn fold_jsx_closing_element(
    &mut self,
    n: JSXClosingElement,
    __ast_path: &mut AstKindPath
) -> JSXClosingElement

source

fn fold_jsx_closing_fragment(
    &mut self,
    n: JSXClosingFragment,
    __ast_path: &mut AstKindPath
) -> JSXClosingFragment

source

fn fold_jsx_element(
    &mut self,
    n: JSXElement,
    __ast_path: &mut AstKindPath
) -> JSXElement

source

fn fold_jsx_element_child(
    &mut self,
    n: JSXElementChild,
    __ast_path: &mut AstKindPath
) -> JSXElementChild

source

fn fold_jsx_element_children(
 &mut self,
 n: Vec<JSXElementChild>,
 __ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_jsx_element_name(
    &mut self,
    n: JSXElementName,
    __ast_path: &mut AstKindPath
) -> JSXElementName

source

fn fold_jsx_empty_expr(
    &mut self,
    n: JSXEmptyExpr,
    __ast_path: &mut AstKindPath
) -> JSXEmptyExpr

source

fn fold_jsx_expr(&mut self, n: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr

source

fn fold_jsx_expr_container(
    &mut self,
    n: JSXExprContainer,
    __ast_path: &mut AstKindPath
) -> JSXExprContainer

source

fn fold_jsx_fragment(
    &mut self,
    n: JSXFragment,
    __ast_path: &mut AstKindPath
) -> JSXFragment

source

fn fold_jsx_member_expr(
    &mut self,
    n: JSXMemberExpr,
    __ast_path: &mut AstKindPath
) -> JSXMemberExpr

source

fn fold_jsx_namespaced_name(
    &mut self,
    n: JSXNamespacedName,
    __ast_path: &mut AstKindPath
) -> JSXNamespacedName

source

fn fold_jsx_object(
    &mut self,
    n: JSXObject,
    __ast_path: &mut AstKindPath
) -> JSXObject

source

fn fold_jsx_opening_element(
    &mut self,
    n: JSXOpeningElement,
    __ast_path: &mut AstKindPath
) -> JSXOpeningElement

source

fn fold_jsx_opening_fragment(
    &mut self,
    n: JSXOpeningFragment,
    __ast_path: &mut AstKindPath
) -> JSXOpeningFragment

source

fn fold_jsx_spread_child(
    &mut self,
    n: JSXSpreadChild,
    __ast_path: &mut AstKindPath
) -> JSXSpreadChild

source

fn fold_jsx_text(&mut self, n: JSXText, __ast_path: &mut AstKindPath) -> JSXText

source

fn fold_key_value_pat_prop(
    &mut self,
    n: KeyValuePatProp,
    __ast_path: &mut AstKindPath
) -> KeyValuePatProp

source

fn fold_key_value_prop(
    &mut self,
    n: KeyValueProp,
    __ast_path: &mut AstKindPath
) -> KeyValueProp

source

fn fold_labeled_stmt(
    &mut self,
    n: LabeledStmt,
    __ast_path: &mut AstKindPath
) -> LabeledStmt

source

fn fold_lit(&mut self, n: Lit, __ast_path: &mut AstKindPath) -> Lit

source

fn fold_member_expr(
    &mut self,
    n: MemberExpr,
    __ast_path: &mut AstKindPath
) -> MemberExpr

source

fn fold_member_prop(
    &mut self,
    n: MemberProp,
    __ast_path: &mut AstKindPath
) -> MemberProp

source

fn fold_meta_prop_expr(
    &mut self,
    n: MetaPropExpr,
    __ast_path: &mut AstKindPath
) -> MetaPropExpr

source

fn fold_meta_prop_kind(
    &mut self,
    n: MetaPropKind,
    __ast_path: &mut AstKindPath
) -> MetaPropKind

source

fn fold_method_kind(
    &mut self,
    n: MethodKind,
    __ast_path: &mut AstKindPath
) -> MethodKind

source

fn fold_method_prop(
    &mut self,
    n: MethodProp,
    __ast_path: &mut AstKindPath
) -> MethodProp

source

fn fold_module(&mut self, n: Module, __ast_path: &mut AstKindPath) -> Module

source

fn fold_module_decl(
    &mut self,
    n: ModuleDecl,
    __ast_path: &mut AstKindPath
) -> ModuleDecl

source

fn fold_module_export_name(
    &mut self,
    n: ModuleExportName,
    __ast_path: &mut AstKindPath
) -> ModuleExportName

source

fn fold_module_item(
    &mut self,
    n: ModuleItem,
    __ast_path: &mut AstKindPath
) -> ModuleItem

source

fn fold_module_items(
 &mut self,
 n: Vec<ModuleItem>,
 __ast_path: &mut AstKindPath
) -> Vec<ModuleItem>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_named_export(
    &mut self,
    n: NamedExport,
    __ast_path: &mut AstKindPath
) -> NamedExport

source

fn fold_new_expr(&mut self, n: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr

source

fn fold_null(&mut self, n: Null, __ast_path: &mut AstKindPath) -> Null

source

fn fold_number(&mut self, n: Number, __ast_path: &mut AstKindPath) -> Number

source

fn fold_object_lit(
    &mut self,
    n: ObjectLit,
    __ast_path: &mut AstKindPath
) -> ObjectLit

source

fn fold_object_pat(
    &mut self,
    n: ObjectPat,
    __ast_path: &mut AstKindPath
) -> ObjectPat

source

fn fold_object_pat_prop(
    &mut self,
    n: ObjectPatProp,
    __ast_path: &mut AstKindPath
) -> ObjectPatProp

source

fn fold_object_pat_props(
 &mut self,
 n: Vec<ObjectPatProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ObjectPatProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_accessibility(
 &mut self,
 n: Option<Accessibility>,
 __ast_path: &mut AstKindPath
) -> Option<Accessibility>

source

fn fold_opt_atom(
 &mut self,
 n: Option<Atom>,
 __ast_path: &mut AstKindPath
) -> Option<Atom>

source

fn fold_opt_block_stmt(
 &mut self,
 n: Option<BlockStmt>,
 __ast_path: &mut AstKindPath
) -> Option<BlockStmt>

source

fn fold_opt_call(&mut self, n: OptCall, __ast_path: &mut AstKindPath) -> OptCall

source

fn fold_opt_catch_clause(
 &mut self,
 n: Option<CatchClause>,
 __ast_path: &mut AstKindPath
) -> Option<CatchClause>

source

fn fold_opt_chain_base(
    &mut self,
    n: OptChainBase,
    __ast_path: &mut AstKindPath
) -> OptChainBase

source

fn fold_opt_chain_expr(
    &mut self,
    n: OptChainExpr,
    __ast_path: &mut AstKindPath
) -> OptChainExpr

source

fn fold_opt_expr(
 &mut self,
 n: Option<Box<Expr>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<Expr>>

source

fn fold_opt_expr_or_spread(
 &mut self,
 n: Option<ExprOrSpread>,
 __ast_path: &mut AstKindPath
) -> Option<ExprOrSpread>

source

fn fold_opt_expr_or_spreads(
 &mut self,
 n: Option<Vec<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ExprOrSpread>>

source

fn fold_opt_ident(
 &mut self,
 n: Option<Ident>,
 __ast_path: &mut AstKindPath
) -> Option<Ident>

source

fn fold_opt_jsx_attr_value(
 &mut self,
 n: Option<JSXAttrValue>,
 __ast_path: &mut AstKindPath
) -> Option<JSXAttrValue>

source

fn fold_opt_jsx_closing_element(
 &mut self,
 n: Option<JSXClosingElement>,
 __ast_path: &mut AstKindPath
) -> Option<JSXClosingElement>

source

fn fold_opt_module_export_name(
 &mut self,
 n: Option<ModuleExportName>,
 __ast_path: &mut AstKindPath
) -> Option<ModuleExportName>

source

fn fold_opt_module_items(
 &mut self,
 n: Option<Vec<ModuleItem>>,
 __ast_path: &mut AstKindPath
) -> Option<Vec<ModuleItem>>

source

fn fold_opt_object_lit(
 &mut self,
 n: Option<ObjectLit>,
 __ast_path: &mut AstKindPath
) -> Option<ObjectLit>

source

fn fold_opt_pat(
 &mut self,
 n: Option<Pat>,
 __ast_path: &mut AstKindPath
) -> Option<Pat>

source

fn fold_opt_span(
 &mut self,
 n: Option,
 __ast_path: &mut AstKindPath
) -> Option

source

fn fold_opt_stmt(
 &mut self,
 n: Option<Box<Stmt>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<Stmt>>

source

fn fold_opt_str(
 &mut self,
 n: Option<Str>,
 __ast_path: &mut AstKindPath
) -> Option<Str>

source

fn fold_opt_true_plus_minus(
 &mut self,
 n: Option<TruePlusMinus>,
 __ast_path: &mut AstKindPath
) -> Option<TruePlusMinus>

source

fn fold_opt_ts_entity_name(
 &mut self,
 n: Option<TsEntityName>,
 __ast_path: &mut AstKindPath
) -> Option<TsEntityName>

source

fn fold_opt_ts_namespace_body(
 &mut self,
 n: Option<TsNamespaceBody>,
 __ast_path: &mut AstKindPath
) -> Option<TsNamespaceBody>

source

fn fold_opt_ts_type(
 &mut self,
 n: Option<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Option<Box<TsType>>

source

fn fold_opt_ts_type_ann(
 &mut self,
 n: Option<TsTypeAnn>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeAnn>

source

fn fold_opt_ts_type_param_decl(
 &mut self,
 n: Option<TsTypeParamDecl>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeParamDecl>

source

fn fold_opt_ts_type_param_instantiation(
 &mut self,
 n: Option<TsTypeParamInstantiation>,
 __ast_path: &mut AstKindPath
) -> Option<TsTypeParamInstantiation>

source

fn fold_opt_var_decl_or_expr(
 &mut self,
 n: Option<VarDeclOrExpr>,
 __ast_path: &mut AstKindPath
) -> Option<VarDeclOrExpr>

source

fn fold_opt_vec_expr_or_spreads(
 &mut self,
 n: Vec<Option<ExprOrSpread>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<ExprOrSpread>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_opt_vec_pats(
 &mut self,
 n: Vec<Option<Pat>>,
 __ast_path: &mut AstKindPath
) -> Vec<Option<Pat>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_param(&mut self, n: Param, __ast_path: &mut AstKindPath) -> Param

source

fn fold_param_or_ts_param_prop(
    &mut self,
    n: ParamOrTsParamProp,
    __ast_path: &mut AstKindPath
) -> ParamOrTsParamProp

source

fn fold_param_or_ts_param_props(
 &mut self,
 n: Vec<ParamOrTsParamProp>,
 __ast_path: &mut AstKindPath
) -> Vec<ParamOrTsParamProp>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_params(
 &mut self,
 n: Vec<Param>,
 __ast_path: &mut AstKindPath
) -> Vec<Param>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_paren_expr(
    &mut self,
    n: ParenExpr,
    __ast_path: &mut AstKindPath
) -> ParenExpr

source

fn fold_pat(&mut self, n: Pat, __ast_path: &mut AstKindPath) -> Pat

source

fn fold_pat_or_expr(
    &mut self,
    n: PatOrExpr,
    __ast_path: &mut AstKindPath
) -> PatOrExpr

source

fn fold_pats(&mut self, n: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_private_method(
    &mut self,
    n: PrivateMethod,
    __ast_path: &mut AstKindPath
) -> PrivateMethod

source

fn fold_private_name(
    &mut self,
    n: PrivateName,
    __ast_path: &mut AstKindPath
) -> PrivateName

source

fn fold_private_prop(
    &mut self,
    n: PrivateProp,
    __ast_path: &mut AstKindPath
) -> PrivateProp

source

fn fold_program(&mut self, n: Program, __ast_path: &mut AstKindPath) -> Program

source

fn fold_prop(&mut self, n: Prop, __ast_path: &mut AstKindPath) -> Prop

source

fn fold_prop_name(
    &mut self,
    n: PropName,
    __ast_path: &mut AstKindPath
) -> PropName

source

fn fold_prop_or_spread(
    &mut self,
    n: PropOrSpread,
    __ast_path: &mut AstKindPath
) -> PropOrSpread

source

fn fold_prop_or_spreads(
 &mut self,
 n: Vec<PropOrSpread>,
 __ast_path: &mut AstKindPath
) -> Vec<PropOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_regex(&mut self, n: Regex, __ast_path: &mut AstKindPath) -> Regex

source

fn fold_reserved_unused(
    &mut self,
    n: ReservedUnused,
    __ast_path: &mut AstKindPath
) -> ReservedUnused

source

fn fold_rest_pat(&mut self, n: RestPat, __ast_path: &mut AstKindPath) -> RestPat

source

fn fold_return_stmt(
    &mut self,
    n: ReturnStmt,
    __ast_path: &mut AstKindPath
) -> ReturnStmt

source

fn fold_script(&mut self, n: Script, __ast_path: &mut AstKindPath) -> Script

source

fn fold_seq_expr(&mut self, n: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr

source

fn fold_setter_prop(
    &mut self,
    n: SetterProp,
    __ast_path: &mut AstKindPath
) -> SetterProp

source

fn fold_span(&mut self, n: Span, __ast_path: &mut AstKindPath) -> Span

source

fn fold_spread_element(
    &mut self,
    n: SpreadElement,
    __ast_path: &mut AstKindPath
) -> SpreadElement

source

fn fold_static_block(
    &mut self,
    n: StaticBlock,
    __ast_path: &mut AstKindPath
) -> StaticBlock

source

fn fold_stmt(&mut self, n: Stmt, __ast_path: &mut AstKindPath) -> Stmt

source

fn fold_stmts(&mut self, n: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_str(&mut self, n: Str, __ast_path: &mut AstKindPath) -> Str

source

fn fold_super(&mut self, n: Super, __ast_path: &mut AstKindPath) -> Super

source

fn fold_super_prop(
    &mut self,
    n: SuperProp,
    __ast_path: &mut AstKindPath
) -> SuperProp

source

fn fold_super_prop_expr(
    &mut self,
    n: SuperPropExpr,
    __ast_path: &mut AstKindPath
) -> SuperPropExpr

source

fn fold_switch_case(
    &mut self,
    n: SwitchCase,
    __ast_path: &mut AstKindPath
) -> SwitchCase

source

fn fold_switch_cases(
 &mut self,
 n: Vec<SwitchCase>,
 __ast_path: &mut AstKindPath
) -> Vec<SwitchCase>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_switch_stmt(
    &mut self,
    n: SwitchStmt,
    __ast_path: &mut AstKindPath
) -> SwitchStmt

source

fn fold_tagged_tpl(
    &mut self,
    n: TaggedTpl,
    __ast_path: &mut AstKindPath
) -> TaggedTpl

source

fn fold_this_expr(
    &mut self,
    n: ThisExpr,
    __ast_path: &mut AstKindPath
) -> ThisExpr

source

fn fold_throw_stmt(
    &mut self,
    n: ThrowStmt,
    __ast_path: &mut AstKindPath
) -> ThrowStmt

source

fn fold_tpl(&mut self, n: Tpl, __ast_path: &mut AstKindPath) -> Tpl

source

fn fold_tpl_element(
    &mut self,
    n: TplElement,
    __ast_path: &mut AstKindPath
) -> TplElement

source

fn fold_tpl_elements(
 &mut self,
 n: Vec<TplElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TplElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_true_plus_minus(
    &mut self,
    n: TruePlusMinus,
    __ast_path: &mut AstKindPath
) -> TruePlusMinus

source

fn fold_try_stmt(&mut self, n: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt

source

fn fold_ts_array_type(
    &mut self,
    n: TsArrayType,
    __ast_path: &mut AstKindPath
) -> TsArrayType

source

fn fold_ts_as_expr(
    &mut self,
    n: TsAsExpr,
    __ast_path: &mut AstKindPath
) -> TsAsExpr

source

fn fold_ts_call_signature_decl(
    &mut self,
    n: TsCallSignatureDecl,
    __ast_path: &mut AstKindPath
) -> TsCallSignatureDecl

source

fn fold_ts_conditional_type(
    &mut self,
    n: TsConditionalType,
    __ast_path: &mut AstKindPath
) -> TsConditionalType

source

fn fold_ts_const_assertion(
    &mut self,
    n: TsConstAssertion,
    __ast_path: &mut AstKindPath
) -> TsConstAssertion

source

fn fold_ts_construct_signature_decl(
    &mut self,
    n: TsConstructSignatureDecl,
    __ast_path: &mut AstKindPath
) -> TsConstructSignatureDecl

source

fn fold_ts_constructor_type(
    &mut self,
    n: TsConstructorType,
    __ast_path: &mut AstKindPath
) -> TsConstructorType

source

fn fold_ts_entity_name(
    &mut self,
    n: TsEntityName,
    __ast_path: &mut AstKindPath
) -> TsEntityName

source

fn fold_ts_enum_decl(
    &mut self,
    n: TsEnumDecl,
    __ast_path: &mut AstKindPath
) -> TsEnumDecl

source

fn fold_ts_enum_member(
    &mut self,
    n: TsEnumMember,
    __ast_path: &mut AstKindPath
) -> TsEnumMember

source

fn fold_ts_enum_member_id(
    &mut self,
    n: TsEnumMemberId,
    __ast_path: &mut AstKindPath
) -> TsEnumMemberId

source

fn fold_ts_enum_members(
 &mut self,
 n: Vec<TsEnumMember>,
 __ast_path: &mut AstKindPath
) -> Vec<TsEnumMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_export_assignment(
    &mut self,
    n: TsExportAssignment,
    __ast_path: &mut AstKindPath
) -> TsExportAssignment

source

fn fold_ts_expr_with_type_args(
    &mut self,
    n: TsExprWithTypeArgs,
    __ast_path: &mut AstKindPath
) -> TsExprWithTypeArgs

source

fn fold_ts_expr_with_type_args_vec(
 &mut self,
 n: Vec<TsExprWithTypeArgs>,
 __ast_path: &mut AstKindPath
) -> Vec<TsExprWithTypeArgs>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_external_module_ref(
    &mut self,
    n: TsExternalModuleRef,
    __ast_path: &mut AstKindPath
) -> TsExternalModuleRef

source

fn fold_ts_fn_or_constructor_type(
    &mut self,
    n: TsFnOrConstructorType,
    __ast_path: &mut AstKindPath
) -> TsFnOrConstructorType

source

fn fold_ts_fn_param(
    &mut self,
    n: TsFnParam,
    __ast_path: &mut AstKindPath
) -> TsFnParam

source

fn fold_ts_fn_params(
 &mut self,
 n: Vec<TsFnParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsFnParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_fn_type(
    &mut self,
    n: TsFnType,
    __ast_path: &mut AstKindPath
) -> TsFnType

source

fn fold_ts_getter_signature(
    &mut self,
    n: TsGetterSignature,
    __ast_path: &mut AstKindPath
) -> TsGetterSignature

source

fn fold_ts_import_equals_decl(
    &mut self,
    n: TsImportEqualsDecl,
    __ast_path: &mut AstKindPath
) -> TsImportEqualsDecl

source

fn fold_ts_import_type(
    &mut self,
    n: TsImportType,
    __ast_path: &mut AstKindPath
) -> TsImportType

source

fn fold_ts_index_signature(
    &mut self,
    n: TsIndexSignature,
    __ast_path: &mut AstKindPath
) -> TsIndexSignature

source

fn fold_ts_indexed_access_type(
    &mut self,
    n: TsIndexedAccessType,
    __ast_path: &mut AstKindPath
) -> TsIndexedAccessType

source

fn fold_ts_infer_type(
    &mut self,
    n: TsInferType,
    __ast_path: &mut AstKindPath
) -> TsInferType

source

fn fold_ts_instantiation(
    &mut self,
    n: TsInstantiation,
    __ast_path: &mut AstKindPath
) -> TsInstantiation

source

fn fold_ts_interface_body(
    &mut self,
    n: TsInterfaceBody,
    __ast_path: &mut AstKindPath
) -> TsInterfaceBody

source

fn fold_ts_interface_decl(
    &mut self,
    n: TsInterfaceDecl,
    __ast_path: &mut AstKindPath
) -> TsInterfaceDecl

source

fn fold_ts_intersection_type(
    &mut self,
    n: TsIntersectionType,
    __ast_path: &mut AstKindPath
) -> TsIntersectionType

source

fn fold_ts_keyword_type(
    &mut self,
    n: TsKeywordType,
    __ast_path: &mut AstKindPath
) -> TsKeywordType

source

fn fold_ts_keyword_type_kind(
    &mut self,
    n: TsKeywordTypeKind,
    __ast_path: &mut AstKindPath
) -> TsKeywordTypeKind

source

fn fold_ts_lit(&mut self, n: TsLit, __ast_path: &mut AstKindPath) -> TsLit

source

fn fold_ts_lit_type(
    &mut self,
    n: TsLitType,
    __ast_path: &mut AstKindPath
) -> TsLitType

source

fn fold_ts_mapped_type(
    &mut self,
    n: TsMappedType,
    __ast_path: &mut AstKindPath
) -> TsMappedType

source

fn fold_ts_method_signature(
    &mut self,
    n: TsMethodSignature,
    __ast_path: &mut AstKindPath
) -> TsMethodSignature

source

fn fold_ts_module_block(
    &mut self,
    n: TsModuleBlock,
    __ast_path: &mut AstKindPath
) -> TsModuleBlock

source

fn fold_ts_module_decl(
    &mut self,
    n: TsModuleDecl,
    __ast_path: &mut AstKindPath
) -> TsModuleDecl

source

fn fold_ts_module_name(
    &mut self,
    n: TsModuleName,
    __ast_path: &mut AstKindPath
) -> TsModuleName

source

fn fold_ts_module_ref(
    &mut self,
    n: TsModuleRef,
    __ast_path: &mut AstKindPath
) -> TsModuleRef

source

fn fold_ts_namespace_body(
    &mut self,
    n: TsNamespaceBody,
    __ast_path: &mut AstKindPath
) -> TsNamespaceBody

source

fn fold_ts_namespace_decl(
    &mut self,
    n: TsNamespaceDecl,
    __ast_path: &mut AstKindPath
) -> TsNamespaceDecl

source

fn fold_ts_namespace_export_decl(
    &mut self,
    n: TsNamespaceExportDecl,
    __ast_path: &mut AstKindPath
) -> TsNamespaceExportDecl

source

fn fold_ts_non_null_expr(
    &mut self,
    n: TsNonNullExpr,
    __ast_path: &mut AstKindPath
) -> TsNonNullExpr

source

fn fold_ts_optional_type(
    &mut self,
    n: TsOptionalType,
    __ast_path: &mut AstKindPath
) -> TsOptionalType

source

fn fold_ts_param_prop(
    &mut self,
    n: TsParamProp,
    __ast_path: &mut AstKindPath
) -> TsParamProp

source

fn fold_ts_param_prop_param(
    &mut self,
    n: TsParamPropParam,
    __ast_path: &mut AstKindPath
) -> TsParamPropParam

source

fn fold_ts_parenthesized_type(
    &mut self,
    n: TsParenthesizedType,
    __ast_path: &mut AstKindPath
) -> TsParenthesizedType

source

fn fold_ts_property_signature(
    &mut self,
    n: TsPropertySignature,
    __ast_path: &mut AstKindPath
) -> TsPropertySignature

source

fn fold_ts_qualified_name(
    &mut self,
    n: TsQualifiedName,
    __ast_path: &mut AstKindPath
) -> TsQualifiedName

source

fn fold_ts_rest_type(
    &mut self,
    n: TsRestType,
    __ast_path: &mut AstKindPath
) -> TsRestType

source

fn fold_ts_setter_signature(
    &mut self,
    n: TsSetterSignature,
    __ast_path: &mut AstKindPath
) -> TsSetterSignature

source

fn fold_ts_this_type(
    &mut self,
    n: TsThisType,
    __ast_path: &mut AstKindPath
) -> TsThisType

source

fn fold_ts_this_type_or_ident(
    &mut self,
    n: TsThisTypeOrIdent,
    __ast_path: &mut AstKindPath
) -> TsThisTypeOrIdent

source

fn fold_ts_tpl_lit_type(
    &mut self,
    n: TsTplLitType,
    __ast_path: &mut AstKindPath
) -> TsTplLitType

source

fn fold_ts_tuple_element(
    &mut self,
    n: TsTupleElement,
    __ast_path: &mut AstKindPath
) -> TsTupleElement

source

fn fold_ts_tuple_elements(
 &mut self,
 n: Vec<TsTupleElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTupleElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_tuple_type(
    &mut self,
    n: TsTupleType,
    __ast_path: &mut AstKindPath
) -> TsTupleType

source

fn fold_ts_type(&mut self, n: TsType, __ast_path: &mut AstKindPath) -> TsType

source

fn fold_ts_type_alias_decl(
    &mut self,
    n: TsTypeAliasDecl,
    __ast_path: &mut AstKindPath
) -> TsTypeAliasDecl

source

fn fold_ts_type_ann(
    &mut self,
    n: TsTypeAnn,
    __ast_path: &mut AstKindPath
) -> TsTypeAnn

source

fn fold_ts_type_assertion(
    &mut self,
    n: TsTypeAssertion,
    __ast_path: &mut AstKindPath
) -> TsTypeAssertion

source

fn fold_ts_type_element(
    &mut self,
    n: TsTypeElement,
    __ast_path: &mut AstKindPath
) -> TsTypeElement

source

fn fold_ts_type_elements(
 &mut self,
 n: Vec<TsTypeElement>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeElement>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_type_lit(
    &mut self,
    n: TsTypeLit,
    __ast_path: &mut AstKindPath
) -> TsTypeLit

source

fn fold_ts_type_operator(
    &mut self,
    n: TsTypeOperator,
    __ast_path: &mut AstKindPath
) -> TsTypeOperator

source

fn fold_ts_type_operator_op(
    &mut self,
    n: TsTypeOperatorOp,
    __ast_path: &mut AstKindPath
) -> TsTypeOperatorOp

source

fn fold_ts_type_param(
    &mut self,
    n: TsTypeParam,
    __ast_path: &mut AstKindPath
) -> TsTypeParam

source

fn fold_ts_type_param_decl(
    &mut self,
    n: TsTypeParamDecl,
    __ast_path: &mut AstKindPath
) -> TsTypeParamDecl

source

fn fold_ts_type_param_instantiation(
    &mut self,
    n: TsTypeParamInstantiation,
    __ast_path: &mut AstKindPath
) -> TsTypeParamInstantiation

source

fn fold_ts_type_params(
 &mut self,
 n: Vec<TsTypeParam>,
 __ast_path: &mut AstKindPath
) -> Vec<TsTypeParam>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_type_predicate(
    &mut self,
    n: TsTypePredicate,
    __ast_path: &mut AstKindPath
) -> TsTypePredicate

source

fn fold_ts_type_query(
    &mut self,
    n: TsTypeQuery,
    __ast_path: &mut AstKindPath
) -> TsTypeQuery

source

fn fold_ts_type_query_expr(
    &mut self,
    n: TsTypeQueryExpr,
    __ast_path: &mut AstKindPath
) -> TsTypeQueryExpr

source

fn fold_ts_type_ref(
    &mut self,
    n: TsTypeRef,
    __ast_path: &mut AstKindPath
) -> TsTypeRef

source

fn fold_ts_types(
 &mut self,
 n: Vec<Box<TsType>>,
 __ast_path: &mut AstKindPath
) -> Vec<Box<TsType>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_ts_union_or_intersection_type(
    &mut self,
    n: TsUnionOrIntersectionType,
    __ast_path: &mut AstKindPath
) -> TsUnionOrIntersectionType

source

fn fold_ts_union_type(
    &mut self,
    n: TsUnionType,
    __ast_path: &mut AstKindPath
) -> TsUnionType

source

fn fold_unary_expr(
    &mut self,
    n: UnaryExpr,
    __ast_path: &mut AstKindPath
) -> UnaryExpr

source

fn fold_unary_op(&mut self, n: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp

source

fn fold_update_expr(
    &mut self,
    n: UpdateExpr,
    __ast_path: &mut AstKindPath
) -> UpdateExpr

source

fn fold_update_op(
    &mut self,
    n: UpdateOp,
    __ast_path: &mut AstKindPath
) -> UpdateOp

source

fn fold_var_decl(&mut self, n: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl

source

fn fold_var_decl_kind(
    &mut self,
    n: VarDeclKind,
    __ast_path: &mut AstKindPath
) -> VarDeclKind

source

fn fold_var_decl_or_expr(
    &mut self,
    n: VarDeclOrExpr,
    __ast_path: &mut AstKindPath
) -> VarDeclOrExpr

source

fn fold_var_decl_or_pat(
    &mut self,
    n: VarDeclOrPat,
    __ast_path: &mut AstKindPath
) -> VarDeclOrPat

source

fn fold_var_declarator(
    &mut self,
    n: VarDeclarator,
    __ast_path: &mut AstKindPath
) -> VarDeclarator

source

fn fold_var_declarators(
 &mut self,
 n: Vec<VarDeclarator>,
 __ast_path: &mut AstKindPath
) -> Vec<VarDeclarator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

source

fn fold_while_stmt(
    &mut self,
    n: WhileStmt,
    __ast_path: &mut AstKindPath
) -> WhileStmt

source

fn fold_with_stmt(
    &mut self,
    n: WithStmt,
    __ast_path: &mut AstKindPath
) -> WithStmt

source

Trait swc_ecma_visit::FoldAstPath

Provided Methods

fn fold_accessibility( &mut self, n: Accessibility, __ast_path: &mut AstKindPath) -> Accessibility

fn fold_array_lit( &mut self, n: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit

fn fold_array_pat( &mut self, n: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat

fn fold_arrow_expr( &mut self, n: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr

fn fold_assign_expr( &mut self, n: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr

fn fold_assign_op( &mut self, n: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp

fn fold_assign_pat( &mut self, n: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat

fn fold_assign_pat_prop( &mut self, n: AssignPatProp, __ast_path: &mut AstKindPath) -> AssignPatProp

fn fold_assign_prop( &mut self, n: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp

fn fold_atom(&mut self, n: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_await_expr( &mut self, n: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr

fn fold_big_int(&mut self, n: BigInt, __ast_path: &mut AstKindPath) -> BigInt

fn fold_big_int_value( &mut self, n: BigIntValue, __ast_path: &mut AstKindPath) -> BigIntValue

fn fold_bin_expr(&mut self, n: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr

fn fold_binary_op( &mut self, n: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp

fn fold_binding_ident( &mut self, n: BindingIdent, __ast_path: &mut AstKindPath) -> BindingIdent

fn fold_block_stmt( &mut self, n: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt

fn fold_block_stmt_or_expr( &mut self, n: BlockStmtOrExpr, __ast_path: &mut AstKindPath) -> BlockStmtOrExpr

fn fold_bool(&mut self, n: Bool, __ast_path: &mut AstKindPath) -> Bool

fn fold_break_stmt( &mut self, n: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt

fn fold_call_expr( &mut self, n: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr

fn fold_callee(&mut self, n: Callee, __ast_path: &mut AstKindPath) -> Callee

fn fold_catch_clause( &mut self, n: CatchClause, __ast_path: &mut AstKindPath) -> CatchClause

fn fold_class(&mut self, n: Class, __ast_path: &mut AstKindPath) -> Class

fn fold_class_decl( &mut self, n: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl

fn fold_class_expr( &mut self, n: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr

fn fold_class_member( &mut self, n: ClassMember, __ast_path: &mut AstKindPath) -> ClassMember

fn fold_class_members( &mut self, n: Vec<ClassMember>, __ast_path: &mut AstKindPath) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_class_method( &mut self, n: ClassMethod, __ast_path: &mut AstKindPath) -> ClassMethod

fn fold_class_prop( &mut self, n: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp

fn fold_computed_prop_name( &mut self, n: ComputedPropName, __ast_path: &mut AstKindPath) -> ComputedPropName

fn fold_cond_expr( &mut self, n: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr

fn fold_constructor( &mut self, n: Constructor, __ast_path: &mut AstKindPath) -> Constructor

fn fold_continue_stmt( &mut self, n: ContinueStmt, __ast_path: &mut AstKindPath) -> ContinueStmt

fn fold_debugger_stmt( &mut self, n: DebuggerStmt, __ast_path: &mut AstKindPath) -> DebuggerStmt

fn fold_decl(&mut self, n: Decl, __ast_path: &mut AstKindPath) -> Decl

fn fold_decorator( &mut self, n: Decorator, __ast_path: &mut AstKindPath) -> Decorator

fn fold_decorators( &mut self, n: Vec<Decorator>, __ast_path: &mut AstKindPath) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_default_decl( &mut self, n: DefaultDecl, __ast_path: &mut AstKindPath) -> DefaultDecl

fn fold_do_while_stmt( &mut self, n: DoWhileStmt, __ast_path: &mut AstKindPath) -> DoWhileStmt

fn fold_empty_stmt( &mut self, n: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt

fn fold_export_all( &mut self, n: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll

fn fold_export_decl( &mut self, n: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl

fn fold_export_default_decl( &mut self, n: ExportDefaultDecl, __ast_path: &mut AstKindPath) -> ExportDefaultDecl

fn fold_export_default_expr( &mut self, n: ExportDefaultExpr, __ast_path: &mut AstKindPath) -> ExportDefaultExpr

fn fold_export_default_specifier( &mut self, n: ExportDefaultSpecifier, __ast_path: &mut AstKindPath) -> ExportDefaultSpecifier

fn fold_export_named_specifier( &mut self, n: ExportNamedSpecifier, __ast_path: &mut AstKindPath) -> ExportNamedSpecifier

fn fold_export_namespace_specifier( &mut self, n: ExportNamespaceSpecifier, __ast_path: &mut AstKindPath) -> ExportNamespaceSpecifier

fn fold_export_specifier( &mut self, n: ExportSpecifier, __ast_path: &mut AstKindPath) -> ExportSpecifier

fn fold_export_specifiers( &mut self, n: Vec<ExportSpecifier>, __ast_path: &mut AstKindPath) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_expr(&mut self, n: Expr, __ast_path: &mut AstKindPath) -> Expr

fn fold_expr_or_spread( &mut self, n: ExprOrSpread, __ast_path: &mut AstKindPath) -> ExprOrSpread

fn fold_expr_or_spreads( &mut self, n: Vec<ExprOrSpread>, __ast_path: &mut AstKindPath) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_expr_stmt( &mut self, n: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt

fn fold_exprs( &mut self, n: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_fn_decl(&mut self, n: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl

fn fold_fn_expr(&mut self, n: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr

fn fold_for_in_stmt( &mut self, n: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt

fn fold_for_of_stmt( &mut self, n: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt

fn fold_for_stmt(&mut self, n: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt

fn fold_function(&mut self, n: Function, __ast_path: &mut AstKindPath) -> Function

fn fold_getter_prop( &mut self, n: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp

fn fold_ident(&mut self, n: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_if_stmt(&mut self, n: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt

fn fold_import(&mut self, n: Import, __ast_path: &mut AstKindPath) -> Import

fn fold_import_decl( &mut self, n: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl

fn fold_import_default_specifier( &mut self, n: ImportDefaultSpecifier, __ast_path: &mut AstKindPath) -> ImportDefaultSpecifier

fn fold_import_named_specifier( &mut self, n: ImportNamedSpecifier, __ast_path: &mut AstKindPath) -> ImportNamedSpecifier

fn fold_import_specifier( &mut self, n: ImportSpecifier, __ast_path: &mut AstKindPath) -> ImportSpecifier

fn fold_import_specifiers( &mut self, n: Vec<ImportSpecifier>, __ast_path: &mut AstKindPath) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_import_star_as_specifier( &mut self, n: ImportStarAsSpecifier, __ast_path: &mut AstKindPath) -> ImportStarAsSpecifier

fn fold_invalid(&mut self, n: Invalid, __ast_path: &mut AstKindPath) -> Invalid

fn fold_js_word(&mut self, n: JsWord, __ast_path: &mut AstKindPath) -> JsWord

fn fold_jsx_attr(&mut self, n: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr

fn fold_jsx_attr_name( &mut self, n: JSXAttrName, __ast_path: &mut AstKindPath) -> JSXAttrName

fn fold_jsx_attr_or_spread( &mut self, n: JSXAttrOrSpread, __ast_path: &mut AstKindPath) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads( &mut self, n: Vec<JSXAttrOrSpread>, __ast_path: &mut AstKindPath) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where A: Allocator,

fn fold_jsx_attr_value( &mut self, n: JSXAttrValue, __ast_path: &mut AstKindPath) -> JSXAttrValue

fn fold_accessibility(
&mut self,
n: Accessibility,
__ast_path: &mut AstKindPath
) -> Accessibility

fn fold_array_lit(
&mut self,
n: ArrayLit,
__ast_path: &mut AstKindPath
) -> ArrayLit

fn fold_array_pat(
&mut self,
n: ArrayPat,
__ast_path: &mut AstKindPath
) -> ArrayPat

fn fold_arrow_expr(
&mut self,
n: ArrowExpr,
__ast_path: &mut AstKindPath
) -> ArrowExpr

fn fold_assign_expr(
&mut self,
n: AssignExpr,
__ast_path: &mut AstKindPath
) -> AssignExpr

fn fold_assign_op(
&mut self,
n: AssignOp,
__ast_path: &mut AstKindPath
) -> AssignOp

fn fold_assign_pat(
&mut self,
n: AssignPat,
__ast_path: &mut AstKindPath
) -> AssignPat

fn fold_assign_pat_prop(
&mut self,
n: AssignPatProp,
__ast_path: &mut AstKindPath
) -> AssignPatProp

fn fold_assign_prop(
&mut self,
n: AssignProp,
__ast_path: &mut AstKindPath
) -> AssignProp

fn fold_await_expr(
&mut self,
n: AwaitExpr,
__ast_path: &mut AstKindPath
) -> AwaitExpr

fn fold_big_int_value(
&mut self,
n: BigIntValue,
__ast_path: &mut AstKindPath
) -> BigIntValue

fn fold_binary_op(
&mut self,
n: BinaryOp,
__ast_path: &mut AstKindPath
) -> BinaryOp

fn fold_binding_ident(
&mut self,
n: BindingIdent,
__ast_path: &mut AstKindPath
) -> BindingIdent

fn fold_block_stmt(
&mut self,
n: BlockStmt,
__ast_path: &mut AstKindPath
) -> BlockStmt

fn fold_block_stmt_or_expr(
&mut self,
n: BlockStmtOrExpr,
__ast_path: &mut AstKindPath
) -> BlockStmtOrExpr

fn fold_break_stmt(
&mut self,
n: BreakStmt,
__ast_path: &mut AstKindPath
) -> BreakStmt

fn fold_call_expr(
&mut self,
n: CallExpr,
__ast_path: &mut AstKindPath
) -> CallExpr

fn fold_catch_clause(
&mut self,
n: CatchClause,
__ast_path: &mut AstKindPath
) -> CatchClause

fn fold_class_decl(
&mut self,
n: ClassDecl,
__ast_path: &mut AstKindPath
) -> ClassDecl

fn fold_class_expr(
&mut self,
n: ClassExpr,
__ast_path: &mut AstKindPath
) -> ClassExpr

fn fold_class_member(
&mut self,
n: ClassMember,
__ast_path: &mut AstKindPath
) -> ClassMember

fn fold_class_members(
&mut self,
n: Vec<ClassMember>,
__ast_path: &mut AstKindPath
) -> Vec<ClassMember>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_class_method(
&mut self,
n: ClassMethod,
__ast_path: &mut AstKindPath
) -> ClassMethod

fn fold_class_prop(
&mut self,
n: ClassProp,
__ast_path: &mut AstKindPath
) -> ClassProp

fn fold_computed_prop_name(
&mut self,
n: ComputedPropName,
__ast_path: &mut AstKindPath
) -> ComputedPropName

fn fold_cond_expr(
&mut self,
n: CondExpr,
__ast_path: &mut AstKindPath
) -> CondExpr

fn fold_constructor(
&mut self,
n: Constructor,
__ast_path: &mut AstKindPath
) -> Constructor

fn fold_continue_stmt(
&mut self,
n: ContinueStmt,
__ast_path: &mut AstKindPath
) -> ContinueStmt

fn fold_debugger_stmt(
&mut self,
n: DebuggerStmt,
__ast_path: &mut AstKindPath
) -> DebuggerStmt

fn fold_decorator(
&mut self,
n: Decorator,
__ast_path: &mut AstKindPath
) -> Decorator

fn fold_decorators(
&mut self,
n: Vec<Decorator>,
__ast_path: &mut AstKindPath
) -> Vec<Decorator>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_default_decl(
&mut self,
n: DefaultDecl,
__ast_path: &mut AstKindPath
) -> DefaultDecl

fn fold_do_while_stmt(
&mut self,
n: DoWhileStmt,
__ast_path: &mut AstKindPath
) -> DoWhileStmt

fn fold_empty_stmt(
&mut self,
n: EmptyStmt,
__ast_path: &mut AstKindPath
) -> EmptyStmt

fn fold_export_all(
&mut self,
n: ExportAll,
__ast_path: &mut AstKindPath
) -> ExportAll

fn fold_export_decl(
&mut self,
n: ExportDecl,
__ast_path: &mut AstKindPath
) -> ExportDecl

fn fold_export_default_decl(
&mut self,
n: ExportDefaultDecl,
__ast_path: &mut AstKindPath
) -> ExportDefaultDecl

fn fold_export_default_expr(
&mut self,
n: ExportDefaultExpr,
__ast_path: &mut AstKindPath
) -> ExportDefaultExpr

fn fold_export_default_specifier(
&mut self,
n: ExportDefaultSpecifier,
__ast_path: &mut AstKindPath
) -> ExportDefaultSpecifier

fn fold_export_named_specifier(
&mut self,
n: ExportNamedSpecifier,
__ast_path: &mut AstKindPath
) -> ExportNamedSpecifier

fn fold_export_namespace_specifier(
&mut self,
n: ExportNamespaceSpecifier,
__ast_path: &mut AstKindPath
) -> ExportNamespaceSpecifier

fn fold_export_specifier(
&mut self,
n: ExportSpecifier,
__ast_path: &mut AstKindPath
) -> ExportSpecifier

fn fold_export_specifiers(
&mut self,
n: Vec<ExportSpecifier>,
__ast_path: &mut AstKindPath
) -> Vec<ExportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_expr_or_spread(
&mut self,
n: ExprOrSpread,
__ast_path: &mut AstKindPath
) -> ExprOrSpread

fn fold_expr_or_spreads(
&mut self,
n: Vec<ExprOrSpread>,
__ast_path: &mut AstKindPath
) -> Vec<ExprOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_expr_stmt(
&mut self,
n: ExprStmt,
__ast_path: &mut AstKindPath
) -> ExprStmt

fn fold_exprs(
&mut self,
n: Vec<Box<Expr>>,
__ast_path: &mut AstKindPath
) -> Vec<Box<Expr>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_for_in_stmt(
&mut self,
n: ForInStmt,
__ast_path: &mut AstKindPath
) -> ForInStmt

fn fold_for_of_stmt(
&mut self,
n: ForOfStmt,
__ast_path: &mut AstKindPath
) -> ForOfStmt

fn fold_getter_prop(
&mut self,
n: GetterProp,
__ast_path: &mut AstKindPath
) -> GetterProp

fn fold_import_decl(
&mut self,
n: ImportDecl,
__ast_path: &mut AstKindPath
) -> ImportDecl

fn fold_import_default_specifier(
&mut self,
n: ImportDefaultSpecifier,
__ast_path: &mut AstKindPath
) -> ImportDefaultSpecifier

fn fold_import_named_specifier(
&mut self,
n: ImportNamedSpecifier,
__ast_path: &mut AstKindPath
) -> ImportNamedSpecifier

fn fold_import_specifier(
&mut self,
n: ImportSpecifier,
__ast_path: &mut AstKindPath
) -> ImportSpecifier

fn fold_import_specifiers(
&mut self,
n: Vec<ImportSpecifier>,
__ast_path: &mut AstKindPath
) -> Vec<ImportSpecifier>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_import_star_as_specifier(
&mut self,
n: ImportStarAsSpecifier,
__ast_path: &mut AstKindPath
) -> ImportStarAsSpecifier

fn fold_jsx_attr_name(
&mut self,
n: JSXAttrName,
__ast_path: &mut AstKindPath
) -> JSXAttrName

fn fold_jsx_attr_or_spread(
&mut self,
n: JSXAttrOrSpread,
__ast_path: &mut AstKindPath
) -> JSXAttrOrSpread

fn fold_jsx_attr_or_spreads(
&mut self,
n: Vec<JSXAttrOrSpread>,
__ast_path: &mut AstKindPath
) -> Vec<JSXAttrOrSpread>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_jsx_attr_value(
&mut self,
n: JSXAttrValue,
__ast_path: &mut AstKindPath
) -> JSXAttrValue

fn fold_jsx_closing_element(
&mut self,
n: JSXClosingElement,
__ast_path: &mut AstKindPath
) -> JSXClosingElement

fn fold_jsx_closing_fragment(
&mut self,
n: JSXClosingFragment,
__ast_path: &mut AstKindPath
) -> JSXClosingFragment

fn fold_jsx_element(
&mut self,
n: JSXElement,
__ast_path: &mut AstKindPath
) -> JSXElement

fn fold_jsx_element_child(
&mut self,
n: JSXElementChild,
__ast_path: &mut AstKindPath
) -> JSXElementChild

fn fold_jsx_element_children(
&mut self,
n: Vec<JSXElementChild>,
__ast_path: &mut AstKindPath
) -> Vec<JSXElementChild>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A>where A: Allocator,`

fn fold_jsx_element_name(
&mut self,
n: JSXElementName,
__ast_path: &mut AstKindPath
) -> JSXElementName

fn fold_jsx_empty_expr(
&mut self,
n: JSXEmptyExpr,
__ast_path: &mut AstKindPath
) -> JSXEmptyExpr

fn fold_jsx_expr_container(
&mut self,
n: JSXExprContainer,
__ast_path: &mut AstKindPath
) -> JSXExprContainer

fn fold_jsx_fragment(
&mut self,
n: JSXFragment,
__ast_path: &mut AstKindPath
) -> JSXFragment

fn fold_jsx_member_expr(
&mut self,
n: JSXMemberExpr,
__ast_path: &mut AstKindPath
) -> JSXMemberExpr

fn fold_jsx_namespaced_name(
&mut self,
n: JSXNamespacedName,
__ast_path: &mut AstKindPath
) -> JSXNamespacedName

fn fold_jsx_object(
&mut self,
n: JSXObject,
__ast_path: &mut AstKindPath
) -> JSXObject

fn fold_jsx_opening_element(
&mut self,
n: JSXOpeningElement,
__ast_path: &mut AstKindPath
) -> JSXOpeningElement

fn fold_jsx_opening_fragment(
&mut self,
n: JSXOpeningFragment,
__ast_path: &mut AstKindPath
) -> JSXOpeningFragment

fn fold_jsx_spread_child(
&mut self,
n: JSXSpreadChild,
__ast_path: &mut AstKindPath
) -> JSXSpreadChild

fn fold_key_value_pat_prop(
&mut self,
n: KeyValuePatProp,
__ast_path: &mut AstKindPath
) -> KeyValuePatProp

fn fold_key_value_prop(
&mut self,
n: KeyValueProp,
__ast_path: &mut AstKindPath
) -> KeyValueProp

fn fold_labeled_stmt(
&mut self,
n: LabeledStmt,
__ast_path: &mut AstKindPath
) -> LabeledStmt

fn fold_member_expr(
&mut self,
n: MemberExpr,
__ast_path: &mut AstKindPath
) -> MemberExpr

fn fold_member_prop(
&mut self,
n: MemberProp,
__ast_path: &mut AstKindPath
) -> MemberProp