Trait rustpython_ast::fold::Fold

pub trait Fold<U> {
    type TargetU;
    type Error;
    type UserContext;

    // Required methods
    fn will_map_user(&mut self, user: &U) -> Self::UserContext;
    fn map_user(
        &mut self,
        user: U,
        context: Self::UserContext
    ) -> Result<Self::TargetU, Self::Error>;

    // Provided methods
    fn will_map_user_cfg(
        &mut self,
        _user: &EmptyRange<U>
    ) -> EmptyRange<Self::TargetU> { ... }
    fn map_user_cfg(
        &mut self,
        _user: EmptyRange<U>,
        _context: EmptyRange<Self::TargetU>
    ) -> Result<EmptyRange<Self::TargetU>, Self::Error> { ... }
    fn fold<X: Foldable<U, Self::TargetU>>(
        &mut self,
        node: X
    ) -> Result<X::Mapped, Self::Error> { ... }
    fn fold_mod(
        &mut self,
        node: Mod<U>
    ) -> Result<Mod<Self::TargetU>, Self::Error> { ... }
    fn fold_mod_module(
        &mut self,
        node: ModModule<U>
    ) -> Result<ModModule<Self::TargetU>, Self::Error> { ... }
    fn fold_mod_interactive(
        &mut self,
        node: ModInteractive<U>
    ) -> Result<ModInteractive<Self::TargetU>, Self::Error> { ... }
    fn fold_mod_expression(
        &mut self,
        node: ModExpression<U>
    ) -> Result<ModExpression<Self::TargetU>, Self::Error> { ... }
    fn fold_mod_function_type(
        &mut self,
        node: ModFunctionType<U>
    ) -> Result<ModFunctionType<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt(
        &mut self,
        node: Stmt<U>
    ) -> Result<Stmt<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_function_def(
        &mut self,
        node: StmtFunctionDef<U>
    ) -> Result<StmtFunctionDef<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_async_function_def(
        &mut self,
        node: StmtAsyncFunctionDef<U>
    ) -> Result<StmtAsyncFunctionDef<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_class_def(
        &mut self,
        node: StmtClassDef<U>
    ) -> Result<StmtClassDef<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_return(
        &mut self,
        node: StmtReturn<U>
    ) -> Result<StmtReturn<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_delete(
        &mut self,
        node: StmtDelete<U>
    ) -> Result<StmtDelete<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_assign(
        &mut self,
        node: StmtAssign<U>
    ) -> Result<StmtAssign<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_type_alias(
        &mut self,
        node: StmtTypeAlias<U>
    ) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_aug_assign(
        &mut self,
        node: StmtAugAssign<U>
    ) -> Result<StmtAugAssign<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_ann_assign(
        &mut self,
        node: StmtAnnAssign<U>
    ) -> Result<StmtAnnAssign<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_for(
        &mut self,
        node: StmtFor<U>
    ) -> Result<StmtFor<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_async_for(
        &mut self,
        node: StmtAsyncFor<U>
    ) -> Result<StmtAsyncFor<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_while(
        &mut self,
        node: StmtWhile<U>
    ) -> Result<StmtWhile<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_if(
        &mut self,
        node: StmtIf<U>
    ) -> Result<StmtIf<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_with(
        &mut self,
        node: StmtWith<U>
    ) -> Result<StmtWith<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_async_with(
        &mut self,
        node: StmtAsyncWith<U>
    ) -> Result<StmtAsyncWith<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_match(
        &mut self,
        node: StmtMatch<U>
    ) -> Result<StmtMatch<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_raise(
        &mut self,
        node: StmtRaise<U>
    ) -> Result<StmtRaise<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_try(
        &mut self,
        node: StmtTry<U>
    ) -> Result<StmtTry<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_try_star(
        &mut self,
        node: StmtTryStar<U>
    ) -> Result<StmtTryStar<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_assert(
        &mut self,
        node: StmtAssert<U>
    ) -> Result<StmtAssert<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_import(
        &mut self,
        node: StmtImport<U>
    ) -> Result<StmtImport<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_import_from(
        &mut self,
        node: StmtImportFrom<U>
    ) -> Result<StmtImportFrom<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_global(
        &mut self,
        node: StmtGlobal<U>
    ) -> Result<StmtGlobal<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_nonlocal(
        &mut self,
        node: StmtNonlocal<U>
    ) -> Result<StmtNonlocal<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_expr(
        &mut self,
        node: StmtExpr<U>
    ) -> Result<StmtExpr<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_pass(
        &mut self,
        node: StmtPass<U>
    ) -> Result<StmtPass<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_break(
        &mut self,
        node: StmtBreak<U>
    ) -> Result<StmtBreak<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt_continue(
        &mut self,
        node: StmtContinue<U>
    ) -> Result<StmtContinue<Self::TargetU>, Self::Error> { ... }
    fn fold_expr(
        &mut self,
        node: Expr<U>
    ) -> Result<Expr<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_bool_op(
        &mut self,
        node: ExprBoolOp<U>
    ) -> Result<ExprBoolOp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_named_expr(
        &mut self,
        node: ExprNamedExpr<U>
    ) -> Result<ExprNamedExpr<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_bin_op(
        &mut self,
        node: ExprBinOp<U>
    ) -> Result<ExprBinOp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_unary_op(
        &mut self,
        node: ExprUnaryOp<U>
    ) -> Result<ExprUnaryOp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_lambda(
        &mut self,
        node: ExprLambda<U>
    ) -> Result<ExprLambda<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_if_exp(
        &mut self,
        node: ExprIfExp<U>
    ) -> Result<ExprIfExp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_dict(
        &mut self,
        node: ExprDict<U>
    ) -> Result<ExprDict<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_set(
        &mut self,
        node: ExprSet<U>
    ) -> Result<ExprSet<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_list_comp(
        &mut self,
        node: ExprListComp<U>
    ) -> Result<ExprListComp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_set_comp(
        &mut self,
        node: ExprSetComp<U>
    ) -> Result<ExprSetComp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_dict_comp(
        &mut self,
        node: ExprDictComp<U>
    ) -> Result<ExprDictComp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_generator_exp(
        &mut self,
        node: ExprGeneratorExp<U>
    ) -> Result<ExprGeneratorExp<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_await(
        &mut self,
        node: ExprAwait<U>
    ) -> Result<ExprAwait<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_yield(
        &mut self,
        node: ExprYield<U>
    ) -> Result<ExprYield<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_yield_from(
        &mut self,
        node: ExprYieldFrom<U>
    ) -> Result<ExprYieldFrom<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_compare(
        &mut self,
        node: ExprCompare<U>
    ) -> Result<ExprCompare<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_call(
        &mut self,
        node: ExprCall<U>
    ) -> Result<ExprCall<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_formatted_value(
        &mut self,
        node: ExprFormattedValue<U>
    ) -> Result<ExprFormattedValue<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_joined_str(
        &mut self,
        node: ExprJoinedStr<U>
    ) -> Result<ExprJoinedStr<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_constant(
        &mut self,
        node: ExprConstant<U>
    ) -> Result<ExprConstant<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_attribute(
        &mut self,
        node: ExprAttribute<U>
    ) -> Result<ExprAttribute<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_subscript(
        &mut self,
        node: ExprSubscript<U>
    ) -> Result<ExprSubscript<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_starred(
        &mut self,
        node: ExprStarred<U>
    ) -> Result<ExprStarred<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_name(
        &mut self,
        node: ExprName<U>
    ) -> Result<ExprName<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_list(
        &mut self,
        node: ExprList<U>
    ) -> Result<ExprList<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_tuple(
        &mut self,
        node: ExprTuple<U>
    ) -> Result<ExprTuple<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_slice(
        &mut self,
        node: ExprSlice<U>
    ) -> Result<ExprSlice<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_context(
        &mut self,
        node: ExprContext
    ) -> Result<ExprContext, Self::Error> { ... }
    fn fold_boolop(&mut self, node: BoolOp) -> Result<BoolOp, Self::Error> { ... }
    fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error> { ... }
    fn fold_unaryop(&mut self, node: UnaryOp) -> Result<UnaryOp, Self::Error> { ... }
    fn fold_cmpop(&mut self, node: CmpOp) -> Result<CmpOp, Self::Error> { ... }
    fn fold_comprehension(
        &mut self,
        node: Comprehension<U>
    ) -> Result<Comprehension<Self::TargetU>, Self::Error> { ... }
    fn fold_excepthandler(
        &mut self,
        node: ExceptHandler<U>
    ) -> Result<ExceptHandler<Self::TargetU>, Self::Error> { ... }
    fn fold_excepthandler_except_handler(
        &mut self,
        node: ExceptHandlerExceptHandler<U>
    ) -> Result<ExceptHandlerExceptHandler<Self::TargetU>, Self::Error> { ... }
    fn fold_arguments(
        &mut self,
        node: Arguments<U>
    ) -> Result<Arguments<Self::TargetU>, Self::Error> { ... }
    fn fold_arg(
        &mut self,
        node: Arg<U>
    ) -> Result<Arg<Self::TargetU>, Self::Error> { ... }
    fn fold_keyword(
        &mut self,
        node: Keyword<U>
    ) -> Result<Keyword<Self::TargetU>, Self::Error> { ... }
    fn fold_alias(
        &mut self,
        node: Alias<U>
    ) -> Result<Alias<Self::TargetU>, Self::Error> { ... }
    fn fold_withitem(
        &mut self,
        node: WithItem<U>
    ) -> Result<WithItem<Self::TargetU>, Self::Error> { ... }
    fn fold_match_case(
        &mut self,
        node: MatchCase<U>
    ) -> Result<MatchCase<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern(
        &mut self,
        node: Pattern<U>
    ) -> Result<Pattern<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_value(
        &mut self,
        node: PatternMatchValue<U>
    ) -> Result<PatternMatchValue<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_singleton(
        &mut self,
        node: PatternMatchSingleton<U>
    ) -> Result<PatternMatchSingleton<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_sequence(
        &mut self,
        node: PatternMatchSequence<U>
    ) -> Result<PatternMatchSequence<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_mapping(
        &mut self,
        node: PatternMatchMapping<U>
    ) -> Result<PatternMatchMapping<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_class(
        &mut self,
        node: PatternMatchClass<U>
    ) -> Result<PatternMatchClass<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_star(
        &mut self,
        node: PatternMatchStar<U>
    ) -> Result<PatternMatchStar<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_as(
        &mut self,
        node: PatternMatchAs<U>
    ) -> Result<PatternMatchAs<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern_match_or(
        &mut self,
        node: PatternMatchOr<U>
    ) -> Result<PatternMatchOr<Self::TargetU>, Self::Error> { ... }
    fn fold_type_ignore(
        &mut self,
        node: TypeIgnore<U>
    ) -> Result<TypeIgnore<Self::TargetU>, Self::Error> { ... }
    fn fold_type_ignore_type_ignore(
        &mut self,
        node: TypeIgnoreTypeIgnore<U>
    ) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> { ... }
    fn fold_type_param(
        &mut self,
        node: TypeParam<U>
    ) -> Result<TypeParam<Self::TargetU>, Self::Error> { ... }
    fn fold_type_param_type_var(
        &mut self,
        node: TypeParamTypeVar<U>
    ) -> Result<TypeParamTypeVar<Self::TargetU>, Self::Error> { ... }
    fn fold_type_param_param_spec(
        &mut self,
        node: TypeParamParamSpec<U>
    ) -> Result<TypeParamParamSpec<Self::TargetU>, Self::Error> { ... }
    fn fold_type_param_type_var_tuple(
        &mut self,
        node: TypeParamTypeVarTuple<U>
    ) -> Result<TypeParamTypeVarTuple<Self::TargetU>, Self::Error> { ... }
    fn fold_arg_with_default(
        &mut self,
        node: ArgWithDefault<U>
    ) -> Result<ArgWithDefault<Self::TargetU>, Self::Error> { ... }
}

