Trait swc_ecma_visit::FoldWithPath

pub trait FoldWithPath<V: ?Sized + FoldAstPath> {
    // Required methods
    fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self;
    fn fold_children_with_path(
        self,
        v: &mut V,
        ast_path: &mut AstKindPath
    ) -> Self;
}

Available on crate feature path only.

A utility trait implemented for ast nodes, and allow to visit them with a visitor.

Required Methods

fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Calls a visitor method (v.fold_xxx) with self and the ast path.

fn fold_children_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Visit children nodes with v and ast path appended [AstKind] of self. The ast path will be resotred when this method returns.

This is the default implementaton of a handler method in FoldAstPath.

Implementations on Foreign Types

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JsWord

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsExprWithTypeArgs

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsEnumMember>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsExternalModuleRef

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for WithStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Script

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for OptChainExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsTupleElement>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AssignPatProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PropOrSpread

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NamedExport

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsIndexedAccessType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ThisExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsNamespaceDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExprOrSpread

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Decl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsSetterSignature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AssignPat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsIntersectionType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyValuePatProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<Expr>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsEntityName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ModuleExportName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CatchClause

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UpdateOp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsUnionOrIntersectionType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeParamDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeAnn

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXClosingElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportDefaultSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsInterfaceDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TruePlusMinus

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportNamedSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for IfStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXElementChild

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsModuleName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Str

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsEnumDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DoWhileStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXElementName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Stmt>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXOpeningElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ArrayPat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<TsNamespaceBody>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContinueStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsSatisfiesExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<ModuleExportName>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsQualifiedName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsNonNullExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UnaryOp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ExportSpecifier>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsTypeParam>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BlockStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ParenExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PrivateProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BlockStmtOrExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AutoAccessor

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BigIntValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Lit

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DebuggerStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsImportEqualsDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExprStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsIndexSignature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Module

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MemberExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for GetterProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AssignOp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<Str>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsThisType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Prop

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTupleElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SuperProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ModuleItem

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TaggedTpl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsKeywordType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PrivateName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Param>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXAttr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportNamespaceSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsFnOrConstructorType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Accessibility>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Number

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsInstantiation

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<TsEntityName>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportAll

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AssignExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<JSXAttrValue>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsMethodSignature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsImportType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TryStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeOperatorOp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for VarDeclKind

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<TruePlusMinus>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ModuleDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Bool

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportDefaultSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Class

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PrivateMethod

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SuperPropExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypePredicate

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Box<Expr>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsUnionType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ObjectPatProp>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BreakStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BinaryOp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for VarDeclOrExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTupleType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ParamOrTsParamProp>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassMethod

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsRestType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ExprOrSpread>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Callee

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ObjectLit

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXMemberExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TplElement>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeQueryExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Tpl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsMappedType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Constructor

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for StaticBlock

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeParamInstantiation

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Pat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXAttrValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<JSXClosingElement>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportDefaultExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<VarDeclOrExpr>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SeqExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NewExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsInferType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Stmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Expr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsModuleBlock

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXOpeningFragment

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Pat>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<JSXElementChild>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsLitType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V, T> FoldWithPath<V> for Box<T>where V: ?Sized + FoldAstPath, T: 'static + FoldWithPath<V>,

fn fold_children_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Visit children nodes of self with v

fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UpdateExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeQuery

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsExprWithTypeArgs>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsNamespaceExportDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PropName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForInStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsFnParam>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Regex

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXExprContainer

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SetterProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Invalid

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Box<TsType>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Accessibility

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsOptionalType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BindingIdent

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SpreadElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ObjectPat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Option<ExprOrSpread>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsConditionalType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MemberProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for YieldExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for VarDeclarator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for LabeledStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXAttrOrSpread

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SwitchStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for EmptyStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<TsTypeParamInstantiation>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeRef

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXObject

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<ExprOrSpread>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForOfStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Param

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Ident>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BinExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for OptCall

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyValueProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<BlockStmt>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<VarDeclarator>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<ModuleItem>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsFnParam

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Pat>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Atom>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeAliasDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeOperator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXNamespacedName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<PropOrSpread>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ParamOrTsParamProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<TsTypeParamDecl>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeAssertion

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Atom

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXAttrName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsConstructSignatureDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SwitchCase

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<TsTypeElement>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Ident

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<Stmt>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXClosingFragment

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsFnType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXText

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Super

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<TsTypeAnn>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Key

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsParamProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsParamPropParam

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeLit

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UnaryExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for VarDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsConstructorType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for WhileStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<ObjectLit>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsConstAssertion

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsEnumMember

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsArrayType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ReturnStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Function

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ModuleItem>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTypeParam

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CondExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AssignProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsExportAssignment

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsParenthesizedType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportDefaultDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXEmptyExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for VarDeclOrPat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Span

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<CatchClause>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<JSXAttrOrSpread>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FnExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ArrayLit

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ObjectPatProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TplElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ReservedUnused

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<TsType>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsCallSignatureDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AwaitExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Null

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsGetterSignature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PatOrExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Option<Pat>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Span>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ClassMember>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ArrowExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsTplLitType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsPropertySignature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CallExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ImportSpecifier>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MetaPropExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsNamespaceBody

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsThisTypeOrIdent

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsAsExpr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ThrowStmt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DefaultDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXElement

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for BigInt

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsInterfaceBody

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsKeywordTypeKind

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for RestPat

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassMember

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsModuleDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MethodKind

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Decorator>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExportNamedSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FnDecl

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MethodProp

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Import

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsModuleRef

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<ExprOrSpread>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportStarAsSpecifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Decorator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXSpreadChild

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for OptChainBase

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MetaPropKind

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Program

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ComputedPropName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsEnumMemberId

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JSXFragment

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<SwitchCase>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TsLit

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

Implementors