Struct swc_ecma_transforms::resolver::Resolver

pub struct Resolver<'a> { /* fields omitted */ }

Phases

Hoisting phase

Resolving phase

Trait Implementations

impl<'_> Fold<Accessibility> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ArrowExpr> for Resolver<'a>

fn fold(&mut self, e: ArrowExpr) -> ArrowExpr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<BlockStmt> for Resolver<'a>

fn fold(&mut self, block: BlockStmt) -> BlockStmt

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<BlockStmtOrExpr> for Resolver<'_>

Handle body of the arrow functions

fn fold(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<BreakStmt> for Resolver<'a>

fn fold(&mut self, s: BreakStmt) -> BreakStmt

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<CatchClause> for Resolver<'_>

fn fold(&mut self, c: CatchClause) -> CatchClause

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<Class> for Resolver<'_>

fn fold(&mut self, c: Class) -> Class

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ClassDecl> for Resolver<'a>

fn fold(&mut self, n: ClassDecl) -> ClassDecl

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ClassExpr> for Resolver<'a>

fn fold(&mut self, n: ClassExpr) -> ClassExpr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<ClassMethod> for Resolver<'_>

fn fold(&mut self, m: ClassMethod) -> ClassMethod

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<Constructor> for Resolver<'_>

fn fold(&mut self, c: Constructor) -> Constructor

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ContinueStmt> for Resolver<'a>

fn fold(&mut self, s: ContinueStmt) -> ContinueStmt

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ExportSpecifier> for Resolver<'a>

fn fold(&mut self, s: ExportSpecifier) -> ExportSpecifier

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<Expr> for Resolver<'a>

fn fold(&mut self, expr: Expr) -> Expr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<FnDecl> for Resolver<'a>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<FnExpr> for Resolver<'a>

fn fold(&mut self, e: FnExpr) -> FnExpr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<Function> for Resolver<'a>

fn fold(&mut self, f: Function) -> Function

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<Ident> for Resolver<'a>

fn fold(&mut self, i: Ident) -> Ident

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<ImportSpecifier> for Resolver<'a>

fn fold(&mut self, s: ImportSpecifier) -> ImportSpecifier

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<KeyValuePatProp> for Resolver<'a>

fn fold(&mut self, n: KeyValuePatProp) -> KeyValuePatProp

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<LabeledStmt> for Resolver<'a>

fn fold(&mut self, s: LabeledStmt) -> LabeledStmt

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<MethodProp> for Resolver<'_>

fn fold(&mut self, m: MethodProp) -> MethodProp

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<ObjectLit> for Resolver<'_>

fn fold(&mut self, o: ObjectLit) -> ObjectLit

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<Pat> for Resolver<'_>

fn fold(&mut self, p: Pat) -> Pat

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<PropName> for Resolver<'_>

fn fold(&mut self, n: PropName) -> PropName

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<SetterProp> for Resolver<'a>

fn fold(&mut self, f: SetterProp) -> SetterProp

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TruePlusMinus> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsArrayType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsCallSignatureDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsConditionalType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsConstructSignatureDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsConstructorType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsEntityName> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsEnumDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsEnumMember> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsEnumMemberId> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsExternalModuleRef> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsFnOrConstructorType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsFnParam> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsFnType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsImportEqualsDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsImportType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsIndexSignature> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsIndexedAccessType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsInferType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsInterfaceBody> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsInterfaceDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsIntersectionType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsKeywordType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsKeywordTypeKind> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsMappedType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsMethodSignature> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsModuleBlock> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsModuleDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsModuleName> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsModuleRef> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsNamespaceBody> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsNamespaceDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsNamespaceExportDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsOptionalType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsParamProp> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsParamPropParam> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsParenthesizedType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsPropertySignature> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsQualifiedName> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsRestType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsSignatureDecl> for Resolver<'_>

fn fold(&mut self, node: TsSignatureDecl) -> TsSignatureDecl

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsThisType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsThisTypeOrIdent> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTupleType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeAliasDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeAnn> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeAssertion> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeCastExpr> for Resolver<'_>

fn fold(&mut self, node: TsTypeCastExpr) -> TsTypeCastExpr

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeElement> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeLit> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeOperator> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeOperatorOp> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeParam> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeParamDecl> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeParamInstantiation> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypePredicate> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeQuery> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeQueryExpr> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsTypeRef> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsUnionOrIntersectionType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<TsUnionType> for Resolver<'_>

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

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<VarDecl> for Resolver<'_>

fn fold(&mut self, decl: VarDecl) -> VarDecl

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'a> Fold<VarDeclarator> for Resolver<'a>

fn fold(&mut self, decl: VarDeclarator) -> VarDeclarator

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<Vec<ModuleItem>> for Resolver<'_>

fn fold(&mut self, stmts: Vec<ModuleItem>) -> Vec<ModuleItem>

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.

impl<'_> Fold<Vec<Stmt>> for Resolver<'_>

fn fold(&mut self, stmts: Vec<Stmt>) -> Vec<Stmt>

By default, this folds fields of node and reconstruct node with folded fields

fn then<F>(self, folder: F) -> AndThen<Self, F> where
    F: Fold<T>, 

Creates a folder which applies folder after self.