Required Associated Types

type TargetU

type Error

type UserContext

Required Methods

fn will_map_user(&mut self, user: &U) -> Self::UserContext

fn map_user( &mut self, user: U, context: Self::UserContext ) -> Result<Self::TargetU, Self::Error>

Provided Methods

fn will_map_user_cfg( &mut self, _user: &EmptyRange<U> ) -> EmptyRange<Self::TargetU>

fn map_user_cfg( &mut self, _user: EmptyRange<U>, _context: EmptyRange<Self::TargetU> ) -> Result<EmptyRange<Self::TargetU>, Self::Error>

fn fold<X: Foldable<U, Self::TargetU>>( &mut self, node: X ) -> Result<X::Mapped, Self::Error>

fn fold_mod(&mut self, node: Mod<U>) -> Result<Mod<Self::TargetU>, Self::Error>

fn fold_mod_module( &mut self, node: ModModule<U> ) -> Result<ModModule<Self::TargetU>, Self::Error>

fn fold_mod_interactive( &mut self, node: ModInteractive<U> ) -> Result<ModInteractive<Self::TargetU>, Self::Error>

fn fold_mod_expression( &mut self, node: ModExpression<U> ) -> Result<ModExpression<Self::TargetU>, Self::Error>

fn fold_mod_function_type( &mut self, node: ModFunctionType<U> ) -> Result<ModFunctionType<Self::TargetU>, Self::Error>

