pub trait Fold {
Show 470 methods
fn fold_access(&mut self, n: Access) -> Access { ... }
fn fold_any_type_annotation(
&mut self,
n: AnyTypeAnnotation
) -> AnyTypeAnnotation { ... }
fn fold_arg(&mut self, n: Arg) -> Arg { ... }
fn fold_args(&mut self, n: Vec<Arg>) -> Vec<Arg> { ... }
fn fold_argument_placeholder(
&mut self,
n: ArgumentPlaceholder
) -> ArgumentPlaceholder { ... }
fn fold_array_expr_el(&mut self, n: ArrayExprEl) -> ArrayExprEl { ... }
fn fold_array_expression(&mut self, n: ArrayExpression) -> ArrayExpression { ... }
fn fold_array_pattern(&mut self, n: ArrayPattern) -> ArrayPattern { ... }
fn fold_array_type_annotation(
&mut self,
n: ArrayTypeAnnotation
) -> ArrayTypeAnnotation { ... }
fn fold_arrow_func_expr_body(
&mut self,
n: ArrowFuncExprBody
) -> ArrowFuncExprBody { ... }
fn fold_arrow_function_expression(
&mut self,
n: ArrowFunctionExpression
) -> ArrowFunctionExpression { ... }
fn fold_assignment_expression(
&mut self,
n: AssignmentExpression
) -> AssignmentExpression { ... }
fn fold_assignment_pattern(
&mut self,
n: AssignmentPattern
) -> AssignmentPattern { ... }
fn fold_assignment_pattern_left(
&mut self,
n: AssignmentPatternLeft
) -> AssignmentPatternLeft { ... }
fn fold_await_expression(&mut self, n: AwaitExpression) -> AwaitExpression { ... }
fn fold_base_comment(&mut self, n: BaseComment) -> BaseComment { ... }
fn fold_base_node(&mut self, n: BaseNode) -> BaseNode { ... }
fn fold_big_int_literal(&mut self, n: BigIntLiteral) -> BigIntLiteral { ... }
fn fold_binary(&mut self, n: Binary) -> Binary { ... }
fn fold_binary_expr_left(&mut self, n: BinaryExprLeft) -> BinaryExprLeft { ... }
fn fold_binary_expr_op(&mut self, n: BinaryExprOp) -> BinaryExprOp { ... }
fn fold_binary_expression(
&mut self,
n: BinaryExpression
) -> BinaryExpression { ... }
fn fold_bind_expression(&mut self, n: BindExpression) -> BindExpression { ... }
fn fold_block(&mut self, n: Block) -> Block { ... }
fn fold_block_parent(&mut self, n: BlockParent) -> BlockParent { ... }
fn fold_block_statement(&mut self, n: BlockStatement) -> BlockStatement { ... }
fn fold_bool(&mut self, n: bool) -> bool { ... }
fn fold_boolean_literal(&mut self, n: BooleanLiteral) -> BooleanLiteral { ... }
fn fold_boolean_literal_type_annotation(
&mut self,
n: BooleanLiteralTypeAnnotation
) -> BooleanLiteralTypeAnnotation { ... }
fn fold_boolean_type_annotation(
&mut self,
n: BooleanTypeAnnotation
) -> BooleanTypeAnnotation { ... }
fn fold_break_statement(&mut self, n: BreakStatement) -> BreakStatement { ... }
fn fold_call_expression(&mut self, n: CallExpression) -> CallExpression { ... }
fn fold_callee(&mut self, n: Callee) -> Callee { ... }
fn fold_catch_clause(&mut self, n: CatchClause) -> CatchClause { ... }
fn fold_catch_clause_param(
&mut self,
n: CatchClauseParam
) -> CatchClauseParam { ... }
fn fold_class(&mut self, n: Class) -> Class { ... }
fn fold_class_body(&mut self, n: ClassBody) -> ClassBody { ... }
fn fold_class_body_el(&mut self, n: ClassBodyEl) -> ClassBodyEl { ... }
fn fold_class_body_els(&mut self, n: Vec<ClassBodyEl>) -> Vec<ClassBodyEl> { ... }
fn fold_class_declaration(
&mut self,
n: ClassDeclaration
) -> ClassDeclaration { ... }
fn fold_class_expression(&mut self, n: ClassExpression) -> ClassExpression { ... }
fn fold_class_impl(&mut self, n: ClassImpl) -> ClassImpl { ... }
fn fold_class_implements(&mut self, n: ClassImplements) -> ClassImplements { ... }
fn fold_class_implements_vec(
&mut self,
n: Vec<ClassImplements>
) -> Vec<ClassImplements> { ... }
fn fold_class_impls(&mut self, n: Vec<ClassImpl>) -> Vec<ClassImpl> { ... }
fn fold_class_method(&mut self, n: ClassMethod) -> ClassMethod { ... }
fn fold_class_method_kind(&mut self, n: ClassMethodKind) -> ClassMethodKind { ... }
fn fold_class_private_method(
&mut self,
n: ClassPrivateMethod
) -> ClassPrivateMethod { ... }
fn fold_class_private_property(
&mut self,
n: ClassPrivateProperty
) -> ClassPrivateProperty { ... }
fn fold_class_property(&mut self, n: ClassProperty) -> ClassProperty { ... }
fn fold_comment(&mut self, n: Comment) -> Comment { ... }
fn fold_comment_type_shorthand(
&mut self,
n: CommentTypeShorthand
) -> CommentTypeShorthand { ... }
fn fold_comments(&mut self, n: Vec<Comment>) -> Vec<Comment> { ... }
fn fold_completion_statement(
&mut self,
n: CompletionStatement
) -> CompletionStatement { ... }
fn fold_conditional(&mut self, n: Conditional) -> Conditional { ... }
fn fold_conditional_expression(
&mut self,
n: ConditionalExpression
) -> ConditionalExpression { ... }
fn fold_continue_statement(
&mut self,
n: ContinueStatement
) -> ContinueStatement { ... }
fn fold_debugger_statement(
&mut self,
n: DebuggerStatement
) -> DebuggerStatement { ... }
fn fold_decimal_literal(&mut self, n: DecimalLiteral) -> DecimalLiteral { ... }
fn fold_declaration(&mut self, n: Declaration) -> Declaration { ... }
fn fold_declare_class(&mut self, n: DeclareClass) -> DeclareClass { ... }
fn fold_declare_export_all_declaration(
&mut self,
n: DeclareExportAllDeclaration
) -> DeclareExportAllDeclaration { ... }
fn fold_declare_export_decl_specifier(
&mut self,
n: DeclareExportDeclSpecifier
) -> DeclareExportDeclSpecifier { ... }
fn fold_declare_export_decl_specifiers(
&mut self,
n: Vec<DeclareExportDeclSpecifier>
) -> Vec<DeclareExportDeclSpecifier> { ... }
fn fold_declare_export_declaration(
&mut self,
n: DeclareExportDeclaration
) -> DeclareExportDeclaration { ... }
fn fold_declare_function(&mut self, n: DeclareFunction) -> DeclareFunction { ... }
fn fold_declare_interface(
&mut self,
n: DeclareInterface
) -> DeclareInterface { ... }
fn fold_declare_module(&mut self, n: DeclareModule) -> DeclareModule { ... }
fn fold_declare_module_exports(
&mut self,
n: DeclareModuleExports
) -> DeclareModuleExports { ... }
fn fold_declare_opaque_type(
&mut self,
n: DeclareOpaqueType
) -> DeclareOpaqueType { ... }
fn fold_declare_type_alias(
&mut self,
n: DeclareTypeAlias
) -> DeclareTypeAlias { ... }
fn fold_declare_variable(&mut self, n: DeclareVariable) -> DeclareVariable { ... }
fn fold_declared_predicate(
&mut self,
n: DeclaredPredicate
) -> DeclaredPredicate { ... }
fn fold_decorator(&mut self, n: Decorator) -> Decorator { ... }
fn fold_decorators(&mut self, n: Vec<Decorator>) -> Vec<Decorator> { ... }
fn fold_directive(&mut self, n: Directive) -> Directive { ... }
fn fold_directive_literal(
&mut self,
n: DirectiveLiteral
) -> DirectiveLiteral { ... }
fn fold_directives(&mut self, n: Vec<Directive>) -> Vec<Directive> { ... }
fn fold_do_expression(&mut self, n: DoExpression) -> DoExpression { ... }
fn fold_do_while_statement(
&mut self,
n: DoWhileStatement
) -> DoWhileStatement { ... }
fn fold_empty_statement(&mut self, n: EmptyStatement) -> EmptyStatement { ... }
fn fold_empty_type_annotation(
&mut self,
n: EmptyTypeAnnotation
) -> EmptyTypeAnnotation { ... }
fn fold_enum_body(&mut self, n: EnumBody) -> EnumBody { ... }
fn fold_enum_boolean_body(&mut self, n: EnumBooleanBody) -> EnumBooleanBody { ... }
fn fold_enum_boolean_member(
&mut self,
n: EnumBooleanMember
) -> EnumBooleanMember { ... }
fn fold_enum_boolean_members(
&mut self,
n: Vec<EnumBooleanMember>
) -> Vec<EnumBooleanMember> { ... }
fn fold_enum_declaration(&mut self, n: EnumDeclaration) -> EnumDeclaration { ... }
fn fold_enum_defaulted_member(
&mut self,
n: EnumDefaultedMember
) -> EnumDefaultedMember { ... }
fn fold_enum_defaulted_members(
&mut self,
n: Vec<EnumDefaultedMember>
) -> Vec<EnumDefaultedMember> { ... }
fn fold_enum_member(&mut self, n: EnumMember) -> EnumMember { ... }
fn fold_enum_number_body(&mut self, n: EnumNumberBody) -> EnumNumberBody { ... }
fn fold_enum_number_member(
&mut self,
n: EnumNumberMember
) -> EnumNumberMember { ... }
fn fold_enum_number_members(
&mut self,
n: Vec<EnumNumberMember>
) -> Vec<EnumNumberMember> { ... }
fn fold_enum_string_body(&mut self, n: EnumStringBody) -> EnumStringBody { ... }
fn fold_enum_string_body_member(
&mut self,
n: EnumStringBodyMember
) -> EnumStringBodyMember { ... }
fn fold_enum_string_body_members(
&mut self,
n: Vec<EnumStringBodyMember>
) -> Vec<EnumStringBodyMember> { ... }
fn fold_enum_string_member(
&mut self,
n: EnumStringMember
) -> EnumStringMember { ... }
fn fold_enum_symbol_body(&mut self, n: EnumSymbolBody) -> EnumSymbolBody { ... }
fn fold_exists_type_annotation(
&mut self,
n: ExistsTypeAnnotation
) -> ExistsTypeAnnotation { ... }
fn fold_export_all_declaration(
&mut self,
n: ExportAllDeclaration
) -> ExportAllDeclaration { ... }
fn fold_export_declaration(
&mut self,
n: ExportDeclaration
) -> ExportDeclaration { ... }
fn fold_export_default_decl_type(
&mut self,
n: ExportDefaultDeclType
) -> ExportDefaultDeclType { ... }
fn fold_export_default_declaration(
&mut self,
n: ExportDefaultDeclaration
) -> ExportDefaultDeclaration { ... }
fn fold_export_default_specifier(
&mut self,
n: ExportDefaultSpecifier
) -> ExportDefaultSpecifier { ... }
fn fold_export_kind(&mut self, n: ExportKind) -> ExportKind { ... }
fn fold_export_named_declaration(
&mut self,
n: ExportNamedDeclaration
) -> ExportNamedDeclaration { ... }
fn fold_export_namespace_specifier(
&mut self,
n: ExportNamespaceSpecifier
) -> ExportNamespaceSpecifier { ... }
fn fold_export_specifier(&mut self, n: ExportSpecifier) -> ExportSpecifier { ... }
fn fold_export_specifier_type(
&mut self,
n: ExportSpecifierType
) -> ExportSpecifierType { ... }
fn fold_export_specifier_types(
&mut self,
n: Vec<ExportSpecifierType>
) -> Vec<ExportSpecifierType> { ... }
fn fold_expression(&mut self, n: Expression) -> Expression { ... }
fn fold_expression_statement(
&mut self,
n: ExpressionStatement
) -> ExpressionStatement { ... }
fn fold_expression_wrapper(
&mut self,
n: ExpressionWrapper
) -> ExpressionWrapper { ... }
fn fold_expressions(
&mut self,
n: Vec<Box<Expression>>
) -> Vec<Box<Expression>> { ... }
fn fold_file(&mut self, n: File) -> File { ... }
fn fold_flow(&mut self, n: Flow) -> Flow { ... }
fn fold_flow_base_annotation(
&mut self,
n: FlowBaseAnnotation
) -> FlowBaseAnnotation { ... }
fn fold_flow_declaration(&mut self, n: FlowDeclaration) -> FlowDeclaration { ... }
fn fold_flow_predicate(&mut self, n: FlowPredicate) -> FlowPredicate { ... }
fn fold_flow_type(&mut self, n: FlowType) -> FlowType { ... }
fn fold_flow_types(&mut self, n: Vec<FlowType>) -> Vec<FlowType> { ... }
fn fold_for(&mut self, n: For) -> For { ... }
fn fold_for_in_statement(&mut self, n: ForInStatement) -> ForInStatement { ... }
fn fold_for_of_statement(&mut self, n: ForOfStatement) -> ForOfStatement { ... }
fn fold_for_statement(&mut self, n: ForStatement) -> ForStatement { ... }
fn fold_for_stmt_init(&mut self, n: ForStmtInit) -> ForStmtInit { ... }
fn fold_for_stmt_left(&mut self, n: ForStmtLeft) -> ForStmtLeft { ... }
fn fold_for_x_statement(&mut self, n: ForXStatement) -> ForXStatement { ... }
fn fold_function(&mut self, n: Function) -> Function { ... }
fn fold_function_declaration(
&mut self,
n: FunctionDeclaration
) -> FunctionDeclaration { ... }
fn fold_function_expression(
&mut self,
n: FunctionExpression
) -> FunctionExpression { ... }
fn fold_function_parent(&mut self, n: FunctionParent) -> FunctionParent { ... }
fn fold_function_type_annotation(
&mut self,
n: FunctionTypeAnnotation
) -> FunctionTypeAnnotation { ... }
fn fold_function_type_param(
&mut self,
n: FunctionTypeParam
) -> FunctionTypeParam { ... }
fn fold_function_type_params(
&mut self,
n: Vec<FunctionTypeParam>
) -> Vec<FunctionTypeParam> { ... }
fn fold_generic_type_annotation(
&mut self,
n: GenericTypeAnnotation
) -> GenericTypeAnnotation { ... }
fn fold_id_or_qualified_id(&mut self, n: IdOrQualifiedId) -> IdOrQualifiedId { ... }
fn fold_id_or_rest(&mut self, n: IdOrRest) -> IdOrRest { ... }
fn fold_id_or_rests(&mut self, n: Vec<IdOrRest>) -> Vec<IdOrRest> { ... }
fn fold_id_or_string(&mut self, n: IdOrString) -> IdOrString { ... }
fn fold_identifier(&mut self, n: Identifier) -> Identifier { ... }
fn fold_identifiers(&mut self, n: Vec<Identifier>) -> Vec<Identifier> { ... }
fn fold_if_statement(&mut self, n: IfStatement) -> IfStatement { ... }
fn fold_immutable(&mut self, n: Immutable) -> Immutable { ... }
fn fold_import(&mut self, n: Import) -> Import { ... }
fn fold_import_attribute(&mut self, n: ImportAttribute) -> ImportAttribute { ... }
fn fold_import_attributes(
&mut self,
n: Vec<ImportAttribute>
) -> Vec<ImportAttribute> { ... }
fn fold_import_declaration(
&mut self,
n: ImportDeclaration
) -> ImportDeclaration { ... }
fn fold_import_default_specifier(
&mut self,
n: ImportDefaultSpecifier
) -> ImportDefaultSpecifier { ... }
fn fold_import_kind(&mut self, n: ImportKind) -> ImportKind { ... }
fn fold_import_namespace_specifier(
&mut self,
n: ImportNamespaceSpecifier
) -> ImportNamespaceSpecifier { ... }
fn fold_import_specifier(&mut self, n: ImportSpecifier) -> ImportSpecifier { ... }
fn fold_import_specifier_type(
&mut self,
n: ImportSpecifierType
) -> ImportSpecifierType { ... }
fn fold_import_specifier_types(
&mut self,
n: Vec<ImportSpecifierType>
) -> Vec<ImportSpecifierType> { ... }
fn fold_inferred_predicate(
&mut self,
n: InferredPredicate
) -> InferredPredicate { ... }
fn fold_interface_declaration(
&mut self,
n: InterfaceDeclaration
) -> InterfaceDeclaration { ... }
fn fold_interface_extends(
&mut self,
n: InterfaceExtends
) -> InterfaceExtends { ... }
fn fold_interface_extends_vec(
&mut self,
n: Vec<InterfaceExtends>
) -> Vec<InterfaceExtends> { ... }
fn fold_interface_type_annotation(
&mut self,
n: InterfaceTypeAnnotation
) -> InterfaceTypeAnnotation { ... }
fn fold_interpreter_directive(
&mut self,
n: InterpreterDirective
) -> InterpreterDirective { ... }
fn fold_intersection_type_annotation(
&mut self,
n: IntersectionTypeAnnotation
) -> IntersectionTypeAnnotation { ... }
fn fold_js_word(&mut self, n: JsWord) -> JsWord { ... }
fn fold_jsx(&mut self, n: JSX) -> JSX { ... }
fn fold_jsx_attr_name(&mut self, n: JSXAttrName) -> JSXAttrName { ... }
fn fold_jsx_attr_val(&mut self, n: JSXAttrVal) -> JSXAttrVal { ... }
fn fold_jsx_attribute(&mut self, n: JSXAttribute) -> JSXAttribute { ... }
fn fold_jsx_closing_element(
&mut self,
n: JSXClosingElement
) -> JSXClosingElement { ... }
fn fold_jsx_closing_fragment(
&mut self,
n: JSXClosingFragment
) -> JSXClosingFragment { ... }
fn fold_jsx_element(&mut self, n: JSXElement) -> JSXElement { ... }
fn fold_jsx_element_child(&mut self, n: JSXElementChild) -> JSXElementChild { ... }
fn fold_jsx_element_children(
&mut self,
n: Vec<JSXElementChild>
) -> Vec<JSXElementChild> { ... }
fn fold_jsx_element_name(&mut self, n: JSXElementName) -> JSXElementName { ... }
fn fold_jsx_empty_expression(
&mut self,
n: JSXEmptyExpression
) -> JSXEmptyExpression { ... }
fn fold_jsx_expr_container_expr(
&mut self,
n: JSXExprContainerExpr
) -> JSXExprContainerExpr { ... }
fn fold_jsx_expression_container(
&mut self,
n: JSXExpressionContainer
) -> JSXExpressionContainer { ... }
fn fold_jsx_fragment(&mut self, n: JSXFragment) -> JSXFragment { ... }
fn fold_jsx_identifier(&mut self, n: JSXIdentifier) -> JSXIdentifier { ... }
fn fold_jsx_member_expr_object(
&mut self,
n: JSXMemberExprObject
) -> JSXMemberExprObject { ... }
fn fold_jsx_member_expression(
&mut self,
n: JSXMemberExpression
) -> JSXMemberExpression { ... }
fn fold_jsx_namespaced_name(
&mut self,
n: JSXNamespacedName
) -> JSXNamespacedName { ... }
fn fold_jsx_opening_el_attr(
&mut self,
n: JSXOpeningElAttr
) -> JSXOpeningElAttr { ... }
fn fold_jsx_opening_el_attrs(
&mut self,
n: Vec<JSXOpeningElAttr>
) -> Vec<JSXOpeningElAttr> { ... }
fn fold_jsx_opening_element(
&mut self,
n: JSXOpeningElement
) -> JSXOpeningElement { ... }
fn fold_jsx_opening_fragment(
&mut self,
n: JSXOpeningFragment
) -> JSXOpeningFragment { ... }
fn fold_jsx_spread_attribute(
&mut self,
n: JSXSpreadAttribute
) -> JSXSpreadAttribute { ... }
fn fold_jsx_spread_child(&mut self, n: JSXSpreadChild) -> JSXSpreadChild { ... }
fn fold_jsx_text(&mut self, n: JSXText) -> JSXText { ... }
fn fold_l_val(&mut self, n: LVal) -> LVal { ... }
fn fold_labeled_statement(
&mut self,
n: LabeledStatement
) -> LabeledStatement { ... }
fn fold_line_col(&mut self, n: LineCol) -> LineCol { ... }
fn fold_literal(&mut self, n: Literal) -> Literal { ... }
fn fold_loc(&mut self, n: Loc) -> Loc { ... }
fn fold_logical_expr_op(&mut self, n: LogicalExprOp) -> LogicalExprOp { ... }
fn fold_logical_expression(
&mut self,
n: LogicalExpression
) -> LogicalExpression { ... }
fn fold_loop(&mut self, n: Loop) -> Loop { ... }
fn fold_member_expr_prop(&mut self, n: MemberExprProp) -> MemberExprProp { ... }
fn fold_member_expression(
&mut self,
n: MemberExpression
) -> MemberExpression { ... }
fn fold_meta_property(&mut self, n: MetaProperty) -> MetaProperty { ... }
fn fold_method(&mut self, n: Method) -> Method { ... }
fn fold_mixed_type_annotation(
&mut self,
n: MixedTypeAnnotation
) -> MixedTypeAnnotation { ... }
fn fold_module_declaration(
&mut self,
n: ModuleDeclaration
) -> ModuleDeclaration { ... }
fn fold_module_expression(
&mut self,
n: ModuleExpression
) -> ModuleExpression { ... }
fn fold_module_kind(&mut self, n: ModuleKind) -> ModuleKind { ... }
fn fold_module_specifier(&mut self, n: ModuleSpecifier) -> ModuleSpecifier { ... }
fn fold_new_expression(&mut self, n: NewExpression) -> NewExpression { ... }
fn fold_noop(&mut self, n: Noop) -> Noop { ... }
fn fold_null_literal(&mut self, n: NullLiteral) -> NullLiteral { ... }
fn fold_null_literal_type_annotation(
&mut self,
n: NullLiteralTypeAnnotation
) -> NullLiteralTypeAnnotation { ... }
fn fold_nullable_type_annotation(
&mut self,
n: NullableTypeAnnotation
) -> NullableTypeAnnotation { ... }
fn fold_number_literal(&mut self, n: NumberLiteral) -> NumberLiteral { ... }
fn fold_number_literal_type_annotation(
&mut self,
n: NumberLiteralTypeAnnotation
) -> NumberLiteralTypeAnnotation { ... }
fn fold_number_type_annotation(
&mut self,
n: NumberTypeAnnotation
) -> NumberTypeAnnotation { ... }
fn fold_numeric_literal(&mut self, n: NumericLiteral) -> NumericLiteral { ... }
fn fold_object_expr_prop(&mut self, n: ObjectExprProp) -> ObjectExprProp { ... }
fn fold_object_expr_props(
&mut self,
n: Vec<ObjectExprProp>
) -> Vec<ObjectExprProp> { ... }
fn fold_object_expression(
&mut self,
n: ObjectExpression
) -> ObjectExpression { ... }
fn fold_object_key(&mut self, n: ObjectKey) -> ObjectKey { ... }
fn fold_object_member(&mut self, n: ObjectMember) -> ObjectMember { ... }
fn fold_object_method(&mut self, n: ObjectMethod) -> ObjectMethod { ... }
fn fold_object_method_kind(
&mut self,
n: ObjectMethodKind
) -> ObjectMethodKind { ... }
fn fold_object_pattern(&mut self, n: ObjectPattern) -> ObjectPattern { ... }
fn fold_object_pattern_prop(
&mut self,
n: ObjectPatternProp
) -> ObjectPatternProp { ... }
fn fold_object_pattern_props(
&mut self,
n: Vec<ObjectPatternProp>
) -> Vec<ObjectPatternProp> { ... }
fn fold_object_prop_val(&mut self, n: ObjectPropVal) -> ObjectPropVal { ... }
fn fold_object_property(&mut self, n: ObjectProperty) -> ObjectProperty { ... }
fn fold_object_type_annot_prop(
&mut self,
n: ObjectTypeAnnotProp
) -> ObjectTypeAnnotProp { ... }
fn fold_object_type_annot_props(
&mut self,
n: Vec<ObjectTypeAnnotProp>
) -> Vec<ObjectTypeAnnotProp> { ... }
fn fold_object_type_annotation(
&mut self,
n: ObjectTypeAnnotation
) -> ObjectTypeAnnotation { ... }
fn fold_object_type_call_properties(
&mut self,
n: Vec<ObjectTypeCallProperty>
) -> Vec<ObjectTypeCallProperty> { ... }
fn fold_object_type_call_property(
&mut self,
n: ObjectTypeCallProperty
) -> ObjectTypeCallProperty { ... }
fn fold_object_type_indexer(
&mut self,
n: ObjectTypeIndexer
) -> ObjectTypeIndexer { ... }
fn fold_object_type_indexers(
&mut self,
n: Vec<ObjectTypeIndexer>
) -> Vec<ObjectTypeIndexer> { ... }
fn fold_object_type_internal_slot(
&mut self,
n: ObjectTypeInternalSlot
) -> ObjectTypeInternalSlot { ... }
fn fold_object_type_internal_slots(
&mut self,
n: Vec<ObjectTypeInternalSlot>
) -> Vec<ObjectTypeInternalSlot> { ... }
fn fold_object_type_prop_kind(
&mut self,
n: ObjectTypePropKind
) -> ObjectTypePropKind { ... }
fn fold_object_type_property(
&mut self,
n: ObjectTypeProperty
) -> ObjectTypeProperty { ... }
fn fold_object_type_spread_property(
&mut self,
n: ObjectTypeSpreadProperty
) -> ObjectTypeSpreadProperty { ... }
fn fold_opaque_type(&mut self, n: OpaqueType) -> OpaqueType { ... }
fn fold_opt_access(&mut self, n: Option<Access>) -> Option<Access> { ... }
fn fold_opt_array_expr_el(
&mut self,
n: Option<ArrayExprEl>
) -> Option<ArrayExprEl> { ... }
fn fold_opt_block_statement(
&mut self,
n: Option<BlockStatement>
) -> Option<BlockStatement> { ... }
fn fold_opt_bool(&mut self, n: Option<bool>) -> Option<bool> { ... }
fn fold_opt_catch_clause(
&mut self,
n: Option<CatchClause>
) -> Option<CatchClause> { ... }
fn fold_opt_catch_clause_param(
&mut self,
n: Option<CatchClauseParam>
) -> Option<CatchClauseParam> { ... }
fn fold_opt_class_implements_vec(
&mut self,
n: Option<Vec<ClassImplements>>
) -> Option<Vec<ClassImplements>> { ... }
fn fold_opt_class_impls(
&mut self,
n: Option<Vec<ClassImpl>>
) -> Option<Vec<ClassImpl>> { ... }
fn fold_opt_class_method_kind(
&mut self,
n: Option<ClassMethodKind>
) -> Option<ClassMethodKind> { ... }
fn fold_opt_comments(
&mut self,
n: Option<Vec<Comment>>
) -> Option<Vec<Comment>> { ... }
fn fold_opt_declaration(
&mut self,
n: Option<Box<Declaration>>
) -> Option<Box<Declaration>> { ... }
fn fold_opt_declare_export_decl_specifiers(
&mut self,
n: Option<Vec<DeclareExportDeclSpecifier>>
) -> Option<Vec<DeclareExportDeclSpecifier>> { ... }
fn fold_opt_declared_predicate(
&mut self,
n: Option<Box<DeclaredPredicate>>
) -> Option<Box<DeclaredPredicate>> { ... }
fn fold_opt_decorators(
&mut self,
n: Option<Vec<Decorator>>
) -> Option<Vec<Decorator>> { ... }
fn fold_opt_export_kind(
&mut self,
n: Option<ExportKind>
) -> Option<ExportKind> { ... }
fn fold_opt_expression(
&mut self,
n: Option<Box<Expression>>
) -> Option<Box<Expression>> { ... }
fn fold_opt_flow(&mut self, n: Option<Box<Flow>>) -> Option<Box<Flow>> { ... }
fn fold_opt_flow_type(&mut self, n: Option<FlowType>) -> Option<FlowType> { ... }
fn fold_opt_for_stmt_init(
&mut self,
n: Option<ForStmtInit>
) -> Option<ForStmtInit> { ... }
fn fold_opt_function_type_param(
&mut self,
n: Option<Box<FunctionTypeParam>>
) -> Option<Box<FunctionTypeParam>> { ... }
fn fold_opt_identifier(
&mut self,
n: Option<Identifier>
) -> Option<Identifier> { ... }
fn fold_opt_import_attributes(
&mut self,
n: Option<Vec<ImportAttribute>>
) -> Option<Vec<ImportAttribute>> { ... }
fn fold_opt_import_kind(
&mut self,
n: Option<ImportKind>
) -> Option<ImportKind> { ... }
fn fold_opt_interface_extends(
&mut self,
n: Option<InterfaceExtends>
) -> Option<InterfaceExtends> { ... }
fn fold_opt_interface_extends_vec(
&mut self,
n: Option<Vec<InterfaceExtends>>
) -> Option<Vec<InterfaceExtends>> { ... }
fn fold_opt_interpreter_directive(
&mut self,
n: Option<InterpreterDirective>
) -> Option<InterpreterDirective> { ... }
fn fold_opt_js_word(&mut self, n: Option<JsWord>) -> Option<JsWord> { ... }
fn fold_opt_jsx_attr_val(
&mut self,
n: Option<JSXAttrVal>
) -> Option<JSXAttrVal> { ... }
fn fold_opt_jsx_closing_element(
&mut self,
n: Option<JSXClosingElement>
) -> Option<JSXClosingElement> { ... }
fn fold_opt_loc(&mut self, n: Option<Loc>) -> Option<Loc> { ... }
fn fold_opt_module_kind(
&mut self,
n: Option<ModuleKind>
) -> Option<ModuleKind> { ... }
fn fold_opt_object_type_call_properties(
&mut self,
n: Option<Vec<ObjectTypeCallProperty>>
) -> Option<Vec<ObjectTypeCallProperty>> { ... }
fn fold_opt_object_type_indexers(
&mut self,
n: Option<Vec<ObjectTypeIndexer>>
) -> Option<Vec<ObjectTypeIndexer>> { ... }
fn fold_opt_object_type_internal_slots(
&mut self,
n: Option<Vec<ObjectTypeInternalSlot>>
) -> Option<Vec<ObjectTypeInternalSlot>> { ... }
fn fold_opt_pattern_like(
&mut self,
n: Option<PatternLike>
) -> Option<PatternLike> { ... }
fn fold_opt_statement(
&mut self,
n: Option<Box<Statement>>
) -> Option<Box<Statement>> { ... }
fn fold_opt_string_literal(
&mut self,
n: Option<StringLiteral>
) -> Option<StringLiteral> { ... }
fn fold_opt_super_type_params(
&mut self,
n: Option<SuperTypeParams>
) -> Option<SuperTypeParams> { ... }
fn fold_opt_tagged_template_expr_type_params(
&mut self,
n: Option<TaggedTemplateExprTypeParams>
) -> Option<TaggedTemplateExprTypeParams> { ... }
fn fold_opt_ts_entity_name(
&mut self,
n: Option<TSEntityName>
) -> Option<TSEntityName> { ... }
fn fold_opt_ts_expression_with_type_arguments(
&mut self,
n: Option<TSExpressionWithTypeArguments>
) -> Option<TSExpressionWithTypeArguments> { ... }
fn fold_opt_ts_func_decl_type_annot(
&mut self,
n: Option<TSFuncDeclTypeAnnot>
) -> Option<TSFuncDeclTypeAnnot> { ... }
fn fold_opt_ts_func_decl_type_params(
&mut self,
n: Option<TSFuncDeclTypeParams>
) -> Option<TSFuncDeclTypeParams> { ... }
fn fold_opt_ts_type(
&mut self,
n: Option<Box<TSType>>
) -> Option<Box<TSType>> { ... }
fn fold_opt_ts_type_annotation(
&mut self,
n: Option<Box<TSTypeAnnotation>>
) -> Option<Box<TSTypeAnnotation>> { ... }
fn fold_opt_ts_type_parameter_declaration(
&mut self,
n: Option<TSTypeParameterDeclaration>
) -> Option<TSTypeParameterDeclaration> { ... }
fn fold_opt_ts_type_parameter_instantiation(
&mut self,
n: Option<TSTypeParameterInstantiation>
) -> Option<TSTypeParameterInstantiation> { ... }
fn fold_opt_type_annot_or_noop(
&mut self,
n: Option<Box<TypeAnnotOrNoop>>
) -> Option<Box<TypeAnnotOrNoop>> { ... }
fn fold_opt_type_annotation(
&mut self,
n: Option<TypeAnnotation>
) -> Option<TypeAnnotation> { ... }
fn fold_opt_type_param_decl_or_noop(
&mut self,
n: Option<TypeParamDeclOrNoop>
) -> Option<TypeParamDeclOrNoop> { ... }
fn fold_opt_type_parameter_declaration(
&mut self,
n: Option<TypeParameterDeclaration>
) -> Option<TypeParameterDeclaration> { ... }
fn fold_opt_type_parameter_instantiation(
&mut self,
n: Option<TypeParameterInstantiation>
) -> Option<TypeParameterInstantiation> { ... }
fn fold_opt_usize(&mut self, n: Option<usize>) -> Option<usize> { ... }
fn fold_opt_values(&mut self, n: Option<Vec<Value>>) -> Option<Vec<Value>> { ... }
fn fold_opt_variance(&mut self, n: Option<Variance>) -> Option<Variance> { ... }
fn fold_opt_vec_array_expr_els(
&mut self,
n: Vec<Option<ArrayExprEl>>
) -> Vec<Option<ArrayExprEl>> { ... }
fn fold_opt_vec_pattern_likes(
&mut self,
n: Vec<Option<PatternLike>>
) -> Vec<Option<PatternLike>> { ... }
fn fold_optional_call_expression(
&mut self,
n: OptionalCallExpression
) -> OptionalCallExpression { ... }
fn fold_optional_member_expr_prop(
&mut self,
n: OptionalMemberExprProp
) -> OptionalMemberExprProp { ... }
fn fold_optional_member_expression(
&mut self,
n: OptionalMemberExpression
) -> OptionalMemberExpression { ... }
fn fold_param(&mut self, n: Param) -> Param { ... }
fn fold_params(&mut self, n: Vec<Param>) -> Vec<Param> { ... }
fn fold_parenthesized_expression(
&mut self,
n: ParenthesizedExpression
) -> ParenthesizedExpression { ... }
fn fold_pattern(&mut self, n: Pattern) -> Pattern { ... }
fn fold_pattern_like(&mut self, n: PatternLike) -> PatternLike { ... }
fn fold_pipeline_bare_function(
&mut self,
n: PipelineBareFunction
) -> PipelineBareFunction { ... }
fn fold_pipeline_primary_topic_reference(
&mut self,
n: PipelinePrimaryTopicReference
) -> PipelinePrimaryTopicReference { ... }
fn fold_pipeline_topic_expression(
&mut self,
n: PipelineTopicExpression
) -> PipelineTopicExpression { ... }
fn fold_placeholder(&mut self, n: Placeholder) -> Placeholder { ... }
fn fold_placeholder_expected_node(
&mut self,
n: PlaceholderExpectedNode
) -> PlaceholderExpectedNode { ... }
fn fold_plus_or_minus(&mut self, n: PlusOrMinus) -> PlusOrMinus { ... }
fn fold_private(&mut self, n: Private) -> Private { ... }
fn fold_private_name(&mut self, n: PrivateName) -> PrivateName { ... }
fn fold_program(&mut self, n: Program) -> Program { ... }
fn fold_property(&mut self, n: Property) -> Property { ... }
fn fold_pureish(&mut self, n: Pureish) -> Pureish { ... }
fn fold_qualified_type_identifier(
&mut self,
n: QualifiedTypeIdentifier
) -> QualifiedTypeIdentifier { ... }
fn fold_record_expr_prop(&mut self, n: RecordExprProp) -> RecordExprProp { ... }
fn fold_record_expr_props(
&mut self,
n: Vec<RecordExprProp>
) -> Vec<RecordExprProp> { ... }
fn fold_record_expression(
&mut self,
n: RecordExpression
) -> RecordExpression { ... }
fn fold_reg_exp_literal(&mut self, n: RegExpLiteral) -> RegExpLiteral { ... }
fn fold_regex_literal(&mut self, n: RegexLiteral) -> RegexLiteral { ... }
fn fold_rest_element(&mut self, n: RestElement) -> RestElement { ... }
fn fold_rest_property(&mut self, n: RestProperty) -> RestProperty { ... }
fn fold_return_statement(&mut self, n: ReturnStatement) -> ReturnStatement { ... }
fn fold_scopable(&mut self, n: Scopable) -> Scopable { ... }
fn fold_sequence_expression(
&mut self,
n: SequenceExpression
) -> SequenceExpression { ... }
fn fold_spread_element(&mut self, n: SpreadElement) -> SpreadElement { ... }
fn fold_spread_property(&mut self, n: SpreadProperty) -> SpreadProperty { ... }
fn fold_src_type(&mut self, n: SrcType) -> SrcType { ... }
fn fold_statement(&mut self, n: Statement) -> Statement { ... }
fn fold_statements(&mut self, n: Vec<Statement>) -> Vec<Statement> { ... }
fn fold_static_block(&mut self, n: StaticBlock) -> StaticBlock { ... }
fn fold_string(&mut self, n: String) -> String { ... }
fn fold_string_literal(&mut self, n: StringLiteral) -> StringLiteral { ... }
fn fold_string_literal_type_annotation(
&mut self,
n: StringLiteralTypeAnnotation
) -> StringLiteralTypeAnnotation { ... }
fn fold_string_type_annotation(
&mut self,
n: StringTypeAnnotation
) -> StringTypeAnnotation { ... }
fn fold_super(&mut self, n: Super) -> Super { ... }
fn fold_super_type_params(&mut self, n: SuperTypeParams) -> SuperTypeParams { ... }
fn fold_switch_case(&mut self, n: SwitchCase) -> SwitchCase { ... }
fn fold_switch_cases(&mut self, n: Vec<SwitchCase>) -> Vec<SwitchCase> { ... }
fn fold_switch_statement(&mut self, n: SwitchStatement) -> SwitchStatement { ... }
fn fold_symbol_type_annotation(
&mut self,
n: SymbolTypeAnnotation
) -> SymbolTypeAnnotation { ... }
fn fold_tagged_template_expr_type_params(
&mut self,
n: TaggedTemplateExprTypeParams
) -> TaggedTemplateExprTypeParams { ... }
fn fold_tagged_template_expression(
&mut self,
n: TaggedTemplateExpression
) -> TaggedTemplateExpression { ... }
fn fold_template_el_val(&mut self, n: TemplateElVal) -> TemplateElVal { ... }
fn fold_template_element(&mut self, n: TemplateElement) -> TemplateElement { ... }
fn fold_template_elements(
&mut self,
n: Vec<TemplateElement>
) -> Vec<TemplateElement> { ... }
fn fold_template_literal(&mut self, n: TemplateLiteral) -> TemplateLiteral { ... }
fn fold_template_literal_expr(
&mut self,
n: TemplateLiteralExpr
) -> TemplateLiteralExpr { ... }
fn fold_template_literal_exprs(
&mut self,
n: Vec<TemplateLiteralExpr>
) -> Vec<TemplateLiteralExpr> { ... }
fn fold_terminatorless(&mut self, n: Terminatorless) -> Terminatorless { ... }
fn fold_this_expression(&mut self, n: ThisExpression) -> ThisExpression { ... }
fn fold_this_type_annotation(
&mut self,
n: ThisTypeAnnotation
) -> ThisTypeAnnotation { ... }
fn fold_throw_statement(&mut self, n: ThrowStatement) -> ThrowStatement { ... }
fn fold_try_statement(&mut self, n: TryStatement) -> TryStatement { ... }
fn fold_ts_any_keyword(&mut self, n: TSAnyKeyword) -> TSAnyKeyword { ... }
fn fold_ts_array_type(&mut self, n: TSArrayType) -> TSArrayType { ... }
fn fold_ts_as_expression(&mut self, n: TSAsExpression) -> TSAsExpression { ... }
fn fold_ts_base_type(&mut self, n: TSBaseType) -> TSBaseType { ... }
fn fold_ts_big_int_keyword(&mut self, n: TSBigIntKeyword) -> TSBigIntKeyword { ... }
fn fold_ts_boolean_keyword(
&mut self,
n: TSBooleanKeyword
) -> TSBooleanKeyword { ... }
fn fold_ts_call_signature_declaration(
&mut self,
n: TSCallSignatureDeclaration
) -> TSCallSignatureDeclaration { ... }
fn fold_ts_conditional_type(
&mut self,
n: TSConditionalType
) -> TSConditionalType { ... }
fn fold_ts_construct_signature_declaration(
&mut self,
n: TSConstructSignatureDeclaration
) -> TSConstructSignatureDeclaration { ... }
fn fold_ts_constructor_type(
&mut self,
n: TSConstructorType
) -> TSConstructorType { ... }
fn fold_ts_declare_function(
&mut self,
n: TSDeclareFunction
) -> TSDeclareFunction { ... }
fn fold_ts_declare_method(&mut self, n: TSDeclareMethod) -> TSDeclareMethod { ... }
fn fold_ts_entity_name(&mut self, n: TSEntityName) -> TSEntityName { ... }
fn fold_ts_enum_declaration(
&mut self,
n: TSEnumDeclaration
) -> TSEnumDeclaration { ... }
fn fold_ts_enum_member(&mut self, n: TSEnumMember) -> TSEnumMember { ... }
fn fold_ts_enum_members(
&mut self,
n: Vec<TSEnumMember>
) -> Vec<TSEnumMember> { ... }
fn fold_ts_export_assignment(
&mut self,
n: TSExportAssignment
) -> TSExportAssignment { ... }
fn fold_ts_expression_with_type_arguments(
&mut self,
n: TSExpressionWithTypeArguments
) -> TSExpressionWithTypeArguments { ... }
fn fold_ts_external_module_reference(
&mut self,
n: TSExternalModuleReference
) -> TSExternalModuleReference { ... }
fn fold_ts_func_decl_type_annot(
&mut self,
n: TSFuncDeclTypeAnnot
) -> TSFuncDeclTypeAnnot { ... }
fn fold_ts_func_decl_type_params(
&mut self,
n: TSFuncDeclTypeParams
) -> TSFuncDeclTypeParams { ... }
fn fold_ts_function_type(&mut self, n: TSFunctionType) -> TSFunctionType { ... }
fn fold_ts_import_equals_decl_module_ref(
&mut self,
n: TSImportEqualsDeclModuleRef
) -> TSImportEqualsDeclModuleRef { ... }
fn fold_ts_import_equals_declaration(
&mut self,
n: TSImportEqualsDeclaration
) -> TSImportEqualsDeclaration { ... }
fn fold_ts_import_type(&mut self, n: TSImportType) -> TSImportType { ... }
fn fold_ts_index_signature(
&mut self,
n: TSIndexSignature
) -> TSIndexSignature { ... }
fn fold_ts_indexed_access_type(
&mut self,
n: TSIndexedAccessType
) -> TSIndexedAccessType { ... }
fn fold_ts_infer_type(&mut self, n: TSInferType) -> TSInferType { ... }
fn fold_ts_interface_body(&mut self, n: TSInterfaceBody) -> TSInterfaceBody { ... }
fn fold_ts_interface_declaration(
&mut self,
n: TSInterfaceDeclaration
) -> TSInterfaceDeclaration { ... }
fn fold_ts_intersection_type(
&mut self,
n: TSIntersectionType
) -> TSIntersectionType { ... }
fn fold_ts_intrinsic_keyword(
&mut self,
n: TSIntrinsicKeyword
) -> TSIntrinsicKeyword { ... }
fn fold_ts_literal_type(&mut self, n: TSLiteralType) -> TSLiteralType { ... }
fn fold_ts_literal_type_literal(
&mut self,
n: TSLiteralTypeLiteral
) -> TSLiteralTypeLiteral { ... }
fn fold_ts_mapped_type(&mut self, n: TSMappedType) -> TSMappedType { ... }
fn fold_ts_method_signature(
&mut self,
n: TSMethodSignature
) -> TSMethodSignature { ... }
fn fold_ts_module_block(&mut self, n: TSModuleBlock) -> TSModuleBlock { ... }
fn fold_ts_module_decl_body(
&mut self,
n: TSModuleDeclBody
) -> TSModuleDeclBody { ... }
fn fold_ts_module_declaration(
&mut self,
n: TSModuleDeclaration
) -> TSModuleDeclaration { ... }
fn fold_ts_named_tuple_member(
&mut self,
n: TSNamedTupleMember
) -> TSNamedTupleMember { ... }
fn fold_ts_namespace_export_declaration(
&mut self,
n: TSNamespaceExportDeclaration
) -> TSNamespaceExportDeclaration { ... }
fn fold_ts_never_keyword(&mut self, n: TSNeverKeyword) -> TSNeverKeyword { ... }
fn fold_ts_non_null_expression(
&mut self,
n: TSNonNullExpression
) -> TSNonNullExpression { ... }
fn fold_ts_null_keyword(&mut self, n: TSNullKeyword) -> TSNullKeyword { ... }
fn fold_ts_number_keyword(&mut self, n: TSNumberKeyword) -> TSNumberKeyword { ... }
fn fold_ts_object_keyword(&mut self, n: TSObjectKeyword) -> TSObjectKeyword { ... }
fn fold_ts_optional_type(&mut self, n: TSOptionalType) -> TSOptionalType { ... }
fn fold_ts_param_prop_param(
&mut self,
n: TSParamPropParam
) -> TSParamPropParam { ... }
fn fold_ts_parameter_property(
&mut self,
n: TSParameterProperty
) -> TSParameterProperty { ... }
fn fold_ts_parenthesized_type(
&mut self,
n: TSParenthesizedType
) -> TSParenthesizedType { ... }
fn fold_ts_property_signature(
&mut self,
n: TSPropertySignature
) -> TSPropertySignature { ... }
fn fold_ts_qualified_name(&mut self, n: TSQualifiedName) -> TSQualifiedName { ... }
fn fold_ts_rest_type(&mut self, n: TSRestType) -> TSRestType { ... }
fn fold_ts_string_keyword(&mut self, n: TSStringKeyword) -> TSStringKeyword { ... }
fn fold_ts_symbol_keyword(&mut self, n: TSSymbolKeyword) -> TSSymbolKeyword { ... }
fn fold_ts_this_type(&mut self, n: TSThisType) -> TSThisType { ... }
fn fold_ts_tuple_type(&mut self, n: TSTupleType) -> TSTupleType { ... }
fn fold_ts_tuple_type_el_type(
&mut self,
n: TSTupleTypeElType
) -> TSTupleTypeElType { ... }
fn fold_ts_tuple_type_el_types(
&mut self,
n: Vec<TSTupleTypeElType>
) -> Vec<TSTupleTypeElType> { ... }
fn fold_ts_type(&mut self, n: TSType) -> TSType { ... }
fn fold_ts_type_alias_declaration(
&mut self,
n: TSTypeAliasDeclaration
) -> TSTypeAliasDeclaration { ... }
fn fold_ts_type_annotation(
&mut self,
n: TSTypeAnnotation
) -> TSTypeAnnotation { ... }
fn fold_ts_type_assertion(&mut self, n: TSTypeAssertion) -> TSTypeAssertion { ... }
fn fold_ts_type_element(&mut self, n: TSTypeElement) -> TSTypeElement { ... }
fn fold_ts_type_elements(
&mut self,
n: Vec<TSTypeElement>
) -> Vec<TSTypeElement> { ... }
fn fold_ts_type_literal(&mut self, n: TSTypeLiteral) -> TSTypeLiteral { ... }
fn fold_ts_type_operator(&mut self, n: TSTypeOperator) -> TSTypeOperator { ... }
fn fold_ts_type_parameter(&mut self, n: TSTypeParameter) -> TSTypeParameter { ... }
fn fold_ts_type_parameter_declaration(
&mut self,
n: TSTypeParameterDeclaration
) -> TSTypeParameterDeclaration { ... }
fn fold_ts_type_parameter_instantiation(
&mut self,
n: TSTypeParameterInstantiation
) -> TSTypeParameterInstantiation { ... }
fn fold_ts_type_parameters(
&mut self,
n: Vec<TSTypeParameter>
) -> Vec<TSTypeParameter> { ... }
fn fold_ts_type_predicate(&mut self, n: TSTypePredicate) -> TSTypePredicate { ... }
fn fold_ts_type_predicate_param_name(
&mut self,
n: TSTypePredicateParamName
) -> TSTypePredicateParamName { ... }
fn fold_ts_type_query(&mut self, n: TSTypeQuery) -> TSTypeQuery { ... }
fn fold_ts_type_query_expr_name(
&mut self,
n: TSTypeQueryExprName
) -> TSTypeQueryExprName { ... }
fn fold_ts_type_reference(&mut self, n: TSTypeReference) -> TSTypeReference { ... }
fn fold_ts_types(&mut self, n: Vec<TSType>) -> Vec<TSType> { ... }
fn fold_ts_undefined_keyword(
&mut self,
n: TSUndefinedKeyword
) -> TSUndefinedKeyword { ... }
fn fold_ts_union_type(&mut self, n: TSUnionType) -> TSUnionType { ... }
fn fold_ts_unknown_keyword(
&mut self,
n: TSUnknownKeyword
) -> TSUnknownKeyword { ... }
fn fold_ts_void_keyword(&mut self, n: TSVoidKeyword) -> TSVoidKeyword { ... }
fn fold_tuple_expr_el(&mut self, n: TupleExprEl) -> TupleExprEl { ... }
fn fold_tuple_expr_els(&mut self, n: Vec<TupleExprEl>) -> Vec<TupleExprEl> { ... }
fn fold_tuple_expression(&mut self, n: TupleExpression) -> TupleExpression { ... }
fn fold_tuple_type_annotation(
&mut self,
n: TupleTypeAnnotation
) -> TupleTypeAnnotation { ... }
fn fold_type_alias(&mut self, n: TypeAlias) -> TypeAlias { ... }
fn fold_type_annot_or_noop(&mut self, n: TypeAnnotOrNoop) -> TypeAnnotOrNoop { ... }
fn fold_type_annotation(&mut self, n: TypeAnnotation) -> TypeAnnotation { ... }
fn fold_type_cast_expression(
&mut self,
n: TypeCastExpression
) -> TypeCastExpression { ... }
fn fold_type_param_decl_or_noop(
&mut self,
n: TypeParamDeclOrNoop
) -> TypeParamDeclOrNoop { ... }
fn fold_type_parameter(&mut self, n: TypeParameter) -> TypeParameter { ... }
fn fold_type_parameter_declaration(
&mut self,
n: TypeParameterDeclaration
) -> TypeParameterDeclaration { ... }
fn fold_type_parameter_instantiation(
&mut self,
n: TypeParameterInstantiation
) -> TypeParameterInstantiation { ... }
fn fold_type_parameters(
&mut self,
n: Vec<TypeParameter>
) -> Vec<TypeParameter> { ... }
fn fold_typeof_type_annotation(
&mut self,
n: TypeofTypeAnnotation
) -> TypeofTypeAnnotation { ... }
fn fold_unary_expr_op(&mut self, n: UnaryExprOp) -> UnaryExprOp { ... }
fn fold_unary_expression(&mut self, n: UnaryExpression) -> UnaryExpression { ... }
fn fold_unary_like(&mut self, n: UnaryLike) -> UnaryLike { ... }
fn fold_union_type_annotation(
&mut self,
n: UnionTypeAnnotation
) -> UnionTypeAnnotation { ... }
fn fold_update_expr_op(&mut self, n: UpdateExprOp) -> UpdateExprOp { ... }
fn fold_update_expression(
&mut self,
n: UpdateExpression
) -> UpdateExpression { ... }
fn fold_user_whitespacable(
&mut self,
n: UserWhitespacable
) -> UserWhitespacable { ... }
fn fold_usize(&mut self, n: usize) -> usize { ... }
fn fold_v8_intrinsic_identifier(
&mut self,
n: V8IntrinsicIdentifier
) -> V8IntrinsicIdentifier { ... }
fn fold_value(&mut self, n: Value) -> Value { ... }
fn fold_values(&mut self, n: Vec<Value>) -> Vec<Value> { ... }
fn fold_variable_declaration(
&mut self,
n: VariableDeclaration
) -> VariableDeclaration { ... }
fn fold_variable_declaration_kind(
&mut self,
n: VariableDeclarationKind
) -> VariableDeclarationKind { ... }
fn fold_variable_declarator(
&mut self,
n: VariableDeclarator
) -> VariableDeclarator { ... }
fn fold_variable_declarators(
&mut self,
n: Vec<VariableDeclarator>
) -> Vec<VariableDeclarator> { ... }
fn fold_variance(&mut self, n: Variance) -> Variance { ... }
fn fold_void_type_annotation(
&mut self,
n: VoidTypeAnnotation
) -> VoidTypeAnnotation { ... }
fn fold_while(&mut self, n: While) -> While { ... }
fn fold_while_statement(&mut self, n: WhileStatement) -> WhileStatement { ... }
fn fold_with_statement(&mut self, n: WithStatement) -> WithStatement { ... }
fn fold_yield_expression(&mut self, n: YieldExpression) -> YieldExpression { ... }