fn fold_stmt( &mut self, node: Stmt<U> ) -> Result<Stmt<Self::TargetU>, Self::Error>

fn fold_stmt_function_def( &mut self, node: StmtFunctionDef<U> ) -> Result<StmtFunctionDef<Self::TargetU>, Self::Error>

fn fold_stmt_async_function_def( &mut self, node: StmtAsyncFunctionDef<U> ) -> Result<StmtAsyncFunctionDef<Self::TargetU>, Self::Error>

fn fold_stmt_class_def( &mut self, node: StmtClassDef<U> ) -> Result<StmtClassDef<Self::TargetU>, Self::Error>

fn fold_stmt_return( &mut self, node: StmtReturn<U> ) -> Result<StmtReturn<Self::TargetU>, Self::Error>

fn fold_stmt_delete( &mut self, node: StmtDelete<U> ) -> Result<StmtDelete<Self::TargetU>, Self::Error>

fn fold_stmt_assign( &mut self, node: StmtAssign<U> ) -> Result<StmtAssign<Self::TargetU>, Self::Error>

fn fold_stmt_type_alias( &mut self, node: StmtTypeAlias<U> ) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error>

fn fold_stmt_aug_assign( &mut self, node: StmtAugAssign<U> ) -> Result<StmtAugAssign<Self::TargetU>, Self::Error>

fn fold_stmt_ann_assign( &mut self, node: StmtAnnAssign<U> ) -> Result<StmtAnnAssign<Self::TargetU>, Self::Error>

fn fold_stmt_for( &mut self, node: StmtFor<U> ) -> Result<StmtFor<Self::TargetU>, Self::Error>

fn fold_stmt_async_for( &mut self, node: StmtAsyncFor<U> ) -> Result<StmtAsyncFor<Self::TargetU>, Self::Error>

fn fold_stmt_while( &mut self, node: StmtWhile<U> ) -> Result<StmtWhile<Self::TargetU>, Self::Error>

fn fold_stmt_if( &mut self, node: StmtIf<U> ) -> Result<StmtIf<Self::TargetU>, Self::Error>

fn fold_stmt_with( &mut self, node: StmtWith<U> ) -> Result<StmtWith<Self::TargetU>, Self::Error>

fn fold_stmt_async_with( &mut self, node: StmtAsyncWith<U> ) -> Result<StmtAsyncWith<Self::TargetU>, Self::Error>

fn fold_stmt_match( &mut self, node: StmtMatch<U> ) -> Result<StmtMatch<Self::TargetU>, Self::Error>

fn fold_stmt_raise( &mut self, node: StmtRaise<U> ) -> Result<StmtRaise<Self::TargetU>, Self::Error>

fn fold_stmt_try( &mut self, node: StmtTry<U> ) -> Result<StmtTry<Self::TargetU>, Self::Error>

fn fold_stmt_try_star( &mut self, node: StmtTryStar<U> ) -> Result<StmtTryStar<Self::TargetU>, Self::Error>

fn fold_stmt_assert( &mut self, node: StmtAssert<U> ) -> Result<StmtAssert<Self::TargetU>, Self::Error>

fn fold_stmt_import( &mut self, node: StmtImport<U> ) -> Result<StmtImport<Self::TargetU>, Self::Error>

fn fold_stmt_import_from( &mut self, node: StmtImportFrom<U> ) -> Result<StmtImportFrom<Self::TargetU>, Self::Error>

fn fold_stmt_global( &mut self, node: StmtGlobal<U> ) -> Result<StmtGlobal<Self::TargetU>, Self::Error>

fn fold_stmt_nonlocal( &mut self, node: StmtNonlocal<U> ) -> Result<StmtNonlocal<Self::TargetU>, Self::Error>

fn fold_stmt_expr( &mut self, node: StmtExpr<U> ) -> Result<StmtExpr<Self::TargetU>, Self::Error>

fn fold_stmt_pass( &mut self, node: StmtPass<U> ) -> Result<StmtPass<Self::TargetU>, Self::Error>

fn fold_stmt_break( &mut self, node: StmtBreak<U> ) -> Result<StmtBreak<Self::TargetU>, Self::Error>

fn fold_stmt_continue( &mut self, node: StmtContinue<U> ) -> Result<StmtContinue<Self::TargetU>, Self::Error>

fn fold_expr( &mut self, node: Expr<U> ) -> Result<Expr<Self::TargetU>, Self::Error>

fn fold_expr_bool_op( &mut self, node: ExprBoolOp<U> ) -> Result<ExprBoolOp<Self::TargetU>, Self::Error>

fn fold_expr_named_expr( &mut self, node: ExprNamedExpr<U> ) -> Result<ExprNamedExpr<Self::TargetU>, Self::Error>

fn fold_expr_bin_op( &mut self, node: ExprBinOp<U> ) -> Result<ExprBinOp<Self::TargetU>, Self::Error>

fn fold_expr_unary_op( &mut self, node: ExprUnaryOp<U> ) -> Result<ExprUnaryOp<Self::TargetU>, Self::Error>

fn fold_expr_lambda( &mut self, node: ExprLambda<U> ) -> Result<ExprLambda<Self::TargetU>, Self::Error>

fn fold_expr_if_exp( &mut self, node: ExprIfExp<U> ) -> Result<ExprIfExp<Self::TargetU>, Self::Error>

fn fold_expr_dict( &mut self, node: ExprDict<U> ) -> Result<ExprDict<Self::TargetU>, Self::Error>

fn fold_expr_set( &mut self, node: ExprSet<U> ) -> Result<ExprSet<Self::TargetU>, Self::Error>

fn fold_expr_list_comp( &mut self, node: ExprListComp<U> ) -> Result<ExprListComp<Self::TargetU>, Self::Error>

fn fold_expr_set_comp( &mut self, node: ExprSetComp<U> ) -> Result<ExprSetComp<Self::TargetU>, Self::Error>

fn fold_expr_dict_comp( &mut self, node: ExprDictComp<U> ) -> Result<ExprDictComp<Self::TargetU>, Self::Error>

fn fold_expr_generator_exp( &mut self, node: ExprGeneratorExp<U> ) -> Result<ExprGeneratorExp<Self::TargetU>, Self::Error>

fn fold_expr_await( &mut self, node: ExprAwait<U> ) -> Result<ExprAwait<Self::TargetU>, Self::Error>

fn fold_expr_yield( &mut self, node: ExprYield<U> ) -> Result<ExprYield<Self::TargetU>, Self::Error>

fn fold_expr_yield_from( &mut self, node: ExprYieldFrom<U> ) -> Result<ExprYieldFrom<Self::TargetU>, Self::Error>

fn fold_expr_compare( &mut self, node: ExprCompare<U> ) -> Result<ExprCompare<Self::TargetU>, Self::Error>

fn fold_expr_call( &mut self, node: ExprCall<U> ) -> Result<ExprCall<Self::TargetU>, Self::Error>

fn fold_expr_formatted_value( &mut self, node: ExprFormattedValue<U> ) -> Result<ExprFormattedValue<Self::TargetU>, Self::Error>

fn fold_expr_joined_str( &mut self, node: ExprJoinedStr<U> ) -> Result<ExprJoinedStr<Self::TargetU>, Self::Error>

fn fold_expr_constant( &mut self, node: ExprConstant<U> ) -> Result<ExprConstant<Self::TargetU>, Self::Error>

fn fold_expr_attribute( &mut self, node: ExprAttribute<U> ) -> Result<ExprAttribute<Self::TargetU>, Self::Error>

fn fold_expr_subscript( &mut self, node: ExprSubscript<U> ) -> Result<ExprSubscript<Self::TargetU>, Self::Error>

fn fold_expr_starred( &mut self, node: ExprStarred<U> ) -> Result<ExprStarred<Self::TargetU>, Self::Error>

fn fold_expr_name( &mut self, node: ExprName<U> ) -> Result<ExprName<Self::TargetU>, Self::Error>

fn fold_expr_list( &mut self, node: ExprList<U> ) -> Result<ExprList<Self::TargetU>, Self::Error>

fn fold_expr_tuple( &mut self, node: ExprTuple<U> ) -> Result<ExprTuple<Self::TargetU>, Self::Error>

fn fold_expr_slice( &mut self, node: ExprSlice<U> ) -> Result<ExprSlice<Self::TargetU>, Self::Error>

fn fold_expr_context( &mut self, node: ExprContext ) -> Result<ExprContext, Self::Error>

fn fold_boolop(&mut self, node: BoolOp) -> Result<BoolOp, Self::Error>

fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error>

fn fold_unaryop(&mut self, node: UnaryOp) -> Result<UnaryOp, Self::Error>

fn fold_cmpop(&mut self, node: CmpOp) -> Result<CmpOp, Self::Error>

fn fold_comprehension( &mut self, node: Comprehension<U> ) -> Result<Comprehension<Self::TargetU>, Self::Error>

fn fold_excepthandler( &mut self, node: ExceptHandler<U> ) -> Result<ExceptHandler<Self::TargetU>, Self::Error>

fn fold_excepthandler_except_handler( &mut self, node: ExceptHandlerExceptHandler<U> ) -> Result<ExceptHandlerExceptHandler<Self::TargetU>, Self::Error>

fn fold_arguments( &mut self, node: Arguments<U> ) -> Result<Arguments<Self::TargetU>, Self::Error>

fn fold_arg(&mut self, node: Arg<U>) -> Result<Arg<Self::TargetU>, Self::Error>

fn fold_keyword( &mut self, node: Keyword<U> ) -> Result<Keyword<Self::TargetU>, Self::Error>

fn fold_alias( &mut self, node: Alias<U> ) -> Result<Alias<Self::TargetU>, Self::Error>

fn fold_withitem( &mut self, node: WithItem<U> ) -> Result<WithItem<Self::TargetU>, Self::Error>

fn fold_match_case( &mut self, node: MatchCase<U> ) -> Result<MatchCase<Self::TargetU>, Self::Error>

fn fold_pattern( &mut self, node: Pattern<U> ) -> Result<Pattern<Self::TargetU>, Self::Error>

fn fold_pattern_match_value( &mut self, node: PatternMatchValue<U> ) -> Result<PatternMatchValue<Self::TargetU>, Self::Error>

fn fold_pattern_match_singleton( &mut self, node: PatternMatchSingleton<U> ) -> Result<PatternMatchSingleton<Self::TargetU>, Self::Error>

fn fold_pattern_match_sequence( &mut self, node: PatternMatchSequence<U> ) -> Result<PatternMatchSequence<Self::TargetU>, Self::Error>

fn fold_pattern_match_mapping( &mut self, node: PatternMatchMapping<U> ) -> Result<PatternMatchMapping<Self::TargetU>, Self::Error>

fn fold_pattern_match_class( &mut self, node: PatternMatchClass<U> ) -> Result<PatternMatchClass<Self::TargetU>, Self::Error>

fn fold_pattern_match_star( &mut self, node: PatternMatchStar<U> ) -> Result<PatternMatchStar<Self::TargetU>, Self::Error>

fn fold_pattern_match_as( &mut self, node: PatternMatchAs<U> ) -> Result<PatternMatchAs<Self::TargetU>, Self::Error>

fn fold_pattern_match_or( &mut self, node: PatternMatchOr<U> ) -> Result<PatternMatchOr<Self::TargetU>, Self::Error>

fn fold_type_ignore( &mut self, node: TypeIgnore<U> ) -> Result<TypeIgnore<Self::TargetU>, Self::Error>

fn fold_type_ignore_type_ignore( &mut self, node: TypeIgnoreTypeIgnore<U> ) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error>

fn fold_type_param( &mut self, node: TypeParam<U> ) -> Result<TypeParam<Self::TargetU>, Self::Error>

fn fold_type_param_type_var( &mut self, node: TypeParamTypeVar<U> ) -> Result<TypeParamTypeVar<Self::TargetU>, Self::Error>

fn fold_type_param_param_spec( &mut self, node: TypeParamParamSpec<U> ) -> Result<TypeParamParamSpec<Self::TargetU>, Self::Error>

fn fold_type_param_type_var_tuple( &mut self, node: TypeParamTypeVarTuple<U> ) -> Result<TypeParamTypeVarTuple<Self::TargetU>, Self::Error>

fn fold_arg_with_default( &mut self, node: ArgWithDefault<U> ) -> Result<ArgWithDefault<Self::TargetU>, Self::Error>

Object Safety

This trait is not object safe.

Implementors

impl Fold<TextRange> for LinearLocator<'_>

type TargetU = SourceRange

type Error = Infallible

type UserContext = SourceLocation

impl Fold<TextRange> for RandomLocator<'_>

type TargetU = SourceRange

type Error = Infallible

type UserContext = SourceLocation